From 073c997eea7a77c47cf55a8cbb04bb81aaf1c370 Mon Sep 17 00:00:00 2001
From: Talha Mansoor <talha131@gmail.com>
Date: Fri, 7 Feb 2014 11:40:48 +0500
Subject: [PATCH 01/26] Fix an issue in neighbors plugin which was introduced
 after subcategory support

It is not necessary that articles will have subcategories. You may
end up getting following critical error.

>
CRITICAL: ("'ArticlesGenerator' object has no attribute 'subcategories'",)
CRITICAL: 'ArticlesGenerator' object has no attribute 'subcategories'
Traceback (most recent call last):
  File "/Users/talha/Repos/VirtualEnvs/pelican-dev/bin/pelican", line 8, in <module>
    load_entry_point('pelican==3.3', 'console_scripts', 'pelican')()
  File "/Users/talha/Repos/VirtualEnvs/pelican-dev/lib/python2.7/site-packages/pelican-3.3-py2.7.egg/pelican/__init__.py", line 346, in main
    pelican.run()
  File "/Users/talha/Repos/VirtualEnvs/pelican-dev/lib/python2.7/site-packages/pelican-3.3-py2.7.egg/pelican/__init__.py", line 162, in run
    p.generate_context()
  File "/Users/talha/Repos/VirtualEnvs/pelican-dev/lib/python2.7/site-packages/pelican-3.3-py2.7.egg/pelican/generators.py", line 480, in generate_context
    signals.article_generator_finalized.send(self)
  File "/Users/talha/Repos/VirtualEnvs/pelican-dev/lib/python2.7/site-packages/blinker/base.py", line 267, in send
    for receiver in self.receivers_for(sender)]
  File "/Users/talha/Repos/pelican-plugins/neighbors/neighbors.py", line 49, in neighbors
    for subcategory, articles in generator.subcategories:
AttributeError: 'ArticlesGenerator' object has no attribute 'subcategories'
---
 neighbors/neighbors.py | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/neighbors/neighbors.py b/neighbors/neighbors.py
index a6dd2f4..b65fcfe 100755
--- a/neighbors/neighbors.py
+++ b/neighbors/neighbors.py
@@ -45,13 +45,14 @@ def neighbors(generator):
         articles.sort(key=(lambda x: x.date), reverse=(True))
         set_neighbors(
             articles, 'next_article_in_category', 'prev_article_in_category')
-    
-    for subcategory, articles in generator.subcategories:
-        articles.sort(key=(lambda x: x.date), reverse=(True))
-        index = subcategory.name.count('/')
-        next_name = 'next_article_in_subcategory{}'.format(index)
-        prev_name = 'prev_article_in_subcategory{}'.format(index)
-        set_neighbors(articles, next_name, prev_name)
+
+    if hasattr(generator, 'subcategories'):
+        for subcategory, articles in generator.subcategories:
+            articles.sort(key=(lambda x: x.date), reverse=(True))
+            index = subcategory.name.count('/')
+            next_name = 'next_article_in_subcategory{}'.format(index)
+            prev_name = 'prev_article_in_subcategory{}'.format(index)
+            set_neighbors(articles, next_name, prev_name)
 
 def register():
     signals.article_generator_finalized.connect(neighbors)

From 3bf1ac5e9832519f01cead61abe6588bd2c88056 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=BAnar=20Berg=20Baugsson=20Sigr=C3=AD=C3=B0arson?=
 <runarberg@zoho.com>
Date: Sun, 9 Feb 2014 00:54:01 +0000
Subject: [PATCH 02/26] Fixed missing quote mark in an HTML example

---
 subcategory/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/subcategory/README.md b/subcategory/README.md
index 21c610f..015bea0 100644
--- a/subcategory/README.md
+++ b/subcategory/README.md
@@ -28,7 +28,7 @@ breadcrumb-style navigation you might try something like this:
         </li>
     {% for subcategory in article.subcategories %}
         <li>
-            <a href="{{ SITEURL }}/{{ subcategory.url }}>{{ subcategory.shortname }}</a>
+            <a href="{{ SITEURL }}/{{ subcategory.url }}">{{ subcategory.shortname }}</a>
         </li>
     {% endfor %}
     </ol>

From b35996ca430c6d069fcfff751a8019d7bbd3737f Mon Sep 17 00:00:00 2001
From: Mario Lang <mlang@delysid.org>
Date: Mon, 10 Feb 2014 17:27:54 +0100
Subject: [PATCH 03/26] Allow for an optional maximum number of entries to
 display.

---
 github_activity/Readme.rst         | 5 +++++
 github_activity/github_activity.py | 3 ++-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/github_activity/Readme.rst b/github_activity/Readme.rst
index fa3b95d..5e17eb0 100644
--- a/github_activity/Readme.rst
+++ b/github_activity/Readme.rst
@@ -9,6 +9,11 @@ For example, to track Pelican project activity, the setting would be::
 
      GITHUB_ACTIVITY_FEED = 'https://github.com/getpelican.atom'
 
+If you want to limit the amount of entries to a certain maximum set the
+``GITHUB_ACTIVITY_MAX_ENTRIES`` parameter.
+
+     GITHUB_ACTIVITY_MAX_ENTRIES = 10
+
 On the template side, you just have to iterate over the ``github_activity``
 variable, as in this example::
 
diff --git a/github_activity/github_activity.py b/github_activity/github_activity.py
index fb3b2b0..76e3405 100644
--- a/github_activity/github_activity.py
+++ b/github_activity/github_activity.py
@@ -25,6 +25,7 @@ class GitHubActivity():
         import feedparser
         self.activities = feedparser.parse(
             generator.settings['GITHUB_ACTIVITY_FEED'])
+        self.max_entries = generator.settings['GITHUB_ACTIVITY_MAX_ENTRIES'] 
 
     def fetch(self):
         """
@@ -37,7 +38,7 @@ class GitHubActivity():
                     [element for element in [activity['title'],
                         activity['content'][0]['value']]])
 
-        return entries
+        return entries[0:self.max_entries]
 
 
 def fetch_github_activity(gen, metadata):

From c85ea081c076f63fad432267bb00d9ec038ab587 Mon Sep 17 00:00:00 2001
From: sil <sil@kryogenix.org>
Date: Sat, 15 Feb 2014 01:21:06 +0000
Subject: [PATCH 04/26] Simple Footnotes plugin. Add footnotes to your text by
 enclosing them in [ref] and [/ref].

---
 simple_footnotes/README.md                | 26 +++++++
 simple_footnotes/__init__.py              |  1 +
 simple_footnotes/simple_footnotes.py      | 91 +++++++++++++++++++++++
 simple_footnotes/test_simple_footnotes.py | 33 ++++++++
 4 files changed, 151 insertions(+)
 create mode 100644 simple_footnotes/README.md
 create mode 100644 simple_footnotes/__init__.py
 create mode 100644 simple_footnotes/simple_footnotes.py
 create mode 100644 simple_footnotes/test_simple_footnotes.py

diff --git a/simple_footnotes/README.md b/simple_footnotes/README.md
new file mode 100644
index 0000000..d4105cc
--- /dev/null
+++ b/simple_footnotes/README.md
@@ -0,0 +1,26 @@
+Simple Footnotes
+================
+
+A Pelican plugin to add footnotes to blog posts.
+
+When writing a post or page, add a footnote like this:
+
+    Here's my written text[ref]and here is a footnote[/ref].
+
+This will appear as, roughly:
+
+Here's my written text<sup>1</sup>
+
+ 1. and here is a footnote ↩
+
+Inspired by Andrew Nacin's [Simple Footnotes WordPress plugin](http://wordpress.org/plugins/simple-footnotes/).
+
+Requirements
+============
+
+Needs html5lib, so you'll want to `pip install html5lib` before running.
+
+Should work with any content format (ReST, Markdown, whatever), because
+it looks for the `[ref]` and `[/ref]` once the conversion to HTML has happened.
+
+Stuart Langridge, http://www.kryogenix.org/, February 2014.
diff --git a/simple_footnotes/__init__.py b/simple_footnotes/__init__.py
new file mode 100644
index 0000000..2f958a8
--- /dev/null
+++ b/simple_footnotes/__init__.py
@@ -0,0 +1 @@
+from .simple_footnotes import *
diff --git a/simple_footnotes/simple_footnotes.py b/simple_footnotes/simple_footnotes.py
new file mode 100644
index 0000000..ea2e480
--- /dev/null
+++ b/simple_footnotes/simple_footnotes.py
@@ -0,0 +1,91 @@
+from pelican import signals
+import re
+import html5lib
+
+RAW_FOOTNOTE_CONTAINERS = ["code"]
+
+def getText(node, recursive = False):
+    """Get all the text associated with this node.
+       With recursive == True, all text from child nodes is retrieved."""
+    L = ['']
+    for n in node.childNodes:
+        if n.nodeType in (node.TEXT_NODE, node.CDATA_SECTION_NODE):
+            L.append(n.data)
+        else:
+            if not recursive:
+                return None
+        L.append(getText(n) )
+    return ''.join(L)
+
+def parse_for_footnotes(article_generator):
+    for article in article_generator.articles:
+        if "[ref]" in article._content and "[/ref]" in article._content:
+            content = article._content.replace("[ref]", "<x-simple-footnote>").replace("[/ref]", "</x-simple-footnote>")
+            parser = html5lib.HTMLParser(tree=html5lib.getTreeBuilder("dom"))
+            dom = parser.parse(content)
+            endnotes = []
+            count = 0
+            for footnote in dom.getElementsByTagName("x-simple-footnote"):
+                pn = footnote
+                leavealone = False
+                while pn:
+                    if pn.nodeName in RAW_FOOTNOTE_CONTAINERS:
+                        leavealone = True
+                        break
+                    pn = pn.parentNode
+                if leavealone:
+                    continue
+                count += 1
+                fnid = "sf-%s-%s" % (article.slug, count)
+                fnbackid = "%s-back" % (fnid,)
+                endnotes.append((footnote, fnid, fnbackid))
+                number = dom.createElement("sup")
+                number.setAttribute("id", fnbackid)
+                numbera = dom.createElement("a")
+                numbera.setAttribute("href", "#%s" % fnid)
+                numbera.setAttribute("class", "simple-footnote")
+                numbera.appendChild(dom.createTextNode(str(count)))
+                txt = getText(footnote, recursive=True).replace("\n", " ")
+                numbera.setAttribute("title", txt)
+                number.appendChild(numbera)
+                footnote.parentNode.insertBefore(number, footnote)
+            if endnotes:
+                ol = dom.createElement("ol")
+                ol.setAttribute("class", "simple-footnotes")
+                for e, fnid, fnbackid in endnotes:
+                    li = dom.createElement("li")
+                    li.setAttribute("id", fnid)
+                    while e.firstChild:
+                        li.appendChild(e.firstChild)
+                    backlink = dom.createElement("a")
+                    backlink.setAttribute("href", "#%s" % fnbackid)
+                    backlink.setAttribute("class", "simple-footnote-back")
+                    backlink.appendChild(dom.createTextNode(u'\u21a9'))
+                    li.appendChild(dom.createTextNode(" "))
+                    li.appendChild(backlink)
+                    ol.appendChild(li)
+                    e.parentNode.removeChild(e)
+                dom.getElementsByTagName("body")[0].appendChild(ol)
+                s = html5lib.serializer.htmlserializer.HTMLSerializer(omit_optional_tags=False, quote_attr_values=True)
+                output_generator = s.serialize(html5lib.treewalkers.getTreeWalker("dom")(dom.getElementsByTagName("body")[0]))
+                article._content =  "".join(list(output_generator)).replace(
+                    "<x-simple-footnote>", "[ref]").replace("</x-simple-footnote>", "[/ref]").replace(
+                    "<body>", "").replace("</body>", "")
+        if False:
+            count = 0
+            endnotes = []
+            for f in footnotes:
+                count += 1
+                fnstr = '<a class="simple-footnote" name="%s-%s-back" href="#%s-%s"><sup>%s</a>' % (
+                    article.slug, count, article.slug, count, count)
+                endstr = '<li id="%s-%s">%s <a href="#%s-%s-back">&uarr;</a></li>' % (
+                    article.slug, count, f[len("[ref]"):-len("[/ref]")], article.slug, count)
+                content = content.replace(f, fnstr)
+                endnotes.append(endstr)
+            content += '<h4>Footnotes</h4><ol class="simple-footnotes">%s</ul>' % ("\n".join(endnotes),)
+            article._content = content
+
+
+def register():
+    signals.article_generator_finalized.connect(parse_for_footnotes)
+
diff --git a/simple_footnotes/test_simple_footnotes.py b/simple_footnotes/test_simple_footnotes.py
new file mode 100644
index 0000000..04af1dc
--- /dev/null
+++ b/simple_footnotes/test_simple_footnotes.py
@@ -0,0 +1,33 @@
+import unittest
+from simple_footnotes import parse_for_footnotes
+
+class PseudoArticleGenerator(object):
+    articles = []
+class PseudoArticle(object):
+    _content = ""
+    slug = "article"
+
+class TestFootnotes(unittest.TestCase):
+
+    def _expect(self, input, expected_output):
+        ag = PseudoArticleGenerator()
+        art = PseudoArticle()
+        art._content = input
+        ag.articles = [art]
+        parse_for_footnotes(ag)
+        self.assertEqual(art._content, expected_output)
+
+    def test_simple(self):
+        self._expect("words[ref]footnote[/ref]end",
+        ('words<sup id="sf-article-1-back"><a title="footnote" '
+         'href="#sf-article-1" class="simple-footnote">1</a></sup>end'
+         '<ol class="simple-footnotes">'
+         u'<li id="sf-article-1">footnote <a href="#sf-article-1-back" class="simple-footnote-back">\u21a9</a></li>'
+         '</ol>'))
+
+    def test_no_footnote_inside_code(self):
+        self._expect("words<code>this is code[ref]footnote[/ref] end code </code> end",
+            "words<code>this is code[ref]footnote[/ref] end code </code> end")
+
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file

From b86e17607c13e5ae1a607f589fcf7ae1d4000709 Mon Sep 17 00:00:00 2001
From: Samy Arous <samyarous@gmail.com>
Date: Sun, 16 Feb 2014 19:23:48 +0100
Subject: [PATCH 05/26] Initial release of the twitter bootstrap rst directives
 plugin

---
 twitter_bootstrap_rst_directives/Demo.rst     | 118 ++++
 twitter_bootstrap_rst_directives/Readme.rst   |  46 ++
 twitter_bootstrap_rst_directives/__init__.py  |   4 +
 .../bootstrap_rst_directives.py               | 543 ++++++++++++++++++
 4 files changed, 711 insertions(+)
 create mode 100644 twitter_bootstrap_rst_directives/Demo.rst
 create mode 100644 twitter_bootstrap_rst_directives/Readme.rst
 create mode 100644 twitter_bootstrap_rst_directives/__init__.py
 create mode 100644 twitter_bootstrap_rst_directives/bootstrap_rst_directives.py

diff --git a/twitter_bootstrap_rst_directives/Demo.rst b/twitter_bootstrap_rst_directives/Demo.rst
new file mode 100644
index 0000000..c38ae10
--- /dev/null
+++ b/twitter_bootstrap_rst_directives/Demo.rst
@@ -0,0 +1,118 @@
+This will be turned into :abbr:`HTML (HyperText Markup Language)`.
+
+Love this music :glyph:`music` 
+
+.. role:: story_time_glyph(glyph)
+    :target: http://www.youtube.com/watch?v=5g8ykQLYnX0
+    :class: small text-info  
+
+Love this music :story_time_glyph:`music` 
+
+This is an example of code: :code:`<example>`.
+
+This is an example of kbd: :kbd:`<example>`.
+
+
+.. label-default::
+    
+    This is a default label content
+
+.. label-primary::
+    
+    This is a primary label content
+
+.. label-success::
+    
+    This is a success label content
+
+.. label-info::
+    
+    This is a info label content
+
+.. label-warning::
+    
+    This is a warning label content
+
+.. label-danger::
+    
+    This is a danger label content
+
+
+.. panel-default::
+    :title: panel default title
+    
+    This is a default panel content
+
+.. panel-primary::
+    :title: panel primary title
+    
+    This is a primary panel content
+
+.. panel-success::
+    :title: panel success title
+    
+    This is a success panel content
+
+.. panel-info::
+    :title: panel info title
+    
+    This is a info panel content
+
+.. panel-warning::
+    :title: panel warning title
+    
+    This is a warning panel content
+
+.. panel-danger::
+    :title: panel danger title
+    
+    This is a danger panel content
+
+
+.. alert-success::
+    
+    This is a success alert content
+
+.. alert-info::
+    
+    This is a info alert content
+
+.. alert-warning::
+    
+    This is a warning alert content
+
+.. alert-danger::
+    
+    This is a danger alert content
+
+        
+.. media:: http://stuffkit.com/wp-content/uploads/2012/11/Worlds-Most-Beautiful-Lady-Camilla-Belle-HD-Photos-4.jpg
+                :height: 750
+                :width: 1000
+                :scale: 20
+                :target: http://www.google.com
+                :alt: Camilla Belle
+                :position: left
+
+                .. class:: h3
+
+                    left position
+
+                This image is not mine. Credit goes to http://stuffkit.com
+                
+
+
+.. media:: http://stuffkit.com/wp-content/uploads/2012/11/Worlds-Most-Beautiful-Lady-Camilla-Belle-HD-Photos-4.jpg
+                :height: 750
+                :width: 1000
+                :scale: 20
+                :target: http://www.google.com
+                :alt: Camilla Belle
+                :position: right
+
+                .. class:: h3
+
+                    right position
+
+
+                This image is not mine. Credit goes to http://stuffkit.com
\ No newline at end of file
diff --git a/twitter_bootstrap_rst_directives/Readme.rst b/twitter_bootstrap_rst_directives/Readme.rst
new file mode 100644
index 0000000..f84417c
--- /dev/null
+++ b/twitter_bootstrap_rst_directives/Readme.rst
@@ -0,0 +1,46 @@
+Twitter Bootstrap Directive for restructured text
+-------------------------------------------------
+
+This plugin defines some rst directive that enable a clean usage of the twitter bootstrap CSS and Javascript components.
+
+Directives
+----------
+
+Implemented directives:
+
+    label,
+    alert,
+    panel,
+    media
+
+Implemented roles:
+
+    glyph,
+    code,
+    kbd
+
+Usage
+-----
+
+For more informations about the usage of each directive, read the corresponding class description.
+Or checkout this demo page.
+
+Dependencies
+------------
+
+In order to use this plugin, you need to use a template that supports bootstrap 3.1.1 with the glyph font setup
+correctly. Usually you should have this structure::
+
+    static
+    ├──  css
+    |     └──  bootstrap.min.css
+    ├──  font
+    |     └──  glyphicons-halflings-regular.ttf
+    └──  js
+          └──     
+
+Warning
+-------
+
+In order to support some unique features and avoid conflicts with bootstrap, this plugin will use a custom html writer which
+is modifying the traditional docutils output.
\ No newline at end of file
diff --git a/twitter_bootstrap_rst_directives/__init__.py b/twitter_bootstrap_rst_directives/__init__.py
new file mode 100644
index 0000000..7dfdc27
--- /dev/null
+++ b/twitter_bootstrap_rst_directives/__init__.py
@@ -0,0 +1,4 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from .bootstrap_rst_directives import *
diff --git a/twitter_bootstrap_rst_directives/bootstrap_rst_directives.py b/twitter_bootstrap_rst_directives/bootstrap_rst_directives.py
new file mode 100644
index 0000000..8385134
--- /dev/null
+++ b/twitter_bootstrap_rst_directives/bootstrap_rst_directives.py
@@ -0,0 +1,543 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+"""
+Twitter Bootstrap RST directives Plugin For Pelican
+===================================================
+
+This plugin defines rst directives for different CSS and Javascript components from
+the twitter bootstrap framework.
+
+"""
+
+from uuid import uuid1
+
+from cgi import escape
+from docutils import nodes, utils
+import docutils
+from docutils.parsers import rst
+from docutils.parsers.rst import directives, roles, Directive
+from pelican import signals
+from pelican.readers import RstReader, PelicanHTMLTranslator
+
+
+
+class CleanHTMLTranslator(PelicanHTMLTranslator):
+
+    """
+        A custom HTML translator based on the Pelican HTML translator.
+        Used to clean up some components html classes that could conflict 
+        with the bootstrap CSS classes.
+        Also defines new tags that are not handleed by the current implementation of 
+        docutils.
+
+        The most obvious example is the Container component
+    """
+
+    def visit_literal(self, node):
+        classes = node.get('classes', node.get('class', []))
+        if 'code' in classes:
+            self.body.append(self.starttag(node, 'code'))
+        elif 'kbd' in classes:
+            self.body.append(self.starttag(node, 'kbd'))
+        else:
+            self.body.append(self.starttag(node, 'pre'))
+
+    def depart_literal(self, node):
+        classes = node.get('classes', node.get('class', []))
+        if 'code' in classes:
+            self.body.append('</code>\n')
+        elif 'kbd' in classes:
+            self.body.append('</kbd>\n')
+        else:
+            self.body.append('</pre>\n')
+
+    def visit_container(self, node):
+        self.body.append(self.starttag(node, 'div'))
+
+
+class CleanRSTReader(RstReader):
+
+    """
+        A custom RST reader that behaves exactly like its parent class RstReader with
+        the difference that it uses the CleanHTMLTranslator
+    """
+
+    def _get_publisher(self, source_path):
+        extra_params = {'initial_header_level': '2',
+                        'syntax_highlight': 'short',
+                        'input_encoding': 'utf-8'}
+        user_params = self.settings.get('DOCUTILS_SETTINGS')
+        if user_params:
+            extra_params.update(user_params)
+
+        pub = docutils.core.Publisher(
+            destination_class=docutils.io.StringOutput)
+        pub.set_components('standalone', 'restructuredtext', 'html')
+        pub.writer.translator_class = CleanHTMLTranslator
+        pub.process_programmatic_settings(None, extra_params, None)
+        pub.set_source(source_path=source_path)
+        pub.publish()
+        return pub
+
+
+def keyboard_role(name, rawtext, text, lineno, inliner,
+                  options={}, content=[]):
+    """
+        This function creates an inline console input block as defined in the twitter bootstrap documentation
+        overrides the default behaviour of the kbd role
+
+        *usage:*
+            :kbd:`<your code>`
+
+        *Example:*
+
+            :kbd:`<section>`
+
+        This code is not highlighted
+    """
+    new_element = nodes.literal(rawtext, text)
+    new_element.set_class('kbd')
+
+    return [new_element], []
+
+
+def code_role(name, rawtext, text, lineno, inliner,
+              options={}, content=[]):
+    """
+        This function creates an inline code block as defined in the twitter bootstrap documentation
+        overrides the default behaviour of the code role
+
+        *usage:*
+            :code:`<your code>`
+
+        *Example:*
+
+            :code:`<section>`
+
+        This code is not highlighted
+    """
+    new_element = nodes.literal(rawtext, text)
+    new_element.set_class('code')
+
+    return [new_element], []
+
+
+def glyph_role(name, rawtext, text, lineno, inliner,
+               options={}, content=[]):
+    """
+        This function defines a glyph inline role that show a glyph icon from the 
+        twitter bootstrap framework
+
+        *Usage:*
+
+            :glyph:`<glyph_name>`
+
+        *Example:*
+
+            Love this music :glyph:`music` :)
+
+        Can be subclassed to include a target
+
+        *Example:*
+
+            .. role:: story_time_glyph(glyph)
+                :target: http://www.youtube.com/watch?v=5g8ykQLYnX0
+                :class: small text-info
+
+            Love this music :story_time_glyph:`music` :)
+
+    """
+
+    target = options.get('target', None)
+    glyph_name = 'glyphicon-{}'.format(text)
+
+    if target:
+        target = utils.unescape(target)
+        new_element = nodes.reference(rawtext, ' ', refuri=target)
+    else:
+        new_element = nodes.container()
+    classes = options.setdefault('class', [])
+    classes += ['glyphicon', glyph_name]
+    for custom_class in classes:
+        new_element.set_class(custom_class)
+    return [new_element], []
+
+glyph_role.options = {
+    'target': rst.directives.unchanged,
+}
+glyph_role.content = False
+
+
+class Label(rst.Directive):
+
+    '''
+        generic Label directive class definition.
+        This class define a directive that shows 
+        bootstrap Labels around its content
+
+        *usage:*
+
+            .. label-<label-type>::
+
+                <Label content>
+
+        *example:*
+
+            .. label-default::
+
+                This is a default label content
+
+    '''
+
+    has_content = True
+    custom_class = ''
+
+    def run(self):
+        # First argument is the name of the glyph
+        label_name = 'label-{}'.format(self.custom_class)
+        # get the label content
+        text = '\n'.join(self.content)
+        # Create a new container element (div)
+        new_element = nodes.container(text)
+        # Update its content
+        self.state.nested_parse(self.content, self.content_offset,
+                                new_element)
+        # Set its custom bootstrap classes
+        new_element['classes'] += ['label ', label_name]
+        # Return one single element
+        return [new_element]
+
+
+class DefaultLabel(Label):
+
+    custom_class = 'default'
+
+
+class PrimaryLabel(Label):
+
+    custom_class = 'primary'
+
+
+class SuccessLabel(Label):
+
+    custom_class = 'success'
+
+
+class InfoLabel(Label):
+
+    custom_class = 'info'
+
+
+class WarningLabel(Label):
+
+    custom_class = 'warning'
+
+
+class DangerLabel(Label):
+
+    custom_class = 'danger'
+
+
+class Panel(rst.Directive):
+
+    """
+        generic Panel directive class definition.
+        This class define a directive that shows 
+        bootstrap Labels around its content
+
+        *usage:*
+
+            .. panel-<panel-type>:: 
+                :title: <title>
+
+                <Panel content>
+
+        *example:*
+
+            .. panel-default:: 
+                :title: panel title
+
+                This is a default panel content
+
+    """
+
+    has_content = True
+    option_spec = {
+        'title': rst.directives.unchanged,
+    }
+    custom_class = ''
+
+    def run(self):
+        # First argument is the name of the glyph
+        panel_name = 'panel-{}'.format(self.custom_class)
+        # get the label title
+        title_text = self.options.get('title', self.custom_class.title())
+        # get the label content
+        text = '\n'.join(self.content)
+        # Create the panel element
+        panel_element = nodes.container()
+        panel_element['classes'] += ['panel', panel_name]
+        # Create the panel headings
+        heading_element = nodes.container(title_text)
+        title_nodes, messages = self.state.inline_text(title_text,
+                                                       self.lineno)
+        title = nodes.paragraph(title_text, '', *title_nodes)
+        heading_element.append(title)
+        heading_element['classes'] += ['panel-heading']
+        # Create a new container element (div)
+        body_element = nodes.container(text)
+        # Update its content
+        self.state.nested_parse(self.content, self.content_offset,
+                                body_element)
+        # Set its custom bootstrap classes
+        body_element['classes'] += ['panel-body']
+        # add the heading and body to the panel
+        panel_element.append(heading_element)
+        panel_element.append(body_element)
+        # Return the panel element
+        return [panel_element]
+
+
+class DefaultPanel(Panel):
+
+    custom_class = 'default'
+
+
+class PrimaryPanel(Panel):
+
+    custom_class = 'primary'
+
+
+class SuccessPanel(Panel):
+
+    custom_class = 'success'
+
+
+class InfoPanel(Panel):
+
+    custom_class = 'info'
+
+
+class WarningPanel(Panel):
+
+    custom_class = 'warning'
+
+
+class DangerPanel(Panel):
+
+    custom_class = 'danger'
+
+
+class Alert(rst.Directive):
+
+    """
+        generic Alert directive class definition.
+        This class define a directive that shows 
+        bootstrap Labels around its content
+
+        *usage:*
+
+            .. alert-<alert-type>::
+
+                <alert content>
+
+        *example:*
+
+            .. alert-default::
+
+                This is a default alert content
+
+    """
+    has_content = True
+    custom_class = ''
+
+    def run(self):
+        # First argument is the name of the glyph
+        alert_name = 'alert-{}'.format(self.custom_class)
+        # get the label content
+        text = '\n'.join(self.content)
+        # Create a new container element (div)
+        new_element = nodes.compound(text)
+        # Update its content
+        self.state.nested_parse(self.content, self.content_offset,
+                                new_element)
+        # Recurse inside its children and change the hyperlinks classes
+        for child in new_element.traverse(include_self=False):
+            if isinstance(child, nodes.reference):
+                child.set_class('alert-link')
+        # Set its custom bootstrap classes
+        new_element['classes'] += ['alert ', alert_name]
+        # Return one single element
+        return [new_element]
+
+
+class SuccessAlert(Alert):
+
+    custom_class = 'success'
+
+
+class InfoAlert(Alert):
+
+    custom_class = 'info'
+
+
+class WarningAlert(Alert):
+
+    custom_class = 'warning'
+
+
+class DangerAlert(Alert):
+
+    custom_class = 'danger'
+
+
+class Media(rst.Directive):
+
+    '''
+        generic Media directive class definition.
+        This class define a directive that shows 
+        bootstrap media image with text according
+        to the media component on bootstrap
+
+        *usage*:
+            .. media:: <image_uri>
+                :position: <position>
+                :alt: <alt>
+                :height: <height>
+                :width: <width>
+                :scale: <scale>
+                :target: <target>
+
+                <text content>
+
+        *example*:
+            .. media:: http://stuffkit.com/wp-content/uploads/2012/11/Worlds-Most-Beautiful-Lady-Camilla-Belle-HD-Photos-4.jpg
+                :height: 750
+                :width: 1000
+                :scale: 20
+                :target: www.google.com
+                :alt: Camilla Belle
+                :position: left
+
+                This image is not mine. Credit goes to http://stuffkit.com
+
+
+
+    '''
+
+    has_content = True
+    required_arguments = 1
+
+    option_spec = {
+        'position': str,
+        'alt': rst.directives.unchanged,
+        'height': rst.directives.length_or_unitless,
+        'width': rst.directives.length_or_percentage_or_unitless,
+        'scale': rst.directives.percentage,
+        'target': rst.directives.unchanged_required,
+    }
+
+    def get_image_element(self):
+        # Get the image url
+        image_url = self.arguments[0]
+        image_reference = rst.directives.uri(image_url)
+        self.options['uri'] = image_reference
+
+        reference_node = None
+        messages = []
+        if 'target' in self.options:
+            block = rst.states.escape2null(
+                self.options['target']).splitlines()
+            block = [line for line in block]
+            target_type, data = self.state.parse_target(
+                block, self.block_text, self.lineno)
+            if target_type == 'refuri':
+                container_node = nodes.reference(refuri=data)
+            elif target_type == 'refname':
+                container_node = nodes.reference(
+                    refname=fully_normalize_name(data),
+                    name=whitespace_normalize_name(data))
+                container_node.indirect_reference_name = data
+                self.state.document.note_refname(container_node)
+            else:                           # malformed target
+                messages.append(data)       # data is a system message
+            del self.options['target']
+        else:
+            container_node = nodes.container()
+
+        # get image position
+        position = self.options.get('position', 'left')
+        position_class = 'pull-{}'.format(position)
+
+        container_node.set_class(position_class)
+
+        image_node = nodes.image(self.block_text, **self.options)
+        image_node['classes'] += ['media-object']
+
+        container_node.append(image_node)
+        return container_node
+
+    def run(self):
+        # now we get the content
+        text = '\n'.join(self.content)
+
+        # get image alternative text
+        alternative_text = self.options.get('alternative-text', '')
+
+        # get container element
+        container_element = nodes.container()
+        container_element['classes'] += ['media']
+
+        # get image element
+        image_element = self.get_image_element()
+
+        # get body element
+        body_element = nodes.container(text)
+        body_element['classes'] += ['media-body']
+        self.state.nested_parse(self.content, self.content_offset,
+                                body_element)
+
+        container_element.append(image_element)
+        container_element.append(body_element)
+        return [container_element, ]
+
+
+def register_directives():
+    rst.directives.register_directive('label-default', DefaultLabel)
+    rst.directives.register_directive('label-primary', PrimaryLabel)
+    rst.directives.register_directive('label-success', SuccessLabel)
+    rst.directives.register_directive('label-info', InfoLabel)
+    rst.directives.register_directive('label-warning', WarningLabel)
+    rst.directives.register_directive('label-danger', DangerLabel)
+
+    rst.directives.register_directive('panel-default', DefaultPanel)
+    rst.directives.register_directive('panel-primary', PrimaryPanel)
+    rst.directives.register_directive('panel-success', SuccessPanel)
+    rst.directives.register_directive('panel-info', InfoPanel)
+    rst.directives.register_directive('panel-warning', WarningPanel)
+    rst.directives.register_directive('panel-danger', DangerPanel)
+
+    rst.directives.register_directive('alert-success', SuccessAlert)
+    rst.directives.register_directive('alert-info', InfoAlert)
+    rst.directives.register_directive('alert-warning', WarningAlert)
+    rst.directives.register_directive('alert-danger', DangerAlert)
+
+    rst.directives.register_directive( 'media', Media )
+
+
+def register_roles():
+    rst.roles.register_local_role('glyph', glyph_role)
+    rst.roles.register_local_role('code', code_role)
+    rst.roles.register_local_role('kbd', keyboard_role)
+
+
+def add_reader(readers):
+    readers.reader_classes['rst'] = CleanRSTReader
+
+
+def register():
+    register_directives()
+    register_roles()
+    signals.readers_init.connect(add_reader)

From 474b7fd2ff5af4b574932db9c93a7fa475a34c20 Mon Sep 17 00:00:00 2001
From: Barry Steyn <barry.steyn@gmail.com>
Date: Mon, 17 Feb 2014 06:14:52 -0800
Subject: [PATCH 06/26] new latex math plugin, now handles typogrify correctly
 and does not need template alteration to be used

---
 latex/Readme.md |  86 ++++++-------
 latex/latex.py  | 334 +++++++++++++++++++++++++++++++++++++++++++-----
 2 files changed, 346 insertions(+), 74 deletions(-)

diff --git a/latex/Readme.md b/latex/Readme.md
index 51424ce..54d27ef 100644
--- a/latex/Readme.md
+++ b/latex/Readme.md
@@ -3,73 +3,73 @@ Latex Plugin For Pelican
 
 This plugin allows you to write mathematical equations in your articles using Latex.
 It uses the MathJax Latex JavaScript library to render latex that is embedded in
-between `$..$` for inline math and `$$..$$` for displayed math. It also allows for 
+between `$..$` for inline math and `$$..$$` for displayed math. It also allows for
 writing equations in by using `\begin{equation}`...`\end{equation}`.
 
 Installation
 ------------
-
 To enable, ensure that `latex.py` is put somewhere that is accessible.
 Then use as follows by adding the following to your settings.py:
 
     PLUGINS = ["latex"]
 
-Be careful: Not loading the plugin is easy to do, and difficult to detect. To
-make life easier, find where pelican is installed, and then copy the plugin
-there. An easy way to find where pelican is installed is to verbose list the
-available themes by typing `pelican-themes -l -v`. 
+Your site is now capable of rendering latex math using the mathjax JavaScript
+library. No alterations to the template file is needed.
 
-Once the pelican folder is found, copy `latex.py` to the `plugins` folder. Then 
-add to settings.py like this:
-
-    PLUGINS = ["pelican.plugins.latex"]
-
-Now all that is left to do is to embed the following to your template file 
-between the `<head>` parameters (for the NotMyIdea template, this file is base.html)
-
-    {% if article and article.latex %}
-        {{ article.latex }}
-    {% endif %}
-    {% if page and page.latex %}
-        {{ page.latex }}
-    {% endif %}
+### Typogrify
+Typogrify will now play nicely with Latex (i.e. typogrify can be enabled
+and Latex will be rendered correctly). In order for this to happen,
+version 2.07 (or above) of typogrify is required. In fact, this plugin expects
+that at least version 2.07 is present and will fail without it.
 
 Usage
 -----
-Latex will be embedded in every article. If however you want latex only for
-selected articles, then in settings.py, add
+### Bakcward Compatibility
+This plugin is backward compatible in the sense that it
+accompishes what previous versions did without needing any setup in the
+metadata or settings files.
 
-    LATEX = 'article'
+### Settings File
+Extra options regarding how mathjax renders latex can be set in the settings
+file. These options are in a dictionary variable called `LATEX` in the pelican
+settings file.
 
-And in each article, add the metadata key `latex:`. For example, with the above
-settings, creating an article that I want to render latex math, I would just 
-include 'Latex' as part of the metadata without any value:
+The dictionary can be set with the following keys:
 
-    Date: 1 sep 2012
-    Status: draft
-    Latex:
+ * `wrap`: controls the tags that math is wrapped with inside the resulting
+html. For example, setting `wrap` to `'mathjax'` would wrap all math inside
+`<mathjax>...</mathjax>` tags. If typogrify is set to True, then math needs
+to be wrapped in tags and `wrap` will therefore default to `mathjax` if not
+set.
+ * `align`: controls how displayed math will be aligned. Can be set to either
+`left`, `right` or `center` (default is `center`).
+ * `indent`: if `align` not set to `center`, then this controls the indent
+level (default is `0em`).
+ * `show_menu`: controls whether the mathjax contextual menu is shown.
+ * `process_escapes`: controls whether mathjax processes escape sequences.
+ * `preview`: controls the preview message users are seen while mathjax is
+loading.
+ * `color`: controls the color of the mathjax rendered font.
+
+For example, in settings.py, the following would make latex render in blue and
+displaymath align to the left:
+
+    LATEX = {'color':'blue','align':left}
 
 Latex Examples
 --------------
 ###Inline
-Latex between `$`..`$`, for example, `$`x^2`$`, will be rendered inline 
+Latex between `$`..`$`, for example, `$`x^2`$`, will be rendered inline
 with respect to the current html block.
 
 ###Displayed Math
-Latex between `$$`..`$$`, for example, `$$`x^2`$$`, will be rendered centered in a 
+Latex between `$$`..`$$`, for example, `$$`x^2`$$`, will be rendered centered in a
 new paragraph.
 
 ###Equations
-Latex between `\begin` and `\end`, for example, `begin{equation}` x^2 `\end{equation}`, 
-will be rendered centered in a new paragraph with a right justified equation number 
-at the top of the paragraph. This equation number can be referenced in the document. 
-To do this, use a `label` inside of the equation format and then refer to that label 
-using `ref`. For example: `begin{equation}` `\label{eq}` X^2 `\end{equation}`. Now 
+Latex between `\begin` and `\end`, for example, `begin{equation}` x^2 `\end{equation}`,
+will be rendered centered in a new paragraph with a right justified equation number
+at the top of the paragraph. This equation number can be referenced in the document.
+To do this, use a `label` inside of the equation format and then refer to that label
+using `ref`. For example: `begin{equation}` `\label{eq}` X^2 `\end{equation}`. Now
 refer to that equation number by `$`\ref{eq}`$`.
-   
-Template And Article Examples
------------------------------
-To see an example of this plugin in action, look at 
-[this article](http://doctrina.org/How-RSA-Works-With-Examples.html). To see how 
-this plugin works with a template, look at 
-[this template](https://github.com/barrysteyn/pelican_theme-personal_blog).
diff --git a/latex/latex.py b/latex/latex.py
index 1d4c579..b1022e0 100644
--- a/latex/latex.py
+++ b/latex/latex.py
@@ -5,51 +5,323 @@ Latex Plugin For Pelican
 
 This plugin allows you to write mathematical equations in your articles using Latex.
 It uses the MathJax Latex JavaScript library to render latex that is embedded in
-between `$..$` for inline math and `$$..$$` for displayed math. It also allows for 
-writing equations in by using `\begin{equation}`...`\end{equation}`.
+between `$..$` for inline math and `$$..$$` for displayed math. It also allows for
+writing equations in by using `\begin{equation}`...`\end{equation}`. No
+alteration to a template is required for this plugin to work, just install and
+use.
+
+Typogrify Compatibility
+-----------------------
+This plugin now plays nicely with typogrify, but it requires
+typogrify version 2.07 or above.
+
+User Settings
+-------------
+Users are also able to pass a dictionary of settings in the settings file which
+will control how the mathjax library renders thing. This could be very useful
+for template builders that want to adjust look and feel of the math.
+See README for more details.
 """
 
 from pelican import signals
