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 # Are comments allowed? (if False, comments_path option is not used)
  18 enable_comments = False
  19
  20 # Directory where comments are stored (must be writeable by the web server)
  21 comments_path = "/tmp/blog/comments"
  22
  23 # Path where templates are stored. Use an empty string for the built-in
  24 # default templates. If they're not found, the built-in ones will be used.
  25 templates_path = "/tmp/blog/templates"
  26
  27 # Path where the cache is stored (must be writeable by the web server);
  28 # set to None to disable. When enabled, you must take care of cleaning it up
  29 # every once in a while.
  30 #cache_path = "/tmp/blog/cache"
  31 cache_path = None
  32
  33 # URL to the blog, including the name. Can be a full URL or just the path.
  34 blog_url = "/blog/blitiri.cgi"
  35
  36 # Style sheet (CSS) URL. Can be relative or absolute. To use the built-in
  37 # default, set it to blog_url + "/style".
  38 css_url = blog_url + "/style"
  39
  40 # Blog title
  41 title = "I don't like blogs"
  42
  43 # Default author
  44 author = "Hartmut Kegan"
  45
  46 # Article encoding
  47 encoding = "utf8"
  48
  49 # Captcha method to use. At the moment only "title" is supported, but if you
  50 # are keen with Python you can provide your own captcha implementation, see
  51 # below for details.
  52 captcha_method = "title"
  53
  54 # How many articles to show in the index
  55 index_articles = 10
  56
  57
  58 #
  59 # End of configuration
  60 # DO *NOT* EDIT ANYTHING PAST HERE
  61 #
  62
  63
  64 import sys
  65 import os
  66 import errno
  67 import shutil
  68 import time
  69 import datetime
  70 import calendar
  71 import zlib
  72 import urllib
  73 import cgi
  74 from docutils.core import publish_parts
  75 from docutils.utils import SystemMessage
  76
  77 # Before importing the config, add our cwd to the Python path
  78 sys.path.append(os.getcwd())
  79
  80 # Load the config file, if there is one
  81 try:
  82         from config import *
  83 except:
  84         pass
  85
  86
  87 # Pimp *_path config variables to support relative paths
  88 data_path = os.path.realpath(data_path)
  89 templates_path = os.path.realpath(templates_path)
  90
  91
  92 #
  93 # Captcha classes
  94 #
  95 # They must follow the interface described below.
  96 #
  97 # Constructor:
  98 #       Captcha(article) -> constructor, takes an article[1] as argument
  99 # Attributes:
 100 #       puzzle -> a string with the puzzle the user must solve to prove he is
 101 #                 not a bot (can be raw HTML)
 102 #       help -> a string with extra instructions, shown only when the user
 103 #               failed to solve the puzzle
 104 # Methods:
 105 #       validate(form_data) -> based on the form data[2],  returns True if
 106 #                              the user has solved the puzzle uccessfully
 107 #                              (False otherwise).
 108 #
 109 # Note you must ensure that the puzzle attribute and validate() method can
 110 # "communicate" because they are executed in different requests. You can pass a
 111 # cookie or just calculate the answer based on the article's data, for example.
 112 #
 113 # [1] article is an object with all the article's information:
 114 #       path -> string
 115 #       created -> datetime
 116 #       updated -> datetime
 117 #       uuid -> string (unique ID)
 118 #       title -> string
 119 #       author -> string
 120 #       tags -> list of strings
 121 #       raw_contents -> string in rst format
 122 #       comments -> list of Comment objects (not too relevant here)
 123 # [2] form_data is an object with the form fields (all strings):
 124 #       author, author_error
 125 #       link, link_error
 126 #       catpcha, captcha_error
 127 #       body, body_error
 128 #       action, method
 129
 130 class TitleCaptcha (object):
 131         "Captcha that uses the article's title for the puzzle"
 132         def __init__(self, article):
 133                 self.article = article
 134                 words = article.title.split()
 135                 self.nword = hash(article.title) % len(words) % 5
 136                 self.answer = words[self.nword]
 137                 self.help = 'gotcha, damn spam bot!'
 138
 139         @property
 140         def puzzle(self):
 141                 nword = self.nword + 1
 142                 if nword == 1:
 143                         n = '1st'
 144                 elif nword == 2:
 145                         n = '2nd'
 146                 elif nword == 3:
 147                         n = '3rd'
 148                 else:
 149                         n = str(nword) + 'th'
 150                 return "enter the %s word of the article's title" % n
 151
 152         def validate(self, form_data):
 153                 if form_data.captcha.lower() == self.answer.lower():
 154                         return True
 155                 return False
 156
 157 known_captcha_methods = {
 158         'title': TitleCaptcha,
 159 }
 160
 161 # If the configured captcha method was a known string, replace it by the
 162 # matching class; otherwise assume it's already a class and leave it
 163 # alone. This way the user can either use one of our methods, or provide one
 164 # of his/her own.
 165 if captcha_method in known_captcha_methods:
 166         captcha_method = known_captcha_methods[captcha_method]
 167
 168
 169 # Default template
 170
 171 default_main_header = """\
 172 <?xml version="1.0" encoding="utf-8"?>
 173 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
 174           "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 175
 176 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 177 <head>
 178 <link rel="alternate" title="%(title)s" href="%(fullurl)s/atom"
 179         type="application/atom+xml" />
 180 <link href="%(css_url)s" rel="stylesheet" type="text/css" />
 181 <title>%(title)s</title>
 182 </head>
 183
 184 <body>
 185
 186 <h1><a href="%(url)s">%(title)s</a></h1>
 187
 188 <div class="content">
 189 """
 190
 191 default_main_footer = """
 192 </div>
 193 <div class="footer">
 194   %(showyear)s: %(monthlinks)s<br/>
 195   years: %(yearlinks)s<br/>
 196   subscribe: <a href="%(url)s/atom">atom</a><br/>
 197   views: <a href="%(url)s/">blog</a> <a href="%(url)s/list">list</a><br/>
 198   tags: %(taglinks)s<br/>
 199 </div>
 200
 201 </body>
 202 </html>
 203 """
 204
 205 default_article_header = """
 206 <div class="article">
 207 <h2><a href="%(url)s/post/%(uuid)s">%(arttitle)s</a></h2>
 208 <span class="artinfo">
 209   by %(author)s on <span class="date">
 210
 211 <a class="date" href="%(url)s/%(cyear)d/">%(cyear)04d</a>-\
 212 <a class="date" href="%(url)s/%(cyear)d/%(cmonth)d/">%(cmonth)02d</a>-\
 213 <a class="date" href="%(url)s/%(cyear)d/%(cmonth)d/%(cday)d/">%(cday)02d</a>\
 214     %(chour)02d:%(cminute)02d</span>
 215   (updated on <span class="date">
 216 <a class="date" href="%(url)s/%(uyear)d/">%(uyear)04d</a>-\
 217 <a class="date" href="%(url)s/%(uyear)d/%(umonth)d/">%(umonth)02d</a>-\
 218 <a class="date" href="%(url)s/%(uyear)d/%(umonth)d/%(uday)d/">%(uday)02d</a>\
 219     %(uhour)02d:%(uminute)02d)</span><br/>
 220   <span class="tags">tagged %(tags)s</span> -
 221   <span class="comments">with %(comments)s
 222     <a href="%(url)s/post/%(uuid)s#comments">comment(s)</a></span>
 223 </span><br/>
 224 <p/>
 225 <div class="artbody">
 226 """
 227
 228 default_article_footer = """
 229 <p/>
 230 </div>
 231 </div>
 232 """
 233
 234 default_comment_header = """
 235 <div class="comment">
 236 <a name="comment-%(number)d" />
 237 <h3><a href="#comment-%(number)d">Comment #%(number)d</a></h3>
 238 <span class="cominfo">by %(linked_author)s
 239   on %(year)04d-%(month)02d-%(day)02d %(hour)02d:%(minute)02d</span>
 240 <p/>
 241 <div class="combody">
 242 """
 243
 244 default_comment_footer = """
 245 <p/>
 246 </div>
 247 </div>
 248 """
 249
 250 default_comment_form = """
 251 <div class="comform">
 252 <a name="comment" />
 253 <h3 class="comform"><a href="#comment">Your comment</a></h3>
 254 <div class="comforminner">
 255 <form method="%(form_method)s" action="%(form_action)s">
 256 <div class="comformauthor">
 257   <label for="comformauthor">Your name %(form_author_error)s</label>
 258   <input type="text" class="comformauthor" id="comformauthor"
 259          name="comformauthor" value="%(form_author)s" />
 260 </div>
 261 <div class="comformlink">
 262   <label for="comformlink">Your link
 263     <span class="comformoptional">(optional, will be published)</span>
 264       %(form_link_error)s</label>
 265   <input type="text" class="comformlink" id="comformlink"
 266          name="comformlink" value="%(form_link)s" />
 267   <div class="comformhelp">
 268     like <span class="formurlexample">http://www.example.com/</span>
 269     or <span class="formurlexample">mailto:you@example.com</span>
 270   </div>
 271 </div>
 272 <div class="comformcaptcha">
 273   <label for="comformcaptcha">Your humanity proof %(form_captcha_error)s</label>
 274   <input type="text" class="comformcaptcha" id="comformcaptcha"
 275          name="comformcaptcha" value="%(form_captcha)s" />
 276   <div class="comformhelp">%(captcha_puzzle)s</div>
 277 </div>
 278 <div class="comformbody">
 279   <label for="comformbody" class="comformbody">The comment
 280     %(form_body_error)s</label>
 281   <textarea class="comformbody" id="comformbody" name="comformbody" rows="15"
 282             cols="80">%(form_body)s</textarea>
 283   <div class="comformhelp">
 284     in
 285     <a href="http://docutils.sourceforge.net/docs/user/rst/quickref.html">\
 286 RestructuredText</a> format, please
 287   </div>
 288 </div>
 289 <div class="comformsend">
 290   <button type="submit" class="comformsend" id="comformsend" name="comformsend">
 291     Send comment
 292   </button>
 293 </div>
 294 </form>
 295 </div>
 296 </div>
 297 """
 298
 299 default_comment_error = '<span class="comformerror">(%(error)s)</span>'
 300
 301
 302 # Default CSS
 303 default_css = """
 304 body {
 305         font-family: sans-serif;
 306         font-size: small;
 307         width: 52em;
 308 }
 309
 310 div.content {
 311         width: 96%;
 312 }
 313
 314 h1 {
 315         font-size: large;
 316         border-bottom: 2px solid #99F;
 317         width: 100%;
 318         margin-bottom: 1em;
 319 }
 320
 321 h2 {
 322         font-size: medium;
 323         font-weigth: none;
 324         margin-bottom: 1pt;
 325         border-bottom: 1px solid #99C;
 326 }
 327
 328 h3 {
 329         font-size: small;
 330         font-weigth: none;
 331         margin-bottom: 1pt;
 332         border-bottom: 1px solid #99C;
 333 }
 334
 335 h1 a, h2 a, h3 a {
 336         text-decoration: none;
 337         color: black;
 338 }
 339
 340 span.artinfo {
 341         font-size: xx-small;
 342 }
 343
 344 span.artinfo a {
 345         text-decoration: none;
 346         color: #339;
 347 }
 348
 349 span.artinfo a:hover {
 350         text-decoration: none;
 351         color: blue;
 352 }
 353
 354 div.artbody {
 355         margin-left: 1em;
 356 }
 357
 358 div.article {
 359         margin-bottom: 2em;
 360 }
 361
 362 span.cominfo {
 363         font-size: xx-small;
 364 }
 365
 366 span.cominfo a {
 367         text-decoration: none;
 368         color: #339;
 369 }
 370
 371 span.cominfo a:hover {
 372         text-decoration: none;
 373         color: blue;
 374 }
 375
 376 div.combody {
 377         margin-left: 2em;
 378 }
 379
 380 div.comment {
 381         margin-left: 1em;
 382         margin-bottom: 1em;
 383 }
 384
 385 div.comforminner {
 386         margin-left: 2em;
 387 }
 388
 389 div.comform {
 390         margin-left: 1em;
 391         margin-bottom: 1em;
 392 }
 393
 394 div.comform label {
 395         display: block;
 396         border-bottom: 1px solid #99C;
 397         margin-top: 0.5em;
 398         clear: both;
 399 }
 400
 401 div.comform span.comformoptional {
 402         font-size: xx-small;
 403         color: #666;
 404 }
 405
 406 div.comform input {
 407         font-size: small;
 408         width: 99%;
 409 }
 410
 411 div.comformhelp {
 412         font-size: xx-small;
 413         text-align: right;
 414         float: right;
 415 }
 416
 417 span.formurlexample {
 418         color: #111;
 419         background-color: #EEF;
 420         font-family: monospace;
 421         padding-left: 0.2em;
 422         padding-right: 0.2em;
 423 }
 424
 425 textarea.comformbody {
 426         font-family: monospace;
 427         font-size: small;
 428         width: 99%;
 429         height: 15em;
 430 }
 431
 432 button.comformsend {
 433         margin-top: 0.5em;
 434 }
 435
 436 span.comformerror {
 437         color: #900;
 438         font-size: xx-small;
 439         margin-left: 0.5em;
 440 }
 441
 442 hr {
 443         float: left;
 444         height: 2px;
 445         border: 0;
 446         background-color: #99F;
 447         width: 60%;
 448 }
 449
 450 div.footer {
 451         margin-top: 1em;
 452         padding-top: 0.4em;
 453         width: 100%;
 454         border-top: 2px solid #99F;
 455         font-size: x-small;
 456 }
 457
 458 div.footer a {
 459         text-decoration: none;
 460 }
 461
 462 /* Articles are enclosed in <div class="section"> */
 463 div.section h1 {
 464         font-size: small;
 465         font-weigth: none;
 466         width: 100%;
 467         margin-bottom: 1pt;
 468         border-bottom: 1px dotted #99C;
 469 }
 470
 471 """
 472
 473
 474 # Cache decorator
 475 # It only works if the function is pure (that is, its return value depends
 476 # only on its arguments), and if all the arguments are hash()eable.
 477 def cached(f):
 478         # do not decorate if the cache is disabled
 479         if cache_path is None:
 480                 return f
 481
 482         def decorate(*args, **kwargs):
 483                 hashes = '-'.join( str(hash(x)) for x in args +
 484                                 tuple(kwargs.items()) )
 485                 fname = 'blitiri.%s.%s.cache' % (f.__name__, hashes)
 486                 cache_file = os.path.join(cache_path, fname)
 487                 try:
 488                         s = open(cache_file).read()
 489                 except:
 490                         s = f(*args, **kwargs)
 491                         open(cache_file, 'w').write(s)
 492                 return s
 493
 494         return decorate
 495
 496
 497 # helper functions
 498 @cached
 499 def rst_to_html(rst, secure = True):
 500         settings = {
 501                 'input_encoding': encoding,
 502                 'output_encoding': 'utf8',
 503                 'halt_level': 1,
 504                 'traceback':  1,
 505                 'file_insertion_enabled': secure,
 506                 'raw_enabled': secure,
 507         }
 508         parts = publish_parts(rst, settings_overrides = settings,
 509                                 writer_name = "html")
 510         return parts['body'].encode('utf8')
 511
 512 def validate_rst(rst, secure = True):
 513         try:
 514                 rst_to_html(rst, secure)
 515                 return None
 516         except SystemMessage, e:
 517                 desc = e.args[0].encode('utf-8') # the error string
 518                 desc = desc[9:] # remove "<string>:"
 519                 line = int(desc[:desc.find(':')] or 0) # get the line number
 520                 desc = desc[desc.find(')')+2:-1] # remove (LEVEL/N)
 521                 try:
 522                         desc, context = desc.split('\n', 1)
 523                 except ValueError:
 524                         context = ''
 525                 if desc.endswith('.'):
 526                         desc = desc[:-1]
 527                 return (line, desc, context)
 528
 529 def valid_link(link):
 530         import re
 531         scheme_re = r'^[a-zA-Z]+:'
 532         mail_re = r"^[^ \t\n\r@<>()]+@[a-z0-9][a-z0-9\.\-_]*\.[a-z]+$"
 533         url_re = r'^(?:[a-z0-9\-]+|[a-z0-9][a-z0-9\-\.\_]*\.[a-z]+)' \
 534                         r'(?::[0-9]+)?(?:/.*)?$'
 535
 536         if re.match(scheme_re, link, re.I):
 537                 scheme, rest = link.split(':', 1)
 538                 # if we have an scheme and a rest, assume the link is valid
 539                 # and return it as-is; otherwise (having just the scheme) is
 540                 # invalid
 541                 if rest:
 542                         return link
 543                 return None
 544
 545         # at this point, we don't have a scheme; we will try to recognize some
 546         # common addresses (mail and http at the moment) and complete them to
 547         # form a valid link, if we fail we will just claim it's invalid
 548         if re.match(mail_re, link, re.I):
 549                 return 'mailto:' + link
 550         elif re.match(url_re, link, re.I):
 551                 return 'http://' + link
 552
 553         return None
 554
 555 def sanitize(obj):
 556         return cgi.escape(obj, quote = True)
 557
 558
 559 # find out our URL, needed for syndication
 560 try:
 561         n = os.environ['SERVER_NAME']
 562         p = os.environ['SERVER_PORT']
 563         s = os.environ['SCRIPT_NAME']
 564         if p == '80': p = ''
 565         else: p = ':' + p
 566         full_url = 'http://%s%s%s' % (n, p, s)
 567 except KeyError:
 568         full_url = 'Not needed'
 569
 570
 571 class Templates (object):
 572         def __init__(self, tpath, db, showyear = None):
 573                 self.tpath = tpath
 574                 self.db = db
 575                 now = datetime.datetime.now()
 576                 if not showyear:
 577                         showyear = now.year
 578
 579                 self.vars = {
 580                         'css_url': css_url,
 581                         'title': title,
 582                         'url': blog_url,
 583                         'fullurl': full_url,
 584                         'year': now.year,
 585                         'month': now.month,
 586                         'day': now.day,
 587                         'showyear': showyear,
 588                         'monthlinks': ' '.join(db.get_month_links(showyear)),
 589                         'yearlinks': ' '.join(db.get_year_links()),
 590                         'taglinks': ' '.join(db.get_tag_links()),
 591                 }
 592
 593         def get_template(self, page_name, default_template, extra_vars = None):
 594                 if extra_vars is None:
 595                         vars = self.vars
 596                 else:
 597                         vars = self.vars.copy()
 598                         vars.update(extra_vars)
 599
 600                 p = '%s/%s.html' % (self.tpath, page_name)
 601                 if os.path.isfile(p):
 602                         return open(p).read() % vars
 603                 return default_template % vars
 604
 605         def get_main_header(self):
 606                 return self.get_template('header', default_main_header)
 607
 608         def get_main_footer(self):
 609                 return self.get_template('footer', default_main_footer)
 610
 611         def get_article_header(self, article):
 612                 return self.get_template(
 613                         'art_header', default_article_header, article.to_vars())
 614
 615         def get_article_footer(self, article):
 616                 return self.get_template(
 617                         'art_footer', default_article_footer, article.to_vars())
 618
 619         def get_comment_header(self, comment):
 620                 vars = comment.to_vars()
 621                 if comment.link:
 622                         vars['linked_author'] = '<a href="%s">%s</a>' \
 623                                         % (vars['link'], vars['author'])
 624                 else:
 625                         vars['linked_author'] = vars['author']
 626                 return self.get_template(
 627                         'com_header', default_comment_header, vars)
 628
 629         def get_comment_footer(self, comment):
 630                 return self.get_template(
 631                         'com_footer', default_comment_footer, comment.to_vars())
 632
 633         def get_comment_form(self, article, form_data, captcha_puzzle):
 634                 vars = article.to_vars()
 635                 vars.update(form_data.to_vars(self))
 636                 vars['captcha_puzzle'] = captcha_puzzle
 637                 return self.get_template(
 638                         'com_form', default_comment_form, vars)
 639
 640         def get_comment_error(self, error):
 641                 return self.get_template(
 642                         'com_error', default_comment_error, dict(error=error))
 643
 644
 645 class CommentFormData (object):
 646         def __init__(self, author = '', link = '', captcha = '', body = ''):
 647                 self.author = author
 648                 self.link = link
 649                 self.captcha = captcha
 650                 self.body = body
 651                 self.author_error = ''
 652                 self.link_error = ''
 653                 self.captcha_error = ''
 654                 self.body_error = ''
 655                 self.action = ''
 656                 self.method = 'post'
 657
 658         def to_vars(self, template):
 659                 render_error = template.get_comment_error
 660                 a_error = self.author_error and render_error(self.author_error)
 661                 l_error = self.link_error and render_error(self.link_error)
 662                 c_error = self.captcha_error \
 663                                 and render_error(self.captcha_error)
 664                 b_error = self.body_error and render_error(self.body_error)
 665                 return {
 666                         'form_author': sanitize(self.author),
 667                         'form_link': sanitize(self.link),
 668                         'form_captcha': sanitize(self.captcha),
 669                         'form_body': sanitize(self.body),
 670
 671                         'form_author_error': a_error,
 672                         'form_link_error': l_error,
 673                         'form_captcha_error': c_error,
 674                         'form_body_error': b_error,
 675
 676                         'form_action': self.action,
 677                         'form_method': self.method,
 678                 }
 679
 680
 681 class Comment (object):
 682         def __init__(self, article, number, created = None):
 683                 self.article = article
 684                 self.number = number
 685                 if created is None:
 686                         self.created = datetime.datetime.now()
 687                 else:
 688                         self.created = created
 689
 690                 self.loaded = False
 691
 692                 # loaded on demand
 693                 self._author = author
 694                 self._link = ''
 695                 self._raw_content = 'Removed comment'
 696
 697         @property
 698         def author(self):
 699                 if not self.loaded:
 700                         self.load()
 701                 return self._author
 702
 703         @property
 704         def link(self):
 705                 if not self.loaded:
 706                         self.load()
 707                 return self._link
 708
 709         @property
 710         def raw_content(self):
 711                 if not self.loaded:
 712                         self.load()
 713                 return self._raw_content
 714
 715         def set(self, author, raw_content, link = '', created = None):
 716                 self.loaded = True
 717                 self._author = author
 718                 self._raw_content = raw_content
 719                 self._link = link
 720                 self.created = created or datetime.datetime.now()
 721
 722
 723         def load(self):
 724                 filename = os.path.join(comments_path, self.article.uuid,
 725                                         str(self.number))
 726                 try:
 727                         raw = open(filename).readlines()
 728                 except:
 729                         return
 730
 731                 count = 0
 732                 for l in raw:
 733                         if ':' in l:
 734                                 name, value = l.split(':', 1)
 735                                 if name.lower() == 'author':
 736                                         self._author = value.strip()
 737                                 elif name.lower() == 'link':
 738                                         self._link = value.strip()
 739                         elif l == '\n':
 740                                 # end of header
 741                                 break
 742                         count += 1
 743                 self._raw_content = ''.join(raw[count + 1:])
 744                 self.loaded = True
 745
 746         def save(self):
 747                 filename = os.path.join(comments_path, self.article.uuid,
 748                                         str(self.number))
 749                 try:
 750                         f = open(filename, 'w')
 751                         f.write('Author: %s\n' % self.author)
 752                         f.write('Link: %s\n' % self.link)
 753                         f.write('\n')
 754                         f.write(self.raw_content)
 755                 except:
 756                         return
 757
 758
 759         def to_html(self):
 760                 return rst_to_html(self.raw_content)
 761
 762         def to_vars(self):
 763                 return {
 764                         'number': self.number,
 765                         'author': sanitize(self.author),
 766                         'link': sanitize(self.link),
 767                         'date': self.created.isoformat(' '),
 768                         'created': self.created.isoformat(' '),
 769
 770                         'year': self.created.year,
 771                         'month': self.created.month,
 772                         'day': self.created.day,
 773                         'hour': self.created.hour,
 774                         'minute': self.created.minute,
 775                         'second': self.created.second,
 776                 }
 777
 778 class CommentDB (object):
 779         def __init__(self, article):
 780                 self.path = os.path.join(comments_path, article.uuid)
 781                 # if comments were enabled after the article was added, we
 782                 # will need to create the directory
 783                 if not os.path.exists(self.path):
 784                         os.mkdir(self.path, 0777)
 785
 786                 self.comments = []
 787                 self.load(article)
 788
 789         def load(self, article):
 790                 try:
 791                         f = open(os.path.join(self.path, 'db'))
 792                 except:
 793                         return
 794
 795                 for l in f:
 796                         # Each line has the following comma separated format:
 797                         # number, created (epoch)
 798                         # Empty lines are meaningful and represent removed
 799                         # comments (so we can preserve the comment number)
 800                         l = l.split(',')
 801                         try:
 802                                 n = int(l[0])
 803                                 d = datetime.datetime.fromtimestamp(float(l[1]))
 804                         except:
 805                                 # Removed/invalid comment
 806                                 self.comments.append(None)
 807                                 continue
 808                         self.comments.append(Comment(article, n, d))
 809
 810         def save(self):
 811                 old_db = os.path.join(self.path, 'db')
 812                 new_db = os.path.join(self.path, 'db.tmp')
 813                 f = open(new_db, 'w')
 814                 for c in self.comments:
 815                         s = ''
 816                         if c is not None:
 817                                 s = ''
 818                                 s += str(c.number) + ', '
 819                                 s += str(time.mktime(c.created.timetuple()))
 820                         s += '\n'
 821                         f.write(s)
 822                 f.close()
 823                 os.rename(new_db, old_db)
 824
 825
 826 class Article (object):
 827         def __init__(self, path, created = None, updated = None):
 828                 self.path = path
 829                 self.created = created
 830                 self.updated = updated
 831                 self.uuid = "%08x" % zlib.crc32(self.path)
 832
 833                 self.loaded = False
 834
 835                 # loaded on demand
 836                 self._title = 'Removed post'
 837                 self._author = author
 838                 self._tags = []
 839                 self._raw_content = ''
 840                 self._comments = []
 841
 842         @property
 843         def title(self):
 844                 if not self.loaded:
 845                         self.load()
 846                 return self._title
 847
 848         @property
 849         def author(self):
 850                 if not self.loaded:
 851                         self.load()
 852                 return self._author
 853
 854         @property
 855         def tags(self):
 856                 if not self.loaded:
 857                         self.load()
 858                 return self._tags
 859
 860         @property
 861         def raw_content(self):
 862                 if not self.loaded:
 863                         self.load()
 864                 return self._raw_content
 865
 866         @property
 867         def comments(self):
 868                 if not self.loaded:
 869                         self.load()
 870                 return self._comments
 871
 872
 873         def __eq__(self, other):
 874                 if self.path == other.path:
 875                         return True
 876                 return False
 877
 878
 879         def add_comment(self, author, raw_content, link = ''):
 880                 c = Comment(self, len(self.comments))
 881                 c.set(author, raw_content, link)
 882                 self.comments.append(c)
 883                 return c
 884
 885
 886         def load(self):
 887                 # XXX this tweak is only needed for old DB format, where
 888                 # article's paths started with a slash
 889                 path = self.path
 890                 if path.startswith('/'):
 891                         path = path[1:]
 892                 filename = os.path.join(data_path, path)
 893                 try:
 894                         raw = open(filename).readlines()
 895                 except:
 896                         return
 897
 898                 count = 0
 899                 for l in raw:
 900                         if ':' in l:
 901                                 name, value = l.split(':', 1)
 902                                 if name.lower() == 'title':
 903                                         self._title = value.strip()
 904                                 elif name.lower() == 'author':
 905                                         self._author = value.strip()
 906                                 elif name.lower() == 'tags':
 907                                         ts = value.split(',')
 908                                         ts = [t.strip() for t in ts]
 909                                         self._tags = set(ts)
 910                         elif l == '\n':
 911                                 # end of header
 912                                 break
 913                         count += 1
 914                 self._raw_content = ''.join(raw[count + 1:])
 915                 db = CommentDB(self)
 916                 self._comments = db.comments
 917                 self.loaded = True
 918
 919         def to_html(self):
 920                 dirname = os.path.dirname
 921                 post_url = '/'.join(dirname(full_url), data_path, dirname(self.path))
 922                 rst = self.raw_content.replace('##POST_URL##', post_url)
 923                 return rst_to_html(rst)
 924
 925         def to_vars(self):
 926                 return {
 927                         'arttitle': sanitize(self.title),
 928                         'author': sanitize(self.author),
 929                         'date': self.created.isoformat(' '),
 930                         'uuid': self.uuid,
 931                         'tags': self.get_tags_links(),
 932                         'comments': len(self.comments),
 933
 934                         'created': self.created.isoformat(' '),
 935                         'ciso': self.created.isoformat(),
 936                         'cyear': self.created.year,
 937                         'cmonth': self.created.month,
 938                         'cday': self.created.day,
 939                         'chour': self.created.hour,
 940                         'cminute': self.created.minute,
 941                         'csecond': self.created.second,
 942
 943                         'updated': self.updated.isoformat(' '),
 944                         'uiso': self.updated.isoformat(),
 945                         'uyear': self.updated.year,
 946                         'umonth': self.updated.month,
 947                         'uday': self.updated.day,
 948                         'uhour': self.updated.hour,
 949                         'uminute': self.updated.minute,
 950                         'usecond': self.updated.second,
 951                 }
 952
 953         def get_tags_links(self):
 954                 l = []
 955                 tags = list(self.tags)
 956                 tags.sort()
 957                 for t in tags:
 958                         l.append('<a class="tag" href="%s/tag/%s">%s</a>' % \
 959                                 (blog_url, urllib.quote(t), sanitize(t) ))
 960                 return ', '.join(l)
 961
 962
 963 class ArticleDB (object):
 964         def __init__(self, dbpath):
 965                 self.dbpath = dbpath
 966                 self.articles = []
 967                 self.uuids = {}
 968                 self.actyears = set()
 969                 self.actmonths = set()
 970                 self.acttags = set()
 971                 self.load()
 972
 973         def get_articles(self, year = 0, month = 0, day = 0, tags = None):
 974                 l = []
 975                 for a in self.articles:
 976                         if year and a.created.year != year: continue
 977                         if month and a.created.month != month: continue
 978                         if day and a.created.day != day: continue
 979                         if tags and not tags.issubset(a.tags): continue
 980
 981                         l.append(a)
 982
 983                 return l
 984
 985         def get_article(self, uuid):
 986                 return self.uuids[uuid]
 987
 988         def load(self):
 989                 try:
 990                         f = open(self.dbpath)
 991                 except:
 992                         return
 993
 994                 for l in f:
 995                         # Each line has the following comma separated format:
 996                         # path (relative to data_path), \
 997                         #       created (epoch), \
 998                         #       updated (epoch)
 999                         try:
