#!/usr/bin/env python
#coding: utf8
# blitiri - A single-file blog engine.
# Alberto Bertogli (albertito@gmail.com)
#
# Configuration section
#
# You can edit these values, or create a file named "config.py" and put them
# there to make updating easier. The ones in config.py take precedence.
#
# 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"
# Path where the cache is stored (must be writeable by the web server);
# set to None to disable. When enabled, you must take care of cleaning it up
# every once in a while.
#cache_path = "/tmp/blog/cache"
cache_path = None
# URL to the blog, including the name. Can be a full URL or just the path.
blog_url = "/blog/blitiri.cgi"
# Style sheet (CSS) URL. Can be relative or absolute. To use the built-in
# default, set it to blog_url + "/style".
css_url = blog_url + "/style"
# Blog title
title = "I don't like blogs"
# Default author
author = "Hartmut Kegan"
# Article encoding
encoding = "utf8"
# Captcha method to use. At the moment only "title" is supported, but if you
# are keen with Python you can provide your own captcha implementation, see
# below for details.
captcha_method = "title"
# How many articles to show in the index
index_articles = 10
#
# End of configuration
# DO *NOT* EDIT ANYTHING PAST HERE
#
import sys
import os
import errno
import shutil
import time
import datetime
import calendar
import zlib
import urllib
import cgi
from docutils.core import publish_parts
from docutils.utils import SystemMessage
# Before importing the config, add our cwd to the Python path
sys.path.append(os.getcwd())
# Load the config file, if there is one
try:
from config import *
except:
pass
# Pimp *_path config variables to support relative paths
data_path = os.path.realpath(data_path)
templates_path = os.path.realpath(templates_path)
#
# Captcha classes
#
# They must follow the interface described below.
#
# Constructor:
# Captcha(article) -> constructor, takes an article[1] as argument
# Attributes:
# puzzle -> a string with the puzzle the user must solve to prove he is
# not a bot (can be raw HTML)
# help -> a string with extra instructions, shown only when the user
# failed to solve the puzzle
# Methods:
# validate(form_data) -> based on the form data[2], returns True if
# the user has solved the puzzle uccessfully
# (False otherwise).
#
# Note you must ensure that the puzzle attribute and validate() method can
# "communicate" because they are executed in different requests. You can pass a
# cookie or just calculate the answer based on the article's data, for example.
#
# [1] article is an object with all the article's information:
# path -> string
# created -> datetime
# updated -> datetime
# uuid -> string (unique ID)
# title -> string
# author -> string
# tags -> list of strings
# raw_contents -> string in rst format
# comments -> list of Comment objects (not too relevant here)
# [2] form_data is an object with the form fields (all strings):
# author, author_error
# link, link_error
# catpcha, captcha_error
# body, body_error
# action, method
class TitleCaptcha (object):
"Captcha that uses the article's title for the puzzle"
def __init__(self, article):
self.article = article
words = article.title.split()
self.nword = hash(article.title) % len(words) % 5
self.answer = words[self.nword]
self.help = 'gotcha, damn spam bot!'
@property
def puzzle(self):
nword = self.nword + 1
if nword == 1:
n = '1st'
elif nword == 2:
n = '2nd'
elif nword == 3:
n = '3rd'
else:
n = str(nword) + 'th'
return "enter the %s word of the article's title" % n
def validate(self, form_data):
if form_data.captcha.lower() == self.answer.lower():
return True
return False
known_captcha_methods = {
'title': TitleCaptcha,
}
# If the configured captcha method was a known string, replace it by the
# matching class; otherwise assume it's already a class and leave it
# alone. This way the user can either use one of our methods, or provide one
# of his/her own.
if captcha_method in known_captcha_methods:
captcha_method = known_captcha_methods[captcha_method]
# Default template
default_main_header = """\
%(title)s
""" % vars
print ""
def render_style():
print 'Content-type: text/css\r\n\r\n',
print default_css
# Get a dictionary with sort() arguments (key and reverse) by parsing the sort
# specification format:
# [+-]??
# Where "-" is used to specify reverse order, while "+" is regular, ascending,
# order (reverse = False). The key value is an Article's attribute name (title,
# author, created, updated and uuid are accepted), and will be used as key for
# sorting. If a value is omitted, that value is taken from the default, which
# should be provided using the same format specification, with the difference
# that all values must be provided for the default.
def get_sort_args(sort_str, default):
def parse(s):
d = dict()
if not s:
return d
key = None
if len(s) > 0:
# accept ' ' as an alias of '+' since '+' is translated
# to ' ' in URLs
if s[0] in ('+', ' ', '-'):
key = s[1:]
d['reverse'] = (s[0] == '-')
else:
key = s
if key in ('title', 'author', 'created', 'updated', 'uuid'):
d['key'] = lambda a: getattr(a, key)
return d
args = parse(default)
assert args['key'] is not None and args['reverse'] is not None
args.update(parse(sort_str))
return args
def handle_cgi():
import cgitb; cgitb.enable()
form = cgi.FieldStorage()
year = int(form.getfirst("year", 0))
month = int(form.getfirst("month", 0))
day = int(form.getfirst("day", 0))
tags = set(form.getlist("tag"))
sort_str = form.getfirst("sort", None)
uuid = None
atom = False
style = False
post = False
post_preview = False
artlist = False
comment = False
if os.environ.has_key('PATH_INFO'):
path_info = os.environ['PATH_INFO']
style = path_info == '/style'
atom = path_info == '/atom'
tag = path_info.startswith('/tag/')
post = path_info.startswith('/post/')
post_preview = path_info.startswith('/preview/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 post_preview \
and not tag and not comment and not artlist:
date = path_info.split('/')[1:]
try:
if len(date) > 1 and date[0]:
year = int(date[0])
if len(date) > 2 and date[1]:
month = int(date[1])
if len(date) > 3 and date[2]:
day = int(date[2])
except ValueError:
pass
elif post:
uuid = path_info.replace('/post/', '')
uuid = uuid.replace('/', '')
elif post_preview:
art_path = path_info.replace('/preview/post/', '')
art_path = urllib.unquote_plus(art_path)
art_path = os.path.join(data_path, art_path)
art_path = os.path.realpath(art_path)
common = os.path.commonprefix([data_path, art_path])
if common != data_path: # something nasty happened
post_preview = False
art_path = art_path[len(data_path)+1:]
elif tag:
t = path_info.replace('/tag/', '')
t = t.replace('/', '')
t = urllib.unquote_plus(t)
tags = set((t,))
elif comment:
uuid = path_info.replace('/comment/', '')
uuid = uuid.replace('#comment', '')
uuid = uuid.replace('/', '')
author = form.getfirst('comformauthor', '')
link = form.getfirst('comformlink', '')
captcha = form.getfirst('comformcaptcha', '')
body = form.getfirst('comformbody', '')
db = ArticleDB(os.path.join(data_path, 'db'))
if atom:
articles = db.get_articles(tags = tags)
articles.sort(**get_sort_args(sort_str, '-created'))
render_atom(articles[:index_articles])
elif style:
render_style()
elif post:
render_html( [db.get_article(uuid)], db, year, enable_comments )
elif post_preview:
article = Article(art_path, datetime.datetime.now(),
datetime.datetime.now())
render_html( [article], db, year, enable_comments )
elif artlist:
articles = db.get_articles()
articles.sort(**get_sort_args(sort_str, '+title'))
render_artlist(articles, db)
elif comment and enable_comments:
form_data = CommentFormData(author.strip().replace('\n', ' '),
link.strip().replace('\n', ' '), captcha,
body.replace('\r', ''))
article = db.get_article(uuid)
captcha = captcha_method(article)
redirect = False
valid = True
if not form_data.author:
form_data.author_error = 'please, enter your name'
valid = False
if form_data.link:
link = valid_link(form_data.link)
if link:
form_data.link = link
else:
form_data.link_error = 'please, enter a ' \
'valid link'
valid = False
if not captcha.validate(form_data):
form_data.captcha_error = captcha.help
valid = False
if not form_data.body:
form_data.body_error = 'please, write a comment'
valid = False
else:
error = validate_rst(form_data.body, secure=False)
if error is not None:
(line, desc, ctx) = error
at = ''
if line:
at = ' at line %d' % line
form_data.body_error = 'error%s: %s' \
% (at, desc)
valid = False
if valid:
c = article.add_comment(form_data.author,
form_data.body, form_data.link)
c.save()
cdb = CommentDB(article)
cdb.comments = article.comments
cdb.save()
redirect = blog_url + '/post/' + uuid + '#comment-' \
+ str(c.number)
render_html( [article], db, year, enable_comments, redirect,
form_data )
else:
articles = db.get_articles(year, month, day, tags)
articles.sort(**get_sort_args(sort_str, '-created'))
if not year and not month and not day and not tags:
articles = articles[:index_articles]
render_html(articles, db, year)
def usage():
print 'Usage: %s {add|rm|update} article_path' % sys.argv[0]
def handle_cmd():
if len(sys.argv) != 3:
usage()
return 1
cmd = sys.argv[1]
art_path = os.path.realpath(sys.argv[2])
if os.path.commonprefix([data_path, art_path]) != data_path:
print "Error: article (%s) must be inside data_path (%s)" % \
(art_path, data_path)
return 1
art_path = art_path[len(data_path)+1:]
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(),
datetime.datetime.now())
for a in db.articles:
if a == article:
print 'Error: article already exists'
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:
if a == article:
break
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:
if a == article:
break
else:
print "Error: no such article"
return 1
a.updated = datetime.datetime.now()
db.save()
else:
usage()
return 1
return 0
if os.environ.has_key('GATEWAY_INTERFACE'):
i = datetime.datetime.now()
handle_cgi()
f = datetime.datetime.now()
print '' % (f-i)
else:
sys.exit(handle_cmd())
Comment #%(number)d
by %(linked_author)s on %(year)04d-%(month)02d-%(day)02d %(hour)02d:%(minute)02d