Changeset 58251 in webkit

Timestamp:

Apr 26, 2010 6:01:39 AM (14 years ago)

Author:

Chris Jerdonek

Message:

2010-04-26 Chris Jerdonek <Chris Jerdonek>

Reviewed by Shinichiro Hamaji.

Deleted the StyleChecker-related classes that are no longer
being used.

​https://bugs.webkit.org/show_bug.cgi?id=38118

• Scripts/webkitpy/style/checker.py:
  • Deleted the DeprecatedStyleChecker class.

• Scripts/webkitpy/style/checker_unittest.py:
  • Deleted the StyleCheckerTest, StyleCheckerCheckFileBase, StyleCheckerCheckFileTest, and StyleCheckerCheckPathsTest classes.

Location:

trunk/WebKitTools

Files:

• ChangeLog (modified) (1 diff)
• Scripts/webkitpy/style/checker.py (modified) (1 diff)
• Scripts/webkitpy/style/checker_unittest.py (modified) (2 diffs)

trunk/WebKitTools/ChangeLog

@@ +1 @@
+2010-04-26  Chris Jerdonek  <cjerdonek@webkit.org>
+
+        Reviewed by Shinichiro Hamaji.
+
+        Deleted the StyleChecker-related classes that are no longer
+        being used.
+
+        https://bugs.webkit.org/show_bug.cgi?id=38118
+
+        * Scripts/webkitpy/style/checker.py:
+          - Deleted the DeprecatedStyleChecker class.
+
+        * Scripts/webkitpy/style/checker_unittest.py:
+          - Deleted the StyleCheckerTest, StyleCheckerCheckFileBase,
+            StyleCheckerCheckFileTest, and StyleCheckerCheckPathsTest classes.
+
 2010-04-26  Chris Jerdonek  <cjerdonek@webkit.org>
 

trunk/WebKitTools/Scripts/webkitpy/style/checker.py

