first step toward a better project layout.

Author: ikirudennis

tests/test_block.py

@@ -1,5 +1,8 @@
 from __future__ import unicode_literals
+
 from textile import Textile
+from textile.objects import Block
+
 try:
     from collections import OrderedDict
 except ImportError:
@@ -11,26 +14,30 @@ def test_block():
     expect = '\t<h1>foobar baby</h1>'
     assert result == expect
 
-    result = t.fBlock("bq", "", None, "", "Hello BlockQuote")
+    b = Block(t, "bq", "", None, "", "Hello BlockQuote")
     expect = ('blockquote', OrderedDict(), 'p', OrderedDict(),
             'Hello BlockQuote')
+    result = (b.outer_tag, b.outer_atts, b.inner_tag, b.inner_atts, b.content)
     assert result == expect
 
-    result = t.fBlock("bq", "", None, "http://google.com", "Hello BlockQuote")
+    b = Block(t, "bq", "", None, "http://google.com", "Hello BlockQuote")
     citation = '{0}1:url'.format(t.uid)
     expect = ('blockquote', OrderedDict([('cite',
         '{0.uid}{0.refIndex}:url'.format(t))]), 'p', OrderedDict(),
         'Hello BlockQuote')
+    result = (b.outer_tag, b.outer_atts, b.inner_tag, b.inner_atts, b.content)
     assert result == expect
 
-    result = t.fBlock("bc", "", None, "", 'printf "Hello, World";')
+    b = Block(t, "bc", "", None, "", 'printf "Hello, World";')
     # the content of text will be turned shelved, so we'll asert only the
     # deterministic portions of the expected values, below
-    expect = ('pre', OrderedDict(), 'code', OrderedDict(), 'shelve')
-    assert result[0:3] == expect[0:3]
+    expect = ('pre', OrderedDict(), 'code', OrderedDict())
+    result = (b.outer_tag, b.outer_atts, b.inner_tag, b.inner_atts)
+    assert result == expect
 
-    result = t.fBlock("h1", "", None, "", "foobar")
+    b = Block(t, "h1", "", None, "", "foobar")
     expect = ('h1', OrderedDict(), '', OrderedDict(), 'foobar')
+    result = (b.outer_tag, b.outer_atts, b.inner_tag, b.inner_atts, b.content)
     assert result == expect
 
 def test_block_tags_false():

textile/core.py

@@ -29,6 +29,7 @@
 from textile.utils import (decode_high, encode_high, encode_html, generate_tag,
         has_raw_text, is_rel_url, is_valid_url, list_type, normalize_newlines,
         parse_attributes, pba)
+from textile.objects import Block
 
 
 try:
@@ -577,18 +578,19 @@ def block(self, text):
             # tag specified on this line.
             if match:
                 tag, atts, ext, cite, content = match.groups()
-                (outer_tag, outer_atts, inner_tag, inner_atts,
-                        content) = self.fBlock(**match.groupdict())
-                inner_block = generate_tag(inner_tag, content, inner_atts)
+                block = Block(self, **match.groupdict())
+                inner_block = generate_tag(block.inner_tag, block.content,
+                        block.inner_atts)
                 # code tags and raw text won't be indented inside outer_tag.
-                if inner_tag != 'code' and not has_raw_text(inner_block):
+                if block.inner_tag != 'code' and not has_raw_text(inner_block):
                     inner_block = "\n\t\t{0}\n\t".format(inner_block)
                 if ext:
-                    line = content
+                    line = block.content
                 else:
-                    line = generate_tag(outer_tag, inner_block, outer_atts)
+                    line = generate_tag(block.outer_tag, inner_block,
+                            block.outer_atts)
                     # pre tags and raw text won't be indented.
-                    if outer_tag != 'pre' and not has_raw_text(line):
+                    if block.outer_tag != 'pre' and not has_raw_text(line):
                         line = "\t{0}".format(line)
             # no tag specified
             else:
@@ -598,13 +600,13 @@ def block(self, text):
                     line = '{0}\n{1}'.format(out.pop(), line)
                 whitespace = ' \t\n\r\f\v'
                 if ext or not line[0] in whitespace:
-                    (outer_tag, outer_atts, inner_tag, inner_atts,
-                            content) = self.fBlock(tag, atts, ext, cite, line)
-                    if tag == 'p' and not has_raw_text(content):
-                        line = content
+                    block = Block(self, tag, atts, ext, cite, line)
+                    if block.tag == 'p' and not has_raw_text(block.content):
+                        line = block.content
                     else:
-                        line = generate_tag(outer_tag, content, outer_atts)
-                        if outer_tag != 'pre' and not has_raw_text(line):
+                        line = generate_tag(block.outer_tag, block.content,
+                                block.outer_atts)
+                        if block.outer_tag != 'pre' and not has_raw_text(line):
                             line = "\t{0}".format(line)
                 else:
                     line = self.graf(line)
@@ -622,113 +624,10 @@ def block(self, text):
                 graf = ''
 
         if ext:
-            out.append(generate_tag(outer_tag, out.pop(), outer_atts))
+            out.append(generate_tag(block.outer_tag, out.pop(),
+                block.outer_atts))
         return '\n\n'.join(out)
 
-    def fBlock(self, tag, atts, ext, cite, content):
-        att = atts
-        attributes = parse_attributes(att)
-        outer_tag = ''
-        inner_tag = ''
-        outer_atts = OrderedDict()
-        inner_atts = OrderedDict()
-        eat = False
-
-        if tag == 'p':
-            # is this an anonymous block with a note definition?
-            notedef_re = re.compile(r"""
-            ^note\#                               # start of note def marker
-            (?P<label>[^%<*!@\#^([{{ {space}.]+)  # label
-            (?P<link>[*!^]?)                      # link
-            (?P<att>{cls})                        # att
-            \.?                                   # optional period.
-            [{space}]+                            # whitespace ends def marker
-            (?P<content>.*)$                      # content""".format(
-                space=regex_snippets['space'], cls=cls_re_s),
-            flags=re.X | re.U)
-            notedef = notedef_re.sub(self.fParseNoteDefs, content)
-
-            # It will be empty if the regex matched and ate it.
-            if '' == notedef:
-                content = notedef
-                return (outer_tag, outer_atts, inner_tag, inner_atts, content)
-
-        fns = re.search(r'fn(?P<fnid>{0}+)'.format(regex_snippets['digit']),
-                tag, flags=re.U)
-        if fns:
-            tag = 'p'
-            fnid = self.fn.get(fns.group('fnid'), None)
-            if fnid is None:
-                fnid = '{0}{1}'.format(self.linkPrefix,
-                        self._increment_link_index())
-
-            # If there is an author-specified ID goes on the wrapper & the
-            # auto-id gets pushed to the <sup>
-            supp_id = OrderedDict()
-
-            # if class has not been previously specified, set it to "footnote"
-            if 'class' not in attributes:
-                attributes.update({'class': 'footnote'})
-
-            # if there's no specified id, use the generated one.
-            if 'id' not in attributes:
-                attributes.update({'id': 'fn{0}'.format(fnid)})
-            else:
-                supp_id = parse_attributes('(#fn{0})'.format(fnid))
-
-
-            if '^' not in att:
-                sup = generate_tag('sup', fns.group('fnid'), supp_id)
-            else:
-                fnrev = generate_tag('a', fns.group('fnid'), {'href':
-                    '#fnrev{0}'.format(fnid)})
-                sup = generate_tag('sup', fnrev, supp_id)
-
-            content = '{0} {1}'.format(sup, content)
-
-        if tag == 'bq':
-            if cite:
-                cite = self.shelveURL(cite)
-                cite_att = OrderedDict(cite=cite)
-                cite = ' cite="{0}"'.format(cite)
-            else:
-                cite = ''
-                cite_att = OrderedDict()
-            cite_att.update(attributes)
-            outer_tag = 'blockquote'
-            outer_atts = cite_att
-            inner_tag = 'p'
-            inner_atts = attributes
-            eat = False
-
-        elif tag == 'bc' or tag == 'pre':
-            i_tag = ''
-            if tag == 'bc':
-                i_tag = 'code'
-            content = self.shelve(encode_html('{0}\n'.format(
-                content.rstrip("\n"))))
-            outer_tag = 'pre'
-            outer_atts = attributes
-            inner_tag = i_tag
-            inner_atts = attributes
-            eat = False
-
-        elif tag == 'notextile':
-            content = self.shelve(content)
-
-        elif tag == '###':
-            eat = True
-
-        else:
-            outer_tag = tag
-            outer_atts = attributes
-
-        if not eat:
-            content = self.graf(content)
-        else:
-            content = ''
-        return (outer_tag, outer_atts, inner_tag, inner_atts, content)
-
     def footnoteRef(self, text):
         # somehow php-textile gets away with not capturing the space.
         return re.compile(r'(?<=\S)\[(?P<id>{0}+)(?P<nolink>!?)\]'

textile/objects/__init__.py

@@ -0,0 +1,3 @@
+from .block import Block
+
+__all__ = ['Block', ]

textile/objects/block.py

@@ -0,0 +1,123 @@
+try:
+    from collections import OrderedDict
+except ImportError:
+    from ordereddict import OrderedDict
+try:
+    import regex as re
+except ImportError:
+    import re
+
+from textile.regex_strings import cls_re_s, regex_snippets
+from textile.utils import encode_html, generate_tag, parse_attributes
+
+
+class Block(object):
+    def __init__(self, textile, tag, atts, ext, cite, content):
+        self.textile = textile
+        self.tag = tag
+        self.atts = atts
+        self.ext = ext
+        self.cite = cite
+        self.content = content
+
+        self.attributes = parse_attributes(atts)
+        self.outer_tag = ''
+        self.inner_tag = ''
+        self.outer_atts = OrderedDict()
+        self.inner_atts = OrderedDict()
+        self.eat = False
+        self.process()
+
+    def process(self):
+        if self.tag == 'p':
+            # is this an anonymous block with a note definition?
+            notedef_re = re.compile(r"""
+            ^note\#                               # start of note def marker
+            (?P<label>[^%<*!@\#^([{{ {space}.]+)  # label
+            (?P<link>[*!^]?)                      # link
+            (?P<att>{cls})                        # att
+            \.?                                   # optional period.
+            [{space}]+                            # whitespace ends def marker
+            (?P<content>.*)$                      # content""".format(
+                space=regex_snippets['space'], cls=cls_re_s),
+            flags=re.X | re.U)
+            notedef = notedef_re.sub(self.textile.fParseNoteDefs, self.content)
+
+            # It will be empty if the regex matched and ate it.
+            if '' == notedef:
+                self.content = notedef
+
+        fns = re.search(r'fn(?P<fnid>{0}+)'.format(regex_snippets['digit']),
+                self.tag, flags=re.U)
+        if fns:
+            self.tag = 'p'
+            fnid = self.textile.fn.get(fns.group('fnid'), None)
+            if fnid is None:
+                fnid = '{0}{1}'.format(self.textile.linkPrefix,
+                        self.textile._increment_link_index())
+
+            # If there is an author-specified ID goes on the wrapper & the
+            # auto-id gets pushed to the <sup>
+            supp_id = OrderedDict()
+
+            # if class has not been previously specified, set it to "footnote"
+            if 'class' not in self.attributes:
+                self.attributes.update({'class': 'footnote'})
+
+            # if there's no specified id, use the generated one.
+            if 'id' not in self.attributes:
+                self.attributes.update({'id': 'fn{0}'.format(fnid)})
+            else:
+                supp_id = parse_attributes('(#fn{0})'.format(fnid))
+
+
+            if '^' not in self.atts:
+                sup = generate_tag('sup', fns.group('fnid'), supp_id)
+            else:
+                fnrev = generate_tag('a', fns.group('fnid'), {'href':
+                    '#fnrev{0}'.format(fnid)})
+                sup = generate_tag('sup', fnrev, supp_id)
+
+            self.content = '{0} {1}'.format(sup, self.content)
+
+        if self.tag == 'bq':
+            if self.cite:
+                self.cite = self.textile.shelveURL(self.cite)
+                cite_att = OrderedDict(cite=self.cite)
+                self.cite = ' cite="{0}"'.format(self.cite)
+            else:
+                self.cite = ''
+                cite_att = OrderedDict()
+            cite_att.update(self.attributes)
+            self.outer_tag = 'blockquote'
+            self.outer_atts = cite_att
+            self.inner_tag = 'p'
+            self.inner_atts = self.attributes
+            self.eat = False
+
+        elif self.tag == 'bc' or self.tag == 'pre':
+            i_tag = ''
+            if self.tag == 'bc':
+                i_tag = 'code'
+            self.content = self.textile.shelve(encode_html('{0}\n'.format(
+                self.content.rstrip("\n"))))
+            self.outer_tag = 'pre'
+            self.outer_atts = self.attributes
+            self.inner_tag = i_tag
+            self.inner_atts = self.attributes
+            self.eat = False
+
+        elif self.tag == 'notextile':
+            self.content = self.textile.shelve(self.content)
+
+        elif self.tag == '###':
+            self.eat = True
+
+        else:
+            self.outer_tag = self.tag
+            self.outer_atts = self.attributes
+
+        if not self.eat:
+            self.content = self.textile.graf(self.content)
+        else:
+            self.content = ''