]> git.llucax.com Git - software/blitiri.git/blobdiff - blitiri.cgi
Show comments when displaying a single article
[software/blitiri.git] / blitiri.cgi
index 829a8cd8f34dd8fb869b6f6617ba19112534a4be..583a497687a62f3f9f46b9e0b16b8b152ef1e557 100755 (executable)
@@ -14,6 +14,9 @@
 # Directory where entries are stored
 data_path = "/tmp/blog/data"
 
 # Directory where entries are stored
 data_path = "/tmp/blog/data"
 
+# Directory where comments are stored (must be writeable by the web server)
+comments_path = "/tmp/blog/comments"
+
 # Path where templates are stored. Use an empty string for the built-in
 # default templates. If they're not found, the built-in ones will be used.
 templates_path = "/tmp/blog/templates"
 # Path where templates are stored. Use an empty string for the built-in
 # default templates. If they're not found, the built-in ones will be used.
 templates_path = "/tmp/blog/templates"
@@ -66,15 +69,16 @@ templates_path = os.path.realpath(templates_path)
 
 # Default template
 
 
 # Default template
 
-default_main_header = """
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+default_main_header = """\
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+          "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 
 
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 <link rel="alternate" title="%(title)s" href="%(fullurl)s/atom"
        type="application/atom+xml" />
 <head>
 <link rel="alternate" title="%(title)s" href="%(fullurl)s/atom"
        type="application/atom+xml" />
-<link href="%(css_url)s" rel="stylesheet"
-       type="text/css" />
+<link href="%(css_url)s" rel="stylesheet" type="text/css" />
 <title>%(title)s</title>
 </head>
 
 <title>%(title)s</title>
 </head>
 
@@ -86,8 +90,7 @@ default_main_header = """
 """
 
 default_main_footer = """
 """
 
 default_main_footer = """
-</div><p/>
-<hr/><br/>
+</div>
 <div class="footer">
   %(showyear)s: %(monthlinks)s<br/>
   years: %(yearlinks)s<br/>
 <div class="footer">
   %(showyear)s: %(monthlinks)s<br/>
   years: %(yearlinks)s<br/>
@@ -114,7 +117,9 @@ default_article_header = """
 <a class="date" href="%(url)s/%(uyear)d/%(umonth)d/">%(umonth)02d</a>-\
 <a class="date" href="%(url)s/%(uyear)d/%(umonth)d/%(uday)d/">%(uday)02d</a>\
     %(uhour)02d:%(uminute)02d)</span><br/>
 <a class="date" href="%(url)s/%(uyear)d/%(umonth)d/">%(umonth)02d</a>-\
 <a class="date" href="%(url)s/%(uyear)d/%(umonth)d/%(uday)d/">%(uday)02d</a>\
     %(uhour)02d:%(uminute)02d)</span><br/>
-  <span class="tags">tagged %(tags)s</span>
+  <span class="tags">tagged %(tags)s</span> -
+  <span class="comments">with %(comments)s
+    <a href="%(url)s/post/%(uuid)s#comments">comment(s)</a></span>
 </span><br/>
 <p/>
 <div class="artbody">
 </span><br/>
 <p/>
 <div class="artbody">
