Merge lp:~adiroiban/pocket-lint/pocket-lint-css-lint into lp:pocket-lint

[Curtis Hovey]

pocket lint should support checking CSS style.

[Adi Roiban (adiroiban)]

The test input texts are a bit cryptic.
Maybe I could put them as module constants and define them using multiline string... but then they will be far from the actual test.

Since they are not that long, I think that string concatenation on multiple lines could also solve this problem

So instead of

    text ='rule1{st1\n}\n@font-face {\n src: url("u\n u"); \n }\nr2{st2}'

It would be

    text = (
        'rule1{st1\n'
        '}\n'
        '@font-face {\n'
        ' src: url("u\n u"); \n'
        ' }\n'
        'r2{st2}')

[Curtis Hovey (sinzui)]

Your library and integration looks good, but test_css is broken. test_css is getting the cssccc errors too.

I think we should treat this like the PythonChecker class where check() calls seperate methods for pyflakes and pep8. Maybe CSSChecker.check() chouls call check_cssutils() and check_cssccc(). Then the two tests modules could be tested separately. What do you think?

I am a little concerned that cssccc raises an error for an indented final brace. I am happy to change the good_css to make that test pass for now. I would like cssccc to permit subordinate indentation for the final brace in the future

I would like to factor CSSUtils out in the future because I think a faster grammar checker could be written that emphasises the current and future standards. Your library could be extended to do this.

review: Needs Information (code)

[lp:~adiroiban/pocket-lint/pocket-lint-css-lint]

378. By Adi Roiban on 2011-04-18

Allow indented closing braces. Integrate tests.

[Adi Roiban (adiroiban)]

I know that the current code break the test suite.
I was not sure if such feature is wanted and this is why I did not invest more time into making the test_cssccc tests work together with test_ccc.

----

I am OK with changing it the code to not raise an error on the indented final brace.
This is also the way I prefer it... but from the blog post and readers comment I saw that this formatting is not that popular.

I was thinking to add these two ways of formatting last brace as options and users could decide their format... in a similar way that the opening brace is implemented.
So for pocket-lint you could chose your preferred format.

----

I am new to CSS world. In fact I also wrote this code as a pretext for learning more about CSS.
I am also new to CSSUtils and I don't know what are its weak points.
With a bit of feedback we could also tackler this issues.

-----

I have made some changes bases of what I understood from your comments.

Feel free to add any comments :)

Cheers

Here is the latest diff
----

