Rename package name to commonmark

This makes the package name PEP8-compliant by changing:

    import CommonMark

to:

    import commonmark

The old camel-cased import should still work as well though, for now.

Closes #60

Author: nikolas

CommonMark

@@ -0,0 +1 @@
+commonmark/

CommonMark/__init__.py

@@ -2,17 +2,17 @@ include README.rst
 include LICENSE
 include .gitignore
 include spec.txt
-include CommonMark/__init__.py
-include CommonMark/blocks.py
-include CommonMark/common.py
-include CommonMark/dump.py
-include CommonMark/entitytrans.py
-include CommonMark/inlines.py
-include CommonMark/main.py
-include CommonMark/node.py
-include CommonMark/utils.py
-include CommonMark/render/__init__.py
-include CommonMark/render/renderer.py
-include CommonMark/render/html.py
-include CommonMark/tests/run_spec_tests.py
-include CommonMark/tests/unit_tests.py
+include commonmark/__init__.py
+include commonmark/blocks.py
+include commonmark/common.py
+include commonmark/dump.py
+include commonmark/entitytrans.py
+include commonmark/inlines.py
+include commonmark/main.py
+include commonmark/node.py
+include commonmark/utils.py
+include commonmark/render/__init__.py
+include commonmark/render/renderer.py
+include commonmark/render/html.py
+include commonmark/tests/run_spec_tests.py
+include commonmark/tests/unit_tests.py

MANIFEST.in

@@ -28,25 +28,25 @@ Usage
 
 ::
 
-    >>> import CommonMark
-    >>> CommonMark.commonmark('*hello!*')
+    >>> import dommonmark
+    >>> commonmark.commonmark('*hello!*')
     '<p><em>hello!</em></p>\n'
 
 Or, without the syntactic sugar:
 
 .. code:: python
 
-    import CommonMark
-    parser = CommonMark.Parser()
+    import commonmark
+    parser = commonmark.Parser()
     ast = parser.parse("Hello *World*")
     
-    renderer = CommonMark.HtmlRenderer()
+    renderer = commonmark.HtmlRenderer()
     html = renderer.render(ast)
     print(html) # <p>Hello <em>World</em><p/>
     
     # inspecting the abstract syntax tree
-    json = CommonMark.dumpJSON(ast)
-    CommonMark.dumpAST(ast) # pretty print generated AST structure
+    json = commonmark.dumpJSON(ast)
+    commonmark.dumpAST(ast) # pretty print generated AST structure
    
 There is also a CLI:
 
@@ -92,7 +92,7 @@ something like this:
    $ pyvenv venv
    $ ./venv/bin/python setup.py develop test
 
-The tests script, ``CommonMark/tests/run_spec_tests.py``, is pretty much a devtool. As
+The tests script, ``commonmark/tests/run_spec_tests.py``, is pretty much a devtool. As
 well as running all the tests embedded in ``spec.txt`` it also allows you
 to run specific tests using the ``-t`` argument, provide information
 about passed tests with ``-p``, percentage passed by category of test
@@ -103,11 +103,11 @@ tracing.
 
 ::
 
-    $ ./venv/bin/python CommonMark/tests/run_spec_tests.py -h
+    $ ./venv/bin/python commonmark/tests/run_spec_tests.py -h
     usage: run_spec_tests.py [-h] [-t T] [-p] [-f] [-i] [-d] [-np] [-s]
 
-    script to run the CommonMark specification tests against the CommonMark.py
-    parser
+    script to run the CommonMark specification tests against the CommonMark-py
+    parser.
 
     optional arguments:
       -h, --help  show this help message and exit
@@ -124,7 +124,7 @@ Authors
 
 -  `Bibek Kafle <https://github.com/kafle>`__
 -  `Roland Shoemaker <https://github.com/rolandshoemaker>`__
--  `Nik Nyby <https://github.com/nikolas>`__
+-  `Nikolas Nyby <https://github.com/nikolas>`__
 
 .. |Build Status| image:: https://travis-ci.org/rtfd/CommonMark-py.svg?branch=master
    :target: https://travis-ci.org/rtfd/CommonMark-py

README.rst

@@ -0,0 +1,8 @@
+# flake8: noqa
+from __future__ import unicode_literals, absolute_import
+
+from commonmark.main import commonmark
+from commonmark.dump import dumpAST, dumpJSON
+from commonmark.blocks import Parser
+from commonmark.render.html import HtmlRenderer
+from commonmark.render.rst import ReStructuredTextRenderer

commonmark/__init__.py

@@ -2,11 +2,11 @@
 
 import re
 from importlib import import_module
