Merge lp:~sinzui/ubuntu/oneiric/pocket-lint/0.5.21 into lp:ubuntu/oneiric/pocket-lint

[Curtis Hovey]

Merge upstream release that improves CSS and JS support
debian/control was updated to require gjs

[Scott Moser (smoser)]

It looks like debian/copyright needs updating at least for './pocketlint/contrib/cssccc.py', which is listed as "public domain", unlike the other files that are MIT.

The rest of it looks good to me.

review: Needs Fixing

[Scott Moser (smoser)]

oh, and just to be clear, you're not expecting this for SRU to oneiric, right?

[Curtis Hovey (sinzui)]

Thank you for spotting the license change. I updated the license file. No I do not think this deserves an SRU given that the branch is more than a month old.

[lp:~sinzui/ubuntu/oneiric/pocket-lint/0.5.21]

6. By Curtis Hovey on 2011-10-14

Updated license information.

Unmerged revisions

6. By Curtis Hovey on 2011-10-14

Updated license information.

5. By Curtis Hovey on 2011-09-11

New upstream release improves CSS and JS support.
Fixes Gtk3 bugs.

=== modified file 'ChangeLog'
--- ChangeLog	2011-04-16 15:32:48 +0000
+++ ChangeLog	2011-10-14 21:24:26 +0000
@@ -1,5 +1,126 @@
 <Generated by bzr log --log-format=gnu>
 
[phone]  Curtis Hovey <[e-mail]>
+
+	[396] Use seed as the js interpreter.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[395] Clear refernece.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[394] Documented how to use jsreporter.js
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[393] Removed unused code.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[392] Use seed as the default js command.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[391] Updated attr name.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[390] Removed js subprocess, but HTML5Browser is slow.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[389] Updated documentation.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[388] Minor speed changes.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[387] Added rudimentary JS checker based on Webkit.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[386] Incremented version.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[385] merged Adi's fix.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[384] Inremented version.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[383] Corrected the js line number.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[382] Catch and report IndentationExceptions.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[381] Removed unneeded checks.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[380] Remove trailing whitespace.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[379] Merged python encoding fix.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[378] Increment version.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[377] Hush WindowError.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[376] Move signed archives rules into setup.py.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[375] Incremented version for cssccc
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[374] Merged cssccc lib.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[373] Added a rule to sign the release after it is made.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[372] Incremenet version for release.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[371] Merged Adi's feature that returns the count od reported issues.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[370] Added simple SQL checker.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[369] Elaborated comment test.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[368] Added a basic test to verify comments do not mess up blank line
+	counts.
+
[phone]  Curtis Hovey <[e-mail]>
+
+	[367] Update pep8 to version 0.6.1
+
 2011-04-15  Curtis Hovey <[e-mail]>
 
 	[366] Increment version.

=== modified file 'PKG-INFO'
--- PKG-INFO	2011-04-16 15:32:48 +0000
+++ PKG-INFO	2011-10-14 21:24:26 +0000
@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: pocketlint
-Version: 0.5.13
+Version: 0.5.21
 Summary: Pocket-lint a composite linter and style checker.
 Home-page: https://launchpad.net/pocket-lint
 Author: Curtis C. Hovey

=== modified file 'debian/changelog'
--- debian/changelog	2011-04-16 15:32:48 +0000
+++ debian/changelog	2011-10-14 21:24:26 +0000
@@ -1,3 +1,9 @@
+pocket-lint (0.5.21-0ubuntu1) UNRELEASED; urgency=low
+
+  * New upstream release.
+
+ -- Curtis C. Hovey <[e-mail]>  Sun, 11 Sep 2011 17:22:02 -0400
+
 pocket-lint (0.5.13-0ubuntu1) natty; urgency=low
 
   * New upstream bug fix release

=== modified file 'debian/control'
--- debian/control	2011-04-15 13:37:44 +0000
+++ debian/control	2011-10-14 21:24:26 +0000
@@ -11,8 +11,7 @@
 Package: python-pocket-lint
 Architecture: all
 Depends: ${misc:Depends}, ${shlibs:Depends}, ${python:Depends}
-Recommends: python-cssutils
-Suggests: spidermonkey-bin
+Recommends: python-cssutils, gjs
 Description: a composite linter and style checker
  Pocket-lint has several notable features:
  .

=== modified file 'debian/copyright'
--- debian/copyright	2010-11-17 15:46:54 +0000
+++ debian/copyright	2011-10-14 21:24:26 +0000
@@ -4,7 +4,7 @@
 Copyright:
     Upstream Author: Curtis C. Hovey
 
-License:
+Primary license:
     The MIT License:
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -25,6 +25,11 @@
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 
+
+contrib/cssccc.py license:
+    Public Domain
+
+
 The Debian packaging is:
     Copyright 2010 Curtis C. Hovey
     and is under the MIT licence.

