Reformat webkitpy.layout_tests w/ format-webkitpy.

Tools/Scripts/webkitpy/layout_tests/layout_tests_mover.py

 # Copyright (C) 2013 Google 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
@@ skipping 45 matching lines @@
 from webkitpy.layout_tests.port.base import Port
 from webkitpy.layout_tests.models.test_expectations import TestExpectations
 
 
 logging.basicConfig()
 _log = logging.getLogger(__name__)
 _log.setLevel(logging.INFO)
 
 PLATFORM_DIRECTORY = 'platform'
 
+
 class LayoutTestsMover(object):
 
     def __init__(self, port=None):
         self._port = port
         if not self._port:
             host = Host()
             # Given that we use include_overrides=False and model_all_expectations=True when
             # constructing the TestExpectations object, it doesn't matter which Port object we use.
             self._port = host.port_factory.get()
             self._port.host.initialize_scm()
@@ skipping 27 matching lines @@
             raise Exception('Destination path %s is not in LayoutTests directory' % self._destination)
 
         # If destination is an existing directory, we move the children of origin into destination.
         # However, if any of the children of origin would clash with existing children of
         # destination, we fail.
         # FIXME: Consider adding support for recursively moving into an existing directory.
         if self._filesystem.isdir(self._absolute_destination):
             for file_path in self._filesystem.listdir(self._absolute_origin):
                 if self._filesystem.exists(self._filesystem.join(self._absolute_destination, file_path)):
                     raise Exception('Origin path %s clashes with existing destination path %s' %
-                            (self._filesystem.join(self._origin, file_path), self._filesystem.join(self._destination, file_path)))
+                                    (self._filesystem.join(self._origin, file_path), self._filesystem.join(self._destination, file_path)))
 
     def _get_expectations_for_test(self, model, test_path):
         """Given a TestExpectationsModel object, finds all expectations that match the specified
         test, specified as a relative path. Handles the fact that expectations may be keyed by
         directory.
         """
         expectations = set()
         if model.has_test(test_path):
             expectations.add(model.get_expectation_line(test_path))
         test_path = self._filesystem.dirname(test_path)
         while not test_path == '':
             # The model requires a trailing slash for directories.
             test_path_for_model = test_path + '/'
             if model.has_test(test_path_for_model):
                 expectations.add(model.get_expectation_line(test_path_for_model))
             test_path = self._filesystem.dirname(test_path)
         return expectations
 
     def _get_expectations(self, model, path):
         """Given a TestExpectationsModel object, finds all expectations for all tests under the
         specified relative path.
         """
         expectations = set()
         for test in self._filesystem.files_under(self._filesystem.join(self._layout_tests_root, path), dirs_to_skip=['script-tests', 'resources'],
                                                  file_filter=Port.is_test_file):
-            expectations = expectations.union(self._get_expectations_for_test(model, self._filesystem.relpath(test, self._layout_tests_root)))
+            expectations = expectations.union(
+                self._get_expectations_for_test(
+                    model,
+                    self._filesystem.relpath(
+                        test,
+                        self._layout_tests_root)))
         return expectations
 
     @staticmethod
     def _clone_expectation_line_for_path(expectation_line, path):
         """Clones a TestExpectationLine object and updates the clone to apply to the specified
         relative path.
         """
         clone = copy.copy(expectation_line)
         clone.original_string = re.compile(expectation_line.name).sub(path, expectation_line.original_string)
         clone.name = path
@@ skipping 54 matching lines @@
         # Both the root path and the target of the reference my be subject to the move, so there are
         # four cases to consider. In the case where both or neither are subject to the move, the
         # reference doesn't need updating.
         #
         # This is true even if the reference includes superfluous dot segments which mention a moved
         # directory, as dot segments are collapsed during URL normalization. For example, if
         # foo.html contains a reference 'bar/../script.js', this remains valid (though ugly) even if
         # bar/ is moved to baz/, because the reference is always normalized to 'script.js'.
         absolute_reference = self._filesystem.normpath(self._filesystem.join(root, reference))
         if self._is_child_path(self._absolute_origin, root) == self._is_child_path(self._absolute_origin, absolute_reference):