@@ -567 +567 @@
 
 
-# FIXME: Delete this class since it is no longer being used.
-class DeprecatedStyleChecker(object):
-
-    """Supports checking style in files and patches.
-
-       Attributes:
-         error_count: An integer that is the total number of reported
-                      errors for the lifetime of this StyleChecker
-                      instance.
-         file_count: An integer that is the total number of processed
-                     files.  Note that the number of skipped files is
-                     included in this value.
-
-    """
-
-    def __init__(self, configuration):
-        """Create a StyleChecker instance.
-
-        Args:
-          configuration: A StyleCheckerConfiguration instance that controls
-                         the behavior of style checking.
-
-        """
-        self._configuration = configuration
-        self.error_count = 0
-        self.file_count = 0
-
-    def _increment_error_count(self):
-        """Increment the total count of reported errors."""
-        self.error_count += 1
-
-    def _read_lines(self, file_path):
-        """Read the file at a path, and return its lines.
-
-        Raises:
-          IOError: if the file does not exist or cannot be read.
-
-        """
-        # Support the UNIX convention of using "-" for stdin.
-        if file_path == '-':
-            file = codecs.StreamReaderWriter(sys.stdin,
-                                             codecs.getreader('utf8'),
-                                             codecs.getwriter('utf8'),
-                                             'replace')
-        else:
-            # We do not open the file with universal newline support
-            # (codecs does not support it anyway), so the resulting
-            # lines contain trailing "\r" characters if we are reading
-            # a file with CRLF endings.
-            file = codecs.open(file_path, 'r', 'utf8', 'replace')
-
-        contents = file.read()
-
-        lines = contents.split("\n")
-        return lines
-
-    def _process_file(self, processor, file_path, handle_style_error):
-        """Process the file using the given style processor."""
-        try:
-            lines = self._read_lines(file_path)
-        except IOError:
-            message = 'Could not read file. Skipping: "%s"' % file_path
-            _log.warn(message)
-            return
-
-        # Check for and remove trailing carriage returns ("\r").
-        #
-        # FIXME: We should probably use the SVN "eol-style" property
-        #        or a white list to decide whether or not to do
-        #        the carriage-return check. Originally, we did the
-        #        check only if (os.linesep != '\r\n').
-        carriage_return_processor = CarriageReturnProcessor(handle_style_error)
-        lines = carriage_return_processor.process(lines)
-
-        processor.process(lines)
-
-    def check_paths(self, paths, mock_check_file=None, mock_os=None):
-        """Check style in the given files or directories.
-
-        Args:
-          paths: A list of file paths and directory paths.
-          mock_check_file: A mock of self.check_file for unit testing.
-          mock_os: A mock os for unit testing.
-
-        """
-        check_file = self.check_file if mock_check_file is None else \
-                     mock_check_file
-        os_module = os if mock_os is None else mock_os
-
-        for path in paths:
-            if os_module.path.isdir(path):
-                self._check_directory(directory=path,
-                                      check_file=check_file,
-                                      mock_os_walk=os_module.walk)
-            else:
-                check_file(path)
-
-    def _check_directory(self, directory, check_file, mock_os_walk=None):
-        """Check style in all files in a directory, recursively.
-
-        Args:
-          directory: A path to a directory.
-          check_file: The function to use in place of self.check_file().
-          mock_os_walk: A mock os.walk for unit testing.
-
-        """
-        os_walk = os.walk if mock_os_walk is None else mock_os_walk
-
-        for dir_path, dir_names, file_names in os_walk(directory):
-            for file_name in file_names:
-                file_path = os.path.join(dir_path, file_name)
-                check_file(file_path)
-
-    def check_file(self, file_path, line_numbers=None,
-                   mock_handle_style_error=None,
-                   mock_os_path_exists=None,
-                   mock_process_file=None):
-        """Check style in the given file.
-
-        Args:
-          file_path: The path of the file to process.  If possible, the path
-                     should be relative to the source root.  Otherwise,
-                     path-specific logic may not behave as expected.
-          line_numbers: An array of line numbers of the lines for which
-                        style errors should be reported, or None if errors
-                        for all lines should be reported.  Normally, this
-                        array contains the line numbers corresponding to the
-                        modified lines of a patch.
-          mock_handle_style_error: A unit-testing replacement for the function
-                                   to call when a style error occurs. Defaults
-                                   to a DefaultStyleErrorHandler instance.
-          mock_os_path_exists: A unit-test replacement for os.path.exists.
-                               This parameter should only be used for unit
-                               tests.
-          mock_process_file: The function to call to process the file. This
-                             parameter should be used only for unit tests.
-                             Defaults to the file processing method of this
-                             class.
-
-        Raises:
-          SystemExit: if the file does not exist.
-
-        """
-        if mock_handle_style_error is None:
-            increment = self._increment_error_count
-            handle_style_error = DefaultStyleErrorHandler(
-                                     configuration=self._configuration,
-                                     file_path=file_path,
-                                     increment_error_count=increment,
-                                     line_numbers=line_numbers)
-        else:
-            handle_style_error = mock_handle_style_error
-
-        os_path_exists = (os.path.exists if mock_os_path_exists is None else
-                          mock_os_path_exists)
-        process_file = (self._process_file if mock_process_file is None else
-                        mock_process_file)
-
-        if not os_path_exists(file_path) and file_path != "-":
-            _log.error("File does not exist: %s" % file_path)
-            sys.exit(1)
-
-        _log.debug("Checking: " + file_path)
-
-        self.file_count += 1
-
-        dispatcher = ProcessorDispatcher()
-
-        if dispatcher.should_skip_without_warning(file_path):
-            return
-        if dispatcher.should_skip_with_warning(file_path):
-            _log.warn('File exempt from style guide. Skipping: "%s"'
-                      % file_path)
-            return
-
-        min_confidence = self._configuration.min_confidence
-        processor = dispatcher.dispatch_processor(file_path,
-                                                  handle_style_error,
-                                                  min_confidence)
-        if processor is None:
-            _log.debug('File not a recognized type to check. Skipping: "%s"'
-                       % file_path)
-            return
-
-        _log.debug("Using class: " + processor.__class__.__name__)
-
-        process_file(processor, file_path, handle_style_error)
-
-
 class StyleProcessor(ProcessorBase):
 

trunk/WebKitTools/Scripts/webkitpy/style/checker_unittest.py

@@ -50 +50 @@
 from checker import check_webkit_style_parser
 from checker import configure_logging
-from checker import DeprecatedStyleChecker
 from checker import ProcessorDispatcher
 from checker import PatchChecker