=== added file 'pocketlint/contrib/cssccc.py'
--- pocketlint/contrib/cssccc.py	1970-01-01 00:00:00 +0000
+++ pocketlint/contrib/cssccc.py	2011-10-14 21:24:26 +0000
@@ -0,0 +1,495 @@
+'''
+This code is in the public domain.
+
+Check CSS code for some common coding conventions.
+The code must be in a valid CSS format.
+It is recommend to first parse it using cssutils.
+It is also recommend to check it with pocket-lint for things like trailing
+spaces or tab characters.
+
+If a comment is on the whole line, it will consume the whole line like it
+was not there.
+If a comment is inside a line it will only consume its own content.
+
+Bases on Stoyan Stefanov's http://www.phpied.com/css-coding-conventions/
+
+'@media' rule is not supported.
+    @media print {
+      html {
+        background: #fff;
+        color: #000;
+      }
+      body {
+        padding: 1in;
+        border: 0.5pt solid #666;
+      }
+    }
+
+The following at-rules are supported:
+ * keyword / text at-rules
+  * @charset "ISO-8859-15";
+  * @import url(/css/screen.css) screen, projection;
+  * @namespace foo "http://example.com/ns/foo";
+ * keybord / block rules
+  * @page { block; }
+  * @font-face { block; }
+
+
+TODO:
+ * add warning for using px for fonts.
+ * add Unicode support.
+ * add AtRule checks
+ * add support for TAB as a separator / identation.
+ * add support for @media
+'''
+from __future__ import with_statement
+
+__version__ = '0.1.1'
+
+import sys
+
+SELECTOR_SEPARATOR = ','
+DECLARATION_SEPARATOR = ';'
+PROPERTY_SEPARATOR = ':'
+COMMENT_START = r'/*'
+COMMENT_END = r'*/'
+AT_TEXT_RULES = ['import', 'charset', 'namespace']
+AT_BLOCK_RULES = ['page', 'font-face']
+# If you want
+# selector,
+# selector2
+# {
+#     property:
+# }
+#IGNORED_MESSAGES = ['I013', 'I014']
+
+# If you want
+# selector,
+# selector {
+#     property:
+# }
+#IGNORED_MESSAGES = ['I005', 'I014']
+
+# If you want
+# selector,
+# selector2 {
+#     property:
+#     }
+IGNORED_MESSAGES = ['I005', 'I006']
+
+
+class CSSRule(object):
+    '''A CSS rule.'''
+
+    def check(self):
+        '''Check the rule.'''
+        raise AssertionError('Method not implemtned.')
+
+
+class CSSAtRule(object):
+    '''A CSS @rule.'''
+
+    type = object()
+
+    def __init__(self, identifier, keyword, log, text=None, block=None):
+        self.identifier = identifier
+        self.keyword = keyword
+        self.text = text
+        self.block = block
+        self.log = log
+
+    def check(self):
+        '''Check the rule.'''
+
+
+class CSSRuleSet(object):
+    '''A CSS rule_set.'''
+
+    type = object()
+
+    def __init__(self, selector, declarations, log):
+        self.selector = selector
+        self.declarations = declarations
+        self.log = log
+
+    def __str__(self):
+        return '%s{%s}' % (str(self.selector), str(self.declarations))
+
+    def __repr__(self):
+        return '%d:%s{%s}' % (
+            self.selector.start_line,
+            str(self.selector),
+            str(self.declarations),
+            )
+
+    def check(self):
+        '''Check the rule set.'''
+        self.checkSelector()
+        self.checkDeclarations()
+
+    def checkSelector(self):
+        '''Check rule-set selector.'''
+        start_line = self.selector.getStartLine()
+        selectors = self.selector.text.split(SELECTOR_SEPARATOR)
+        offset = 0
+        last_selector = selectors[-1]
+        first_selector = selectors[0]
+        rest_selectors = selectors[1:]
+
+        if first_selector.startswith('\n\n\n'):
+            self.log(start_line, 'I002', 'To many newlines before selectors.')
+        elif first_selector.startswith('\n\n'):
+            pass
+        elif start_line > 2:
+            self.log(start_line, 'I003', 'To few newlines before selectors.')
+        else:
+            pass
+
+        for selector in rest_selectors:
+            if not selector.startswith('\n'):
+                self.log(
+                    start_line + offset,
+                    'I004',
+                    'Selector must be on a new line.')
+            offset += selector.count('\n')
+
+        if not last_selector.endswith('\n'):
+            self.log(
+                start_line + offset,
+                'I005',
+                'No newline after last selector.')
+
+        if not (last_selector[-2] != ' ' and last_selector[-1] == (' ')):
+            self.log(
+                start_line + offset,
+                'I013',
+                'Last selector must be followed by " {".')
+
+    def checkDeclarations(self):
+        '''Check rule-set declarations.'''
+        start_line = self.declarations.getStartLine()
+        declarations = self.declarations.text.split(DECLARATION_SEPARATOR)
+        offset = 0
+
+        # Check all declarations except last as this is the new line.
+        first_declaration = True
+        for declaration in declarations[:-1]:
+            if not declaration.startswith('\n'):
+                self.log(
+                    start_line + offset,
+                    'I007',
+                    'Each declarations should start on a new line.',
+                    )
+            elif (not declaration.startswith('\n    ') or
+                declaration[5] == ' '):
+                self.log(
+                    start_line + offset,
+                    'I008',
+                    'Each declaration must be indented with 4 spaces.',
+                    )
+
+            parts = declaration.split(PROPERTY_SEPARATOR)
+            if len(parts) != 2:
+                self.log(
+                    start_line + offset,
+                    'I009',
+                    'Wrong separator on property: value pair.',
+                    )
+            else:
+                prop, value = parts
+                if prop.endswith(' '):
+                    self.log(
+                        start_line + offset,
+                        'I010',
+                        'Whitespace before ":".',
+                        )
+                if not (value.startswith(' ') or value.startswith('\n')):
+                    self.log(
+                        start_line + offset,
+                        'I011',
+                        'Missing whitespace after ":".',
+                        )
+                elif value.startswith('  '):
+                    self.log(
+                        start_line + offset,
+                        'I012',
+                        'Multiple whitespaces after ":".',
+                        )
+            if first_declaration:
+                first_declaration = False
+            else:
+                offset += declaration.count('\n')
+
+        last_declaration = declarations[-1]
+        offset += last_declaration.count('\n')
+        if last_declaration != '\n':
+            self.log(
+                start_line + offset,
+                'I006',
+                'Rule declarations should end with a single new line.',
+                )
+        if last_declaration != '\n    ':
+            self.log(
+                start_line + offset,
+                'I014',
+                'Rule declarations should end indented on a single new line.',
+                )
+
+
+class CSSStatementMember(object):
+    '''A member of CSS statement.'''
+
+    def __init__(self, start_line, start_character, text):
+        self.start_line = start_line
+        self.start_character = start_character
+        self.text = text
+
+    def getStartLine(self):
+        '''Return the line number for first character in the statement and
+        the number of new lines untilg the first character.'''
+        index = 0
+        text = self.text
+        character = text[index]
+        while character == '\n':
+            index += 1
+            character = text[index]
+
+        return self.start_line + index + 1
+
+    def __str__(self):
+        return self.text
+
+    def __repr__(self):
+        return '%d:%d:{%s}' % (
+            self.start_line, self.start_character, self.text)
+
+
+class CSSCodingConventionChecker(object):
+    '''CSS coding convention checker.'''
+
+    icons = {
+        'E': 'error',
+        'I': 'info',
+        }
+
+    def __init__(self, text, logger=None):
+        self._text = text.splitlines(True)
+        self.line_number = 0
+        self.character_number = 0
+        if logger:
+            self._logger = logger
+        else:
+            self._logger = self._defaultLog
+
+    def log(self, line_number, code, message):
+        '''Log the message with `code`.'''
+        if code in IGNORED_MESSAGES:
+            return
+        icon = self.icons[code[0]]
+        self._logger(line_number, code + ': ' + message, icon=icon)
+
+    def check(self):
+        '''Check all rules.'''
+        for rule in self.getRules():
+            rule.check()
+
+    def getRules(self):
+        '''Generates the next CSS rule ignoring comments.'''
+        while True:
+            yield self.getNextRule()
+
+    def getNextRule(self):
+        '''Return the next parsed rule.
+
+        Raise `StopIteration` if we are at the last rule.
+        '''
+        if self._nextStatementIsAtRule():
+            text = None
+            block = None
+            keyword = self._parse('@')
+            # TODO: user regex [ \t {]
+            keyword_text = self._parse(' ')
+            keyword_name = keyword_text.text
+            keyword.text += '@' + keyword_name + ' '
+
+            if keyword_name.lower() in AT_TEXT_RULES:
+                text = self._parse(';')
+            elif keyword_name.lower() in AT_BLOCK_RULES:
+                start = self._parse('{')
+                keyword.text += start.text
+                block = self._parse('}')
+            else:
+                self._parse(';')
+                raise StopIteration
+
+            return CSSAtRule(
+                identifier=keyword_name,
+                keyword=keyword,
+                text=text,
+                block=block,
+                log=self.log)
+        else:
+            selector = self._parse('{')
+            declarations = self._parse('}')
+            return CSSRuleSet(
+                selector=selector,
+                declarations=declarations,
+                log=self.log)
+
+    def _defaultLog(self, line_number, message, icon='info'):
+        '''Log the message to STDOUT.'''
+        print '    %4s:%s' % (line_number, message)
+
+    def _nextStatementIsAtRule(self):
+        '''Return True if next statement in the buffer is an at-rule.
+
+        Just look for open brackets and see if there is an @ before that
+        braket.
+        '''
+        search_buffer = []
+        line_counter = self.line_number
+        current_line = self._text[line_counter][self.character_number:]
+        while current_line.find('@') == -1:
+            search_buffer.append(current_line)
+            line_counter += 1
+            try:
+                current_line = self._text[line_counter]
+            except IndexError:
+                return False
+
+        text_buffer = ''.join(search_buffer)
+        if text_buffer.find('{') == -1:
+            return True
+        else:
+            return False
+
+    def _parse(self, stop_character):
+        '''Return the parsed text until stop_character.'''
+        try:
+            self._text[self.line_number][self.character_number]
+        except IndexError:
+            raise StopIteration
+        result = []
+        start_line = self.line_number
+        start_character = self.character_number
+        comment_started = False
+        while True:
+            try:
+                data = self._text[self.line_number][self.character_number:]
+            except IndexError:
+                break
+
+            # Look for comment start/end.
+            (comment_update,
+            before_comment,
+            after_comment,
+            newline_consumed) = _check_comment(data)
+            if comment_update is not None:
+                comment_started = comment_update
+
+            if comment_started:
+                # We are inside a comment.
+                # Add the data before the comment and go to next line.
+                if before_comment is not None:
+                    result.append(before_comment)
+                self.character_number = 0
+                self.line_number += 1
+                continue
+
+            # If we have a comment, strip it from the data.
+            # Remember the initial cursor position to know where to
+            # continue.
+            initial_position = data.find(stop_character)
+            if before_comment is not None or after_comment is not None:
+                if before_comment is None:
+                    before_comment = ''
+                if after_comment is None:
+                    after_comment = ''
+                data = before_comment + after_comment
+
+            if initial_position == -1 or newline_consumed:
+                # We are not at the end.
+                # Go to next line and append the data.
+                result.append(data)
+                self.character_number = 0
+                self.line_number += 1
+                continue
+            else:
+                # Delimiter found.
+                # Find it again in the text that now has no comments.
+                # Append data until the delimiter.
+                # Move cursor to next character and stop searching for it.
+                new_position = data.find(stop_character)
+                result.append(data[:new_position])
+                self.character_number += initial_position + 1
+                break
+
+        return CSSStatementMember(
+            start_line=start_line,
+            start_character=start_character,
+            text=''.join(result))
+
+
+def _check_comment(data):
+    '''Check the data for comment markers.'''
+
+    comment_started = None
+    before_comment = None
+    after_comment = None
+    newline_consumed = False
+
+    comment_start = data.find(COMMENT_START)
+    if comment_start != -1:
+        comment_started = True
+        before_comment = data[:comment_start]
+        # Only use `None` to signal that there is no text before the comment.
+        if before_comment == '':
+            before_comment = None
+
+    comment_end = data.find(COMMENT_END)
+    if comment_end != -1:
+        comment_started = False
+        # Set comment end after the lenght of the actual comment end
+        # marker.
+        comment_end += len(COMMENT_END)
+        if before_comment is None and data[comment_end] == '\n':
+            # Consume the new line if it next to the comment end and
+            # the comment in on the whole line.
+            comment_end += 1
+            newline_consumed = True
+        after_comment = data[comment_end:]
+    return (comment_started, before_comment, after_comment, newline_consumed)
+
+
+def show_usage():
+    '''Print the command usage.'''
+    print 'Usage: cssccc OPTIONS'
+    print '  -h, --help\t\tShow this help.'
+    print '  -v, --version\t\tShow version.'
+    print '  -f FILE, --file=FILE\tCheck FILE'
+
+
+def read_file(filename):
+    '''Return the content of filename.'''
+    text = ''
+    with open(filename, 'r') as f:
+        text = f.read()
+    return text
+
+
+if __name__ == '__main__':
+    if len(sys.argv) < 2:
+        show_usage()
+    elif sys.argv[1] in ['-v', '--version']:
+        print 'CSS Code Convention Checker %s' % (__version__)
+        sys.exit(0)
+    elif sys.argv[1] == '-f':
+        text = read_file(sys.argv[2])
+        checker = CSSCodingConventionChecker(text)
+        sys.exit(checker.check())
+    elif sys.argv[1] == '--file=':
+        text = read_file(sys.argv[1][len('--file='):])
+        checker = CSSCodingConventionChecker(text)
+        sys.exit(checker.check())
+    else:
+        show_usage()

=== modified file 'pocketlint/contrib/pep8.py'
--- pocketlint/contrib/pep8.py	2010-11-17 15:46:54 +0000
+++ pocketlint/contrib/pep8.py	2011-10-14 21:24:26 +0000
@@ -1,6 +1,6 @@
 #!/usr/bin/python
 # pep8.py - Check Python source code formatting, according to PEP 8
-# Copyright (C) 2006 Johann C. Rocholl <[e-mail]>
+# Copyright (C) 2006 Johann C. Rocholl <[e-mail]>
 #
 # Permission is hereby granted, free of charge, to any person
 # obtaining a copy of this software and associated documentation files
@@ -30,8 +30,7 @@
 $ python pep8.py -h
 
 This program and its regression test suite live here:
-http://svn.browsershots.org/trunk/devtools/pep8/
-http://trac.browsershots.org/browser/trunk/devtools/pep8/
+http://github.com/jcrocholl/pep8
 
 Groups of errors and warnings:
 E errors
@@ -79,33 +78,65 @@
 
 The docstring of each check function shall be the relevant part of
 text from PEP 8. It is printed if the user enables --show-pep8.
+Several docstrings contain examples directly from the PEP 8 document.
+
+Okay: spam(ham[1], {eggs: 2})
+E201: spam( ham[1], {eggs: 2})
+
+These examples are verified automatically when pep8.py is run with the
+--doctest option. You can add examples for your own check functions.
+The format is simple: "Okay" or error/warning code followed by colon
+and space, the rest of the line is example source code. If you put 'r'
+before the docstring, you can use \n for newline, \t for tab and \s
+for space.
 
 """
 
+__version__ = '0.5.1dev'
+
 import os
 import sys
 import re
 import time
 import inspect
+import keyword
 import tokenize
 from optparse import OptionParser
-from keyword import iskeyword
 from fnmatch import fnmatch
-
-__version__ = '0.2.0'
-__revision__ = '$Rev: 2208 $'
-
-default_exclude = '.svn,CVS,*.pyc,*.pyo'
-
-indent_match = re.compile(r'([ \t]*)').match
-raise_comma_match = re.compile(r'raise\s+\w+\s*(,)').match
-
-operators = """
-+  -  *  /  %  ^  &  |  =  <  >  >>  <<
-+= -= *= /= %= ^= &= |= == <= >= >>= <<=
-!= <> :
-in is or not and
-""".split()
+try:
+    frozenset
+except NameError:
+    from sets import ImmutableSet as frozenset
+
+
+DEFAULT_EXCLUDE = '.svn,CVS,.bzr,.hg,.git'
+DEFAULT_IGNORE = 'E24'
+MAX_LINE_LENGTH = 79
+
+INDENT_REGEX = re.compile(r'([ \t]*)')
+RAISE_COMMA_REGEX = re.compile(r'raise\s+\w+\s*(,)')
+SELFTEST_REGEX = re.compile(r'(Okay|[EW]\d{3}):\s(.*)')
+ERRORCODE_REGEX = re.compile(r'[EW]\d{3}')
+DOCSTRING_REGEX = re.compile(r'u?r?["\']')
+WHITESPACE_AROUND_OPERATOR_REGEX = \
+    re.compile('([^\w\s]*)\s*(\t|  )\s*([^\w\s]*)')
+EXTRANEOUS_WHITESPACE_REGEX = re.compile(r'[[({] | []}),;:]')
+WHITESPACE_AROUND_NAMED_PARAMETER_REGEX = \
+    re.compile(r'[()]|\s=[^=]|[^=!<>]=\s')
+
+
+WHITESPACE = ' \t'
+
+BINARY_OPERATORS = frozenset(['**=', '*=', '+=', '-=', '!=', '<>',
+    '%=', '^=', '&=', '|=', '==', '/=', '//=', '<=', '>=', '<<=', '>>=',
+    '%',  '^',  '&',  '|',  '=',  '/',  '//',  '<',  '>',  '<<'])
+UNARY_OPERATORS = frozenset(['>>', '**', '*', '+', '-'])
+OPERATORS = BINARY_OPERATORS | UNARY_OPERATORS
+SKIP_TOKENS = frozenset([tokenize.COMMENT, tokenize.NL, tokenize.INDENT,
+                         tokenize.DEDENT, tokenize.NEWLINE])
+E225NOT_KEYWORDS = (frozenset(keyword.kwlist + ['print']) -
+                    frozenset(['False', 'None', 'True']))
+BENCHMARK_KEYS = ('directories', 'files', 'logical lines', 'physical lines')
 
 options = None
 args = None
@@ -117,7 +148,7 @@
 
 
 def tabs_or_spaces(physical_line, indent_char):
-    """
+    r"""
     Never mix tabs and spaces.
 
     The most popular way of indenting Python is with spaces only.  The
@@ -126,38 +157,65 @@
     invoking the Python command line interpreter with the -t option, it issues
     warnings about code that illegally mixes tabs and spaces.  When using -tt
     these warnings become errors.  These options are highly recommended!
+
+    Okay: if a == 0:\n        a = 1\n        b = 1
+    E101: if a == 0:\n        a = 1\n\tb = 1
     """
-    indent = indent_match(physical_line).group(1)
+    indent = INDENT_REGEX.match(physical_line).group(1)
     for offset, char in enumerate(indent):
         if char != indent_char:
             return offset, "E101 indentation contains mixed spaces and tabs"
 
 
 def tabs_obsolete(physical_line):
-    """
+    r"""
     For new projects, spaces-only are strongly recommended over tabs.  Most
     editors have features that make this easy to do.
+
+    Okay: if True:\n    return
+    W191: if True:\n\treturn
     """
-    indent = indent_match(physical_line).group(1)
+    indent = INDENT_REGEX.match(physical_line).group(1)
     if indent.count('\t'):
         return indent.index('\t'), "W191 indentation contains tabs"
 
 
 def trailing_whitespace(physical_line):
-    """
+    r"""
     JCR: Trailing whitespace is superfluous.
+    FBM: Except when it occurs as part of a blank line (i.e. the line is
+         nothing but whitespace). According to Python docs[1] a line with only
+         whitespace is considered a blank line, and is to be ignored. However,
+         matching a blank line to its indentation level avoids mistakenly
+         terminating a multi-line statement (e.g. class declaration) when
+         pasting code into the standard Python interpreter.
+
+         [1] http://docs.python.org/reference/lexical_analysis.html#blank-lines
+
+    The warning returned varies on whether the line itself is blank, for easier
+    filtering for those who want to indent their blank lines.
+
+    Okay: spam(1)
+    W291: spam(1)\s
+    W293: class Foo(object):\n    \n    bang = 12
     """
-    physical_line = physical_line.rstrip('\n') # chr(10), newline
-    physical_line = physical_line.rstrip('\r') # chr(13), carriage return
-    physical_line = physical_line.rstrip('\x0c') # chr(12), form feed, ^L
+    physical_line = physical_line.rstrip('\n')    # chr(10), newline
+    physical_line = physical_line.rstrip('\r')    # chr(13), carriage return
+    physical_line = physical_line.rstrip('\x0c')  # chr(12), form feed, ^L
     stripped = physical_line.rstrip()
     if physical_line != stripped:
-        return len(stripped), "W291 trailing whitespace"
+        if stripped:
+            return len(stripped), "W291 trailing whitespace"
+        else:
+            return 0, "W293 blank line contains whitespace"
 
 
 def trailing_blank_lines(physical_line, lines, line_number):
-    """
+    r"""
     JCR: Trailing blank lines are superfluous.
+
+    Okay: spam(1)
+    W391: spam(1)\n
     """
     if physical_line.strip() == '' and line_number == len(lines):
         return 0, "W391 blank line at end of file"
@@ -182,9 +240,18 @@
     For flowing long blocks of text (docstrings or comments), limiting the
     length to 72 characters is recommended.
     """
-    length = len(physical_line.rstrip())
-    if length > 79:
-        return 79, "E501 line too long (%d characters)" % length
+    line = physical_line.rstrip()
+    length = len(line)
+    if length > MAX_LINE_LENGTH:
+        try:
+            # The line could contain multi-byte characters
+            if not hasattr(line, 'decode'):   # Python 3
+                line = line.encode('latin-1')
+            length = len(line.decode('utf-8'))
+        except UnicodeDecodeError:
+            pass
+    if length > MAX_LINE_LENGTH:
+        return MAX_LINE_LENGTH, "E501 line too long (%d characters)" % length
 
 
 ##############################################################################
@@ -193,8 +260,9 @@
 
 
 def blank_lines(logical_line, blank_lines, indent_level, line_number,
-                previous_logical):
-    """
+                previous_logical, previous_indent_level,
+                blank_lines_before_comment):
+    r"""
     Separate top-level function and class definitions with two blank lines.
 
     Method definitions inside a class are separated by a single blank line.
@@ -204,20 +272,33 @@
     one-liners (e.g. a set of dummy implementations).
 
     Use blank lines in functions, sparingly, to indicate logical sections.
+
+    Okay: def a():\n    pass\n\n\ndef b():\n    pass
+    Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
+
+    E301: class Foo:\n    b = 0\n    def bar():\n        pass
+    E302: def a():\n    pass\n\ndef b(n):\n    pass
+    E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
+    E303: def a():\n\n\n\n    pass
+    E304: @decorator\n\ndef a():\n    pass
     """
     if line_number == 1:
-        return # Don't expect blank lines before the first line
+        return  # Don't expect blank lines before the first line
+    max_blank_lines = max(blank_lines, blank_lines_before_comment)
     if previous_logical.startswith('@'):
-        return # Don't expect blank lines after function decorator
-    if (logical_line.startswith('def ') or
-        logical_line.startswith('class ') or
-        logical_line.startswith('@')):
-        if indent_level > 0 and blank_lines != 1:
-            return 0, "E301 expected 1 blank line, found %d" % blank_lines
-        if indent_level == 0 and blank_lines != 2:
-            return 0, "E302 expected 2 blank lines, found %d" % blank_lines
-    if blank_lines > 2:
-        return 0, "E303 too many blank lines (%d)" % blank_lines
+        if max_blank_lines:
+            return 0, "E304 blank lines found after function decorator"
+    elif max_blank_lines > 2 or (indent_level and max_blank_lines == 2):
+        return 0, "E303 too many blank lines (%d)" % max_blank_lines
+    elif (logical_line.startswith('def ') or
+          logical_line.startswith('class ') or
+          logical_line.startswith('@')):
+        if indent_level:
+            if not (max_blank_lines or previous_indent_level < indent_level or
+                    DOCSTRING_REGEX.match(previous_logical)):
+                return 0, "E301 expected 1 blank line, found 0"
+        elif max_blank_lines != 2:
+            return 0, "E302 expected 2 blank lines, found %d" % max_blank_lines
 
 
 def extraneous_whitespace(logical_line):
@@ -227,45 +308,75 @@
     - Immediately inside parentheses, brackets or braces.
 
     - Immediately before a comma, semicolon, or colon.
+
+    Okay: spam(ham[1], {eggs: 2})
+    E201: spam( ham[1], {eggs: 2})
+    E201: spam(ham[ 1], {eggs: 2})
+    E201: spam(ham[1], { eggs: 2})
+    E202: spam(ham[1], {eggs: 2} )
+    E202: spam(ham[1 ], {eggs: 2})
+    E202: spam(ham[1], {eggs: 2 })
+
+    E203: if x == 4: print x, y; x, y = y , x
+    E203: if x == 4: print x, y ; x, y = y, x
+    E203: if x == 4 : print x, y; x, y = y, x
     """
     line = logical_line
