Merge lp:~adiroiban/pocket-lint/plugin-system into lp:pocket-lint

[Adi Roiban]

Description
-----------

I want to have google-js-linter, pep257 , some custom regex checkers, css/LESS/SASS checker, HTML5 etc... then there is jshint/jslint ... maybe someone want pylint :)

I think that is hard to ship all this checkers with pocket lint.

One option is to let pocket-link define a framework for checkers and then users can add custom checkers as plugins.

Each plugin has its own configuration and can also use global configuration (once we have a well defined configuration object)

Changes
-------

As a drive-by fix I have updated PocektLintOption to not have the dirty hack for filling values from command line options.

PocketLintOption now have the addPlugin method... there is no method to remove plugins :)

I have defined a base Pluging which can register itself for a list of languages. We might want a checker for all files... ex line lenght like checker or tab checker or traling spaces checker

check is the entry paint and a helper for calling the plugin for multiple files.

check_all is the main method which should be defined by plugins.

I am also thinking at check_line to remove the need for plugins to split the file if they only want to do line checks.

I added `enabled` attribute, but I am not sure if it make sense... From an 3rd party user, if plugin is not enable, just don't add it. I am thinking that maybe we want to use the plugin system for own checker... like jshint.

Please let me know what do you think.\

Does it make sense? Do you find it useful? Is the API ok?

Thanks!

Unmerged revisions

453. By Adi Roiban <email address hidden> on 2014-04-12

Initial code for plugin system.

=== added file 'pocketlint/contrib/pep257_plugin.py'
--- pocketlint/contrib/pep257_plugin.py	1970-01-01 00:00:00 +0000
+++ pocketlint/contrib/pep257_plugin.py	2014-04-12 19:27:30 +0000
@@ -0,0 +1,97 @@
+import os
+
+try:
+    import pep257
+    # Shut up the linter.
+    pep257
+except ImportError:
+    pep257 = None
+from pocketlint.formatcheck import Language
+
+
+class Plugin(object):
+    """
+    Base class for implementing pocket-lint plugins.
+
+    You will need to define `check_all` if your linter needs whole content
+    or `check_line` if you will check each line.
+
+    Use `message` to add a message to reporter.
+    """
+    #: List of languages which can be checked using this plugin.
+    languages = [Language.TEXT]
+    #: Whether this plugin is enabled.
+    enabled = True
+    #: Path to current file that is checked.
+    file_path = None
+    #: Global options used by pocket-lint
+    global_options = None
+
+    def check(self, language, file_path, text, reporter, options):
+        """
+        Check code using this plugin.
+        """
+        if not self.enabled:
+            return
+
+        if language not in self.languages:
+            return
+
+        self._reporter = reporter
+        self.global_options = options
+        self.file_path = file_path
+
+        self.check_all(text)
+
+        for line_no, line in enumerate(text.splitlines()):
+            self.check_line(line, line_no + 1)
+
+    def check_all(self, text):
+        """
+        Check whole file content.
+        """
+        pass
+
+    def check_line(self, line, line_no):
+        """
+        Check single line.
+        """
+
+    def message(self, line_no, message, icon=None):
+        """
+        Add a message to reporter.
+        """
+        self._reporter(
+            line_no,
+            message,
+            icon=icon,
+            base_dir=os.path.dirname(self.file_path),
+            file_name=self.file_path,
+            )
+
+
+class PEP257Plugin(Plugin):
+    """
+    A plugin to check Python docstrings for PEP257.
+    """
+
+    languages = [Language.PYTHON]
+
+    _default_options = {
+        'ignore': ['D203', 'D204', 'D401'],
+        }
+
+    def __init__(self, options=None):
+        if not options:
+            options = self._default_options.copy()
+        self._options = options
+        self.enabled = pep257 != None
+        self._checker = pep257.PEP257Checker()
+
+    def check_all(self, text):
+        """Pass all content to pep257 module."""
+        results = self._checker.check_source(text, self.file_path)
+        for error in results:
+            if error.code in self._options['ignore']:
+                continue
+            self.message(error.line, error.message, icon='error')
 
=== modified file 'pocketlint/formatcheck.py'
--- pocketlint/formatcheck.py	2014-03-09 21:04:28 +0000
+++ pocketlint/formatcheck.py	2014-04-12 19:27:30 +0000
@@ -83,14 +83,6 @@
 except ImportError:
     closure_linter = None
 
-try:
-    import pep257
-    # Shut up the linter.
-    pep257
-except ImportError:
-    pep257 = None
-
-
 IS_PY3 = True if sys.version_info >= (3,) else False
 
 
@@ -262,10 +254,14 @@
 
 
 class PocketLintOptions(object):
-    """Default options used by pocketlint"""
+    """Default options used by pocketlint."""
 
-    def __init__(self, command_options=None):
+    def __init__(self):
         self.max_line_length = 0