@@ -742 +741 @@
 
 
-# FIXME: Delete this class since it is no longer being used.
-class StyleCheckerTest(unittest.TestCase):
-
-    """Test the StyleChecker class."""
-
-    def _mock_stderr_write(self, message):
-        pass
-
-    def _style_checker(self, configuration):
-        return DeprecatedStyleChecker(configuration)
-
-    def test_init(self):
-        """Test __init__ constructor."""
-        configuration = StyleCheckerConfiguration(
-                            filter_configuration=FilterConfiguration(),
-                            max_reports_per_category={},
-                            min_confidence=3,
-                            output_format="vs7",
-                            stderr_write=self._mock_stderr_write)
-
-        style_checker = self._style_checker(configuration)
-
-        self.assertEquals(style_checker._configuration, configuration)
-        self.assertEquals(style_checker.error_count, 0)
-        self.assertEquals(style_checker.file_count, 0)
-
-
-# FIXME: Delete this class since it is no longer being used.
-class StyleCheckerCheckFileBase(LoggingTestCase):
-
-    def setUp(self):
-        LoggingTestCase.setUp(self)
-        self.warning_messages = ""
-
-    def mock_stderr_write(self, warning_message):
-        self.warning_messages += warning_message
-
-    def _style_checker_configuration(self):
-        return StyleCheckerConfiguration(
-            filter_configuration=FilterConfiguration(),
-            max_reports_per_category={"whitespace/newline": 1},
-            min_confidence=3,
-            output_format="vs7",
-            stderr_write=self.mock_stderr_write)
-
-
-# FIXME: Delete this class since it is no longer being used.
-class StyleCheckerCheckFileTest(StyleCheckerCheckFileBase):
-
-    """Test the check_file() method of the StyleChecker class.
-
-    The check_file() method calls its process_file parameter when
-    given a file that should not be skipped.
-
-    The "got_*" attributes of this class are the parameters passed
-    to process_file by calls to check_file() made by this test
-    class. These attributes allow us to check the parameter values
-    passed internally to the process_file function.
-
-    Attributes:
-      got_file_path: The file_path parameter passed by check_file()
-                     to its process_file parameter.
-      got_handle_style_error: The handle_style_error parameter passed
-                              by check_file() to its process_file
-                              parameter.
-      got_processor: The processor parameter passed by check_file() to
-                     its process_file parameter.
-      warning_messages: A string containing all of the warning messages
-                        written to the mock_stderr_write method of
-                        this class.
-
-    """
-    def setUp(self):
-        StyleCheckerCheckFileBase.setUp(self)
-        self.got_file_path = None
-        self.got_handle_style_error = None
-        self.got_processor = None
-
-    def mock_handle_style_error(self):
-        pass
-
-    def mock_os_path_exists(self, path):
-        # We deliberately make it so that this method returns False unless
-        # the caller has made an effort to put "does_exist" in the path.
-        return path.find("does_exist") > -1
-
-    def mock_process_file(self, processor, file_path, handle_style_error):
-        """A mock _process_file().
-
-        See the documentation for this class for more information
-        on this function.
-
-        """
-        self.got_file_path = file_path
-        self.got_handle_style_error = handle_style_error
-        self.got_processor = processor
-
-    def assert_attributes(self,
-                          expected_file_path,
-                          expected_handle_style_error,
-                          expected_processor,
-                          expected_warning_messages):
-        """Assert that the attributes of this class equal the given values."""
-        self.assertEquals(self.got_file_path, expected_file_path)
-        self.assertEquals(self.got_handle_style_error, expected_handle_style_error)
-        self.assertEquals(self.got_processor, expected_processor)
-        self.assertEquals(self.warning_messages, expected_warning_messages)
-
-    def call_check_file(self, file_path):
-        """Call the check_file() method of a test StyleChecker instance."""
-        # Confirm that the attributes are reset.
-        self.assert_attributes(None, None, None, "")
-
-        configuration = self._style_checker_configuration()
-
-        style_checker = DeprecatedStyleChecker(configuration)
-
-        style_checker.check_file(file_path=file_path,
-            mock_handle_style_error=self.mock_handle_style_error,
-            mock_os_path_exists=self.mock_os_path_exists,
-            mock_process_file=self.mock_process_file)
-
-        self.assertEquals(style_checker.file_count, 1)
-
-    def test_check_file_does_not_exist(self):
-        file_path = "file_does_not_exist.txt"
-
-        # Confirm that the file does not exist.
-        self.assertFalse(self.mock_os_path_exists(file_path))
-
-        # Check the outcome.
-        self.assertRaises(SystemExit, self.call_check_file, file_path)
-        self.assertLog(["ERROR: File does not exist: "
-                        "file_does_not_exist.txt\n"])
-
-    def test_check_file_stdin(self):
-        file_path = "-"
-
-        # Confirm that the file does not exist.
-        self.assertFalse(self.mock_os_path_exists(file_path))
-
-        # Check the outcome.
-        self.call_check_file(file_path)
-        expected_processor = CppProcessor(file_path,
-                                          "",
-                                          self.mock_handle_style_error, 3)
-        self.assert_attributes(file_path,
-                               self.mock_handle_style_error,
-                               expected_processor,
-                               "")
-
-    def test_check_file_on_skip_without_warning(self):
-        """Test check_file() for a skipped-without-warning file."""
-
-        file_path = "LayoutTests/does_exist/foo.txt"
-
-        dispatcher = ProcessorDispatcher()
-        # Confirm that the input file is truly a skipped-without-warning file.
-        self.assertTrue(dispatcher.should_skip_without_warning(file_path))
-
-        # Check the outcome.
-        self.call_check_file(file_path)
-        self.assert_attributes(None, None, None, "")
-
-    def test_check_file_on_skip_with_warning(self):
-        """Test check_file() for a skipped-with-warning file."""
-
-        file_path = "does_exist/gtk2drawing.c"
-
-        dispatcher = ProcessorDispatcher()
-        # Check that the input file is truly a skipped-with-warning file.
-        self.assertTrue(dispatcher.should_skip_with_warning(file_path))
-
-        # Check the outcome.
-        self.call_check_file(file_path)
-        self.assert_attributes(None, None, None, "")
-        self.assertLog(["WARNING: File exempt from style guide. "
-                        'Skipping: "does_exist/gtk2drawing.c"\n'])
-
-    def test_check_file_on_non_skipped(self):
-
-        # We use a C++ file since by using a CppProcessor, we can check
-        # that all of the possible information is getting passed to
-        # process_file (in particular, the min_confidence parameter).
-        file_base = "foo_does_exist"
-        file_extension = "cpp"
-        file_path = file_base + "." + file_extension
-
-        dispatcher = ProcessorDispatcher()
-        # Check that the input file is truly a C++ file.
-        self.assertEquals(dispatcher._file_type(file_path), style.FileType.CPP)
-
-        # Check the outcome.
-        self.call_check_file(file_path)
-
-        expected_processor = CppProcessor(file_path, file_extension, self.mock_handle_style_error, 3)
-
-        self.assert_attributes(file_path,
-                               self.mock_handle_style_error,
-                               expected_processor,
-                               "")
-
-
-# FIXME: Delete this class since it is no longer being used.
-class StyleCheckerCheckPathsTest(unittest.TestCase):
-
-    """Test the check_paths() method of the StyleChecker class."""
-
-    class MockOs(object):
-
-        class MockPath(object):
-
-            """A mock os.path."""
-
-            def isdir(self, path):
-                return path == "directory"
-
-        def __init__(self):
-            self.path = self.MockPath()
-
-        def walk(self, directory):
-            """A mock of os.walk."""
-            if directory == "directory":
-                dirs = [("dir_path1", [], ["file1", "file2"]),
-                        ("dir_path2", [], ["file3"])]
-                return dirs
-            return None
-
-    def setUp(self):
-        self._checked_files = []
-
-    def _mock_check_file(self, file):
-        self._checked_files.append(file)
-
-    def test_check_paths(self):
-        """Test StyleChecker.check_paths()."""
-        checker = DeprecatedStyleChecker(configuration=None)
-        mock_check_file = self._mock_check_file
-        mock_os = self.MockOs()
-
-        # Confirm that checked files is empty at the outset.
-        self.assertEquals(self._checked_files, [])
-        checker.check_paths(["path1", "directory"],
-                            mock_check_file=mock_check_file,
-                            mock_os=mock_os)
-        self.assertEquals(self._checked_files,
-                          ["path1",
-                           os.path.join("dir_path1", "file1"),
-                           os.path.join("dir_path1", "file2"),
-                           os.path.join("dir_path2", "file3")])
-
-
 class PatchCheckerTest(unittest.TestCase):