Run auto-formatter (autopep8) on webkitpy.

third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_importer.py

 # Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
 # are met:
 #
 # 1. Redistributions of source code must retain the above
 #    copyright notice, this list of conditions and the following
 #    disclaimer.
 # 2. Redistributions in binary form must reproduce the above
@@ skipping 115 matching lines @@
     logger.setLevel(logging.INFO)
     handler = LogHandler()
     handler.setLevel(logging.INFO)
     logger.addHandler(handler)
     return handler
 
 
 def parse_args():
     parser = optparse.OptionParser(usage='usage: %prog [options] [dir_to_import] [top_of_repo]')
     parser.add_option('-n', '--no-overwrite', dest='overwrite', action='store_false', default=True,
-        help='Flag to prevent duplicate test files from overwriting existing tests. By default, they will be overwritten.')
+                      help='Flag to prevent duplicate test files from overwriting existing tests. By default, they will be overwritten.')
     parser.add_option('-a', '--all', action='store_true', default=False,
-        help='Import all tests including reftests, JS tests, and manual/pixel tests. By default, only reftests and JS tests are imported.')
+                      help='Import all tests including reftests, JS tests, and manual/pixel tests. By default, only reftests and JS tests are imported.')
     parser.add_option('-d', '--dest-dir', dest='destination', default='w3c',
-        help='Import into a specified directory relative to the LayoutTests root. By default, files are imported under LayoutTests/w3c.')
+                      help='Import into a specified directory relative to the LayoutTests root. By default, files are imported under LayoutTests/w3c.')
     parser.add_option('--ignore-expectations', action='store_true', default=False,
-        help='Ignore the W3CImportExpectations file and import everything.')
+                      help='Ignore the W3CImportExpectations file and import everything.')
     parser.add_option('--dry-run', action='store_true', default=False,
-        help='Dryrun only (don\'t actually write any results).')
+                      help='Dryrun only (don\'t actually write any results).')
 
     options, args = parser.parse_args()
     if len(args) > 2:
         parser.error('Incorrect number of arguments')
     elif len(args) == 0:
         args = (os.getcwd(),)
     return options, args
 
 
 class TestImporter(object):
@@ skipping 59 matching lines @@
                     path_base = path_base.replace(cur_dir, '')
                     path_full = self.filesystem.join(root, path_base)
                     if path_base in dirs:
                         dirs.remove(path_base)
                         if not self.options.dry_run and self.import_in_place:
                             _log.info("  pruning %s" % path_base)
                             self.filesystem.rmtree(path_full)
                         else:
                             _log.info("  skipping %s" % path_base)
 
-
             copy_list = []
 
             for filename in files:
                 path_full = self.filesystem.join(root, filename)
                 path_base = path_full.replace(directory + '/', '')
                 path_base = self.destination_directory.replace(self.layout_tests_dir + '/', '') + '/' + path_base
                 if path_base in paths_to_skip:
                     if not self.options.dry_run and self.import_in_place:
                         _log.info("  pruning %s" % path_base)
                         self.filesystem.remove(path_full)
@@ skipping 30 matching lines @@
                     # FIXME: Ideally we'd support reading the metadata
                     # directly rather than relying  on a naming convention.
                     # Using a naming convention creates duplicate copies of the
                     # reference files.
                     ref_file = os.path.splitext(test_basename)[0] + '-expected'
                     # Make sure to use the extension from the *reference*, not
                     # from the test, because at least flexbox tests use XHTML
                     # references but HTML tests.
                     ref_file += os.path.splitext(test_info['reference'])[1]
 
-                    copy_list.append({'src': test_info['reference'], 'dest': ref_file, 'reference_support_info': test_info['reference_support_info']})
+                    copy_list.append({'src': test_info['reference'], 'dest': ref_file,
+                                      'reference_support_info': test_info['reference_support_info']})
                     copy_list.append({'src': test_info['test'], 'dest': filename})
 
                 elif 'jstest' in test_info.keys():
                     jstests += 1
                     total_tests += 1
                     copy_list.append({'src': fullpath, 'dest': filename})
                 else:
                     total_tests += 1
                     copy_list.append({'src': fullpath, 'dest': filename})
 
             if copy_list:
                 # Only add this directory to the list if there's something to import
                 self.import_list.append({'dirname': root, 'copy_list': copy_list,
-                    'reftests': reftests, 'jstests': jstests, 'total_tests': total_tests})
+                                         'reftests': reftests, 'jstests': jstests, 'total_tests': total_tests})
 
     def find_paths_to_skip(self):
         if self.options.ignore_expectations:
             return set()
 
         paths_to_skip = set()
         port = self.host.port_factory.get()
         w3c_import_expectations_path = self.webkit_finder.path_from_webkit_base('LayoutTests', 'W3CImportExpectations')
         w3c_import_expectations = self.filesystem.read_text_file(w3c_import_expectations_path)
         parser = TestExpectationParser(port, all_tests=(), is_lint_mode=False)
@@ skipping 60 matching lines @@
                     _log.info('  skipping %s' % relpath)
                 else:
                     # FIXME: Maybe doing a file diff is in order here for existing files?
                     # In other words, there's no sense in overwriting identical files, but
                     # there's no harm in copying the identical thing.
                     _log.info('  %s' % relpath)
 
                 # Only html, xml, or css should be converted
                 # FIXME: Eventually, so should js when support is added for this type of conversion
                 mimetype = mimetypes.guess_type(orig_filepath)
-                if 'html' in str(mimetype[0]) or 'xml' in str(mimetype[0])  or 'css' in str(mimetype[0]):
-                    converted_file = convert_for_webkit(new_path, filename=orig_filepath, reference_support_info=reference_support_info)
+                if 'html' in str(mimetype[0]) or 'xml' in str(mimetype[0]) or 'css' in str(mimetype[0]):
+                    converted_file = convert_for_webkit(new_path, filename=orig_filepath,
+                                                        reference_support_info=reference_support_info)
 
                     if not converted_file:
                         if not self.import_in_place and not self.options.dry_run:
                             shutil.copyfile(orig_filepath, new_filepath)  # The file was unmodified.
                     else:
                         for prefixed_property in converted_file[0]:
                             total_prefixed_properties.setdefault(prefixed_property, 0)
                             total_prefixed_properties[prefixed_property] += 1
 
                         prefixed_properties.extend(set(converted_file[0]) - set(prefixed_properties))
@@ skipping 25 matching lines @@
         """ Creates a destination directory that mirrors that of the source directory """
 
         new_subpath = self.dir_to_import[len(self.top_of_repo):]
 
         destination_directory = os.path.join(self.destination_directory, new_subpath)
 
         if not os.path.exists(destination_directory):
             os.makedirs(destination_directory)
 
         _log.info('Tests will be imported into: %s', destination_directory)