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, 0755)
 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         def __cmp__(self, other):
 873                 if self.path == other.path:
 874                         return 0
 875                 if not self.created:
 876                         return 1
 877                 if not other.created:
 878                         return -1
 879                 if self.created < other.created:
 880                         return -1
 881                 return 1
 882
 883         def title_cmp(self, other):
 884                 return cmp(self.title, other.title)
 885
 886
 887         def add_comment(self, author, raw_content, link = ''):
 888                 c = Comment(self, len(self.comments))
 889                 c.set(author, raw_content, link)
 890                 self.comments.append(c)
 891                 return c
 892
 893
 894         def load(self):
 895                 # XXX this tweak is only needed for old DB format, where
 896                 # article's paths started with a slash
 897                 path = self.path
 898                 if path.startswith('/'):
 899                         path = path[1:]
 900                 filename = os.path.join(data_path, path)
 901                 try:
 902                         raw = open(filename).readlines()
 903                 except:
 904                         return
 905
 906                 count = 0
 907                 for l in raw:
 908                         if ':' in l:
 909                                 name, value = l.split(':', 1)
 910                                 if name.lower() == 'title':
 911                                         self._title = value.strip()
 912                                 elif name.lower() == 'author':
 913                                         self._author = value.strip()
 914                                 elif name.lower() == 'tags':
 915                                         ts = value.split(',')
 916                                         ts = [t.strip() for t in ts]
 917                                         self._tags = set(ts)
 918                         elif l == '\n':
 919                                 # end of header
 920                                 break
 921                         count += 1
 922                 self._raw_content = ''.join(raw[count + 1:])
 923                 db = CommentDB(self)
 924                 self._comments = db.comments
 925                 self.loaded = True
 926
 927         def to_html(self):
 928                 return rst_to_html(self.raw_content)
 929
 930         def to_vars(self):
 931                 return {
 932                         'arttitle': sanitize(self.title),
 933                         'author': sanitize(self.author),
 934                         'date': self.created.isoformat(' '),
 935                         'uuid': self.uuid,
 936                         'tags': self.get_tags_links(),
 937                         'comments': len(self.comments),
 938
 939                         'created': self.created.isoformat(' '),
 940                         'ciso': self.created.isoformat(),
 941                         'cyear': self.created.year,
 942                         'cmonth': self.created.month,
 943                         'cday': self.created.day,
 944                         'chour': self.created.hour,
 945                         'cminute': self.created.minute,
 946                         'csecond': self.created.second,
 947
 948                         'updated': self.updated.isoformat(' '),
 949                         'uiso': self.updated.isoformat(),
 950                         'uyear': self.updated.year,
 951                         'umonth': self.updated.month,
 952                         'uday': self.updated.day,
 953                         'uhour': self.updated.hour,
 954                         'uminute': self.updated.minute,
 955                         'usecond': self.updated.second,
 956                 }
 957
 958         def get_tags_links(self):
 959                 l = []
 960                 tags = list(self.tags)
 961                 tags.sort()
 962                 for t in tags:
 963                         l.append('<a class="tag" href="%s/tag/%s">%s</a>' % \
 964                                 (blog_url, urllib.quote(t), sanitize(t) ))
 965                 return ', '.join(l)
 966
 967
 968 class ArticleDB (object):
 969         def __init__(self, dbpath):
 970                 self.dbpath = dbpath
 971                 self.articles = []
 972                 self.uuids = {}
 973                 self.actyears = set()
 974                 self.actmonths = set()
 975                 self.acttags = set()
 976                 self.load()
 977
 978         def get_articles(self, year = 0, month = 0, day = 0, tags = None):
 979                 l = []
 980                 for a in self.articles:
 981                         if year and a.created.year != year: continue
 982                         if month and a.created.month != month: continue
 983                         if day and a.created.day != day: continue
 984                         if tags and not tags.issubset(a.tags): continue
 985
 986                         l.append(a)
 987
 988                 return l
 989
 990         def get_article(self, uuid):
 991                 return self.uuids[uuid]
 992
 993         def load(self):
 994                 try:
 995                         f = open(self.dbpath)
 996                 except:
 997                         return
 998
 999                 for l in f:
