# Directory where entries are stored
data_path = "/tmp/blog/data"
+# Are comments allowed? (if False, comments_path option is not used)
+enable_comments = False
+
+# 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"
import sys
import os
+import errno
+import shutil
import time
import datetime
import calendar
<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">
</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_comment_form = """
+<div class="comform">
+<a name="comment" />
+<h3 class="comform"><a href="#comment">Your comment</a></h3>
+<div class="comforminner">
+<form method="%(form_method)s" action="%(form_action)s">
+<div class="comformauthor">
+ <label for="comformauthor">Your name</label>
+ <input type="text" class="comformauthor" id="comformauthor"
+ name="comformauthor" />
+</div>
+<div class="comformlink">
+ <label for="comformlink">Your link
+ <span class="comformoptional">(optional, will be published)</span></label>
+ <input type="text" class="comformlink" id="comformlink"
+ name="comformlink" />
+ <div class="comformhelp">
+ like <span class="formurlexample">http://www.example.com/</span>
+ or <span class="formurlexample">mailto:you@example.com</span>
+ </div>
+</div>
+<div class="comformbody">
+ <label for="comformbody" class="comformbody">The comment</label>
+ <textarea class="comformbody" id="comformbody" name="comformbody" rows="15"
+ cols="80"></textarea>
+ <div class="comformhelp">
+ in
+ <a href="http://docutils.sourceforge.net/docs/user/rst/quickref.html">\
+RestructuredText</a> format, please
+ </div>
+</div>
+<div class="comformsend">
+ <button type="submit" class="comformsend" id="comformsend" name="comformsend">
+ Send comment
+ </button>
+</div>
+</form>
+</div>
+</div>
+"""
+
+
# Default CSS
default_css = """
body {
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;
}
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;
+}
+
+div.comforminner {
+ margin-left: 2em;
+}
+
+div.comform {
+ margin-left: 1em;
+ margin-bottom: 1em;
+}
+
+div.comform label {
+ display: block;
+ border-bottom: 1px solid #99C;
+ margin-top: 0.5em;
+ clear: both;
+}
+
+div.comform span.comformoptional {
+ font-size: xx-small;
+ color: #666;
+}
+
+div.comform input {
+ font-size: small;
+ width: 99%;
+}
+
+div.comformhelp {
+ font-size: xx-small;
+ text-align: right;
+ float: right;
+}
+
+span.formurlexample {
+ color: #111;
+ background-color: #EEF;
+ font-family: monospace;
+ padding-left: 0.2em;
+ padding-right: 0.2em;
+}
+
+textarea.comformbody {
+ font-family: monospace;
+ font-size: small;
+ width: 99%;
+ height: 15em;
+}
+
+button.comformsend {
+ margin-top: 0.5em;
+}
+
+hr {
+ float: left;
+ height: 2px;
+ border: 0;
+ background-color: #99F;
+ width: 60%;
+}
+
div.footer {
margin-top: 1em;
padding-top: 0.4em;
"""
-# helper function
+# helper functions
def rst_to_html(rst):
settings = {
'input_encoding': encoding,
'output_encoding': 'utf8',
+ 'halt_level': 1,
+ 'traceback': 1,
}
parts = publish_parts(rst, settings_overrides = settings,
writer_name = "html")
return parts['body'].encode('utf8')
+def valid_rst(rst):
+ try:
+ rst_to_html(rst)
+ return True
+ except:
+ return False
+
+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']
return self.get_template(
'art_footer', default_article_footer, article.to_vars())
+ 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())
+
+ def get_comment_form(self, article, method, action):
+ vars = article.to_vars()
+ vars['form_method'] = method
+ vars['form_action'] = action
+ return self.get_template(
+ 'com_form', default_comment_form, 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 set(self, author, raw_content, link = '', created = None):
+ self.loaded = True
+ self._author = author
+ self._raw_content = raw_content
+ self._link = link
+ self.created = created or datetime.datetime.now()
+
+
+ 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 save(self):
+ filename = os.path.join(comments_path, self.article.uuid,
+ str(self.number))
+ try:
+ f = open(filename, 'w')
+ f.write('Author: %s\n' % self.author)
+ f.write('Link: %s\n' % self.link)
+ f.write('\n')
+ f.write(self.raw_content)
+ except:
+ return
+
+
+ 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):
def __init__(self, path, created = None, updated = None):
self._author = author
self._tags = []
self._raw_content = ''
+ self._comments = []
def get_title(self):
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:
return cmp(self.title, other.title)
+ def add_comment(self, author, raw_content, link = ''):
+ c = Comment(self, len(self.comments))
+ c.set(author, raw_content, link)
+ self.comments.append(c)
+ return c
+
+
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:
- raw = open(data_path + '/' + self.path).readlines()
+ raw = open(filename).readlines()
except:
return
break
count += 1
self._raw_content = ''.join(raw[count + 1:])
+ db = CommentDB(self)
+ self._comments = db.comments
self.loaded = True
def to_html(self):
def to_vars(self):
return {
- 'arttitle': self.title,
- 'author': self.author,
+ '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(),
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)
-class DB (object):
+class ArticleDB (object):
def __init__(self, dbpath):
self.dbpath = dbpath
self.articles = []
#
-def render_html(articles, db, actyear = None):
+def render_html(articles, db, actyear = None, show_comments = False,
+ redirect = None):
+ if redirect is not None:
+ print 'Status: 303 See Other\r\n',
+ print 'Location: %s\r\n' % redirect,
+ print 'Content-type: text/html; charset=utf-8\r\n',
+ print '\r\n',
template = Templates(templates_path, db, actyear)
- print 'Content-type: text/html; charset=utf-8\n'
print template.get_main_header()
for a in articles:
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_comment_form(a, 'post',
+ blog_url + '/comment/' + a.uuid)
print template.get_main_footer()
def render_artlist(articles, db, actyear = None):
style = False
post = False
artlist = False
+ comment = False
if os.environ.has_key('PATH_INFO'):
path_info = os.environ['PATH_INFO']
tag = path_info.startswith('/tag/')
post = path_info.startswith('/post/')
artlist = path_info.startswith('/list')
+ comment = path_info.startswith('/comment/') and enable_comments
if not style and not atom and not post and not tag \
- and not artlist:
+ and not comment and not artlist:
date = path_info.split('/')[1:]
try:
if len(date) > 1 and date[0]:
t = t.replace('/', '')
t = urllib.unquote_plus(t)
tags = set((t,))
+ elif comment:
+ uuid = path_info.replace('/comment/', '')
+ uuid = uuid.replace('/', '')
+ author = form.getfirst('comformauthor', '')
+ link = form.getfirst('comformlink', '')
+ body = form.getfirst('comformbody', '')
- 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)
elif style:
render_style()
elif post:
- render_html( [db.get_article(uuid)], db, year )
+ render_html( [db.get_article(uuid)], db, year, enable_comments )
elif artlist:
articles = db.get_articles()
articles.sort(cmp = Article.title_cmp)
render_artlist(articles, db)
+ elif comment:
+ author = author.strip().replace('\n', ' ')
+ link = link.strip().replace('\n', ' ')
+ body = body.strip()
+ article = db.get_article(uuid)
+ redirect = blog_url + '/post/' + uuid + '#comment'
+ if author and body and valid_rst(body):
+ c = article.add_comment(author, body, link)
+ c.save()
+ cdb = CommentDB(article)
+ cdb.comments = article.comments
+ cdb.save()
+ redirect += '-' + str(c.number)
+ render_html( [article], db, year, enable_comments,
+ redirect = redirect )
else:
articles = db.get_articles(year, month, day, tags)
articles.sort(reverse = True)
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':
article = Article(art_path, datetime.datetime.now(),
return 1
db.articles.append(article)
db.save()
+ if enable_comments:
+ comment_dir = os.path.join(comments_path, article.uuid)
+ try:
+ os.mkdir(comment_dir, 0775)
+ except OSError, e:
+ if e.errno != errno.EEXIST:
+ print "Error: can't create comments " \
+ "directory %s (%s)" \
+ % (comment_dir, e)
+ # otherwise is probably a removed and re-added
+ # article
elif cmd == 'rm':
article = Article(art_path)
for a in db.articles:
else:
print "Error: no such article"
return 1
+ if enable_comments:
+ r = raw_input('Remove comments [y/N]? ')
db.articles.remove(a)
db.save()
+ if enable_comments and r.lower() == 'y':
+ shutil.rmtree(os.path.join(comments_path, a.uuid))
elif cmd == 'update':
article = Article(art_path)
for a in db.articles:
projects / software / blitiri.git / blobdiff