-    for char in '([{':
-        found = line.find(char + ' ')
-        if found > -1:
+    for match in EXTRANEOUS_WHITESPACE_REGEX.finditer(line):
+        text = match.group()
+        char = text.strip()
+        found = match.start()
+        if text == char + ' ' and char in '([{':
             return found + 1, "E201 whitespace after '%s'" % char
-    for char in '}])':
-        found = line.find(' ' + char)
-        if found > -1 and line[found - 1] != ',':
-            return found, "E202 whitespace before '%s'" % char
-    for char in ',;:':
-        found = line.find(' ' + char)
-        if found > -1:
-            return found, "E203 whitespace before '%s'" % char
+        if text == ' ' + char and line[found - 1] != ',':
+            if char in '}])':
+                return found, "E202 whitespace before '%s'" % char
+            if char in ',;:':
+                return found, "E203 whitespace before '%s'" % char
 
 
 def missing_whitespace(logical_line):
     """
     JCR: Each comma, semicolon or colon should be followed by whitespace.
+
+    Okay: [a, b]
+    Okay: (3,)
+    Okay: a[1:4]
+    Okay: a[:4]
+    Okay: a[1:]
+    Okay: a[1:4:2]
+    E231: ['a','b']
+    E231: foo(bar,baz)
     """
     line = logical_line
     for index in range(len(line) - 1):
         char = line[index]
-        if char in ',;:' and line[index + 1] != ' ':
+        if char in ',;:' and line[index + 1] not in WHITESPACE:
             before = line[:index]
             if char == ':' and before.count('[') > before.count(']'):
-                continue # Slice syntax, no space required
+                continue  # Slice syntax, no space required
             if char == ',' and line[index + 1] == ')':
-                continue # Singleton tuple syntax, no space required
+                continue  # Allow tuple with only one element: (3,)
             return index, "E231 missing whitespace after '%s'" % char
 
 
 def indentation(logical_line, previous_logical, indent_char,
                 indent_level, previous_indent_level):
-    """
+    r"""
     Use 4 spaces per indentation level.
 
     For really old code that you don't want to mess up, you can continue to
     use 8-space tabs.
+
+    Okay: a = 1
+    Okay: if a == 0:\n    a = 1
+    E111:   a = 1
+
+    Okay: for item in items:\n    pass
+    E112: for item in items:\npass
+
+    Okay: a = 1\nb = 2
+    E113: a = 1\n    b = 2
     """
     if indent_char == ' ' and indent_level % 4:
         return 0, "E111 indentation is not a multiple of four"
@@ -285,6 +396,13 @@
 
     - Immediately before the open parenthesis that starts an indexing or
       slicing.
+
+    Okay: spam(1)
+    E211: spam (1)
+
+    Okay: dict['key'] = list[index]
+    E211: dict ['key'] = list[index]
+    E211: dict['key'] = list [index]
     """
     prev_type = tokens[0][0]
     prev_text = tokens[0][1]
@@ -294,9 +412,11 @@
         if (token_type == tokenize.OP and
             text in '([' and
             start != prev_end and
-            prev_type == tokenize.NAME and
+            (prev_type == tokenize.NAME or prev_text in '}])') and
+            # Syntax "class A (B):" is allowed, but avoid it
             (index < 2 or tokens[index - 2][1] != 'class') and
-            (not iskeyword(prev_text))):
+            # Allow "return (a.foo for a in range(5))"
+            (not keyword.iskeyword(prev_text))):
             return prev_end, "E211 whitespace before '%s'" % text
         prev_type = token_type
         prev_text = text
@@ -309,21 +429,97 @@
 
     - More than one space around an assignment (or other) operator to
       align it with another.
-    """
-    line = logical_line
-    for operator in operators:
-        found = line.find('  ' + operator)
-        if found > -1:
-            return found, "E221 multiple spaces before operator"
-        found = line.find(operator + '  ')
-        if found > -1:
-            return found, "E222 multiple spaces after operator"
-        found = line.find('\t' + operator)
-        if found > -1:
-            return found, "E223 tab before operator"
-        found = line.find(operator + '\t')
-        if found > -1:
-            return found, "E224 tab after operator"
+
+    Okay: a = 12 + 3
+    E221: a = 4  + 5
+    E222: a = 4 +  5
+    E223: a = 4\t+ 5
+    E224: a = 4 +\t5
+    """
+    for match in WHITESPACE_AROUND_OPERATOR_REGEX.finditer(logical_line):
+        before, whitespace, after = match.groups()
+        tab = whitespace == '\t'
+        offset = match.start(2)
+        if before in OPERATORS:
+            return offset, (tab and "E224 tab after operator" or
+                            "E222 multiple spaces after operator")
+        elif after in OPERATORS:
+            return offset, (tab and "E223 tab before operator" or
+                            "E221 multiple spaces before operator")
+
+
+def missing_whitespace_around_operator(logical_line, tokens):
+    r"""
+    - Always surround these binary operators with a single space on
+      either side: assignment (=), augmented assignment (+=, -= etc.),
+      comparisons (==, <, >, !=, <>, <=, >=, in, not in, is, is not),
+      Booleans (and, or, not).
+
+    - Use spaces around arithmetic operators.
+
+    Okay: i = i + 1
+    Okay: submitted += 1
+    Okay: x = x * 2 - 1
+    Okay: hypot2 = x * x + y * y
+    Okay: c = (a + b) * (a - b)
+    Okay: foo(bar, key='word', *args, **kwargs)
+    Okay: baz(**kwargs)
+    Okay: negative = -1
+    Okay: spam(-1)
+    Okay: alpha[:-i]
+    Okay: if not -5 < x < +5:\n    pass
+    Okay: lambda *args, **kw: (args, kw)
+
+    E225: i=i+1
+    E225: submitted +=1
+    E225: x = x*2 - 1
+    E225: hypot2 = x*x + y*y
+    E225: c = (a+b) * (a-b)
+    E225: c = alpha -4
+    E225: z = x **y
+    """
+    parens = 0
+    need_space = False
+    prev_type = tokenize.OP
+    prev_text = prev_end = None
+    for token_type, text, start, end, line in tokens:
+        if token_type in (tokenize.NL, tokenize.NEWLINE, tokenize.ERRORTOKEN):
+            # ERRORTOKEN is triggered by backticks in Python 3000
+            continue
+        if text in ('(', 'lambda'):
+            parens += 1
+        elif text == ')':
+            parens -= 1
+        if need_space:
+            if start != prev_end:
+                need_space = False
+            elif text == '>' and prev_text == '<':
+                # Tolerate the "<>" operator, even if running Python 3
+                pass
+            else:
+                return prev_end, "E225 missing whitespace around operator"
+        elif token_type == tokenize.OP and prev_end is not None:
+            if text == '=' and parens:
+                # Allow keyword args or defaults: foo(bar=None).
+                pass
+            elif text in BINARY_OPERATORS:
+                need_space = True
+            elif text in UNARY_OPERATORS:
+                # Allow unary operators: -123, -x, +1.
+                # Allow argument unpacking: foo(*args, **kwargs).
+                if prev_type == tokenize.OP:
+                    if prev_text in '}])':
+                        need_space = True
+                elif prev_type == tokenize.NAME:
+                    if prev_text not in E225NOT_KEYWORDS:
+                        need_space = True
+                else:
+                    need_space = True
+            if need_space and start == prev_end:
+                return prev_end, "E225 missing whitespace around operator"
+        prev_type = token_type
+        prev_text = text
+        prev_end = end
 
 
 def whitespace_around_comma(logical_line):
@@ -334,6 +530,11 @@
       align it with another.
 
     JCR: This should also be applied around comma etc.
