initial code

.gitignore

+*~
+*.pyc
+/catalog.yaml

generate.py

+import os
+import yaml
+from mako.lookup import TemplateLookup
+import pyrtek, pyrtek.rst, pyrtek.mako
+
+
+mako_filter = pyrtek.mako.Filter(TemplateLookup(['../templates']))
+rst_filter = pyrtek.rst.Filter()
+
+filters = {'mako': mako_filter,
+          'rst': rst_filter,
+          'default': pyrtek.chain_filters(rst_filter, mako_filter)}
+
+default_meta = {'__filter__': 'default',
+                '__template__': 'default.mako'}
+
+# rexp, repl, priority, func
+rules = [(r'(.*)\.txt$', r'\1.html', 0,
+          lambda s, d: pyrtek.Text(s, d, filters, default_meta))]
+
+
+def main():
+    # Load catalog, if it exists.
+    try:
+        with open('catalog.yaml') as f:
+            catalog = yaml.load(f)
+    except IOError:
+        catalog = {}
+
+    # The following block of code is executed inside the content directory.
+    saved_cwd = os.getcwd();
+    os.chdir('content')
+    try:
+        catalog = pyrtek.build(pyrtek.expand_rules(rules), catalog)
+    finally:
+        os.chdir(saved_cwd)
+
+    # Save catalog.
+    with open('catalog.yaml', 'w') as f:
+        yaml.dump(catalog, f)
+
+
+if __name__ == '__main__':
+    main()

pyrtek/__init__.py

+import os, os.path
+import re
+import abc
+import logging
+import yaml
+
+log = logging.getLogger(__name__)
+
+class Item(object):
+    __metaclass__ = abc.ABCMeta
+
+    @abc.abstractproperty
+    def name(self):
+        pass
+
+    def isuptodate(self, oldmeta, catalog):
+        return False
+
+    def render(self, catalog):
+        """Render the item, return re-generated metadata."""
+        pass
+
+
+class Text(Item):
+    def __init__(self, source, dest, filters, default_meta={}):
+        self.source = source
+        self.dest = dest
+        self.filters = filters
+        self.default_meta = default_meta
+
+    def __repr__(self):
+        return '<{0}({1}, {2}, ...)>'.format(
+            self.__class__.__name__, self.source, self.dest)
+
+    @property
+    def name(self):
+        return self.dest
+
+    def render(self, catalog):
+        meta = self.default_meta.copy()
+
+        # Initialize data and metadata from source file.
+        with open(self.source) as f:
+            data = f.read().decode('utf-8')
+        if data.startswith('---\n'):
+            meta_yaml, data = data.split('\n---\n', 1)
+            meta.update(yaml.safe_load(meta_yaml[4:]))
+
+        # Appply filter.
+        try:
+            filter_name = meta['__filter__']
+        except KeyError:
+            log.error('{0}: No __filter__ defined.'.format(self.source))
+        else:
+            try:
+                filter = self.filters[filter_name]
+            except KeyError:
+                log.error('{0}: No filter {0}.'.format(filter_name))
+            else:
+                data, meta = filter(data, meta, self.dest, catalog)
+
+        # Write filtered data to destination file.
+        with open(self.dest, 'w') as f:
+            f.write(data.encode('utf-8'))
+
+        return meta
+
+
+def build(items, old_catalog={}):
+    catalog = {}
+
+    for item in items:
+        name = item.name
+        meta = old_catalog.get(name)
+        if meta is None or not item.isuptodate(meta, catalog):
+            meta = item.render(catalog)
+        if name in catalog:
+            log.warning('{0} already present.'.format(name))
+        catalog[name] = meta
+
+    return catalog
+
+
+def chain_filters(*filters):
+    def chained(data, meta, name, catalog):
+        for filter in filters:
+            data, meta = filter(data, meta, name, catalog)
+        return data, meta
+
+    return chained
+
+
+def expand_rules(rules):
+    rules = [(rexp if hasattr(rexp, 'match') else re.compile(rexp),
+             repl, priority, func)
+             for rexp, repl, priority, func in rules]
+
+    priority_item_seq = []
+    for root, dirs, files in os.walk('.'):
+        for file in files:
+            # For security, do not follow symlinks.
+            source = os.path.join(root, file)
+            if os.path.islink(os.path.join(root, file)):
+                log.warn('Ignoring symlink: {0}'.format(source))
+                continue
+            for rexp, repl, priority, func in rules:
+                if not rexp.match(source):
+                    continue
+                dest = rexp.sub(repl, source)
+                priority_item_seq.append((priority, func(source, dest)))
+
+    priority_item_seq.sort(key=lambda p_i: p_i[0])
+    return [i for p, i in priority_item_seq]

pyrtek/mako.py

+import logging
+
+log = logging.getLogger(__name__)
+
+class Filter(object):
+    def __init__(self, lookup):
+        self.lookup = lookup
+
+    def __call__(self, data, meta, name, catalog):
+        try:
+            template_name = meta['__template__']
+        except KeyError:
+            log.error('{0}: No __template__ defined.'.format(name))
+            return None, meta
+
+        # TODO: surround with try-block
+        template = self.lookup.get_template(template_name)
+        data = template.render(body=data, name=name, meta=meta, catalog=catalog)
+
+        return data, meta

pyrtek/rst.py

+import logging
+import docutils.core, docutils.nodes, docutils.io, docutils as du
+
+log = logging.getLogger(__name__)
+
+class Filter(object):
+    def __call__(self, data, meta, name, catalog):
+        doctree = du.core.publish_doctree(data)
+        parts = du.core.publish_parts(doctree, reader_name='doctree',
+                                      source_class=du.io.DocTreeInput,
+                                      writer_name='html')
+        data = parts['html_body']
+        meta.setdefault('title', parts['title'])
+        meta.setdefault('subtitle', parts['subtitle'])
+        return data, meta

serve.py

+# Taken from
+# http://www.linuxjournal.com/content/tech-tip-really-simple-http-server-python
+
+import os
+import BaseHTTPServer
+from SimpleHTTPServer import SimpleHTTPRequestHandler
+
+
+HandlerClass = SimpleHTTPRequestHandler
+ServerClass  = BaseHTTPServer.HTTPServer
+Protocol     = "HTTP/1.0"
+
+server_address = ('127.0.0.1', 8000)
+
+HandlerClass.protocol_version = Protocol
+httpd = ServerClass(server_address, HandlerClass)
+
+sa = httpd.socket.getsockname()
+print "Serving HTTP on", sa[0], "port", sa[1], "..."
+os.chdir('content')
+httpd.serve_forever()