@@ -126,6 +131,23 @@ default_article_footer = """
 </div>
 """
 
 </div>
 """
 
+default_comment_header = """
+<div class="comment">
+<a name="comment-%(number)d" />
+<h3><a href="#comment-%(number)d">Comment #%(number)d</a></h3>
+<span class="cominfo">by <a href="%(link)s">%(author)s</a>
+  on %(year)04d-%(month)02d-%(day)02d %(hour)02d:%(minute)02d</span>
+<p/>
+<div class="combody">
+"""
+
+default_comment_footer = """
+<p/>
+</div>
+</div>
+"""
+
+
 # Default CSS
 default_css = """
 body {
 # Default CSS
 default_css = """
 body {
@@ -152,7 +174,14 @@ h2 {
        border-bottom: 1px solid #99C;
 }
 
        border-bottom: 1px solid #99C;
 }
 
-h1 a, h2 a {
+h3 {
+       font-size: small;
+       font-weigth: none;
+       margin-bottom: 1pt;
+       border-bottom: 1px solid #99C;
+}
+
+h1 a, h2 a, h3 a {
        text-decoration: none;
        color: black;
 }
        text-decoration: none;
        color: black;
 }
@@ -179,15 +208,42 @@ div.article {
        margin-bottom: 2em;
 }
 
        margin-bottom: 2em;
 }
 
+span.cominfo {
+       font-size: xx-small;
+}
+
+span.cominfo a {
+       text-decoration: none;
+       color: #339;
+}
+
+span.cominfo a:hover {
+       text-decoration: none;
+       color: blue;
+}
+
+div.combody {
+       margin-left: 2em;
+}
+
+div.comment {
+       margin-left: 1em;
+       margin-bottom: 1em;
+}
+
 hr {
        float: left;
        height: 2px;
        border: 0;
        background-color: #99F;
 hr {
        float: left;
        height: 2px;
        border: 0;
        background-color: #99F;
-       width: 100%;
+       width: 60%;
 }
 
 div.footer {
 }
 
 div.footer {
+       margin-top: 1em;
+       padding-top: 0.4em;
+       width: 100%;
+       border-top: 2px solid #99F;
        font-size: x-small;
 }
 
        font-size: x-small;
 }
 
@@ -206,6 +262,22 @@ div.section h1 {
 
 """
 
 
 """
 
+# helper functions
+def rst_to_html(rst):
+       settings = {
+               'input_encoding': encoding,
+               'output_encoding': 'utf8',
+       }
+       parts = publish_parts(rst, settings_overrides = settings,
+                               writer_name = "html")
+       return parts['body'].encode('utf8')
+
+def sanitize(obj):
+       if isinstance(obj, basestring):
+               return cgi.escape(obj, True)
+       return obj
+
+
 # find out our URL, needed for syndication
 try:
        n = os.environ['SERVER_NAME']
 # find out our URL, needed for syndication
 try:
        n = os.environ['SERVER_NAME']
@@ -239,86 +311,167 @@ class Templates (object):
                        'yearlinks': ' '.join(db.get_year_links()),
                }
 
                        'yearlinks': ' '.join(db.get_year_links()),
                }
 
-       def get_main_header(self):
-               p = self.tpath + '/header.html'
+       def get_template(self, page_name, default_template, extra_vars = None):
+               if extra_vars is None:
+                       vars = self.vars
+               else:
+                       vars = self.vars.copy()
+                       vars.update(extra_vars)
+
+               p = '%s/%s.html' % (self.tpath, page_name)
                if os.path.isfile(p):
                if os.path.isfile(p):
-                       return open(p).read() % self.vars
-               return default_main_header % self.vars
+                       return open(p).read() % vars
+               return default_template % vars
+
+       def get_main_header(self):
+               return self.get_template('header', default_main_header)
 
        def get_main_footer(self):
 
        def get_main_footer(self):
-               p = self.tpath + '/footer.html'
-               if os.path.isfile(p):
-                       return open(p).read() % self.vars
-               return default_main_footer % self.vars
+               return self.get_template('footer', default_main_footer)
 
        def get_article_header(self, article):
 
        def get_article_header(self, article):
-               avars = self.vars.copy()
-               avars.update( {
-                       'arttitle': article.title,
-                       'author': article.author,
-                       'date': article.created.isoformat(' '),
-                       'uuid': article.uuid,
-                       'created': article.created.isoformat(' '),
-                       'updated': article.updated.isoformat(' '),
-                       'tags': article.get_tags_links(),
-
-                       'cyear': article.created.year,
-                       'cmonth': article.created.month,
-                       'cday': article.created.day,
-                       'chour': article.created.hour,
-                       'cminute': article.created.minute,
-                       'csecond': article.created.second,
-
-                       'uyear': article.updated.year,
-                       'umonth': article.updated.month,
-                       'uday': article.updated.day,
-                       'uhour': article.updated.hour,
-                       'uminute': article.updated.minute,
-                       'usecond': article.updated.second,
-               } )
-
-               p = self.tpath + '/art_header.html'
-               if os.path.isfile(p):
-                       return open(p).read() % avars
-               return default_article_header % avars
+               return self.get_template(
+                       'art_header', default_article_header, article.to_vars())
 
        def get_article_footer(self, article):
 
        def get_article_footer(self, article):
-               avars = self.vars.copy()
-               avars.update( {
-                       'arttitle': article.title,
-                       'author': article.author,
-                       'date': article.created.isoformat(' '),
-                       'uuid': article.uuid,
-                       'created': article.created.isoformat(' '),
-                       'updated': article.updated.isoformat(' '),
-                       'tags': article.get_tags_links(),
-
-                       'cyear': article.created.year,
-                       'cmonth': article.created.month,
-                       'cday': article.created.day,
-                       'chour': article.created.hour,
-                       'cminute': article.created.minute,
-                       'csecond': article.created.second,
-
-                       'uyear': article.updated.year,
-                       'umonth': article.updated.month,
-                       'uday': article.updated.day,
-                       'uhour': article.updated.hour,
-                       'uminute': article.updated.minute,
-                       'usecond': article.updated.second,
-               } )
+               return self.get_template(
+                       'art_footer', default_article_footer, article.to_vars())
 
 
-               p = self.tpath + '/art_footer.html'
-               if os.path.isfile(p):
-                       return open(p).read() % avars
-               return default_article_footer % avars
+       def get_comment_header(self, comment):
+               return self.get_template(
+                       'com_header', default_comment_header, comment.to_vars())
+
+       def get_comment_footer(self, comment):
+               return self.get_template(
+                       'com_footer', default_comment_footer, comment.to_vars())
+
+
+class Comment (object):
+       def __init__(self, article, number, created = None):
+               self.article = article
+               self.number = number
+               if created is None:
+                       self.created = datetime.datetime.now()
+               else:
+                       self.created = created
+
+               self.loaded = False
+
+               # loaded on demand
+               self._author = author
+               self._link = ''
+               self._raw_content = 'Removed comment'
+
+
+       def get_author(self):
+               if not self.loaded:
+                       self.load()
+               return self._author
+       author = property(fget = get_author)
+
+       def get_link(self):
+               if not self.loaded:
+                       self.load()
+               return self._link
+       link = property(fget = get_link)
+
+       def get_raw_content(self):
+               if not self.loaded:
+                       self.load()
+               return self._raw_content
+       raw_content = property(fget = get_raw_content)
+
+
+       def load(self):
+               filename = os.path.join(comments_path, self.article.uuid,
+                                       str(self.number))
+               try:
+                       raw = open(filename).readlines()
+               except:
+                       return
+
+               count = 0
+               for l in raw:
+                       if ':' in l:
+                               name, value = l.split(':', 1)
+                               if name.lower() == 'author':
+                                       self._author = value.strip()
+                               elif name.lower() == 'link':
+                                       self._link = value.strip()
+                       elif l == '\n':
+                               # end of header
+                               break
+                       count += 1
+               self._raw_content = ''.join(raw[count + 1:])
+               self.loaded = True
+
+       def to_html(self):
+               return rst_to_html(self.raw_content)
+
+       def to_vars(self):
+               return {
+                       'number': self.number,
+                       'author': sanitize(self.author),
+                       'link': sanitize(self.link),
+                       'date': self.created.isoformat(' '),
+                       'created': self.created.isoformat(' '),
+
+                       'year': self.created.year,
+                       'month': self.created.month,
+                       'day': self.created.day,
+                       'hour': self.created.hour,
+                       'minute': self.created.minute,
+                       'second': self.created.second,
+               }
+
+class CommentDB (object):
+       def __init__(self, article):
+               self.path = os.path.join(comments_path, article.uuid)
+               self.comments = []
+               self.load(article)
+
+       def load(self, article):
+               try:
+                       f = open(os.path.join(self.path, 'db'))
+               except:
+                       return
+
+               for l in f:
+                       # Each line has the following comma separated format:
+                       # number, created (epoch)
+                       # Empty lines are meaningful and represent removed
+                       # comments (so we can preserve the comment number)
+                       l = l.split(',')
+                       try:
+                               n = int(l[0])
+                               d = datetime.datetime.fromtimestamp(float(l[1]))
+                       except:
+                               # Removed/invalid comment
+                               self.comments.append(None)
+                               continue
+                       self.comments.append(Comment(article, n, d))
+
+       def save(self):
+               old_db = os.path.join(self.path, 'db')
+               new_db = os.path.join(self.path, 'db.tmp')
+               f = open(new_db, 'w')
+               for c in self.comments:
+                       s = ''
+                       if c is not None:
+                               s = ''
+                               s += str(c.number) + ', '
+                               s += str(time.mktime(c.created.timetuple()))
+                       s += '\n'
+                       f.write(s)
+               f.close()
+               os.rename(new_db, old_db)
 
 
 class Article (object):
 
 
 class Article (object):
-       def __init__(self, path):
+       def __init__(self, path, created = None, updated = None):
                self.path = path
                self.path = path
-               self.created = None
-               self.updated = None
+               self.created = created
+               self.updated = updated
                self.uuid = "%08x" % zlib.crc32(self.path)
 
                self.loaded = False
                self.uuid = "%08x" % zlib.crc32(self.path)
 
                self.loaded = False
@@ -328,6 +481,7 @@ class Article (object):
                self._author = author
                self._tags = []
                self._raw_content = ''
                self._author = author
                self._tags = []
                self._raw_content = ''
+               self._comments = []
 
 
        def get_title(self):
 
 
        def get_title(self):
@@ -354,6 +508,12 @@ class Article (object):
                return self._raw_content
        raw_content = property(fget = get_raw_content)
 
                return self._raw_content
        raw_content = property(fget = get_raw_content)
 
+       def get_comments(self):
+               if not self.loaded:
+                       self.load()
+               return self._comments
+       comments = property(fget = get_comments)
+
 
        def __cmp__(self, other):
                if self.path == other.path:
 
        def __cmp__(self, other):
                if self.path == other.path:
@@ -371,8 +531,14 @@ class Article (object):
 
 
        def load(self):
 
 
        def load(self):
+               # XXX this tweak is only needed for old DB format, where
+               # article's paths started with a slash
+               path = self.path
+               if path.startswith('/'):
+                       path = path[1:]
+               filename = os.path.join(data_path, path)
                try:
                try:
-                       raw = open(data_path + '/' + self.path).readlines()
+                       raw = open(filename).readlines()
                except:
                        return
 
                except:
                        return
 
@@ -381,9 +547,9 @@ class Article (object):
                        if ':' in l:
                                name, value = l.split(':', 1)
                                if name.lower() == 'title':
                        if ':' in l:
                                name, value = l.split(':', 1)
                                if name.lower() == 'title':
-                                       self._title = value
+                                       self._title = value.strip()
                                elif name.lower() == 'author':
                                elif name.lower() == 'author':
-                                       self._author = value
+                                       self._author = value.strip()
                                elif name.lower() == 'tags':
                                        ts = value.split(',')
                                        ts = [t.strip() for t in ts]
                                elif name.lower() == 'tags':
                                        ts = value.split(',')
                                        ts = [t.strip() for t in ts]
@@ -393,23 +559,40 @@ class Article (object):
                                break
                        count += 1
                self._raw_content = ''.join(raw[count + 1:])
                                break
                        count += 1
                self._raw_content = ''.join(raw[count + 1:])
+               db = CommentDB(self)
+               self._comments = db.comments
                self.loaded = True
 
        def to_html(self):
                self.loaded = True
 
        def to_html(self):
-               try:
-                       raw = open(data_path + '/' + self.path).readlines()
-               except:
-                       return "Can't open post file<p>"
-               raw = raw[raw.index('\n'):]
-
-               settings = {
-                       'input_encoding': encoding,
-                       'output_encoding': 'utf8',
+               return rst_to_html(self.raw_content)
+
+       def to_vars(self):
+               return {
+                       'arttitle': sanitize(self.title),
+                       'author': sanitize(self.author),
+                       'date': self.created.isoformat(' '),
+                       'uuid': self.uuid,
+                       'tags': self.get_tags_links(),
+                       'comments': len(self.comments),
+
+                       'created': self.created.isoformat(' '),
+                       'ciso': self.created.isoformat(),
+                       'cyear': self.created.year,
+                       'cmonth': self.created.month,
+                       'cday': self.created.day,
+                       'chour': self.created.hour,
+                       'cminute': self.created.minute,
+                       'csecond': self.created.second,
+
+                       'updated': self.updated.isoformat(' '),
+                       'uiso': self.updated.isoformat(),
+                       'uyear': self.updated.year,
+                       'umonth': self.updated.month,
+                       'uday': self.updated.day,
+                       'uhour': self.updated.hour,
+                       'uminute': self.updated.minute,
+                       'usecond': self.updated.second,
                }
                }
-               parts = publish_parts(self.raw_content,
-                               settings_overrides = settings,
-                               writer_name = "html")
-               return parts['body'].encode('utf8')
 
        def get_tags_links(self):
                l = []
 
        def get_tags_links(self):
                l = []
@@ -417,11 +600,11 @@ class Article (object):
                tags.sort()
                for t in tags:
                        l.append('<a class="tag" href="%s/tag/%s">%s</a>' % \
                tags.sort()
                for t in tags:
                        l.append('<a class="tag" href="%s/tag/%s">%s</a>' % \
-                               (blog_url, urllib.quote(t), t) )
+                               (blog_url, urllib.quote(t), sanitize(t) ))
                return ', '.join(l)
 
 
                return ', '.join(l)
 
 
-class DB (object):
+class ArticleDB (object):
        def __init__(self, dbpath):
                self.dbpath = dbpath
                self.articles = []
        def __init__(self, dbpath):
                self.dbpath = dbpath
                self.articles = []
@@ -461,11 +644,9 @@ class DB (object):
                        except:
                                continue
 
                        except:
                                continue
 
-                       a = Article(l[0])
-                       a.created = datetime.datetime.fromtimestamp(
-                                               float(l[1]) )
-                       a.updated = datetime.datetime.fromtimestamp(
-                                               float(l[2]))
+                       a = Article(l[0],
+                               datetime.datetime.fromtimestamp(float(l[1])),
+                               datetime.datetime.fromtimestamp(float(l[2])))
                        self.uuids[a.uuid] = a
                        self.actyears.add(a.created.year)
                        self.actmonths.add((a.created.year, a.created.month))
                        self.uuids[a.uuid] = a
                        self.actyears.add(a.created.year)
                        self.actmonths.add((a.created.year, a.created.month))
@@ -506,7 +687,7 @@ class DB (object):
 #
 
 
 #
 
 
-def render_html(articles, db, actyear = None):
+def render_html(articles, db, actyear = None, show_comments = False):
        template = Templates(templates_path, db, actyear)
        print 'Content-type: text/html; charset=utf-8\n'
        print template.get_main_header()
        template = Templates(templates_path, db, actyear)
        print 'Content-type: text/html; charset=utf-8\n'
        print template.get_main_header()
@@ -514,6 +695,14 @@ def render_html(articles, db, actyear = None):
                print template.get_article_header(a)
                print a.to_html()
                print template.get_article_footer(a)
                print template.get_article_header(a)
                print a.to_html()
                print template.get_article_footer(a)
+               if show_comments:
+                       print '<a name="comments" />'
+                       for c in a.comments:
+                               if c is None:
+                                       continue
+                               print template.get_comment_header(c)
+                               print c.to_html()
+                               print template.get_comment_footer(c)
        print template.get_main_footer()
 
 def render_artlist(articles, db, actyear = None):
        print template.get_main_footer()
 
 def render_artlist(articles, db, actyear = None):
@@ -553,6 +742,11 @@ def render_atom(articles):
        }
 
        for a in articles:
        }
 
        for a in articles:
+               vars = a.to_vars()
+               vars.update( {
+                       'url': full_url,
+                       'contents': a.to_html(),
+               } )
                print """
   <entry>
     <title>%(arttitle)s</title>
                print """
   <entry>
     <title>%(arttitle)s</title>
@@ -560,29 +754,20 @@ def render_atom(articles):
     <link href="%(url)s/post/%(uuid)s" />
     <id>%(url)s/post/%(uuid)s</id>
     <summary>%(arttitle)s</summary>
     <link href="%(url)s/post/%(uuid)s" />
     <id>%(url)s/post/%(uuid)s</id>
     <summary>%(arttitle)s</summary>
-    <published>%(created)sZ</published>
-    <updated>%(updated)sZ</updated>
+    <published>%(ciso)sZ</published>
+    <updated>%(uiso)sZ</updated>
     <content type="xhtml">
       <div xmlns="http://www.w3.org/1999/xhtml"><p>
 %(contents)s
       </p></div>
     </content>
   </entry>
     <content type="xhtml">
       <div xmlns="http://www.w3.org/1999/xhtml"><p>
 %(contents)s
       </p></div>
     </content>
   </entry>
-               """ % {
-                       'arttitle': a.title,
-                       'author': a.author,
-                       'uuid': a.uuid,
-                       'url': full_url,
-                       'created': a.created.isoformat(),
-                       'updated': a.updated.isoformat(),
-                       'contents': a.to_html(),
-               }
-
+               """ % vars
        print "</feed>"
 
 
 def render_style():
        print "</feed>"
 
 
 def render_style():
-       print 'Content-type: text/plain\n'
+       print 'Content-type: text/css\r\n\r\n',
        print default_css
 
 def handle_cgi():
        print default_css
 
 def handle_cgi():
@@ -627,7 +812,7 @@ def handle_cgi():
                        t = urllib.unquote_plus(t)
                        tags = set((t,))
 
                        t = urllib.unquote_plus(t)
                        tags = set((t,))
 
-       db = DB(data_path + '/db')
+       db = ArticleDB(os.path.join(data_path, 'db'))
        if atom:
                articles = db.get_articles(tags = tags)
                articles.sort(reverse = True)
        if atom:
                articles = db.get_articles(tags = tags)
                articles.sort(reverse = True)
@@ -635,7 +820,7 @@ def handle_cgi():
        elif style:
                render_style()
        elif post:
        elif style:
                render_style()
        elif post:
-               render_html( [db.get_article(uuid)], db, year )
+               render_html( [db.get_article(uuid)], db, year, True )
        elif artlist:
                articles = db.get_articles()
                articles.sort(cmp = Article.title_cmp)
        elif artlist:
                articles = db.get_articles()
                articles.sort(cmp = Article.title_cmp)
@@ -663,21 +848,21 @@ def handle_cmd():
                print "Error: article (%s) must be inside data_path (%s)" % \
                                (art_path, data_path)
                return 1
                print "Error: article (%s) must be inside data_path (%s)" % \
                                (art_path, data_path)
                return 1
-       art_path = art_path[len(data_path):]
+       art_path = art_path[len(data_path)+1:]
 
 
-       if not os.path.isfile(data_path + '/db'):
-               open(data_path + '/db', 'w').write('')
-       db = DB(data_path + '/db')
+       db_filename = os.path.join(data_path, 'db')
+       if not os.path.isfile(db_filename):
+               open(db_filename, 'w').write('')
+       db = ArticleDB(db_filename)
 
        if cmd == 'add':
 
        if cmd == 'add':
-               article = Article(art_path)
+               article = Article(art_path, datetime.datetime.now(),
+                                       datetime.datetime.now())
                for a in db.articles:
                        if a == article:
                                print 'Error: article already exists'
                                return 1
                db.articles.append(article)
                for a in db.articles:
                        if a == article:
                                print 'Error: article already exists'
                                return 1
                db.articles.append(article)
-               article.created = datetime.datetime.now()
-               article.updated = datetime.datetime.now()
                db.save()
        elif cmd == 'rm':
                article = Article(art_path)
                db.save()
        elif cmd == 'rm':
                article = Article(art_path)