Changeset 139712 in webkit


Ignore:
Timestamp:
Jan 14, 2013 9:16:20 PM (11 years ago)
Author:
commit-queue@webkit.org
Message:

Changing clean_working_directory/clean_local_commits and related
functions to have consistent naming.

​https://bugs.webkit.org/show_bug.cgi?id=104198

Patch by Tim 'mithro' Ansell <​mithro@mithis.com> on 2013-01-14
Reviewed by Adam Barth.

  • Scripts/webkitpy/common/checkout/scm/git.py:
  • Scripts/webkitpy/common/checkout/scm/scm.py:
  • Scripts/webkitpy/common/checkout/scm/scm_mock.py:
  • Scripts/webkitpy/common/checkout/scm/scm_unittest.py:
  • Scripts/webkitpy/tool/steps/cleanworkingdirectory.py:
  • Scripts/webkitpy/tool/steps/cleanworkingdirectory_unittest.py:
Location:
trunk/Tools
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/Tools/ChangeLog

    r139704 r139712  
     12013-01-14  Tim 'mithro' Ansell  <mithro@mithis.com>
     2
     3        Changing clean_working_directory/clean_local_commits and related
     4        functions to have consistent naming.
     5
     6        https://bugs.webkit.org/show_bug.cgi?id=104198
     7
     8        Reviewed by Adam Barth.
     9
     10        * Scripts/webkitpy/common/checkout/scm/git.py:
     11        * Scripts/webkitpy/common/checkout/scm/scm.py:
     12        * Scripts/webkitpy/common/checkout/scm/scm_mock.py:
     13        * Scripts/webkitpy/common/checkout/scm/scm_unittest.py:
     14        * Scripts/webkitpy/tool/steps/cleanworkingdirectory.py:
     15        * Scripts/webkitpy/tool/steps/cleanworkingdirectory_unittest.py:
     16
    1172013-01-14  Alan Cutter  <alancutter@chromium.org>
    218

  • trunk/Tools/Scripts/webkitpy/common/checkout/scm/git.py

    r139700 r139712  
    4949
    5050class AmbiguousCommitError(Exception):
    51     def __init__(self, num_local_commits, working_directory_is_clean):
     51    def __init__(self, num_local_commits, has_working_directory_changes):
    5252        Exception.__init__(self, "Found %s local commits and the working directory is %s" % (
    53             num_local_commits, ["not clean", "clean"][working_directory_is_clean]))
     53            num_local_commits, ["clean", "not clean"][has_working_directory_changes]))
    5454        self.num_local_commits = num_local_commits
    55         self.working_directory_is_clean = working_directory_is_clean
     55        self.has_working_directory_changes = has_working_directory_changes
    5656
    5757
    … …  
    149149        return self._filesystem.exists(self.absolute_path(self._filesystem.join('.git', 'rebase-apply')))
    150150
    151     def working_directory_is_clean(self):
    152         return self._run_git(['diff', self.remote_merge_base(), '--no-renames', '--name-only']) == ""
    153 
    154     def clean_working_directory(self):
    155         # Could run git clean here too, but that wouldn't match working_directory_is_clean
    156         self._run_git(['reset', '--hard', self.remote_merge_base()])
    157         # Aborting rebase even though this does not match working_directory_is_clean
     151    def has_working_directory_changes(self):
     152        return self._run_git(['diff', 'HEAD', '--no-renames', '--name-only']) != ""
     153
     154    def discard_working_directory_changes(self):
     155        # Could run git clean here too, but that wouldn't match subversion
     156        self._run_git(['reset', 'HEAD', '--hard'])
     157        # Aborting rebase even though this does not match subversion
    158158        if self.rebase_in_progress():
    159159            self._run_git(['rebase', '--abort'])
    … …  
    337337        self._run_git(['checkout', 'HEAD'] + file_paths)
    338338
    339     def _assert_can_squash(self, working_directory_is_clean):
     339    def _assert_can_squash(self, has_working_directory_changes):
    340340        squash = Git.read_git_config('webkit-patch.commit-should-always-squash', cwd=self.checkout_root)
    341341        should_squash = squash and squash.lower() == "true"
    … …  
    344344            # Only warn if there are actually multiple commits to squash.
    345345            num_local_commits = len(self.local_commits())
    346             if num_local_commits > 1 or (num_local_commits > 0 and not working_directory_is_clean):
    347                 raise AmbiguousCommitError(num_local_commits, working_directory_is_clean)
     346            if num_local_commits > 1 or (num_local_commits > 0 and has_working_directory_changes):
     347                raise AmbiguousCommitError(num_local_commits, has_working_directory_changes)
    348348
    349349    def commit_with_message(self, message, username=None, password=None, git_commit=None, force_squash=False, changed_files=None):
    350350        # Username is ignored during Git commits.
    351         working_directory_is_clean = self.working_directory_is_clean()
     351        has_working_directory_changes = self.has_working_directory_changes()
    352352
    353353        if git_commit:
    354354            # Special-case HEAD.. to mean working-copy changes only.
    355355            if git_commit.upper() == 'HEAD..':
    356                 if working_directory_is_clean:
     356                if not has_working_directory_changes:
    357357                    raise ScriptError(message="The working copy is not modified. --git-commit=HEAD.. only commits working copy changes.")
    358358                self.commit_locally_with_message(message)
    … …  
    360360
    361361            # Need working directory changes to be committed so we can checkout the merge branch.
    362             if not working_directory_is_clean:
     362            if has_working_directory_changes:
    363363                # FIXME: webkit-patch land will modify the ChangeLogs to correct the reviewer.
    364364                # That will modify the working-copy and cause us to hit this error.
    … …  
    368368
    369369        if not force_squash:
    370             self._assert_can_squash(working_directory_is_clean)
     370            self._assert_can_squash(has_working_directory_changes)
    371371        self._run_git(['reset', '--soft', self.remote_merge_base()])
    372372        self.commit_locally_with_message(message)
    … …  
    409409        finally:
    410410            # And then swap back to the original branch and clean up.
    411             self.clean_working_directory()
     411            self.discard_working_directory_changes()
    412412            self._run_git(['checkout', '-q', branch_name])
    413413            self.delete_branch(MERGE_BRANCH_NAME)

  • trunk/Tools/Scripts/webkitpy/common/checkout/scm/scm.py

    r135912 r139712  
    9191        return self._filesystem.join(self.scripts_directory(), script_name)
    9292
    93     def ensure_clean_working_directory(self, force_clean):
    94         if self.working_directory_is_clean():
    95             return
    96         if not force_clean:
    97             print self.run(self.status_command(), error_handler=Executive.ignore_error, cwd=self.checkout_root)
    98             raise ScriptError(message="Working directory has modifications, pass --force-clean or --no-clean to continue.")
    99         _log.info("Cleaning working directory")
    100         self.clean_working_directory()
    101 
    102     def ensure_no_local_commits(self, force):
    103         if not self.supports_local_commits():
    104             return
    105         commits = self.local_commits()
    106         if not len(commits):
    107             return
    108         if not force:
    109             _log.error("Working directory has local commits, pass --force-clean to continue.")
    110             sys.exit(1)
    111         self.discard_local_commits()
    112 
    11393    def run_status_and_extract_filenames(self, status_command, status_regexp):
    11494        filenames = []
    … …  
    148128        SCM._subclass_must_implement()
    149129
    150     def working_directory_is_clean(self):
    151         self._subclass_must_implement()
    152 
    153     def clean_working_directory(self):
    154         self._subclass_must_implement()
    155 
    156130    def status_command(self):
    157131        self._subclass_must_implement()
    … …  
    232206        self._subclass_must_implement()
    233207
     208    def has_working_directory_changes(self):
     209        self._subclass_must_implement()
     210
     211    def discard_working_directory_changes(self):
     212        self._subclass_must_implement()
     213
     214    #--------------------------------------------------------------------------
    234215    # Subclasses must indicate if they support local commits,
    235216    # but the SCM baseclass will only call local_commits methods when this is true.
    … …  
    238219        SCM._subclass_must_implement()
    239220
     221    def local_commits(self):
     222        return []
     223
     224    def has_local_commits(self):
     225        return len(self.local_commits()) > 0
     226
     227    def discard_local_commits(self):
     228        return
     229
    240230    def remote_merge_base(self):
    241231        SCM._subclass_must_implement()
    … …  
    245235        sys.exit(1)
    246236
    247     def discard_local_commits(self):
    248         pass
    249 
    250     def local_commits(self):
    251         return []
     237    def local_changes_exist(self):
     238        return (self.supports_local_commits() and self.has_local_commits()) or self.has_working_directory_changes()
     239
     240    def discard_local_changes(self):
     241        if self.has_working_directory_changes():
     242            self.discard_working_directory_changes()
     243
     244        if self.has_local_commits():
     245            self.discard_local_commits()

  • trunk/Tools/Scripts/webkitpy/common/checkout/scm/scm_mock.py

    r134371 r139712  
    4747            return 0
    4848
    49     def ensure_clean_working_directory(self, force_clean):
     49    def has_working_directory_changes(self):
     50        return False
     51
     52    def discard_working_directory_changes(self):
    5053        pass
    5154
    … …  
    5356        return True
    5457
    55     def ensure_no_local_commits(self, force_clean):
     58    def has_local_commits(self):
     59        return False
     60
     61    def discard_local_commits(self):
     62        pass
     63
     64    def discard_local_changes(self):
    5665        pass
    5766

  • trunk/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py

    r139399 r139712  
    330330        self.assertItemsEqual(added_files, ["added_dir/added_file2", "added_file", "added_file3", "added_file4"])
    331331
    332         # Test also to make sure clean_working_directory removes added files
    333         self.scm.clean_working_directory()
     332        # Test also to make sure discard_working_directory_changes removes added files
     333        self.scm.discard_working_directory_changes()
    334334        self.assertItemsEqual(self.scm.added_files(), [])
    335335        self.assertFalse(os.path.exists("added_file"))
    … …  
    890890        # webkit-patch uses a Checkout object and runs update-webkit, just use svn update here.
    891891        self.assertRaises(ScriptError, run_command, ['svn', 'update'])
    892         self.scm.clean_working_directory()
     892        self.scm.discard_working_directory_changes()
    893893        self.assertFalse(os.path.exists(svn_root_lock_path))
    894894        run_command(['svn', 'update'])  # Should succeed and not raise.
    … …  
    11121112
    11131113        # Make sure our cleanup works.
    1114         self.scm.clean_working_directory()
     1114        self.scm.discard_working_directory_changes()
    11151115        self.assertFalse(self.scm.rebase_in_progress())
    11161116
    11171117        # Make sure cleanup doesn't throw when no rebase is in progress.
    1118         self.scm.clean_working_directory()
     1118        self.scm.discard_working_directory_changes()
    11191119
    11201120    def test_commitish_parsing(self):

  • trunk/Tools/Scripts/webkitpy/common/checkout/scm/svn.py

    r139399 r139712  
    139139        return self._run_svn(['--version', '--quiet'])
    140140
    141     def working_directory_is_clean(self):
    142         return self._run_svn(["diff"], cwd=self.checkout_root, decode_output=False) == ""
    143 
    144     def clean_working_directory(self):
     141    def has_working_directory_changes(self):
     142        # FIXME: What about files which are not committed yet?
     143        return self._run_svn(["diff"], cwd=self.checkout_root, decode_output=False) != ""
     144
     145    def discard_working_directory_changes(self):
    145146        # Make sure there are no locks lying around from a previously aborted svn invocation.
    146147        # This is slightly dangerous, as it's possible the user is running another svn process

  • trunk/Tools/Scripts/webkitpy/tool/bot/irc_command.py

    r139585 r139712  
    112112
    113113    def _update_working_copy(self, tool):
    114         tool.scm().ensure_clean_working_directory(force_clean=True)
     114        tool.scm().discard_local_changes()
    115115        tool.executive.run_and_throw_if_fail(tool.deprecated_port().update_webkit_command(), quiet=True, cwd=tool.scm().checkout_root)
    116116

  • trunk/Tools/Scripts/webkitpy/tool/steps/cleanworkingdirectory.py

    r107302 r139712  
    2929from webkitpy.tool.steps.abstractstep import AbstractStep
    3030from webkitpy.tool.steps.options import Options
     31from webkitpy.common.system.executive import ScriptError
    3132
    3233
    … …  
    4748            return
    4849        if not self._allow_local_commits:
    49             self._tool.scm().ensure_no_local_commits(self._options.force_clean)
    50         self._tool.scm().ensure_clean_working_directory(force_clean=self._options.force_clean)
     50            if self._tool.scm().has_local_commits() and not self._options.force_clean:
     51                raise ScriptError("Repository has local commits, pass --force-clean to continue.")
     52            self._tool.scm().discard_local_commits()
     53        if self._tool.scm().has_working_directory_changes() and not self._options.force_clean:
     54            raise ScriptError("Working directory has changes, pass --force-clean to continue.")
     55        self._tool.scm().discard_working_directory_changes()

  • trunk/Tools/Scripts/webkitpy/tool/steps/cleanworkingdirectory_unittest.py

    r91210 r139712  
    3232from webkitpy.tool.mocktool import MockOptions, MockTool
    3333from webkitpy.tool.steps.cleanworkingdirectory import CleanWorkingDirectory
     34from webkitpy.common.system.executive import ScriptError
    3435
    3536
    3637class CleanWorkingDirectoryTest(unittest.TestCase):
    37     def test_run(self):
     38    def test_run_working_directory_changes_no_force(self):
    3839        tool = MockTool()
    3940        tool._scm = Mock()
    40         tool._scm.checkout_root = '/mock-checkout'
    4141        step = CleanWorkingDirectory(tool, MockOptions(clean=True, force_clean=False))
     42        tool._scm.has_working_directory_changes = lambda: True
     43        self.assertRaises(ScriptError, step.run, {})
     44        self.assertEqual(tool._scm.discard_local_commits.call_count, 0)
     45        self.assertEqual(tool._scm.discard_working_directory_changes.call_count, 0)
     46
     47    def test_run_local_commits_no_force(self):
     48        tool = MockTool()
     49        tool._scm = Mock()
     50        step = CleanWorkingDirectory(tool, MockOptions(clean=True, force_clean=False))
     51        tool._scm.has_local_commits = lambda: True
     52        self.assertRaises(ScriptError, step.run, {})
     53        self.assertEqual(tool._scm.discard_local_commits.call_count, 0)
     54        self.assertEqual(tool._scm.discard_working_directory_changes.call_count, 0)
     55
     56    def test_run_working_directory_changes_force(self):
     57        tool = MockTool()
     58        tool._scm = Mock()
     59        step = CleanWorkingDirectory(tool, MockOptions(clean=True, force_clean=True))
     60        tool._scm.has_working_directory_changes = lambda: True
    4261        step.run({})
    43         self.assertEqual(tool._scm.ensure_no_local_commits.call_count, 1)
    44         self.assertEqual(tool._scm.ensure_clean_working_directory.call_count, 1)
     62        self.assertEqual(tool._scm.discard_local_commits.call_count, 1)
     63        self.assertEqual(tool._scm.discard_working_directory_changes.call_count, 1)
     64
     65    def test_run_local_commits_force(self):
     66        tool = MockTool()
     67        tool._scm = Mock()
     68        step = CleanWorkingDirectory(tool, MockOptions(clean=True, force_clean=True))
     69        tool._scm.has_local_commits = lambda: True
     70        step.run({})
     71        self.assertEqual(tool._scm.discard_local_commits.call_count, 1)
     72        self.assertEqual(tool._scm.discard_working_directory_changes.call_count, 1)
     73
     74    def test_run_no_local_changes(self):
     75        tool = MockTool()
     76        tool._scm = Mock()
     77        step = CleanWorkingDirectory(tool, MockOptions(clean=True, force_clean=False))
     78        tool._scm.has_working_directory_changes = lambda: False
     79        tool._scm.has_local_commits = lambda: False
     80        step.run({})
     81        self.assertEqual(tool._scm.discard_local_commits.call_count, 1)
     82        self.assertEqual(tool._scm.discard_working_directory_changes.call_count, 1)
    4583
    4684    def test_no_clean(self):
    … …  
    4987        step = CleanWorkingDirectory(tool, MockOptions(clean=False))
    5088        step.run({})
    51         self.assertEqual(tool._scm.ensure_no_local_commits.call_count, 0)
    52         self.assertEqual(tool._scm.ensure_clean_working_directory.call_count, 0)
     89        self.assertEqual(tool._scm.discard_local_commits.call_count, 0)
     90        self.assertEqual(tool._scm.discard_working_directory_changes.call_count, 0)
Note: See TracChangeset for help on using the changeset viewer.