diff options
Diffstat (limited to 'WebKitTools/Scripts/bugzilla-tool')
| -rwxr-xr-x | WebKitTools/Scripts/bugzilla-tool | 695 |
1 files changed, 695 insertions, 0 deletions
diff --git a/WebKitTools/Scripts/bugzilla-tool b/WebKitTools/Scripts/bugzilla-tool new file mode 100755 index 0000000..b3c0d67 --- /dev/null +++ b/WebKitTools/Scripts/bugzilla-tool @@ -0,0 +1,695 @@ +#!/usr/bin/python +# Copyright (c) 2009, Google Inc. All rights reserved. +# Copyright (c) 2009 Apple Inc. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following disclaimer +# in the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +# A tool for automating dealing with bugzilla, posting patches, committing patches, etc. + +import fileinput # inplace file editing for set_reviewer_in_changelog +import os +import re +import StringIO # for add_patch_to_bug file wrappers +import subprocess +import sys + +from optparse import OptionParser, IndentedHelpFormatter, SUPPRESS_USAGE, make_option + +# Import WebKit-specific modules. +from modules.bugzilla import Bugzilla +from modules.logging import error, log +from modules.scm import CommitMessage, detect_scm_system, ScriptError + +def plural(noun): + # This is a dumb plural() implementation which was just enough for our uses. + if re.search('h$', noun): + return noun + 'es' + else: + return noun + 's' + +def pluralize(noun, count): + if count != 1: + noun = plural(noun) + return "%d %s" % (count, noun) + +# These could be put in some sort of changelogs.py. +def latest_changelog_entry(changelog_path): + # e.g. 2009-06-03 Eric Seidel <eric@webkit.org> + changelog_date_line_regexp = re.compile('^(\d{4}-\d{2}-\d{2})' # Consume the date. + + '\s+(.+)\s+' # Consume the name. + + '<([^<>]+)>$') # And finally the email address. + + entry_lines = [] + changelog = open(changelog_path) + try: + log("Parsing ChangeLog: " + changelog_path) + # The first line should be a date line. + first_line = changelog.readline() + if not changelog_date_line_regexp.match(first_line): + return None + entry_lines.append(first_line) + + for line in changelog: + # If we've hit the next entry, return. + if changelog_date_line_regexp.match(line): + return ''.join(entry_lines) + entry_lines.append(line) + finally: + changelog.close() + # We never found a date line! + return None + +def set_reviewer_in_changelog(changelog_path, reviewer): + # inplace=1 creates a backup file and re-directs stdout to the file + for line in fileinput.FileInput(changelog_path, inplace=1): + print line.replace("NOBODY (OOPS!)", reviewer.encode("utf-8")), # Trailing comma suppresses printing newline + +def modified_changelogs(scm): + changelog_paths = [] + paths = scm.changed_files() + for path in paths: + if os.path.basename(path) == "ChangeLog": + changelog_paths.append(path) + return changelog_paths + +def parse_bug_id(commit_message): + message = commit_message.message() + match = re.search("http\://webkit\.org/b/(?P<bug_id>\d+)", message) + if match: + return match.group('bug_id') + match = re.search(Bugzilla.bug_server_regex + "show_bug\.cgi\?id=(?P<bug_id>\d+)", message) + if match: + return match.group('bug_id') + return None + +def commit_message_for_this_commit(scm): + changelog_paths = modified_changelogs(scm) + if not len(changelog_paths): + raise ScriptError("Found no modified ChangeLogs, cannot create a commit message.\n" + "All changes require a ChangeLog. See:\n" + "http://webkit.org/coding/contributing.html") + + changelog_messages = [] + for path in changelog_paths: + changelog_entry = latest_changelog_entry(path) + if not changelog_entry: + error("Failed to parse ChangeLog: " + os.path.abspath(path)) + changelog_messages.append(changelog_entry) + + # FIXME: We should sort and label the ChangeLog messages like commit-log-editor does. + return CommitMessage(''.join(changelog_messages).splitlines()) + + +class Command: + def __init__(self, help_text, argument_names="", options=[], requires_local_commits=False): + self.help_text = help_text + self.argument_names = argument_names + self.options = options + self.option_parser = HelpPrintingOptionParser(usage=SUPPRESS_USAGE, add_help_option=False, option_list=self.options) + self.requires_local_commits = requires_local_commits + + def name_with_arguments(self, command_name): + usage_string = command_name + if len(self.options) > 0: + usage_string += " [options]" + if self.argument_names: + usage_string += " " + self.argument_names + return usage_string + + def parse_args(self, args): + return self.option_parser.parse_args(args) + + def execute(self, options, args, tool): + raise NotImplementedError, "subclasses must implement" + + +class BugsInCommitQueue(Command): + def __init__(self): + Command.__init__(self, 'Bugs in the commit queue') + + def execute(self, options, args, tool): + bug_ids = tool.bugs.fetch_bug_ids_from_commit_queue() + for bug_id in bug_ids: + print "%s" % bug_id + + +class PatchesInCommitQueue(Command): + def __init__(self): + Command.__init__(self, 'Patches in the commit queue') + + def execute(self, options, args, tool): + patches = tool.bugs.fetch_patches_from_commit_queue() + log("Patches in commit queue:") + for patch in patches: + print "%s" % patch['url'] + + +class ReviewedPatchesOnBug(Command): + def __init__(self): + Command.__init__(self, 'r+\'d patches on a bug', 'BUGID') + + def execute(self, options, args, tool): + bug_id = args[0] + patches_to_land = tool.bugs.fetch_reviewed_patches_from_bug(bug_id) + for patch in patches_to_land: + print "%s" % patch['url'] + + +class ApplyPatchesFromBug(Command): + def __init__(self): + options = [ + make_option("--no-update", action="store_false", dest="update", default=True, help="Don't update the working directory before applying patches"), + make_option("--force-clean", action="store_true", dest="force_clean", default=False, help="Clean working directory before applying patches (removes local changes and commits)"), + make_option("--no-clean", action="store_false", dest="clean", default=True, help="Don't check if the working directory is clean before applying patches"), + make_option("--local-commit", action="store_true", dest="local_commit", default=False, help="Make a local commit for each applied patch"), + ] + Command.__init__(self, 'Applies all patches on a bug to the local working directory without committing.', 'BUGID', options=options) + + @staticmethod + def apply_patches(patches, scm, commit_each): + for patch in patches: + scm.apply_patch(patch) + if commit_each: + commit_message = commit_message_for_this_commit(scm) + scm.commit_locally_with_message(commit_message.message() or patch['name']) + + def execute(self, options, args, tool): + bug_id = args[0] + patches = tool.bugs.fetch_reviewed_patches_from_bug(bug_id) + os.chdir(tool.scm().checkout_root) + if options.clean: + tool.scm().ensure_clean_working_directory(options.force_clean) + if options.update: + tool.scm().update_webkit() + + if options.local_commit and not tool.scm().supports_local_commits(): + error("--local-commit passed, but %s does not support local commits" % tool.scm().display_name()) + + self.apply_patches(patches, tool.scm(), options.local_commit) + + +def bug_comment_from_commit_text(scm, commit_text): + match = re.search(scm.commit_success_regexp(), commit_text, re.MULTILINE) + svn_revision = match.group('svn_revision') + commit_text += ("\nhttp://trac.webkit.org/changeset/%s" % svn_revision) + return commit_text + + +class LandAndUpdateBug(Command): + def __init__(self): + options = [ + make_option("-r", "--reviewer", action="store", type="string", dest="reviewer", help="Update ChangeLogs to say Reviewed by REVIEWER."), + make_option("--no-close", action="store_false", dest="close_bug", default=True, help="Leave bug open after landing."), + make_option("--no-build", action="store_false", dest="build", default=True, help="Commit without building first, implies --no-test."), + make_option("--no-test", action="store_false", dest="test", default=True, help="Commit without running run-webkit-tests."), + make_option("--quiet", action="store_true", dest="quiet", default=False, help="Produce less console output."), + make_option("--commit-queue", action="store_true", dest="commit_queue", default=False, help="Run in commit queue mode (no user interaction)."), + ] + Command.__init__(self, 'Lands the current working directory diff and updates the bug if provided.', '[BUGID]', options=options) + + def guess_reviewer_from_bug(self, bugs, bug_id): + patches = bugs.fetch_reviewed_patches_from_bug(bug_id) + if len(patches) != 1: + log("%s on bug %s, cannot infer reviewer." % (pluralize("reviewed patch", len(patches)), bug_id)) + return None + patch = patches[0] + reviewer = patch['reviewer'] + log('Guessing "%s" as reviewer from attachment %s on bug %s.' % (reviewer, patch['id'], bug_id)) + return reviewer + + def update_changelogs_with_reviewer(self, reviewer, bug_id, tool): + if not reviewer: + if not bug_id: + log("No bug id provided and --reviewer= not provided. Not updating ChangeLogs with reviewer.") + return + reviewer = self.guess_reviewer_from_bug(tool.bugs, bug_id) + + if not reviewer: + log("Failed to guess reviewer from bug %s and --reviewer= not provided. Not updating ChangeLogs with reviewer." % bug_id) + return + + changelogs = modified_changelogs(tool.scm()) + for changelog in changelogs: + set_reviewer_in_changelog(changelog, reviewer) + + def execute(self, options, args, tool): + bug_id = args[0] if len(args) else None + os.chdir(tool.scm().checkout_root) + + self.update_changelogs_with_reviewer(options.reviewer, bug_id, tool) + + comment_text = LandPatchesFromBugs.build_and_commit(tool.scm(), options) + if bug_id: + log("Updating bug %s" % bug_id) + if options.close_bug: + tool.bugs.close_bug_as_fixed(bug_id, comment_text) + else: + # FIXME: We should a smart way to figure out if the patch is attached + # to the bug, and if so obsolete it. + tool.bugs.post_comment_to_bug(bug_id, comment_text) + else: + log(comment_text) + log("No bug id provided.") + + +class LandPatchesFromBugs(Command): + def __init__(self): + options = [ + make_option("--force-clean", action="store_true", dest="force_clean", default=False, help="Clean working directory before applying patches (removes local changes and commits)"), + make_option("--no-clean", action="store_false", dest="clean", default=True, help="Don't check if the working directory is clean before applying patches"), + make_option("--no-close", action="store_false", dest="close_bug", default=True, help="Leave bug open after landing."), + make_option("--no-build", action="store_false", dest="build", default=True, help="Commit without building first, implies --no-test."), + make_option("--no-test", action="store_false", dest="test", default=True, help="Commit without running run-webkit-tests."), + make_option("--quiet", action="store_true", dest="quiet", default=False, help="Produce less console output."), + make_option("--commit-queue", action="store_true", dest="commit_queue", default=False, help="Run in commit queue mode (no user interaction)."), + ] + Command.__init__(self, 'Lands all patches on a bug optionally testing them first', 'BUGID', options=options) + + @staticmethod + def run_and_throw_if_fail(args, quiet=False): + child_stdout = subprocess.PIPE if quiet else None + child_process = subprocess.Popen(args, stdout=child_stdout) + if child_process.stdout: + child_process.communicate() + return_code = child_process.wait() + if return_code: + raise ScriptError("%s failed with exit code %d" % (" ".join(args), return_code)) + + # We might need to pass scm into this function for scm.checkout_root + @staticmethod + def webkit_script_path(script_name): + return os.path.join("WebKitTools", "Scripts", script_name) + + @classmethod + def run_webkit_script(cls, script_name, quiet=False): + print "Running WebKit Script " + script_name + cls.run_and_throw_if_fail(cls.webkit_script_path(script_name), quiet) + + @classmethod + def build_webkit(cls, quiet=False): + cls.run_webkit_script("build-webkit", quiet) + + @classmethod + def run_webkit_tests(cls, launch_safari, quiet=False): + args = [cls.webkit_script_path("run-webkit-tests")] + if not launch_safari: + args.append("--no-launch-safari") + if quiet: + args.append("--quiet") + cls.run_and_throw_if_fail(args) + + @staticmethod + def setup_for_landing(scm, options): + os.chdir(scm.checkout_root) + scm.ensure_no_local_commits(options.force_clean) + if options.clean: + scm.ensure_clean_working_directory(options.force_clean) + + @classmethod + def build_and_commit(cls, scm, options): + if options.build: + cls.build_webkit(quiet=options.quiet) + if options.test: + cls.run_webkit_tests(launch_safari=not options.commit_queue, quiet=options.quiet) + commit_message = commit_message_for_this_commit(scm) + commit_log = scm.commit_with_message(commit_message.message()) + return bug_comment_from_commit_text(scm, commit_log) + + @classmethod + def land_patches(cls, bug_id, patches, options, tool): + try: + comment_text = "" + for patch in patches: + tool.scm().update_webkit() # Update before every patch in case the tree has changed + tool.scm().apply_patch(patch, force=options.commit_queue) + comment_text = cls.build_and_commit(tool.scm(), options) + tool.bugs.clear_attachment_review_flag(patch['id'], comment_text) + + if options.close_bug: + tool.bugs.close_bug_as_fixed(bug_id, "All reviewed patches have been landed. Closing bug.") + except ScriptError, e: + # We should add a comment to the bug, and r- the patch on failure + error(e) + + def execute(self, options, args, tool): + if not len(args): + error("bug-id(s) required") + + bugs_to_patches = {} + patch_count = 0 + for bug_id in args: + patches = [] + if options.commit_queue: + patches = tool.bugs.fetch_commit_queue_patches_from_bug(bug_id) + else: + patches = tool.bugs.fetch_reviewed_patches_from_bug(bug_id) + if not len(patches): + log("No reviewed patches found on %s." % bug_id) + continue + patch_count += len(patches) + bugs_to_patches[bug_id] = patches + + log("Landing %s from %s." % (pluralize("patch", patch_count), pluralize("bug", len(args)))) + + self.setup_for_landing(tool.scm(), options) + + for bug_id in bugs_to_patches.keys(): + self.land_patches(bug_id, bugs_to_patches[bug_id], options, tool) + + +class CommitMessageForCurrentDiff(Command): + def __init__(self): + Command.__init__(self, 'Prints a commit message suitable for the uncommitted changes.') + + def execute(self, options, args, tool): + os.chdir(tool.scm().checkout_root) + print "%s" % commit_message_for_this_commit(tool.scm()).message() + + +class ObsoleteAttachmentsOnBug(Command): + def __init__(self): + Command.__init__(self, 'Marks all attachments on a bug as obsolete.', 'BUGID') + + def execute(self, options, args, tool): + bug_id = args[0] + attachments = tool.bugs.fetch_attachments_from_bug(bug_id) + for attachment in attachments: + if not attachment['is_obsolete']: + tool.bugs.obsolete_attachment(attachment['id']) + + +class PostDiffAsPatchToBug(Command): + def __init__(self): + options = [ + make_option("--no-obsolete", action="store_false", dest="obsolete_patches", default=True, help="Do not obsolete old patches before posting this one."), + make_option("--no-review", action="store_false", dest="review", default=True, help="Do not mark the patch for review."), + make_option("-m", "--description", action="store", type="string", dest="description", help="Description string for the attachment (default: 'patch')"), + ] + Command.__init__(self, 'Attaches the current working directory diff to a bug as a patch file.', 'BUGID', options=options) + + @staticmethod + def obsolete_patches_on_bug(bug_id, bugs): + patches = bugs.fetch_patches_from_bug(bug_id) + if len(patches): + log("Obsoleting %s on bug %s" % (pluralize('old patch', len(patches)), bug_id)) + for patch in patches: + bugs.obsolete_attachment(patch['id']) + + def execute(self, options, args, tool): + bug_id = args[0] + + if options.obsolete_patches: + self.obsolete_patches_on_bug(bug_id, tool.bugs) + + diff = tool.scm().create_patch() + diff_file = StringIO.StringIO(diff) # add_patch_to_bug expects a file-like object + + description = options.description or "Patch v1" + tool.bugs.add_patch_to_bug(bug_id, diff_file, description, mark_for_review=options.review) + + +class PostCommitsAsPatchesToBug(Command): + def __init__(self): + options = [ + make_option("-b", "--bug-id", action="store", type="string", dest="bug_id", help="Specify bug id if no URL is provided in the commit log."), + make_option("--no-comment", action="store_false", dest="comment", default=True, help="Do not use commit log message as a comment for the patch."), + make_option("--no-obsolete", action="store_false", dest="obsolete_patches", default=True, help="Do not obsolete old patches before posting new ones."), + make_option("--no-review", action="store_false", dest="review", default=True, help="Do not mark the patch for review."), + make_option("-m", "--description", action="store", type="string", dest="description", help="Description string for the attachment (default: 'patch')"), + ] + Command.__init__(self, 'Attaches a range of local commits to bugs as patch files.', 'COMMITISH', options=options, requires_local_commits=True) + + def execute(self, options, args, tool): + if not args: + error("%s argument is required" % self.argument_names) + + commit_ids = tool.scm().commit_ids_from_commitish_arguments(args) + if len(commit_ids) > 10: + error("Are you sure you want to attach %s patches?" % (pluralize('patch', len(commit_ids)))) + # Could add a --patches-limit option. + + have_obsoleted_patches = set() + for commit_id in commit_ids: + # FIXME: commit_message is the wrong place to look for the bug_id + # the ChangeLogs should have the bug id, but the local commit message might not. + commit_message = tool.scm().commit_message_for_local_commit(commit_id) + + bug_id = options.bug_id or parse_bug_id(commit_message) + if not bug_id: + log("Skipping %s: No bug id found in commit log or specified with --bug-id." % commit_id) + continue + + if options.obsolete_patches and bug_id not in have_obsoleted_patches: + PostDiffAsPatchToBug.obsolete_patches_on_bug(bug_id, tool.bugs) + have_obsoleted_patches.add(bug_id) + + description = options.description or commit_message.description(lstrip=True, strip_url=True) + comment_text = None + if (options.comment): + comment_text = commit_message.body(lstrip=True) + comment_text += "---\n" + comment_text += tool.scm().files_changed_summary_for_commit(commit_id) + + diff = tool.scm().create_patch_from_local_commit(commit_id) + diff_file = StringIO.StringIO(diff) # add_patch_to_bug expects a file-like object + tool.bugs.add_patch_to_bug(bug_id, diff_file, description, comment_text, mark_for_review=options.review) + + +class CreateBug(Command): + def __init__(self): + options = [ + make_option("--cc", action="store", type="string", dest="cc", help="Comma-separated list of email addresses to carbon-copy."), + make_option("--component", action="store", type="string", dest="component", help="Component for the new bug."), + make_option("--no-prompt", action="store_false", dest="prompt", default=True, help="Do not prompt for bug title and comment; use commit log instead."), + make_option("--no-review", action="store_false", dest="review", default=True, help="Do not mark the patch for review."), + ] + Command.__init__(self, 'Create a bug from local changes or local commits.', '[COMMITISH]', options=options) + + def create_bug_from_commit(self, options, args, tool): + commit_ids = tool.scm().commit_ids_from_commitish_arguments(args) + if len(commit_ids) > 3: + error("Are you sure you want to create one bug with %s patches?" % len(commit_ids)) + + commit_id = commit_ids[0] + + bug_title = "" + comment_text = "" + if options.prompt: + (bug_title, comment_text) = self.prompt_for_bug_title_and_comment() + else: + commit_message = tool.scm().commit_message_for_local_commit(commit_id) + bug_title = commit_message.description(lstrip=True, strip_url=True) + comment_text = commit_message.body(lstrip=True) + comment_text += "---\n" + comment_text += tool.scm().files_changed_summary_for_commit(commit_id) + + diff = tool.scm().create_patch_from_local_commit(commit_id) + diff_file = StringIO.StringIO(diff) # create_bug_with_patch expects a file-like object + bug_id = tool.bugs.create_bug_with_patch(bug_title, comment_text, options.component, diff_file, "Patch v1", cc=options.cc, mark_for_review=options.review) + + if bug_id and len(commit_ids) > 1: + options.bug_id = bug_id + options.obsolete_patches = False + # FIXME: We should pass through --no-comment switch as well. + PostCommitsAsPatchesToBug.execute(self, options, commit_ids[1:], tool) + + def create_bug_from_patch(self, options, args, tool): + bug_title = "" + comment_text = "" + if options.prompt: + (bug_title, comment_text) = self.prompt_for_bug_title_and_comment() + else: + commit_message = commit_message_for_this_commit(tool.scm()) + bug_title = commit_message.description(lstrip=True, strip_url=True) + comment_text = commit_message.body(lstrip=True) + + diff = tool.scm().create_patch() + diff_file = StringIO.StringIO(diff) # create_bug_with_patch expects a file-like object + bug_id = tool.bugs.create_bug_with_patch(bug_title, comment_text, options.component, diff_file, "Patch v1", cc=options.cc, mark_for_review=options.review) + + def prompt_for_bug_title_and_comment(self): + bug_title = raw_input("Bug title: ") + print("Bug comment (hit ^D on blank line to end):") + lines = sys.stdin.readlines() + sys.stdin.seek(0, os.SEEK_END) + comment_text = ''.join(lines) + return (bug_title, comment_text) + + def execute(self, options, args, tool): + if len(args): + if (not tool.scm().supports_local_commits()): + error("Extra arguments not supported; patch is taken from working directory.") + self.create_bug_from_commit(options, args, tool) + else: + self.create_bug_from_patch(options, args, tool) + + +class NonWrappingEpilogIndentedHelpFormatter(IndentedHelpFormatter): + def __init__(self): + IndentedHelpFormatter.__init__(self) + + # The standard IndentedHelpFormatter paragraph-wraps the epilog, killing our custom formatting. + def format_epilog(self, epilog): + if epilog: + return "\n" + epilog + "\n" + return "" + + +class HelpPrintingOptionParser(OptionParser): + def error(self, msg): + self.print_usage(sys.stderr) + error_message = "%s: error: %s\n" % (self.get_prog_name(), msg) + error_message += "\nType '" + self.get_prog_name() + " --help' to see usage.\n" + self.exit(2, error_message) + + +class BugzillaTool: + def __init__(self): + self.cached_scm = None + self.bugs = Bugzilla() + self.commands = [ + { 'name' : 'bugs-to-commit', 'object' : BugsInCommitQueue() }, + { 'name' : 'patches-to-commit', 'object' : PatchesInCommitQueue() }, + { 'name' : 'reviewed-patches', 'object' : ReviewedPatchesOnBug() }, + { 'name' : 'create-bug', 'object' : CreateBug() }, + { 'name' : 'apply-patches', 'object' : ApplyPatchesFromBug() }, + { 'name' : 'land-diff', 'object' : LandAndUpdateBug() }, + { 'name' : 'land-patches', 'object' : LandPatchesFromBugs() }, + { 'name' : 'commit-message', 'object' : CommitMessageForCurrentDiff() }, + { 'name' : 'obsolete-attachments', 'object' : ObsoleteAttachmentsOnBug() }, + { 'name' : 'post-diff', 'object' : PostDiffAsPatchToBug() }, + { 'name' : 'post-commits', 'object' : PostCommitsAsPatchesToBug() }, + ] + + self.global_option_parser = HelpPrintingOptionParser(usage=self.usage_line(), formatter=NonWrappingEpilogIndentedHelpFormatter(), epilog=self.commands_usage()) + self.global_option_parser.add_option("--dry-run", action="store_true", dest="dryrun", help="do not touch remote servers", default=False) + + def scm(self): + # Lazily initialize SCM to not error-out before command line parsing (or when running non-scm commands). + original_cwd = os.path.abspath('.') + if not self.cached_scm: + self.cached_scm = detect_scm_system(original_cwd) + + if not self.cached_scm: + script_directory = os.path.abspath(sys.path[0]) + webkit_directory = os.path.abspath(os.path.join(script_directory, "../..")) + self.cached_scm = detect_scm_system(webkit_directory) + if self.cached_scm: + log("The current directory (%s) is not a WebKit checkout, using %s" % (original_cwd, webkit_directory)) + else: + error("FATAL: Failed to determine the SCM system for either %s or %s" % (original_cwd, webkit_directory)) + + return self.cached_scm + + @staticmethod + def usage_line(): + return "Usage: %prog [options] command [command-options] [command-arguments]" + + def commands_usage(self): + commands_text = "Commands:\n" + longest_name_length = 0 + command_rows = [] + scm_supports_local_commits = self.scm().supports_local_commits() + for command in self.commands: + command_object = command['object'] + if command_object.requires_local_commits and not scm_supports_local_commits: + continue + command_name_and_args = command_object.name_with_arguments(command['name']) + command_rows.append({ 'name-and-args': command_name_and_args, 'object': command_object }) + longest_name_length = max([longest_name_length, len(command_name_and_args)]) + + # Use our own help formatter so as to indent enough. + formatter = IndentedHelpFormatter() + formatter.indent() + formatter.indent() + + for row in command_rows: + command_object = row['object'] + commands_text += " " + row['name-and-args'].ljust(longest_name_length + 3) + command_object.help_text + "\n" + commands_text += command_object.option_parser.format_option_help(formatter) + return commands_text + + def handle_global_args(self, args): + (options, args) = self.global_option_parser.parse_args(args) + if len(args): + # We'll never hit this because split_args splits at the first arg without a leading '-' + self.global_option_parser.error("Extra arguments before command: " + args) + + if options.dryrun: + self.scm().dryrun = True + self.bugs.dryrun = True + + @staticmethod + def split_args(args): + # Assume the first argument which doesn't start with '-' is the command name. + command_index = 0 + for arg in args: + if arg[0] != '-': + break + command_index += 1 + else: + return (args[:], None, []) + + global_args = args[:command_index] + command = args[command_index] + command_args = args[command_index + 1:] + return (global_args, command, command_args) + + def command_by_name(self, command_name): + for command in self.commands: + if command_name == command['name']: + return command + return None + + def main(self): + (global_args, command_name, args_after_command_name) = self.split_args(sys.argv[1:]) + + # Handle --help, etc: + self.handle_global_args(global_args) + + if not command_name: + self.global_option_parser.error("No command specified") + + command = self.command_by_name(command_name) + if not command: + self.global_option_parser.error(command_name + " is not a recognized command") + + command_object = command['object'] + + if command_object.requires_local_commits and not self.scm().supports_local_commits(): + error(command_name + " requires local commits using %s in %s." % (self.scm().display_name(), self.scm().checkout_root)) + + (command_options, command_args) = command_object.parse_args(args_after_command_name) + return command_object.execute(command_options, command_args, self) + + +def main(): + tool = BugzillaTool() + return tool.main() + +if __name__ == "__main__": + main() |