-from CommonMark import common
-from CommonMark.common import unescape_string
-from CommonMark.inlines import InlineParser
-from CommonMark.node import Node
-from CommonMark.utils import to_camel_case
+from commonmark import common
+from commonmark.common import unescape_string
+from commonmark.inlines import InlineParser
+from commonmark.node import Node
+from commonmark.utils import to_camel_case
 
 
 CODE_INDENT = 4
@@ -610,12 +610,12 @@ def add_child(self, tag, offset):
         """ Add block of type tag as a child of the tip.  If the tip can't
         accept children, close and finalize it and try its parent,
         and so on til we find a block that can accept children."""
-        block_class = getattr(import_module('CommonMark.blocks'),
+        block_class = getattr(import_module('commonmark.blocks'),
                               to_camel_case(self.tip.t))
         while not block_class.can_contain(tag):
             self.finalize(self.tip, self.line_number - 1)
             block_class = getattr(
-                import_module('CommonMark.blocks'),
+                import_module('commonmark.blocks'),
                 to_camel_case(self.tip.t))
 
         column_number = offset + 1
@@ -731,7 +731,7 @@ def incorporate_line(self, ln):
 
             self.find_next_nonspace()
             block_class = getattr(
-                import_module('CommonMark.blocks'),
+                import_module('commonmark.blocks'),
                 to_camel_case(container.t))
             rv = block_class.continue_(self, container)
             if rv == 0:
@@ -757,7 +757,7 @@ def incorporate_line(self, ln):
         self.all_closed = (container == self.oldtip)
         self.last_matched_container = container
 
-        block_class = getattr(import_module('CommonMark.blocks'),
+        block_class = getattr(import_module('commonmark.blocks'),
                               to_camel_case(container.t))
         matched_leaf = container.t != 'paragraph' and block_class.accepts_lines
         starts = self.block_starts
@@ -824,7 +824,7 @@ def incorporate_line(self, ln):
                 cont.last_line_blank = last_line_blank
                 cont = cont.parent
 
-            block_class = getattr(import_module('CommonMark.blocks'),
+            block_class = getattr(import_module('commonmark.blocks'),
                                   to_camel_case(t))
             if block_class.accepts_lines:
                 self.add_line()
@@ -853,7 +853,7 @@ def finalize(self, block, line_number):
         above = block.parent
         block.is_open = False
         block.sourcepos[1] = [line_number, self.last_line_length]
-        block_class = getattr(import_module('CommonMark.blocks'),
+        block_class = getattr(import_module('commonmark.blocks'),
                               to_camel_case(block.t))
         block_class.finalize(self, block)
 

CommonMark/blocks.py renamed to commonmark/blocks.py

@@ -2,7 +2,7 @@
 from __future__ import unicode_literals
 import argparse
 import sys
-import CommonMark
+import commonmark
 
 
 def main():
@@ -27,7 +27,7 @@ def main():
     parser.add_argument('-a', action="store_true", help="Print formatted AST")
     parser.add_argument('-aj', action="store_true", help="Output JSON AST")
     args = parser.parse_args()
-    parser = CommonMark.Parser()
+    parser = commonmark.Parser()
     f = args.infile
     o = args.o
     lines = []
@@ -36,16 +36,16 @@ def main():
     data = "".join(lines)
     ast = parser.parse(data)
     if not args.a and not args.aj:
-        renderer = CommonMark.HtmlRenderer()
+        renderer = commonmark.HtmlRenderer()
         o.write(renderer.render(ast))
         exit()
     if args.a:
         # print ast
-        CommonMark.dumpAST(ast)
+        commonmark.dumpAST(ast)
         exit()
 
     # o.write(ast.to_JSON())
-    o.write(CommonMark.dumpJSON(ast))
+    o.write(commonmark.dumpJSON(ast))
     exit()
 
 

CommonMark/cmark.py renamed to commonmark/cmark.py

@@ -16,7 +16,7 @@
         from .entitytrans import _unescape
         HTMLunescape = _unescape
 else:
-    from CommonMark import entitytrans
+    from commonmark import entitytrans
     HTMLunescape = entitytrans._unescape
 
 ENTITY = '&(?:#x[a-f0-9]{1,8}|#[0-9]{1,8}|[a-z][a-z0-9]{1,31});'

CommonMark/common.py renamed to commonmark/common.py

@@ -2,7 +2,7 @@
 
 from builtins import str
 import json
-from CommonMark.node import is_container
+from commonmark.node import is_container
 
 
 def prepare(obj, topnode=False):

CommonMark/dump.py renamed to commonmark/dump.py

@@ -2,9 +2,9 @@
 
 import re
 import sys
-from CommonMark import common
-from CommonMark.common import normalize_uri, unescape_string
-from CommonMark.node import Node
+from commonmark import common
+from commonmark.common import normalize_uri, unescape_string
+from commonmark.node import Node
 
 if sys.version_info >= (3, 0):
     if sys.version_info >= (3, 4):
@@ -14,7 +14,7 @@
         from .entitytrans import _unescape
         HTMLunescape = _unescape
 else:
-    from CommonMark import entitytrans
+    from commonmark import entitytrans
     HTMLunescape = entitytrans._unescape
 
 # Some regexps used in inline parser:

CommonMark/entitytrans.py renamed to commonmark/entitytrans.py

@@ -1,20 +1,20 @@
 # 2014 - Bibek Kafle & Roland Shoemaker
-# 2015-2017 - Nik Nyby
+# 2015-2017 - Nikolas Nyby
 # Port of @jgm's commonmark.js implementation of the CommonMark spec.
 
 # Basic usage:
 #
-# import CommonMark
-# parser = CommonMark.Parser()
-# renderer = CommonMark.HtmlRenderer()
+# import commonmark
+# parser = commonmark.Parser()
+# renderer = commonmark.HtmlRenderer()
 # print(renderer.render(parser.parse('Hello *world*')))
 
 from __future__ import absolute_import, unicode_literals
 
-from CommonMark.blocks import Parser
-from CommonMark.dump import dumpAST, dumpJSON
-from CommonMark.render.html import HtmlRenderer
-from CommonMark.render.rst import ReStructuredTextRenderer
+from commonmark.blocks import Parser
+from commonmark.dump import dumpAST, dumpJSON
+from commonmark.render.html import HtmlRenderer
+from commonmark.render.rst import ReStructuredTextRenderer
 
 
 def commonmark(text, format="html"):

CommonMark/inlines.py renamed to commonmark/inlines.py

@@ -3,8 +3,8 @@
 
 import re
 from builtins import str
-from CommonMark.common import escape_xml
-from CommonMark.render.renderer import Renderer
+from commonmark.common import escape_xml
+from commonmark.render.renderer import Renderer
 
 
 reUnsafeProtocol = re.compile(

CommonMark/main.py renamed to commonmark/main.py

@@ -1,7 +1,7 @@
 from __future__ import unicode_literals
 
 
-from CommonMark.render.renderer import Renderer
+from commonmark.render.renderer import Renderer
 
 
 class ReStructuredTextRenderer(Renderer):
@@ -12,12 +12,12 @@ class ReStructuredTextRenderer(Renderer):
 
     .. code:: python
 
-        import CommonMark
+        import commonmark
 
-        parser = CommonMark.Parser()
+        parser = commonmark.Parser()
         ast = parser.parse('Hello `inline code` example')
 
-        renderer = CommonMark.ReStructuredTextRenderer()
+        renderer = commonmark.ReStructuredTextRenderer()
         rst = renderer.render(ast)
         print(rst)  # Hello ``inline code`` example
     """

CommonMark/node.py renamed to commonmark/node.py

@@ -1,12 +1,12 @@
 import unittest
 
-import CommonMark
+import commonmark
 
 
 class TestCommonmark(unittest.TestCase):
     def setUp(self):
-        self.parser = CommonMark.Parser()
-        self.renderer = CommonMark.ReStructuredTextRenderer()
+        self.parser = commonmark.Parser()
+        self.renderer = commonmark.ReStructuredTextRenderer()
 
     def render_rst(self, test_str):
         ast = self.parser.parse(test_str)

CommonMark/render/__init__.py renamed to commonmark/render/__init__.py

@@ -7,8 +7,8 @@
 import argparse
 import sys
 from builtins import str
-from CommonMark.render.html import HtmlRenderer
-from CommonMark.main import Parser, dumpAST
+from commonmark.render.html import HtmlRenderer
+from commonmark.main import Parser, dumpAST
 
 
 class colors(object):

CommonMark/render/html.py renamed to commonmark/render/html.py

@@ -16,13 +16,13 @@ Installation
 Usage
 -----
 
-	import CommonMark
-	parser = CommonMark.Parser()
-	renderer = CommonMark.HtmlRenderer()
+	import commonmark
+	parser = commonmark.Parser()
+	renderer = commonmark.HtmlRenderer()
 	ast = parser.parse("Hello *World*")
 	html = renderer.render(ast)
-	json = CommonMark.dumpJSON(ast)
-	CommonMark.dumpAST(ast) # pretty print generated AST structure
+	json = commonmark.dumpJSON(ast)
+	commonmark.dumpAST(ast) # pretty print generated AST structure
 	print(html) # <p>Hello <em>World</em><p/>
 
     ----- or -----