+    Note: these checks are disabled by default
+
+    Okay: a = (1, 2)
+    E241: a = (1,  2)
+    E242: a = (1,\t2)
     """
     line = logical_line
     for separator in ',;:':
@@ -345,9 +546,77 @@
             return found + 1, "E242 tab after '%s'" % separator
 
 
+def whitespace_around_named_parameter_equals(logical_line):
+    """
+    Don't use spaces around the '=' sign when used to indicate a
+    keyword argument or a default parameter value.
+
+    Okay: def complex(real, imag=0.0):
+    Okay: return magic(r=real, i=imag)
+    Okay: boolean(a == b)
+    Okay: boolean(a != b)
+    Okay: boolean(a <= b)
+    Okay: boolean(a >= b)
+
+    E251: def complex(real, imag = 0.0):
+    E251: return magic(r = real, i = imag)
+    """
+    parens = 0
+    for match in WHITESPACE_AROUND_NAMED_PARAMETER_REGEX.finditer(
+            logical_line):
+        text = match.group()
+        if parens and len(text) == 3:
+            issue = "E251 no spaces around keyword / parameter equals"
+            return match.start(), issue
+        if text == '(':
+            parens += 1
+        elif text == ')':
+            parens -= 1
+
+
+def whitespace_before_inline_comment(logical_line, tokens):
+    """
+    Separate inline comments by at least two spaces.
+
+    An inline comment is a comment on the same line as a statement.  Inline
+    comments should be separated by at least two spaces from the statement.
+    They should start with a # and a single space.
+
+    Okay: x = x + 1  # Increment x
+    Okay: x = x + 1    # Increment x
+    E261: x = x + 1 # Increment x
+    E262: x = x + 1  #Increment x
+    E262: x = x + 1  #  Increment x
+    """
+    prev_end = (0, 0)
+    for token_type, text, start, end, line in tokens:
+        if token_type == tokenize.NL:
+            continue
+        if token_type == tokenize.COMMENT:
+            if not line[:start[1]].strip():
+                continue
+            if prev_end[0] == start[0] and start[1] < prev_end[1] + 2:
+                return (prev_end,
+                        "E261 at least two spaces before inline comment")
+            if (len(text) > 1 and text.startswith('#  ')
+                           or not text.startswith('# ')):
+                return start, "E262 inline comment should start with '# '"
+        else:
+            prev_end = end
+
+
 def imports_on_separate_lines(logical_line):
-    """
+    r"""
     Imports should usually be on separate lines.
+
+    Okay: import os\nimport sys
+    E401: import sys, os
+
+    Okay: from subprocess import Popen, PIPE
+    Okay: from myclas import MyClass
+    Okay: from foo.bar.yourclass import YourClass
+    Okay: import myclass
+    Okay: import foo.bar.yourclass
     """
     line = logical_line
     if line.startswith('import '):
@@ -357,17 +626,37 @@
 
 
 def compound_statements(logical_line):
-    """
+    r"""
     Compound statements (multiple statements on the same line) are
     generally discouraged.
+
+    While sometimes it's okay to put an if/for/while with a small body
+    on the same line, never do this for multi-clause statements. Also
+    avoid folding such long lines!
+
+    Okay: if foo == 'blah':\n    do_blah_thing()
+    Okay: do_one()
+    Okay: do_two()
+    Okay: do_three()
+
+    E701: if foo == 'blah': do_blah_thing()
+    E701: for x in lst: total += x
+    E701: while t < 10: t = delay()
+    E701: if foo == 'blah': do_blah_thing()
+    E701: else: do_non_blah_thing()
+    E701: try: something()
+    E701: finally: cleanup()
+    E701: if foo == 'blah': one(); two(); three()
+
+    E702: do_one(); do_two(); do_three()
     """
     line = logical_line
     found = line.find(':')
     if -1 < found < len(line) - 1:
         before = line[:found]
-        if (before.count('{') <= before.count('}') and # {'a': 1} (dict)
-            before.count('[') <= before.count(']') and # [1:2] (slice)
-            not re.search(r'\blambda\b', before)):     # lambda x: x
+        if (before.count('{') <= before.count('}') and  # {'a': 1} (dict)
+            before.count('[') <= before.count(']') and  # [1:2] (slice)
+            not re.search(r'\blambda\b', before)):      # lambda x: x
             return found, "E701 multiple statements on one line (colon)"
     found = line.find(';')
     if -1 < found:
@@ -397,16 +686,49 @@
     continuation characters thanks to the containing parentheses.  The older
     form will be removed in Python 3000.
     """
-    match = raise_comma_match(logical_line)
+    match = RAISE_COMMA_REGEX.match(logical_line)
     if match:
         return match.start(1), "W602 deprecated form of raising exception"
 
 
+def python_3000_not_equal(logical_line):
+    """
+    != can also be written <>, but this is an obsolete usage kept for
+    backwards compatibility only. New code should always use !=.
+    The older syntax is removed in Python 3000.
+    """
+    pos = logical_line.find('<>')
+    if pos > -1:
+        return pos, "W603 '<>' is deprecated, use '!='"
+
+
+def python_3000_backticks(logical_line):
+    """
+    Backticks are removed in Python 3000.
+    Use repr() instead.
+    """
+    pos = logical_line.find('`')
+    if pos > -1:
+        return pos, "W604 backticks are deprecated, use 'repr()'"
+
+
 ##############################################################################
 # Helper functions
 ##############################################################################
 
 
+if '' == ''.encode():
+    # Python 2: implicit encoding.
+    def readlines(filename):
+        return open(filename).readlines()
+else:
+    # Python 3: decode to latin-1.
+    # This function is lazy, it does not read the encoding declaration.
+    # XXX: use tokenize.detect_encoding()
+    def readlines(filename):
+        return open(filename, encoding='latin-1').readlines()
+
+
 def expand_indent(line):
     """
     Return the amount of indentation.
@@ -426,7 +748,7 @@
     result = 0
     for char in line:
         if char == '\t':
-            result = result / 8 * 8 + 8
+            result = result // 8 * 8 + 8
         elif char == ' ':
             result += 1
         else:
@@ -434,34 +756,6 @@
     return result
 
 
-##############################################################################
-# Framework to run all checks
-##############################################################################
-
-
-def message(text):
-    """Print a message."""
-    # print >> sys.stderr, options.prog + ': ' + text
-    # print >> sys.stderr, text
-    print text
-
-
-def find_checks(argument_name):
-    """
-    Find all globally visible functions where the first argument name
-    starts with argument_name.
-    """
-    checks = []
-    function_type = type(find_checks)
-    for name, function in globals().iteritems():
-        if type(function) is function_type:
-            args = inspect.getargspec(function)[0]
-            if len(args) >= 1 and args[0].startswith(argument_name):
-                checks.append((name, function, args))
-    checks.sort()
-    return checks
-
-
 def mute_string(text):
     """
     Replace contents with 'xxx' to prevent syntax matching.
@@ -487,18 +781,53 @@
     return text[:start] + 'x' * (end - start) + text[end:]
 
 
-class Checker:
+def message(text):
+    """Print a message."""
+    # print >> sys.stderr, options.prog + ': ' + text
+    # print >> sys.stderr, text
+    print(text)
+
+
+##############################################################################
+# Framework to run all checks
+##############################################################################
+
+
+def find_checks(argument_name):
+    """
+    Find all globally visible functions where the first argument name
+    starts with argument_name.
+    """
+    checks = []
+    for name, function in globals().items():
+        if not inspect.isfunction(function):
+            continue
+        args = inspect.getargspec(function)[0]
+        if args and args[0].startswith(argument_name):
+            codes = ERRORCODE_REGEX.findall(inspect.getdoc(function) or '')
+            for code in codes or ['']:
+                if not code or not ignore_code(code):
+                    checks.append((name, function, args))
+                    break
+    checks.sort()
+    return checks
+
+
+class Checker(object):
     """
     Load a Python source file, tokenize it, check coding style.
     """
 
-    def __init__(self, filename):
+    def __init__(self, filename, lines=None):
         self.filename = filename