-            return None;
+            return None
 
         new_root = self._move_path(root, self._absolute_origin, self._absolute_destination)
         new_absolute_reference = self._move_path(absolute_reference, self._absolute_origin, self._absolute_destination)
         return self._filesystem.relpath(new_absolute_reference, new_root)
 
     def _get_all_updated_references(self, references):
         """Determines the updated references due to the move. Returns a dictionary that maps from an
         absolute file path to a dictionary that maps from a reference string to the corresponding
         updated reference.
         """
@@ skipping 21 matching lines @@
         for target in updates.keys():
             regex = re.compile(r'((?:src=|href=|importScripts\(|url\()["\']?)%s(["\']?)' % target)
             contents = regex.sub(r'\1%s\2' % updates[target], contents)
         self._filesystem.write_binary_file(path, contents)
         self._scm.add(path)
 
     def _update_test_source_files(self):
         def is_test_source_file(filesystem, dirname, basename):
             pass_regex = re.compile(r'\.(css|js)$')
             fail_regex = re.compile(r'-expected\.')
-            return (Port.is_test_file(filesystem, dirname, basename) or pass_regex.search(basename)) and not fail_regex.search(basename)
+            return (Port.is_test_file(filesystem, dirname, basename)
+                    or pass_regex.search(basename)) and not fail_regex.search(basename)
 
         test_source_files = self._filesystem.files_under(self._layout_tests_root, file_filter=is_test_source_file)
         _log.info('Considering %s test source files for references' % len(test_source_files))
         references = self._find_references(test_source_files)
         _log.info('Considering references in %s files' % len(references))
         updates = self._get_all_updated_references(references)
         _log.info('Updating references in %s files' % len(updates))
         count = 0
         for file_path in updates.keys():
             self._update_file(file_path, updates[file_path])
@@ skipping 17 matching lines @@
             self._scm.move(self._scm_path(origin, directory), self._scm_path(destination, directory))
         self._filesystem.rmtree(absolute_origin)
 
     def _move_files(self):
         """Moves the all files that correspond to the move, including platform-specific expected
         results.
         """
         self._move_directory(self._origin, self._destination)
         for directory in self._filesystem.listdir(self._filesystem.join(self._layout_tests_root, PLATFORM_DIRECTORY)):
             self._move_directory(self._filesystem.join(PLATFORM_DIRECTORY, directory, self._origin),
-                           self._filesystem.join(PLATFORM_DIRECTORY, directory, self._destination))
+                                 self._filesystem.join(PLATFORM_DIRECTORY, directory, self._destination))
 
     def _commit_changes(self):
         if not self._scm.supports_local_commits():
             return
         title = 'Move LayoutTests directory %s to %s' % (self._origin, self._destination)
         _log.info('Committing change \'%s\'' % title)
         self._scm.commit_locally_with_message('%s\n\nThis commit was automatically generated by move-layout-tests.' % title,
                                               commit_all_working_directory_changes=False)
 
     def move(self, origin, destination):
         self._origin = origin
         self._destination = destination
         self._absolute_origin = self._filesystem.join(self._layout_tests_root, self._origin)
         self._absolute_destination = self._filesystem.join(self._layout_tests_root, self._destination)
         self._validate_input()
         self._update_expectations()
         self._update_test_source_files()
         self._move_files()
         # FIXME: Handle virtual test suites.
         self._commit_changes()
 
+
 def main(argv):
     parser = optparse.OptionParser(description=__doc__)
     parser.add_option('--origin',
                       help=('The directory of tests to move, as a relative path from the LayoutTests directory.'))
     parser.add_option('--destination',
                       help=('The new path for the directory of tests, as a relative path from the LayoutTests directory.'))
     options, _ = parser.parse_args()
     LayoutTestsMover().move(options.origin, options.destination)