switch import-w3c-tests from using print statements to logging

Tools/Scripts/webkitpy/w3c/test_importer.py

 #!/usr/bin/env python
 
 # 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
@@ skipping 71 matching lines @@
        require prefixes, the list of imported files, and guidance for future test modification and
        maintenance.
 
      - On subsequent imports, this file is read to determine if files have been removed in the newer changesets.
        The script removes these files accordingly.
 """
 
 # FIXME: Change this file to use the Host abstractions rather that os, sys, shutils, etc.
 
 import datetime
+import logging
 import mimetypes
 import optparse
 import os
 import shutil
 import sys
 
 from webkitpy.common.host import Host
 from webkitpy.common.system.executive import ScriptError
 from webkitpy.w3c.test_parser import TestParser
 from webkitpy.w3c.test_converter import W3CTestConverter
 
 
 TEST_STATUS_UNKNOWN = 'unknown'
 TEST_STATUS_APPROVED = 'approved'
 TEST_STATUS_SUBMITTED = 'submitted'
 
 CHANGESET_NOT_AVAILABLE = 'Not Available'
 
 
+_log = logging.getLogger(__name__)
+
+
 def main(_argv, _stdout, _stderr):
     options, args = parse_args()
     import_dir = args[0]
     if len(args) == 1:
         repo_dir = os.path.dirname(import_dir)
     else:
         repo_dir = args[1]
 
     if not os.path.exists(import_dir):
         sys.exit('Source directory %s not found!' % import_dir)
 
     if not os.path.exists(repo_dir):
         sys.exit('Repository directory %s not found!' % repo_dir)
     if not repo_dir in import_dir:
         sys.exit('Repository directory %s must be a parent of %s' % (repo_dir, import_dir))
 
+    configure_logging()
+
     test_importer = TestImporter(Host(), import_dir, repo_dir, options)
     test_importer.do_import()
 
 
+def configure_logging():
+    class LogHandler(logging.StreamHandler):
+
+        def format(self, record):
+            if record.levelno > logging.INFO:

[ojan, 2013/05/29 00:31:47]

Should this be: if record.levelno > self.lvl: ?

+                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] w3c_test_directory [repo_directory]')
     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')
 
     options, args = parser.parse_args()
     if len(args) not in (1, 2):
         parser.error('Incorrect number of arguments')
@@ skipping 31 matching lines @@
     def load_changeset(self):
         """Returns the current changeset from mercurial or "Not Available"."""
         try:
             self.changeset = self.host.executive.run_command(['hg', 'tip']).split('changeset:')[1]
         except (OSError, ScriptError):
             self.changeset = CHANGESET_NOT_AVAILABLE
 
     def find_importable_tests(self, directory):
         # FIXME: use filesystem
         for root, dirs, files in os.walk(directory):
-            print 'Scanning ' + root + '...'
+            _log.info('Scanning ' + root + '...')
             total_tests = 0
             reftests = 0
             jstests = 0
 
             # "archive" and "data" dirs are internal csswg things that live in every approved directory.
             # FIXME: skip 'incoming' tests for now, but we should rework the 'test_status' concept and
             # support reading them as well.
             DIRS_TO_SKIP = ('.git', '.hg', 'data', 'archive', 'incoming')
             for d in DIRS_TO_SKIP:
                 if d in dirs:
@@ skipping 91 matching lines @@
                 os.makedirs(new_path)
 
             copied_files = []
 
             for file_to_copy in dir_to_copy['copy_list']:
                 # FIXME: Split this block into a separate function.
                 orig_filepath = os.path.normpath(file_to_copy['src'])
 
                 if os.path.isdir(orig_filepath):
                     # FIXME: Figure out what is triggering this and what to do about it.
-                    print 'Error: %s refers to a directory' % orig_filepath
+                    _log.error('%s refers to a directory' % orig_filepath)
                     continue
 
                 if not(os.path.exists(orig_filepath)):
-                    print 'Warning: ' + orig_filepath + ' not found. Possible error in the test.'
+                    _log.warning('%s not found. Possible error in the test.', orig_filepath)
                     continue
 
                 new_filepath = os.path.join(new_path, file_to_copy['dest'])
 
                 if not(os.path.exists(os.path.dirname(new_filepath))):
                     os.makedirs(os.path.dirname(new_filepath))
 
                 if not self.options.overwrite and os.path.exists(new_filepath):
-                    print 'Skipping import of existing file ' + new_filepath
+                    _log.info('Skipping import of existing file ' + new_filepath)
                 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.
-                    print 'Importing:', orig_filepath
-                    print '       As:', new_filepath
+                    _log.info('Importing: %s', orig_filepath)
+                    _log.info('       As: %s', new_filepath)
 
                 # 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 = converter.convert_for_webkit(new_path, filename=orig_filepath)
 
                     if not converted_file:
                         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))
                         outfile = open(new_filepath, 'wb')
                         outfile.write(converted_file[1])
                         outfile.close()
                 else:
                     shutil.copyfile(orig_filepath, new_filepath)
 
                 copied_files.append(new_filepath.replace(self._webkit_root, ''))
 
             self.remove_deleted_files(new_path, copied_files)
             self.write_import_log(new_path, copied_files, prefixed_properties)
 
-        print 'Import complete'
+        _log.info('Import complete')
 
-        print 'IMPORTED ' + str(total_imported_tests) + ' TOTAL TESTS'
-        print 'Imported ' + str(total_imported_reftests) + ' reftests'
-        print 'Imported ' + str(total_imported_jstests) + ' JS tests'
-        print 'Imported ' + str(total_imported_tests - total_imported_jstests - total_imported_reftests) + ' pixel/manual tests'
-        print
-        print "Properties needing prefixes (by count):"
+        _log.info('IMPORTED %d TOTAL TESTS', total_imported_tests)
+        _log.info('Imported %d reftests', total_imported_reftests)
+        _log.info('Imported %d JS tests', total_imported_jstests)
+        _log.info('Imported %d pixel/manual tests', total_imported_tests - total_imported_jstests - total_imported_reftests)
+        _log.info('')
+        _log.info('Properties needing prefixes (by count):')
         for prefixed_property in sorted(total_prefixed_properties, key=lambda p: total_prefixed_properties[p]):
-            print "  %s: %s" % (prefixed_property, total_prefixed_properties[prefixed_property])
+            _log.info('  %s: %s', prefixed_property, total_prefixed_properties[prefixed_property])
 
     def setup_destination_directory(self):
         """ Creates a destination directory that mirrors that of the source approved or submitted directory """
 
         self.update_test_status()
 
         start = self.source_directory.find(self.test_status)
         new_subpath = self.source_directory[len(self.repo_dir):]
 
         destination_directory = os.path.join(self.destination_directory, new_subpath)
 
         if not os.path.exists(destination_directory):
             os.makedirs(destination_directory)
 
-        print 'Tests will be imported into: ' + destination_directory
+        _log.info('Tests will be imported into: %s', destination_directory)
 
     def update_test_status(self):
         """ Sets the test status to either 'approved' or 'submitted' """
 
         status = TEST_STATUS_UNKNOWN
 
         if 'approved' in self.source_directory.split(os.path.sep):
             status = TEST_STATUS_APPROVED
         elif 'submitted' in self.source_directory.split(os.path.sep):
             status = TEST_STATUS_SUBMITTED
@@ skipping 11 matching lines @@
 
         import_log = open(import_log_file, 'r')
         contents = import_log.readlines()
 
         if 'List of files\n' in contents:
             list_index = contents.index('List of files:\n') + 1
             previous_file_list = [filename.strip() for filename in contents[list_index:]]
 
         deleted_files = set(previous_file_list) - set(new_file_list)
         for deleted_file in deleted_files:
-            print 'Deleting file removed from the W3C repo:' + deleted_file
+            _log.info('Deleting file removed from the W3C repo: %s', deleted_file)
             deleted_file = os.path.join(self._webkit_root, deleted_file)
             os.remove(deleted_file)
 
         import_log.close()
 
     def write_import_log(self, import_directory, file_list, prop_list):
         """ Writes a w3c-import.log file in each directory with imported files. """
 
         now = datetime.datetime.now()
 
@@ skipping 13 matching lines @@
             for prop in prop_list:
                 import_log.write(prop + '\n')
         else:
             import_log.write('None\n')
         import_log.write('------------------------------------------------------------------------\n')
         import_log.write('List of files:\n')
         for item in file_list:
             import_log.write(item + '\n')
 
         import_log.close()