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

[Adi Roiban]

Hi,

This is my initial rst checker.

It contains a few changes outside of the rst part.

1. For the test runner I added the option to select the test based on regex. In this was I was able to run only a subset of test modules.

2. For the general CheckerTestCase, i set self.reporter.call_count = 0 in the setUp. Not sure if this is really needed.

Please let me know if you want me to revert these changes.
----

Now for the RST part.

For the Language class, I wanted to sort the language type identifier objects, mimetypes.add_type and mime_type_language in alphabetic order... but I didn't want to add to much noise to the diff.

I know that it is hard to force a certain coding convention and the current rules are made base on the style used in the Python documentation.

It does not checks for rst compilation errors, but rather for coding conventions.

For not it only checks for sections styles and an empty line at the end of file.

Please let me know if you thinks this is on a right direction and what should be changed.

Thanks!
Adi

[Curtis Hovey (sinzui)]

Thank you very much.

I have merged this and pushed it to Launchpad. I think there are a few methods that return True or False that could be made smaller and more precise. I do not think they need changing just yet. I think it is best that this feature be merged and used so that we know exactly where we want to improve it.

review: Approve (code)

=== modified file 'pocketlint/formatcheck.py'
--- pocketlint/formatcheck.py	2012-04-20 16:52:00 +0000
+++ pocketlint/formatcheck.py	2012-04-21 17:17:20 +0000
@@ -178,6 +178,7 @@
     DOCBOOK = object()
     LOG = object()
     SQL = object()
+    RESTRUCTUREDTEXT = object()
 
     XML_LIKE = (XML, XSLT, HTML, ZPT, ZCML, DOCBOOK)
 
@@ -186,6 +187,7 @@
     mimetypes.add_type('text/x-python-doctest', '.doctest')
     mimetypes.add_type('text/x-twisted-application', '.tac')
     mimetypes.add_type('text/x-log', '.log')