-        self.lines = file(filename).readlines()
-        self.physical_checks = find_checks('physical_line')
-        self.logical_checks = find_checks('logical_line')
-        options.counters['physical lines'] = \
-            options.counters.get('physical lines', 0) + len(self.lines)
+        if filename is None:
+            self.filename = 'stdin'
+            self.lines = lines or []
+        elif lines is None:
+            self.lines = readlines(filename)
+        else:
+            self.lines = lines
+        options.counters['physical lines'] += len(self.lines)
 
     def readline(self):
         """
@@ -535,7 +864,7 @@
         self.physical_line = line
         if self.indent_char is None and len(line) and line[0] in ' \t':
             self.indent_char = line[0]
-        for name, check, argument_names in self.physical_checks:
+        for name, check, argument_names in options.physical_checks:
             result = self.run_check(check, argument_names)
             if result is not None:
                 offset, text = result
@@ -551,20 +880,20 @@
         previous = None
         for token in self.tokens:
             token_type, text = token[0:2]
-            if token_type in (tokenize.COMMENT, tokenize.NL,
-                              tokenize.INDENT, tokenize.DEDENT,
-                              tokenize.NEWLINE):
+            if token_type in SKIP_TOKENS:
                 continue
             if token_type == tokenize.STRING:
                 text = mute_string(text)
             if previous:
                 end_line, end = previous[3]
                 start_line, start = token[2]
-                if end_line != start_line: # different row
-                    if self.lines[end_line - 1][end - 1] not in '{[(':
+                if end_line != start_line:  # different row
+                    prev_text = self.lines[end_line - 1][end - 1]
+                    if prev_text == ',' or (prev_text not in '{[('
+                                            and text not in '}])'):
                         logical.append(' ')
                         length += 1
-                elif end != start: # different column
+                elif end != start:  # different column
                     fill = self.lines[end_line - 1][end:start]
                     logical.append(fill)
                     length += len(fill)
@@ -580,22 +909,21 @@
         """
         Build a line from tokens and run all logical checks on it.
         """
-        options.counters['logical lines'] = \
-            options.counters.get('logical lines', 0) + 1
+        options.counters['logical lines'] += 1
         self.build_tokens_line()
         first_line = self.lines[self.mapping[0][1][2][0] - 1]
         indent = first_line[:self.mapping[0][1][2][1]]
         self.previous_indent_level = self.indent_level
         self.indent_level = expand_indent(indent)
         if options.verbose >= 2:
-            print self.logical_line[:80].rstrip()
-        for name, check, argument_names in self.logical_checks:
-            if options.verbose >= 3:
-                print '   ', name
+            print(self.logical_line[:80].rstrip())
+        for name, check, argument_names in options.logical_checks:
+            if options.verbose >= 4:
+                print('   ' + name)
             result = self.run_check(check, argument_names)
             if result is not None:
                 offset, text = result
-                if type(offset) is tuple:
+                if isinstance(offset, tuple):
                     original_number, original_offset = offset
                 else:
                     for token_offset, token in self.mapping:
@@ -607,20 +935,29 @@
                                   text, check)
         self.previous_logical = self.logical_line
 
-    def check_all(self):
+    def check_all(self, expected=None, line_offset=0):
         """
         Run all checks on the input file.
         """
+        self.expected = expected or ()
+        self.line_offset = line_offset
+        self.line_number = 0
         self.file_errors = 0
-        self.line_number = 0
         self.indent_char = None
         self.indent_level = 0
         self.previous_logical = ''
         self.blank_lines = 0
+        self.blank_lines_before_comment = 0
         self.tokens = []
         parens = 0
         for token in tokenize.generate_tokens(self.readline_check_physical):
-            # print tokenize.tok_name[token[0]], repr(token)
+            if options.verbose >= 3:
+                if token[2][0] == token[3][0]:
+                    pos = '[%s:%s]' % (token[2][1] or '', token[3][1])
+                else:
+                    pos = 'l.%s' % token[3][0]
+                print('l.%s\t%s\t%s\t%r' %
+                    (token[2][0], pos, tokenize.tok_name[token[0]], token[1]))
             self.tokens.append(token)
             token_type, text = token[0:2]
             if token_type == tokenize.OP and text in '([{':
@@ -630,40 +967,49 @@
             if token_type == tokenize.NEWLINE and not parens:
                 self.check_logical()
                 self.blank_lines = 0
+                self.blank_lines_before_comment = 0
                 self.tokens = []
             if token_type == tokenize.NL and not parens:
-                self.blank_lines += 1
+                if len(self.tokens) <= 1:
+                    # The physical line contains only this token.
+                    self.blank_lines += 1
                 self.tokens = []
             if token_type == tokenize.COMMENT:
                 source_line = token[4]
                 token_start = token[2][1]
                 if source_line[:token_start].strip() == '':
+                    self.blank_lines_before_comment = max(self.blank_lines,
+                        self.blank_lines_before_comment)
                     self.blank_lines = 0
+                if text.endswith('\n') and not parens:
+                    # The comment also ends a physical line.  This works around
+                    # Python < 2.6 behaviour, which does not generate NL after
+                    # a comment which is on a line by itself.
+                    self.tokens = []
         return self.file_errors
 
     def report_error(self, line_number, offset, text, check):
         """
         Report an error, according to options.
         """
+        code = text[:4]
+        if ignore_code(code):
+            return
         if options.quiet == 1 and not self.file_errors:
             message(self.filename)
+        if code in options.counters:
+            options.counters[code] += 1
+        else:
+            options.counters[code] = 1
+            options.messages[code] = text[5:]
+        if options.quiet or code in self.expected:
+            # Don't care about expected errors or warnings
+            return
         self.file_errors += 1
-        code = text[:4]
-        options.counters[code] = options.counters.get(code, 0) + 1
-        options.messages[code] = text[5:]
-        if options.quiet:
-            return
-        if options.testsuite:
-            base = os.path.basename(self.filename)[:4]
-            if base == code:
-                return
-            if base[0] == 'E' and code[0] == 'W':
-                return
-        if ignore_code(code):
-            return
         if options.counters[code] == 1 or options.repeat:
             message("%s:%s:%d: %s" %
-                    (self.filename, line_number, offset + 1, text))
+                    (self.filename, self.line_offset + line_number,
+                     offset + 1, text))
             if options.show_source:
                 line = self.lines[line_number - 1]
                 message(line.rstrip())
@@ -676,35 +1022,33 @@
     """
     Run all checks on a Python source file.
     """
-    if excluded(filename) or not filename_match(filename):
-        return {}
     if options.verbose:
         message('checking ' + filename)
-    options.counters['files'] = options.counters.get('files', 0) + 1
     errors = Checker(filename).check_all()
-    if options.testsuite and not errors:
-        message("%s: %s" % (filename, "no errors found"))
-
-
-def input_dir(dirname):
+
+
+def input_dir(dirname, runner=None):
     """
     Check all Python source files in this directory and all subdirectories.
     """
     dirname = dirname.rstrip('/')
     if excluded(dirname):
         return
+    if runner is None:
+        runner = input_file
     for root, dirs, files in os.walk(dirname):
         if options.verbose:
             message('directory ' + root)
-        options.counters['directories'] = \
-            options.counters.get('directories', 0) + 1
+        options.counters['directories'] += 1
         dirs.sort()
         for subdir in dirs:
             if excluded(subdir):
                 dirs.remove(subdir)
         files.sort()
         for filename in files:
-            input_file(os.path.join(root, filename))
+            if filename_match(filename) and not excluded(filename):
+                options.counters['files'] += 1
+                runner(os.path.join(root, filename))
 
 
 def excluded(filename):
@@ -733,12 +1077,23 @@
 def ignore_code(code):
     """
     Check if options.ignore contains a prefix of the error code.
+    If options.select contains a prefix of the error code, do not ignore it.
     """
+    for select in options.select:
+        if code.startswith(select):
+            return False
     for ignore in options.ignore:
         if code.startswith(ignore):
             return True
 
 
+def reset_counters():
+    for key in list(options.counters.keys()):
+        if key not in BENCHMARK_KEYS:
+            del options.counters[key]
+    options.messages = {}
+
+
 def get_error_statistics():
     """Get error statistics."""
     return get_statistics("E")
@@ -759,7 +1114,7 @@
     prefix='E4' matches all errors that have to do with imports
     """
     stats = []
-    keys = options.messages.keys()
+    keys = list(options.messages.keys())
     keys.sort()
     for key in keys:
         if key.startswith(prefix):
@@ -768,24 +1123,131 @@
     return stats
 
 
+def get_count(prefix=''):
+    """Return the total count of errors and warnings."""
+    keys = list(options.messages.keys())
+    count = 0
+    for key in keys:
+        if key.startswith(prefix):
+            count += options.counters[key]
+    return count
+
+
 def print_statistics(prefix=''):
     """Print overall statistics (number of errors and warnings)."""
     for line in get_statistics(prefix):
-        print line
+        print(line)
 
 
 def print_benchmark(elapsed):
     """
     Print benchmark numbers.
     """
-    print '%-7.2f %s' % (elapsed, 'seconds elapsed')
-    keys = ['directories', 'files',
-            'logical lines', 'physical lines']
-    for key in keys:
-        if key in options.counters:
-            print '%-7d %s per second (%d total)' % (
-                options.counters[key] / elapsed, key,
-                options.counters[key])
+    print('%-7.2f %s' % (elapsed, 'seconds elapsed'))
+    for key in BENCHMARK_KEYS:
+        print('%-7d %s per second (%d total)' % (
+            options.counters[key] / elapsed, key,
+            options.counters[key]))
+
+
+def run_tests(filename):
+    """
+    Run all the tests from a file.
+
+    A test file can provide many tests.  Each test starts with a declaration.
+    This declaration is a single line starting with '#:'.
+    It declares codes of expected failures, separated by spaces or 'Okay'
+    if no failure is expected.
+    If the file does not contain such declaration, it should pass all tests.
+    If the declaration is empty, following lines are not checked, until next
+    declaration.
+
+    Examples:
+
+     * Only E224 and W701 are expected:         #: E224 W701
+     * Following example is conform:            #: Okay
+     * Don't check these lines:                 #:
+    """
+    lines = readlines(filename) + ['#:\n']
+    line_offset = 0
+    codes = ['Okay']
+    testcase = []
+    for index, line in enumerate(lines):
+        if not line.startswith('#:'):
+            if codes:
+                # Collect the lines of the test case
+                testcase.append(line)
+            continue
+        if codes and index > 0:
+            label = '%s:%s:1' % (filename, line_offset + 1)
+            codes = [c for c in codes if c != 'Okay']
+            # Run the checker
+            errors = Checker(filename, testcase).check_all(codes, line_offset)
+            # Check if the expected errors were found
+            for code in codes:
+                if not options.counters.get(code):
+                    errors += 1
+                    message('%s: error %s not found' % (label, code))
+            if options.verbose and not errors:
+                message('%s: passed (%s)' % (label, ' '.join(codes)))
+            # Keep showing errors for multiple tests
+            reset_counters()
+        # output the real line numbers
+        line_offset = index
+        # configure the expected errors
+        codes = line.split()[1:]
+        # empty the test case buffer
+        del testcase[:]
+
+
+def selftest():
+    """
+    Test all check functions with test cases in docstrings.
+    """
+    count_passed = 0
+    count_failed = 0
+    checks = options.physical_checks + options.logical_checks
+    for name, check, argument_names in checks:
+        for line in check.__doc__.splitlines():
+            line = line.lstrip()
+            match = SELFTEST_REGEX.match(line)
+            if match is None:
+                continue
+            code, source = match.groups()
+            checker = Checker(None)
+            for part in source.split(r'\n'):
+                part = part.replace(r'\t', '\t')
+                part = part.replace(r'\s', ' ')
+                checker.lines.append(part + '\n')
+            options.quiet = 2
+            checker.check_all()
+            error = None
+            if code == 'Okay':
+                if len(options.counters) > len(BENCHMARK_KEYS):
+                    codes = [key for key in options.counters.keys()
+                             if key not in BENCHMARK_KEYS]
+                    error = "incorrectly found %s" % ', '.join(codes)
+            elif not options.counters.get(code):
+                error = "failed to find %s" % code
+            # Reset the counters
+            reset_counters()
+            if not error:
+                count_passed += 1
+            else:
+                count_failed += 1
+                if len(checker.lines) == 1:
+                    print("pep8.py: %s: %s" %
+                          (error, checker.lines[0].rstrip()))
+                else:
+                    print("pep8.py: %s:" % error)
+                    for line in checker.lines:
+                        print(line.rstrip())
+    if options.verbose:
+        print("%d passed and %d failed." % (count_passed, count_failed))
+        if count_failed:
+            print("Test failed.")
+        else:
+            print("Test passed.")
 
 
 def process_options(arglist=None):
