]> git.llucax.com Git - software/blitiri.git/blob - blitiri.cgi
Move docutils rendering bits to a helper function
[software/blitiri.git] / blitiri.cgi
1 #!/usr/bin/env python
2 #coding: utf8
3
4 # blitiri - A single-file blog engine.
5 # Alberto Bertogli (albertito@gmail.com)
6
7 #
8 # Configuration section
9 #
10 # You can edit these values, or create a file named "config.py" and put them
11 # there to make updating easier. The ones in config.py take precedence.
12 #
13
14 # Directory where entries are stored
15 data_path = "/tmp/blog/data"
16
17 # Path where templates are stored. Use an empty string for the built-in
18 # default templates. If they're not found, the built-in ones will be used.
19 templates_path = "/tmp/blog/templates"
20
21 # URL to the blog, including the name. Can be a full URL or just the path.
22 blog_url = "/blog/blitiri.cgi"
23
24 # Style sheet (CSS) URL. Can be relative or absolute. To use the built-in
25 # default, set it to blog_url + "/style".
26 css_url = blog_url + "/style"
27
28 # Blog title
29 title = "I don't like blogs"
30
31 # Default author
32 author = "Hartmut Kegan"
33
34 # Article encoding
35 encoding = "utf8"
36
37 #
38 # End of configuration
39 # DO *NOT* EDIT ANYTHING PAST HERE
40 #
41
42
43 import sys
44 import os
45 import time
46 import datetime
47 import calendar
48 import zlib
49 import urllib
50 import cgi
51 from docutils.core import publish_parts
52
53 # Before importing the config, add our cwd to the Python path
54 sys.path.append(os.getcwd())
55
56 # Load the config file, if there is one
57 try:
58         from config import *
59 except:
60         pass
61
62
63 # Pimp *_path config variables to support relative paths
64 data_path = os.path.realpath(data_path)
65 templates_path = os.path.realpath(templates_path)
66
67 # Default template
68
69 default_main_header = """\
70 <?xml version="1.0" encoding="utf-8"?>
71 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
72           "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
73
74 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
75 <head>
76 <link rel="alternate" title="%(title)s" href="%(fullurl)s/atom"
77         type="application/atom+xml" />
78 <link href="%(css_url)s" rel="stylesheet" type="text/css" />
79 <title>%(title)s</title>
80 </head>
81
82 <body>
83
84 <h1><a href="%(url)s">%(title)s</a></h1>
85
86 <div class="content">
87 """
88
89 default_main_footer = """
90 </div>
91 <div class="footer">
92   %(showyear)s: %(monthlinks)s<br/>
93   years: %(yearlinks)s<br/>
94   subscribe: <a href="%(url)s/atom">atom</a><br/>
95   views: <a href="%(url)s/">blog</a> <a href="%(url)s/list">list</a><br/>
96 </div>
97
98 </body>
99 </html>
100 """
101
102 default_article_header = """
103 <div class="article">
104 <h2><a href="%(url)s/post/%(uuid)s">%(arttitle)s</a></h2>
105 <span class="artinfo">
106   by %(author)s on <span class="date">
107
108 <a class="date" href="%(url)s/%(cyear)d/">%(cyear)04d</a>-\
109 <a class="date" href="%(url)s/%(cyear)d/%(cmonth)d/">%(cmonth)02d</a>-\
110 <a class="date" href="%(url)s/%(cyear)d/%(cmonth)d/%(cday)d/">%(cday)02d</a>\
111     %(chour)02d:%(cminute)02d</span>
112   (updated on <span class="date">
113 <a class="date" href="%(url)s/%(uyear)d/">%(uyear)04d</a>-\
114 <a class="date" href="%(url)s/%(uyear)d/%(umonth)d/">%(umonth)02d</a>-\
115 <a class="date" href="%(url)s/%(uyear)d/%(umonth)d/%(uday)d/">%(uday)02d</a>\
116     %(uhour)02d:%(uminute)02d)</span><br/>
117   <span class="tags">tagged %(tags)s</span>
118 </span><br/>
119 <p/>
120 <div class="artbody">
121 """
122
123 default_article_footer = """
124 <p/>
125 </div>
126 </div>
127 """
128
129 # Default CSS
130 default_css = """
131 body {
132         font-family: sans-serif;
133         font-size: small;
134         width: 52em;
135 }
136
137 div.content {
138         width: 96%;
139 }
140
141 h1 {
142         font-size: large;
143         border-bottom: 2px solid #99F;
144         width: 100%;
145         margin-bottom: 1em;
146 }
147
148 h2 {
149         font-size: medium;
150         font-weigth: none;
151         margin-bottom: 1pt;
152         border-bottom: 1px solid #99C;
153 }
154
155 h1 a, h2 a {
156         text-decoration: none;
157         color: black;
158 }
159
160 span.artinfo {
161         font-size: xx-small;
162 }
163
164 span.artinfo a {
165         text-decoration: none;
166         color: #339;
167 }
168
169 span.artinfo a:hover {
170         text-decoration: none;
171         color: blue;
172 }
173
174 div.artbody {
175         margin-left: 1em;
176 }
177
178 div.article {
179         margin-bottom: 2em;
180 }
181
182 div.footer {
183         margin-top: 1em;
184         padding-top: 0.4em;
185         width: 100%;
186         border-top: 2px solid #99F;
187         font-size: x-small;
188 }
189
190 div.footer a {
191         text-decoration: none;
192 }
193
194 /* Articles are enclosed in <div class="section"> */
195 div.section h1 {
196         font-size: small;
197         font-weigth: none;
198         width: 100%;
199         margin-bottom: 1pt;
200         border-bottom: 1px dotted #99C;
201 }
202
203 """
204
205 # helper function
206 def rst_to_html(rst):
207         settings = {
208                 'input_encoding': encoding,
209                 'output_encoding': 'utf8',
210         }
211         parts = publish_parts(rst, settings_overrides = settings,
212                                 writer_name = "html")
213         return parts['body'].encode('utf8')
214
215 # find out our URL, needed for syndication
216 try:
217         n = os.environ['SERVER_NAME']
218         p = os.environ['SERVER_PORT']
219         s = os.environ['SCRIPT_NAME']
220         if p == '80': p = ''
221         else: p = ':' + p
222         full_url = 'http://%s%s%s' % (n, p, s)
223 except KeyError:
224         full_url = 'Not needed'
225
226
227 class Templates (object):
228         def __init__(self, tpath, db, showyear = None):
229                 self.tpath = tpath
230                 self.db = db
231                 now = datetime.datetime.now()
232                 if not showyear:
233                         showyear = now.year
234
235                 self.vars = {
236                         'css_url': css_url,
237                         'title': title,
238                         'url': blog_url,
239                         'fullurl': full_url,
240                         'year': now.year,
241                         'month': now.month,
242                         'day': now.day,
243                         'showyear': showyear,
244                         'monthlinks': ' '.join(db.get_month_links(showyear)),
245                         'yearlinks': ' '.join(db.get_year_links()),
246                 }
247
248         def get_template(self, page_name, default_template, extra_vars = None):
249                 if extra_vars is None:
250                         vars = self.vars
251                 else:
252                         vars = self.vars.copy()
253                         vars.update(extra_vars)
254
255                 p = '%s/%s.html' % (self.tpath, page_name)
256                 if os.path.isfile(p):
257                         return open(p).read() % vars
258                 return default_template % vars
259
260         def get_main_header(self):
261                 return self.get_template('header', default_main_header)
262
263         def get_main_footer(self):
264                 return self.get_template('footer', default_main_footer)
265
266         def get_article_header(self, article):
267                 return self.get_template(
268                         'art_header', default_article_header, article.to_vars())
269
270         def get_article_footer(self, article):
271                 return self.get_template(
272                         'art_footer', default_article_footer, article.to_vars())
273
274
275 class Article (object):
276         def __init__(self, path):
277                 self.path = path
278                 self.created = None
279                 self.updated = None
280                 self.uuid = "%08x" % zlib.crc32(self.path)
281
282                 self.loaded = False
283
284                 # loaded on demand
285                 self._title = 'Removed post'
286                 self._author = author
287                 self._tags = []
288                 self._raw_content = ''
289
290
291         def get_title(self):
292                 if not self.loaded:
293                         self.load()
294                 return self._title
295         title = property(fget = get_title)
296
297         def get_author(self):
298                 if not self.loaded:
299                         self.load()
300                 return self._author
301         author = property(fget = get_author)
302
303         def get_tags(self):
304                 if not self.loaded:
305                         self.load()
306                 return self._tags
307         tags = property(fget = get_tags)
308
309         def get_raw_content(self):
310                 if not self.loaded:
311                         self.load()
312                 return self._raw_content
313         raw_content = property(fget = get_raw_content)
314
315
316         def __cmp__(self, other):
317                 if self.path == other.path:
318                         return 0
319                 if not self.created:
320                         return 1
321                 if not other.created:
322                         return -1
323                 if self.created < other.created:
324                         return -1
325                 return 1
326
327         def title_cmp(self, other):
328                 return cmp(self.title, other.title)
329
330
331         def load(self):
332                 try:
333                         raw = open(data_path + '/' + self.path).readlines()
334                 except:
335                         return
336
337                 count = 0
338                 for l in raw:
339                         if ':' in l:
340                                 name, value = l.split(':', 1)
341                                 if name.lower() == 'title':
342                                         self._title = value
343                                 elif name.lower() == 'author':
344                                         self._author = value
345                                 elif name.lower() == 'tags':
346                                         ts = value.split(',')
347                                         ts = [t.strip() for t in ts]
348                                         self._tags = set(ts)
349                         elif l == '\n':
350                                 # end of header
351                                 break
352                         count += 1
353                 self._raw_content = ''.join(raw[count + 1:])
354                 self.loaded = True
355
356         def to_html(self):
357                 try:
358                         raw = open(data_path + '/' + self.path).readlines()
359                 except:
360                         return "Can't open post file<p>"
361                 raw = raw[raw.index('\n'):]
362
363                 return rst_to_html(self.raw_content)
364
365         def to_vars(self):
366                 return {
367                         'arttitle': self.title,
368                         'author': self.author,
369                         'date': self.created.isoformat(' '),
370                         'uuid': self.uuid,
371                         'tags': self.get_tags_links(),
372
373                         'created': self.created.isoformat(' '),
374                         'ciso': self.created.isoformat(),
375                         'cyear': self.created.year,
376                         'cmonth': self.created.month,
377                         'cday': self.created.day,
378                         'chour': self.created.hour,
379                         'cminute': self.created.minute,
380                         'csecond': self.created.second,
381
382                         'updated': self.updated.isoformat(' '),
383                         'uiso': self.updated.isoformat(),
384                         'uyear': self.updated.year,
385                         'umonth': self.updated.month,
386                         'uday': self.updated.day,
387                         'uhour': self.updated.hour,
388                         'uminute': self.updated.minute,
389                         'usecond': self.updated.second,
390                 }
391
392         def get_tags_links(self):
393                 l = []
394                 tags = list(self.tags)
395                 tags.sort()
396                 for t in tags:
397                         l.append('<a class="tag" href="%s/tag/%s">%s</a>' % \
398                                 (blog_url, urllib.quote(t), t) )
399                 return ', '.join(l)
400
401
402 class DB (object):
403         def __init__(self, dbpath):
404                 self.dbpath = dbpath
405                 self.articles = []
406                 self.uuids = {}
407                 self.actyears = set()
408                 self.actmonths = set()
409                 self.load()
410
411         def get_articles(self, year = 0, month = 0, day = 0, tags = None):
412                 l = []
413                 for a in self.articles:
414                         if year and a.created.year != year: continue
415                         if month and a.created.month != month: continue
416                         if day and a.created.day != day: continue
417                         if tags and not tags.issubset(a.tags): continue
418
419                         l.append(a)
420
421                 return l
422
423         def get_article(self, uuid):
424                 return self.uuids[uuid]
425
426         def load(self):
427                 try:
428                         f = open(self.dbpath)
429                 except:
430                         return
431
432                 for l in f:
433                         # Each line has the following comma separated format:
434                         # path (relative to data_path), \
435                         #       created (epoch), \
436                         #       updated (epoch)
437                         try:
438                                 l = l.split(',')
439                         except:
440                                 continue
441
442                         a = Article(l[0])
443                         a.created = datetime.datetime.fromtimestamp(
444                                                 float(l[1]) )
445                         a.updated = datetime.datetime.fromtimestamp(
446                                                 float(l[2]))
447                         self.uuids[a.uuid] = a
448                         self.actyears.add(a.created.year)
449                         self.actmonths.add((a.created.year, a.created.month))
450                         self.articles.append(a)
451
452         def save(self):
453                 f = open(self.dbpath + '.tmp', 'w')
454                 for a in self.articles:
455                         s = ''
456                         s += a.path + ', '
457                         s += str(time.mktime(a.created.timetuple())) + ', '
458                         s += str(time.mktime(a.updated.timetuple())) + '\n'
459                         f.write(s)
460                 f.close()
461                 os.rename(self.dbpath + '.tmp', self.dbpath)
462
463         def get_year_links(self):
464                 yl = list(self.actyears)
465                 yl.sort(reverse = True)
466                 return [ '<a href="%s/%d/">%d</a>' % (blog_url, y, y)
467                                 for y in yl ]
468
469         def get_month_links(self, year):
470                 am = [ i[1] for i in self.actmonths if i[0] == year ]
471                 ml = []
472                 for i in range(1, 13):
473                         name = calendar.month_name[i][:3]
474                         if i in am:
475                                 s = '<a href="%s/%d/%d/">%s</a>' % \
476                                         ( blog_url, year, i, name )
477                         else:
478                                 s = name
479                         ml.append(s)
480                 return ml
481
482 #
483 # Main
484 #
485
486
487 def render_html(articles, db, actyear = None):
488         template = Templates(templates_path, db, actyear)
489         print 'Content-type: text/html; charset=utf-8\n'
490         print template.get_main_header()
491         for a in articles:
492                 print template.get_article_header(a)
493                 print a.to_html()
494                 print template.get_article_footer(a)
495         print template.get_main_footer()
496
497 def render_artlist(articles, db, actyear = None):
498         template = Templates(templates_path, db, actyear)
499         print 'Content-type: text/html; charset=utf-8\n'
500         print template.get_main_header()
501         print '<h2>Articles</h2>'
502         for a in articles:
503                 print '<li><a href="%(url)s/uuid/%(uuid)s">%(title)s</a></li>' \
504                         % {     'url': blog_url,
505                                 'uuid': a.uuid,
506                                 'title': a.title,
507                                 'author': a.author,
508                         }
509         print template.get_main_footer()
510
511 def render_atom(articles):
512         if len(articles) > 0:
513                 updated = articles[0].updated.isoformat()
514         else:
515                 updated = datetime.datetime.now().isoformat()
516
517         print 'Content-type: application/atom+xml; charset=utf-8\n'
518         print """<?xml version="1.0" encoding="utf-8"?>
519
520 <feed xmlns="http://www.w3.org/2005/Atom">
521  <title>%(title)s</title>
522  <link rel="alternate" type="text/html" href="%(url)s"/>
523  <link rel="self" type="application/atom+xml" href="%(url)s/atom"/>
524  <id>%(url)s</id> <!-- TODO: find a better <id>, see RFC 4151 -->
525  <updated>%(updated)sZ</updated>
526
527         """ % {
528                 'title': title,
529                 'url': full_url,
530                 'updated': updated,
531         }
532
533         for a in articles:
534                 vars = a.to_vars()
535                 vars.update( {
536                         'url': full_url,
537                         'contents': a.to_html(),
538                 } )
539                 print """
540   <entry>
541     <title>%(arttitle)s</title>
542     <author><name>%(author)s</name></author>
543     <link href="%(url)s/post/%(uuid)s" />
544     <id>%(url)s/post/%(uuid)s</id>
545     <summary>%(arttitle)s</summary>
546     <published>%(ciso)sZ</published>
547     <updated>%(uiso)sZ</updated>
548     <content type="xhtml">
549       <div xmlns="http://www.w3.org/1999/xhtml"><p>
550 %(contents)s
551       </p></div>
552     </content>
553   </entry>
554                 """ % vars
555         print "</feed>"
556
557
558 def render_style():
559         print 'Content-type: text/css\r\n\r\n',
560         print default_css
561
562 def handle_cgi():
563         import cgitb; cgitb.enable()
564
565         form = cgi.FieldStorage()
566         year = int(form.getfirst("year", 0))
567         month = int(form.getfirst("month", 0))
568         day = int(form.getfirst("day", 0))
569         tags = set(form.getlist("tag"))
570         uuid = None
571         atom = False
572         style = False
573         post = False
574         artlist = False
575
576         if os.environ.has_key('PATH_INFO'):
577                 path_info = os.environ['PATH_INFO']
578                 style = path_info == '/style'
579                 atom = path_info == '/atom'
580                 tag = path_info.startswith('/tag/')
581                 post = path_info.startswith('/post/')
582                 artlist = path_info.startswith('/list')
583                 if not style and not atom and not post and not tag \
584                                 and not artlist:
585                         date = path_info.split('/')[1:]
586                         try:
587                                 if len(date) > 1 and date[0]:
588                                         year = int(date[0])
589                                 if len(date) > 2 and date[1]:
590                                         month = int(date[1])
591                                 if len(date) > 3 and date[2]:
592                                         day = int(date[2])
593                         except ValueError:
594                                 pass
595                 elif post:
596                         uuid = path_info.replace('/post/', '')
597                         uuid = uuid.replace('/', '')
598                 elif tag:
599                         t = path_info.replace('/tag/', '')
600                         t = t.replace('/', '')
601                         t = urllib.unquote_plus(t)
602                         tags = set((t,))
603
604         db = DB(data_path + '/db')
605         if atom:
606                 articles = db.get_articles(tags = tags)
607                 articles.sort(reverse = True)
608                 render_atom(articles[:10])
609         elif style:
610                 render_style()
611         elif post:
612                 render_html( [db.get_article(uuid)], db, year )
613         elif artlist:
614                 articles = db.get_articles()
615                 articles.sort(cmp = Article.title_cmp)
616                 render_artlist(articles, db)
617         else:
618                 articles = db.get_articles(year, month, day, tags)
619                 articles.sort(reverse = True)
620                 if not year and not month and not day and not tags:
621                         articles = articles[:10]
622                 render_html(articles, db, year)
623
624
625 def usage():
626         print 'Usage: %s {add|rm|update} article_path' % sys.argv[0]
627
628 def handle_cmd():
629         if len(sys.argv) != 3:
630                 usage()
631                 return 1
632
633         cmd = sys.argv[1]
634         art_path = os.path.realpath(sys.argv[2])
635
636         if os.path.commonprefix([data_path, art_path]) != data_path:
637                 print "Error: article (%s) must be inside data_path (%s)" % \
638                                 (art_path, data_path)
639                 return 1
640         art_path = art_path[len(data_path):]
641
642         if not os.path.isfile(data_path + '/db'):
643                 open(data_path + '/db', 'w').write('')
644         db = DB(data_path + '/db')
645
646         if cmd == 'add':
647                 article = Article(art_path)
648                 for a in db.articles:
649                         if a == article:
650                                 print 'Error: article already exists'
651                                 return 1
652                 db.articles.append(article)
653                 article.created = datetime.datetime.now()
654                 article.updated = datetime.datetime.now()
655                 db.save()
656         elif cmd == 'rm':
657                 article = Article(art_path)
658                 for a in db.articles:
659                         if a == article:
660                                 break
661                 else:
662                         print "Error: no such article"
663                         return 1
664                 db.articles.remove(a)
665                 db.save()
666         elif cmd == 'update':
667                 article = Article(art_path)
668                 for a in db.articles:
669                         if a == article:
670                                 break
671                 else:
672                         print "Error: no such article"
673                         return 1
674                 a.updated = datetime.datetime.now()
675                 db.save()
676         else:
677                 usage()
678                 return 1
679
680         return 0
681
682
683 if os.environ.has_key('GATEWAY_INTERFACE'):
684         handle_cgi()
685 else:
686         sys.exit(handle_cmd())
687
688