+    mimetypes.add_type('text/x-rst', '.rst')
     mime_type_language = {
         'text/x-python': PYTHON,
         'text/x-twisted-application': PYTHON,
@@ -195,6 +197,7 @@
         'text/plain': TEXT,
         'text/x-sql': SQL,
         'text/x-log': LOG,
+        'text/x-rst': RESTRUCTUREDTEXT,
         'application/javascript': JAVASCRIPT,
         'application/xml': XML,
         'application/x-sh': SH,
@@ -648,6 +651,248 @@
             self.check_tab(line_no, line)
 
 
+class ReStructuredTextChecker(BaseChecker, AnyTextMixin):
+    """Check reStructuredText ource code."""
+
+    # Taken from rst documentation.
+    delimiter_characters = [
+        '=', '-', '`', ':', '\'', '"', '~', '^', '_', '*', '+', '#', '<', '>',
+        ]
+
+    def __init__(self, file_path, text, reporter=None):
+        super(ReStructuredTextChecker, self).__init__(
+            file_path, text, reporter=reporter)
+        self.lines = self.text.splitlines()
+
+    def check(self):
+        """Check the syntax of the reStructuredText code."""
+        self.check_lines()
+        self.check_empty_last_line()
+
+    def check_lines(self):
+        """Call each line checker for each line in text."""
+        for line_no, line in enumerate(self.lines):
+            line_no += 1
+            self.check_length(line_no, line)
+            self.check_trailing_whitespace(line_no, line)
+            self.check_tab(line_no, line)
+            self.check_conflicts(line_no, line)
+
+            if self.isTransition(line_no - 1):
+                self.check_transition(line_no - 1)
+            elif self.isSectionDelimiter(line_no - 1):
+                self.check_section_delimiter(line_no - 1)
+            else:
+                pass
+
+    def isTransition(self, line_number):
+        '''Return True if the current line is a line transition.'''
+        line = self.lines[line_number]
+        if len(line) < 4:
+            return False
+
+        if len(self.lines) < 3:
+            return False
+
+        succesive_characters = (
+            line[0] == line[1] == line[2] == line[3] and
+            line[0] in self.delimiter_characters)
+
+        if not succesive_characters:
+            return False
+
+        emply_lines_bounded = (
+            self.lines[line_number - 1] == '' and
+            self.lines[line_number + 1] == '')
+
+        if not emply_lines_bounded:
+            return False
+
+        return True
+
+    def check_transition(self, line_number):
+        '''Transitions should be delimited by a single emtpy line.'''
+        if (self.lines[line_number - 2] == '' or
+                self.lines[line_number + 2] == ''):
+            self.message(
+                line_number + 1,
+                'Transition markers should be bounded by single empty lines.',
+                icon='info',
+                )
+
+    def isSectionDelimiter(self, line_number):
+        '''Return true if the line is a section delimiter.'''
+        if len(self.lines) < 3:
+            return False
+
+        if line_number >= len(self.lines):
+            return False
+
+        line = self.lines[line_number]
+        if len(line) < 3:
+            return False
+
+        if (line[0] == line[1] == line[2] and line[0] in
+                self.delimiter_characters):
+            if ' ' in line:
+                # We have a table header.
+                return False
+            else:
+                return True
+
+        return False
+
+    def check_section_delimiter(self, line_number):
+        """Checks for section delimiter.
+
+        These checkes are designed for sections delimited by top and bottom
+        markers.
+
+        =======  <- top marker
+        Section  <- text_line
+        =======  <- bottom marker
+
+        If the section is delimted only by bottom marker, the section text
+        is considered the top marker.
+
+        Section  <- top marker, text_line
+        =======  <- bottom marker
+
+        If the section has a custom anchor name:
+
+        .. _link  <- top marker
+
+        =======
+        Section   <- text_line
+        =======   <- bottom marker
+
+        or:
+
+        .. _link  <- top marker
+
+        Section   <- text_line
+        =======   <- bottom marker
+
+        If we have top and bottom markers, the check will be called twice (
+        for each marker). In this case we will skip the tests for bottom
+        marker.
+        """
+        human_line_number = line_number + 1
+        current_line = self.lines[line_number]
+
+        # Skip test if we have both top and bottom markers and we are
+        # at the bottom marker.
+        if (line_number > 1 and current_line == self.lines[line_number - 2]):
+            return
+
+        if ((line_number + 2) < len(self.lines) and
+                current_line == self.lines[line_number + 2]):
+            # We have both top and bottom markers and we are currently at
+            # the top marker.
+            top_marker = line_number
+            text_line = line_number + 1
+            bottom_marker = line_number + 2
+        else:
+            # We only have bottom marker, and are at the bottom marker.
+            top_marker = line_number - 1
+            text_line = line_number - 1
+            bottom_marker = line_number
+
+        # In case we have a custom anchor, the top_marker is replaced by
+        # the custom anchor.
+        if self._sectionHasCustomAnchor(top_marker):
+            top_marker = top_marker - 2
+
+        # Check underline length for bottom marker,
+        # since top marker can be the same as text line.
+        if len(self.lines[bottom_marker]) != len(self.lines[text_line]):
+            self.message(
+                human_line_number,
+                'Section marker has wrong length.',
+                icon='error',
+                )
+
+        if not self._haveGoodSpacingBeforeSection(top_marker):
+            self.message(
+                human_line_number,
+                'Section should be divided by 2 empty lines.',
+                icon='info',
+                )
+
+        if not self._haveGoodSpacingAfterSection(bottom_marker):
+            self.message(
+                human_line_number,
+                'Section title should be followed by 1 empty line.',
+                icon='info',
+                )
+
+    def _sectionHasCustomAnchor(self, top_marker):
+        if (top_marker - 2) < 0:
+            return False
+
+        if self.lines[top_marker - 2].startswith('.. _'):
+            return True
+
+        return False
+
+    def _haveGoodSpacingBeforeSection(self, top_marker):
+        '''Return True if we have good spacing before the section.'''
+        if top_marker > 0:
+            if self.lines[top_marker - 1] != '':
+                return False
+
+        # If we are on the second line, there is no space for 2 empty lines
+        # before.
+        if top_marker == 1:
+            return False
+
+        if top_marker > 1:
+            if self.lines[top_marker - 2] != '':
+                return False
+
+        if top_marker > 2:
+            if self.lines[top_marker - 3] == '':
+                return False
+
+        return True
+
+    def _haveGoodSpacingAfterSection(self, bottom_marker):
+        '''Return True if we have good spacing after the section.'''
+        lines_count = len(self.lines)
+
+        if bottom_marker < lines_count - 1:
+            if self.lines[bottom_marker + 1] != '':
+                return False
+
+        if bottom_marker < lines_count - 2:
+            if self.lines[bottom_marker + 2] == '':
+                # If the section is followed by 2 empty spaces and then
+                # followed by a section delimiter, the section delimiter
+                # rules will take priority
+                if self.isSectionDelimiter(bottom_marker + 3):
+                    return True
+                if self.isSectionDelimiter(bottom_marker + 4):
+                    return True
+                return False
+
+        return True
+
+    def check_empty_last_line(self):
+        """Chech the files ends with an emtpy line and not with double empty
+        line.
+
+        This will avoid merge conflicts.
+        """
+        if len(self.lines) < 2:
+            return
+        if self.text[-1] != '\n' or self.text[-2:] == '\n\n':
+            self.message(
+                len(self.lines),
+                'File does not ends with an empty line.',
+                icon='info',
+                )
+
+
 def get_option_parser():
     """Return the option parser for this program."""
     usage = "usage: %prog [options] file1 file2"
 
=== modified file 'pocketlint/tests/__init__.py'
--- pocketlint/tests/__init__.py	2012-01-29 21:24:20 +0000
+++ pocketlint/tests/__init__.py	2012-04-21 17:17:20 +0000
@@ -11,3 +11,4 @@
 
     def setUp(self):
         self.reporter = Reporter(Reporter.COLLECTOR)
+        self.reporter.call_count = 0
 
=== added file 'pocketlint/tests/test_restructuredtext.py'
--- pocketlint/tests/test_restructuredtext.py	1970-01-01 00:00:00 +0000
+++ pocketlint/tests/test_restructuredtext.py	2012-04-21 17:17:20 +0000
@@ -0,0 +1,524 @@
+'''Tests for ReStructuredTextChecker.'''
+from pocketlint.formatcheck import ReStructuredTextChecker
+from pocketlint.tests import CheckerTestCase
+
+# This is a valid rst content.
+# This comment is here so that the content starts at line 11
+# and make it easier to identify errors in tests.
+# Just add 10 to the reported line number.
+#
+valid_rst_content = '''\
+=============
+First section
+=============
+
+Text *for* first **section**.
+
+
+--------------------
+Second emtpy section
+--------------------
+
+
+Third section
+^^^^^^^^^^^^^
+
+Paragrhap for
+third section `with link<http://my.home>`_.
+
+::
+
+  Literal block1.
+
+  Literal block paragraph.
+
+
+| Line blocks are useful for addresses,
+| verse, and adornment-free lists.
+
+
+.. _section-permalink:
+
+Another Section with predefined link
+------------------------------------
+
+>>> print "This is a doctest block."
+... with a line continuation
+This is a doctest block.
+
+A grid table.
+
++------------+------------+-----------+
+| Header 1   | Header 2   | Header 3  |
++============+============+===========+
+| body row 1 | column 2   | column 3  |
++------------+------------+-----------+
+| body row 2 | Cells may span columns.|
++------------+------------+-----------+
+| body row 3 | Cells may  | - Cells   |
++------------+ span rows. | - contain |
+| body row 4 |            | - blocks. |
++------------+------------+-----------+
+
+A simple table.
+
+=====  =====  ======
+   Inputs     Output
+------------  ------
+  A      B    A or B
+=====  =====  ======
+False  False  False
+True   False  True
+False  True   True
+True   True   True
+=====  =====  ======
+
+A transition marker is a horizontal line
+of 4 or more repeated punctuation
+characters.
+
+------------
+
+A transition should not begin or end a
+section or document, nor should two
+transitions be immediately adjacent.
+
+Footnote references, like [5]_.
+Note that footnotes may get
+rearranged, e.g., to the bottom of
+the "page".
+
+.. [5] A numerical footnote. Note
+   there's no colon after the ``]``.
+
+External hyperlinks, like Python_.
+.. _Python: http://www.python.org/
+
+For instance:
+
+.. image:: images/ball1.gif
+
+The |biohazard| symbol must be used on containers used to dispose of
+medical waste.
+
+.. |biohazard| image:: biohazard.png
+
+.. This text will not be shown
+   (but, for instance, in HTML might be
+   rendered as an HTML comment)
+'''
+# The last line from multi line string is a bit hard to visualize,
+# but it is there.
+
+
+class TestReStructuredTextChecker(CheckerTestCase):
+    """Verify reStructuredTextChecker checking."""
+
+    def test_empty_file(self):
+        self.reporter.call_count = 0
+        content = ('')
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check()
+        self.assertEqual([], self.reporter.messages)
+        self.assertEqual(0, self.reporter.call_count)
+
+    def test_valid_content(self):
+        self.reporter.call_count = 0
+        checker = ReStructuredTextChecker(
+            'bogus', valid_rst_content, self.reporter)
+        checker.check()
+        self.assertEqual([], self.reporter.messages)
+        self.assertEqual(0, self.reporter.call_count)
+
+    def test_no_empty_last_line(self):
+        self.reporter.call_count = 0
+        content = (
+            'Some first line\n'
+            'the second and last line witout newline'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check_empty_last_line()
+        expected = [(
+            2, 'File does not ends with an empty line.')]
+        self.assertEqual(expected, self.reporter.messages)
+        self.assertEqual(1, self.reporter.call_count)
+
+    def test_multiple_empty_last_lines(self):
+        self.reporter.call_count = 0
+        content = (
+            'Some first line\n'
+            'the second and last\n'
+            '\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check_empty_last_line()
+        expected = [(
+            3, 'File does not ends with an empty line.')]
+        self.assertEqual(expected, self.reporter.messages)
+        self.assertEqual(1, self.reporter.call_count)
+
+    def test_isTransition_good(self):
+        content = (
+            '\n'
+            '----\n'
+            '\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        result = checker.isTransition(1)
+        self.assertTrue(result)
+
+    def test_isTransition_short_line(self):
+        content = (
+            '\n'
+            '---\n'
+            '\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        result = checker.isTransition(1)
+        self.assertFalse(result)
+
+    def test_isTransition_short_file(self):
+        content = (
+            '\n'
+            '----\n'
+            ''
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        result = checker.isTransition(1)
+        self.assertFalse(result)
+
+    def test_isTransition_false(self):
+        content = (
+            '\n'
+            '----\n'
+            'some\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        result = checker.isTransition(1)
+        self.assertFalse(result)
+
+        content = (
+            'some\n'
+            '----\n'
+            '\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        result = checker.isTransition(1)
+        self.assertFalse(result)
+
+    def test_check_transitions_good(self):
+        content = (
+            'some text\n'
+            '\n'
+            '----\n'
+            '\n'
+            'some text\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check_transition(2)
+        self.assertEqual([], self.reporter.messages)
+        self.assertEqual(0, self.reporter.call_count)
+
+    def test_check_transitions_bad_spacing_before(self):
+        content = (
+            'some text\n'
+            '\n'
+            '\n'
+            '----\n'
+            '\n'
+            'some text\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check_transition(3)
+        expect = [(
+            4, 'Transition markers should be bounded by single empty lines.')]
+        self.assertEqual(expect, self.reporter.messages)
+        self.assertEqual(1, self.reporter.call_count)
+
+    def test_check_transitions_bad_spacing_after(self):
+        content = (
+            'some text\n'
+            '\n'
+            '----\n'
+            '\n'
+            '\n'
+            'some text\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check_transition(2)
+        expect = [(
+            3, 'Transition markers should be bounded by single empty lines.')]
+        self.assertEqual(expect, self.reporter.messages)
+        self.assertEqual(1, self.reporter.call_count)
+
+    def test_check_transitions_bad_spacing_both(self):
+        content = (
+            'some text\n'
+            '\n'
+            '\n'
+            '----\n'
+            '\n'
+            '\n'
+            'some text\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check_transition(3)
+        expect = [(
+            4, 'Transition markers should be bounded by single empty lines.')]
+        self.assertEqual(expect, self.reporter.messages)
+        self.assertEqual(1, self.reporter.call_count)
+
+    def test_isSectionDelimiter_short_file(self):
+        content = (
+            'Something'
+            '---------\n'
+            ''
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        result = checker.isSectionDelimiter(1)
+        self.assertFalse(result)
+
+    def test_isSectionDelimiter_short_line(self):
+        content = (
+            'Som'
+            '---\n'
+            ''
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        result = checker.isSectionDelimiter(1)
+        self.assertFalse(result)
+
+    def test_isSectionDelimiter_table(self):
+        content = (
+            '---- ----'
+            'Row1 Row1'
+            '---- ----\n'
+            ''
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        result = checker.isSectionDelimiter(0)
+        self.assertFalse(result)
+        result = checker.isSectionDelimiter(2)
+        self.assertFalse(result)
+
+    def test_isSectionDelimiter_good(self):
+        content = (
+            'Section\n'
+            '-------\n'
+            'some text'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        result = checker.isSectionDelimiter(1)
+        self.assertTrue(result)
+
+    def test_isSectionDelimiter_good_bounded_start_of_file(self):
+        content = (
+            '=======\n'
+            'Section\n'
+            '=======\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        result = checker.isSectionDelimiter(0)
+        self.assertTrue(result)
+        result = checker.isSectionDelimiter(2)
+        self.assertTrue(result)
+
+    def test_check_section_delimiter_bounded(self):
+        content = (
+            'some text\n'
+            '\n'
+            '\n'
+            '=======\n'
+            'Section\n'
+            '=======\n'
+            '\n'
+            'some text\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check_section_delimiter(3)
+        checker.check_section_delimiter(5)
+        self.assertEqual([], self.reporter.messages)
+        self.assertEqual(0, self.reporter.call_count)
+
+    def test_check_section_delimiter_bad_marker_length(self):
+        content = (
+            'Section\n'
+            '------\n'
+            '\n'
+            'some text\n'
+            'other text\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check_section_delimiter(1)
+        expect = [(2, 'Section marker has wrong length.')]
+        self.assertEqual(expect, self.reporter.messages)
+        self.assertEqual(1, self.reporter.call_count)
+
+    def test_check_section_delimiter_bad_length_both_markers(self):
+        content = (
+            '---------\n'
+            'Section\n'
+            '---------\n'
+            '\n'
+            'some text\n'
+            'other text\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check_section_delimiter(0)
+        checker.check_section_delimiter(2)
+        expect = [(1, 'Section marker has wrong length.')]
+        self.assertEqual(expect, self.reporter.messages)
+        self.assertEqual(1, self.reporter.call_count)
+
+    def test_check_section_before_space_good_start_both(self):
+        content = (
+            '-------\n'
+            'Section\n'
+            '-------\n'
+            '\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check_section_delimiter(0)
+        checker.check_section_delimiter(2)
+        self.assertEqual([], self.reporter.messages)
+        self.assertEqual(0, self.reporter.call_count)
+
+    def test_check_section_before_space_good_start_bottom(self):
+        content = (
+            'Section\n'
+            '-------\n'
+            '\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check_section_delimiter(1)
+        self.assertEqual([], self.reporter.messages)
+        self.assertEqual(0, self.reporter.call_count)
+
+    def test_check_section_before_space_bad_only_one_line_near_start(self):
+        content = (
+            '\n'
+            'Section\n'
+            '-------\n'
+            '\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check_section_delimiter(2)
+        expect = [(3, 'Section should be divided by 2 empty lines.')]
+        self.assertEqual(expect, self.reporter.messages)
+        self.assertEqual(1, self.reporter.call_count)
+
+    def test_check_section_before_space_bad_only_one_line(self):
+        content = (
+            'end of previous section.\n'
+            '\n'
+            'Section\n'
+            '-------\n'
+            '\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check_section_delimiter(3)
+        expect = [(4, 'Section should be divided by 2 empty lines.')]
+        self.assertEqual(expect, self.reporter.messages)
+        self.assertEqual(1, self.reporter.call_count)
+
+    def test_check_section_before_space_multiple_empty_lines(self):
+        content = (
+            'end of previous section.\n'
+            '\n'
+            '\n'
+            '\n'
+            'Section\n'
+            '-------\n'
+            '\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check_section_delimiter(5)
+        expect = [(6, 'Section should be divided by 2 empty lines.')]
+        self.assertEqual(expect, self.reporter.messages)
+        self.assertEqual(1, self.reporter.call_count)
+
+    def test_check_section_after_space_last_line(self):
+        content = (
+            'Section\n'
+            '-------\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check_section_delimiter(1)
+        self.assertEqual([], self.reporter.messages)
+        self.assertEqual(0, self.reporter.call_count)
+
+    def test_check_section_after_space_bad(self):
+        content = (
+            'Section\n'
+            '-------\n'
+            'Paragraph start.\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check_section_delimiter(1)
+        expect = [(2, 'Section title should be followed by 1 empty line.')]
+        self.assertEqual(expect, self.reporter.messages)
+        self.assertEqual(1, self.reporter.call_count)
+
+    def test_check_section_after_space_too_many_empty_lines(self):
+        content = (
+            'Section\n'
+            '-------\n'
+            '\n'
+            '\n'
+            'Paragraph start.\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check_section_delimiter(1)
+        expect = [(2, 'Section title should be followed by 1 empty line.')]
+        self.assertEqual(expect, self.reporter.messages)
+        self.assertEqual(1, self.reporter.call_count)
+
+    def test_check_section_empty_section_next_section_only_bottom(self):
+        content = (
+            'Emtpy Section\n'
+            '=============\n'
+            '\n'
+            '\n'
+            'Another Section\n'
+            '---------------\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check_section_delimiter(1)
+        self.assertEqual([], self.reporter.messages)
+        self.assertEqual(0, self.reporter.call_count)
+
+    def test_check_section_empty_section_next_section_both_markers(self):
+        content = (
+            'Emtpy Section\n'
+            '=============\n'
+            '\n'
+            '\n'
+            '---------------\n'
+            'Another Section\n'
+            '---------------\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check_section_delimiter(1)
+        self.assertEqual([], self.reporter.messages)
+        self.assertEqual(0, self.reporter.call_count)
+
+    def disable_check_section_delimiter_both_markers_not_sync(self):
+        # When both top and bottom markers are used, and they don't have
+        # the same size, they are interpreted as separate markers.
+        content = (
+            '------\n'
+            'Section\n'
+            '--------\n'
+            '\n'
+            'some text\n'
+            'other text\n'
+            )
+        checker = ReStructuredTextChecker('bogus', content, self.reporter)
+        checker.check_lines()
+        expect = [
+            (1, 'Section marker has wrong length.'),
+            (1, 'Section title should be followed by 1 empty line.'),
+            (3, 'Section marker has wrong length.'),
+            ]
+        self.assertEqual(expect, self.reporter.messages)
+        self.assertEqual(3, self.reporter.call_count)
 
=== modified file 'test.py'
--- test.py	2012-01-29 21:24:20 +0000
+++ test.py	2012-04-21 17:17:20 +0000
@@ -6,6 +6,7 @@
 
 import re
 import os
+import sys
 import unittest
 try:
     from unittest.runner import _WritelnDecorator
@@ -81,23 +82,40 @@
         self.stream.write(text)
 
 
-def find_tests(root_dir):
+def find_tests(root_dir, filter=None):
     """Generate a list of matching test modules below a directory."""
     for path, subdirs, files in os.walk(root_dir):
         subdirs[:] = [dir for dir in subdirs]
         if path.endswith('tests'):
             for file_ in files:
                 if file_.startswith('test_') and file_.endswith('.py'):
+                    if filter and not re.search(filter, file_):
+                        continue
                     file_path = os.path.join(path, file_)
                     test_module = file_path[2:-3].replace('/', '.')
                     yield test_module
 
 
+def show_help():
+    print '''\
+python test.py [-h|--help] [test_module_regex_filter]
+'''
+
+
 def main():
+    if len(sys.argv) > 1:
+        if (sys.argv[1] in ['-h', '--help']):
+            show_help()
+            return
+        else:
+            filter = sys.argv[1]
+    else:
+        filter = None
+
     unittest.runner._WritelnDecorator = XTermWritelnDecorator
     test_loader = unittest.defaultTestLoader
     suite = unittest.TestSuite()
-    for test_module in find_tests('.'):
+    for test_module in find_tests('.', filter=filter):
         suite.addTest(test_loader.loadTestsFromName(test_module))
     unittest.TextTestRunner(verbosity=2).run(suite)