1000                         # Each line has the following comma separated format:
1001                         # path (relative to data_path), \
1002                         #       created (epoch), \
1003                         #       updated (epoch)
1004                         try:
1005                                 l = l.split(',')
1006                         except:
1007                                 continue
1008
1009                         a = Article(l[0],
1010                                 datetime.datetime.fromtimestamp(float(l[1])),
1011                                 datetime.datetime.fromtimestamp(float(l[2])))
1012                         self.uuids[a.uuid] = a
1013                         self.acttags.update(a.tags)
1014                         self.actyears.add(a.created.year)
1015                         self.actmonths.add((a.created.year, a.created.month))
1016                         self.articles.append(a)
1017
1018         def save(self):
1019                 f = open(self.dbpath + '.tmp', 'w')
1020                 for a in self.articles:
1021                         s = ''
1022                         s += a.path + ', '
1023                         s += str(time.mktime(a.created.timetuple())) + ', '
1024                         s += str(time.mktime(a.updated.timetuple())) + '\n'
1025                         f.write(s)
1026                 f.close()
1027                 os.rename(self.dbpath + '.tmp', self.dbpath)
1028
1029         def get_year_links(self):
1030                 yl = list(self.actyears)
1031                 yl.sort(reverse = True)
1032                 return [ '<a href="%s/%d/">%d</a>' % (blog_url, y, y)
1033                                 for y in yl ]
1034
1035         def get_month_links(self, year):
1036                 am = [ i[1] for i in self.actmonths if i[0] == year ]
1037                 ml = []
1038                 for i in range(1, 13):
1039                         name = calendar.month_name[i][:3]
1040                         if i in am:
1041                                 s = '<a href="%s/%d/%d/">%s</a>' % \
1042                                         ( blog_url, year, i, name )
1043                         else:
1044                                 s = name
1045                         ml.append(s)
1046                 return ml
1047
1048         def get_tag_links(self):
1049                 tl = list(self.acttags)
1050                 tl.sort()
1051                 return [ '<a href="%s/tag/%s">%s</a>' % (blog_url,
1052                                 sanitize(t), sanitize(t)) for t in tl ]
1053
1054 #
1055 # Main
1056 #
1057
1058 def render_comments(article, template, form_data):
1059         print '<a name="comments" />'
1060         for c in article.comments:
1061                 if c is None:
1062                         continue
1063                 print template.get_comment_header(c)
1064                 print c.to_html()
1065                 print template.get_comment_footer(c)
1066         if not form_data:
1067                 form_data = CommentFormData()
1068         form_data.action = blog_url + '/comment/' + article.uuid + '#comment'
1069         captcha = captcha_method(article)
1070         print template.get_comment_form(article, form_data, captcha.puzzle)
1071
1072 def render_html(articles, db, actyear = None, show_comments = False,
1073                 redirect =  None, form_data = None):
1074         if redirect:
1075                 print 'Status: 303 See Other\r\n',
1076                 print 'Location: %s\r\n' % redirect,
1077         print 'Content-type: text/html; charset=utf-8\r\n',
1078         print '\r\n',
1079         template = Templates(templates_path, db, actyear)
1080         print template.get_main_header()
1081         for a in articles:
1082                 print template.get_article_header(a)
1083                 print a.to_html()
1084                 print template.get_article_footer(a)
1085                 if show_comments:
1086                         render_comments(a, template, form_data)
1087         print template.get_main_footer()
1088
1089 def render_artlist(articles, db, actyear = None):
1090         template = Templates(templates_path, db, actyear)
1091         print 'Content-type: text/html; charset=utf-8\n'
1092         print template.get_main_header()
1093         print '<h2>Articles</h2>'
1094         for a in articles:
1095                 print '<li><a href="%(url)s/post/%(uuid)s">%(title)s</a></li>' \
1096                         % {     'url': blog_url,
1097                                 'uuid': a.uuid,
1098                                 'title': a.title,
1099                                 'author': a.author,
1100                         }
1101         print template.get_main_footer()
1102
1103 def render_atom(articles):
1104         if len(articles) > 0:
1105                 updated = articles[0].updated.isoformat()
1106         else:
1107                 updated = datetime.datetime.now().isoformat()
1108
1109         print 'Content-type: application/atom+xml; charset=utf-8\n'
1110         print """<?xml version="1.0" encoding="utf-8"?>
1111
1112 <feed xmlns="http://www.w3.org/2005/Atom">
1113  <title>%(title)s</title>
1114  <link rel="alternate" type="text/html" href="%(url)s"/>
1115  <link rel="self" type="application/atom+xml" href="%(url)s/atom"/>
1116  <id>%(url)s</id> <!-- TODO: find a better <id>, see RFC 4151 -->
1117  <updated>%(updated)sZ</updated>
1118
1119         """ % {
1120                 'title': title,
1121                 'url': full_url,
1122                 'updated': updated,
1123         }
1124
1125         for a in articles:
1126                 vars = a.to_vars()
1127                 vars.update( {
1128                         'url': full_url,
1129                         'contents': a.to_html(),
1130                 } )
1131                 print """
1132   <entry>
1133     <title>%(arttitle)s</title>
1134     <author><name>%(author)s</name></author>
1135     <link href="%(url)s/post/%(uuid)s" />
1136     <id>%(url)s/post/%(uuid)s</id>
1137     <summary>%(arttitle)s</summary>
1138     <published>%(ciso)sZ</published>
1139     <updated>%(uiso)sZ</updated>
1140     <content type="xhtml">
1141       <div xmlns="http://www.w3.org/1999/xhtml">
1142 %(contents)s
1143       </div>
1144     </content>
1145   </entry>
1146                 """ % vars
1147         print "</feed>"
1148
1149
1150 def render_style():
1151         print 'Content-type: text/css\r\n\r\n',
1152         print default_css
1153
1154 def handle_cgi():
1155         import cgitb; cgitb.enable()
1156
1157         form = cgi.FieldStorage()
1158         year = int(form.getfirst("year", 0))
1159         month = int(form.getfirst("month", 0))
1160         day = int(form.getfirst("day", 0))
1161         tags = set(form.getlist("tag"))
1162         uuid = None
1163         atom = False
1164         style = False
1165         post = False
1166         post_preview = False
1167         artlist = False
1168         comment = False
1169
1170         if os.environ.has_key('PATH_INFO'):
1171                 path_info = os.environ['PATH_INFO']
1172                 style = path_info == '/style'
1173                 atom = path_info == '/atom'
1174                 tag = path_info.startswith('/tag/')
1175                 post = path_info.startswith('/post/')
1176                 post_preview = path_info.startswith('/preview/post/')
1177                 artlist = path_info.startswith('/list')
1178                 comment = path_info.startswith('/comment/') and enable_comments
1179                 if not style and not atom and not post and not post_preview \
1180                                 and not tag and not comment and not artlist:
1181                         date = path_info.split('/')[1:]
1182                         try:
1183                                 if len(date) > 1 and date[0]:
1184                                         year = int(date[0])
1185                                 if len(date) > 2 and date[1]:
1186                                         month = int(date[1])
1187                                 if len(date) > 3 and date[2]:
1188                                         day = int(date[2])
1189                         except ValueError:
1190                                 pass
1191                 elif post:
1192                         uuid = path_info.replace('/post/', '')
1193                         uuid = uuid.replace('/', '')
1194                 elif post_preview:
1195                         art_path = path_info.replace('/preview/post/', '')
1196                         art_path = urllib.unquote_plus(art_path)
1197                         art_path = os.path.join(data_path, art_path)
1198                         art_path = os.path.realpath(art_path)
1199                         common = os.path.commonprefix([data_path, art_path])
1200                         if common != data_path: # something nasty happened
1201                                 post_preview = False
1202                         art_path = art_path[len(data_path)+1:]
1203                 elif tag:
1204                         t = path_info.replace('/tag/', '')
1205                         t = t.replace('/', '')
1206                         t = urllib.unquote_plus(t)
1207                         tags = set((t,))
1208                 elif comment:
1209                         uuid = path_info.replace('/comment/', '')
1210                         uuid = uuid.replace('#comment', '')
1211                         uuid = uuid.replace('/', '')
1212                         author = form.getfirst('comformauthor', '')
1213                         link = form.getfirst('comformlink', '')
1214                         captcha = form.getfirst('comformcaptcha', '')
1215                         body = form.getfirst('comformbody', '')
1216
1217         db = ArticleDB(os.path.join(data_path, 'db'))
1218         if atom:
1219                 articles = db.get_articles(tags = tags)
1220                 articles.sort(reverse = True)
1221                 render_atom(articles[:index_articles])
1222         elif style:
1223                 render_style()
1224         elif post:
1225                 render_html( [db.get_article(uuid)], db, year, enable_comments )
1226         elif post_preview:
1227                 article = Article(art_path, datetime.datetime.now(),
1228                                         datetime.datetime.now())
1229                 render_html( [article], db, year, enable_comments )
1230         elif artlist:
1231                 articles = db.get_articles()
1232                 articles.sort(cmp = Article.title_cmp)
1233                 render_artlist(articles, db)
1234         elif comment and enable_comments:
1235                 form_data = CommentFormData(author.strip().replace('\n', ' '),
1236                                 link.strip().replace('\n', ' '), captcha,
1237                                 body.replace('\r', ''))
1238                 article = db.get_article(uuid)
1239                 captcha = captcha_method(article)
1240                 redirect = False
1241                 valid = True
1242                 if not form_data.author:
1243                         form_data.author_error = 'please, enter your name'
1244                         valid = False
1245                 if form_data.link:
1246                         link = valid_link(form_data.link)
1247                         if link:
1248                                 form_data.link = link
1249                         else:
1250                                 form_data.link_error = 'please, enter a ' \
1251                                                 'valid link'
1252                                 valid = False
1253                 if not captcha.validate(form_data):
1254                         form_data.captcha_error = captcha.help
1255                         valid = False
1256                 if not form_data.body:
1257                         form_data.body_error = 'please, write a comment'
1258                         valid = False
1259                 else:
1260                         error = validate_rst(form_data.body, secure=False)
1261                         if error is not None:
1262                                 (line, desc, ctx) = error
1263                                 at = ''
1264                                 if line:
1265                                         at = ' at line %d' % line
1266                                 form_data.body_error = 'error%s: %s' \
1267                                                 % (at, desc)
1268                                 valid = False
1269                 if valid:
1270                         c = article.add_comment(form_data.author,
1271                                         form_data.body, form_data.link)
1272                         c.save()
1273                         cdb = CommentDB(article)
1274                         cdb.comments = article.comments
1275                         cdb.save()
1276                         redirect = blog_url + '/post/' + uuid + '#comment-' \
1277                                         + str(c.number)
1278                 render_html( [article], db, year, enable_comments, redirect,
1279                                 form_data )
1280         else:
1281                 articles = db.get_articles(year, month, day, tags)
1282                 articles.sort(reverse = True)
1283                 if not year and not month and not day and not tags:
1284                         articles = articles[:index_articles]
1285                 render_html(articles, db, year)
1286
1287
1288 def usage():
1289         print 'Usage: %s {add|rm|update} article_path' % sys.argv[0]
1290
1291 def handle_cmd():
1292         if len(sys.argv) != 3:
1293                 usage()
1294                 return 1
1295
1296         cmd = sys.argv[1]
1297         art_path = os.path.realpath(sys.argv[2])
1298
1299         if os.path.commonprefix([data_path, art_path]) != data_path:
1300                 print "Error: article (%s) must be inside data_path (%s)" % \
1301                                 (art_path, data_path)
1302                 return 1
1303         art_path = art_path[len(data_path)+1:]
1304
1305         db_filename = os.path.join(data_path, 'db')
1306         if not os.path.isfile(db_filename):
1307                 open(db_filename, 'w').write('')
1308         db = ArticleDB(db_filename)
1309
1310         if cmd == 'add':
1311                 article = Article(art_path, datetime.datetime.now(),
1312                                         datetime.datetime.now())
1313                 for a in db.articles:
1314                         if a == article:
1315                                 print 'Error: article already exists'
1316                                 return 1
1317                 db.articles.append(article)
1318                 db.save()
1319                 if enable_comments:
1320                         comment_dir = os.path.join(comments_path, article.uuid)
1321                         try:
1322                                 os.mkdir(comment_dir, 0775)
1323                         except OSError, e:
1324                                 if e.errno != errno.EEXIST:
1325                                         print "Error: can't create comments " \
1326                                                 "directory %s (%s)" \
1327                                                         % (comment_dir, e)
1328                                 # otherwise is probably a removed and re-added
1329                                 # article
1330         elif cmd == 'rm':
1331                 article = Article(art_path)
1332                 for a in db.articles:
1333                         if a == article:
1334                                 break
1335                 else:
1336                         print "Error: no such article"
1337                         return 1
1338                 if enable_comments:
1339                         r = raw_input('Remove comments [y/N]? ')
1340                 db.articles.remove(a)
1341                 db.save()
1342                 if enable_comments and r.lower() == 'y':
1343                         shutil.rmtree(os.path.join(comments_path, a.uuid))
1344         elif cmd == 'update':
1345                 article = Article(art_path)
1346                 for a in db.articles:
1347                         if a == article:
1348                                 break
1349                 else:
1350                         print "Error: no such article"
1351                         return 1
1352                 a.updated = datetime.datetime.now()
1353                 db.save()
1354         else:
1355                 usage()
1356                 return 1
1357
1358         return 0
1359
1360
1361 if os.environ.has_key('GATEWAY_INTERFACE'):
1362         i = datetime.datetime.now()
1363         handle_cgi()
1364         f = datetime.datetime.now()
1365         print '<!-- render time: %s -->' % (f-i)
1366 else:
1367         sys.exit(handle_cmd())
1368
1369