Remove committer list, bugzilla, watchlist code and transitive closure of stuff.

Tools/Scripts/webkitpy/style/checker.py

 # Copyright (C) 2009 Google Inc. All rights reserved.
 # Copyright (C) 2010 Chris Jerdonek (chris.jerdonek@gmail.com)
 # Copyright (C) 2010 ProFUSION embedded systems
 #
 # 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.
@@ skipping 26 matching lines @@
 
 from checkers.common import categories as CommonCategories
 from checkers.common import CarriageReturnChecker
 from checkers.cpp import CppChecker
 from checkers.cmake import CMakeChecker
 from checkers.jsonchecker import JSONChecker
 from checkers.png import PNGChecker
 from checkers.python import PythonChecker
 from checkers.test_expectations import TestExpectationsChecker
 from checkers.text import TextChecker
-from checkers.watchlist import WatchListChecker
 from checkers.xcodeproj import XcodeProjectFileChecker
 from checkers.xml import XMLChecker
 from error_handlers import DefaultStyleErrorHandler
 from filter import FilterConfiguration
 from optparser import ArgumentParser
 from optparser import DefaultCommandOptionValues
 from webkitpy.common.system.logutils import configure_logging as _configure_logging
 
 
 _log = logging.getLogger(__name__)
@@ skipping 446 matching lines @@
                                   handlers=handlers)
 
     return handlers
 
 
 # Enum-like idiom
 class FileType:
 
     NONE = 0  # FileType.NONE evaluates to False.
     # Alphabetize remaining types
-    CHANGELOG = 1
+    # CHANGELOG = 1
     CPP = 2
     JSON = 3
     PNG = 4
     PYTHON = 5
     TEXT = 6
-    WATCHLIST = 7
+    # WATCHLIST = 7
     XML = 8
     XCODEPROJ = 9
     CMAKE = 10
 
 
 class CheckerDispatcher(object):
 
     """Supports determining whether and how to check style, based on path."""
 
     def _file_extension(self, file_path):
@@ skipping 16 matching lines @@
         for skipped_file in _SKIPPED_FILES_WITH_WARNING:
             if self._should_skip_file_path(file_path, skipped_file):
                 return True
         return False
 
     def should_skip_without_warning(self, file_path):
         """Return whether the given file should be skipped without a warning."""
         if not self._file_type(file_path):  # FileType.NONE.
             return True
         # Since "LayoutTests" is in _SKIPPED_FILES_WITHOUT_WARNING, make
-        # an exception to prevent files like "LayoutTests/ChangeLog" and
-        # "LayoutTests/ChangeLog-2009-06-16" from being skipped.
-        # Files like 'TestExpectations' are also should not be skipped.
+        # an exception to prevent files like 'TestExpectations' from being skipped.
         #
         # FIXME: Figure out a good way to avoid having to add special logic
         #        for this special case.
         basename = os.path.basename(file_path)
         if basename == 'TestExpectations':
             return False
         for skipped_file in _SKIPPED_FILES_WITHOUT_WARNING:
             if self._should_skip_file_path(file_path, skipped_file):
                 return True
         return False
@@ skipping 12 matching lines @@
             # Treat stdin as C++. Since the extension is unknown when
             # reading from stdin, cpp_style tests should not rely on
             # the extension.
             return FileType.CPP
         elif file_extension == _JSON_FILE_EXTENSION:
             return FileType.JSON
         elif file_extension == _PYTHON_FILE_EXTENSION:
             return FileType.PYTHON
         elif file_extension in _XML_FILE_EXTENSIONS:
             return FileType.XML
-        elif os.path.basename(file_path).startswith('ChangeLog'):
-            return FileType.CHANGELOG
-        elif os.path.basename(file_path) == 'watchlist':
-            return FileType.WATCHLIST
         elif file_extension == _XCODEPROJ_FILE_EXTENSION:
             return FileType.XCODEPROJ
         elif file_extension == _PNG_FILE_EXTENSION:
             return FileType.PNG
         elif ((file_extension == _CMAKE_FILE_EXTENSION) or os.path.basename(file_path) == 'CMakeLists.txt'):
             return FileType.CMAKE
         elif ((not file_extension and os.path.join("Tools", "Scripts") in file_path) or
               file_extension in _TEXT_FILE_EXTENSIONS or os.path.basename(file_path) == 'TestExpectations'):
             return FileType.TEXT
         else:
             return FileType.NONE
 
     def _create_checker(self, file_type, file_path, handle_style_error,
                         min_confidence):
         """Instantiate and return a style checker based on file type."""
         if file_type == FileType.NONE:
             checker = None
-        elif file_type == FileType.CHANGELOG:
-            checker = None
         elif file_type == FileType.CPP:
             file_extension = self._file_extension(file_path)
             checker = CppChecker(file_path, file_extension,
                                  handle_style_error, min_confidence)
         elif file_type == FileType.JSON:
             checker = JSONChecker(file_path, handle_style_error)
         elif file_type == FileType.PYTHON:
             checker = PythonChecker(file_path, handle_style_error)
         elif file_type == FileType.XML:
             checker = XMLChecker(file_path, handle_style_error)
         elif file_type == FileType.XCODEPROJ:
             checker = XcodeProjectFileChecker(file_path, handle_style_error)
         elif file_type == FileType.PNG:
             checker = PNGChecker(file_path, handle_style_error)
         elif file_type == FileType.CMAKE:
             checker = CMakeChecker(file_path, handle_style_error)
         elif file_type == FileType.TEXT:
             basename = os.path.basename(file_path)
             if basename == 'TestExpectations':
                 checker = TestExpectationsChecker(file_path, handle_style_error)
             else:
                 checker = TextChecker(file_path, handle_style_error)
-        elif file_type == FileType.WATCHLIST:
-            checker = WatchListChecker(file_path, handle_style_error)
         else:
             raise ValueError('Invalid file type "%(file_type)s": the only valid file types '
                              "are %(NONE)s, %(CPP)s, and %(TEXT)s."
                              % {"file_type": file_type,
                                 "NONE": FileType.NONE,
                                 "CPP": FileType.CPP,
                                 "TEXT": FileType.TEXT})
 
         return checker
 
@@ skipping 230 matching lines @@
         checker = self._dispatcher.dispatch(file_path,
                                             style_error_handler,
                                             min_confidence)
 
         if checker is None:
             raise AssertionError("File should not be checked: '%s'" % file_path)
 
         _log.debug("Using class: " + checker.__class__.__name__)
 
         checker.check(lines)