From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- tools/check-moz-style/modules/scm.py | 420 +++++++++++++++++++++++++++++++++++ 1 file changed, 420 insertions(+) create mode 100644 tools/check-moz-style/modules/scm.py (limited to 'tools/check-moz-style/modules/scm.py') diff --git a/tools/check-moz-style/modules/scm.py b/tools/check-moz-style/modules/scm.py new file mode 100644 index 000000000..e7cb9ffc6 --- /dev/null +++ b/tools/check-moz-style/modules/scm.py @@ -0,0 +1,420 @@ +# 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. +# +# Python module for interacting with an SCM system (like SVN or Git) + +import os +import re +import subprocess +import sys + +# Import WebKit-specific modules. +from modules.logging import error, log + +def detect_scm_system(path): + if HG.in_working_directory(path): + return HG(cwd=path) + + if SVN.in_working_directory(path): + return SVN(cwd=path) + + if Git.in_working_directory(path): + return Git(cwd=path) + + raise ScriptError("working directory is not a HG/SVN/Git repo") + +def first_non_empty_line_after_index(lines, index=0): + first_non_empty_line = index + for line in lines[index:]: + if re.match("^\s*$", line): + first_non_empty_line += 1 + else: + break + return first_non_empty_line + + +class CommitMessage: + def __init__(self, message): + self.message_lines = message[first_non_empty_line_after_index(message, 0):] + + def body(self, lstrip=False): + lines = self.message_lines[first_non_empty_line_after_index(self.message_lines, 1):] + if lstrip: + lines = [line.lstrip() for line in lines] + return "\n".join(lines) + "\n" + + def description(self, lstrip=False, strip_url=False): + line = self.message_lines[0] + if lstrip: + line = line.lstrip() + if strip_url: + line = re.sub("^(\s*)<.+> ", "\1", line) + return line + + def message(self): + return "\n".join(self.message_lines) + "\n" + + def parse_bug_id(self): + for line in self.message_lines: + match = re.search("http\://webkit\.org/b/(?P\d+)", line) + if match: + return match.group('bug_id') + match = re.search(Bugzilla.bug_server_regex + "show_bug\.cgi\?id=(?P\d+)", line) + if match: + return match.group('bug_id') + return None + + +class ScriptError(Exception): + pass + + +class SCM: + def __init__(self, cwd, dryrun=False): + self.cwd = cwd + self.checkout_root = self.find_checkout_root(self.cwd) + self.dryrun = dryrun + + @staticmethod + def run_command(args, cwd=None, input=None, raise_on_failure=True, return_exit_code=False): + stdin = subprocess.PIPE if input else None + process = subprocess.Popen(args, stdout=subprocess.PIPE, stdin=stdin, cwd=cwd) + output = process.communicate(input)[0].rstrip() + exit_code = process.wait() + if raise_on_failure and exit_code: + raise ScriptError('Failed to run "%s" exit_code: %d cwd: %s' % (args, exit_code, cwd)) + if return_exit_code: + return exit_code + return output + + def script_path(self, script_name): + return os.path.join(self.checkout_root, "WebKitTools", "Scripts", script_name) + + def ensure_clean_working_directory(self, force): + if not force and not self.working_directory_is_clean(): + print self.run_command(self.status_command(), raise_on_failure=False) + error("Working directory has modifications, pass --force-clean or --no-clean to continue.") + + log("Cleaning working directory") + self.clean_working_directory() + + def ensure_no_local_commits(self, force): + if not self.supports_local_commits(): + return + commits = self.local_commits() + if not len(commits): + return + if not force: + error("Working directory has local commits, pass --force-clean to continue.") + self.discard_local_commits() + + def apply_patch(self, patch): + # It's possible that the patch was not made from the root directory. + # We should detect and handle that case. + curl_process = subprocess.Popen(['curl', patch['url']], stdout=subprocess.PIPE) + patch_apply_process = subprocess.Popen([self.script_path('svn-apply'), '--reviewer', patch['reviewer']], stdin=curl_process.stdout) + + return_code = patch_apply_process.wait() + if return_code: + raise ScriptError("Patch %s from bug %s failed to download and apply." % (patch['url'], patch['bug_id'])) + + def run_status_and_extract_filenames(self, status_command, status_regexp): + filenames = [] + for line in self.run_command(status_command).splitlines(): + match = re.search(status_regexp, line) + if not match: + continue + # status = match.group('status') + filename = match.group('filename') + filenames.append(filename) + return filenames + + @staticmethod + def in_working_directory(path): + raise NotImplementedError, "subclasses must implement" + + @staticmethod + def find_checkout_root(path): + raise NotImplementedError, "subclasses must implement" + + @staticmethod + def commit_success_regexp(): + raise NotImplementedError, "subclasses must implement" + + def working_directory_is_clean(self): + raise NotImplementedError, "subclasses must implement" + + def clean_working_directory(self): + raise NotImplementedError, "subclasses must implement" + + def update_webkit(self): + raise NotImplementedError, "subclasses must implement" + + def status_command(self): + raise NotImplementedError, "subclasses must implement" + + def changed_files(self): + raise NotImplementedError, "subclasses must implement" + + def display_name(self): + raise NotImplementedError, "subclasses must implement" + + def create_patch(self): + raise NotImplementedError, "subclasses must implement" + + def commit_with_message(self, message): + raise NotImplementedError, "subclasses must implement" + + # Subclasses must indicate if they support local commits, + # but the SCM baseclass will only call local_commits methods when this is true. + @staticmethod + def supports_local_commits(): + raise NotImplementedError, "subclasses must implement" + + def create_patch_from_local_commit(self, commit_id): + pass + + def commit_locally_with_message(self, message): + pass + + def discard_local_commits(self): + pass + + def local_commits(self): + return [] + + +class SVN(SCM): + def __init__(self, cwd, dryrun=False): + SCM.__init__(self, cwd, dryrun) + self.cached_version = None + + @staticmethod + def in_working_directory(path): + return os.path.isdir(os.path.join(path, '.svn')) + + @staticmethod + def find_uuid(path): + if not SVN.in_working_directory(path): + return None + info = SVN.run_command(['svn', 'info', path]) + match = re.search("^Repository UUID: (?P.+)$", info, re.MULTILINE) + if not match: + raise ScriptError('svn info did not contain a UUID.') + return match.group('uuid') + + @staticmethod + def find_checkout_root(path): + uuid = SVN.find_uuid(path) + # If |path| is not in a working directory, we're supposed to return |path|. + if not uuid: + return path + # Search up the directory hierarchy until we find a different UUID. + last_path = None + while True: + if uuid != SVN.find_uuid(path): + return last_path + last_path = path + (path, last_component) = os.path.split(path) + if last_path == path: + return None + + @staticmethod + def commit_success_regexp(): + return "^Committed revision (?P\d+)\.$" + + def svn_version(self): + if not self.cached_version: + self.cached_version = self.run_command(['svn', '--version', '--quiet']) + + return self.cached_version + + def working_directory_is_clean(self): + return self.run_command(['svn', 'diff']) == "" + + def clean_working_directory(self): + self.run_command(['svn', 'revert', '-R', '.']) + + def update_webkit(self): + self.run_command(self.script_path("update-webkit")) + + def status_command(self): + return ['svn', 'status'] + + def changed_files(self): + if self.svn_version() > "1.6": + status_regexp = "^(?P[ACDMR]).{6} (?P.+)$" + else: + status_regexp = "^(?P[ACDMR]).{5} (?P.+)$" + return self.run_status_and_extract_filenames(self.status_command(), status_regexp) + + @staticmethod + def supports_local_commits(): + return False + + def display_name(self): + return "svn" + + def create_patch(self): + return self.run_command(self.script_path("svn-create-patch")) + + def commit_with_message(self, message): + if self.dryrun: + return "Dry run, no remote commit." + return self.run_command(['svn', 'commit', '-m', message]) + + +# All git-specific logic should go here. +class Git(SCM): + def __init__(self, cwd, dryrun=False): + SCM.__init__(self, cwd, dryrun) + + @classmethod + def in_working_directory(cls, path): + return cls.run_command(['git', 'rev-parse', '--is-inside-work-tree'], raise_on_failure=False, cwd=path) == "true" + + @classmethod + def find_checkout_root(cls, path): + # "git rev-parse --show-cdup" would be another way to get to the root + (checkout_root, dot_git) = os.path.split(cls.run_command(['git', 'rev-parse', '--git-dir'], cwd=path)) + # If we were using 2.6 # checkout_root = os.path.relpath(checkout_root, path) + if not os.path.isabs(checkout_root): # Sometimes git returns relative paths + checkout_root = os.path.join(path, checkout_root) + return checkout_root + + @staticmethod + def commit_success_regexp(): + return "^Committed r(?P\d+)$" + + def discard_local_commits(self): + self.run_command(['git', 'reset', '--hard', 'trunk']) + + def local_commits(self): + return self.run_command(['git', 'log', '--pretty=oneline', 'HEAD...trunk']).splitlines() + + def working_directory_is_clean(self): + return self.run_command(['git', 'diff-index', 'HEAD']) == "" + + def clean_working_directory(self): + # Could run git clean here too, but that wouldn't match working_directory_is_clean + self.run_command(['git', 'reset', '--hard', 'HEAD']) + + def update_webkit(self): + # FIXME: Should probably call update-webkit, no? + log("Updating working directory") + self.run_command(['git', 'svn', 'rebase']) + + def status_command(self): + return ['git', 'status'] + + def changed_files(self): + status_command = ['git', 'diff', '-r', '--name-status', '-C', '-M', 'HEAD'] + status_regexp = '^(?P[ADM])\t(?P.+)$' + return self.run_status_and_extract_filenames(status_command, status_regexp) + + @staticmethod + def supports_local_commits(): + return True + + def display_name(self): + return "git" + + def create_patch(self): + return self.run_command(['git', 'diff', 'HEAD']) + + def commit_with_message(self, message): + self.commit_locally_with_message(message) + return self.push_local_commits_to_server() + + # Git-specific methods: + + def create_patch_from_local_commit(self, commit_id): + return self.run_command(['git', 'diff', commit_id + "^.." + commit_id]) + + def commit_locally_with_message(self, message): + self.run_command(['git', 'commit', '--all', '-F', '-'], input=message) + + def push_local_commits_to_server(self): + if self.dryrun: + return "Dry run, no remote commit." + return self.run_command(['git', 'svn', 'dcommit']) + + def commit_ids_from_range_arguments(self, args, cherry_pick=False): + # First get the commit-ids for the passed in revisions. + revisions = self.run_command(['git', 'rev-parse', '--revs-only'] + args).splitlines() + + if cherry_pick: + return revisions + + # If we're not cherry picking and were only passed one revision, assume "^revision head" aka "revision..head". + if len(revisions) < 2: + revisions[0] = "^" + revisions[0] + revisions.append("HEAD") + + return self.run_command(['git', 'rev-list'] + revisions).splitlines() + + def commit_message_for_local_commit(self, commit_id): + commit_lines = self.run_command(['git', 'cat-file', 'commit', commit_id]).splitlines() + + # Skip the git headers. + first_line_after_headers = 0 + for line in commit_lines: + first_line_after_headers += 1 + if line == "": + break + return CommitMessage(commit_lines[first_line_after_headers:]) + + def files_changed_summary_for_commit(self, commit_id): + return self.run_command(['git', 'diff-tree', '--shortstat', '--no-commit-id', commit_id]) + + +# All hg-specific logic should go here. +class HG(SCM): + def __init__(self, cwd, dryrun=False): + SCM.__init__(self, cwd, dryrun) + + @classmethod + def in_working_directory(cls, path): + return cls.run_command(['hg', 'status'], cwd=path, return_exit_code=True) == 0 + + @classmethod + def find_checkout_root(cls, path): + checkout_root = cls.run_command(['hg', 'root'], cwd=path) + return checkout_root + + def status_command(self): + return ['hg', 'status'] + + def display_name(self): + return "hg" + + def create_patch(self): + if self.run_command(['hg', 'diff']) != "": + sys.stderr.write("Warning: outstanding changes not include in style check.\n") + return self.run_command(['hg', 'export', 'tip']) -- cgit v1.2.3