1000                                 l = l.split(',')
1001                         except:
1002                                 continue
1003
1004                         a = Article(l[0],
1005                                 datetime.datetime.fromtimestamp(float(l[1])),
1006                                 datetime.datetime.fromtimestamp(float(l[2])))
1007                         self.uuids[a.uuid] = a
1008                         self.acttags.update(a.tags)
1009                         self.actyears.add(a.created.year)
1010                         self.actmonths.add((a.created.year, a.created.month))
1011                         self.articles.append(a)
1012
1013         def save(self):
1014                 f = open(self.dbpath + '.tmp', 'w')
1015                 for a in self.articles:
1016                         s = ''
1017                         s += a.path + ', '
1018                         s += str(time.mktime(a.created.timetuple())) + ', '
1019                         s += str(time.mktime(a.updated.timetuple())) + '\n'
1020                         f.write(s)
1021                 f.close()
1022                 os.rename(self.dbpath + '.tmp', self.dbpath)
1023
1024         def get_year_links(self):
1025                 yl = list(self.actyears)
1026                 yl.sort(reverse = True)
1027                 return [ '<a href="%s/%d/">%d</a>' % (blog_url, y, y)
1028                                 for y in yl ]
1029
1030         def get_month_links(self, year):
1031                 am = [ i[1] for i in self.actmonths if i[0] == year ]
1032                 ml = []
1033                 for i in range(1, 13):
1034                         name = calendar.month_name[i][:3]
1035                         if i in am:
1036                                 s = '<a href="%s/%d/%d/">%s</a>' % \
1037                                         ( blog_url, year, i, name )
1038                         else:
1039                                 s = name
1040                         ml.append(s)
1041                 return ml
1042
1043         def get_tag_links(self):
1044                 tl = list(self.acttags)
1045                 tl.sort()
1046                 return [ '<a href="%s/tag/%s">%s</a>' % (blog_url,
1047                                 sanitize(t), sanitize(t)) for t in tl ]
1048
1049 #
1050 # Main
1051 #
1052
1053 def render_comments(article, template, form_data):
1054         print '<a name="comments" />'
1055         for c in article.comments:
1056                 if c is None:
1057                         continue
1058                 print template.get_comment_header(c)
1059                 print c.to_html()
1060                 print template.get_comment_footer(c)
1061         if not form_data:
1062                 form_data = CommentFormData()
1063         form_data.action = blog_url + '/comment/' + article.uuid + '#comment'
1064         captcha = captcha_method(article)
1065         print template.get_comment_form(article, form_data, captcha.puzzle)
1066
1067 def render_html(articles, db, actyear = None, show_comments = False,
1068                 redirect =  None, form_data = None):
1069         if redirect:
1070                 print 'Status: 303 See Other\r\n',
1071                 print 'Location: %s\r\n' % redirect,
1072         print 'Content-type: text/html; charset=utf-8\r\n',
1073         print '\r\n',
1074         template = Templates(templates_path, db, actyear)
1075         print template.get_main_header()
1076         for a in articles:
1077                 print template.get_article_header(a)
1078                 print a.to_html()
1079                 print template.get_article_footer(a)
1080                 if show_comments:
1081                         render_comments(a, template, form_data)
1082         print template.get_main_footer()
1083
1084 def render_artlist(articles, db, actyear = None):
1085         template = Templates(templates_path, db, actyear)
1086         print 'Content-type: text/html; charset=utf-8\n'
1087         print template.get_main_header()
1088         print '<h2>Articles</h2>'
1089         for a in articles:
1090                 print '<li><a href="%(url)s/post/%(uuid)s">%(title)s</a></li>' \
1091                         % {     'url': blog_url,
1092                                 'uuid': a.uuid,
1093                                 'title': a.title,
1094                                 'author': a.author,
1095                         }
1096         print template.get_main_footer()
1097
1098 def render_atom(articles):
1099         if len(articles) > 0:
1100                 updated = articles[0].updated.isoformat()
1101         else:
1102                 updated = datetime.datetime.now().isoformat()
1103
1104         print 'Content-type: application/atom+xml; charset=utf-8\n'
1105         print """<?xml version="1.0" encoding="utf-8"?>
1106
1107 <feed xmlns="http://www.w3.org/2005/Atom">
1108  <title>%(title)s</title>
1109  <link rel="alternate" type="text/html" href="%(url)s"/>
1110  <link rel="self" type="application/atom+xml" href="%(url)s/atom"/>
1111  <id>%(url)s</id> <!-- TODO: find a better <id>, see RFC 4151 -->
1112  <updated>%(updated)sZ</updated>
1113
1114         """ % {
1115                 'title': title,
1116                 'url': full_url,
1117                 'updated': updated,
1118         }
1119
1120         for a in articles:
1121                 vars = a.to_vars()
1122                 vars.update( {
1123                         'url': full_url,
1124                         'contents': a.to_html(),
1125                 } )
1126                 print """
1127   <entry>
1128     <title>%(arttitle)s</title>
1129     <author><name>%(author)s</name></author>
1130     <link href="%(url)s/post/%(uuid)s" />
1131     <id>%(url)s/post/%(uuid)s</id>
1132     <summary>%(arttitle)s</summary>
1133     <published>%(ciso)sZ</published>
1134     <updated>%(uiso)sZ</updated>
1135     <content type="xhtml">
1136       <div xmlns="http://www.w3.org/1999/xhtml">
1137 %(contents)s
1138       </div>
1139     </content>
1140   </entry>
1141                 """ % vars
1142         print "</feed>"
1143
1144
1145 def render_style():
1146         print 'Content-type: text/css\r\n\r\n',
1147         print default_css
1148
1149 # Get a dictionary with sort() arguments (key and reverse) by parsing the sort
1150 # specification format:
1151 # [+-]?<key>?
1152 # Where "-" is used to specify reverse order, while "+" is regular, ascending,
1153 # order (reverse = False). The key value is an Article's attribute name (title,
1154 # author, created, updated and uuid are accepted), and will be used as key for
1155 # sorting. If a value is omitted, that value is taken from the default, which
1156 # should be provided using the same format specification, with the difference
1157 # that all values must be provided for the default.
1158 def get_sort_args(sort_str, default):
1159         def parse(s):
1160                 d = dict()
1161                 if not s:
1162                         return d
1163                 key = None
1164                 if len(s) > 0:
1165                         # accept ' ' as an alias of '+' since '+' is translated
1166                         # to ' ' in URLs
1167                         if s[0] in ('+', ' ', '-'):
1168                                 key = s[1:]
1169                                 d['reverse'] = (s[0] == '-')
1170                         else:
1171                                 key = s
1172                 if key in ('title', 'author', 'created', 'updated', 'uuid'):
1173                         d['key'] = lambda a: getattr(a, key)
1174                 return d
1175         args = parse(default)
1176         assert args['key'] is not None and args['reverse'] is not None
1177         args.update(parse(sort_str))
1178         return args
1179
1180 def handle_cgi():
1181         import cgitb; cgitb.enable()
1182
1183         form = cgi.FieldStorage()
1184         year = int(form.getfirst("year", 0))
1185         month = int(form.getfirst("month", 0))
1186         day = int(form.getfirst("day", 0))
1187         tags = set(form.getlist("tag"))
1188         sort_str = form.getfirst("sort", None)
1189         uuid = None
1190         atom = False
1191         style = False
1192         post = False
1193         post_preview = False
1194         artlist = False
1195         comment = False
1196
1197         if os.environ.has_key('PATH_INFO'):
1198                 path_info = os.environ['PATH_INFO']
1199                 style = path_info == '/style'
1200                 atom = path_info == '/atom'
1201                 tag = path_info.startswith('/tag/')
1202                 post = path_info.startswith('/post/')
1203                 post_preview = path_info.startswith('/preview/post/')
1204                 artlist = path_info.startswith('/list')
1205                 comment = path_info.startswith('/comment/') and enable_comments
1206                 if not style and not atom and not post and not post_preview \
1207                                 and not tag and not comment and not artlist:
1208                         date = path_info.split('/')[1:]
1209                         try:
1210                                 if len(date) > 1 and date[0]:
1211                                         year = int(date[0])
1212                                 if len(date) > 2 and date[1]:
1213                                         month = int(date[1])
1214                                 if len(date) > 3 and date[2]:
1215                                         day = int(date[2])
1216                         except ValueError:
1217                                 pass
1218                 elif post:
1219                         uuid = path_info.replace('/post/', '')
1220                         uuid = uuid.replace('/', '')
1221                 elif post_preview:
1222                         art_path = path_info.replace('/preview/post/', '')
1223                         art_path = urllib.unquote_plus(art_path)
1224                         art_path = os.path.join(data_path, art_path)
1225                         art_path = os.path.realpath(art_path)
1226                         common = os.path.commonprefix([data_path, art_path])
1227                         if common != data_path: # something nasty happened
1228                                 post_preview = False
1229                         art_path = art_path[len(data_path)+1:]
1230                 elif tag:
1231                         t = path_info.replace('/tag/', '')
1232                         t = t.replace('/', '')
1233                         t = urllib.unquote_plus(t)
1234                         tags = set((t,))
1235                 elif comment:
1236                         uuid = path_info.replace('/comment/', '')
1237                         uuid = uuid.replace('#comment', '')
1238                         uuid = uuid.replace('/', '')
1239                         author = form.getfirst('comformauthor', '')
1240                         link = form.getfirst('comformlink', '')
1241                         captcha = form.getfirst('comformcaptcha', '')
1242                         body = form.getfirst('comformbody', '')
1243
1244         db = ArticleDB(os.path.join(data_path, 'db'))
1245         if atom:
1246                 articles = db.get_articles(tags = tags)
1247                 articles.sort(**get_sort_args(sort_str, '-created'))
1248                 render_atom(articles[:index_articles])
1249         elif style:
1250                 render_style()
1251         elif post:
1252                 render_html( [db.get_article(uuid)], db, year, enable_comments )
1253         elif post_preview:
1254                 article = Article(art_path, datetime.datetime.now(),
1255                                         datetime.datetime.now())
1256                 render_html( [article], db, year, enable_comments )
1257         elif artlist:
1258                 articles = db.get_articles()
1259                 articles.sort(**get_sort_args(sort_str, '+title'))
1260                 render_artlist(articles, db)
1261         elif comment and enable_comments:
1262                 form_data = CommentFormData(author.strip().replace('\n', ' '),
1263                                 link.strip().replace('\n', ' '), captcha,
1264                                 body.replace('\r', ''))
1265                 article = db.get_article(uuid)
1266                 captcha = captcha_method(article)
1267                 redirect = False
1268                 valid = True
1269                 if not form_data.author:
1270                         form_data.author_error = 'please, enter your name'
1271                         valid = False
1272                 if form_data.link:
1273                         link = valid_link(form_data.link)
1274                         if link:
1275                                 form_data.link = link
1276                         else:
1277                                 form_data.link_error = 'please, enter a ' \
1278                                                 'valid link'
1279                                 valid = False
1280                 if not captcha.validate(form_data):
1281                         form_data.captcha_error = captcha.help
1282                         valid = False
1283                 if not form_data.body:
1284                         form_data.body_error = 'please, write a comment'
1285                         valid = False
1286                 else:
1287                         error = validate_rst(form_data.body, secure=False)
1288                         if error is not None:
1289                                 (line, desc, ctx) = error
1290                                 at = ''
1291                                 if line:
1292                                         at = ' at line %d' % line
1293                                 form_data.body_error = 'error%s: %s' \
1294                                                 % (at, desc)
1295                                 valid = False
1296                 if valid:
1297                         c = article.add_comment(form_data.author,
1298                                         form_data.body, form_data.link)
1299                         c.save()
1300                         cdb = CommentDB(article)
1301                         cdb.comments = article.comments
1302                         cdb.save()
1303                         redirect = blog_url + '/post/' + uuid + '#comment-' \
1304                                         + str(c.number)
1305                 render_html( [article], db, year, enable_comments, redirect,
1306                                 form_data )
1307         else:
1308                 articles = db.get_articles(year, month, day, tags)
1309                 articles.sort(**get_sort_args(sort_str, '-created'))
1310                 if not year and not month and not day and not tags:
1311                         articles = articles[:index_articles]
1312                 render_html(articles, db, year)
1313
1314
1315 def usage():
1316         print 'Usage: %s {add|rm|update} article_path' % sys.argv[0]
1317
1318 def handle_cmd():
1319         if len(sys.argv) != 3:
1320                 usage()
1321                 return 1
1322
1323         cmd = sys.argv[1]
1324         art_path = os.path.realpath(sys.argv[2])
1325
1326         if os.path.commonprefix([data_path, art_path]) != data_path:
1327                 print "Error: article (%s) must be inside data_path (%s)" % \
1328                                 (art_path, data_path)
1329                 return 1
1330         art_path = art_path[len(data_path)+1:]
1331
1332         db_filename = os.path.join(data_path, 'db')
1333         if not os.path.isfile(db_filename):
1334                 open(db_filename, 'w').write('')
1335         db = ArticleDB(db_filename)
1336
1337         if cmd == 'add':
1338                 article = Article(art_path, datetime.datetime.now(),
1339                                         datetime.datetime.now())
1340                 for a in db.articles:
1341                         if a == article:
1342                                 print 'Error: article already exists'
1343                                 return 1
1344                 db.articles.append(article)
1345                 db.save()
1346                 if enable_comments:
1347                         comment_dir = os.path.join(comments_path, article.uuid)
1348                         try:
1349                                 os.mkdir(comment_dir, 0775)
1350                         except OSError, e:
1351                                 if e.errno != errno.EEXIST:
1352                                         print "Error: can't create comments " \
1353                                                 "directory %s (%s)" \
1354                                                         % (comment_dir, e)
1355                                 # otherwise is probably a removed and re-added
1356                                 # article
1357         elif cmd == 'rm':
1358                 article = Article(art_path)
1359                 for a in db.articles:
1360                         if a == article:
1361                                 break
1362                 else:
1363                         print "Error: no such article"
1364                         return 1
1365                 if enable_comments:
1366                         r = raw_input('Remove comments [y/N]? ')
1367                 db.articles.remove(a)
1368                 db.save()
1369                 if enable_comments and r.lower() == 'y':
1370                         shutil.rmtree(os.path.join(comments_path, a.uuid))
1371         elif cmd == 'update':
1372                 article = Article(art_path)
1373                 for a in db.articles:
1374                         if a == article:
1375                                 break
1376                 else:
1377                         print "Error: no such article"
1378                         return 1
1379                 a.updated = datetime.datetime.now()
1380                 db.save()
1381         else:
1382                 usage()
1383                 return 1
1384
1385         return 0
1386
1387
1388 if os.environ.has_key('GATEWAY_INTERFACE'):
1389         i = datetime.datetime.now()
1390         handle_cgi()
1391         f = datetime.datetime.now()
1392         print '<!-- render time: %s -->' % (f-i)
1393 else:
1394         sys.exit(handle_cmd())
1395
1396