=== modified file 'pocketlint/contrib/cssccc.py'
--- pocketlint/contrib/cssccc.py 2011-04-17 23:45:04 +0000
+++ pocketlint/contrib/cssccc.py 2011-04-18 01:41:02 +0000
@@ -42,6 +42,7 @@
  * add support for TAB as a separator / identation.
  * add support for @media
 '''
+from __future__ import with_statement

 __version__ = '0.1.0'

@@ -55,17 +56,26 @@
 AT_TEXT_RULES = ['import', 'charset', 'namespace']
 AT_BLOCK_RULES = ['page', 'font-face']
 # If you want
-# selector
+# selector,
+# selector2
 # {
 # property:
 # }
-#IGNORED_MESSAGES = ['I013']
+#IGNORED_MESSAGES = ['I013', 'I014']

 # If you want
+# selector,
 # selector {
 # property:
 # }
-IGNORED_MESSAGES = ['I005']
+#IGNORED_MESSAGES = ['I005', 'I014']
+
+# If you want
+# selector,
+# selector2 {
+# property:
+# }
+IGNORED_MESSAGES = ['I005', 'I006']

 class CSSRule(object):
@@ -218,6 +228,12 @@
                 '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):

=== modified file 'pocketlint/formatcheck.py'
--- pocketlint/formatcheck.py 2011-04-17 14:13:31 +0000
+++ pocketlint/formatcheck.py 2011-04-18 01:42:28 +0000
@@ -382,27 +382,37 @@
         if self.text == '':
             return

- if HAS_CSSUTILS:
- handler = CSSReporterHandler(self)
- log = logging.getLogger('pocket-lint')
- log.addHandler(handler)
- parser = cssutils.CSSParser(
- log=log, loglevel=logging.INFO, raiseExceptions=False)
- parser.parseString(self.text)
- log.removeHandler(handler)
-
+ 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."""...

[Curtis Hovey (sinzui)]

Thank you very much. I am merging this and building the package in the unstable PPA. If this proves to be reliable, I will copy it to stable and launchpad's ppa.

review: Approve (code)

[Adi Roiban (adiroiban)]

Hi,

Thanks for the merge.

I have added the unstable PPA and will report any problem... but I am not an hardcore CSS users/developers so I am not sure how much testing can I cover.

I will also look into the CSSUtils replacement part.
Right now I am monkey patching CSSUtils to recognize some of the CSS3 tags or browser specific tags and I would like to stop doing that :)

Cheers

=== added file 'pocketlint/contrib/cssccc.py'
--- pocketlint/contrib/cssccc.py	1970-01-01 00:00:00 +0000
+++ pocketlint/contrib/cssccc.py	2011-04-18 01:45:49 +0000
@@ -0,0 +1,492 @@
+'''
+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.0'
+
+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_check = _check_comment(data)
+            (comment_update,
+            before_comment,
+            after_comment,
+            newline_consumed) = comment_check
+            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]
+
+    comment_end = data.find(COMMENT_END)
+    if comment_end != -1:
+        comment_started = False
+        # 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/formatcheck.py'
--- pocketlint/formatcheck.py	2011-04-17 16:32:41 +0000
+++ pocketlint/formatcheck.py	2011-04-18 01:45:49 +0000
@@ -31,6 +31,7 @@
 from formatdoctest import DoctestReviewer
 
 import contrib.pep8 as pep8
+from contrib.cssccc import CSSCodingConventionChecker
 from contrib.pyflakes.checker import Checker
 try:
     import cssutils
@@ -396,7 +397,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')
@@ -405,7 +417,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."""
@@ -416,6 +427,10 @@
             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."""

=== modified file 'pocketlint/tests/test_css.py'
--- pocketlint/tests/test_css.py	2011-04-15 03:14:05 +0000
+++ pocketlint/tests/test_css.py	2011-04-18 01:45:49 +0000
@@ -41,7 +41,7 @@
         if not HAS_CSSUTILS:
             return
         checker = CSSChecker('bogus', ill_formed_property, self.reporter)
