#!/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"
# 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"
# 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"
#
# End of configuration
# DO *NOT* EDIT ANYTHING PAST HERE
#
import sys
import os
import time
import datetime
import calendar
import zlib
import urllib
import cgi
from docutils.core import publish_parts
# Load the config file, if there is one
try:
from config import *
except:
pass
# Default template
default_main_header = """
%(title)s
*/
div.section h1 {
font-size: small;
font-weigth: none;
width: 100%;
margin-bottom: 1pt;
border-bottom: 1px dotted #99C;
}
"""
# find out our URL, needed for syndication
try:
n = os.environ['SERVER_NAME']
p = os.environ['SERVER_PORT']
s = os.environ['SCRIPT_NAME']
if p == '80': p = ''
else: p = ':' + p
full_url = 'http://%s%s%s' % (n, p, s)
except KeyError:
full_url = 'Not needed'
class Templates (object):
def __init__(self, tpath, db, showyear = None):
self.tpath = tpath
self.db = db
now = datetime.datetime.now()
if not showyear:
showyear = now.year
self.vars = {
'css_url': css_url,
'title': title,
'url': blog_url,
'fullurl': full_url,
'year': now.year,
'month': now.month,
'day': now.day,
'showyear': showyear,
'monthlinks': ' '.join(db.get_month_links(showyear)),
'yearlinks': ' '.join(db.get_year_links()),
}
def get_main_header(self):
p = self.tpath + '/header.html'
if os.path.isfile(p):
return open(p).read() % self.vars
return default_main_header % self.vars
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
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
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,
} )
p = self.tpath + '/art_footer.html'
if os.path.isfile(p):
return open(p).read() % avars
return default_article_footer % avars
class Article (object):
def __init__(self, path):
self.path = path
self.created = None
self.updated = None
self.uuid = "%08x" % zlib.crc32(self.path)
self.loaded = False
# loaded on demand
self._title = 'Removed post'
self._author = author
self._tags = []
self._raw_content = ''
def get_title(self):
if not self.loaded:
self.load()
return self._title
title = property(fget = get_title)
def get_author(self):
if not self.loaded:
self.load()
return self._author
author = property(fget = get_author)
def get_tags(self):
if not self.loaded:
self.load()
return self._tags
tags = property(fget = get_tags)
def get_raw_content(self):
if not self.loaded:
self.load()
return self._raw_content
raw_content = property(fget = get_raw_content)
def __cmp__(self, other):
if self.path == other.path:
return 0
if not self.created:
return 1
if not other.created:
return -1
if self.created < other.created:
return -1
return 1
def title_cmp(self, other):
return cmp(self.title, other.title)
def load(self):
try:
raw = open(data_path + '/' + self.path).readlines()
except:
return
count = 0
for l in raw:
if ':' in l:
name, value = l.split(':', 1)
if name.lower() == 'title':
self._title = value
elif name.lower() == 'author':
self._author = value
elif name.lower() == 'tags':
ts = value.split(',')
ts = [t.strip() for t in ts]
self._tags = set(ts)
elif l == '\n':
# end of header
break
count += 1
self._raw_content = ''.join(raw[count + 1:])
self.loaded = True
def to_html(self):
try:
raw = open(data_path + '/' + self.path).readlines()
except:
return "Can't open post file
"
raw = raw[raw.index('\n'):]
settings = {
'input_encoding': encoding,
'output_encoding': 'utf8',
}
parts = publish_parts(self.raw_content,
settings_overrides = settings,
writer_name = "html")
return parts['body'].encode('utf8')
def get_tags_links(self):
l = []
tags = list(self.tags)
tags.sort()
for t in tags:
l.append('%s' % \
(blog_url, urllib.quote(t), t) )
return ', '.join(l)
class DB (object):
def __init__(self, dbpath):
self.dbpath = dbpath
self.articles = []
self.uuids = {}
self.actyears = set()
self.actmonths = set()
self.load()
def get_articles(self, year = 0, month = 0, day = 0, tags = None):
l = []
for a in self.articles:
if year and a.created.year != year: continue
if month and a.created.month != month: continue
if day and a.created.day != day: continue
if tags and not tags.issubset(a.tags): continue
l.append(a)
return l
def get_article(self, uuid):
return self.uuids[uuid]
def load(self):
try:
f = open(self.dbpath)
except:
return
for l in f:
# Each line has the following comma separated format:
# path (relative to data_path), \
# created (epoch), \
# updated (epoch)
try:
l = l.split(',')
except:
continue
a = Article(l[0])
a.created = datetime.datetime.fromtimestamp(
float(l[1]) )
a.updated = 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.articles.append(a)
def save(self):
f = open(self.dbpath + '.tmp', 'w')
for a in self.articles:
s = ''
s += a.path + ', '
s += str(time.mktime(a.created.timetuple())) + ', '
s += str(time.mktime(a.updated.timetuple())) + '\n'
f.write(s)
f.close()
os.rename(self.dbpath + '.tmp', self.dbpath)
def get_year_links(self):
yl = list(self.actyears)
yl.sort(reverse = True)
return [ '%d' % (blog_url, y, y)
for y in yl ]
def get_month_links(self, year):
am = [ i[1] for i in self.actmonths if i[0] == year ]
ml = []
for i in range(1, 13):
name = calendar.month_name[i][:3]
if i in am:
s = '%s' % \
( blog_url, year, i, name )
else:
s = name
ml.append(s)
return ml
#
# Main
#
def render_html(articles, db, actyear = None):
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)
print template.get_main_footer()
def render_artlist(articles, db, actyear = None):
template = Templates(templates_path, db, actyear)
print 'Content-type: text/html; charset=utf-8\n'
print template.get_main_header()
print '