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