Simplify import-w3c-tests: support exactly one argument.

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 55 matching lines @@
 """
 
 import logging
 import mimetypes
 import optparse
 import os
 import sys
 
 from webkitpy.common.host import Host
 from webkitpy.common.webkit_finder import WebKitFinder
-from webkitpy.common.system.executive import ScriptError
 from webkitpy.layout_tests.models.test_expectations import TestExpectationParser
 from webkitpy.w3c.test_parser import TestParser
 from webkitpy.w3c.test_converter import convert_for_webkit
 
 
 # Maximum length of import path starting from top of source repository.
 # This limit is here because the Windows builders cannot create paths that are
 # longer than the Windows max path length (260). See http://crbug.com/609871.
 MAX_PATH_LENGTH = 125
 
 
 _log = logging.getLogger(__name__)
 
 
 def main(_argv, _stdout, _stderr):
     options, args = parse_args()
     host = Host()
-    dir_to_import = host.filesystem.normpath(os.path.abspath(args[0]))
-    if len(args) == 1:
-        top_of_repo = dir_to_import
-    else:
-        top_of_repo = host.filesystem.normpath(os.path.abspath(args[1]))
+    source_repo_path = host.filesystem.normpath(os.path.abspath(args[0]))
 
-    if not host.filesystem.exists(dir_to_import):
-        sys.exit('Directory %s not found!' % dir_to_import)
-    if not host.filesystem.exists(top_of_repo):
-        sys.exit('Repository directory %s not found!' % top_of_repo)
-    if top_of_repo not in dir_to_import:
-        sys.exit('Repository directory %s must be a parent of %s' % (top_of_repo, dir_to_import))
+    if not host.filesystem.exists(source_repo_path):
+        sys.exit('Repository directory %s not found!' % source_repo_path)
 
     configure_logging()
-    test_importer = TestImporter(host, dir_to_import, top_of_repo, options)
+    test_importer = TestImporter(host, source_repo_path, options)
     test_importer.do_import()
 
 
 def configure_logging():
     class LogHandler(logging.StreamHandler):
 
         def format(self, record):
             if record.levelno > logging.INFO:
                 return "%s: %s" % (record.levelname, record.getMessage())
             return record.getMessage()
 
     logger = logging.getLogger()
     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 = optparse.OptionParser(usage='usage: %prog [options] source_repo_path')
     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.')
     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.')
     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.')
     parser.add_option('--ignore-expectations', action='store_true', default=False,
                       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).')
 
     options, args = parser.parse_args()
-    if len(args) > 2:
-        parser.error('Incorrect number of arguments')
-    elif len(args) == 0:
-        # If no top-of-repo path was given, then assume that the user means to
-        # use the current working directory as the top-of-repo path.
-        # TODO(qyearsley): Remove this behavior, since it's a little confusing.
-        args = (os.getcwd(),)
+    if len(args) != 1:
+        parser.error('Incorrect number of arguments; source repo path is required.')
     return options, args
 
 
 class TestImporter(object):
 
-    def __init__(self, host, dir_to_import, top_of_repo, options):
+    def __init__(self, host, source_repo_path, options):
         self.host = host
-        self.dir_to_import = dir_to_import
-        self.top_of_repo = top_of_repo
+        self.source_repo_path = source_repo_path
         self.options = options
 
         self.filesystem = self.host.filesystem
         self.webkit_finder = WebKitFinder(self.filesystem)
         self._webkit_root = self.webkit_finder.webkit_base()
         self.layout_tests_dir = self.webkit_finder.path_from_webkit_base('LayoutTests')
         self.destination_directory = self.filesystem.normpath(self.filesystem.join(self.layout_tests_dir, options.destination,
-                                                                                   self.filesystem.basename(self.top_of_repo)))
-        self.import_in_place = (self.dir_to_import == self.destination_directory)
-        self.dir_above_repo = self.filesystem.dirname(self.top_of_repo)
+                                                                                   self.filesystem.basename(self.source_repo_path)))
+        self.import_in_place = (self.source_repo_path == self.destination_directory)
+        self.dir_above_repo = self.filesystem.dirname(self.source_repo_path)
 
         self.import_list = []
 
     def do_import(self):
-        _log.info("Importing %s into %s", self.dir_to_import, self.destination_directory)
-        self.find_importable_tests(self.dir_to_import)
+        _log.info("Importing %s into %s", self.source_repo_path, self.destination_directory)
+        self.find_importable_tests()
         self.import_tests()
 
-    def find_importable_tests(self, directory):
+    def find_importable_tests(self):
         """Walks through the source directory to find what tests should be imported.
 
         This function sets self.import_list, which contains information about how many
         tests are being imported, and their source and destination paths.
         """
         paths_to_skip = self.find_paths_to_skip()
 
-        for root, dirs, files in self.filesystem.walk(directory):
+        for root, dirs, files in self.filesystem.walk(self.source_repo_path):
             cur_dir = root.replace(self.dir_above_repo + '/', '') + '/'
             _log.info('  scanning ' + cur_dir + '...')
             total_tests = 0
             reftests = 0
             jstests = 0
 
             # Files in 'tools' are not for browser testing (e.g., a script for generating test files).
             # http://testthewebforward.org/docs/test-format-guidelines.html#tools
             DIRS_TO_SKIP = ('.git', 'test-plan', 'tools')
 
@@ skipping 15 matching lines @@
                         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 = path_full.replace(self.source_repo_path + '/', '')
                 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)
                         continue
                     else:
                         continue
                 # FIXME: This block should really be a separate function, but the early-continues make that difficult.
 
@@ skipping 95 matching lines @@
             total_imported_reftests += dir_to_copy['reftests']
             total_imported_jstests += dir_to_copy['jstests']
 
             prefixed_properties = []
 
             if not dir_to_copy['copy_list']:
                 continue
 
             orig_path = dir_to_copy['dirname']
 
-            subpath = self.filesystem.relpath(orig_path, self.top_of_repo)
+            subpath = self.filesystem.relpath(orig_path, self.source_repo_path)
             new_path = self.filesystem.join(self.destination_directory, subpath)
 
             if not self.filesystem.exists(new_path):
                 self.filesystem.maybe_make_directory(new_path)
 
             copied_files = []
 
             for file_to_copy in dir_to_copy['copy_list']:
                 # FIXME: Split this block into a separate function.
                 orig_filepath = self.filesystem.normpath(file_to_copy['src'])
@@ skipping 66 matching lines @@
             _log.info('Properties needing prefixes (by count):')
             for prefixed_property in sorted(total_prefixed_properties, key=lambda p: total_prefixed_properties[p]):
                 _log.info('  %s: %s', prefixed_property, total_prefixed_properties[prefixed_property])
 
     def path_too_long(self, source_path):
         """Checks whether a source path is too long to import.
 
         Args:
           Absolute path of file to be imported.
         """
-        path_from_repo_base = os.path.relpath(source_path, self.top_of_repo)
+        path_from_repo_base = os.path.relpath(source_path, self.source_repo_path)
         return len(path_from_repo_base) > MAX_PATH_LENGTH