-        checker.check()
+        checker.check_cssutils()
         messages = [
             (3, "CSSValue: No match: 'CHAR', u':'"),
             (0, 'CSSStyleDeclaration: Syntax Error in Property: '
@@ -52,7 +52,7 @@
         if not HAS_CSSUTILS:
             return
         checker = CSSChecker('ballyhoo', invalid_value, self.reporter)
-        checker.check()
+        checker.check_cssutils()
         message = (
             'Invalid value for "CSS Color Module Level 3/CSS Level 2.1" '
             'property: speckled: color')

=== added file 'pocketlint/tests/test_cssccc.py'
--- pocketlint/tests/test_cssccc.py	1970-01-01 00:00:00 +0000
+++ pocketlint/tests/test_cssccc.py	2011-04-18 01:45:49 +0000
@@ -0,0 +1,529 @@
+'''Test module for cssccc'''
+
+from unittest import TestCase, main as unittest_main
+
+
+from pocketlint.contrib.cssccc import (
+     CSSCodingConventionChecker, CSSAtRule, CSSRuleSet, CSSStatementMember)
+
+
+class TestCSSCodingConventionChecker(TestCase):
+    '''Test for parsing the CSS text.'''
+
+    def test_getNextRule_start(self):
+        text = 'selector{}'
+        lint = CSSCodingConventionChecker(text)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSRuleSet.type)
+        self.assertEqual('selector', rule.selector.text)
+        self.assertEqual(0, rule.selector.start_line)
+        self.assertEqual(0, rule.selector.start_character)
+
+        text = '\nselector{}'
+        lint = CSSCodingConventionChecker(text)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSRuleSet.type)
+        self.assertEqual('\nselector', rule.selector.text)
+        self.assertEqual(0, rule.selector.start_line)
+        self.assertEqual(0, rule.selector.start_character)
+
+        text = '\n\nselector{}'
+        lint = CSSCodingConventionChecker(text)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSRuleSet.type)
+        self.assertEqual('\n\nselector', rule.selector.text)
+        self.assertEqual(0, rule.selector.start_line)
+        self.assertEqual(0, rule.selector.start_character)
+
+        text = 'selector\n{}'
+        lint = CSSCodingConventionChecker(text)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSRuleSet.type)
+        self.assertEqual('selector\n', rule.selector.text)
+        self.assertEqual(0, rule.selector.start_line)
+        self.assertEqual(0, rule.selector.start_character)
+
+        text = 'selector, {}'
+        lint = CSSCodingConventionChecker(text)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSRuleSet.type)
+        self.assertEqual('selector, ', rule.selector.text)
+        self.assertEqual(0, rule.selector.start_line)
+        self.assertEqual(0, rule.selector.start_character)
+
+    def test_getNextRule_content(self):
+        text = 'selector { content; }'
+        lint = CSSCodingConventionChecker(text)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSRuleSet.type)
+        self.assertEqual(' content; ', rule.declarations.text)
+        self.assertEqual(0, rule.declarations.start_line)
+        self.assertEqual(10, rule.declarations.start_character)
+
+        text = 'selector \n{\n content; }'
+        lint = CSSCodingConventionChecker(text)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSRuleSet.type)
+        self.assertEqual('\n content; ', rule.declarations.text)
+        self.assertEqual(1, rule.declarations.start_line)
+        self.assertEqual(1, rule.declarations.start_character)
+
+    def test_getNextRule_continue(self):
+        text = 'selector1\n { content1; }\n\nselector2\n{content2}\n'
+        lint = CSSCodingConventionChecker(text)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSRuleSet.type)
+        self.assertEqual('selector1\n ', rule.selector.text)
+        self.assertEqual(0, rule.selector.start_line)
+        self.assertEqual(0, rule.selector.start_character)
+        self.assertEqual(' content1; ', rule.declarations.text)
+        self.assertEqual(1, rule.declarations.start_line)
+        self.assertEqual(2, rule.declarations.start_character)
+
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSRuleSet.type)
+        self.assertEqual('\n\nselector2\n', rule.selector.text)
+        self.assertEqual(1, rule.selector.start_line)
+        self.assertEqual(14, rule.selector.start_character)
+        self.assertEqual('content2', rule.declarations.text)
+        self.assertEqual(4, rule.declarations.start_line)
+        self.assertEqual(1, rule.declarations.start_character)
+
+    def test_getNextRule_stop(self):
+        text ='rule1{st1\n}\n@font-face {\n src: url("u\n u"); \n }\nr2{st2}'
+        lint = CSSCodingConventionChecker(text)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSRuleSet.type)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSAtRule.type)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSRuleSet.type)
+        self.failUnlessRaises(StopIteration, lint.getNextRule)
+
+    def test_getNextRule_comment(self):
+        text = '\n\n/* c\nm*/\nsel\n{\ns/*com*/\ncont1;/*com*/\ncont2;}'
+        lint = CSSCodingConventionChecker(text)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSRuleSet.type)
+        self.assertEqual('\n\nsel\n', rule.selector.text)
+        self.assertEqual(0, rule.selector.start_line)
+        self.assertEqual(0, rule.selector.start_character)
+        self.assertEqual('\ns\ncont1;\ncont2;', rule.declarations.text)
+        self.assertEqual(5, rule.declarations.start_line)
+        self.assertEqual(1, rule.declarations.start_character)
+
+    def test_get_at_import_rule(self):
+        '''Test for @import url(/css/screen.css) screen, projection;'''
+        text ='rule1{st1\n}\n@import  url(somet) print, soment ;rule2{st2}'
+        lint = CSSCodingConventionChecker(text)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSRuleSet.type)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSAtRule.type)
+        self.assertTrue(rule.block is None)
+        self.assertEqual('import', rule.identifier)
+        self.assertEqual('\n@import ', rule.keyword.text)
+        self.assertEqual(1, rule.keyword.start_line)
+        self.assertEqual(1, rule.keyword.start_character)
+        self.assertEqual(' url(somet) print, soment ', rule.text.text)
+        self.assertEqual(2, rule.text.start_line)
+        self.assertEqual(8, rule.text.start_character)
+
+    def test_get_at_charset_rule(self):
+        '''Test for @charset "ISO-8859-15";'''
+        text ='rule1{st1\n}\n@charset  "utf" ;rule2{st2}'
+        lint = CSSCodingConventionChecker(text)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSRuleSet.type)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSAtRule.type)
+        self.assertTrue(rule.block is None)
+        self.assertEqual('charset', rule.identifier)
+        self.assertEqual('\n@charset ', rule.keyword.text)
+        self.assertEqual(1, rule.keyword.start_line)
+        self.assertEqual(1, rule.keyword.start_character)
+        self.assertEqual(' "utf" ', rule.text.text)
+        self.assertEqual(2, rule.text.start_line)
+        self.assertEqual(9, rule.text.start_character)
+
+    def test_get_at_namespace_rule(self):
+        '''Test for @namespace  foo  "http://foo" ;'''
+        text ='rule1{st1\n}@namespace  foo  "http://foo" ;rule2{st2}'
+        lint = CSSCodingConventionChecker(text)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSRuleSet.type)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSAtRule.type)
+        self.assertTrue(rule.block is None)
+        self.assertEqual('namespace', rule.identifier)
+        self.assertEqual('@namespace ', rule.keyword.text)
+        self.assertEqual(1, rule.keyword.start_line)
+        self.assertEqual(1, rule.keyword.start_character)
+        self.assertEqual(' foo  "http://foo" ', rule.text.text)
+        self.assertEqual(1, rule.text.start_line)
+        self.assertEqual(12, rule.text.start_character)
+
+    def test_get_at_page_rule(self):
+        '''Test for @page
+
+        @page :left {
+          margin-left: 5cm; /* left pages only */
+        }
+        '''
+        text ='rule1{st1\n}\n@page :left {\n  mar; /*com*/\n }\nrule2{st2}'
+        lint = CSSCodingConventionChecker(text)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSRuleSet.type)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSAtRule.type)
+        self.assertTrue(rule.text is None)
+        self.assertEqual('page', rule.identifier)
+        self.assertEqual('\n@page :left ', rule.keyword.text)
+        self.assertEqual(1, rule.keyword.start_line)
+        self.assertEqual(1, rule.keyword.start_character)
+        self.assertEqual('\n  mar; \n ', rule.block.text)
+        self.assertEqual(2, rule.block.start_line)
+        self.assertEqual(13, rule.block.start_character)
+
+    def test_get_at_font_face_rule(self):
+        '''Test for @font-face
+
+        @font-face {
+          font-family: "Example Font";
+          src: url("http://www.example.com
+              /fonts/example");
+        }
+        '''
+        text ='rule1{st1\n}\n@font-face {\n src: url("u\n u"); \n }\nr2{st2}'
+        lint = CSSCodingConventionChecker(text)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSRuleSet.type)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSAtRule.type)
+        self.assertTrue(rule.text is None)
+        self.assertEqual('font-face', rule.identifier)
+        self.assertEqual('\n@font-face ', rule.keyword.text)
+        self.assertEqual(1, rule.keyword.start_line)
+        self.assertEqual(1, rule.keyword.start_character)
+        self.assertEqual('\n src: url("u\n u"); \n ', rule.block.text)
+        self.assertEqual(2, rule.block.start_line)
+        self.assertEqual(12, rule.block.start_character)
+        rule = lint.getNextRule()
+        self.assertTrue(rule.type is CSSRuleSet.type)
+        self.failUnlessRaises(StopIteration, lint.getNextRule)
+
+
+class TestCSSStatementMember(TestCase):
+    '''Tests for CSSStatementMember.'''
+
+    def test_getStartLine(self):
+        statement = CSSStatementMember(0, 4, 'some')
+        self.assertEqual(1, statement.getStartLine())
+        statement = CSSStatementMember(3, 4, 'some')
+        self.assertEqual(4, statement.getStartLine())
+        statement = CSSStatementMember(3, 4, '\n\nsome')
+        self.assertEqual(6, statement.getStartLine())
+
+
+class TestLog(object):
+    '''Container for a test log.'''
+
+    def __init__(self, line_number, code, message):
+        self.line_number = line_number
+        self.code = code
+        self.message = message
+
+
+class RuleTesterBase(TestCase):
+    '''Base class for rule checkers.'''
+
+    ignored_messaged = []
+
+    def setUp(self):
+        self.logs = []
+
+    def log(self, line_number, code, message):
+        if code in self.ignored_messaged:
+            return
+        self.logs.append((line_number, code, message))
+
+    @property
+    def last_log(self):
+        (line_number, code, message) = self.logs.pop()
+        return TestLog(line_number, code, message)
+
+
+class RuleTesterConventionA(RuleTesterBase):
+    '''Class for convention A.
+
+    selector1,
+    selecter2
+    {
+        property1: value1;
+        property2: value2;
+    }
+    '''
+
+    ignored_messaged = ['I013', 'I014']
+
+
+class TestCSSRuleSetSelectorChecksA(RuleTesterConventionA):
+    '''Test coding conventions for selector from rule sets.'''
+
+    def test_valid_selector(self):
+
+        selector = CSSStatementMember(0, 0, 'something\n')
+        rule = CSSRuleSet(selector=selector, declarations=None, log=self.log)
+        rule.checkSelector()
+        self.assertEqual([], self.logs)
+
+        selector = CSSStatementMember(0, 0, '\nsomething\n')
+        rule = CSSRuleSet(selector=selector, declarations=None, log=self.log)
+        rule.checkSelector()
+        self.assertEqual([], self.logs)
+
+        selector = CSSStatementMember(1, 0, '\n\nsomething\n')
+        rule = CSSRuleSet(selector=selector, declarations=None, log=self.log)
+        rule.checkSelector()
+        self.assertEqual([], self.logs)
+
+        selector = CSSStatementMember(2, 0, '\n\nsomething,\nsomethi\n')
+        rule = CSSRuleSet(selector=selector, declarations=None, log=self.log)
+        rule.checkSelector()
+        self.assertEqual([], self.logs)
+
+        selector = CSSStatementMember(3, 0, '\n\nsom:some some,\n#somethi\n')
+        rule = CSSRuleSet(selector=selector, declarations=None, log=self.log)
+        rule.checkSelector()
+        self.assertEqual([], self.logs)
+
+    def test_I002(self):
+        selector = CSSStatementMember(2, 0, '\n\n\nsomething\n')
+        rule = CSSRuleSet(selector=selector, declarations=None, log=self.log)
+        rule.checkSelector()
+        last_log = self.last_log
+        self.assertEqual('I002', last_log.code)
+        self.assertEqual(6, last_log.line_number)
+
+        selector = CSSStatementMember(4, 0, '\n\n\n\nsomething\n')
+        rule = CSSRuleSet(selector=selector, declarations=None, log=self.log)
+        rule.checkSelector()
+        last_log = self.last_log
+        self.assertEqual('I002', last_log.code)
+        self.assertEqual(9, last_log.line_number)
+
+    def test_I003(self):
+        selector = CSSStatementMember(2, 0, '\nsomething\n')
+        rule = CSSRuleSet(selector=selector, declarations=None, log=self.log)
+        rule.checkSelector()
+        last_log = self.last_log
+        self.assertEqual('I003', last_log.code)
+        self.assertEqual(4, last_log.line_number)
+
+        selector = CSSStatementMember(2, 0, 'something\n')
+        rule = CSSRuleSet(selector=selector, declarations=None, log=self.log)
+        rule.checkSelector()
+        last_log = self.last_log
+        self.assertEqual('I003', last_log.code)
+        self.assertEqual(3, last_log.line_number)
+
+    def test_I004(self):
+        selector = CSSStatementMember(3, 0, '\n\nsomething, something\n')
+        rule = CSSRuleSet(selector=selector, declarations=None, log=self.log)
+        rule.checkSelector()
+        last_log = self.last_log
+        self.assertEqual('I004', last_log.code)
+        self.assertEqual(6, last_log.line_number)
+
+    def test_I005(self):
+        selector = CSSStatementMember(4, 0, '\nsomething,\nsomething')
+        rule = CSSRuleSet(selector=selector, declarations=None, log=self.log)
+        rule.checkSelector()
+        last_log = self.last_log
+        self.assertEqual('I005', last_log.code)
+        self.assertEqual(7, last_log.line_number)
+
+
+class TestCSSRuleSetDeclarationsChecksA(RuleTesterConventionA):
+    '''Test coding conventions for declarations from rule sets.'''
+
+    def test_valid_declarations(self):
+        stmt = CSSStatementMember(
+            0, 0, '\n    some: 3px;\n    other:\n        url();\n')
+        rule = CSSRuleSet(selector=None, declarations=stmt, log=self.log)
+        rule.checkDeclarations()
+        self.assertEqual([], self.logs)
+
+    def test_I006(self):
+        stmt = CSSStatementMember(
+            4, 0, '\n    some: 3px;\n    other: url();')
+        rule = CSSRuleSet(selector=None, declarations=stmt, log=self.log)
+        rule.checkDeclarations()
+        last_log = self.last_log
+        self.assertEqual('I006', last_log.code)
+        self.assertEqual(7, last_log.line_number)
+
+        stmt = CSSStatementMember(
+            4, 0, '\n    some: 3px;\n    other: url();\n ')
+        rule = CSSRuleSet(selector=None, declarations=stmt, log=self.log)
+        rule.checkDeclarations()
+        last_log = self.last_log
+        self.assertEqual('I006', last_log.code)
+        self.assertEqual(8, last_log.line_number)
+
+        stmt = CSSStatementMember(
+            4, 0, '\n    some: 3px;\n    other: url();\n\n ')
+        rule = CSSRuleSet(selector=None, declarations=stmt, log=self.log)
+        rule.checkDeclarations()
+        last_log = self.last_log
+        self.assertEqual('I006', last_log.code)
+        self.assertEqual(9, last_log.line_number)
+
+    def test_I007(self):
+        stmt = CSSStatementMember(
+            4, 0, '\n    some: 3px; other: url();\n')
+        rule = CSSRuleSet(selector=None, declarations=stmt, log=self.log)
+        rule.checkDeclarations()
+        last_log = self.last_log
+        self.assertEqual('I007', last_log.code)
+        self.assertEqual(6, last_log.line_number)
+
+    def test_I008(self):
+        stmt = CSSStatementMember(
+            0, 0, '\n    some: 3px;\n  other: url();\n')
+        rule = CSSRuleSet(selector=None, declarations=stmt, log=self.log)
+        rule.checkDeclarations()
+        self.assertEqual('I008', self.last_log.code)
+
+        stmt = CSSStatementMember(
+            0, 0, '\n    some: 3px;\n     other: url();\n')
+        rule = CSSRuleSet(selector=None, declarations=stmt, log=self.log)
+        rule.checkDeclarations()
+        self.assertEqual('I008', self.last_log.code)
+
+    def test_I009(self):
+        stmt = CSSStatementMember(
+            0, 0, '\n    some 3px;\n    other: url();\n')
+        rule = CSSRuleSet(selector=None, declarations=stmt, log=self.log)
+        rule.checkDeclarations()
+        self.assertEqual('I009', self.last_log.code)
+
+        stmt = CSSStatementMember(
+            0, 0, '\n    some: 3:px;\n    other: url();\n')
+        rule = CSSRuleSet(selector=None, declarations=stmt, log=self.log)
+        rule.checkDeclarations()
+        self.assertEqual('I009', self.last_log.code)
+
+    def test_I010(self):
+        stmt = CSSStatementMember(
+            0, 0, '\n    some : 3px;\n')
+        rule = CSSRuleSet(selector=None, declarations=stmt, log=self.log)
+        rule.checkDeclarations()
+        self.assertEqual('I010', self.last_log.code)
+
+    def test_I011(self):
+        stmt = CSSStatementMember(
+            0, 0, '\n    some:3px;\n')
+        rule = CSSRuleSet(selector=None, declarations=stmt, log=self.log)
+        rule.checkDeclarations()
+        self.assertEqual('I011', self.last_log.code)
+
+    def test_I012(self):
+        stmt = CSSStatementMember(
+            0, 0, '\n    some:  3px;\n')
+        rule = CSSRuleSet(selector=None, declarations=stmt, log=self.log)
+        rule.checkDeclarations()
+        self.assertEqual('I012', self.last_log.code)
+
+
+class RuleTesterConventionB(RuleTesterBase):
+    '''Class for convention B.
+
+    selector1,
+    selecter2 {
+        property1: value1;
+        property2: value2;
+    }
+    '''
+
+    ignored_messaged = ['I005', 'I014']
+
+
+class TestCSSRuleSetSelectorChecksB(RuleTesterConventionB):
+    '''Test coding conventions for selector from rule sets.'''
+
+    def test_valid_selector(self):
+
+        selector = CSSStatementMember(0, 0, 'something ')
+        rule = CSSRuleSet(selector=selector, declarations=None, log=self.log)
+        rule.checkSelector()
+        self.assertEqual([], self.logs)
+
+        selector = CSSStatementMember(0, 0, '\nsomething ')
+        rule = CSSRuleSet(selector=selector, declarations=None, log=self.log)
+        rule.checkSelector()
+        self.assertEqual([], self.logs)
+
+        selector = CSSStatementMember(1, 0, '\n\nsomething ')
+        rule = CSSRuleSet(selector=selector, declarations=None, log=self.log)
+        rule.checkSelector()
+        self.assertEqual([], self.logs)
+
+        selector = CSSStatementMember(2, 0, '\n\nsomething,\nsomethi ')
+        rule = CSSRuleSet(selector=selector, declarations=None, log=self.log)
+        rule.checkSelector()
+        self.assertEqual([], self.logs)
+
+        selector = CSSStatementMember(3, 0, '\n\nsom:some some,\n#somethi ')
+        rule = CSSRuleSet(selector=selector, declarations=None, log=self.log)
+        rule.checkSelector()
+        self.assertEqual([], self.logs)
+
+    def test_I013(self):
+        selector = CSSStatementMember(2, 0, '\n\nsomething\n')
+        rule = CSSRuleSet(selector=selector, declarations=None, log=self.log)
+        rule.checkSelector()
+        last_log = self.last_log
+        self.assertEqual('I013', last_log.code)
+        self.assertEqual(5, last_log.line_number)
+
+
+class RuleTesterConventionC(RuleTesterBase):
+    '''Class for convention C.
+
+    selector1,
+    selecter2 {
+        property1: value1;
+        property2: value2;
+        }
+    '''
+
+    ignored_messaged = ['I005', 'I006']
+
+
+class TestCSSRuleSetDeclarationsChecksC(RuleTesterConventionC):
+    '''Test coding conventions for declarations from rule sets.'''
+
+    def test_valid_declarations(self):
+        stmt = CSSStatementMember(
+            0, 0, '\n    some: 3px;\n    other:\n        url();\n    ')
+        rule = CSSRuleSet(selector=None, declarations=stmt, log=self.log)
+        rule.checkDeclarations()
+        self.assertEqual([], self.logs)
+
+    def test_I014(self):
+        stmt = CSSStatementMember(
+            0, 0, '\n    some:  3px;\n')
+        rule = CSSRuleSet(selector=None, declarations=stmt, log=self.log)
+        rule.checkDeclarations()
+        self.assertEqual('I014', self.last_log.code)
+
+        stmt = CSSStatementMember(
+            0, 0, '\n    some:  3px;\n   ')
+        rule = CSSRuleSet(selector=None, declarations=stmt, log=self.log)
+        rule.checkDeclarations()
+        self.assertEqual('I014', self.last_log.code)
+
+
+if __name__ == '__main__':
+    unittest_main()