@@ -793,26 +1255,36 @@
     Process options passed either via arglist or via command line args.
     """
     global options, args
-    usage = "%prog [options] input ..."
-    parser = OptionParser(usage)
+    parser = OptionParser(version=__version__,
+                          usage="%prog [options] input ...")
     parser.add_option('-v', '--verbose', default=0, action='count',
                       help="print status messages, or debug with -vv")
     parser.add_option('-q', '--quiet', default=0, action='count',
                       help="report only file names, or nothing with -qq")
-    parser.add_option('--exclude', metavar='patterns', default=default_exclude,
-                      help="skip matches (default %s)" % default_exclude)
-    parser.add_option('--filename', metavar='patterns',
-                      help="only check matching files (e.g. *.py)")
+    parser.add_option('-r', '--repeat', action='store_true',
+                      help="show all occurrences of the same error")
+    parser.add_option('--exclude', metavar='patterns', default=DEFAULT_EXCLUDE,
+                      help="exclude files or directories which match these "
+                        "comma separated patterns (default: %s)" %
+                        DEFAULT_EXCLUDE)
+    parser.add_option('--filename', metavar='patterns', default='*.py',
+                      help="when parsing directories, only check filenames "
+                        "matching these comma separated patterns (default: "
+                        "*.py)")
+    parser.add_option('--select', metavar='errors', default='',
+                      help="select errors and warnings (e.g. E,W6)")
     parser.add_option('--ignore', metavar='errors', default='',
                       help="skip errors and warnings (e.g. E4,W)")
-    parser.add_option('--repeat', action='store_true',
-                      help="show all occurrences of the same error")
     parser.add_option('--show-source', action='store_true',
                       help="show source code for each error")
     parser.add_option('--show-pep8', action='store_true',
                       help="show text of PEP 8 for each error")
     parser.add_option('--statistics', action='store_true',
                       help="count errors and warnings")
+    parser.add_option('--count', action='store_true',
+                      help="print total number of errors and warnings "
+                        "to standard error and set exit code to 1 if "
+                        "total is not null")
     parser.add_option('--benchmark', action='store_true',
                       help="measure processing speed")
     parser.add_option('--testsuite', metavar='dir',
@@ -822,7 +1294,7 @@
     options, args = parser.parse_args(arglist)
     if options.testsuite:
         args.append(options.testsuite)
-    if len(args) == 0:
+    if not args and not options.doctest:
         parser.error('input not specified')
     options.prog = os.path.basename(sys.argv[0])
     options.exclude = options.exclude.split(',')
@@ -830,13 +1302,25 @@
         options.exclude[index] = options.exclude[index].rstrip('/')
     if options.filename:
         options.filename = options.filename.split(',')
+    if options.select:
+        options.select = options.select.split(',')
+    else:
+        options.select = []
     if options.ignore:
         options.ignore = options.ignore.split(',')
-    else:
+    elif options.select:
+        # Ignore all checks which are not explicitly selected
+        options.ignore = ['']
+    elif options.testsuite or options.doctest:
+        # For doctest and testsuite, all checks are required
         options.ignore = []
-    options.counters = {}
+    else:
+        # The default choice: ignore controversial checks
+        options.ignore = DEFAULT_IGNORE.split(',')
+    options.physical_checks = find_checks('physical_line')
+    options.logical_checks = find_checks('logical_line')
+    options.counters = dict.fromkeys(BENCHMARK_KEYS, 0)
     options.messages = {}
-
     return options, args
 
 
@@ -847,18 +1331,29 @@
     options, args = process_options()
     if options.doctest:
         import doctest
-        return doctest.testmod()
+        doctest.testmod(verbose=options.verbose)
+        selftest()
+    if options.testsuite:
+        runner = run_tests
+    else:
+        runner = input_file
     start_time = time.time()
     for path in args:
         if os.path.isdir(path):
-            input_dir(path)
-        else:
-            input_file(path)
+            input_dir(path, runner=runner)
+        elif not excluded(path):
+            options.counters['files'] += 1
+            runner(path)
     elapsed = time.time() - start_time
     if options.statistics:
         print_statistics()
     if options.benchmark:
         print_benchmark(elapsed)
+    count = get_count()
+    if count:
+        if options.count:
+            sys.stderr.write(str(count) + '\n')
+        sys.exit(1)
 
 
 if __name__ == '__main__':

=== modified file 'pocketlint/formatcheck.py'
--- pocketlint/formatcheck.py	2011-04-15 13:37:44 +0000
+++ pocketlint/formatcheck.py	2011-10-14 21:24:26 +0000
@@ -3,10 +3,15 @@
 # This software is licensed under the MIT license (see the file COPYING).
 """Check for syntax and style problems."""
 
-from __future__ import with_statement
-
 __metaclass__ = type
 
+
+__all__ = [
+    'Reporter',
+    'UniversalChecker',
+    ]
+
+
 import compiler
 import htmlentitydefs
 import logging
@@ -31,26 +36,39 @@
 from formatdoctest import DoctestReviewer
 
 import contrib.pep8 as pep8
-from contrib.pyflakes.checker import Checker
+from contrib.cssccc import CSSCodingConventionChecker
+from contrib.pyflakes.checker import Checker as PyFlakesChecker
 try:
     import cssutils
     HAS_CSSUTILS = True
 except ImportError:
     HAS_CSSUTILS = False
 
-# Javascript checking is available if spider money's js is available.
-js = subprocess.Popen(
-    ['which', 'js'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-js_exec, ignore = js.communicate()
-if js.returncode != 0:
-    JS = None
-else:
-    JS = js_exec.strip()
-
-__all__ = [
-    'Reporter',
-    'UniversalChecker',
-    ]
+
+def find_exec(names):
+    """Return the name of a GI enabled JS interpreter."""
+    for name in names:
+        js = subprocess.Popen(
+            ['which', name], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        js_exec, ignore = js.communicate()
+        if js.returncode == 0:
+            return js_exec.strip()
+
+
+JS = find_exec(['gjs', 'seed'])
+
+
+class PocketLintPyFlakesChecker(PyFlakesChecker):
+    '''PocketLint checker for pyflakes.
+
+    This is here to work around some of the pyflakes problems.
+    '''
+
+    def NAME(self, node):
+        '''Locate name. Ignore WindowsErrors.'''
+        if node.name == 'WindowsError':
+            return
+        return super(PocketLintPyFlakesChecker, self).NAME(node)
 
 
 class Reporter:
@@ -65,10 +83,12 @@
             self.treestore = self.file_lines_view.get_model()
         self.piter = None
         self._last_file_name = None
+        self.call_count = 0
 
     def __call__(self, line_no, message, icon=None,
                  base_dir=None, file_name=None):
         """Report a message."""
+        self.call_count += 1
         if self.report_type == self.FILE_LINES:
             self._message_file_lines(
                 line_no, message, icon=icon,
@@ -117,6 +137,7 @@
     ZCML = object()
     DOCBOOK = object()
     LOG = object()
+    SQL = object()
 
     XML_LIKE = (XML, XSLT, HTML, ZPT, ZCML, DOCBOOK)
 
@@ -130,6 +151,7 @@
         'text/css': CSS,
         'text/html': HTML,
         'text/plain': TEXT,
+        'text/x-sql': SQL,
         'text/x-log': LOG,
         'application/javascript': JAVASCRIPT,
         'application/xml': XML,
@@ -285,6 +307,20 @@
             self.check_conflicts(line_no, line)
 
 
+class SQLChecker(BaseChecker, AnyTextMixin):
+    """Verify SQL style."""
+
+    def check(self):
+        """Call each line_method for each line in text."""
+        # Consider http://code.google.com/p/python-sqlparse/ to verify
+        # keywords and reformatting.
+        for line_no, line in enumerate(self.text.splitlines()):
+            line_no += 1
+            self.check_trailing_whitespace(line_no, line)
+            self.check_tab(line_no, line)
+            self.check_conflicts(line_no, line)
+
+
 class XMLChecker(BaseChecker, AnyTextMixin):
     """Check XML documents."""
 
@@ -312,7 +348,7 @@
                 start, end = match.span(0)
                 text = text[:start] + self.xhtml_doctype + text[end:]
         try:
-            root = ElementTree.parse(StringIO(text), parser)
+            ElementTree.parse(StringIO(text), parser)
         except (ExpatError, ParseError), error:
             if hasattr(error, 'code'):
                 error_message = ErrorString(error.code)
@@ -326,7 +362,7 @@
                     error_lineno = 0
             else:
                 error_message, location = str(error).rsplit(':')
-                error_lineno = int(location.split(',')[0].split()[1])- offset
+                error_lineno = int(location.split(',')[0].split()[1]) - offset
             self.message(error_lineno, error_message, icon='error')
         self.check_text()
 
@@ -378,7 +414,18 @@
 
     def check(self):
         """Check the syntax of the CSS code."""
-        if self.text == '' or not HAS_CSSUTILS:
+        if self.text == '':
+            return
+
+        self.check_cssutils()
+        self.check_text()
+        # CSS coding conventoins checks should go last since they rely
+        # on previous checks.
+        self.check_css_coding_conventions()
+
+    def check_cssutils(self):
+        """Check the CSS code by parsing it using CSSUtils module."""
+        if not HAS_CSSUTILS:
             return
         handler = CSSReporterHandler(self)
         log = logging.getLogger('pocket-lint')
@@ -387,7 +434,6 @@
             log=log, loglevel=logging.INFO, raiseExceptions=False)
         parser.parseString(self.text)
         log.removeHandler(handler)
-        self.check_text()
 
     def check_text(self):
         """Call each line_method for each line in text."""
@@ -398,22 +444,29 @@
             self.check_conflicts(line_no, line)
             self.check_tab(line_no, line)
 
+    def check_css_coding_conventions(self):
+        """Check the input using CSS Coding Convention checker."""
+        CSSCodingConventionChecker(self.text, logger=self.message).check()
+
 
 class PythonChecker(BaseChecker, AnyTextMixin):
     """Check python source code."""
 
+    # This regex is taken from PEP 0263.
+    encoding_pattern = re.compile("coding[:=]\s*([-\w.]+)")
+
     def __init__(self, file_path, text, reporter=None):
         super(PythonChecker, self).__init__(
             file_path, text, reporter=reporter)
-        self.is_utf8 = False
+        self.encoding = 'ascii'
 
     def check(self):
         """Check the syntax of the python code."""
         if self.text == '':
             return
+        self.check_text()
         self.check_flakes()
         self.check_pep8()
-        self.check_text()
 
     def check_flakes(self):
         """Check compilation and syntax."""
@@ -421,13 +474,12 @@
             tree = compiler.parse(self.text)
         except (SyntaxError, IndentationError), exc:
             line_no = exc.lineno or 0
-            offset = exc.offset or 0
             line = exc.text or ''
             explanation = 'Could not compile; %s' % exc.msg
             message = '%s: %s' % (explanation, line.strip())
             self.message(line_no, message, icon='error')
         else:
-            warnings = Checker(tree)
+            warnings = PocketLintPyFlakesChecker(tree)
             for warning in warnings.messages:
                 dummy, line_no, message = str(warning).split(':')
                 self.message(int(line_no), message.strip(), icon='error')
@@ -448,20 +500,24 @@
             except TokenError, er:
                 message, location = er.args
                 self.message(location[0], message, icon='error')
+            except IndentationError, er:
+                message, location = er.args
+                message = "%s: %s" % (message, location[3].strip())
+                self.message(location[1], message, icon='error')
         finally:
-            Checker.report_error = original_report_error
+            pep8.Checker.report_error = original_report_error
 
     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
-            if line_no in (1, 2) and '# -*- coding: utf-8 -*-' in line:
-                self.is_utf8 = True
+            if line_no in (1, 2):
+                match = self.encoding_pattern.search(line)
+                if match:
+                    self.encoding = match.group(1).lower()
             self.check_pdb(line_no, line)
             self.check_length(line_no, line)
-            self.check_trailing_whitespace(line_no, line)
             self.check_conflicts(line_no, line)
-            self.check_tab(line_no, line)
             self.check_ascii(line_no, line)
 
     def check_pdb(self, line_no, line):
@@ -473,10 +529,10 @@
 
     def check_ascii(self, line_no, line):
         """Check that the line is ascii."""
-        if self.is_utf8:
+        if self.encoding != 'ascii':
             return
         try:
-            ascii_line = line.encode('ascii')
+            line.encode('ascii')
         except UnicodeEncodeError, error:
             self.message(
                 line_no, 'Non-ascii characer at position %s.' % error.end,
@@ -494,7 +550,7 @@
         """Check the syntax of the javascript code."""
         if JS is None or self.text == '':
             return
-        args = [JS, '-f', self.FULLJSLINT, self.JSREPORTER, self.text]
+        args = [JS, self.JSREPORTER, self.FULLJSLINT, self.file_path]
         jslint = subprocess.Popen(
             args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         issues, errors = jslint.communicate()
@@ -502,7 +558,9 @@
         if issues:
             for issue in issues.splitlines():
                 line_no, char_no_, message = issue.split('::')
-                self.message(int(line_no), message, icon='error')
+                line_no = int(line_no)
+                line_no -= 1
+                self.message(line_no, message, icon='error')
         self.check_text()
 
     def check_text(self):
@@ -530,6 +588,7 @@
 def check_sources(sources, reporter=None):
     if reporter is None:
         reporter = Reporter(Reporter.CONSOLE)
+    reporter.call_count = 0
     for source in sources:
         file_path = os.path.normpath(source)
         if os.path.isdir(source) or not Language.is_editable(source):
@@ -540,6 +599,7 @@
         checker = UniversalChecker(
             file_path, text=text, language=language, reporter=reporter)
         checker.check()
+    return reporter.call_count
 
 
 def main(argv=None):
@@ -554,7 +614,7 @@
     if options.verbose:
         pass
     reporter = Reporter(Reporter.CONSOLE)
-    check_sources(sources, reporter)
+    return check_sources(sources, reporter)
 
 
 if __name__ == '__main__':

=== modified file 'pocketlint/jsreporter.js'
--- pocketlint/jsreporter.js	2011-04-15 13:37:44 +0000
+++ pocketlint/jsreporter.js	2011-10-14 21:24:26 +0000
@@ -1,44 +1,101 @@
-// Copyright (C) 2009-2010 - Curtis Hovey <sinzui.is at verizon.net>
+// Copyright (C) 2009-2011 - Curtis Hovey <sinzui.is at verizon.net>
 // This software is licensed under the MIT license (see the file COPYING).
 
+// Run like:
+// <seed|gjs> jsreporter.js <path/to/fulljslint.js> <path/file/to/lint.js>
+
+
+function get_seed() {
+    // Define a common global object like seed.
+    var argv = ['gjs', 'jsreporter.js'];
+    var i;
+    for (i = 0; i < ARGV.length; i++) {
+        argv.push(ARGV[i]);
+        }
+    return {
+        'print': print,
+        'argv': argv
+        };
+    }
+
+
+var Seed = Seed || get_seed();
+
+
+jslint_path = Seed.argv[2].substring(0, Seed.argv[2].lastIndexOf('/'));
+imports.searchPath.push(jslint_path);
+var JSLINT = imports.fulljslint.JSLINT;
+
+
+function get_file_content(file_path) {
+    // Return the content of the file.
+    var Gio = imports.gi.Gio;
+    var file = Gio.file_new_for_path(file_path);
+    var istream = file.read(null);
+    var dstream = new Gio.DataInputStream({base_stream: istream});
+    var content_and_count = dstream.read_upto("", -1, null);
+    istream.close(null);
+    dstream = null;
+    return content_and_count[0];
+    }
+
+
 function report_implied_names() {
     // Report about implied global names.
     var implied_names = [];
-    for (var name in JSLINT.implied) {
-        if (JSLINT.implied.hasOwnPropery(name)) {
-            implied_names.push(name);
+    var prop;
+    for (prop in JSLINT.implied) {
+        if (JSLINT.implied.hasOwnProperty(prop)) {
+            implied_names.push(prop);
             }
         }
     if (implied_names.length > 0) {
         implied_names.sort();
-        print('0::0::Implied globals:' + implied_names.join(', '));
+        return '0::0::Implied globals:' + implied_names.join(', ');
         }
+    return '';
     }
 
 
 function report_lint_errors() {
     // Report about lint errors.
-    for (var i = 0; i < JSLINT.errors.length; i++) {
+    var errors = [];
+    var i;
+    for (i = 0; i < JSLINT.errors.length; i++) {
         var error = JSLINT.errors[i];
         if (error === null) {
-            print('0::0::JSLINT had a fatal error.');
+            error = {
+                'line': -1,
+                'character': -1,
+                'reason': 'JSLINT had a fatal error.'
+                };
             }
         // Fix the line and character offset for editors.
         error.line += 1;
         error.character += 1;
-        print(error.line + '::' + error.character + '::' + error.reason);
+        errors.push(
+            [error.line, error.character, error.reason].join('::'));
         }
+    return errors.join('\n');
     }
 
 
-function main(source_script) {
+function lint_script() {
     // Lint the source and report errors.
-    var result = JSLINT(source_script);
+    var script = get_file_content(Seed.argv[3]);
+    var result = JSLINT(script);
     if (! result) {
-        report_lint_errors();
-        report_implied_names();
+        var issues = [];
+        errors = report_lint_errors();
+        if (errors) {
+            issues.push(errors);
+            }
+        implied = report_implied_names();
+        if (implied) {
+            issues.push(implied);
+            }
+        Seed.print(issues.join('\n'));
         }
     }
 
-
-main(arguments[0]);
+lint_script();

=== modified file 'setup.py' (properties changed: -x to +x)
--- setup.py	2011-04-16 15:32:48 +0000
+++ setup.py	2011-10-14 21:24:26 +0000
@@ -1,9 +1,26 @@
+import subprocess
+
 from distutils.core import setup
+from distutils.command.sdist import sdist
+
+
+class SignedSDistCommand(sdist):
+    """Sign the source archive with a detached signature."""
+
+    description = "Sign the source archive after it is generated."
+
+    def run(self):
+        sdist.run(self)
+        gpg_args = [
+            'gpg', '--armor', '--sign', '--detach-sig', self.archive_files[0]]
+        gpg = subprocess.Popen(
+            gpg_args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        gpg.communicate()
 
 setup(
     name="pocketlint",
     description="Pocket-lint a composite linter and style checker.",
-    version="0.5.13",
+    version="0.5.21",
     maintainer="Curtis C. Hovey",
     maintainer_email="[e-mail]",
     url="https://launchpad.net/pocket-lint",
@@ -17,4 +34,7 @@
         'pocketlint/contrib': ['fulljslint.js'],
         },
     scripts=['scripts/pocketlint'],
+    cmdclass={
+        'signed_sdist': SignedSDistCommand,
+        },
     )