+from pelican import contents
+import re
 
-# Reference about dynamic loading of MathJax can be found at http://docs.mathjax.org/en/latest/dynamic.html
-# The https cdn address can be found at http://www.mathjax.org/resources/faqs/#problem-https
-latexScript = """
-    <script type= "text/javascript">
+# Global Variables
+_WRAP_TAG = None  # the tag to wrap mathjax in (needed to play nicely with typogrify or for template designers)
+_LATEX_REGEX = re.compile(r'(\$\$|\$|\\begin\{(.+?)\}).*?\1|\\end\{\2\}', re.DOTALL | re.IGNORECASE) #  used to detect latex
+_LATEX_SUMMARY_REGEX = None  # used to match latex in summary
+_LATEX_PARTIAL_REGEX = None  # used to match latex that has been cut off in summary
+_MATHJAX_SETTINGS = {}  # Settings that can be specified by the user, used to control mathjax script settings
+_MATHJAX_SCRIPT="""
+<script type= "text/javascript">
+    if (!document.getElementById('mathjaxscript_pelican')) {{
         var s = document.createElement('script');
-        s.type = 'text/javascript';
-        s.src = 'https:' == document.location.protocol ? 'https://c328740.ssl.cf1.rackcdn.com/mathjax/latest/MathJax.js' : 'http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML'; 
+        s.id = 'mathjaxscript_pelican';
+        s.type = 'text/javascript'; s.src = 'https:' == document.location.protocol ? 'https://c328740.ssl.cf1.rackcdn.com/mathjax/latest/MathJax.js' : 'http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML';
         s[(window.opera ? "innerHTML" : "text")] =
-            "MathJax.Hub.Config({" + 
-            "    config: ['MMLorHTML.js']," + 
-            "    jax: ['input/TeX','input/MathML','output/HTML-CSS','output/NativeMML']," +
-            "    TeX: { extensions: ['AMSmath.js','AMSsymbols.js','noErrors.js','noUndefined.js'], equationNumbers: { autoNumber: 'AMS' } }," + 
+            "MathJax.Hub.Config({{" +
+            "    config: ['MMLorHTML.js']," +
+            "    TeX: {{ extensions: ['AMSmath.js','AMSsymbols.js','noErrors.js','noUndefined.js'], equationNumbers: {{ autoNumber: 'AMS' }} }}," +
+            "    jax: ['input/TeX','input/MathML','output/HTML-CSS']," +
             "    extensions: ['tex2jax.js','mml2jax.js','MathMenu.js','MathZoom.js']," +
-            "    tex2jax: { " +
+            "    displayAlign: '{align}'," +
+            "    displayIndent: '{indent}'," +
+            "    showMathMenu: {show_menu}," +
+            "    tex2jax: {{ " +
             "        inlineMath: [ [\'$\',\'$\'] ], " +
             "        displayMath: [ [\'$$\',\'$$\'] ]," +
-            "        processEscapes: true }, " +
-            "    'HTML-CSS': { " +
-            "        styles: { '.MathJax .mo, .MathJax .mi': {color: 'black ! important'}} " +
-            "    } " +
-            "}); ";
+            "        processEscapes: {process_escapes}," +
+            "        preview: '{preview}'," +
+            "    }}, " +
+            "    'HTML-CSS': {{ " +
+            "        styles: {{ '.MathJax_Display, .MathJax .mo, .MathJax .mi, .MathJax .mn': {{color: '{color} ! important'}} }}" +
+            "    }} " +
+            "}}); ";
         (document.body || document.getElementsByTagName('head')[0]).appendChild(s);
-    </script>
+    }}
+</script>
 """
 
-def addLatex(gen, metadata):
+
+# Python standard library for binary search, namely bisect is cool but I need
+# specific business logic to evaluate my search predicate, so I am using my
+# own version
+def binary_search(match_tuple, ignore_within):
+    """Determines if t is within tupleList. Using the fact that tupleList is
+    ordered, binary search can be performed which is O(logn)
     """
-        The registered handler for the latex plugin. It will add 
-        the latex script to the article metadata
+
+    ignore = False
+    if ignore_within == []:
+        return False
+
+    lo = 0
+    hi = len(ignore_within)-1
+
+    # Find first value in array where predicate is False
+    # predicate function: tupleList[mid][0] < t[index]
+    while lo < hi:
+        mid = lo + (hi-lo+1)/2
+        if ignore_within[mid][0] < match_tuple[0]:
+            lo = mid
+        else:
+            hi = mid-1
+
+    if lo >= 0 and lo <= len(ignore_within)-1:
+        ignore = (ignore_within[lo][0] <= match_tuple[0] and ignore_within[lo][1] >= match_tuple[1])
+
+    return ignore
+
+
+def ignore_content(content):
+    """Creates a list of match span tuples for which content should be ignored
+    e.g. <pre> and <code> tags
     """
-    if 'LATEX' in gen.settings.keys() and gen.settings['LATEX'] == 'article':
-        if 'latex' in metadata.keys():
-            metadata['latex'] = latexScript
+    ignore_within = []
+
+    # used to detect all <pre> and <code> tags. NOTE: Alter this regex should
+    # additional tags need to be ignored
+    ignore_regex = re.compile(r'<(pre|code).*?>.*?</(\1)>', re.DOTALL | re.IGNORECASE)
+
+    for match in ignore_regex.finditer(content):
+        ignore_within.append(match.span())
+
+    return ignore_within
+
+
+def wrap_latex(content, ignore_within):
+    """Wraps latex in user specified tags.
+
+    This is needed for typogrify to play nicely with latex but it can also be
+    styled by template providers
+    """
+    wrap_latex.foundlatex = False
+
+    def math_tag_wrap(match):
+        """function for use in re.sub"""
+
+        # determine if the tags are within <pre> and <code> blocks
+        ignore = binary_search(match.span(1), ignore_within) and binary_search(match.span(2), ignore_within)
+
+        if ignore:
+            return match.group(0)
+        else:
+            wrap_latex.foundlatex = True
+            return '<%s>%s</%s>' % (_WRAP_TAG, match.group(0), _WRAP_TAG)
+
+    return (_LATEX_REGEX.sub(math_tag_wrap, content), wrap_latex.foundlatex)
+
+
+def process_summary(instance, ignore_within):
+    """Summaries need special care. If Latex is cut off, it must be restored.
+
+    In addition, the mathjax script must be included if necessary thereby
+    making it independent to the template
+    """
+
+    process_summary.altered_summary = False
+    insert_mathjax_script = False
+    endtag = '</%s>' % _WRAP_TAG if _WRAP_TAG != None else ''
+
+    # use content's _get_summary method to obtain summary
+    summary = instance._get_summary()
+
+    # Determine if there is any math in the summary which are not within the
+    # ignore_within tags
+    mathitem = None
+    for mathitem in _LATEX_SUMMARY_REGEX.finditer(summary):
+        if binary_search(mathitem.span(), ignore_within):
+            mathitem = None # In <code> or <pre> tags, so ignore
+        else:
+            insert_mathjax_script = True
+
+    # Repair the latex if it was cut off mathitem will be the final latex
+    # code  matched that is not within <pre> or <code> tags
+    if mathitem and mathitem.group(4) == ' ...':
+        end = r'\end{%s}' % mathitem.group(3) if mathitem.group(3) is not None else mathitem.group(2)
+        latex_match = re.search('%s.*?%s' % (re.escape(mathitem.group(1)), re.escape(end)), instance._content, re.DOTALL | re.IGNORECASE)
+        new_summary = summary.replace(mathitem.group(0), latex_match.group(0)+'%s ...' % endtag)
+
+        if new_summary != summary:
+            return new_summary+_MATHJAX_SCRIPT.format(**_MATHJAX_SETTINGS)
+
+    def partial_regex(match):
+        """function for use in re.sub"""
+        if binary_search(match.span(), ignore_within):
+            return match.group(0)
+
+        process_summary.altered_summary = True
+        return match.group(1) + match.group(4)
+
+    # check for partial latex tags at end. These must be removed
+    summary = _LATEX_PARTIAL_REGEX.sub(partial_regex, summary)
+
+    if process_summary.altered_summary:
+        return summary+_MATHJAX_SCRIPT.format(**_MATHJAX_SETTINGS) if insert_mathjax_script else summary
+
+    return summary+_MATHJAX_SCRIPT.format(**_MATHJAX_SETTINGS) if insert_mathjax_script else None
+
+
+def process_settings(settings):
+    """Sets user specified MathJax settings (see README for more details)"""
+
+    global _MATHJAX_SETTINGS
+
+    # NOTE TO FUTURE DEVELOPERS: Look at the README and what is happening in
+    # this function if any additional changes to the mathjax settings need to
+    # be incorporated. Also, please inline comment what the variables
+    # will be used for
+
+    # Default settings
+    _MATHJAX_SETTINGS['align'] = 'center'  # controls alignment of of displayed equations (values can be: left, right, center)
+    _MATHJAX_SETTINGS['indent'] = '0em'  # if above is not set to 'center', then this setting acts as an indent
+    _MATHJAX_SETTINGS['show_menu'] = 'true'  # controls whether to attach mathjax contextual menu
+    _MATHJAX_SETTINGS['process_escapes'] = 'true'  # controls whether escapes are processed
+    _MATHJAX_SETTINGS['preview'] = 'TeX'  # controls what user sees as preview
+    _MATHJAX_SETTINGS['color'] = 'black'  # controls color math is rendered in
+
+    if not isinstance(settings, dict):
+        return
+
+    # The following mathjax settings can be set via the settings dictionary
+    # Iterate over dictionary in a way that is compatible with both version 2
+    # and 3 of python
+    for key, value in ((key, settings[key]) for key in settings):
+        if key == 'align' and isinstance(value, str):
+            if value == 'left' or value == 'right' or value == 'center':
+                _MATHJAX_SETTINGS[key] = value
+            else:
+                _MATHJAX_SETTINGS[key] = 'center'
+
+        if key == 'indent':
+            _MATHJAX_SETTINGS[key] = value
+
+        if key == 'show_menu' and isinstance(value, bool):
+            _MATHJAX_SETTINGS[key] = 'true' if value else 'false'
+
+        if key == 'process_escapes' and isinstance(value, bool):
+            _MATHJAX_SETTINGS[key] = 'true' if value else 'false'
+
+        if key == 'preview' and isinstance(value, str):
+            _MATHJAX_SETTINGS[key] = value
+
+        if key == 'color' and isinstance(value, str):
+            _MATHJAX_SETTINGS[key] = value
+
+
+def process_content(instance):
+    """Processes content, with logic to ensure that typogrify does not clash
+    with latex.
+
+    In addition, mathjax script is inserted at the end of the content thereby
+    making it independent of the template
+    """
+
+    if not instance._content:
+        return
+
+    ignore_within = ignore_content(instance._content)
+
+    if _WRAP_TAG:
+        instance._content, latex = wrap_latex(instance._content, ignore_within)
     else:
-        metadata['latex'] = latexScript
+        latex = True if _LATEX_REGEX.search(instance._content) else False
+
+    # The user initially set typogrify to be True, but since it would clash
+    # with latex, we set it to False. This means that the default reader will
+    # not call typogrify, so it is called here, where we are able to control
+    # logic for it ignore latex if necessary
+    if process_content.typogrify:
+        # Tell typogrify to ignore the tags that latex has been wrapped in
+        ignore_tags = [_WRAP_TAG] if _WRAP_TAG else None
+
+        # Exact copy of the logic as found in the default reader
+        from typogrify.filters import typogrify
+        instance._content = typogrify(instance._content, ignore_tags)
+        instance.metadata['title'] = typogrify(instance.metadata['title'], ignore_tags)
+
+    if latex:
+        # Mathjax script added to the end of article. Now it does not need to
+        # be explicitly added to the template
+        instance._content += _MATHJAX_SCRIPT.format(**_MATHJAX_SETTINGS)
+
+        # The summary needs special care because latex math cannot just be cut
+        # off
+        summary = process_summary(instance, ignore_within)
+        if summary != None:
+            instance._summary = summary
+
+
+def pelican_init(pelicanobj):
+    """Intialializes certain global variables and sets typogogrify setting to
+    False should it be set to True.
+    """
+
+    global _WRAP_TAG
+    global _LATEX_SUMMARY_REGEX
+    global _LATEX_PARTIAL_REGEX
+
+    try:
+        settings = pelicanobj.settings['LATEX']
+    except:
+        settings = None
+
+    process_settings(settings)
+
+    # Allows mathjax script to be accessed from template should it be needed
+    pelicanobj.settings['MATHJAXSCRIPT'] = _MATHJAX_SCRIPT.format(**_MATHJAX_SETTINGS)
+
+    # If typogrify set to True, then we need to handle it manually so it does
+    # not conflict with Latex
+    try:
+        if pelicanobj.settings['TYPOGRIFY'] == True:
+            pelicanobj.settings['TYPOGRIFY'] = False
+            _WRAP_TAG = 'mathjax' # default to wrap mathjax content inside of
+            process_content.typogrify = True
+    except KeyError:
+        pass
+
+    # Set _WRAP_TAG to the settings tag if defined. The idea behind this is
+    # to give template designers control over how math would be rendered
+    try:
+        if pelicanobj.settings['LATEX']['wrap']:
+            _WRAP_TAG = pelicanobj.settings['LATEX']['wrap']
+    except (KeyError, TypeError):
+        pass
+
+    # regular expressions that depend on _WRAP_TAG are set here
+    tagstart = r'<%s>' % _WRAP_TAG if not _WRAP_TAG is None else ''
+    tagend = r'</%s>' % _WRAP_TAG if not _WRAP_TAG is None else ''
+    latex_summary_regex = r'((\$\$|\$|\\begin\{(.+?)\}).+?)(\2|\\end\{\3\}|\s?\.\.\.)(%s)?' % tagend
+    latex_partial_regex = r'(.*)(%s)(\\.*?|\$.*?)(\s?\.\.\.)(%s)' % (tagstart, tagend)
+
+    _LATEX_SUMMARY_REGEX = re.compile(latex_summary_regex, re.DOTALL | re.IGNORECASE)
+    _LATEX_PARTIAL_REGEX = re.compile(latex_partial_regex, re.DOTALL | re.IGNORECASE)
+
 
 def register():
-    """
-        Plugin registration
-    """
-    signals.article_generator_context.connect(addLatex)
-    signals.page_generator_context.connect(addLatex)
+    """Plugin registration"""
+
+    signals.initialized.connect(pelican_init)
+    signals.content_object_init.connect(process_content)

From 8ac0e61720a0a42b8d8dea513c6cf15be564c835 Mon Sep 17 00:00:00 2001
From: Barry Steyn <barry.steyn@gmail.com>
Date: Tue, 18 Feb 2014 08:21:09 -0800
Subject: [PATCH 07/26] Update Readme.md

Fixed spelling error
---
 latex/Readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/latex/Readme.md b/latex/Readme.md
index 54d27ef..49888b8 100644
--- a/latex/Readme.md
+++ b/latex/Readme.md
@@ -24,7 +24,7 @@ that at least version 2.07 is present and will fail without it.
 
 Usage
 -----
-### Bakcward Compatibility
+### Backward Compatibility
 This plugin is backward compatible in the sense that it
 accompishes what previous versions did without needing any setup in the
 metadata or settings files.

From 5d3ab5b9642b3cf3ec557ff72fa72ec9e6ab5195 Mon Sep 17 00:00:00 2001
From: Barry Steyn <barry.steyn@gmail.com>
Date: Wed, 19 Feb 2014 08:18:43 -0800
Subject: [PATCH 08/26] Logic for MathMl; Fixed Bug; Updated Readme

---
 latex/Readme.md | 40 ++++++++++++++++++++++++++---------
 latex/latex.py  | 56 +++++++++++++++++++++++++++++++++----------------
 2 files changed, 68 insertions(+), 28 deletions(-)

diff --git a/latex/Readme.md b/latex/Readme.md
index 49888b8..8ee917d 100644
--- a/latex/Readme.md
+++ b/latex/Readme.md
@@ -1,10 +1,20 @@
 Latex Plugin For Pelican
 ========================
 
-This plugin allows you to write mathematical equations in your articles using Latex.
-It uses the MathJax Latex JavaScript library to render latex that is embedded in
-between `$..$` for inline math and `$$..$$` for displayed math. It also allows for
-writing equations in by using `\begin{equation}`...`\end{equation}`.
+This plugin allows you to write mathematical equations in your articles using Latex and MathMl.
+It uses the MathJax Latex JavaScript library to render *Latex* and *MathMl* that is embedded in
+your site.
+
+### Latex
+Anything between `$..$` (inline math) and `$$..$$` (displayed math) will be recognized as
+Latex. In addition, anything between between `\begin` and `\end` macros will also be 
+recognized as Latex. For example, `\begin{equation}`...`\end{equation}` would be used to 
+render math equations with numbering.
+
+Within recognized Latex as described above, Latex macros can be used.
+
+### MathMl
+Anything between `<math>` and `</math>` tags will be recognized as *MathMl*.
 
 Installation
 ------------
@@ -13,7 +23,7 @@ Then use as follows by adding the following to your settings.py:
 
     PLUGINS = ["latex"]
 
-Your site is now capable of rendering latex math using the mathjax JavaScript
+Your site is now capable of rendering math math using the mathjax JavaScript
 library. No alterations to the template file is needed.
 
 ### Typogrify
@@ -22,15 +32,24 @@ and Latex will be rendered correctly). In order for this to happen,
 version 2.07 (or above) of typogrify is required. In fact, this plugin expects
 that at least version 2.07 is present and will fail without it.
 
+### Summaries
+Summaries that contain math are processed to ensure that math is not off. If
+math is cut off, it will add it back into the summary.
+
+### Templates
+No alteration is needed to a template for this plugin to work. Just install
+the plugin and start writing your Math.
+
 Usage
 -----
 ### Backward Compatibility
 This plugin is backward compatible in the sense that it
-accompishes what previous versions did without needing any setup in the
-metadata or settings files.
+will render previous setups correctly. This is because those
+settings and metadata information is ignored by this version. Therefore
+you can remove them to neaten up your site
 
 ### Settings File
-Extra options regarding how mathjax renders latex can be set in the settings
+Extra options regarding how mathjax renders math can be set in the settings
 file. These options are in a dictionary variable called `LATEX` in the pelican
 settings file.
 
@@ -40,7 +59,8 @@ The dictionary can be set with the following keys:
 html. For example, setting `wrap` to `'mathjax'` would wrap all math inside
 `<mathjax>...</mathjax>` tags. If typogrify is set to True, then math needs
 to be wrapped in tags and `wrap` will therefore default to `mathjax` if not
-set.
+set. `wrap` cannot be set to `'math'` because this tag is reserved for 
+mathml notation
  * `align`: controls how displayed math will be aligned. Can be set to either
 `left`, `right` or `center` (default is `center`).
  * `indent`: if `align` not set to `center`, then this controls the indent
@@ -51,7 +71,7 @@ level (default is `0em`).
 loading.
  * `color`: controls the color of the mathjax rendered font.
 
-For example, in settings.py, the following would make latex render in blue and
+For example, in settings.py, the following would make math render in blue and
 displaymath align to the left:
 
     LATEX = {'color':'blue','align':left}
diff --git a/latex/latex.py b/latex/latex.py
index b1022e0..f0570be 100644
--- a/latex/latex.py
+++ b/latex/latex.py
@@ -28,11 +28,12 @@ from pelican import contents
 import re
 
 # Global Variables
+_TYPOGRIFY = False  # used to determine if we should process typogrify
 _WRAP_TAG = None  # the tag to wrap mathjax in (needed to play nicely with typogrify or for template designers)
-_LATEX_REGEX = re.compile(r'(\$\$|\$|\\begin\{(.+?)\}).*?\1|\\end\{\2\}', re.DOTALL | re.IGNORECASE) #  used to detect latex
+_LATEX_REGEX = re.compile(r'(\$\$|\$|\\begin\{(.+?)\}|<(math).*?>).*?(\1|\\end\{\2\}|</\3>)', re.DOTALL | re.IGNORECASE) #  used to detect latex
 _LATEX_SUMMARY_REGEX = None  # used to match latex in summary
 _LATEX_PARTIAL_REGEX = None  # used to match latex that has been cut off in summary
-_MATHJAX_SETTINGS = {}  # Settings that can be specified by the user, used to control mathjax script settings
+_MATHJAX_SETTINGS = {}  # settings that can be specified by the user, used to control mathjax script settings
 _MATHJAX_SCRIPT="""
 <script type= "text/javascript">
     if (!document.getElementById('mathjaxscript_pelican')) {{
@@ -124,7 +125,11 @@ def wrap_latex(content, ignore_within):
         # determine if the tags are within <pre> and <code> blocks
         ignore = binary_search(match.span(1), ignore_within) and binary_search(match.span(2), ignore_within)
 
-        if ignore:
+        if ignore or match.group(3) == 'math':
+            if match.group(3) == 'math':
+                # Will detect mml, but not wrap anything around it
+                wrap_latex.foundlatex = True
+
             return match.group(0)
         else:
             wrap_latex.foundlatex = True
@@ -142,7 +147,7 @@ def process_summary(instance, ignore_within):
 
     process_summary.altered_summary = False
     insert_mathjax_script = False
-    endtag = '</%s>' % _WRAP_TAG if _WRAP_TAG != None else ''
+    end_tag = '</%s>' % _WRAP_TAG if _WRAP_TAG != None else ''
 
     # use content's _get_summary method to obtain summary
     summary = instance._get_summary()
@@ -158,23 +163,33 @@ def process_summary(instance, ignore_within):
 
     # Repair the latex if it was cut off mathitem will be the final latex
     # code  matched that is not within <pre> or <code> tags
-    if mathitem and mathitem.group(4) == ' ...':
-        end = r'\end{%s}' % mathitem.group(3) if mathitem.group(3) is not None else mathitem.group(2)
-        latex_match = re.search('%s.*?%s' % (re.escape(mathitem.group(1)), re.escape(end)), instance._content, re.DOTALL | re.IGNORECASE)
-        new_summary = summary.replace(mathitem.group(0), latex_match.group(0)+'%s ...' % endtag)
+    if mathitem and '...' in mathitem.group(6):
+        if mathitem.group(3) is not None:
+            end = r'\end{%s}' % mathitem.group(3)
+        elif mathitem.group(4) is not None:
+            end = r'</math>'
+        elif mathitem.group(2) is not None:
+            end = mathitem.group(2)
 
-        if new_summary != summary:
-            return new_summary+_MATHJAX_SCRIPT.format(**_MATHJAX_SETTINGS)
+        search_regex = r'%s(%s.*?%s)' % (re.escape(instance._content[0:mathitem.start(1)]), re.escape(mathitem.group(1)), re.escape(end))
+        latex_match = re.search(search_regex, instance._content, re.DOTALL | re.IGNORECASE)
+
+        if latex_match:
+            new_summary = summary.replace(mathitem.group(0), latex_match.group(1)+'%s ...' % end_tag)
+
+            if new_summary != summary:
+                return new_summary+_MATHJAX_SCRIPT.format(**_MATHJAX_SETTINGS)
 
     def partial_regex(match):
         """function for use in re.sub"""
-        if binary_search(match.span(), ignore_within):
+        if binary_search(match.span(3), ignore_within):
             return match.group(0)
 
         process_summary.altered_summary = True
         return match.group(1) + match.group(4)
 
     # check for partial latex tags at end. These must be removed
+
     summary = _LATEX_PARTIAL_REGEX.sub(partial_regex, summary)
 
     if process_summary.altered_summary:
@@ -252,9 +267,10 @@ def process_content(instance):
     # with latex, we set it to False. This means that the default reader will
     # not call typogrify, so it is called here, where we are able to control
     # logic for it ignore latex if necessary
-    if process_content.typogrify:
+    if _TYPOGRIFY:
         # Tell typogrify to ignore the tags that latex has been wrapped in
-        ignore_tags = [_WRAP_TAG] if _WRAP_TAG else None
+        # also, typogrify must always ignore mml (math) tags
+        ignore_tags = [_WRAP_TAG,'math'] if _WRAP_TAG else ['math']
 
         # Exact copy of the logic as found in the default reader
         from typogrify.filters import typogrify
@@ -278,6 +294,7 @@ def pelican_init(pelicanobj):
     False should it be set to True.
     """
 
+    global _TYPOGRIFY
     global _WRAP_TAG
     global _LATEX_SUMMARY_REGEX
     global _LATEX_PARTIAL_REGEX
@@ -298,7 +315,7 @@ def pelican_init(pelicanobj):
         if pelicanobj.settings['TYPOGRIFY'] == True:
             pelicanobj.settings['TYPOGRIFY'] = False
             _WRAP_TAG = 'mathjax' # default to wrap mathjax content inside of
-            process_content.typogrify = True
+            _TYPOGRIFY = True
     except KeyError:
         pass
 
@@ -311,10 +328,13 @@ def pelican_init(pelicanobj):
         pass
 
     # regular expressions that depend on _WRAP_TAG are set here
-    tagstart = r'<%s>' % _WRAP_TAG if not _WRAP_TAG is None else ''
-    tagend = r'</%s>' % _WRAP_TAG if not _WRAP_TAG is None else ''
-    latex_summary_regex = r'((\$\$|\$|\\begin\{(.+?)\}).+?)(\2|\\end\{\3\}|\s?\.\.\.)(%s)?' % tagend
-    latex_partial_regex = r'(.*)(%s)(\\.*?|\$.*?)(\s?\.\.\.)(%s)' % (tagstart, tagend)
+    tag_start= r'<%s>' % _WRAP_TAG if not _WRAP_TAG is None else ''
+    tag_end = r'</%s>' % _WRAP_TAG if not _WRAP_TAG is None else ''
+    latex_summary_regex = r'((\$\$|\$|\\begin\{(.+?)\}|<(math)(\s.*?)?>).+?)(\2|\\end\{\3\}|\s?\.\.\.)(%s|</\4>)?' % tag_end
+
+    # NOTE: The logic in _get_summary will handle <math> correctly because it
+    # is perceived as an html tag. Therefore we are only interested in handling non mml
+    latex_partial_regex = r'(.*)(%s)(\\\S*?|\$)\s*?(\s?\.\.\.)(%s)?$' % (tag_start, tag_end)
 
     _LATEX_SUMMARY_REGEX = re.compile(latex_summary_regex, re.DOTALL | re.IGNORECASE)
     _LATEX_PARTIAL_REGEX = re.compile(latex_partial_regex, re.DOTALL | re.IGNORECASE)

From 64dca25e86aac21eec593574231f8be9447a13a2 Mon Sep 17 00:00:00 2001
From: Barry Steyn <barry.steyn@gmail.com>
Date: Wed, 19 Feb 2014 10:19:49 -0800
Subject: [PATCH 09/26] Fixed slight error with mathml regex in summary

---
 latex/latex.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/latex/latex.py b/latex/latex.py
index f0570be..930e686 100644
--- a/latex/latex.py
+++ b/latex/latex.py
@@ -330,7 +330,7 @@ def pelican_init(pelicanobj):
     # regular expressions that depend on _WRAP_TAG are set here
     tag_start= r'<%s>' % _WRAP_TAG if not _WRAP_TAG is None else ''
     tag_end = r'</%s>' % _WRAP_TAG if not _WRAP_TAG is None else ''
-    latex_summary_regex = r'((\$\$|\$|\\begin\{(.+?)\}|<(math)(\s.*?)?>).+?)(\2|\\end\{\3\}|\s?\.\.\.)(%s|</\4>)?' % tag_end
+    latex_summary_regex = r'((\$\$|\$|\\begin\{(.+?)\}|<(math)(\s.*?)?>).+?)(\2|\\end\{\3\}|</\4>|\s?\.\.\.)(%s|</\4>)?' % tag_end
 
     # NOTE: The logic in _get_summary will handle <math> correctly because it
     # is perceived as an html tag. Therefore we are only interested in handling non mml

From 5af9d08c069eae50775242c272e3651d30871cd5 Mon Sep 17 00:00:00 2001
From: Barry Steyn <barry.steyn@gmail.com>
Date: Sat, 22 Feb 2014 13:15:24 -0800
Subject: [PATCH 10/26] moved latex to render_math; latex now symbolic link

---
 latex                                 |   1 +
 latex/Readme.md                       |  95 -----------
 latex/__init__.py                     |   1 -
 render_math/Readme.md                 | 166 +++++++++++++++++++
 render_math/__init__.py               |   1 +
 latex/latex.py => render_math/math.py | 223 +++++++++++++-------------
 render_math/mathjax_script.txt        |  30 ++++
 7 files changed, 310 insertions(+), 207 deletions(-)
 create mode 120000 latex
 delete mode 100644 latex/Readme.md
 delete mode 100644 latex/__init__.py
 create mode 100644 render_math/Readme.md
 create mode 100644 render_math/__init__.py
 rename latex/latex.py => render_math/math.py (53%)
 create mode 100644 render_math/mathjax_script.txt

diff --git a/latex b/latex
new file mode 120000
index 0000000..4a2d98c
--- /dev/null
+++ b/latex
@@ -0,0 +1 @@
+render_math/
\ No newline at end of file
diff --git a/latex/Readme.md b/latex/Readme.md
deleted file mode 100644
index 8ee917d..0000000
--- a/latex/Readme.md
+++ /dev/null
@@ -1,95 +0,0 @@
-Latex Plugin For Pelican
-========================
-
-This plugin allows you to write mathematical equations in your articles using Latex and MathMl.
-It uses the MathJax Latex JavaScript library to render *Latex* and *MathMl* that is embedded in
-your site.
-
-### Latex
-Anything between `$..$` (inline math) and `$$..$$` (displayed math) will be recognized as
-Latex. In addition, anything between between `\begin` and `\end` macros will also be 
-recognized as Latex. For example, `\begin{equation}`...`\end{equation}` would be used to 
-render math equations with numbering.
-
-Within recognized Latex as described above, Latex macros can be used.
-
-### MathMl
-Anything between `<math>` and `</math>` tags will be recognized as *MathMl*.
-
-Installation
-------------
-To enable, ensure that `latex.py` is put somewhere that is accessible.
-Then use as follows by adding the following to your settings.py:
-
-    PLUGINS = ["latex"]
-
-Your site is now capable of rendering math math using the mathjax JavaScript
-library. No alterations to the template file is needed.
-
-### Typogrify
-Typogrify will now play nicely with Latex (i.e. typogrify can be enabled
-and Latex will be rendered correctly). In order for this to happen,
-version 2.07 (or above) of typogrify is required. In fact, this plugin expects
-that at least version 2.07 is present and will fail without it.
-
-### Summaries
-Summaries that contain math are processed to ensure that math is not off. If
-math is cut off, it will add it back into the summary.
-
-### Templates
-No alteration is needed to a template for this plugin to work. Just install
-the plugin and start writing your Math.
-
-Usage
------
-### Backward Compatibility
-This plugin is backward compatible in the sense that it
-will render previous setups correctly. This is because those
-settings and metadata information is ignored by this version. Therefore
-you can remove them to neaten up your site
-
-### Settings File
-Extra options regarding how mathjax renders math can be set in the settings
-file. These options are in a dictionary variable called `LATEX` in the pelican
-settings file.
-
-The dictionary can be set with the following keys:
-
- * `wrap`: controls the tags that math is wrapped with inside the resulting
-html. For example, setting `wrap` to `'mathjax'` would wrap all math inside
-`<mathjax>...</mathjax>` tags. If typogrify is set to True, then math needs
-to be wrapped in tags and `wrap` will therefore default to `mathjax` if not
-set. `wrap` cannot be set to `'math'` because this tag is reserved for 
-mathml notation
- * `align`: controls how displayed math will be aligned. Can be set to either
-`left`, `right` or `center` (default is `center`).
- * `indent`: if `align` not set to `center`, then this controls the indent
-level (default is `0em`).
- * `show_menu`: controls whether the mathjax contextual menu is shown.
- * `process_escapes`: controls whether mathjax processes escape sequences.
- * `preview`: controls the preview message users are seen while mathjax is
-loading.
- * `color`: controls the color of the mathjax rendered font.
-
-For example, in settings.py, the following would make math render in blue and
-displaymath align to the left:
-
-    LATEX = {'color':'blue','align':left}
-
-Latex Examples
---------------
-###Inline
-Latex between `$`..`$`, for example, `$`x^2`$`, will be rendered inline
-with respect to the current html block.
-
-###Displayed Math
-Latex between `$$`..`$$`, for example, `$$`x^2`$$`, will be rendered centered in a
-new paragraph.
-
-###Equations
-Latex between `\begin` and `\end`, for example, `begin{equation}` x^2 `\end{equation}`,
-will be rendered centered in a new paragraph with a right justified equation number
-at the top of the paragraph. This equation number can be referenced in the document.
-To do this, use a `label` inside of the equation format and then refer to that label
-using `ref`. For example: `begin{equation}` `\label{eq}` X^2 `\end{equation}`. Now
-refer to that equation number by `$`\ref{eq}`$`.
diff --git a/latex/__init__.py b/latex/__init__.py
deleted file mode 100644
index 1b2ce76..0000000
--- a/latex/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from .latex import *
\ No newline at end of file
diff --git a/render_math/Readme.md b/render_math/Readme.md
new file mode 100644
index 0000000..45d600a
--- /dev/null
+++ b/render_math/Readme.md
@@ -0,0 +1,166 @@
+Math Render Plugin For Pelican
+==============================
+This plugin gives pelican the ability to render mathematics. It accomplishes
+this by using the [MathJax](http://www.mathjax.org/) javascript engine. Both
+[LaTex](http://en.wikipedia.org/wiki/LaTeX) and [MathML](http://en.wikipedia.org/wiki/MathML) 
+can be rendered within the content.
+
+The plugin also ensures that pelican and recognized math "play" nicely together, by
+ensuring [Typogrify](https://github.com/mintchaos/typogrify) does not alter math content
+and summaries that get cut off are repaired.
+
+Recognized math in the context of this plugin is either LaTex or MathML as described below.
+
+### LaTex
+Anything between `$`...`$` (inline math) and `$$`..`$$` (displayed math) will be recognized as
+LaTex. In addition, anything the `\begin` and `\end` LaTex macros will also be 
+recognized as LaTex. For example, `\begin{equation}`...`\end{equation}` would be used to 
+render math equations with numbering.
+
+Within recognized LaTex as described above, any supported LaTex macro can be used.
+
+### MathML
+Anything between `<math>` and `</math>` tags will be recognized as MathML
+
+Installation
+------------
+To enable, ensure that `render_math` plugin is accessible.
+Then add the following to settings.py:
+
+    PLUGINS = ["render_math"]
+
+Your site is now capable of rendering math math using the mathjax JavaScript
+engine. No alterations to the template is needed, just use and enjoy!
+
+### Typogrify
+In the past, using [Typgogrify](https://github.com/mintchaos/typogrify) would alter the math contents resulting
+in math that could not be rendered by MathJax. The only option was to ensure
+that Typogrify was disabled in the settings.
+
+The problem has been recitified in this plugin, but it requires [Typogrify version 2.04](https://pypi.python.org/pypi/typogrify)
+(or higher). In fact, this plugin will not work with lower versions of Typogrfrify.
+
+Usage
+-----
+### Backward Compatibility
+This plugin is backward compatible in the sense that it
+will render previous setups correctly. This is because those
+settings and metadata information is ignored by this version. Therefore
+you can remove them to neaten up your site
+
+### Templates
+No alteration is needed to a template for this plugin to work. Just install
+the plugin and start writing your Math. 
+
+If on the other hand, you are template designer and want total control
+over the MathJax JavaScript, you can set the `auto_insert` setting to 
+`False` which will cause no MathJax JavaScript to be added to the content.
+
+If you choose this option, you should really know what you are doing. Therefore
+only do this if you are designing your template. There is no real advantage to
+to letting template logic handle the insertion of the MathJax JavaScript other
+than it being slightly neater.
+
+By setting `auto_insert` to `False`, metadata with `key` value of `mathjax`
+will be present in all pages and articles where MathJax should be present.
+The template designer can detect this and then use the `MATHJAXSCRIPT` setting
+which will contain the user specified MathJax script to insert into the content.
+
+For example, this code could be used:
+```
+{% if not MATH['auto_insert'] %}
+    {% if page and page.mathjax or article and article.mathjax %}
+        {{ MATHJAXSCRIPT }}
+    {% endif %}
+{% endif %}
+```
+
+### Settings
+Certain MathJax rendering options can be set. These options 
+are in a dictionary variable called `MATH` in the pelican
+settings file.
+
+The dictionary can be set with the following keys:
+
+ * `auto_insert`: controls whether plugin should automatically insert
+MathJax JavaScript in content that has Math. It is only recommended
+to set this to False if you are a template designer and you want
+extra control over where the MathJax JavaScript is renderd. **Default Value**:
+True
+ * `wrap_latex`: controls the tags that LaTex math is wrapped with inside the resulting
+html. For example, setting `wrap_latex` to `mathjax` would wrap all LaTex math inside
+`<mathjax>...</mathjax>` tags. If typogrify is set to True, then math needs
+to be wrapped in tags and `wrap_latex` will therefore default to `mathjax` if not
+set. `wrap_latex` cannot be set to `'math'` because this tag is reserved for 
+mathml notation. **Default Value**: None unless Typogrify is enabled in which case, 
+it defaults to `mathjax`
+ * `align`: controls how displayed math will be aligned. Can be set to either
+`left`, `right` or `center`. **Default Value**: `center`.
+ * `indent`: if `align` not set to `center`, then this controls the indent
+level. **Default Value**: `0em`.
+ * `show_menu`: a boolean value that controls whether the mathjax contextual 
+menu is shown. **Default Value**: True
+ * `process_escapes`: a boolean value that controls whether mathjax processes escape 
+sequences. **Default Value**: True
+ * `latex_preview`: controls the preview message users are seen while mathjax is
+rendering LaTex. If set to `Tex`, then the TeX code is used as the preview 
+(which will be visible until it is processed by MathJax). **Default Value**: `Tex`
+ * `color`: controls the color of the mathjax rendered font. **Default Value**: `black`
+
+For example, in settings.py, the following would make math render in blue and
+displaymath align to the left:
+
+    MATH = {'color':'blue','align':left}
+
+LaTex Examples
+--------------
+###Inline
+LaTex between `$`..`$`, for example, `$`x^2`$`, will be rendered inline
+with respect to the current html block.
+
+###Displayed Math
+LaTex between `$$`..`$$`, for example, `$$`x^2`$$`, will be rendered centered in a
+new paragraph.
+
+###Equations
+LaTex between `\begin` and `\end`, for example, `begin{equation}` x^2 `\end{equation}`,
+will be rendered centered in a new paragraph with a right justified equation number
+at the top of the paragraph. This equation number can be referenced in the document.
+To do this, use a `label` inside of the equation format and then refer to that label
+using `ref`. For example: `begin{equation}` `\label{eq}` X^2 `\end{equation}`. Now
+refer to that equation number by `$`\ref{eq}`$`.
+
+MathML Examples
+---------------
+The following will render the Quadratic formula:
+```
+<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"> 
+  <mrow>
+    <mi>x</mi>
+    <mo>=</mo>
+    <mfrac>
+      <mrow>
+        <mo>&#x2212;</mo>
+        <mi>b</mi>
+        <mo>&#xB1;</mo>
+        <msqrt>
+          <mrow>
+            <msup>
+              <mi>b</mi>
+              <mn>2</mn>
+            </msup>
+            <mo>&#x2212;</mo>
+            <mn>4</mn>
+            <mi>a</mi>
+            <mi>c</mi>
+          </mrow>
+        </msqrt>
+      </mrow>
+      <mrow>
+        <mn>2</mn>
+        <mi>a</mi>
+      </mrow>
+    </mfrac>
+  </mrow>
+</math>
+```
diff --git a/render_math/__init__.py b/render_math/__init__.py
new file mode 100644
index 0000000..2ac15dd
--- /dev/null
+++ b/render_math/__init__.py
@@ -0,0 +1 @@
+from .math import *
diff --git a/latex/latex.py b/render_math/math.py
similarity index 53%
rename from latex/latex.py
rename to render_math/math.py
index 930e686..da595c7 100644
--- a/latex/latex.py
+++ b/render_math/math.py
@@ -1,19 +1,14 @@
 # -*- coding: utf-8 -*-
 """
-Latex Plugin For Pelican
-========================
-
-This plugin allows you to write mathematical equations in your articles using Latex.
-It uses the MathJax Latex JavaScript library to render latex that is embedded in
-between `$..$` for inline math and `$$..$$` for displayed math. It also allows for
-writing equations in by using `\begin{equation}`...`\end{equation}`. No
-alteration to a template is required for this plugin to work, just install and
-use.
+Math Render Plugin For Pelican
+==============================
+This plugin allows your site to render Math. It supports both LaTex and MathML
+using the MathJax JavaScript engine.
 
 Typogrify Compatibility
 -----------------------
 This plugin now plays nicely with typogrify, but it requires
-typogrify version 2.07 or above.
+typogrify version 2.04 or above.
 
 User Settings
 -------------
@@ -25,45 +20,17 @@ See README for more details.
 
 from pelican import signals
 from pelican import contents
-import re
+import re, os
 
 # Global Variables
 _TYPOGRIFY = False  # used to determine if we should process typogrify
-_WRAP_TAG = None  # the tag to wrap mathjax in (needed to play nicely with typogrify or for template designers)
-_LATEX_REGEX = re.compile(r'(\$\$|\$|\\begin\{(.+?)\}|<(math).*?>).*?(\1|\\end\{\2\}|</\3>)', re.DOTALL | re.IGNORECASE) #  used to detect latex
-_LATEX_SUMMARY_REGEX = None  # used to match latex in summary
-_LATEX_PARTIAL_REGEX = None  # used to match latex that has been cut off in summary
+_WRAP_LATEX = None  # the tag to wrap LaTex math in (needed to play nicely with typogrify or for template designers)
+_MATH_REGEX = re.compile(r'(\$\$|\$|\\begin\{(.+?)\}|<(math)(?:\s.*?)?>).*?(\1|\\end\{\2\}|</\3>)', re.DOTALL | re.IGNORECASE) #  used to detect math
+_MATH_SUMMARY_REGEX = None  # used to match math in summary
+_MATH_INCOMPLETE_TAG_REGEX = None  # used to match math that has been cut off in summary
 _MATHJAX_SETTINGS = {}  # settings that can be specified by the user, used to control mathjax script settings
-_MATHJAX_SCRIPT="""
-<script type= "text/javascript">
-    if (!document.getElementById('mathjaxscript_pelican')) {{
-        var s = document.createElement('script');
-        s.id = 'mathjaxscript_pelican';
-        s.type = 'text/javascript'; s.src = 'https:' == document.location.protocol ? 'https://c328740.ssl.cf1.rackcdn.com/mathjax/latest/MathJax.js' : 'http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML';
-        s[(window.opera ? "innerHTML" : "text")] =
-            "MathJax.Hub.Config({{" +
-            "    config: ['MMLorHTML.js']," +
-            "    TeX: {{ extensions: ['AMSmath.js','AMSsymbols.js','noErrors.js','noUndefined.js'], equationNumbers: {{ autoNumber: 'AMS' }} }}," +
-            "    jax: ['input/TeX','input/MathML','output/HTML-CSS']," +
-            "    extensions: ['tex2jax.js','mml2jax.js','MathMenu.js','MathZoom.js']," +
-            "    displayAlign: '{align}'," +
-            "    displayIndent: '{indent}'," +
-            "    showMathMenu: {show_menu}," +
-            "    tex2jax: {{ " +
-            "        inlineMath: [ [\'$\',\'$\'] ], " +
-            "        displayMath: [ [\'$$\',\'$$\'] ]," +
-            "        processEscapes: {process_escapes}," +
-            "        preview: '{preview}'," +
-            "    }}, " +
-            "    'HTML-CSS': {{ " +
-            "        styles: {{ '.MathJax_Display, .MathJax .mo, .MathJax .mi, .MathJax .mn': {{color: '{color} ! important'}} }}" +
-            "    }} " +
-            "}}); ";
-        (document.body || document.getElementsByTagName('head')[0]).appendChild(s);
-    }}
-</script>
-"""
-
+with open (os.path.dirname(os.path.realpath(__file__))+'/mathjax_script.txt', 'r') as mathjax_script:  # Read the mathjax javascript from file
+    _MATHJAX_SCRIPT=mathjax_script.read()
 
 # Python standard library for binary search, namely bisect is cool but I need
 # specific business logic to evaluate my search predicate, so I am using my
@@ -103,7 +70,7 @@ def ignore_content(content):
 
     # used to detect all <pre> and <code> tags. NOTE: Alter this regex should
     # additional tags need to be ignored
-    ignore_regex = re.compile(r'<(pre|code).*?>.*?</(\1)>', re.DOTALL | re.IGNORECASE)
+    ignore_regex = re.compile(r'<(pre|code)(?:\s.*?)?>.*?</(\1)>', re.DOTALL | re.IGNORECASE)
 
     for match in ignore_regex.finditer(content):
         ignore_within.append(match.span())
@@ -111,31 +78,32 @@ def ignore_content(content):
     return ignore_within
 
 
-def wrap_latex(content, ignore_within):
-    """Wraps latex in user specified tags.
+def wrap_math(content, ignore_within):
+    """Wraps math in user specified tags.
 
-    This is needed for typogrify to play nicely with latex but it can also be
+    This is needed for typogrify to play nicely with math but it can also be
     styled by template providers
     """
-    wrap_latex.foundlatex = False
+
+    wrap_math.found_math = False
 
     def math_tag_wrap(match):
         """function for use in re.sub"""
 
         # determine if the tags are within <pre> and <code> blocks
-        ignore = binary_search(match.span(1), ignore_within) and binary_search(match.span(2), ignore_within)
+        ignore = binary_search(match.span(1), ignore_within) or binary_search(match.span(4), ignore_within)
 
         if ignore or match.group(3) == 'math':
             if match.group(3) == 'math':
                 # Will detect mml, but not wrap anything around it
-                wrap_latex.foundlatex = True
+                wrap_math.found_math = True
 
             return match.group(0)
         else:
-            wrap_latex.foundlatex = True
-            return '<%s>%s</%s>' % (_WRAP_TAG, match.group(0), _WRAP_TAG)
+            wrap_math.found_math = True
+            return '<%s>%s</%s>' % (_WRAP_LATEX, match.group(0), _WRAP_LATEX)
 
-    return (_LATEX_REGEX.sub(math_tag_wrap, content), wrap_latex.foundlatex)
+    return (_MATH_REGEX.sub(math_tag_wrap, content), wrap_math.found_math)
 
 
 def process_summary(instance, ignore_within):
@@ -146,41 +114,51 @@ def process_summary(instance, ignore_within):
     """
 
     process_summary.altered_summary = False
-    insert_mathjax_script = False
-    end_tag = '</%s>' % _WRAP_TAG if _WRAP_TAG != None else ''
+    insert_mathjax = False
+    end_tag = '</%s>' % _WRAP_LATEX if _WRAP_LATEX != None else ''
 
     # use content's _get_summary method to obtain summary
     summary = instance._get_summary()
 
     # Determine if there is any math in the summary which are not within the
     # ignore_within tags
-    mathitem = None
-    for mathitem in _LATEX_SUMMARY_REGEX.finditer(summary):
-        if binary_search(mathitem.span(), ignore_within):
-            mathitem = None # In <code> or <pre> tags, so ignore
+    math_item = None
+    for math_item in _MATH_SUMMARY_REGEX.finditer(summary):
+        ignore = binary_search(math_item.span(2), ignore_within)
+        if '...' not in math_item.group(5):
+            ignore = ignore or binary_search(math_item.span(5), ignore_within)
         else:
-            insert_mathjax_script = True
+            ignore = ignore or binary_search(math_item.span(6), ignore_within)
 
-    # Repair the latex if it was cut off mathitem will be the final latex
+        if ignore:
+            math_item = None # In <code> or <pre> tags, so ignore
+        else:
+            insert_mathjax = True
+
+    # Repair the math if it was cut off math_item will be the final math
     # code  matched that is not within <pre> or <code> tags
-    if mathitem and '...' in mathitem.group(6):
-        if mathitem.group(3) is not None:
-            end = r'\end{%s}' % mathitem.group(3)
-        elif mathitem.group(4) is not None:
+    if math_item and '...' in math_item.group(5):
+        if math_item.group(3) is not None:
+            end = r'\end{%s}' % math_item.group(3)
+        elif math_item.group(4) is not None:
             end = r'</math>'
-        elif mathitem.group(2) is not None:
-            end = mathitem.group(2)
+        elif math_item.group(2) is not None:
+            end = math_item.group(2)
 
-        search_regex = r'%s(%s.*?%s)' % (re.escape(instance._content[0:mathitem.start(1)]), re.escape(mathitem.group(1)), re.escape(end))
-        latex_match = re.search(search_regex, instance._content, re.DOTALL | re.IGNORECASE)
+        search_regex = r'%s(%s.*?%s)' % (re.escape(instance._content[0:math_item.start(1)]), re.escape(math_item.group(1)), re.escape(end))
+        math_match = re.search(search_regex, instance._content, re.DOTALL | re.IGNORECASE)
 
-        if latex_match:
-            new_summary = summary.replace(mathitem.group(0), latex_match.group(1)+'%s ...' % end_tag)
+        if math_match:
+            new_summary = summary.replace(math_item.group(0), math_match.group(1)+'%s ...' % end_tag)
 
             if new_summary != summary:
-                return new_summary+_MATHJAX_SCRIPT.format(**_MATHJAX_SETTINGS)
+                if _MATHJAX_SETTINGS['auto_insert']:
+                    return new_summary+_MATHJAX_SCRIPT.format(**_MATHJAX_SETTINGS)
+                else:
+                    instance.mathjax = True
+                    return new_summary
 
-    def partial_regex(match):
+    def incomplete_end_latex_tag(match):
         """function for use in re.sub"""
         if binary_search(match.span(3), ignore_within):
             return match.group(0)
@@ -188,15 +166,20 @@ def process_summary(instance, ignore_within):
         process_summary.altered_summary = True
         return match.group(1) + match.group(4)
 
-    # check for partial latex tags at end. These must be removed
+    # check for partial math tags at end. These must be removed
 
-    summary = _LATEX_PARTIAL_REGEX.sub(partial_regex, summary)
+    summary = _MATH_INCOMPLETE_TAG_REGEX.sub(incomplete_end_latex_tag, summary)
 
-    if process_summary.altered_summary:
-        return summary+_MATHJAX_SCRIPT.format(**_MATHJAX_SETTINGS) if insert_mathjax_script else summary
+    if process_summary.altered_summary or insert_mathjax:
+        if insert_mathjax:
+            if _MATHJAX_SETTINGS['auto_insert']:
+                summary+= _MATHJAX_SCRIPT.format(**_MATHJAX_SETTINGS)
+            else:
+                instance.mathjax = True
 
-    return summary+_MATHJAX_SCRIPT.format(**_MATHJAX_SETTINGS) if insert_mathjax_script else None
+        return summary
 
+    return None  # Making it explicit that summary was not altered
 
 def process_settings(settings):
     """Sets user specified MathJax settings (see README for more details)"""
@@ -213,9 +196,18 @@ def process_settings(settings):
     _MATHJAX_SETTINGS['indent'] = '0em'  # if above is not set to 'center', then this setting acts as an indent
     _MATHJAX_SETTINGS['show_menu'] = 'true'  # controls whether to attach mathjax contextual menu
     _MATHJAX_SETTINGS['process_escapes'] = 'true'  # controls whether escapes are processed
-    _MATHJAX_SETTINGS['preview'] = 'TeX'  # controls what user sees as preview
+    _MATHJAX_SETTINGS['latex_preview'] = 'TeX'  # controls what user sees while waiting for LaTex to render
     _MATHJAX_SETTINGS['color'] = 'black'  # controls color math is rendered in
 
+    # This next setting controls whether the mathjax script should be automatically
+    # inserted into the content. The mathjax script will not be inserted into
+    # the content if no math is detected. For summaries that are present in the
+    # index listings, mathjax script will also be automatically inserted.
+    # Setting this value to false means the template must be altered if this
+    # plugin is to work, and so it is only recommended for the template
+    # designer who wants maximum control.
+    _MATHJAX_SETTINGS['auto_insert'] = True # controls whether mathjax script is automatically inserted into the content
+
     if not isinstance(settings, dict):
         return
 
@@ -223,6 +215,9 @@ def process_settings(settings):
     # Iterate over dictionary in a way that is compatible with both version 2
     # and 3 of python
     for key, value in ((key, settings[key]) for key in settings):
+        if key == 'auto_insert' and isinstance(value, bool):
+            _MATHJAX_SETTINGS[key] = value
+
         if key == 'align' and isinstance(value, str):
             if value == 'left' or value == 'right' or value == 'center':
                 _MATHJAX_SETTINGS[key] = value
@@ -238,7 +233,7 @@ def process_settings(settings):
         if key == 'process_escapes' and isinstance(value, bool):
             _MATHJAX_SETTINGS[key] = 'true' if value else 'false'
 
-        if key == 'preview' and isinstance(value, str):
+        if key == 'latex_preview' and isinstance(value, str):
             _MATHJAX_SETTINGS[key] = value
 
         if key == 'color' and isinstance(value, str):
@@ -247,7 +242,7 @@ def process_settings(settings):
 
 def process_content(instance):
     """Processes content, with logic to ensure that typogrify does not clash
-    with latex.
+    with math.
 
     In addition, mathjax script is inserted at the end of the content thereby
     making it independent of the template
@@ -258,31 +253,36 @@ def process_content(instance):
 
     ignore_within = ignore_content(instance._content)
 
-    if _WRAP_TAG:
-        instance._content, latex = wrap_latex(instance._content, ignore_within)
+    if _WRAP_LATEX:
+        instance._content, math = wrap_math(instance._content, ignore_within)
     else:
-        latex = True if _LATEX_REGEX.search(instance._content) else False
+        math = True if _MATH_REGEX.search(instance._content) else False
 
     # The user initially set typogrify to be True, but since it would clash
-    # with latex, we set it to False. This means that the default reader will
+    # with math, we set it to False. This means that the default reader will
     # not call typogrify, so it is called here, where we are able to control
-    # logic for it ignore latex if necessary
+    # logic for it ignore math if necessary
     if _TYPOGRIFY:
-        # Tell typogrify to ignore the tags that latex has been wrapped in
+        # Tell typogrify to ignore the tags that math has been wrapped in
         # also, typogrify must always ignore mml (math) tags
-        ignore_tags = [_WRAP_TAG,'math'] if _WRAP_TAG else ['math']
+        ignore_tags = [_WRAP_LATEX,'math'] if _WRAP_LATEX else ['math']
 
         # Exact copy of the logic as found in the default reader
         from typogrify.filters import typogrify
         instance._content = typogrify(instance._content, ignore_tags)
         instance.metadata['title'] = typogrify(instance.metadata['title'], ignore_tags)
 
-    if latex:
-        # Mathjax script added to the end of article. Now it does not need to
-        # be explicitly added to the template
-        instance._content += _MATHJAX_SCRIPT.format(**_MATHJAX_SETTINGS)
+    if math:
+        if _MATHJAX_SETTINGS['auto_insert']:
+            # Mathjax script added to content automatically. Now it
+            # does not need to be explicitly added to the template
+            instance._content += _MATHJAX_SCRIPT.format(**_MATHJAX_SETTINGS)
+        else:
+            # Place the burden on ensuring mathjax script is available to
+            # browser on the template designer (see README for more details)
+            instance.mathjax = True
 
-        # The summary needs special care because latex math cannot just be cut
+        # The summary needs special care because math math cannot just be cut
         # off
         summary = process_summary(instance, ignore_within)
         if summary != None:
@@ -295,12 +295,12 @@ def pelican_init(pelicanobj):
     """
 
     global _TYPOGRIFY
-    global _WRAP_TAG
-    global _LATEX_SUMMARY_REGEX
-    global _LATEX_PARTIAL_REGEX
+    global _WRAP_LATEX
+    global _MATH_SUMMARY_REGEX
+    global _MATH_INCOMPLETE_TAG_REGEX
 
     try:
-        settings = pelicanobj.settings['LATEX']
+        settings = pelicanobj.settings['MATH']
     except:
         settings = None
 
@@ -314,30 +314,31 @@ def pelican_init(pelicanobj):
     try:
         if pelicanobj.settings['TYPOGRIFY'] == True:
             pelicanobj.settings['TYPOGRIFY'] = False
-            _WRAP_TAG = 'mathjax' # default to wrap mathjax content inside of
+            _WRAP_LATEX = 'mathjax' # default to wrap mathjax content inside of
             _TYPOGRIFY = True
     except KeyError:
         pass
 
-    # Set _WRAP_TAG to the settings tag if defined. The idea behind this is
+    # Set _WRAP_LATEX to the settings tag if defined. The idea behind this is
     # to give template designers control over how math would be rendered
     try:
-        if pelicanobj.settings['LATEX']['wrap']:
-            _WRAP_TAG = pelicanobj.settings['LATEX']['wrap']
+        if pelicanobj.settings['MATH']['wrap_latex']:
+            _WRAP_LATEX = pelicanobj.settings['MATH']['wrap_latex']
     except (KeyError, TypeError):
         pass
 
-    # regular expressions that depend on _WRAP_TAG are set here
-    tag_start= r'<%s>' % _WRAP_TAG if not _WRAP_TAG is None else ''
-    tag_end = r'</%s>' % _WRAP_TAG if not _WRAP_TAG is None else ''
-    latex_summary_regex = r'((\$\$|\$|\\begin\{(.+?)\}|<(math)(\s.*?)?>).+?)(\2|\\end\{\3\}|</\4>|\s?\.\.\.)(%s|</\4>)?' % tag_end
+    # regular expressions that depend on _WRAP_LATEX are set here
+    tag_start= r'<%s>' % _WRAP_LATEX if not _WRAP_LATEX is None else ''
+    tag_end = r'</%s>' % _WRAP_LATEX if not _WRAP_LATEX is None else ''
+    math_summary_regex = r'((\$\$|\$|\\begin\{(.+?)\}|<(math)(?:\s.*?)?>).+?)(\2|\\end\{\3\}|</\4>|\s?\.\.\.)(%s|</\4>)?' % tag_end
 
     # NOTE: The logic in _get_summary will handle <math> correctly because it
-    # is perceived as an html tag. Therefore we are only interested in handling non mml
-    latex_partial_regex = r'(.*)(%s)(\\\S*?|\$)\s*?(\s?\.\.\.)(%s)?$' % (tag_start, tag_end)
+    # is perceived as an html tag. Therefore we are only interested in handling
+    # non mml (i.e. LaTex)
+    incomplete_end_latex_tag = r'(.*)(%s)(\\\S*?|\$)\s*?(\s?\.\.\.)(%s)?$' % (tag_start, tag_end)
 
-    _LATEX_SUMMARY_REGEX = re.compile(latex_summary_regex, re.DOTALL | re.IGNORECASE)
-    _LATEX_PARTIAL_REGEX = re.compile(latex_partial_regex, re.DOTALL | re.IGNORECASE)
+    _MATH_SUMMARY_REGEX = re.compile(math_summary_regex, re.DOTALL | re.IGNORECASE)
+    _MATH_INCOMPLETE_TAG_REGEX = re.compile(incomplete_end_latex_tag, re.DOTALL | re.IGNORECASE)
 
 
 def register():
diff --git a/render_math/mathjax_script.txt b/render_math/mathjax_script.txt
new file mode 100644
index 0000000..e1f3f12
--- /dev/null
+++ b/render_math/mathjax_script.txt
@@ -0,0 +1,30 @@
+<script type= "text/javascript">
+    if (!document.getElementById('mathjaxscript_pelican_#%@#$@#')) {{
+        var mathjaxscript = document.createElement('script');
+        mathjaxscript.id = 'mathjaxscript_pelican_#%@#$@#';
+        mathjaxscript.type = 'text/javascript';
+        mathjaxscript.src = 'https:' == document.location.protocol
+		? 'https://c328740.ssl.cf1.rackcdn.com/mathjax/latest/MathJax.js'
+		: 'http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML';
+        mathjaxscript[(window.opera ? "innerHTML" : "text")] =
+            "MathJax.Hub.Config({{" +
+            "    config: ['MMLorHTML.js']," +
+            "    TeX: {{ extensions: ['AMSmath.js','AMSsymbols.js','noErrors.js','noUndefined.js'], equationNumbers: {{ autoNumber: 'AMS' }} }}," +
+            "    jax: ['input/TeX','input/MathML','output/HTML-CSS']," +
+            "    extensions: ['tex2jax.js','mml2jax.js','MathMenu.js','MathZoom.js']," +
+            "    displayAlign: '{align}'," +
+            "    displayIndent: '{indent}'," +
+            "    showMathMenu: {show_menu}," +
+            "    tex2jax: {{ " +
+            "        inlineMath: [ ['$','$'] ], " +
+            "        displayMath: [ ['$$','$$'] ]," +
+            "        processEscapes: {process_escapes}," +
+            "        preview: '{latex_preview}'," +
+            "    }}, " +
+            "    'HTML-CSS': {{ " +
+            "        styles: {{ '.MathJax_Display, .MathJax .mo, .MathJax .mi, .MathJax .mn': {{color: '{color} ! important'}} }}" +
+            "    }} " +
+            "}}); ";
+        (document.body || document.getElementsByTagName('head')[0]).appendChild(mathjaxscript);
+    }}
+</script>

From 47dc3e9747984e5d85712e9866514ea4f998dd14 Mon Sep 17 00:00:00 2001
From: Barry Steyn <barry.steyn@gmail.com>
Date: Tue, 25 Feb 2014 16:53:16 -0800
Subject: [PATCH 11/26] ability to specify ssl protocol

---
 render_math/Readme.md          |  6 ++++++
 render_math/math.py            | 12 +++++++++++-
 render_math/mathjax_script.txt |  4 +---
 3 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/render_math/Readme.md b/render_math/Readme.md
index 45d600a..9a4412f 100644
--- a/render_math/Readme.md
+++ b/render_math/Readme.md
@@ -106,6 +106,12 @@ sequences. **Default Value**: True
 rendering LaTex. If set to `Tex`, then the TeX code is used as the preview 
 (which will be visible until it is processed by MathJax). **Default Value**: `Tex`
  * `color`: controls the color of the mathjax rendered font. **Default Value**: `black`
+ * `ssl`: specifies if ssl should be used to load MathJax engine. Can be set to one
+of three things
+  * `auto`: **Default Value** will automatically determine what protodol to use 
+based on current protocol of the site. 
+  * `force`: will force ssl to be used.
+  * `off`: will ensure that ssl is not used
 
 For example, in settings.py, the following would make math render in blue and
 displaymath align to the left:
diff --git a/render_math/math.py b/render_math/math.py
index da595c7..c6b71f0 100644
--- a/render_math/math.py
+++ b/render_math/math.py
@@ -167,7 +167,6 @@ def process_summary(instance, ignore_within):
         return match.group(1) + match.group(4)
 
     # check for partial math tags at end. These must be removed
-
     summary = _MATH_INCOMPLETE_TAG_REGEX.sub(incomplete_end_latex_tag, summary)
 
     if process_summary.altered_summary or insert_mathjax:
@@ -199,6 +198,11 @@ def process_settings(settings):
     _MATHJAX_SETTINGS['latex_preview'] = 'TeX'  # controls what user sees while waiting for LaTex to render
     _MATHJAX_SETTINGS['color'] = 'black'  # controls color math is rendered in
 
+    # Source for MathJax: default (below) is to automatically determine what protocol to use
+    _MATHJAX_SETTINGS['source'] = """'https:' == document.location.protocol
+                ? 'https://c328740.ssl.cf1.rackcdn.com/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML'
+                : 'http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML'"""
+
     # This next setting controls whether the mathjax script should be automatically
     # inserted into the content. The mathjax script will not be inserted into
     # the content if no math is detected. For summaries that are present in the
@@ -239,6 +243,12 @@ def process_settings(settings):
         if key == 'color' and isinstance(value, str):
             _MATHJAX_SETTINGS[key] = value
 
+        if key == 'ssl' and isinstance(value, str):
+            if value == 'off':
+                _MATHJAX_SETTINGS['source'] = "'http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML'"
+
+            if value == 'force':
+                _MATHJAX_SETTINGS['source'] = "'https://c328740.ssl.cf1.rackcdn.com/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML'"
 
 def process_content(instance):
     """Processes content, with logic to ensure that typogrify does not clash
diff --git a/render_math/mathjax_script.txt b/render_math/mathjax_script.txt
index e1f3f12..b9c75c3 100644
--- a/render_math/mathjax_script.txt
+++ b/render_math/mathjax_script.txt
@@ -3,9 +3,7 @@
         var mathjaxscript = document.createElement('script');
         mathjaxscript.id = 'mathjaxscript_pelican_#%@#$@#';
         mathjaxscript.type = 'text/javascript';
-        mathjaxscript.src = 'https:' == document.location.protocol
-		? 'https://c328740.ssl.cf1.rackcdn.com/mathjax/latest/MathJax.js'
-		: 'http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML';
+        mathjaxscript.src = {source};
         mathjaxscript[(window.opera ? "innerHTML" : "text")] =
             "MathJax.Hub.Config({{" +
             "    config: ['MMLorHTML.js']," +

From f93764f73759341382e1b7325f5f4cf53a948ef6 Mon Sep 17 00:00:00 2001
From: Barry Steyn <barry.steyn@gmail.com>
Date: Sun, 2 Mar 2014 11:44:14 -0800
Subject: [PATCH 12/26] alert user to incorrect usage of typogrify

---
 render_math/Readme.md |  3 ++-
 render_math/math.py   | 27 +++++++++++++++++++++------
 2 files changed, 23 insertions(+), 7 deletions(-)

diff --git a/render_math/Readme.md b/render_math/Readme.md
index 9a4412f..1f1fdd8 100644
--- a/render_math/Readme.md
+++ b/render_math/Readme.md
@@ -38,7 +38,8 @@ in math that could not be rendered by MathJax. The only option was to ensure
 that Typogrify was disabled in the settings.
 
 The problem has been recitified in this plugin, but it requires [Typogrify version 2.04](https://pypi.python.org/pypi/typogrify)
-(or higher). In fact, this plugin will not work with lower versions of Typogrfrify.
+(or higher). If this version of Typogrify is not present, the plugin will inform that an incorrect
+version of Typogrify is not present and disable Typogrify for the entire site
 
 Usage
 -----
diff --git a/render_math/math.py b/render_math/math.py
index c6b71f0..bdc4092 100644
--- a/render_math/math.py
+++ b/render_math/math.py
@@ -23,7 +23,7 @@ from pelican import contents
 import re, os
 
 # Global Variables
-_TYPOGRIFY = False  # used to determine if we should process typogrify
+_TYPOGRIFY = None  # if typogrify is enabled, this is set to the typogrify.filter function
 _WRAP_LATEX = None  # the tag to wrap LaTex math in (needed to play nicely with typogrify or for template designers)
 _MATH_REGEX = re.compile(r'(\$\$|\$|\\begin\{(.+?)\}|<(math)(?:\s.*?)?>).*?(\1|\\end\{\2\}|</\3>)', re.DOTALL | re.IGNORECASE) #  used to detect math
 _MATH_SUMMARY_REGEX = None  # used to match math in summary
@@ -278,9 +278,8 @@ def process_content(instance):
         ignore_tags = [_WRAP_LATEX,'math'] if _WRAP_LATEX else ['math']
 
         # Exact copy of the logic as found in the default reader
-        from typogrify.filters import typogrify
-        instance._content = typogrify(instance._content, ignore_tags)
-        instance.metadata['title'] = typogrify(instance.metadata['title'], ignore_tags)
+        instance._content = _TYPOGRIFY(instance._content, ignore_tags)
+        instance.metadata['title'] = _TYPOGRIFY(instance.metadata['title'], ignore_tags)
 
     if math:
         if _MATHJAX_SETTINGS['auto_insert']:
@@ -324,8 +323,24 @@ def pelican_init(pelicanobj):
     try:
         if pelicanobj.settings['TYPOGRIFY'] == True:
             pelicanobj.settings['TYPOGRIFY'] = False
-            _WRAP_LATEX = 'mathjax' # default to wrap mathjax content inside of
-            _TYPOGRIFY = True
+            try:
+                from typogrify.filters import typogrify
+
+                # Determine if this is the correct version of Typogrify to use
+                import inspect
+                typogrify_args = inspect.getargspec(typogrify).args
+                if len(typogrify_args) < 2 or 'ignore_tags' not in typogrify_args:
+                    raise TypeError('Incorrect version of typogrify')
+
+                # At this point, we are happy to use Typogrify, meaning
+                # it is installed and it is a recent enough version
+                # that can be used to ignore all math
+                _TYPOGRIFY = typogrify
+                _WRAP_LATEX = 'mathjax' # default to wrap mathjax content inside of
+            except ImportError:
+                print "\nTypogrify is not installed, so it is being ignored.\nPlease install it if you want to use it: pip install typogrify\n"
+            except TypeError:
+                print "\nA more recent versio of Typogrify is needed for the render_math module.\nPlease upgrade the typogrify to the latest version (anything above version 2.04 is okay).\nTypogrify will be turned off due to this reason\n"
     except KeyError:
         pass
 

From 3bcb54ac555bdcfd7a0b2db0e2d685ad22bede7b Mon Sep 17 00:00:00 2001
From: Allen Riddell <abr@ariddell.org>
Date: Sun, 2 Mar 2014 23:46:58 -0500
Subject: [PATCH 13/26] Add Python 3 compatibility

---
 render_math/math.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/render_math/math.py b/render_math/math.py
index bdc4092..b8d0512 100644
--- a/render_math/math.py
+++ b/render_math/math.py
@@ -1,3 +1,4 @@
+from __future__ import print_function
 # -*- coding: utf-8 -*-
 """
 Math Render Plugin For Pelican
@@ -338,9 +339,9 @@ def pelican_init(pelicanobj):
                 _TYPOGRIFY = typogrify
                 _WRAP_LATEX = 'mathjax' # default to wrap mathjax content inside of
             except ImportError:
-                print "\nTypogrify is not installed, so it is being ignored.\nPlease install it if you want to use it: pip install typogrify\n"
+                print("\nTypogrify is not installed, so it is being ignored.\nPlease install it if you want to use it: pip install typogrify\n")
             except TypeError:
-                print "\nA more recent versio of Typogrify is needed for the render_math module.\nPlease upgrade the typogrify to the latest version (anything above version 2.04 is okay).\nTypogrify will be turned off due to this reason\n"
+                print("\nA more recent versio of Typogrify is needed for the render_math module.\nPlease upgrade the typogrify to the latest version (anything above version 2.04 is okay).\nTypogrify will be turned off due to this reason\n")
     except KeyError:
         pass
 

From 8052ea9f9e81f88da55da476f9d0200e25f4887f Mon Sep 17 00:00:00 2001
From: Jesus Ruiz <jesrui@gmail.com>
Date: Tue, 4 Mar 2014 16:16:39 +0100
Subject: [PATCH 14/26] add static_comments plugin

---
 static_comments/Readme.md          | 26 +++++++++++++++++
 static_comments/__init__.py        |  1 +
 static_comments/static_comments.py | 46 ++++++++++++++++++++++++++++++
 3 files changed, 73 insertions(+)
 create mode 100644 static_comments/Readme.md
 create mode 100644 static_comments/__init__.py
 create mode 100644 static_comments/static_comments.py

diff --git a/static_comments/Readme.md b/static_comments/Readme.md
new file mode 100644
index 0000000..f95fbc4
--- /dev/null
+++ b/static_comments/Readme.md
@@ -0,0 +1,26 @@
+Static comments
+---------------
+
+This plugin allows you to add static comments to an article. By default the
+plugin looks for the comments of each article in a local file named
+``comments/{slug}.md``, where ``{slug}`` is the value of the slug tag for the
+article. The comments file should be formatted using markdown.
+
+Set the ``STATIC_COMMENTS`` parameter to True to enable the plugin. Default is
+False.
+
+Set the ``STATIC_COMMENTS_DIR`` parameter to the directory where the comments
+are located. Default is ``comments``.
+
+On the template side, you just have to add a section for the comments to your
+``article.html``, as in this example::
+
+    {% if STATIC_COMMENTS %}
+    <section id="comments" class="body">
+    <h2>Comments!</h2>
+    {{ article.metadata.static_comments }}
+    </section>
+    {% endif %}
+
+Here is an example of usage:
+<http://jesrui.sdf-eu.org/pelican-static-comments.html>
diff --git a/static_comments/__init__.py b/static_comments/__init__.py
new file mode 100644
index 0000000..9d131b2
--- /dev/null
+++ b/static_comments/__init__.py
@@ -0,0 +1 @@
+from .static_comments import *
diff --git a/static_comments/static_comments.py b/static_comments/static_comments.py
new file mode 100644
index 0000000..65c4491
--- /dev/null
+++ b/static_comments/static_comments.py
@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+
+import codecs
+import logging
+import markdown
+import os
+
+logger = logging.getLogger(__name__)
+
+from pelican import signals
+
+
+def initialized(pelican):
+    from pelican.settings import DEFAULT_CONFIG
+    DEFAULT_CONFIG.setdefault('STATIC_COMMENTS', False)
+    DEFAULT_CONFIG.setdefault('STATIC_COMMENTS_DIR' 'comments')
+    if pelican:
+        pelican.settings.setdefault('STATIC_COMMENTS', False)
+        pelican.settings.setdefault('STATIC_COMMENTS_DIR', 'comments')
+
+
+def add_static_comments(gen, metadata):
+    if gen.settings['STATIC_COMMENTS'] != True:
+        return
+
+    if not 'slug' in metadata:
+        logger.warning("static_comments: "
+                "cant't locate comments file without slug tag in the article")
+        return
+
+    fname = os.path.join(gen.settings['STATIC_COMMENTS_DIR'],
+            metadata['slug'] + ".md")
+
+    if not os.path.exists(fname):
+        return
+
+    input_file = codecs.open(fname, mode="r", encoding="utf-8")
+    text = input_file.read()
+    html = markdown.markdown(text)
+
+    metadata['static_comments'] = html
+
+
+def register():
+    signals.initialized.connect(initialized)
+    signals.article_generator_context.connect(add_static_comments)

From c38851cf9c2b59ced7f48ddb1b8b8c0c74ea6a59 Mon Sep 17 00:00:00 2001
From: Justin Mayer <entroP@gmail.com>
Date: Fri, 7 Mar 2014 08:33:06 +0100
Subject: [PATCH 15/26] Grammar and PEP8 fixes for render_math plugin

---
 render_math/math.py | 60 +++++++++++++++++++++++++--------------------
 1 file changed, 33 insertions(+), 27 deletions(-)

diff --git a/render_math/math.py b/render_math/math.py
index b8d0512..190b5f6 100644
--- a/render_math/math.py
+++ b/render_math/math.py
@@ -1,38 +1,42 @@
-from __future__ import print_function
 # -*- coding: utf-8 -*-
 """
-Math Render Plugin For Pelican
+Math Render Plugin for Pelican
 ==============================
-This plugin allows your site to render Math. It supports both LaTex and MathML
+This plugin allows your site to render Math. It supports both LaTeX and MathML
 using the MathJax JavaScript engine.
 
 Typogrify Compatibility
 -----------------------
-This plugin now plays nicely with typogrify, but it requires
-typogrify version 2.04 or above.
+This plugin now plays nicely with Typogrify, but it requires
+Typogrify version 2.04 or above.
 
 User Settings
 -------------
 Users are also able to pass a dictionary of settings in the settings file which
-will control how the mathjax library renders thing. This could be very useful
-for template builders that want to adjust look and feel of the math.
+will control how the MathJax library renders things. This could be very useful
+for template builders that want to adjust the look and feel of the math.
 See README for more details.
 """
 
+from __future__ import print_function
+import os
+import re
+
 from pelican import signals
 from pelican import contents
-import re, os
+
 
 # Global Variables
-_TYPOGRIFY = None  # if typogrify is enabled, this is set to the typogrify.filter function
-_WRAP_LATEX = None  # the tag to wrap LaTex math in (needed to play nicely with typogrify or for template designers)
-_MATH_REGEX = re.compile(r'(\$\$|\$|\\begin\{(.+?)\}|<(math)(?:\s.*?)?>).*?(\1|\\end\{\2\}|</\3>)', re.DOTALL | re.IGNORECASE) #  used to detect math
+_TYPOGRIFY = None  # if Typogrify is enabled, this is set to the typogrify.filter function
+_WRAP_LATEX = None  # the tag to wrap LaTeX math in (needed to play nicely with Typogrify or for template designers)
+_MATH_REGEX = re.compile(r'(\$\$|\$|\\begin\{(.+?)\}|<(math)(?:\s.*?)?>).*?(\1|\\end\{\2\}|</\3>)', re.DOTALL | re.IGNORECASE)  # used to detect math
 _MATH_SUMMARY_REGEX = None  # used to match math in summary
 _MATH_INCOMPLETE_TAG_REGEX = None  # used to match math that has been cut off in summary
 _MATHJAX_SETTINGS = {}  # settings that can be specified by the user, used to control mathjax script settings
 with open (os.path.dirname(os.path.realpath(__file__))+'/mathjax_script.txt', 'r') as mathjax_script:  # Read the mathjax javascript from file
     _MATHJAX_SCRIPT=mathjax_script.read()
 
+
 # Python standard library for binary search, namely bisect is cool but I need
 # specific business logic to evaluate my search predicate, so I am using my
 # own version
@@ -82,7 +86,7 @@ def ignore_content(content):
 def wrap_math(content, ignore_within):
     """Wraps math in user specified tags.
 
-    This is needed for typogrify to play nicely with math but it can also be
+    This is needed for Typogrify to play nicely with math but it can also be
     styled by template providers
     """
 
@@ -116,7 +120,7 @@ def process_summary(instance, ignore_within):
 
     process_summary.altered_summary = False
     insert_mathjax = False
-    end_tag = '</%s>' % _WRAP_LATEX if _WRAP_LATEX != None else ''
+    end_tag = '</%s>' % _WRAP_LATEX if _WRAP_LATEX is not None else ''
 
     # use content's _get_summary method to obtain summary
     summary = instance._get_summary()
@@ -181,6 +185,7 @@ def process_summary(instance, ignore_within):
 
     return None  # Making it explicit that summary was not altered
 
+
 def process_settings(settings):
     """Sets user specified MathJax settings (see README for more details)"""
 
@@ -211,7 +216,7 @@ def process_settings(settings):
     # Setting this value to false means the template must be altered if this
     # plugin is to work, and so it is only recommended for the template
     # designer who wants maximum control.
-    _MATHJAX_SETTINGS['auto_insert'] = True # controls whether mathjax script is automatically inserted into the content
+    _MATHJAX_SETTINGS['auto_insert'] = True  # controls whether mathjax script is automatically inserted into the content
 
     if not isinstance(settings, dict):
         return
@@ -251,8 +256,9 @@ def process_settings(settings):
             if value == 'force':
                 _MATHJAX_SETTINGS['source'] = "'https://c328740.ssl.cf1.rackcdn.com/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML'"
 
+
 def process_content(instance):
-    """Processes content, with logic to ensure that typogrify does not clash
+    """Processes content, with logic to ensure that Typogrify does not clash
     with math.
 
     In addition, mathjax script is inserted at the end of the content thereby
@@ -269,13 +275,13 @@ def process_content(instance):
     else:
         math = True if _MATH_REGEX.search(instance._content) else False
 
-    # The user initially set typogrify to be True, but since it would clash
+    # The user initially set Typogrify to be True, but since it would clash
     # with math, we set it to False. This means that the default reader will
-    # not call typogrify, so it is called here, where we are able to control
+    # not call Typogrify, so it is called here, where we are able to control
     # logic for it ignore math if necessary
     if _TYPOGRIFY:
-        # Tell typogrify to ignore the tags that math has been wrapped in
-        # also, typogrify must always ignore mml (math) tags
+        # Tell Typogrify to ignore the tags that math has been wrapped in
+        # also, Typogrify must always ignore mml (math) tags
         ignore_tags = [_WRAP_LATEX,'math'] if _WRAP_LATEX else ['math']
 
         # Exact copy of the logic as found in the default reader
@@ -295,7 +301,7 @@ def process_content(instance):
         # The summary needs special care because math math cannot just be cut
         # off
         summary = process_summary(instance, ignore_within)
-        if summary != None:
+        if summary is not None:
             instance._summary = summary
 
 
@@ -316,13 +322,13 @@ def pelican_init(pelicanobj):
 
     process_settings(settings)
 
-    # Allows mathjax script to be accessed from template should it be needed
+    # Allows MathJax script to be accessed from template should it be needed
     pelicanobj.settings['MATHJAXSCRIPT'] = _MATHJAX_SCRIPT.format(**_MATHJAX_SETTINGS)
 
-    # If typogrify set to True, then we need to handle it manually so it does
-    # not conflict with Latex
+    # If Typogrify set to True, then we need to handle it manually so it does
+    # not conflict with LaTeX
     try:
-        if pelicanobj.settings['TYPOGRIFY'] == True:
+        if pelicanobj.settings['TYPOGRIFY'] is True:
             pelicanobj.settings['TYPOGRIFY'] = False
             try:
                 from typogrify.filters import typogrify
@@ -331,7 +337,7 @@ def pelican_init(pelicanobj):
                 import inspect
                 typogrify_args = inspect.getargspec(typogrify).args
                 if len(typogrify_args) < 2 or 'ignore_tags' not in typogrify_args:
-                    raise TypeError('Incorrect version of typogrify')
+                    raise TypeError('Incorrect version of Typogrify')
 
                 # At this point, we are happy to use Typogrify, meaning
                 # it is installed and it is a recent enough version
@@ -339,9 +345,9 @@ def pelican_init(pelicanobj):
                 _TYPOGRIFY = typogrify
                 _WRAP_LATEX = 'mathjax' # default to wrap mathjax content inside of
             except ImportError:
-                print("\nTypogrify is not installed, so it is being ignored.\nPlease install it if you want to use it: pip install typogrify\n")
+                print("\nTypogrify is not installed, so it is being ignored.\nIf you want to use it, please install via: pip install typogrify\n")
             except TypeError:
-                print("\nA more recent versio of Typogrify is needed for the render_math module.\nPlease upgrade the typogrify to the latest version (anything above version 2.04 is okay).\nTypogrify will be turned off due to this reason\n")
+                print("\nA more recent version of Typogrify is needed for the render_math module.\nPlease upgrade Typogrify to the latest version (anything above version 2.04 is okay).\nTypogrify will be turned off due to this reason.\n")
     except KeyError:
         pass
 

From b95142b415aa8fe0c2cbdaa6cd26f118fc783048 Mon Sep 17 00:00:00 2001
From: Sven Kreiss <sk@svenkreiss.com>
Date: Fri, 7 Mar 2014 17:57:39 -0500
Subject: [PATCH 16/26] New vimeo tag.

---
 liquid_tags/Readme.md | 13 +++++++++--
 liquid_tags/vimeo.py  | 54 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 65 insertions(+), 2 deletions(-)
 create mode 100644 liquid_tags/vimeo.py

diff --git a/liquid_tags/Readme.md b/liquid_tags/Readme.md
index e1591f1..2fff718 100644
--- a/liquid_tags/Readme.md
+++ b/liquid_tags/Readme.md
@@ -14,8 +14,8 @@ First, in your pelicanconf.py file, add the plugins you want to  use:
 
     PLUGIN_PATH = '/path/to/pelican-plugins'
     PLUGINS = ['liquid_tags.img', 'liquid_tags.video',
-               'liquid_tags.youtube', 'liquid_tags.include_code',
-               'liquid_tags.notebook']
+               'liquid_tags.youtube', 'liquid_tags.vimeo',
+               'liquid_tags.include_code', 'liquid_tags.notebook']
 
 There are several options available
 
@@ -34,6 +34,15 @@ To insert youtube video into a post, enable the
 The width and height are in pixels, and can be optionally specified.  If they
 are not, then the dimensions will be 640 (wide) by 390 (tall).
 
+## Vimeo Tag
+To insert a Vimeo video into a post, enable the
+``liquid_tags.vimeo`` plugin, and add to your document:
+
+    {% vimeo vimeo_id [width] [height] %}
+
+The width and height are in pixels, and can be optionally specified.  If they
+are not, then the dimensions will be 640 (wide) by 390 (tall).
+
 ## Video Tag
 To insert flash/HTML5-friendly video into a post, enable the
 ``liquid_tags.video`` plugin, and add to your document:
diff --git a/liquid_tags/vimeo.py b/liquid_tags/vimeo.py
new file mode 100644
index 0000000..6dc929a
--- /dev/null
+++ b/liquid_tags/vimeo.py
@@ -0,0 +1,54 @@
+"""
+Vimeo Tag
+---------
+This implements a Liquid-style vimeo tag for Pelican,
+based on the youtube tag which is in turn based on
+the jekyll / octopress youtube tag [1]_
+
+Syntax
+------
+{% vimeo id [width height] %}
+
+Example
+-------
+{% vimeo 10739054 640 480 %}
+
+Output
+------
+<div style="width:640px; height:480px;"><iframe src="//player.vimeo.com/video/10739054?title=0&amp;byline=0&amp;portrait=0" width="640" height="480" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe></div>
+
+[1] https://gist.github.com/jamieowen/2063748
+"""
+import re
+from .mdx_liquid_tags import LiquidTags
+
+SYNTAX = "{% vimeo id [width height] %}"
+
+VIMEO = re.compile(r'(\w+)(\s+(\d+)\s(\d+))?')
+
+
+@LiquidTags.register('vimeo')
+def vimeo(preprocessor, tag, markup):
+    width = 640
+    height = 390
+    vimeo_id = None
+
+    match = VIMEO.search(markup)
+    if match:
+        groups = match.groups()
+        vimeo_id = groups[0]
+        width = groups[2] or width
+        height = groups[3] or height
+
+    if vimeo_id:
+        vimeo_out = '<div style="width:{width}px; height:{height}px;"><iframe src="//player.vimeo.com/video/{vimeo_id}?title=0&amp;byline=0&amp;portrait=0" width="{width}" height="{height}" frameborder="0" webkitAllowFullScreen mozallowfullscreen allowFullScreen></iframe></div>'.format(width=width, height=height, vimeo_id=vimeo_id)
+    else:
+        raise ValueError("Error processing input, "
+                         "expected syntax: {0}".format(SYNTAX))
+
+    return vimeo_out
+
+
+#----------------------------------------------------------------------
+# This import allows vimeo tag to be a Pelican plugin
+from liquid_tags import register

From db4683c515898f7b6978c454e68c601f41a91f3a Mon Sep 17 00:00:00 2001
From: MinRK <benjaminrk@gmail.com>
Date: Sun, 9 Mar 2014 11:00:14 -0700
Subject: [PATCH 17/26] support IPython 2.0 in notebook liquid tag

The only relevant changes seem to be a few renamed classes, and changed signatures.
---
 liquid_tags/notebook.py | 39 +++++++++++++++++++++++++++------------
 1 file changed, 27 insertions(+), 12 deletions(-)

diff --git a/liquid_tags/notebook.py b/liquid_tags/notebook.py
index 8b45d5d..f803bdf 100644
--- a/liquid_tags/notebook.py
+++ b/liquid_tags/notebook.py
@@ -55,7 +55,12 @@ if not LooseVersion(IPython.__version__) >= '1.0':
 
 from IPython import nbconvert
 
-from IPython.nbconvert.filters.highlight import _pygment_highlight
+try:
+    from IPython.nbconvert.filters.highlight import _pygments_highlight
+except ImportError:
+    # IPython < 2.0
+    from IPython.nbconvert.filters.highlight import _pygment_highlight as _pygments_highlight
+
 from pygments.formatters import HtmlFormatter
 
 from IPython.nbconvert.exporters import HTMLExporter
@@ -64,9 +69,10 @@ from IPython.config import Config
 from IPython.nbformat import current as nbformat
 
 try:
-    from IPython.nbconvert.transformers import Transformer
+    from IPython.nbconvert.preprocessors import Preprocessor
 except ImportError:
-    raise ValueError("IPython version 2.0 is not yet supported")
+    # IPython < 2.0
+    from IPython.nbconvert.transformers import Transformer as Preprocessor
 
 from IPython.utils.traitlets import Integer
 from copy import deepcopy
@@ -144,7 +150,7 @@ CSS_WRAPPER = """
 
 
 #----------------------------------------------------------------------
-# Create a custom transformer
+# Create a custom preprocessor
 class SliceIndex(Integer):
     """An integer trait that accepts None"""
     default_value = None
@@ -156,20 +162,22 @@ class SliceIndex(Integer):
             return super(SliceIndex, self).validate(obj, value)
 
 
-class SubCell(Transformer):
+class SubCell(Preprocessor):
     """A transformer to select a slice of the cells of a notebook"""
     start = SliceIndex(0, config=True,
                        help="first cell of notebook to be converted")
     end = SliceIndex(None, config=True,
                      help="last cell of notebook to be converted")
 
-    def call(self, nb, resources):
+    def preprocess(self, nb, resources):
         nbc = deepcopy(nb)
-        for worksheet in nbc.worksheets :
+        for worksheet in nbc.worksheets:
             cells = worksheet.cells[:]
             worksheet.cells = cells[self.start:self.end]
         return nbc, resources
 
+    call = preprocess # IPython < 2.0
+
 
 #----------------------------------------------------------------------
 # Customize the html template:
@@ -205,9 +213,11 @@ pelican_loader = DictLoader({'pelicanhtml.tpl':
 #----------------------------------------------------------------------
 # Custom highlighter:
 #  instead of using class='highlight', use class='highlight-ipynb'
-def custom_highlighter(source, language='ipython'):
+def custom_highlighter(source, language='ipython', metadata=None):
     formatter = HtmlFormatter(cssclass='highlight-ipynb')
-    output = _pygment_highlight(source, formatter, language)
+    if not language:
+        language = 'ipython'
+    output = _pygments_highlight(source, formatter, language)
     return output.replace('<pre>', '<pre class="ipynb">')
 
 
@@ -252,12 +262,17 @@ def notebook(preprocessor, tag, markup):
                     {'enabled':True, 'highlight_class':'.highlight-ipynb'},
                 'SubCell':
                     {'enabled':True, 'start':start, 'end':end}})
-
+    
+    if LooseVersion(IPython.__version__) >= '2.0':
+        subcell_kwarg = dict(preprocessors=[SubCell])
+    else:
+        subcell_kwarg = dict(transformers=[SubCell])
+    
     exporter = HTMLExporter(config=c,
                             template_file='basic',
                             filters={'highlight2html': custom_highlighter},
-                            transformers=[SubCell],
-                            extra_loaders=[pelican_loader])
+                            extra_loaders=[pelican_loader],
+                            **subcell_kwarg)
 
     # read and parse the notebook
     with open(nb_path) as f:

From 657505cf3538724f1fe5fcfda3044a822fcb4095 Mon Sep 17 00:00:00 2001
From: MinRK <benjaminrk@gmail.com>
Date: Sun, 9 Mar 2014 16:51:31 -0700
Subject: [PATCH 18/26] adjust embedded notebook CSS for IPython 2.0

remove text-cell prompt and padding, so it aligns with outer body text
---
 liquid_tags/notebook.py | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/liquid_tags/notebook.py b/liquid_tags/notebook.py
index f803bdf..8c896a2 100644
--- a/liquid_tags/notebook.py
+++ b/liquid_tags/notebook.py
@@ -117,6 +117,17 @@ pre.ipynb {
   font-size: 13px;
 }
 
+/* remove the prompt div from text cells */
+div.text_cell .prompt {
+    display: none;
+}
+
+/* remove horizontal padding from text cells, */
+/* so it aligns with outer body text */
+div.text_cell_render {
+    padding: 0.5em 0em;
+}
+
 img.anim_icon{padding:0; border:0; vertical-align:middle; -webkit-box-shadow:none; -box-shadow:none}
 </style>
 

From fb570c528bc87af5e2e54a7eda3820aa90c7a342 Mon Sep 17 00:00:00 2001
From: Barry Steyn <barry.steyn@gmail.com>
Date: Tue, 18 Mar 2014 06:42:41 -0700
Subject: [PATCH 19/26] Fixed errors arising from Python 3.x

---
 render_math/math.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/render_math/math.py b/render_math/math.py
index 190b5f6..2bd292e 100644
--- a/render_math/math.py
+++ b/render_math/math.py
@@ -18,7 +18,6 @@ for template builders that want to adjust the look and feel of the math.
 See README for more details.
 """
 
-from __future__ import print_function
 import os
 import re
 
@@ -55,7 +54,7 @@ def binary_search(match_tuple, ignore_within):
     # Find first value in array where predicate is False
     # predicate function: tupleList[mid][0] < t[index]
     while lo < hi:
-        mid = lo + (hi-lo+1)/2
+        mid = lo + (hi-lo+1)//2
         if ignore_within[mid][0] < match_tuple[0]:
             lo = mid
         else:

From 20f8a24971064af1ede1a6ca44f7e1478da7cef1 Mon Sep 17 00:00:00 2001
From: Bernhard Scheirle <bernhard-scheirle@gmx.de>
Date: Sun, 30 Mar 2014 14:14:22 +0200
Subject: [PATCH 20/26] Added plugin: pelican comment system

---
 pelican_comment_system/Readme.md              | 110 ++++++++++++++++++
 pelican_comment_system/__init__.py            |   1 +
 .../pelican_comment_system.py                 | 104 +++++++++++++++++
 3 files changed, 215 insertions(+)
 create mode 100644 pelican_comment_system/Readme.md
 create mode 100644 pelican_comment_system/__init__.py
 create mode 100644 pelican_comment_system/pelican_comment_system.py

diff --git a/pelican_comment_system/Readme.md b/pelican_comment_system/Readme.md
new file mode 100644
index 0000000..441cbab
--- /dev/null
+++ b/pelican_comment_system/Readme.md
@@ -0,0 +1,110 @@
+# Pelican comment system
+The pelican comment system allows you to add static comments to your articles. It also supports replies to comments.
+
+The comments are stored in Markdown files. Each comment in it own file.
+
+See it in action here: [blog.scheirle.de](http://blog.scheirle.de/posts/2014/March/29/static-comments-via-email/)
+
+Thanks to jesrui the author of [Static comments](https://github.com/getpelican/pelican-plugins/tree/master/static_comments). I reused some code from it.
+
+## Installation
+Activate the plugin by adding it you your `pelicanconf.py`
+
+	PLUGIN_PATH = '/path/to/pelican-plugins'
+	PLUGINS = ['pelican_comment_system']
+	PELICAN_COMMENT_SYSTEM = True
+
+And modify your `article.html` theme (see below).
+
+## Settings
+Name                         | Type      | Default    | Description
+-----------------------------|-----------|------------|-------
+`PELICAN_COMMENT_SYSTEM`     | `boolean` | `False`    | Activates or deactivates the comment system
+`PELICAN_COMMENT_SYSTEM_DIR` | `string`  | `comments` | Folder where the comments are stored
+
+
+### Folder structure
+Every comment file has to be stored in a sub folder of `PELICAN_COMMENT_SYSTEM_DIR`.
+Sub folders are named after the `slug` of the articles.
+
+So the comments to your `foo-bar` article are stored in `comments/foo-bar/`
+
+The filenames of the comment files are up to you. But the filename is the Identifier of the comment (without extension).
+
+##### Example folder structure
+
+	.
+	└── comments
+		└── foo-bar
+		│   ├── 1.md
+		│   └── 0.md
+		└── some-other-slug
+			├── random-Name.md
+			├── 1.md
+			└── 0.md
+
+
+### Comment file
+##### Meta information
+Tag           | Required  | Description
+--------------|-----------|----------------
+`date`        | yes       | Date when the comment was posted
+`replyto`     | no        | Identifier of the parent comment. Identifier = Filename (without extension)
+`locale_date` | forbidden | Will be overwritten with a locale representation of the date
+
+Every other (custom) tag gets parsed as well and will be available through the theme.
+
+
+##### Example of a comment file
+
+	date: 2014-3-21 15:02
+	author: Author of the comment
+	website: http://authors.website.com
+	replyto: 7
+	anothermetatag: some random tag
+
+	Content of the comment.
+
+### Theme
+In the `article.html` theme file are now two more variables available.
+
+Variables                         | Description
+----------------------------------|--------------------------
+`article.metadata.comments_count` | Amount of total comments for this article (including replies to comments)
+`article.metadata.comments`       | Array containing the top level comments for this article (no replies to comments)
+
+#### Comment object
+Variables  | Description
+-----------|--------------------------
+`id`       | Identifier of this comment
+`content`  | Content of this comment
+`metadata` | All metadata as in the comment file (or described above)
+`replies`  | Array containing the top level replies for this comment
+
+##### Example article.html theme
+(only the comment section)
+
+```html
+{% if article.metadata.comments %}
+	{% for comment in article.metadata.comments recursive %}
+		{% set metadata = comment.metadata %}
+		{% if loop.depth0 == 0 %}
+			{% set marginLeft = 0 %}
+		{% else %}
+			{% set marginLeft = 50 %}
+		{% endif %}
+			<article id="comment-{{comment.id}}" style="border: 1px solid #DDDDDD; padding: 5px 0px 0px 5px; margin: 0px -1px 5px {{marginLeft}}px;">
+				<a href="{{ SITEURL }}/{{ article.url }}#comment-{{comment.id}}" rel="bookmark" title="Permalink to this comment">Permalink</a>
+				<h4>{{ metadata['author'] }}</h4>
+				<p>Posted on <abbr class="published" title="{{ metadata['date'].isoformat() }}">{{ metadata['locale_date'] }}</abbr></p>
+
+				{{ comment.content }}
+				{% if comment.replies %}
+					{{ loop(comment.replies) }}
+				{% endif %}
+			</article>
+	{% endfor %}
+{% else %}
+	<p>There are no comments yet.<p>
+{% endif %}
+```
diff --git a/pelican_comment_system/__init__.py b/pelican_comment_system/__init__.py
new file mode 100644
index 0000000..4c8a3ca
--- /dev/null
+++ b/pelican_comment_system/__init__.py
@@ -0,0 +1 @@
+from .pelican_comment_system import *
diff --git a/pelican_comment_system/pelican_comment_system.py b/pelican_comment_system/pelican_comment_system.py
new file mode 100644
index 0000000..bf281bf
--- /dev/null
+++ b/pelican_comment_system/pelican_comment_system.py
@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+from itertools import chain
+from pelican import signals
+from pelican.utils import strftime
+from pelican.readers import MarkdownReader
+
+class Comment:
+	def __init__(self, id, metadata, content):
+		self.id = id
+		self.content = content
+		self.metadata = metadata
+		self.replies = []
+
+	def addReply(self, comment):
+		self.replies.append(comment)
+
+	def getReply(self, id):
+		for reply in self.replies:
+			if reply.id == id:
+				return reply
+			else:
+				deepReply = reply.getReply(id)
+				if deepReply != None:
+					return deepReply
+		return None
+
+	def __lt__(self, other):
+		return self.metadata['date'] < other.metadata['date']
+
+	def sort(self):
+		for r in self.replies:
+			r.sort()
+		self.replies = sorted(self.replies)
+
+	def countReplies(self):
+		amount = 0
+		for r in self.replies:
+			amount += r.countReplies()
+		return amount + len(self.replies)
+
+def initialized(pelican):
+	from pelican.settings import DEFAULT_CONFIG
+	DEFAULT_CONFIG.setdefault('PELICAN_COMMENT_SYSTEM', False)
+	DEFAULT_CONFIG.setdefault('PELICAN_COMMENT_SYSTEM_DIR' 'comments')
+	if pelican:
+		pelican.settings.setdefault('PELICAN_COMMENT_SYSTEM', False)
+		pelican.settings.setdefault('PELICAN_COMMENT_SYSTEM_DIR', 'comments')
+
+
+def add_static_comments(gen, metadata):
+	if gen.settings['PELICAN_COMMENT_SYSTEM'] != True:
+		return
+
+	metadata['comments_count'] = 0
+	metadata['comments'] = []
+
+	if not 'slug' in metadata:
+		logger.warning("pelican_comment_system: cant't locate comments files without slug tag in the article")
+		return
+
+	reader = MarkdownReader(gen.settings)
+	comments = []
+	replies = []
+	folder = os.path.join(gen.settings['PELICAN_COMMENT_SYSTEM_DIR'], metadata['slug'])
+
+	if not os.path.isdir(folder):
+		logger.debug("No comments found for: " + metadata['slug'])
+		return
+
+	for file in os.listdir(folder):
+		name, extension = os.path.splitext(file)
+		if extension[1:].lower() in reader.file_extensions:
+			content, meta = reader.read(folder + "/" + file)
+			meta['locale_date'] = strftime(meta['date'], gen.settings['DEFAULT_DATE_FORMAT'])
+			com = Comment(name, meta, content)
+			if 'replyto' in meta:
+				replies.append( com )
+			else:
+				comments.append( com )
+
+	for reply in replies:
+		for comment in chain(comments, replies):
+			if comment.id == reply.metadata['replyto']:
+				comment.addReply(reply)
+
+	count = 0
+	for comment in comments:
+		comment.sort()
+		count += comment.countReplies()
+
+	comments = sorted(comments)
+
+	metadata['comments_count'] = len(comments) + count
+	metadata['comments'] = comments
+
+def register():
+	signals.initialized.connect(initialized)
+	signals.article_generator_context.connect(add_static_comments)

From 1a20cc84b28951982eec239743d1e8c3627e996f Mon Sep 17 00:00:00 2001
From: Bernhard Scheirle <bernhard-scheirle@gmx.de>
Date: Thu, 3 Apr 2014 19:38:45 +0200
Subject: [PATCH 21/26] [pelican_comment_system] Added Recommendation

---
 pelican_comment_system/Readme.md              | 84 ++++++++++++++++++-
 .../pelican_comment_system.py                 | 16 +++-
 2 files changed, 96 insertions(+), 4 deletions(-)

diff --git a/pelican_comment_system/Readme.md b/pelican_comment_system/Readme.md
index 441cbab..14d327a 100644
--- a/pelican_comment_system/Readme.md
+++ b/pelican_comment_system/Readme.md
@@ -7,8 +7,12 @@ See it in action here: [blog.scheirle.de](http://blog.scheirle.de/posts/2014/Mar
 
 Thanks to jesrui the author of [Static comments](https://github.com/getpelican/pelican-plugins/tree/master/static_comments). I reused some code from it.
 
+Author             | Website                   | Github
+-------------------|---------------------------|------------------------------
+Bernhard Scheirle  | <http://blog.scheirle.de> | <https://github.com/Scheirle>
+
 ## Installation
-Activate the plugin by adding it you your `pelicanconf.py`
+Activate the plugin by adding it to your `pelicanconf.py`
 
 	PLUGIN_PATH = '/path/to/pelican-plugins'
 	PLUGINS = ['pelican_comment_system']
@@ -108,3 +112,81 @@ Variables  | Description
 	<p>There are no comments yet.<p>
 {% endif %}
 ```
+## Recommendation
+Add a form, which allows your visitors to easily write comments.
+
+But more importantly, on submit the form generates a mailto-link.
+The resulting email contains a valid markdown block. Now you only have to copy this block in a new file. And therefore there is no need to gather the metadata (like date, author, replyto) yourself.
+
+##### Reply button
+Add this in the above `for` loop, so your visitors can reply to a comment.
+
+```html
+<button onclick="reply('{{comment.id | urlencode}}');">Reply</button>
+```
+
+##### form + javascript
+
+```html
+<form role="form" id="commentForm" action="#">
+	<input name="Name" type="text" id="commentForm_inputName" placeholder="Enter your name or synonym">
+	<textarea name="Text" id="commentForm_inputText" rows="10" style="resize:vertical;" placeholder="Your comment"></textarea>
+	<button type="submit" id="commentForm_button">Post via email</button>
+	<input name="replyto" type="hidden" id="commentForm_replyto">
+</form>
+```
+
+```javascript
+<script type="text/javascript">
+	function reply(id)
+	{
+		id = decodeURIComponent(id);
+		$('#commentForm_replyto').val(id);
+	}
+
+	$(document).ready(function() {
+		function generateMailToLink()
+		{
+			var user = 'your_user_name'; //user@domain = your email address
+			var domain = 'your_email_provider';
+			var subject = 'Comment for \'{{ article.slug }}\'' ;
+
+			var d = new Date();
+			var body = ''
+				+ 'Hey,\nI posted a new comment on ' + document.URL + '\n\nGreetings ' + $("#commentForm_inputName").val() + '\n\n\n'
+				+ 'Raw comment data:\n'
+				+ '----------------------------------------\n'
+				+ 'date: ' + d.getFullYear() + '-' + (d.getMonth()+1) + '-' + d.getDate() + ' ' + d.getHours() + ':' + d.getMinutes() + '\n'
+				+ 'author: ' + $("#commentForm_inputName").val() + '\n';
+
+			var replyto = $('#commentForm_replyto').val();
+			if (replyto.length != 0)
+			{
+				body += 'replyto: ' + replyto + '\n'
+			}
+
+			body += '\n'
+				+ $("#commentForm_inputText").val() + '\n'
+				+ '----------------------------------------\n';
+
+			var link = 'mailto:' + user + '@' + domain + '?subject='
+				+ encodeURIComponent(subject)
+				+ "&body="
+				+ encodeURIComponent(body);
+			return link;
+		}
+
+
+		$('#commentForm').on("submit",
+			function( event )
+			{
+				event.preventDefault();
+				$(location).attr('href', generateMailToLink());
+			}
+		);
+	});
+</script>
+```
+(jQuery is required for this script)
+
+Don't forget to set the Variables `user` and `domain`.
diff --git a/pelican_comment_system/pelican_comment_system.py b/pelican_comment_system/pelican_comment_system.py
index bf281bf..cee8ff5 100644
--- a/pelican_comment_system/pelican_comment_system.py
+++ b/pelican_comment_system/pelican_comment_system.py
@@ -1,4 +1,12 @@
 # -*- coding: utf-8 -*-
+"""
+Pelican Comment System
+======================
+
+A Pelican plugin, which allows you to add comments to your articles.
+
+Author: Bernhard Scheirle
+"""
 
 import logging
 import os
@@ -33,9 +41,9 @@ class Comment:
 	def __lt__(self, other):
 		return self.metadata['date'] < other.metadata['date']
 
-	def sort(self):
+	def sortReplies(self):
 		for r in self.replies:
-			r.sort()
+			r.sortReplies()
 		self.replies = sorted(self.replies)
 
 	def countReplies(self):
@@ -44,6 +52,7 @@ class Comment:
 			amount += r.countReplies()
 		return amount + len(self.replies)
 
+
 def initialized(pelican):
 	from pelican.settings import DEFAULT_CONFIG
 	DEFAULT_CONFIG.setdefault('PELICAN_COMMENT_SYSTEM', False)
@@ -84,6 +93,7 @@ def add_static_comments(gen, metadata):
 			else:
 				comments.append( com )
 
+	#TODO: Fix this O(n²) loop
 	for reply in replies:
 		for comment in chain(comments, replies):
 			if comment.id == reply.metadata['replyto']:
@@ -91,7 +101,7 @@ def add_static_comments(gen, metadata):
 
 	count = 0
 	for comment in comments:
-		comment.sort()
+		comment.sortReplies()
 		count += comment.countReplies()
 
 	comments = sorted(comments)

From 98e2f16059a03ee3496c3caac33af010c8adcd75 Mon Sep 17 00:00:00 2001
From: Bernhard Scheirle <bernhard-scheirle@gmx.de>
Date: Thu, 10 Apr 2014 08:58:19 +0200
Subject: [PATCH 22/26] [pelican_comment_system] Added Avatars and Identicons

---
 pelican_comment_system/Readme.md              | 201 ++------------
 pelican_comment_system/avatars.py             |  92 +++++++
 pelican_comment_system/doc/avatars.md         |  35 +++
 pelican_comment_system/doc/form.md            |  83 ++++++
 pelican_comment_system/doc/installation.md    | 104 +++++++
 pelican_comment_system/identicon/LICENSE      |  11 +
 pelican_comment_system/identicon/README.md    |  17 ++
 pelican_comment_system/identicon/__init__.py  |   0
 pelican_comment_system/identicon/identicon.py | 255 ++++++++++++++++++
 .../pelican_comment_system.py                 |  45 +++-
 10 files changed, 653 insertions(+), 190 deletions(-)
 create mode 100644 pelican_comment_system/avatars.py
 create mode 100644 pelican_comment_system/doc/avatars.md
 create mode 100644 pelican_comment_system/doc/form.md
 create mode 100644 pelican_comment_system/doc/installation.md
 create mode 100755 pelican_comment_system/identicon/LICENSE
 create mode 100755 pelican_comment_system/identicon/README.md
 create mode 100644 pelican_comment_system/identicon/__init__.py
 create mode 100755 pelican_comment_system/identicon/identicon.py

diff --git a/pelican_comment_system/Readme.md b/pelican_comment_system/Readme.md
index 14d327a..e95d86a 100644
--- a/pelican_comment_system/Readme.md
+++ b/pelican_comment_system/Readme.md
@@ -1,192 +1,29 @@
 # Pelican comment system
-The pelican comment system allows you to add static comments to your articles. It also supports replies to comments.
-
+The pelican comment system allows you to add static comments to your articles.
 The comments are stored in Markdown files. Each comment in it own file.
 
-See it in action here: [blog.scheirle.de](http://blog.scheirle.de/posts/2014/March/29/static-comments-via-email/)
+#### Features
+ - Static comments for each article
+ - Replies to comments
+ - Avatars and [Identicons](https://en.wikipedia.org/wiki/Identicon)
+ - Easy styleable via the themes
 
-Thanks to jesrui the author of [Static comments](https://github.com/getpelican/pelican-plugins/tree/master/static_comments). I reused some code from it.
+
+See it in action here: [blog.scheirle.de](http://blog.scheirle.de/posts/2014/March/29/static-comments-via-email/)
 
 Author             | Website                   | Github
 -------------------|---------------------------|------------------------------
 Bernhard Scheirle  | <http://blog.scheirle.de> | <https://github.com/Scheirle>
 
-## Installation
-Activate the plugin by adding it to your `pelicanconf.py`
+## Instructions
+ - [Installation and basic usage](doc/installation.md)
+ - [Avatars and Identicons](doc/avatars.md)
+ - [Comment Form (aka: never gather Metadata)](doc/form.md)
+ 
+## Requirements
+To create identicons the Python Image Library is needed. Therefore you either need PIL **or** Pillow (recommended).
 
-	PLUGIN_PATH = '/path/to/pelican-plugins'
-	PLUGINS = ['pelican_comment_system']
-	PELICAN_COMMENT_SYSTEM = True
-
-And modify your `article.html` theme (see below).
-
-## Settings
-Name                         | Type      | Default    | Description
------------------------------|-----------|------------|-------
-`PELICAN_COMMENT_SYSTEM`     | `boolean` | `False`    | Activates or deactivates the comment system
-`PELICAN_COMMENT_SYSTEM_DIR` | `string`  | `comments` | Folder where the comments are stored
-
-
-### Folder structure
-Every comment file has to be stored in a sub folder of `PELICAN_COMMENT_SYSTEM_DIR`.
-Sub folders are named after the `slug` of the articles.
-
-So the comments to your `foo-bar` article are stored in `comments/foo-bar/`
-
-The filenames of the comment files are up to you. But the filename is the Identifier of the comment (without extension).
-
-##### Example folder structure
-
-	.
-	└── comments
-		└── foo-bar
-		│   ├── 1.md
-		│   └── 0.md
-		└── some-other-slug
-			├── random-Name.md
-			├── 1.md
-			└── 0.md
-
-
-### Comment file
-##### Meta information
-Tag           | Required  | Description
---------------|-----------|----------------
-`date`        | yes       | Date when the comment was posted
-`replyto`     | no        | Identifier of the parent comment. Identifier = Filename (without extension)
-`locale_date` | forbidden | Will be overwritten with a locale representation of the date
-
-Every other (custom) tag gets parsed as well and will be available through the theme.
-
-
-##### Example of a comment file
-
-	date: 2014-3-21 15:02
-	author: Author of the comment
-	website: http://authors.website.com
-	replyto: 7
-	anothermetatag: some random tag
-
-	Content of the comment.
-
-### Theme
-In the `article.html` theme file are now two more variables available.
-
-Variables                         | Description
-----------------------------------|--------------------------
-`article.metadata.comments_count` | Amount of total comments for this article (including replies to comments)
-`article.metadata.comments`       | Array containing the top level comments for this article (no replies to comments)
-
-#### Comment object
-Variables  | Description
------------|--------------------------
-`id`       | Identifier of this comment
-`content`  | Content of this comment
-`metadata` | All metadata as in the comment file (or described above)
-`replies`  | Array containing the top level replies for this comment
-
-##### Example article.html theme
-(only the comment section)
-
-```html
-{% if article.metadata.comments %}
-	{% for comment in article.metadata.comments recursive %}
-		{% set metadata = comment.metadata %}
-		{% if loop.depth0 == 0 %}
-			{% set marginLeft = 0 %}
-		{% else %}
-			{% set marginLeft = 50 %}
-		{% endif %}
-			<article id="comment-{{comment.id}}" style="border: 1px solid #DDDDDD; padding: 5px 0px 0px 5px; margin: 0px -1px 5px {{marginLeft}}px;">
-				<a href="{{ SITEURL }}/{{ article.url }}#comment-{{comment.id}}" rel="bookmark" title="Permalink to this comment">Permalink</a>
-				<h4>{{ metadata['author'] }}</h4>
-				<p>Posted on <abbr class="published" title="{{ metadata['date'].isoformat() }}">{{ metadata['locale_date'] }}</abbr></p>
-
-				{{ comment.content }}
-				{% if comment.replies %}
-					{{ loop(comment.replies) }}
-				{% endif %}
-			</article>
-	{% endfor %}
-{% else %}
-	<p>There are no comments yet.<p>
-{% endif %}
-```
-## Recommendation
-Add a form, which allows your visitors to easily write comments.
-
-But more importantly, on submit the form generates a mailto-link.
-The resulting email contains a valid markdown block. Now you only have to copy this block in a new file. And therefore there is no need to gather the metadata (like date, author, replyto) yourself.
-
-##### Reply button
-Add this in the above `for` loop, so your visitors can reply to a comment.
-
-```html
-<button onclick="reply('{{comment.id | urlencode}}');">Reply</button>
-```
-
-##### form + javascript
-
-```html
-<form role="form" id="commentForm" action="#">
-	<input name="Name" type="text" id="commentForm_inputName" placeholder="Enter your name or synonym">
-	<textarea name="Text" id="commentForm_inputText" rows="10" style="resize:vertical;" placeholder="Your comment"></textarea>
-	<button type="submit" id="commentForm_button">Post via email</button>
-	<input name="replyto" type="hidden" id="commentForm_replyto">
-</form>
-```
-
-```javascript
-<script type="text/javascript">
-	function reply(id)
-	{
-		id = decodeURIComponent(id);
-		$('#commentForm_replyto').val(id);
-	}
-
-	$(document).ready(function() {
-		function generateMailToLink()
-		{
-			var user = 'your_user_name'; //user@domain = your email address
-			var domain = 'your_email_provider';
-			var subject = 'Comment for \'{{ article.slug }}\'' ;
-
-			var d = new Date();
-			var body = ''
-				+ 'Hey,\nI posted a new comment on ' + document.URL + '\n\nGreetings ' + $("#commentForm_inputName").val() + '\n\n\n'
-				+ 'Raw comment data:\n'
-				+ '----------------------------------------\n'
-				+ 'date: ' + d.getFullYear() + '-' + (d.getMonth()+1) + '-' + d.getDate() + ' ' + d.getHours() + ':' + d.getMinutes() + '\n'
-				+ 'author: ' + $("#commentForm_inputName").val() + '\n';
-
-			var replyto = $('#commentForm_replyto').val();
-			if (replyto.length != 0)
-			{
-				body += 'replyto: ' + replyto + '\n'
-			}
-
-			body += '\n'
-				+ $("#commentForm_inputText").val() + '\n'
-				+ '----------------------------------------\n';
-
-			var link = 'mailto:' + user + '@' + domain + '?subject='
-				+ encodeURIComponent(subject)
-				+ "&body="
-				+ encodeURIComponent(body);
-			return link;
-		}
-
-
-		$('#commentForm').on("submit",
-			function( event )
-			{
-				event.preventDefault();
-				$(location).attr('href', generateMailToLink());
-			}
-		);
-	});
-</script>
-```
-(jQuery is required for this script)
-
-Don't forget to set the Variables `user` and `domain`.
+##### Install Pillow
+	easy_install Pillow
+	
+If you don't use avatars or identicons this plugin works fine without PIL/Pillow. You will however get a warning that identicons are deactivated (as expected).
diff --git a/pelican_comment_system/avatars.py b/pelican_comment_system/avatars.py
new file mode 100644
index 0000000..5094d1c
--- /dev/null
+++ b/pelican_comment_system/avatars.py
@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+"""
+
+"""
+
+import logging
+import os
+
+import hashlib
+
+
+logger = logging.getLogger(__name__)
+_log = "pelican_comment_system: avatars: "
+try:
+	from identicon import identicon
+	_identiconImported = True
+except ImportError as e:
+	logger.warning(_log + "identicon deactivated: " + str(e))
+	_identiconImported = False
+
+# Global Variables
+_identicon_save_path = None
+_identicon_output_path = None
+_identicon_data = None
+_identicon_size = None
+_initialized = False
+_authors = None
+_missingAvatars = []
+
+def _ready():
+	if not _initialized:
+		logger.warning(_log + "Module not initialized. use init")
+	if not _identicon_data:
+		logger.debug(_log + "No identicon data set")
+	return _identiconImported and _initialized and _identicon_data
+
+
+def init(pelican_output_path, identicon_output_path, identicon_data, identicon_size, authors):
+	global _identicon_save_path
+	global _identicon_output_path
+	global _identicon_data
+	global _identicon_size
+	global _initialized
+	global _authors
+	_identicon_save_path = os.path.join(pelican_output_path, identicon_output_path)
+	_identicon_output_path = identicon_output_path
+	_identicon_data = identicon_data
+	_identicon_size = identicon_size
+	_authors = authors
+	_initialized = True
+
+def _createIdenticonOutputFolder():
+	if not _ready():
+		return
+
+	if not os.path.exists(_identicon_save_path):
+		os.makedirs(_identicon_save_path)
+
+
+def getAvatarPath(comment_id, metadata):
+	if not _ready():
+		return ''
+
+	md5 = hashlib.md5()
+	author = tuple()
+	for data in _identicon_data:
+		if data in metadata:
+			string = str(metadata[data])
+			md5.update(string)
+			author += tuple([string])
+		else:
+			logger.warning(_log + data + " is missing in comment: " + comment_id)
+
+	if author in _authors:
+		return _authors[author]
+
+	global _missingAvatars
+
+	code = md5.hexdigest()
+
+	if not code in _missingAvatars:
+		_missingAvatars.append(code)
+
+	return os.path.join(_identicon_output_path, '%s.png' % code)
+
+def generateAndSaveMissingAvatars():
+	_createIdenticonOutputFolder()
+	for code in _missingAvatars:
+		avatar_path = '%s.png' % code
+		avatar = identicon.render_identicon(int(code, 16), _identicon_size)
+		avatar_save_path = os.path.join(_identicon_save_path, avatar_path)
+		avatar.save(avatar_save_path, 'PNG')
diff --git a/pelican_comment_system/doc/avatars.md b/pelican_comment_system/doc/avatars.md
new file mode 100644
index 0000000..8d05e70
--- /dev/null
+++ b/pelican_comment_system/doc/avatars.md
@@ -0,0 +1,35 @@
+# Avatars and Identicons
+To activate the avatars and [identicons](https://en.wikipedia.org/wiki/Identicon) you have to set `PELICAN_COMMENT_SYSTEM_IDENTICON_DATA`.
+
+##### Example
+```python
+PELICAN_COMMENT_SYSTEM_IDENTICON_DATA = ('author')
+```
+Now every comment with the same author tag will be treated as if written from the same person. And therefore have the same avatar/identicon. Of cause you can modify this tuple so other metadata are checked.
+
+## Specific Avatars
+To set a specific avatar for a author you have to add them to the `PELICAN_COMMENT_SYSTEM_AUTHORS` dictionary.
+
+The `key` of the dictionary has to be a tuple of the form of `PELICAN_COMMENT_SYSTEM_IDENTICON_DATA`, so in our case only the author's name.
+
+The `value` of the dictionary is the path to the specific avatar.
+
+##### Example
+```python
+PELICAN_COMMENT_SYSTEM_AUTHORS = {
+	('John'): "images/authors/john.png",
+	('Tom'): "images/authors/tom.png",
+}
+```
+
+## Theme
+To display the avatars and identicons simply add the following in the "comment for loop" in you theme:
+
+```html
+<img src="{{ SITEURL }}/{{ comment.avatar }}"
+		alt="Avatar"
+		height="{{ PELICAN_COMMENT_SYSTEM_IDENTICON_SIZE }}"
+		width="{{ PELICAN_COMMENT_SYSTEM_IDENTICON_SIZE }}">
+```
+
+Of cause the `height` and `width` are optional, but they make sure that everything has the same size (in particular  specific avatars).
diff --git a/pelican_comment_system/doc/form.md b/pelican_comment_system/doc/form.md
new file mode 100644
index 0000000..81124a8
--- /dev/null
+++ b/pelican_comment_system/doc/form.md
@@ -0,0 +1,83 @@
+# Comment Form (aka: never gather Metadata)
+Add a form, which allows your visitors to easily write comments.
+
+But more importantly, on submit the form generates a mailto-link.
+The resulting email contains a valid markdown block. Now you only have to copy this block in a new file. And therefore there is no need to gather the metadata (like date, author, replyto) yourself.
+
+#### Reply button
+Add this in the "comment for loop" in your article theme, so your visitors can reply to a comment.
+
+```html
+<button onclick="reply('{{comment.id | urlencode}}');">Reply</button>
+```
+
+#### Form
+A basic form so your visitors can write comments.
+
+```html
+<form role="form" id="commentForm" action="#">
+	<input name="Name" type="text" id="commentForm_inputName" placeholder="Enter your name or synonym">
+	<textarea name="Text" id="commentForm_inputText" rows="10" style="resize:vertical;" placeholder="Your comment"></textarea>
+	<button type="submit" id="commentForm_button">Post via email</button>
+	<input name="replyto" type="hidden" id="commentForm_replyto">
+</form>
+```
+You may want to add a button to reset the `replyto` field.
+
+#### Javascript
+To generate the mailto-Link and set the `replyto` field there is some javascript required.
+
+```javascript
+<script type="text/javascript">
+	function reply(id)
+	{
+		id = decodeURIComponent(id);
+		$('#commentForm_replyto').val(id);
+	}
+
+	$(document).ready(function() {
+		function generateMailToLink()
+		{
+			var user = 'your_user_name'; //user@domain = your email address
+			var domain = 'your_email_provider';
+			var subject = 'Comment for \'{{ article.slug }}\'' ;
+
+			var d = new Date();
+			var body = ''
+				+ 'Hey,\nI posted a new comment on ' + document.URL + '\n\nGreetings ' + $("#commentForm_inputName").val() + '\n\n\n'
+				+ 'Raw comment data:\n'
+				+ '----------------------------------------\n'
+				+ 'date: ' + d.getFullYear() + '-' + (d.getMonth()+1) + '-' + d.getDate() + ' ' + d.getHours() + ':' + d.getMinutes() + '\n'
+				+ 'author: ' + $("#commentForm_inputName").val() + '\n';
+
+			var replyto = $('#commentForm_replyto').val();
+			if (replyto.length != 0)
+			{
+				body += 'replyto: ' + replyto + '\n'
+			}
+
+			body += '\n'
+				+ $("#commentForm_inputText").val() + '\n'
+				+ '----------------------------------------\n';
+
+			var link = 'mailto:' + user + '@' + domain + '?subject='
+				+ encodeURIComponent(subject)
+				+ "&body="
+				+ encodeURIComponent(body);
+			return link;
+		}
+
+
+		$('#commentForm').on("submit",
+			function( event )
+			{
+				event.preventDefault();
+				$(location).attr('href', generateMailToLink());
+			}
+		);
+	});
+</script>
+```
+(jQuery is required for this script)
+
+Don't forget to set the Variables `user` and `domain`.
diff --git a/pelican_comment_system/doc/installation.md b/pelican_comment_system/doc/installation.md
new file mode 100644
index 0000000..7fda760
--- /dev/null
+++ b/pelican_comment_system/doc/installation.md
@@ -0,0 +1,104 @@
+# Installation
+Activate the plugin by adding it to your `pelicanconf.py`
+
+	PLUGIN_PATH = '/path/to/pelican-plugins'
+	PLUGINS = ['pelican_comment_system']
+	PELICAN_COMMENT_SYSTEM = True
+
+And modify your `article.html` theme (see below).
+
+## Settings
+Name                                           | Type      | Default            | Description
+-----------------------------------------------|-----------|--------------------|-------
+`PELICAN_COMMENT_SYSTEM`                       | `boolean` | `False`            | Activates or deactivates the comment system
+`PELICAN_COMMENT_SYSTEM_DIR`                   | `string`  | `comments`         | Folder where the comments are stored
+`PELICAN_COMMENT_SYSTEM_IDENTICON_OUTPUT_PATH` | `string`  | `images/identicon` | Output folder where the identicons are stored
+`PELICAN_COMMENT_SYSTEM_IDENTICON_DATA`        | `tuple`   | `()`               | Contains all Metadata tags, which in combination identifies a comment author (like `('author', 'email')`)
+`PELICAN_COMMENT_SYSTEM_IDENTICON_SIZE`        | `int`     | `72`               | Width and height of the identicons. Has to be a multiple of 3.
+`PELICAN_COMMENT_SYSTEM_AUTHORS`               | `dict`    | `{}`               | Comment authors, which should have a specific avatar. More infos [here](avatars.md)
+
+
+## Folder structure
+Every comment file has to be stored in a sub folder of `PELICAN_COMMENT_SYSTEM_DIR`.
+Sub folders are named after the `slug` of the articles.
+
+So the comments to your `foo-bar` article are stored in `comments/foo-bar/`
+
+The filenames of the comment files are up to you. But the filename is the Identifier of the comment (without extension).
+
+##### Example folder structure
+
+	.
+	└── comments
+		└── foo-bar
+		│   ├── 1.md
+		│   └── 0.md
+		└── some-other-slug
+			├── random-Name.md
+			├── 1.md
+			└── 0.md
+
+
+## Comment file
+### Meta information
+Tag           | Required  | Description
+--------------|-----------|----------------
+`date`        | yes       | Date when the comment was posted
+`replyto`     | no        | Identifier of the parent comment. Identifier = Filename (without extension)
+`locale_date` | forbidden | Will be overwritten with a locale representation of the date
+
+Every other (custom) tag gets parsed as well and will be available through the theme.
+
+##### Example of a comment file
+
+	date: 2014-3-21 15:02
+	author: Author of the comment
+	website: http://authors.website.com
+	replyto: 7
+	anothermetatag: some random tag
+
+	Content of the comment.
+
+## Theme
+In the `article.html` theme file are now two more variables available.
+
+Variables                         | Description
+----------------------------------|--------------------------
+`article.metadata.comments_count` | Amount of total comments for this article (including replies to comments)
+`article.metadata.comments`       | Array containing the top level comments for this article (no replies to comments)
+
+### Comment object
+Variables  | Description
+-----------|--------------------------
+`id`       | Identifier of this comment
+`content`  | Content of this comment
+`metadata` | All metadata as in the comment file (or described above)
+`replies`  | Array containing the top level replies for this comment
+`avatar`   | Path to the avatar or identicon of the comment author
+
+##### Example article.html theme
+(only the comment section)
+```html
+{% if article.metadata.comments %}
+	{% for comment in article.metadata.comments recursive %}
+		{% set metadata = comment.metadata %}
+		{% if loop.depth0 == 0 %}
+			{% set marginLeft = 0 %}
+		{% else %}
+			{% set marginLeft = 50 %}
+		{% endif %}
+			<article id="comment-{{comment.id}}" style="border: 1px solid #DDDDDD; padding: 5px 0px 0px 5px; margin: 0px -1px 5px {{marginLeft}}px;">
+				<a href="{{ SITEURL }}/{{ article.url }}#comment-{{comment.id}}" rel="bookmark" title="Permalink to this comment">Permalink</a>
+				<h4>{{ metadata['author'] }}</h4>
+				<p>Posted on <abbr class="published" title="{{ metadata['date'].isoformat() }}">{{ metadata['locale_date'] }}</abbr></p>
+
+				{{ comment.content }}
+				{% if comment.replies %}
+					{{ loop(comment.replies) }}
+				{% endif %}
+			</article>
+	{% endfor %}
+{% else %}
+	<p>There are no comments yet.<p>
+{% endif %}
+```
diff --git a/pelican_comment_system/identicon/LICENSE b/pelican_comment_system/identicon/LICENSE
new file mode 100755
index 0000000..e6e964f
--- /dev/null
+++ b/pelican_comment_system/identicon/LICENSE
@@ -0,0 +1,11 @@
+identicon.py is Licesensed under FreeBSD License.
+(http://www.freebsd.org/copyright/freebsd-license.html)
+
+Copyright 1994-2009 Shin Adachi. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/pelican_comment_system/identicon/README.md b/pelican_comment_system/identicon/README.md
new file mode 100755
index 0000000..1aa768c
--- /dev/null
+++ b/pelican_comment_system/identicon/README.md
@@ -0,0 +1,17 @@
+identicon.py: identicon python implementation.
+==============================================
+:Author:Shin Adachi <shn@glucose.jp>
+
+## usage
+
+### commandline
+
+    python identicon.py [code]
+
+### python
+
+    import identicon
+    identicon.render_identicon(code, size)
+
+Return a PIL Image class instance which have generated identicon image.
+`size` specifies patch size. Generated image size is 3 * `size`.
\ No newline at end of file
diff --git a/pelican_comment_system/identicon/__init__.py b/pelican_comment_system/identicon/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/pelican_comment_system/identicon/identicon.py b/pelican_comment_system/identicon/identicon.py
new file mode 100755
index 0000000..8318d87
--- /dev/null
+++ b/pelican_comment_system/identicon/identicon.py
@@ -0,0 +1,255 @@
+#!/usr/bin/env python
+# -*- coding:utf-8 -*-
+"""
+identicon.py
+identicon python implementation.
+by Shin Adachi <shn@glucose.jp>
+
+= usage =
+
+== commandline ==
+>>> python identicon.py [code]
+
+== python ==
+>>> import identicon
+>>> identicon.render_identicon(code, size)
+
+Return a PIL Image class instance which have generated identicon image.
+```size``` specifies `patch size`. Generated image size is 3 * ```size```.
+"""
+# g
+# PIL Modules
+from PIL import Image, ImageDraw, ImagePath, ImageColor
+
+
+__all__ = ['render_identicon', 'IdenticonRendererBase']
+
+
+class Matrix2D(list):
+    """Matrix for Patch rotation"""
+    def __init__(self, initial=[0.] * 9):
+        assert isinstance(initial, list) and len(initial) == 9
+        list.__init__(self, initial)
+
+    def clear(self):
+        for i in xrange(9):
+            self[i] = 0.
+
+    def set_identity(self):
+        self.clear()
+        for i in xrange(3):
+            self[i] = 1.
+
+    def __str__(self):
+        return '[%s]' % ', '.join('%3.2f' % v for v in self)
+
+    def __mul__(self, other):
+        r = []
+        if isinstance(other, Matrix2D):
+            for y in xrange(3):
+                for x in xrange(3):
+                    v = 0.0
+                    for i in xrange(3):
+                        v += (self[i * 3 + x] * other[y * 3 + i])
+                    r.append(v)
+        else:
+            raise NotImplementedError
+        return Matrix2D(r)
+
+    def for_PIL(self):
+        return self[0:6]
+
+    @classmethod
+    def translate(kls, x, y):
+        return kls([1.0, 0.0, float(x),
+                    0.0, 1.0, float(y),
+                    0.0, 0.0, 1.0])
+
+    @classmethod
+    def scale(kls, x, y):
+        return kls([float(x), 0.0, 0.0,
+                    0.0, float(y), 0.0,
+                    0.0, 0.0, 1.0])
+
+    """
+    # need `import math`
+    @classmethod
+    def rotate(kls, theta, pivot=None):
+        c = math.cos(theta)
+        s = math.sin(theta)
+
+        matR = kls([c, -s, 0., s, c, 0., 0., 0., 1.])
+        if not pivot:
+            return matR
+        return kls.translate(-pivot[0], -pivot[1]) * matR *
+            kls.translate(*pivot)
+    """
+    
+    @classmethod
+    def rotateSquare(kls, theta, pivot=None):
+        theta = theta % 4
+        c = [1., 0., -1., 0.][theta]
+        s = [0., 1., 0., -1.][theta]
+
+        matR = kls([c, -s, 0., s, c, 0., 0., 0., 1.])
+        if not pivot:
+            return matR
+        return kls.translate(-pivot[0], -pivot[1]) * matR * \
+            kls.translate(*pivot)
+
+
+class IdenticonRendererBase(object):
+    PATH_SET = []
+    
+    def __init__(self, code):
+        """
+        @param code code for icon
+        """
+        if not isinstance(code, int):
+            code = int(code)
+        self.code = code
+    
+    def render(self, size):
+        """
+        render identicon to PIL.Image
+        
+        @param size identicon patchsize. (image size is 3 * [size])
+        @return PIL.Image
+        """
+        
+        # decode the code
+        middle, corner, side, foreColor, backColor = self.decode(self.code)
+
+        # make image        
+        image = Image.new("RGB", (size * 3, size * 3))
+        draw = ImageDraw.Draw(image)
+        
+        # fill background
+        draw.rectangle((0, 0, image.size[0], image.size[1]), fill=0)
+        
+        kwds = {
+            'draw': draw,
+            'size': size,
+            'foreColor': foreColor,
+            'backColor': backColor}
+        # middle patch
+        self.drawPatch((1, 1), middle[2], middle[1], middle[0], **kwds)
+
+        # side patch
+        kwds['type'] = side[0]
+        for i in xrange(4):
+            pos = [(1, 0), (2, 1), (1, 2), (0, 1)][i]
+            self.drawPatch(pos, side[2] + 1 + i, side[1], **kwds)
+        
+        # corner patch
+        kwds['type'] = corner[0]
+        for i in xrange(4):
+            pos = [(0, 0), (2, 0), (2, 2), (0, 2)][i]
+            self.drawPatch(pos, corner[2] + 1 + i, corner[1], **kwds)
+        
+        return image
+                
+    def drawPatch(self, pos, turn, invert, type, draw, size, foreColor,
+            backColor):
+        """
+        @param size patch size
+        """
+        path = self.PATH_SET[type]
+        if not path:
+            # blank patch
+            invert = not invert
+            path = [(0., 0.), (1., 0.), (1., 1.), (0., 1.), (0., 0.)]
+        patch = ImagePath.Path(path)
+        if invert:
+            foreColor, backColor = backColor, foreColor
+        
+        mat = Matrix2D.rotateSquare(turn, pivot=(0.5, 0.5)) *\
+              Matrix2D.translate(*pos) *\
+              Matrix2D.scale(size, size)
+        
+        patch.transform(mat.for_PIL())
+        draw.rectangle((pos[0] * size, pos[1] * size, (pos[0] + 1) * size,
+            (pos[1] + 1) * size), fill=backColor)
+        draw.polygon(patch, fill=foreColor, outline=foreColor)
+
+    ### virtual functions
+    def decode(self, code):
+        raise NotImplementedError
+
+
+class DonRenderer(IdenticonRendererBase):
+    """
+    Don Park's implementation of identicon
+    see : http://www.docuverse.com/blog/donpark/2007/01/19/identicon-updated-and-source-released
+    """
+    
+    PATH_SET = [
+        [(0, 0), (4, 0), (4, 4), (0, 4)],   # 0
+        [(0, 0), (4, 0), (0, 4)],
+        [(2, 0), (4, 4), (0, 4)],
+        [(0, 0), (2, 0), (2, 4), (0, 4)],
+        [(2, 0), (4, 2), (2, 4), (0, 2)],   # 4
+        [(0, 0), (4, 2), (4, 4), (2, 4)],
+        [(2, 0), (4, 4), (2, 4), (3, 2), (1, 2), (2, 4), (0, 4)],
+        [(0, 0), (4, 2), (2, 4)],
+        [(1, 1), (3, 1), (3, 3), (1, 3)],   # 8   
+        [(2, 0), (4, 0), (0, 4), (0, 2), (2, 2)],
+        [(0, 0), (2, 0), (2, 2), (0, 2)],
+        [(0, 2), (4, 2), (2, 4)],
+        [(2, 2), (4, 4), (0, 4)],
+        [(2, 0), (2, 2), (0, 2)],
+        [(0, 0), (2, 0), (0, 2)],
+        []]                                 # 15
+    MIDDLE_PATCH_SET = [0, 4, 8, 15]
+    
+    # modify path set
+    for idx in xrange(len(PATH_SET)):
+        if PATH_SET[idx]:
+            p = map(lambda vec: (vec[0] / 4.0, vec[1] / 4.0), PATH_SET[idx])
+            PATH_SET[idx] = p + p[:1]
+    
+    def decode(self, code):
+        # decode the code        
+        middleType  = self.MIDDLE_PATCH_SET[code & 0x03]
+        middleInvert= (code >> 2) & 0x01
+        cornerType  = (code >> 3) & 0x0F
+        cornerInvert= (code >> 7) & 0x01
+        cornerTurn  = (code >> 8) & 0x03
+        sideType    = (code >> 10) & 0x0F
+        sideInvert  = (code >> 14) & 0x01
+        sideTurn    = (code >> 15) & 0x03
+        blue        = (code >> 16) & 0x1F
+        green       = (code >> 21) & 0x1F
+        red         = (code >> 27) & 0x1F
+        
+        foreColor = (red << 3, green << 3, blue << 3)
+        
+        return (middleType, middleInvert, 0),\
+               (cornerType, cornerInvert, cornerTurn),\
+               (sideType, sideInvert, sideTurn),\
+               foreColor, ImageColor.getrgb('white')
+
+
+def render_identicon(code, size, renderer=None):
+    if not renderer:
+        renderer = DonRenderer
+    return renderer(code).render(size)
+
+
+if __name__ == '__main__':
+    import sys
+    
+    if len(sys.argv) < 2:
+        print 'usage: python identicon.py [CODE]....'
+        raise SystemExit
+    
+    for code in sys.argv[1:]:
+        if code.startswith('0x') or code.startswith('0X'):
+            code = int(code[2:], 16)
+        elif code.startswith('0'):
+            code = int(code[1:], 8)
+        else:
+            code = int(code)
+        
+        icon = render_identicon(code, 24)
+        icon.save('%08x.png' % code, 'PNG')
diff --git a/pelican_comment_system/pelican_comment_system.py b/pelican_comment_system/pelican_comment_system.py
index cee8ff5..10b86f6 100644
--- a/pelican_comment_system/pelican_comment_system.py
+++ b/pelican_comment_system/pelican_comment_system.py
@@ -18,12 +18,15 @@ from pelican import signals
 from pelican.utils import strftime
 from pelican.readers import MarkdownReader
 
+import avatars
+
 class Comment:
-	def __init__(self, id, metadata, content):
+	def __init__(self, id, metadata, content, avatar):
 		self.id = id
 		self.content = content
 		self.metadata = metadata
 		self.replies = []
+		self.avatar = avatar
 
 	def addReply(self, comment):
 		self.replies.append(comment)
@@ -53,15 +56,32 @@ class Comment:
 		return amount + len(self.replies)
 
 
-def initialized(pelican):
+def pelican_initialized(pelican):
 	from pelican.settings import DEFAULT_CONFIG
 	DEFAULT_CONFIG.setdefault('PELICAN_COMMENT_SYSTEM', False)
 	DEFAULT_CONFIG.setdefault('PELICAN_COMMENT_SYSTEM_DIR' 'comments')
+	DEFAULT_CONFIG.setdefault('PELICAN_COMMENT_SYSTEM_IDENTICON_OUTPUT_PATH' 'images/identicon')
+	DEFAULT_CONFIG.setdefault('PELICAN_COMMENT_SYSTEM_IDENTICON_DATA', ())
+	DEFAULT_CONFIG.setdefault('PELICAN_COMMENT_SYSTEM_IDENTICON_SIZE', 72)
+	DEFAULT_CONFIG.setdefault('PELICAN_COMMENT_SYSTEM_AUTHORS', {})
 	if pelican:
 		pelican.settings.setdefault('PELICAN_COMMENT_SYSTEM', False)
 		pelican.settings.setdefault('PELICAN_COMMENT_SYSTEM_DIR', 'comments')
+		pelican.settings.setdefault('PELICAN_COMMENT_SYSTEM_IDENTICON_OUTPUT_PATH', 'images/identicon')
+		pelican.settings.setdefault('PELICAN_COMMENT_SYSTEM_IDENTICON_DATA', ())
+		pelican.settings.setdefault('PELICAN_COMMENT_SYSTEM_IDENTICON_SIZE', 72)
+		pelican.settings.setdefault('PELICAN_COMMENT_SYSTEM_AUTHORS', {})
 
 
+def initialize(article_generator):
+	avatars.init(
+		article_generator.settings['OUTPUT_PATH'],
+		article_generator.settings['PELICAN_COMMENT_SYSTEM_IDENTICON_OUTPUT_PATH'],
+		article_generator.settings['PELICAN_COMMENT_SYSTEM_IDENTICON_DATA'],
+		article_generator.settings['PELICAN_COMMENT_SYSTEM_IDENTICON_SIZE']/3,
+		article_generator.settings['PELICAN_COMMENT_SYSTEM_AUTHORS'],
+		)
+
 def add_static_comments(gen, metadata):
 	if gen.settings['PELICAN_COMMENT_SYSTEM'] != True:
 		return
@@ -73,21 +93,25 @@ def add_static_comments(gen, metadata):
 		logger.warning("pelican_comment_system: cant't locate comments files without slug tag in the article")
 		return
 
-	reader = MarkdownReader(gen.settings)
-	comments = []
-	replies = []
 	folder = os.path.join(gen.settings['PELICAN_COMMENT_SYSTEM_DIR'], metadata['slug'])
 
 	if not os.path.isdir(folder):
 		logger.debug("No comments found for: " + metadata['slug'])
 		return
 
+	reader = MarkdownReader(gen.settings)
+	comments = []
+	replies = []
+
 	for file in os.listdir(folder):
 		name, extension = os.path.splitext(file)
 		if extension[1:].lower() in reader.file_extensions:
-			content, meta = reader.read(folder + "/" + file)
+			content, meta = reader.read(os.path.join(folder, file))
 			meta['locale_date'] = strftime(meta['date'], gen.settings['DEFAULT_DATE_FORMAT'])
-			com = Comment(name, meta, content)
+
+			avatar_path = avatars.getAvatarPath(name, meta)
+			com = Comment(name, meta, content, avatar_path)
+
 			if 'replyto' in meta:
 				replies.append( com )
 			else:
@@ -109,6 +133,11 @@ def add_static_comments(gen, metadata):
 	metadata['comments_count'] = len(comments) + count
 	metadata['comments'] = comments
 
+def writeIdenticonsToDisk(gen, writer):
+	avatars.generateAndSaveMissingAvatars()
+
 def register():
-	signals.initialized.connect(initialized)
+	signals.initialized.connect(pelican_initialized)
+	signals.article_generator_init.connect(initialize)
 	signals.article_generator_context.connect(add_static_comments)
+	signals.article_writer_finalized.connect(writeIdenticonsToDisk)

From 24fce038c398b219092ba115b29360b88d901fcf Mon Sep 17 00:00:00 2001
From: Bernhard Scheirle <bernhard-scheirle@gmx.de>
Date: Mon, 14 Apr 2014 11:55:29 +0200
Subject: [PATCH 23/26] [pelican_comment_system] Added comment feeds

---
 pelican_comment_system/Readme.md              |  2 +
 pelican_comment_system/comment.py             | 45 +++++++++++
 pelican_comment_system/doc/avatars.md         |  2 +-
 pelican_comment_system/doc/feed.md            | 28 +++++++
 pelican_comment_system/doc/installation.md    | 52 ++++++------
 .../pelican_comment_system.py                 | 81 +++++++------------
 6 files changed, 132 insertions(+), 78 deletions(-)
 create mode 100644 pelican_comment_system/comment.py
 create mode 100644 pelican_comment_system/doc/feed.md

diff --git a/pelican_comment_system/Readme.md b/pelican_comment_system/Readme.md
index e95d86a..3b4dfd4 100644
--- a/pelican_comment_system/Readme.md
+++ b/pelican_comment_system/Readme.md
@@ -6,6 +6,7 @@ The comments are stored in Markdown files. Each comment in it own file.
  - Static comments for each article
  - Replies to comments
  - Avatars and [Identicons](https://en.wikipedia.org/wiki/Identicon)
+ - Comment Atom Feed for each article
  - Easy styleable via the themes
 
 
@@ -18,6 +19,7 @@ Bernhard Scheirle  | <http://blog.scheirle.de> | <https://github.com/Scheirle>
 ## Instructions
  - [Installation and basic usage](doc/installation.md)
  - [Avatars and Identicons](doc/avatars.md)
+ - [Comment Atom Feed](doc/feed.md)
  - [Comment Form (aka: never gather Metadata)](doc/form.md)
  
 ## Requirements
diff --git a/pelican_comment_system/comment.py b/pelican_comment_system/comment.py
new file mode 100644
index 0000000..84f03e6
--- /dev/null
+++ b/pelican_comment_system/comment.py
@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+"""
+
+"""
+
+from pelican import contents
+from pelican.contents import Content
+
+class Comment(Content):
+	mandatory_properties = ('author', 'date')
+	default_template = 'None'
+
+	def __init__(self, id, avatar, content, metadata, settings, source_path, context):
+		super(Comment,self).__init__( content, metadata, settings, source_path, context )
+		self.id = id
+		self.replies = []
+		self.avatar = avatar
+		self.title = "Posted by:  " + str(metadata['author'])
+
+	def addReply(self, comment):
+		self.replies.append(comment)
+
+	def getReply(self, id):
+		for reply in self.replies:
+			if reply.id == id:
+				return reply
+			else:
+				deepReply = reply.getReply(id)
+				if deepReply != None:
+					return deepReply
+		return None
+
+	def __lt__(self, other):
+		return self.metadata['date'] < other.metadata['date']
+
+	def sortReplies(self):
+		for r in self.replies:
+			r.sortReplies()
+		self.replies = sorted(self.replies)
+
+	def countReplies(self):
+		amount = 0
+		for r in self.replies:
+			amount += r.countReplies()
+		return amount + len(self.replies)
diff --git a/pelican_comment_system/doc/avatars.md b/pelican_comment_system/doc/avatars.md
index 8d05e70..f0567c7 100644
--- a/pelican_comment_system/doc/avatars.md
+++ b/pelican_comment_system/doc/avatars.md
@@ -23,7 +23,7 @@ PELICAN_COMMENT_SYSTEM_AUTHORS = {
 ```
 
 ## Theme
-To display the avatars and identicons simply add the following in the "comment for loop" in you theme:
+To display the avatars and identicons simply add the following in the "comment for loop" in your theme:
 
 ```html
 <img src="{{ SITEURL }}/{{ comment.avatar }}"
diff --git a/pelican_comment_system/doc/feed.md b/pelican_comment_system/doc/feed.md
new file mode 100644
index 0000000..949bd25
--- /dev/null
+++ b/pelican_comment_system/doc/feed.md
@@ -0,0 +1,28 @@
+# Comment Atom Feed
+## Custom comment url
+Be sure that the id of the html tag containing the comment matches `COMMENT_URL`.
+
+##### pelicanconf.py
+```python
+COMMENT_URL = "#my_own_comment_id_{path}"
+```
+
+##### Theme
+```html
+{% for comment in article.comments recursive %}
+	...
+	<article id="my_own_comment_id_{{comment.id}}">{{ comment.content }}</article>
+	...
+{% endfor %}
+```
+## Theme
+#### Link
+To display a link to the article feed simply add the following to your theme:
+
+```html
+{% if article %}
+	<a href="{{ FEED_DOMAIN }}/{{ PELICAN_COMMENT_SYSTEM_FEED|format(article.slug) }}">Comment Atom Feed</a>
+{% endif %}
+```
+
+
diff --git a/pelican_comment_system/doc/installation.md b/pelican_comment_system/doc/installation.md
index 7fda760..97e6c65 100644
--- a/pelican_comment_system/doc/installation.md
+++ b/pelican_comment_system/doc/installation.md
@@ -8,15 +8,16 @@ Activate the plugin by adding it to your `pelicanconf.py`
 And modify your `article.html` theme (see below).
 
 ## Settings
-Name                                           | Type      | Default            | Description
------------------------------------------------|-----------|--------------------|-------
-`PELICAN_COMMENT_SYSTEM`                       | `boolean` | `False`            | Activates or deactivates the comment system
-`PELICAN_COMMENT_SYSTEM_DIR`                   | `string`  | `comments`         | Folder where the comments are stored
-`PELICAN_COMMENT_SYSTEM_IDENTICON_OUTPUT_PATH` | `string`  | `images/identicon` | Output folder where the identicons are stored
-`PELICAN_COMMENT_SYSTEM_IDENTICON_DATA`        | `tuple`   | `()`               | Contains all Metadata tags, which in combination identifies a comment author (like `('author', 'email')`)
-`PELICAN_COMMENT_SYSTEM_IDENTICON_SIZE`        | `int`     | `72`               | Width and height of the identicons. Has to be a multiple of 3.
-`PELICAN_COMMENT_SYSTEM_AUTHORS`               | `dict`    | `{}`               | Comment authors, which should have a specific avatar. More infos [here](avatars.md)
-
+Name                                           | Type      | Default                    | Description
+-----------------------------------------------|-----------|----------------------------|-------
+`PELICAN_COMMENT_SYSTEM`                       | `boolean` | `False`                    | Activates or deactivates the comment system
+`PELICAN_COMMENT_SYSTEM_DIR`                   | `string`  | `comments`                 | Folder where the comments are stored
+`PELICAN_COMMENT_SYSTEM_IDENTICON_OUTPUT_PATH` | `string`  | `images/identicon`         | Relative URL to the output folder where the identicons are stored
+`PELICAN_COMMENT_SYSTEM_IDENTICON_DATA`        | `tuple`   | `()`                       | Contains all Metadata tags, which in combination identifies a comment author (like `('author', 'email')`)
+`PELICAN_COMMENT_SYSTEM_IDENTICON_SIZE`        | `int`     | `72`                       | Width and height of the identicons. Has to be a multiple of 3.
+`PELICAN_COMMENT_SYSTEM_AUTHORS`               | `dict`    | `{}`                       | Comment authors, which should have a specific avatar. More info [here](avatars.md)
+`PELICAN_COMMENT_SYSTEM_FEED`                  | `string`  |`feeds/comment.%s.atom.xml` | Relative URL to output the Atom feed for each article.`%s` gets replaced with the slug of the article. More info [here](http://docs.getpelican.com/en/latest/settings.html#feed-settings)
+`COMMENT_URL`                                  | `string`  | `#comment-{path}`          | `{path}` gets replaced with the id of the comment. More info [here](feed.md)
 
 ## Folder structure
 Every comment file has to be stored in a sub folder of `PELICAN_COMMENT_SYSTEM_DIR`.
@@ -24,7 +25,7 @@ Sub folders are named after the `slug` of the articles.
 
 So the comments to your `foo-bar` article are stored in `comments/foo-bar/`
 
-The filenames of the comment files are up to you. But the filename is the Identifier of the comment (without extension).
+The filenames of the comment files are up to you. But the filename is the Identifier of the comment (**with** extension).
 
 ##### Example folder structure
 
@@ -44,8 +45,8 @@ The filenames of the comment files are up to you. But the filename is the Identi
 Tag           | Required  | Description
 --------------|-----------|----------------
 `date`        | yes       | Date when the comment was posted
-`replyto`     | no        | Identifier of the parent comment. Identifier = Filename (without extension)
-`locale_date` | forbidden | Will be overwritten with a locale representation of the date
+`author`      | yes       | Name of the comment author
+`replyto`     | no        | Identifier of the parent comment. Identifier = Filename (**with** extension)
 
 Every other (custom) tag gets parsed as well and will be available through the theme.
 
@@ -62,26 +63,27 @@ Every other (custom) tag gets parsed as well and will be available through the t
 ## Theme
 In the `article.html` theme file are now two more variables available.
 
-Variables                         | Description
-----------------------------------|--------------------------
-`article.metadata.comments_count` | Amount of total comments for this article (including replies to comments)
-`article.metadata.comments`       | Array containing the top level comments for this article (no replies to comments)
+Variables                | Description
+-------------------------|--------------------------
+`article.comments_count` | Amount of total comments for this article (including replies to comments)
+`article.comments`       | Array containing the top level comments for this article (no replies to comments)
 
 ### Comment object
-Variables  | Description
+The comment object is a [content](https://github.com/getpelican/pelican/blob/master/pelican/contents.py#L34) object, so all common attributes are available (like author, content, date, local_date, metadata, ...).
+
+Additional following attributes are added:
+
+Attribute  | Description
 -----------|--------------------------
 `id`       | Identifier of this comment
-`content`  | Content of this comment
-`metadata` | All metadata as in the comment file (or described above)
 `replies`  | Array containing the top level replies for this comment
 `avatar`   | Path to the avatar or identicon of the comment author
 
 ##### Example article.html theme
 (only the comment section)
 ```html
-{% if article.metadata.comments %}
-	{% for comment in article.metadata.comments recursive %}
-		{% set metadata = comment.metadata %}
+{% if article.comments %}
+	{% for comment in article.comments recursive %}
 		{% if loop.depth0 == 0 %}
 			{% set marginLeft = 0 %}
 		{% else %}
@@ -89,9 +91,9 @@ Variables  | Description
 		{% endif %}
 			<article id="comment-{{comment.id}}" style="border: 1px solid #DDDDDD; padding: 5px 0px 0px 5px; margin: 0px -1px 5px {{marginLeft}}px;">
 				<a href="{{ SITEURL }}/{{ article.url }}#comment-{{comment.id}}" rel="bookmark" title="Permalink to this comment">Permalink</a>
-				<h4>{{ metadata['author'] }}</h4>
-				<p>Posted on <abbr class="published" title="{{ metadata['date'].isoformat() }}">{{ metadata['locale_date'] }}</abbr></p>
-
+				<h4>{{ comment.author }}</h4>
+				<p>Posted on <abbr class="published" title="{{ comment.date.isoformat() }}">{{ comment.locale_date }}</abbr></p>
+				{{ comment.metadata['my_custom_metadata'] }}
 				{{ comment.content }}
 				{% if comment.replies %}
 					{{ loop(comment.replies) }}
diff --git a/pelican_comment_system/pelican_comment_system.py b/pelican_comment_system/pelican_comment_system.py
index 10b86f6..f9cce59 100644
--- a/pelican_comment_system/pelican_comment_system.py
+++ b/pelican_comment_system/pelican_comment_system.py
@@ -10,51 +10,17 @@ Author: Bernhard Scheirle
 
 import logging
 import os
+import copy
 
 logger = logging.getLogger(__name__)
 
 from itertools import chain
 from pelican import signals
-from pelican.utils import strftime
 from pelican.readers import MarkdownReader
+from pelican.writers import Writer
 
 import avatars
-
-class Comment:
-	def __init__(self, id, metadata, content, avatar):
-		self.id = id
-		self.content = content
-		self.metadata = metadata
-		self.replies = []
-		self.avatar = avatar
-
-	def addReply(self, comment):
-		self.replies.append(comment)
-
-	def getReply(self, id):
-		for reply in self.replies:
-			if reply.id == id:
-				return reply
-			else:
-				deepReply = reply.getReply(id)
-				if deepReply != None:
-					return deepReply
-		return None
-
-	def __lt__(self, other):
-		return self.metadata['date'] < other.metadata['date']
-
-	def sortReplies(self):
-		for r in self.replies:
-			r.sortReplies()
-		self.replies = sorted(self.replies)
-
-	def countReplies(self):
-		amount = 0
-		for r in self.replies:
-			amount += r.countReplies()
-		return amount + len(self.replies)
-
+from comment import Comment
 
 def pelican_initialized(pelican):
 	from pelican.settings import DEFAULT_CONFIG
@@ -64,6 +30,8 @@ def pelican_initialized(pelican):
 	DEFAULT_CONFIG.setdefault('PELICAN_COMMENT_SYSTEM_IDENTICON_DATA', ())
 	DEFAULT_CONFIG.setdefault('PELICAN_COMMENT_SYSTEM_IDENTICON_SIZE', 72)
 	DEFAULT_CONFIG.setdefault('PELICAN_COMMENT_SYSTEM_AUTHORS', {})
+	DEFAULT_CONFIG.setdefault('PELICAN_COMMENT_SYSTEM_FEED', os.path.join('feeds', 'comment.%s.atom.xml'))
+	DEFAULT_CONFIG.setdefault('COMMENT_URL', '#comment-{path}')
 	if pelican:
 		pelican.settings.setdefault('PELICAN_COMMENT_SYSTEM', False)
 		pelican.settings.setdefault('PELICAN_COMMENT_SYSTEM_DIR', 'comments')
@@ -71,6 +39,8 @@ def pelican_initialized(pelican):
 		pelican.settings.setdefault('PELICAN_COMMENT_SYSTEM_IDENTICON_DATA', ())
 		pelican.settings.setdefault('PELICAN_COMMENT_SYSTEM_IDENTICON_SIZE', 72)
 		pelican.settings.setdefault('PELICAN_COMMENT_SYSTEM_AUTHORS', {})
+		pelican.settings.setdefault('PELICAN_COMMENT_SYSTEM_FEED', os.path.join('feeds', 'comment.%s.atom.xml'))
+		pelican.settings.setdefault('COMMENT_URL', '#comment-{path}')
 
 
 def initialize(article_generator):
@@ -82,21 +52,26 @@ def initialize(article_generator):
 		article_generator.settings['PELICAN_COMMENT_SYSTEM_AUTHORS'],
 		)
 
-def add_static_comments(gen, metadata):
+def add_static_comments(gen, content):
 	if gen.settings['PELICAN_COMMENT_SYSTEM'] != True:
 		return
 
-	metadata['comments_count'] = 0
-	metadata['comments'] = []
+	content.comments_count = 0
+	content.comments = []
 
-	if not 'slug' in metadata:
-		logger.warning("pelican_comment_system: cant't locate comments files without slug tag in the article")
-		return
+	#Modify the local context, so we get proper values for the feed
+	context = copy.copy(gen.context)
+	context['SITEURL'] += "/" + content.url
+	context['SITENAME'] = "Comments for: " + content.title
+	context['SITESUBTITLE'] = ""
+	path = gen.settings['PELICAN_COMMENT_SYSTEM_FEED'] % content.slug
+	writer = Writer(gen.output_path, settings=gen.settings)
 
-	folder = os.path.join(gen.settings['PELICAN_COMMENT_SYSTEM_DIR'], metadata['slug'])
+	folder = os.path.join(gen.settings['PELICAN_COMMENT_SYSTEM_DIR'], content.slug)
 
 	if not os.path.isdir(folder):
-		logger.debug("No comments found for: " + metadata['slug'])
+		logger.debug("No comments found for: " + content.slug)
+		writer.write_feed( [], context, path)
 		return
 
 	reader = MarkdownReader(gen.settings)
@@ -106,17 +81,19 @@ def add_static_comments(gen, metadata):
 	for file in os.listdir(folder):
 		name, extension = os.path.splitext(file)
 		if extension[1:].lower() in reader.file_extensions:
-			content, meta = reader.read(os.path.join(folder, file))
-			meta['locale_date'] = strftime(meta['date'], gen.settings['DEFAULT_DATE_FORMAT'])
-
+			com_content, meta = reader.read(os.path.join(folder, file))
+			
 			avatar_path = avatars.getAvatarPath(name, meta)
-			com = Comment(name, meta, content, avatar_path)
+
+			com = Comment(file, avatar_path, com_content, meta, gen.settings, file, context)
 
 			if 'replyto' in meta:
 				replies.append( com )
 			else:
 				comments.append( com )
 
+	writer.write_feed( comments + replies, context, path)
+
 	#TODO: Fix this O(n²) loop
 	for reply in replies:
 		for comment in chain(comments, replies):
@@ -130,8 +107,8 @@ def add_static_comments(gen, metadata):
 
 	comments = sorted(comments)
 
-	metadata['comments_count'] = len(comments) + count
-	metadata['comments'] = comments
+	content.comments_count = len(comments) + count
+	content.comments = comments
 
 def writeIdenticonsToDisk(gen, writer):
 	avatars.generateAndSaveMissingAvatars()
@@ -139,5 +116,5 @@ def writeIdenticonsToDisk(gen, writer):
 def register():
 	signals.initialized.connect(pelican_initialized)
 	signals.article_generator_init.connect(initialize)
-	signals.article_generator_context.connect(add_static_comments)
+	signals.article_generator_write_article.connect(add_static_comments)
 	signals.article_writer_finalized.connect(writeIdenticonsToDisk)

From 02a464591263e3e167fa40d1c080e22bddc23d4a Mon Sep 17 00:00:00 2001
From: Bernhard Scheirle <bernhard-scheirle@gmx.de>
Date: Mon, 14 Apr 2014 18:15:14 +0200
Subject: [PATCH 24/26] [pelican_comment_system] made python3 compatible

---
 pelican_comment_system/avatars.py               |  6 ++++--
 pelican_comment_system/comment.py               |  2 +-
 pelican_comment_system/identicon/identicon.py   | 17 +++++++++--------
 .../pelican_comment_system.py                   |  7 ++++---
 4 files changed, 18 insertions(+), 14 deletions(-)

diff --git a/pelican_comment_system/avatars.py b/pelican_comment_system/avatars.py
index 5094d1c..d357f19 100644
--- a/pelican_comment_system/avatars.py
+++ b/pelican_comment_system/avatars.py
@@ -3,6 +3,8 @@
 
 """
 
+from __future__ import unicode_literals
+
 import logging
 import os
 
@@ -12,7 +14,7 @@ import hashlib
 logger = logging.getLogger(__name__)
 _log = "pelican_comment_system: avatars: "
 try:
-	from identicon import identicon
+	from . identicon import identicon
 	_identiconImported = True
 except ImportError as e:
 	logger.warning(_log + "identicon deactivated: " + str(e))
@@ -66,7 +68,7 @@ def getAvatarPath(comment_id, metadata):
 	for data in _identicon_data:
 		if data in metadata:
 			string = str(metadata[data])
-			md5.update(string)
+			md5.update(string.encode('utf-8'))
 			author += tuple([string])
 		else:
 			logger.warning(_log + data + " is missing in comment: " + comment_id)
diff --git a/pelican_comment_system/comment.py b/pelican_comment_system/comment.py
index 84f03e6..cf5f4c8 100644
--- a/pelican_comment_system/comment.py
+++ b/pelican_comment_system/comment.py
@@ -2,7 +2,7 @@
 """
 
 """
-
+from __future__ import unicode_literals
 from pelican import contents
 from pelican.contents import Content
 
diff --git a/pelican_comment_system/identicon/identicon.py b/pelican_comment_system/identicon/identicon.py
index 8318d87..eb4abe5 100755
--- a/pelican_comment_system/identicon/identicon.py
+++ b/pelican_comment_system/identicon/identicon.py
@@ -46,10 +46,10 @@ class Matrix2D(list):
     def __mul__(self, other):
         r = []
         if isinstance(other, Matrix2D):
-            for y in xrange(3):
-                for x in xrange(3):
+            for y in range(3):
+                for x in range(3):
                     v = 0.0
-                    for i in xrange(3):
+                    for i in range(3):
                         v += (self[i * 3 + x] * other[y * 3 + i])
                     r.append(v)
         else:
@@ -119,7 +119,7 @@ class IdenticonRendererBase(object):
         
         # decode the code
         middle, corner, side, foreColor, backColor = self.decode(self.code)
-
+        size = int(size)
         # make image        
         image = Image.new("RGB", (size * 3, size * 3))
         draw = ImageDraw.Draw(image)
@@ -137,13 +137,13 @@ class IdenticonRendererBase(object):
 
         # side patch
         kwds['type'] = side[0]
-        for i in xrange(4):
+        for i in range(4):
             pos = [(1, 0), (2, 1), (1, 2), (0, 1)][i]
             self.drawPatch(pos, side[2] + 1 + i, side[1], **kwds)
         
         # corner patch
         kwds['type'] = corner[0]
-        for i in xrange(4):
+        for i in range(4):
             pos = [(0, 0), (2, 0), (2, 2), (0, 2)][i]
             self.drawPatch(pos, corner[2] + 1 + i, corner[1], **kwds)
         
@@ -203,9 +203,10 @@ class DonRenderer(IdenticonRendererBase):
     MIDDLE_PATCH_SET = [0, 4, 8, 15]
     
     # modify path set
-    for idx in xrange(len(PATH_SET)):
+    for idx in range(len(PATH_SET)):
         if PATH_SET[idx]:
             p = map(lambda vec: (vec[0] / 4.0, vec[1] / 4.0), PATH_SET[idx])
+            p = list(p)
             PATH_SET[idx] = p + p[:1]
     
     def decode(self, code):
@@ -240,7 +241,7 @@ if __name__ == '__main__':
     import sys
     
     if len(sys.argv) < 2:
-        print 'usage: python identicon.py [CODE]....'
+        print('usage: python identicon.py [CODE]....')
         raise SystemExit
     
     for code in sys.argv[1:]:
diff --git a/pelican_comment_system/pelican_comment_system.py b/pelican_comment_system/pelican_comment_system.py
index f9cce59..aecf8a0 100644
--- a/pelican_comment_system/pelican_comment_system.py
+++ b/pelican_comment_system/pelican_comment_system.py
@@ -7,7 +7,7 @@ A Pelican plugin, which allows you to add comments to your articles.
 
 Author: Bernhard Scheirle
 """
-
+from __future__ import unicode_literals
 import logging
 import os
 import copy
@@ -19,8 +19,9 @@ from pelican import signals
 from pelican.readers import MarkdownReader
 from pelican.writers import Writer
 
-import avatars
-from comment import Comment
+from . comment import Comment
+from . import avatars
+
 
 def pelican_initialized(pelican):
 	from pelican.settings import DEFAULT_CONFIG

From 046eaadd617610cee9a560eeff18a23a97daee87 Mon Sep 17 00:00:00 2001
From: Julien Enselme <julien.enselme@centrale-marseille.fr>
Date: Mon, 21 Apr 2014 23:57:04 +0200
Subject: [PATCH 25/26] Add the Creole Reader plugin

---
 creole_reader/Readme.md        | 31 +++++++++++++++++++
 creole_reader/__init__.py      |  1 +
 creole_reader/creole_reader.py | 56 ++++++++++++++++++++++++++++++++++
 3 files changed, 88 insertions(+)
 create mode 100644 creole_reader/Readme.md
 create mode 100644 creole_reader/__init__.py
 create mode 100644 creole_reader/creole_reader.py

diff --git a/creole_reader/Readme.md b/creole_reader/Readme.md
new file mode 100644
index 0000000..4db3eab
--- /dev/null
+++ b/creole_reader/Readme.md
@@ -0,0 +1,31 @@
+# Creole Reader
+
+This plugins allows you to write your posts using the wikicreole syntax. Give to
+these files the creole extension. The medata are between <<header>> <</header>>
+tags.
+
+## Syntax
+Use ** for strong, // for emphasis, one = for 1st level titles.
+
+For the complete syntax, look at: http://www.wikicreole.org/
+
+## Basic example
+```
+<<header>>
+title: Créole
+tags: creole, python, pelican_open
+date: 2013-12-12
+<</header>>
+
+= Title 1
+== Title 2
+
+Some nice texte with **strong** and //emphasis//.
+
+* A nice list
+** With subelements
+* Python
+
+# An ordered list
+# A second item
+```
diff --git a/creole_reader/__init__.py b/creole_reader/__init__.py
new file mode 100644
index 0000000..2e26d46
--- /dev/null
+++ b/creole_reader/__init__.py
@@ -0,0 +1 @@
+from .creole_reader import *
diff --git a/creole_reader/creole_reader.py b/creole_reader/creole_reader.py
new file mode 100644
index 0000000..49317c5
--- /dev/null
+++ b/creole_reader/creole_reader.py
@@ -0,0 +1,56 @@
+#-*- conding: utf-8 -*-
+
+'''
+Creole Reader
+-------------
+
+This plugins allows you to write your posts using the wikicreole syntax. Give to
+these files the creole extension.
+For the syntax, look at: http://www.wikicreole.org/
+'''
+
+from pelican import readers
+from pelican import signals
+from pelican import settings
+
+from pelican.utils import pelican_open
+
+try:
+    from creole import creole2html
+    creole = True
+except ImportError:
+    creole = False
+
+class CreoleReader(readers.BaseReader):
+    enabled = creole
+
+    file_extensions = ['creole']
+
+    def __init__(self, settings):
+        super(CreoleReader, self).__init__(settings)
+
+    def _parse_header_macro(self, text):
+        for line in text.split('\n'):
+            name, value = line.split(':')
+            name, value = name.strip(), value.strip()
+            if name == 'title':
+                self._metadata[name] = value
+            else:
+                self._metadata[name] = self.process_metadata(name, value)
+        return u''
+
+    # You need to have a read method, which takes a filename and returns
+    # some content and the associated metadata.
+    def read(self, source_path):
+        """Parse content and metadata of creole files"""
+
+        self._metadata = {}
+        with pelican_open(source_path) as text:
+            content = creole2html(text, macros={'header': self._parse_header_macro})
+        return content, self._metadata
+
+def add_reader(readers):
+    readers.reader_classes['creole'] = CreoleReader
+
+def register():
+    signals.readers_init.connect(add_reader)

From 9750c136659237d9d5b5a723658b1b9b4deca411 Mon Sep 17 00:00:00 2001
From: Jenselme <jenselme@jujens.eu>
Date: Tue, 22 Apr 2014 00:05:08 +0200
Subject: [PATCH 26/26] Add dependency information.

---
 creole_reader/Readme.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/creole_reader/Readme.md b/creole_reader/Readme.md
index 4db3eab..d478bf2 100644
--- a/creole_reader/Readme.md
+++ b/creole_reader/Readme.md
@@ -1,9 +1,13 @@
 # Creole Reader
 
 This plugins allows you to write your posts using the wikicreole syntax. Give to
-these files the creole extension. The medata are between <<header>> <</header>>
+these files the creole extension. The medata are between `<<header>> <</header>>`
 tags.
 
+## Dependency
+This plugin relies on [python-creole](https://pypi.python.org/pypi/python-creole/) to work. Install it with:
+`pip install python-creole`
+
 ## Syntax
 Use ** for strong, // for emphasis, one = for 1st level titles.