+        self.verbose = False
+        # Docstring options.
+        self.do_format = False
+        self.is_interactive = False
 
         self.jslint = {
             'enabled': True,
@@ -287,19 +283,16 @@
 
         self.regex_line = []
 
-        if command_options:
-            self._updateFromCommandLineOptions(command_options)
-
-    def _updateFromCommandLineOptions(self, options):
-        """
-        Update with options received from command line.
-        """
-        # Update maximum line length.
-        self.max_line_length = options.max_line_length
-        self.pep8['max_line_length'] = options.max_line_length - 1
-        self.pep8['hang_closing'] = options.hang_closing
-        if hasattr(options, 'regex_line'):
-            self.regex_line = options.regex_line
+        self._plugins = set()
+
+    @property
+    def plugins(self):
+        """Return a copy of current plugins."""
+        return self._plugins.copy()
+
+    def addPlugin(self, plugin):
+        """Add `plugin`."""
+        self._plugins.add(plugin)
 
 
 class BaseChecker(object):
@@ -318,12 +311,9 @@
             self.text = u(text)
         self.set_reporter(reporter=reporter)
 
-        if options is None:
-            self.options = PocketLintOptions()
-        elif not isinstance(options, PocketLintOptions):
-            self.options = PocketLintOptions(command_options=options)
-        else:
-            self.options = options
+        if not options:
+            options = PocketLintOptions()
+        self.options = options
 
     def set_reporter(self, reporter=None):
         """Set the reporter for messages."""
@@ -397,6 +387,19 @@
             self.file_path, self.text, self._reporter, self.options)
         checker.check()
 
+        self.check_plugins()
+
+    def check_plugins(self):
+        """Checked code with registered plugins."""
+        for plugin in self.options.plugins:
+            plugin.check(
+                self.language,
+                self.file_path,
+                self.text,
+                self._reporter,
+                self.options,
+                )
+
 
 class AnyTextMixin:
     """Common checks for many checkers."""
@@ -512,9 +515,9 @@
 class FastParser(object):
     """A simple and pure-python parser that checks well-formedness.
 
-     This parser works in py 2 and 3. It handles entities and ignores
-     namespaces. This parser works with python ElementTree.
-     """
+    This parser works in py 2 and 3. It handles entities and ignores
+    namespaces. This parser works with python ElementTree.
+    """
 
     def __init__(self, html=0, target=None, encoding=None):
         parser = expat.ParserCreate(encoding, None)
@@ -702,7 +705,6 @@
         self.check_text()
         self.check_flakes()
         self.check_pep8()
-        self.check_pep257()
         self.check_windows_endlines()
 
     def check_flakes(self):
@@ -744,24 +746,6 @@
             message = "%s: %s" % (message, location[3].strip())
             self.message(location[1], message, icon='error')
 
-    def check_pep257(self):
-        """PEP 257 docstring style checker."""
-        if not pep257:
-            # PEP257 is not available.
-            return
-
-        ignore_list = getattr(self.options, 'pep257_ignore', [])
-
-        results = pep257.check_source(self.text, self.file_path)
-
-        for error in results:
-            # PEP257 message contains the short error as first line from
-            # the long docstring explanation.
-            error_message = error.explanation.splitlines()[0]
-            if error_message in ignore_list:
-                continue
-            self.message(error.line, error_message, icon='error')
-
     def check_text(self):
         """Call each line_method for each line in text."""
         for line_no, line in enumerate(self.text.splitlines()):
@@ -1160,6 +1144,7 @@
 
     def check_text(self):
         """Call each line_method for each line in text."""
+
         for line_no, line in enumerate(self.text.splitlines()):
             line_no += 1
             self.check_length(line_no, line)
@@ -1168,8 +1153,8 @@
             self.check_regex_line(line_no, line)
 
 
-def get_option_parser():
-    """Return the option parser for this program."""
+def parse_command_line(args):
+    """Return a tuple with (options, source) for the command line request."""
     usage = "usage: %prog [options] file1 file2"
     parser = OptionParser(usage=usage)
     parser.add_option(
@@ -1197,7 +1182,18 @@
         is_interactive=False,
         max_line_length=DEFAULT_MAX_LENGTH,
         )
-    return parser
+
+    (command_options, sources) = parser.parse_args(args=args)
+
+    # Create options based on parsed command line.
+    options = PocketLintOptions()
+    options.verbose = command_options.verbose
+    options.do_format = command_options.do_format
+    options.is_interactive = command_options.is_interactive
+    options.max_line_length = command_options.max_line_length
+    options.pep8['hang_closing'] = command_options.hang_closing
+
+    return (options, sources)
 
 
 def check_sources(sources, options, reporter=None):
@@ -1224,11 +1220,15 @@
     """Run the command line operations."""
     if argv is None:
         argv = sys.argv
-    parser = get_option_parser()
-    (options, sources) = parser.parse_args(args=argv[1:])
-    # Handle standard args.
+    (options, sources) = parse_command_line(args=argv[1:])
+
     if len(sources) == 0:
-        parser.error("Expected file paths.")
+        sys.stderr.write("Expected file paths.\n")
+        return 1
+
+    from pocketlint.contrib.pep257_plugin import PEP257Plugin
+
+    options.addPlugin(PEP257Plugin())
     reporter = Reporter(Reporter.CONSOLE)
     reporter.error_only = not options.verbose
     return check_sources(sources, options, reporter)