#!/usr/bin/env python

"""
darcsweb - A web interface for darcs
Alberto Bertogli (albertito@blitiri.com.ar)

Inspired on gitweb (as of 28/Jun/2005), which is written by Kay Sievers
<kay.sievers@vrfy.org> and Christian Gierke <ch@gierke.de>
"""

import time
time_begin = time.time()
import sys
import os
import string
import stat
import cgi
import cgitb; cgitb.enable()
import urllib
import xml.sax
from xml.sax.saxutils import escape as xml_escape
time_imports = time.time() - time_begin

iso_datetime = '%Y-%m-%dT%H:%M:%SZ'

PATCHES_PER_PAGE = 50

# In order to be able to store the config file in /etc/darcsweb, it has to be
# added to sys.path. It's mainly used by distributions, which place the
# default configuration there. Add it second place, so it goes after '.' but
# before the normal path. This allows per-directory config files (desirable
# for multiple darcsweb installations on the same machin), and avoids name
# clashing if there's a config.py in the standard path.
sys.path.insert(1, '/etc/darcsweb')

# Similarly, when hosting multiple darcsweb instrances on the same
# server, you can just 'SetEnv DARCSWEB_CONFPATH' in the httpd config,
# and this will have a bigger priority than the system-wide
# configuration file.
if 'DARCSWEB_CONFPATH' in os.environ:
	sys.path.insert(1, os.environ['DARCSWEB_CONFPATH'])

# empty configuration class, we will fill it in later depending on the repo
class config:
	pass

# list of run_darcs() invocations, for performance measures
darcs_runs = []

# exception handling
def exc_handle(t, v, tb):
	try:
		cache.cancel()
	except:
		pass
	cgitb.handler((t, v, tb))
sys.excepthook = exc_handle

#
# utility functions
#

def filter_num(s):
	l = [c for c in s if c in string.digits]
	return ''.join(l)


allowed_in_action = string.ascii_letters + string.digits + '_'
def filter_act(s):
	l = [c for c in s if c in allowed_in_action]
	return ''.join(l)


allowed_in_hash = string.ascii_letters + string.digits + '-.'
def filter_hash(s):
	l = [c for c in s if c in allowed_in_hash]
	return ''.join(l)


def filter_file(s):
	if '..' in s or '"' in s:
		raise Exception, 'FilterFile FAILED'
	if s == '/':
		return s

	# remove extra "/"s
	r = s[0]
	last = s[0]
	for c in s[1:]:
		if c == last and c == '/':
			continue
		r += c
		last = c
	return r


def printd(*params):
	print ' '.join(params), '<br/>'


# I _hate_ this.
def fixu8(s):
	"""Calls _fixu8(), which does the real work, line by line. Otherwise
	we choose the wrong encoding for big buffers and end up messing
	output."""
	n = []
	for i in s.split('\n'):
		n.append(_fixu8(i))
	return '\n'.join(n)

def _fixu8(s):
	if type(s) == unicode:
		return s.encode('utf8', 'replace')
	for e in config.repoencoding:
		try:
			return s.decode(e).encode('utf8', 'replace')
		except UnicodeDecodeError:
			pass
	raise UnicodeDecodeError, config.repoencoding


def escape(s):
	s = xml_escape(s)
	s = s.replace('"', '&quot;')
	return s

def how_old(epoch):
	if config.cachedir:
		# when we have a cache, the how_old() becomes a problem since
		# the cached entries will have old data; so in this case just
		# return a nice string
		t = time.localtime(epoch)
		currentYear = time.localtime()[0]
		if t[0] == currentYear:
			s = time.strftime("%d %b %H:%M", t)
		else:
			s = time.strftime("%d %b %Y %H:%M", t)
		return s
	age = int(time.time()) - int(epoch)
	if age > 60*60*24*365*2:
		s = str(age/60/60/24/365)
		s += " years ago"
	elif age > 60*60*24*(365/12)*2:
		s = str(age/60/60/24/(365/12))
		s += " months ago"
	elif age > 60*60*24*7*2:
		s = str(age/60/60/24/7)
		s += " weeks ago"
	elif age > 60*60*24*2:
		s = str(age/60/60/24)
		s += " days ago"
	elif age > 60*60*2:
		s = str(age/60/60)
		s += " hours ago"
	elif age > 60*2:
		s = str(age/60)
		s += " minutes ago"
	elif age > 2:
		s = str(age)
		s += " seconds ago"
	else:
		s = "right now"
	return s

def shorten_str(s, max = 60):
	if len(s) > max:
		s = s[:max - 4] + ' ...'
	return s

def replace_tabs(s):
	pos = s.find("\t")
	while pos != -1:
		count = 8 - (pos % 8)
		if count:
			spaces = ' ' * count
			s = s.replace('\t', spaces, 1)
		pos = s.find("\t")
	return s

def replace_links(s):
	"""Replace user defined strings with links, as specified in the
	configuration file."""
	import re

	vardict = {
		"myreponame": config.myreponame,
		"reponame": config.reponame,
	}

	for link_pat, link_dst in config.url_links:
		s = re.sub(link_pat, link_dst % vardict, s)

	return s

def strip_ignore_this(s):
	"""Strip out darcs' Ignore-this: metadata if present."""
	import re
	return re.sub(r'^Ignore-this:[^\n]*\n?','',s)

def highlight(s, l):
	"Highlights appearences of s in l"
	import re
	# build the regexp by leaving "(s)", replacing '(' and ') first
	s = s.replace('\\', '\\\\')
	s = s.replace('(', '\\(')
	s = s.replace(')', '\\)')
	s = '(' + escape(s) + ')'
	try:
		pat = re.compile(s, re.I)
		repl = '<span style="color:#e00000">\\1</span>'
		l = re.sub(pat, repl, l)
	except:
		pass
	return l

def fperms(fname):
	m = os.stat(fname)[stat.ST_MODE]
	m = m & 0777
	s = []
	if os.path.isdir(fname): s.append('d')
	else: s.append('-')

	if m & 0400: s.append('r')
	else: s.append('-')
	if m & 0200: s.append('w')
	else: s.append('-')
	if m & 0100: s.append('x')
	else: s.append('-')

	if m & 0040: s.append('r')
	else: s.append('-')
	if m & 0020: s.append('w')
	else: s.append('-')
	if m & 0010: s.append('x')
	else: s.append('-')

	if m & 0004: s.append('r')
	else: s.append('-')
	if m & 0002: s.append('w')
	else: s.append('-')
	if m & 0001: s.append('x')
	else: s.append('-')

	return ''.join(s)

def fsize(fname):
	s = os.stat(fname)[stat.ST_SIZE]
	if s < 1024:
		return "%s" % s
	elif s < 1048576:
		return "%sK" % (s / 1024)
	elif s < 1073741824:
		return "%sM" % (s / 1048576)

def isbinary(fname):
	import re
	bins = open(config.repodir + '/_darcs/prefs/binaries').readlines()
	bins = [b[:-1] for b in bins if b and b[0] != '#']
	for b in bins:
		if re.compile(b).search(fname):
			return 1
	return 0

def realpath(fname):
	realf = filter_file(config.repodir + '/_darcs/pristine/' + fname)
	if os.path.exists(realf):
		return realf
	realf = filter_file(config.repodir + '/_darcs/current/' + fname)
	if os.path.exists(realf):
		return realf
	realf = filter_file(config.repodir + '/' + fname)
	return realf

def log_times(cache_hit, repo = None, event = None):
	if not config.logtimes:
		return

	time_total = time.time() - time_begin
	processing = time_total - time_imports
	if not event:
		event = action
	if cache_hit:
		event = event + " (hit)"
	s = '%s\n' % event

	if repo:
		s += '\trepo: %s\n' % repo

	s += """\
	total: %.3f
	processing: %.3f
	imports: %.3f\n""" % (time_total, processing, time_imports)

	if darcs_runs:
		s += "\truns:\n"
		for params in darcs_runs:
			s += '\t\t%s\n' % params
	s += '\n'

	lf = open(config.logtimes, 'a')
	lf.write(s)
	lf.close()


def parse_darcs_time(s):
	"Try to convert a darcs' time string into a Python time tuple."
	try:
		return time.strptime(s, "%Y%m%d%H%M%S")
	except ValueError:
		# very old darcs commits use a different format, for example:
		# "Wed May 21 19:39:10 CEST 2003" or even:
		# "Sun Sep 21 07:23:57 Pacific Daylight Time 2003"
		# we can't parse the time zone part reliably, so we ignore it
		fmt = "%a %b %d %H:%M:%S %Y"
		parts = s.split()
		ns = ' '.join(parts[0:4]) + ' ' + parts[-1]
		return time.strptime(ns, fmt)



#
# generic html functions
#

def print_header():
	print "Content-type: text/html; charset=utf-8"
	print """
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
		"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
<!-- darcsweb 1.1
     Alberto Bertogli (albertito@blitiri.com.ar).

     Based on gitweb, which is written by Kay Sievers <kay.sievers@vrfy.org>
     and Christian Gierke <ch@gierke.de>
-->
<head>
<meta http-equiv="content-type" content="text/html; charset=utf-8"/>
<meta name="robots" content="index, nofollow"/>
<title>darcs - %(reponame)s</title>
<link rel="stylesheet" type="text/css" href="%(css)s"/>
<link rel="alternate" title="%(reponame)s" href="%(url)s;a=rss"
		type="application/rss+xml"/>
<link rel="alternate" title="%(reponame)s" href="%(url)s;a=atom"
		type='application/atom+xml'/>
<link rel="shortcut icon" href="%(fav)s"/>
<link rel="icon" href="%(fav)s"/>
</head>

<body>
<div class="page_header">
  <div class="search_box">
    <form action="%(myname)s" method="get"><div>
      <input type="hidden" name="r" value="%(reponame)s"/>
      <input type="hidden" name="a" value="search"/>
      <input type="text" name="s" size="20" class="search_text"/>
      <input type="submit" value="search" class="search_button"/>
      <a href="http://darcs.net" title="darcs">
        <img src="%(logo)s" alt="darcs logo" class="logo"/>
      </a>
    </div></form>
  </div>
  <a href="%(myname)s">repos</a> /
  <a href="%(myreponame)s;a=summary">%(reponame)s</a> /
  %(action)s
</div>
	""" % {
		'reponame': config.reponame,
		'css': config.cssfile,
		'url': config.myurl + '/' + config.myreponame,
		'fav': config.darcsfav,
		'logo': config.darcslogo,
		'myname': config.myname,
		'myreponame': config.myreponame,
		'action': action
	}


def print_footer(put_rss = 1):
	print """
<div class="page_footer">
<div class="page_footer_text">%s</div>
	""" % config.footer
	if put_rss:
		print '<a class="rss_logo" href="%s;a=rss">RSS</a>' % \
				(config.myurl + '/' + config.myreponame)
	print "</div>\n</body>\n</html>"


def print_navbar(h = "", f = ""):
	print """
<div class="page_nav">
<a href="%(myreponame)s;a=summary">summary</a>
| <a href="%(myreponame)s;a=shortlog">shortlog</a>
| <a href="%(myreponame)s;a=log">log</a>
| <a href="%(myreponame)s;a=tree">tree</a>
	""" % { "myreponame": config.myreponame }

	if h:
		print """
| <a href="%(myreponame)s;a=commit;h=%(hash)s">commit</a>
| <a href="%(myreponame)s;a=commitdiff;h=%(hash)s">commitdiff</a>
| <a href="%(myreponame)s;a=headdiff;h=%(hash)s">headdiff</a>
		""" % { "myreponame": config.myreponame, 'hash': h }

	realf = realpath(f)
	f = urllib.quote(f)

	if f and h:
		print """
| <a href="%(myreponame)s;a=annotate_shade;f=%(fname)s;h=%(hash)s">annotate</a>
		""" % {
			'myreponame': config.myreponame,
			'hash': h,
			'fname': f
		}
	elif f:
		print """
| <a href="%(myreponame)s;a=annotate_shade;f=%(fname)s">annotate</a>
		""" % { "myreponame": config.myreponame, 'fname': f }

	if f and os.path.isfile(realf):
		print """
| <a href="%(myreponame)s;a=headblob;f=%(fname)s">headblob</a>
		""" % { "myreponame": config.myreponame, 'fname': f }

	if f and os.path.isdir(realf):
		print """
| <a href="%(myreponame)s;a=tree;f=%(fname)s">headtree</a>
		"""  % { "myreponame": config.myreponame, 'fname': f }

	if h and f and (os.path.isfile(realf) or os.path.isdir(realf)):
		print """
| <a href="%(myreponame)s;a=headfilediff;h=%(hash)s;f=%(fname)s">headfilediff</a>
		""" % { "myreponame": config.myreponame, 'hash': h, 'fname': f }

	if f:
		print """
| <a class="link" href="%(myreponame)s;a=filehistory;f=%(fname)s">filehistory</a>
		""" % { "myreponame": config.myreponame, 'fname': f }

	print "<br/>"

	efaction = action
	if '_' in action:
		# action is composed as "format_action", like
		# "darcs_commitdiff"; so we get the "effective action" to
		# decide if we need to present the "alternative formats" menu
		pos = action.find('_')
		fmt = action[:pos]
		efaction = action[pos + 1:]
	if efaction in ("commit", "commitdiff", "filediff", "headdiff",
			"headfilediff"):

		# in order to show the small bar in the commit page too, we
		# accept it here and change efaction to commitdiff, because
		# that's what we're really intrested in
		if efaction == "commit":
			efaction = "commitdiff"

		params = 'h=%s;' % h
		if f:
			params += 'f=%s;' % f

		# normal (unified)
		print """
<a class="link" href="%(myreponame)s;a=%(act)s;%(params)s">unified</a>
		""" % { "myreponame": config.myreponame, "act": efaction,
			"params": params }

		# plain
		print """
| <a class="link" href="%(myreponame)s;a=plain_%(act)s;%(params)s">plain</a>
		""" % { "myreponame": config.myreponame, "act": efaction,
			"params": params }

		# darcs, htmlized
		print """
| <a class="link" href="%(myreponame)s;a=darcs_%(act)s;%(params)s">darcs</a>
		""" % { "myreponame": config.myreponame, "act": efaction,
			"params": params }

		# darcs, raw, if available; and only for commitdiff
		realf = filter_file(config.repodir + '/_darcs/patches/' + h)
		if efaction == "commitdiff" and os.path.isfile(realf):
			print """
| <a class="link" href="%(myreponame)s;a=raw_%(act)s;%(params)s">raw</a>
			""" % { "myreponame": config.myreponame,
				"act": efaction, "params": params }

	elif f and action == "headblob":
		# show the only alternative format: plain
		print """
<a class="link" href="%(myreponame)s;a=plainblob;f=%(fname)s">plain</a>
		""" % { "myreponame": config.myreponame, "fname": f }

	elif f and h and action.startswith("annotate"):
		# same for annotate
		print """
<a href="%(myreponame)s;a=annotate_normal;f=%(fname)s;h=%(hash)s">normal</a>
| <a href="%(myreponame)s;a=annotate_plain;f=%(fname)s;h=%(hash)s">plain</a>
| <a href="%(myreponame)s;a=annotate_shade;f=%(fname)s;h=%(hash)s">shade</a>
| <a href="%(myreponame)s;a=annotate_zebra;f=%(fname)s;h=%(hash)s">zebra</a>
		""" % {
			"myreponame": config.myreponame,
			"fname": f,
			"hash": h
		}

	print '<br/>'
	print '</div>'

def print_plain_header():
	print "Content-type: text/plain; charset=utf-8\n"

def print_binary_header(fname = None):
	import mimetypes
	if fname :
		(mime, enc) = mimetypes.guess_type(fname)
	else :
		mime = None
	if mime :
		print "Content-type: %s" % mime
	else :
		print "Content-type: application/octet-stream"
	if fname:
		print "Content-Disposition:attachment;filename=%s" % fname
	print

def gen_authorlink(author, shortauthor=None):
	if not config.author_links:
		if shortauthor:
			return shortauthor
		else:
			return author
	if not shortauthor:
		shortauthor = author
	return '<a href="' + config.author_links % { 'author': author } + '">%s</a>' % shortauthor

#
# basic caching
#

class Cache:
	def __init__(self, basedir, url):
		import sha
		self.basedir = basedir
		self.url = url
		self.fname = sha.sha(repr(url)).hexdigest()
		self.file = None
		self.mode = None
		self.real_stdout = sys.stdout

	def open(self):
		"Returns 1 on hit, 0 on miss"
		fname = self.basedir + '/' + self.fname

		if not os.access(fname, os.R_OK):
			# the file doesn't exist, direct miss
			pid = str(os.getpid())
			fname = self.basedir + '/.' + self.fname + '-' + pid
			self.file = open(fname, 'w')
			self.mode = 'w'
			os.chmod(fname, stat.S_IRUSR | stat.S_IWUSR)

			# step over stdout so when "print" tries to write
			# output, we get it first
			sys.stdout = self
			return 0

		inv = config.repodir + '/_darcs/patches'
		cache_lastmod = os.stat(fname).st_mtime
		repo_lastmod = os.stat(inv).st_mtime
		dw_lastmod = os.stat(sys.argv[0]).st_mtime

		if repo_lastmod > cache_lastmod or dw_lastmod > cache_lastmod:
			# the entry is too old, remove it and return a miss
			os.unlink(fname)

			pid = str(os.getpid())
			fname = self.basedir + '/.' + self.fname + '-' + pid
			self.file = open(fname, 'w')
			self.mode = 'w'
			sys.stdout = self
			return 0

		# the entry is still valid, hit!
		self.file = open(fname, 'r')
		self.mode = 'r'
		return 1


	def dump(self):
		for l in self.file:
			self.real_stdout.write(l)

	def write(self, s):
		# this gets called from print, because we replaced stdout with
		# ourselves
		self.file.write(s)
		self.real_stdout.write(s)

	def close(self):
		if self.file:
			self.file.close()
		sys.stdout = self.real_stdout
		if self.mode == 'w':
			pid = str(os.getpid())
			fname1 = self.basedir + '/.' + self.fname + '-' + pid
			fname2 = self.basedir + '/' + self.fname
			os.rename(fname1, fname2)
			self.mode = 'c'

	def cancel(self):
		"Like close() but don't save the entry."
		if self.file:
			self.file.close()
		sys.stdout = self.real_stdout
		if self.mode == 'w':
			pid = str(os.getpid())
			fname = self.basedir + '/.' + self.fname + '-' + pid
			os.unlink(fname)
			self.mode = 'c'


#
# darcs repo manipulation
#

def repo_get_owner():
	try:
		fd = open(config.repodir + '/_darcs/prefs/author')
		for line in fd:
			line = line.strip()
			if line != "" and line[0] != "#":
				return line.strip()
	except:
		return None

def run_darcs(params):
	"""Runs darcs on the repodir with the given params, return a file
	object with its output."""
	os.chdir(config.repodir)
	try:
		original_8bit_setting = os.environ['DARCS_DONT_ESCAPE_8BIT']
	except KeyError:
		original_8bit_setting = None
	os.environ['DARCS_DONT_ESCAPE_8BIT'] = '1'
	cmd = config.darcspath + "darcs " + params
	inf, outf = os.popen4(cmd, 't')
	darcs_runs.append(params)
	if original_8bit_setting == None:
		del(os.environ['DARCS_DONT_ESCAPE_8BIT'])
	else:
		os.environ['DARCS_DONT_ESCAPE_8BIT'] = original_8bit_setting
	return outf


class Patch:
	"Represents a single patch/record"
	def __init__(self):
		self.hash = ''
		self.author = ''
		self.shortauthor = ''
		self.date = 0
		self.local_date = 0
		self.name = ''
		self.comment = ''
		self.inverted = False;
		self.adds = []
		self.removes = []
		self.modifies = {}
		self.diradds = []
		self.dirremoves = []
		self.replaces = {}
		self.moves = {}

	def tostr(self):
		s = "%s\n\tAuthor: %s\n\tDate: %s\n\tHash: %s\n" % \
			(self.name, self.author, self.date, self.hash)
		return s

	def getdiff(self):
		"""Returns a list of lines from the diff -u corresponding with
		the patch."""
		params = 'diff --quiet -u --match "hash %s"' % self.hash
		f = run_darcs(params)
		return f.readlines()

	def matches(self, s):
		"Defines if the patch matches a given string"
		if s.lower() in self.comment.lower():
			return self.comment
		elif s.lower() in self.name.lower():
			return self.name
		elif s.lower() in self.author.lower():
			return self.author
		elif s == self.hash:
			return self.hash

		s = s.lower()
		for l in (self.adds, self.removes, self.modifies,
				self.diradds, self.dirremoves,
				self.replaces.keys(), self.moves.keys(),
				self.moves.keys() ):
			for i in l:
				if s in i.lower():
					return i
		return ''

class XmlInputWrapper:
	def __init__(self, fd):
		self.fd = fd
		self.times = 0
		self._read = self.read

	def read(self, *args, **kwargs):
		self.times += 1
		if self.times == 1:
			return '<?xml version="1.0" encoding="utf-8"?>\n'
		s = self.fd.read(*args, **kwargs)
		if not s:
			return s
		return fixu8(s)

	def close(self, *args, **kwargs):
		return self.fd.close(*args, **kwargs)


# patch parsing, we get them through "darcs changes --xml-output"
class BuildPatchList(xml.sax.handler.ContentHandler):
	def __init__(self):
		self.db = {}
		self.list = []
		self.cur_hash = ''
		self.cur_elem = None
		self.cur_val = ''
		self.cur_file = ''

	def startElement(self, name, attrs):
		# When you ask for changes to a given file, the xml output
		# begins with the patch that creates it is enclosed in a
		# "created_as" tag; then, later, it gets shown again in its
		# usual place. The following two "if"s take care of ignoring
		# everything inside the "created_as" tag, since we don't care.
		if name == 'created_as':
			self.cur_elem = 'created_as'
			return
		if self.cur_elem == 'created_as':
			return

		# now parse the tags normally
		if name == 'patch':
			p = Patch()
			p.hash = fixu8(attrs.get('hash'))

			au = attrs.get('author', None)
			p.author = fixu8(escape(au))
			if au.find('<') != -1:
				au = au[:au.find('<')].strip()
			p.shortauthor = fixu8(escape(au))

			td = parse_darcs_time(attrs.get('date', None))
			p.date = time.mktime(td)
			p.date_str = time.strftime("%a, %d %b %Y %H:%M:%S", td)

			td = time.strptime(attrs.get('local_date', None),
					"%a %b %d %H:%M:%S %Z %Y")
			p.local_date = time.mktime(td)
			p.local_date_str = \
				time.strftime("%a, %d %b %Y %H:%M:%S", td)

			inverted = attrs.get('inverted', None)
			if inverted and inverted == 'True':
				p.inverted = True

			self.db[p.hash] = p
			self.current = p.hash
			self.list.append(p.hash)
		elif name == 'name':
			self.db[self.current].name = ''
			self.cur_elem = 'name'
		elif name == 'comment':
			self.db[self.current].comment = ''
			self.cur_elem = 'comment'
		elif name == 'add_file':
			self.cur_elem = 'add_file'
		elif name == 'remove_file':
			self.cur_elem = 'remove_file'
		elif name == 'add_directory':
			self.cur_elem = 'add_directory'
		elif name == 'remove_directory':
			self.cur_elem = 'remove_dir'
		elif name == 'modify_file':
			self.cur_elem = 'modify_file'
		elif name == 'removed_lines':
			if self.cur_val:
				self.cur_file = fixu8(self.cur_val.strip())
			cf = self.cur_file
			p = self.db[self.current]
			# the current value holds the file name at this point
			if not p.modifies.has_key(cf):
				p.modifies[cf] = { '+': 0, '-': 0 }
			p.modifies[cf]['-'] = int(attrs.get('num', None))
		elif name == 'added_lines':
			if self.cur_val:
				self.cur_file = fixu8(self.cur_val.strip())
			cf = self.cur_file
			p = self.db[self.current]
			if not p.modifies.has_key(cf):
				p.modifies[cf] = { '+': 0, '-': 0 }
			p.modifies[cf]['+'] = int(attrs.get('num', None))
		elif name == 'move':
			src = fixu8(attrs.get('from', None))
			dst = fixu8(attrs.get('to', None))
			p = self.db[self.current]
			p.moves[src] = dst
		elif name == 'replaced_tokens':
			if self.cur_val:
				self.cur_file = fixu8(self.cur_val.strip())
			cf = self.cur_file
			p = self.db[self.current]
			if not p.replaces.has_key(cf):
				p.replaces[cf] = 0
			p.replaces[cf] = int(attrs.get('num', None))
		else:
			self.cur_elem = None

	def characters(self, s):
		if not self.cur_elem:
			return
		self.cur_val += s

	def endElement(self, name):
		# See the comment in startElement()
		if name == 'created_as':
			self.cur_elem = None
			self.cur_val = ''
			return
		if self.cur_elem == 'created_as':
			return
		if name == 'replaced_tokens':
			return

		if name == 'name':
			p = self.db[self.current]
			p.name = fixu8(self.cur_val)
			if p.inverted:
				p.name = 'UNDO: ' + p.name
		elif name == 'comment':
			self.db[self.current].comment = fixu8(strip_ignore_this(self.cur_val))
		elif name == 'add_file':
			scv = fixu8(self.cur_val.strip())
			self.db[self.current].adds.append(scv)
		elif name == 'remove_file':
			scv = fixu8(self.cur_val.strip())
			self.db[self.current].removes.append(scv)
		elif name == 'add_directory':
			scv = fixu8(self.cur_val.strip())
			self.db[self.current].diradds.append(scv)
		elif name == 'remove_directory':
			scv = fixu8(self.cur_val.strip())
			self.db[self.current].dirremoves.append(scv)

		elif name == 'modify_file':
			if not self.cur_file:
				# binary modification appear without a line
				# change summary, so we add it manually here
				f = fixu8(self.cur_val.strip())
				p = self.db[self.current]
				p.modifies[f] = { '+': 0, '-': 0, 'b': 1 }
			self.cur_file = ''

		self.cur_elem = None
		self.cur_val = ''

	def get_list(self):
		plist = []
		for h in self.list:
			plist.append(self.db[h])
		return plist

	def get_db(self):
		return self.db

	def get_list_db(self):
		return (self.list, self.db)

def get_changes_handler(params):
	"Returns a handler for the changes output, run with the given params"
	parser = xml.sax.make_parser()
	handler = BuildPatchList()
	parser.setContentHandler(handler)

	# get the xml output and parse it
	xmlf = run_darcs("changes --xml-output " + params)
	parser.parse(XmlInputWrapper(xmlf))
	xmlf.close()

	return handler

def get_last_patches(last = 15, topi = 0, fname = None):
	"""Gets the last N patches from the repo, returns a patch list. If
	"topi" is specified, then it will return the N patches that preceeded
	the patch number topi in the list. It sounds messy but it's quite
	simple. You can optionally pass a filename and only changes that
	affect it will be returned. FIXME: there's probably a more efficient
	way of doing this."""

	# darcs calculate last first, and then filters the filename,
	# so it's not so simple to combine them; that's why we do so much
	# special casing here
	toget = last + topi

	if fname:
		if fname[0] == '/': fname = fname[1:]
		s = '-s "%s"' % fname
	else:
		s = "-s --last=%d" % toget

	handler = get_changes_handler(s)

	# return the list of all the patch objects
	return handler.get_list()[topi:toget]

def get_patch(hash):
	handler = get_changes_handler('-s --match "hash %s"' % hash)
	patch = handler.db[handler.list[0]]
	return patch

def get_diff(hash):
	return run_darcs('diff --quiet -u --match "hash %s"' % hash)

def get_file_diff(hash, fname):
	return run_darcs('diff --quiet -u --match "hash %s" "%s"' % (hash, fname))

def get_file_headdiff(hash, fname):
	return run_darcs('diff --quiet -u --from-match "hash %s" "%s"' % (hash, fname))

def get_patch_headdiff(hash):
	return run_darcs('diff --quiet -u --from-match "hash %s"' % hash)

def get_raw_diff(hash):
	import gzip
	realf = filter_file(config.repodir + '/_darcs/patches/' + hash)
	if not os.path.isfile(realf):
		return None
	file = open(realf, 'rb')
	if file.read(2) == '\x1f\x8b':
		# file begins with gzip magic
		file.close()
		dsrc = gzip.open(realf)
	else:
		file.seek(0)
		dsrc = file
	return dsrc

def get_darcs_diff(hash, fname = None):
	cmd = 'changes -v --matches "hash %s"' % hash
	if fname:
		cmd += ' "%s"' % fname
	return run_darcs(cmd)

def get_darcs_headdiff(hash, fname = None):
	cmd = 'changes -v --from-match "hash %s"' % hash
	if fname:
		cmd += ' "%s"' % fname
	return run_darcs(cmd)


class Annotate:
	def __init__(self):
		self.fname = ""
		self.creator_hash = ""
		self.created_as = ""
		self.lastchange_hash = ""
		self.lastchange_author = ""
		self.lastchange_name = ""
		self.lastchange_date = None
		self.firstdate = None
		self.lastdate = None
		self.lines = []
		self.patches = {}

	class Line:
		def __init__(self):
			self.text = ""
			self.phash = None
			self.pauthor = None
			self.pdate = None

def parse_annotate(src):
	import xml.dom.minidom

	annotate = Annotate()

	# FIXME: convert the source to UTF8; it _has_ to be a way to let
	# minidom know the source encoding
	s = ""
	for i in src:
		s += fixu8(i).replace('', '^L')

	dom = xml.dom.minidom.parseString(s)

	file = dom.getElementsByTagName("file")[0]
	annotate.fname = fixu8(file.getAttribute("name"))

	createinfo = dom.getElementsByTagName("created_as")[0]
	annotate.created_as = fixu8(createinfo.getAttribute("original_name"))

	creator = createinfo.getElementsByTagName("patch")[0]
	annotate.creator_hash = fixu8(creator.getAttribute("hash"))

	mod = dom.getElementsByTagName("modified")[0]
	lastpatch = mod.getElementsByTagName("patch")[0]
	annotate.lastchange_hash = fixu8(lastpatch.getAttribute("hash"))
	annotate.lastchange_author = fixu8(lastpatch.getAttribute("author"))

	lastname = lastpatch.getElementsByTagName("name")[0]
	lastname = lastname.childNodes[0].wholeText
	annotate.lastchange_name = fixu8(lastname)

	lastdate = parse_darcs_time(lastpatch.getAttribute("date"))
	annotate.lastchange_date = lastdate

	annotate.patches[annotate.lastchange_hash] = annotate.lastchange_date

	# these will be overriden by the real dates later
	annotate.firstdate = lastdate
	annotate.lastdate = 0

	file = dom.getElementsByTagName("file")[0]

	for l in file.childNodes:
		# we're only intrested in normal and added lines
		if l.nodeName not in ["normal_line", "added_line"]:
			continue
		line = Annotate.Line()

		if l.nodeName == "normal_line":
			patch = l.getElementsByTagName("patch")[0]
			phash = patch.getAttribute("hash")
			pauthor = patch.getAttribute("author")
			pdate = patch.getAttribute("date")
			pdate = parse_darcs_time(pdate)
		else:
			# added lines inherit the creation from the annotate
			# patch
			phash = annotate.lastchange_hash
			pauthor = annotate.lastchange_author
			pdate = annotate.lastchange_date

		text = ""
		for node in l.childNodes:
			if node.nodeType == node.TEXT_NODE:
				text += node.wholeText

		# strip all "\n"s at the beginning; because the way darcs
		# formats the xml output it makes the DOM parser to add "\n"s
		# in front of it
		text = text.lstrip("\n")

		line.text = fixu8(text)
		line.phash = fixu8(phash)
		line.pauthor = fixu8(pauthor)
		line.pdate = pdate
		annotate.lines.append(line)
		annotate.patches[line.phash] = line.pdate

		if pdate > annotate.lastdate:
			annotate.lastdate = pdate
		if pdate < annotate.firstdate:
			annotate.firstdate = pdate

	return annotate

def get_annotate(fname, hash = None):
	if config.disable_annotate:
		return None

	cmd = 'annotate --xml-output'
	if hash:
		cmd += ' --match="hash %s"' % hash

	if fname.startswith('/'):
		# darcs 2 doesn't like files starting with /, and darcs 1
		# doesn't really care
		fname = fname[1:]
	cmd += ' "%s"' % fname

	return parse_annotate(run_darcs(cmd))

def get_readme():
	import glob
	readmes = glob.glob("README*")
	if len(readmes) == 0: return False, False
	import re
	for p in readmes:
		file = os.path.basename(p)
		if re.search('\.(md|markdown)$', p):
			import codecs
			import markdown
			f = codecs.open(p, encoding=config.repoencoding[0])
			str = f.read()
			html = markdown.markdown(str, ['extra', 'codehilite(css_class=page_body)'])
			return file, fixu8(html)
		elif re.search('README$', p):
			f = open(p)
			str = f.read()
			return file, '<pre>%s</pre>' % fixu8(escape(str))
	# We can't handle this ourselves, try shelling out
	if not config.readme_converter: return False, False
	cmd = '%s "%s"' % (config.readme_converter, readmes[0])
	inf, outf = os.popen2(cmd, 't')
	return os.path.basename(readmes[0]), fixu8(outf.read())


#
# specific html functions
#

def print_diff(dsrc):
	for l in dsrc:
		l = fixu8(l)

		# remove the trailing newline
		if len(l) > 1:
			l = l[:-1]

		if l.startswith('diff'):
			# file lines, they have their own class
			print '<div class="diff_info">%s</div>' % escape(l)
			continue

		color = ""
		if l[0] == '+':
			color = 'style="color:#008800;"'
		elif l[0] == '-':
			color = 'style="color:#cc0000;"'
		elif l[0] == '@':
			color = 'style="color:#990099; '
			color += 'border: solid #ffe0ff; '
			color += 'border-width: 1px 0px 0px 0px; '
			color += 'margin-top: 2px;"'
		elif l.startswith('Files'):
			# binary differences
			color = 'style="color:#666;"'
		print '<div class="pre" %s>' % color + escape(l) + '</div>'


def print_darcs_diff(dsrc):
	for l in dsrc:
		l = fixu8(l)

		if not l.startswith("    "):
			# comments and normal stuff
			print '<div class="pre">' + escape(l) + "</div>"
			continue

		l = l.strip()
		if not l:
			continue

		if l[0] == '+':
			cl = 'class="pre" style="color:#008800;"'
		elif l[0] == '-':
			cl = 'class="pre" style="color:#cc0000;"'
		else:
			cl = 'class="diff_info"'
		print '<div %s>' % cl + escape(l) + '</div>'


def print_shortlog(last = PATCHES_PER_PAGE, topi = 0, fname = None):
	ps = get_last_patches(last, topi, fname)

	if fname:
		title = '<a class="title" href="%s;a=filehistory;f=%s">' % \
				(config.myreponame, fname)
		title += 'History for path %s' % escape(fname)
		title += '</a>'
	else:
		title = '<a class="title" href="%s;a=shortlog">shortlog</a>' \
				% config.myreponame

	print '<div>%s</div>' % title
	print '<table cellspacing="0">'

	if topi != 0:
		# put a link to the previous page
		ntopi = topi - last
		if ntopi < 0:
			ntopi = 0
		print '<tr><td>'
		if fname:
			print '<a href="%s;a=filehistory;topi=%d;f=%s">...</a>' \
				% (config.myreponame, ntopi, fname)
		else:
			print '<a href="%s;a=shortlog;topi=%d">...</a>' \
				% (config.myreponame, ntopi)
		print '</td></tr>'

	alt = True
	for p in ps:
		if p.name.startswith("TAG "):
			print '<tr class="tag">'
		elif alt:
			print '<tr class="dark">'
		else:
			print '<tr class="light">'
		alt = not alt

		print """
  <td><i>%(age)s</i></td>
  <td>%(author)s</td>
  <td>
    <a class="list" title="%(fullname)s" href="%(myrname)s;a=commit;h=%(hash)s">
      <b>%(name)s</b>
    </a>
  </td>
  <td class="link">
    <a href="%(myrname)s;a=commit;h=%(hash)s">commit</a> |
    <a href="%(myrname)s;a=commitdiff;h=%(hash)s">commitdiff</a>
  </td>
		""" % {
			'age': how_old(p.local_date),
			'author': gen_authorlink(p.author, shorten_str(p.shortauthor, 26)),
			'myrname': config.myreponame,
			'hash': p.hash,
			'name': escape(shorten_str(p.name)),
			'fullname': escape(p.name),
		}
		print "</tr>"

	if len(ps) >= last:
		# only show if we've not shown them all already
		print '<tr><td>'
		if fname:
			print '<a href="%s;a=filehistory;topi=%d;f=%s">...</a>' \
				% (config.myreponame, topi + last, fname)
		else:
			print '<a href="%s;a=shortlog;topi=%d">...</a>' \
				% (config.myreponame, topi + last)
		print '</td></tr>'
	print "</table>"


def print_readme():
	head, body = get_readme()
	if not head: return False
	print '<div class="title">%s</div>' % head
	print '<section>%s</section' % body


def print_log(last = PATCHES_PER_PAGE, topi = 0):
	ps = get_last_patches(last, topi)

	if topi != 0:
		# put a link to the previous page
		ntopi = topi - last
		if ntopi < 0:
			ntopi = 0
		print '<p/><a href="%s;a=log;topi=%d">&lt;- Prev</a><p/>' % \
				(config.myreponame, ntopi)

	for p in ps:
		if p.comment:
			comment = replace_links(escape(p.comment))
			fmt_comment = comment.replace('\n', '<br/>') + '\n'
			fmt_comment += '<br/><br/>'
		else:
			fmt_comment = ''
		print """
<div><a class="title" href="%(myreponame)s;a=commit;h=%(hash)s">
    <span class="age">%(age)s</span>%(desc)s
</a></div>
<div class="title_text">
  <div class="log_link">
    <a href="%(myreponame)s;a=commit;h=%(hash)s">commit</a> |
    <a href="%(myreponame)s;a=commitdiff;h=%(hash)s">commitdiff</a><br/>
  </div>
  <i>%(author)s [%(date)s]</i><br/>
</div>
<div class="log_body">
  %(comment)s
</div>

		""" % {
			'myreponame': config.myreponame,
			'age': how_old(p.local_date),
			'date': p.local_date_str,
			'author': gen_authorlink(p.author, p.shortauthor),
			'hash': p.hash,
			'desc': escape(p.name),
			'comment': fmt_comment
		}

	if len(ps) >= last:
		# only show if we've not shown them all already
		print '<p><a href="%s;a=log;topi=%d">Next -&gt;</a></p>' % \
				(config.myreponame, topi + last)


def print_blob(fname):
	print '<div class="page_path"><b>%s</b></div>' % escape(fname)
	if isbinary(fname):
		print """
<div class="page_body">
<i>This is a binary file and its contents will not be displayed.</i>
</div>
		"""
		return

	try:
		import pygments
	except ImportError:
		pygments = False

	if not pygments:
		print_blob_simple(fname)
		return
	else:
		try:
			print_blob_highlighted(fname)
		except ValueError:
			# pygments couldn't guess a lexer to highlight the code, try
			# another method with sampling the file contents.
			try:
				print_blob_highlighted(fname, sample_code=True)
			except ValueError:
				# pygments really could not find any lexer for this file.
				print_blob_simple(fname)

def print_blob_simple(fname):
	print '<div class="page_body">'

	f = open(realpath(fname), 'r')
	count = 1
	for l in f:
		l = fixu8(escape(l))
		if l and l[-1] == '\n':
			l = l[:-1]
		l = replace_tabs(l)

		print """\
<div class="pre">\
<a id="l%(c)d" href="#l%(c)d" class="linenr">%(c)4d</a> %(l)s\
</div>\
		""" % {
			'c': count,
			'l': l
		}
		count += 1
	print '</div>'

def print_blob_highlighted(fname, sample_code=False):
	import pygments
	import pygments.lexers
	import pygments.formatters

	code = open(realpath(fname), 'r').read()
	if sample_code:
		lexer = pygments.lexers.guess_lexer(code[:200],
				encoding=config.repoencoding[0])
	else:
		lexer = pygments.lexers.guess_lexer_for_filename(fname, code[:200],
				encoding=config.repoencoding[0])

	pygments_version = map(int, pygments.__version__.split('.'))
	if pygments_version >= [0, 7]:
		linenos_method = 'inline'
	else:
		linenos_method = True
	formatter = pygments.formatters.HtmlFormatter(linenos=linenos_method,
				cssclass='page_body')

	print pygments.highlight(code, lexer, formatter)
	print """<script type='text/javascript'>
(function () {
  if (!document.getElementsByClassName || !document.evaluate || !window.addEventListener)
    return;

  function fakeAnchors () {
    var pbody = document.getElementsByClassName("page_body")[0];
    var anchor = window.location.hash;
    if (!pbody || "" == anchor || "#" == anchor) return;

    /* Avoid xpath injection, because so far as I can tell there's no way to set
       xpath variables from JavaScript. */
    if (anchor.match(/['"]/)) return;

    anchor = anchor.substr(1);
    var parts = anchor.split(/ /);
    var xpq = '//span[string()="'+parts[0]+'"]';
    for (var i = 1; i < parts.length; i++) {
      xpq += '//following-sibling::span[1][string()="'+parts[i]+'"]';
    }
    var res = document.evaluate(xpq, pbody, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
    if (!res || !res.singleNodeValue) return;

    res.singleNodeValue.scrollIntoView(true);
  };
  window.addEventListener("DOMContentLoaded", fakeAnchors, false);
  window.addEventListener("hashchange", fakeAnchors, false);
})();
</script>"""

def print_annotate(ann, style):
	print '<div class="page_body">'
	if isbinary(ann.fname):
		print """
<i>This is a binary file and its contents will not be displayed.</i>
</div>
		"""
		return

	if style == 'shade':
		# here's the idea: we will assign to each patch a shade of
		# color from its date (newer gets darker)
		max = 0xff
		min = max - 80

		# to do that, we need to get a list of the patch hashes
		# ordered by their dates
		l = [ (date, hash) for (hash, date) in ann.patches.items() ]
		l.sort()
		l = [ hash for (date, hash) in l ]

		# now we have to map each element to a number in the range
		# min-max, with max being close to l[0] and min l[len(l) - 1]
		lenn = max - min
		lenl = len(l)
		shadetable = {}
		for i in range(0, lenl):
			hash = l[i]
			n = float(i * lenn) / lenl
			n = max - int(round(n))
			shadetable[hash] = n
	elif style == "zebra":
		lineclass = 'dark'

	count = 1
	prevhash = None
	for l in ann.lines:
		text = escape(l.text)
		text = text.rstrip()
		text = replace_tabs(text)
		plongdate = time.strftime("%Y-%m-%d %H:%M:%S", l.pdate)
		title = "%s by %s" % (plongdate, escape(l.pauthor) )

		link = "%(myrname)s;a=commit;h=%(hash)s" % {
			'myrname': config.myreponame,
			'hash': l.phash
		}

		if style == "shade":
			linestyle = 'style="background-color:#ffff%.2x"' % \
					shadetable[l.phash]
			lineclass = ''
		elif style == "zebra":
			linestyle = ''
			if l.phash != prevhash:
				if lineclass == 'dark':
					lineclass = 'light'
				else:
					lineclass = 'dark'
		else:
			linestyle = ''
			lineclass = ''

		if l.phash != prevhash:
			pdate = time.strftime("%Y-%m-%d", l.pdate)

			left = l.pauthor.find('<')
			right = l.pauthor.find('@')
			if left != -1 and right != -1:
				shortau = l.pauthor[left + 1:right]
			elif l.pauthor.find(" ") != -1:
				shortau = l.pauthor[:l.pauthor.find(" ")]
			elif right != -1:
				shortau = l.pauthor[:right]
			else:
				shortau = l.pauthor

			desc = "%12.12s" % shortau
			date = "%-10.10s" % pdate
			prevhash = l.phash
			line = 1
		else:
			if line == 1 and style in ["shade", "zebra"]:
				t = "%s  " % time.strftime("%H:%M:%S", l.pdate)
				desc = "%12.12s" % "'"
				date = "%-10.10s" % t
			else:
				desc = "%12.12s" % "'"
				date = "%-10.10s" % ""
			line += 1

		print """\
<div class="pre %(class)s" %(style)s>\
<a href="%(link)s" title="%(title)s" class="annotate_desc">%(date)s %(desc)s</a> \
<a href="%(link)s" title="%(title)s" class="linenr">%(c)4d</a> \
<a href="%(link)s" title="%(title)s" class="line">%(text)s</a>\
</div>\
		""" % {
			'class': lineclass,
			'style': linestyle,
			'date': date,
			'desc': escape(desc),
			'c': count,
			'text': text,
			'title': title,
			'link': link
		}

		count += 1

	print '</div>'


#
# available actions
#

def do_summary():
	print_header()
	print_navbar()
	owner = repo_get_owner()

	# we should optimize this, it's a pity to go in such a mess for just
	# one hash
	ps = get_last_patches(1)

	print '<div class="title">&nbsp;</div>'
	print '<table cellspacing="0">'
	print '  <tr><td>description</td><td>%s</td></tr>' % \
			escape(config.repodesc)
	if owner:
		print '  <tr><td>owner</td><td>%s</td></tr>' % escape(owner)
	if len(ps) > 0:
		print '  <tr><td>last change</td><td>%s</td></tr>' % \
			ps[0].local_date_str
	print '  <tr><td>url</td><td><a href="%(url)s">%(url)s</a></td></tr>' %\
			{ 'url': config.repourl }
	if config.repoprojurl:
		print '  <tr><td>project url</td>'
		print '  <td><a href="%(url)s">%(url)s</a></td></tr>' % \
			{ 'url': config.repoprojurl }
	if config.repolisturl:
		print '  <tr><td>mailing list url</td>'
		print '  <td><a href="%(url)s">%(url)s</a></td></tr>' % \
			{ 'url': config.repolisturl }
	print '</table>'

	print_shortlog(15)
	print_readme()
	print_footer()


def do_commitdiff(phash):
	print_header()
	print_navbar(h = phash)
	p = get_patch(phash)
	print """
<div>
  <a class="title" href="%(myreponame)s;a=commit;h=%(hash)s">%(name)s</a>
</div>
	""" % {
		'myreponame': config.myreponame,
		'hash': p.hash,
		'name': escape(p.name),
	}

	dsrc = p.getdiff()
	print_diff(dsrc)
	print_footer()

def do_plain_commitdiff(phash):
	print_plain_header()
	dsrc = get_diff(phash)
	for l in dsrc:
		sys.stdout.write(fixu8(l))

def do_darcs_commitdiff(phash):
	print_header()
	print_navbar(h = phash)
	p = get_patch(phash)
	print """
<div>
  <a class="title" href="%(myreponame)s;a=commit;h=%(hash)s">%(name)s</a>
</div>
	""" % {
		'myreponame': config.myreponame,
		'hash': p.hash,
		'name': escape(p.name),
	}

	dsrc = get_darcs_diff(phash)
	print_darcs_diff(dsrc)
	print_footer()

def do_raw_commitdiff(phash):
	print_plain_header()
	dsrc = get_raw_diff(phash)
	if not dsrc:
		print "Error opening file!"
		return
	for l in dsrc:
		sys.stdout.write(l)


def do_headdiff(phash):
	print_header()
	print_navbar(h = phash)
	p = get_patch(phash)
	print """
<div>
  <a class="title" href="%(myreponame)s;a=commit;h=%(hash)s">
    %(name)s --&gt; to head</a>
</div>
	""" % {
		'myreponame': config.myreponame,
		'hash': p.hash,
		'name': escape(p.name),
	}

	dsrc = get_patch_headdiff(phash)
	print_diff(dsrc)
	print_footer()

def do_plain_headdiff(phash):
	print_plain_header()
	dsrc = get_patch_headdiff(phash)
	for l in dsrc:
		sys.stdout.write(fixu8(l))

def do_darcs_headdiff(phash):
	print_header()
	print_navbar(h = phash)
	p = get_patch(phash)
	print """
<div>
  <a class="title" href="%(myreponame)s;a=commit;h=%(hash)s">
    %(name)s --&gt; to head</a>
</div>
	""" % {
		'myreponame': config.myreponame,
		'hash': p.hash,
		'name': escape(p.name),
	}

	dsrc = get_darcs_headdiff(phash)
	print_darcs_diff(dsrc)
	print_footer()

def do_raw_headdiff(phash):
	print_plain_header()
	dsrc = get_darcs_headdiff(phash)
	for l in dsrc:
		sys.stdout.write(l)


def do_filediff(phash, fname):
	print_header()
	print_navbar(h = phash, f = fname)
	p = get_patch(phash)
	dsrc = get_file_diff(phash, fname)
	print """
<div>
  <a class="title" href="%(myreponame)s;a=commit;h=%(hash)s">%(name)s</a>
</div>
<div class="page_path"><b>%(fname)s</b></div>
	""" % {
		'myreponame': config.myreponame,
		'hash': p.hash,
		'name': escape(p.name),
		'fname': escape(fname),
	}

	print_diff(dsrc)
	print_footer()

def do_plain_filediff(phash, fname):
	print_plain_header()
	dsrc = get_file_diff(phash, fname)
	for l in dsrc:
		sys.stdout.write(fixu8(l))

def do_darcs_filediff(phash, fname):
	print_header()
	print_navbar(h = phash, f = fname)
	p = get_patch(phash)
	print """
<div>
  <a class="title" href="%(myreponame)s;a=commit;h=%(hash)s">%(name)s</a>
</div>
<div class="page_path"><b>%(fname)s</b></div>
	""" % {
		'myreponame': config.myreponame,
		'hash': p.hash,
		'name': escape(p.name),
		'fname': escape(fname),
	}

	dsrc = get_darcs_diff(phash, fname)
	print_darcs_diff(dsrc)
	print_footer()


def do_file_headdiff(phash, fname):
	print_header()
	print_navbar(h = phash, f = fname)
	p = get_patch(phash)
	dsrc = get_file_headdiff(phash, fname)
	print """
<div>
  <a class="title" href="%(myreponame)s;a=commit;h=%(hash)s">
    %(name)s --&gt; to head</a>
</div>
<div class="page_path"><b>%(fname)s</b></div>
	""" % {
		'myreponame': config.myreponame,
		'hash': p.hash,
		'name': escape(p.name),
		'fname': escape(fname),
	}

	print_diff(dsrc)
	print_footer()

def do_plain_fileheaddiff(phash, fname):
	print_plain_header()
	dsrc = get_file_headdiff(phash, fname)
	for l in dsrc:
		sys.stdout.write(fixu8(l))

def do_darcs_fileheaddiff(phash, fname):
	print_header()
	print_navbar(h = phash, f = fname)
	p = get_patch(phash)
	print """
<div>
  <a class="title" href="%(myreponame)s;a=commit;h=%(hash)s">
    %(name)s --&gt; to head</a>
</div>
<div class="page_path"><b>%(fname)s</b></div>
	""" % {
		'myreponame': config.myreponame,
		'hash': p.hash,
		'name': escape(p.name),
		'fname': escape(fname),
	}

	dsrc = get_darcs_headdiff(phash, fname)
	print_darcs_diff(dsrc)
	print_footer()

	print_plain_header()
	print "Not yet implemented"


def do_commit(phash):
	print_header()
	print_navbar(h = phash)
	p = get_patch(phash)

	print """
<div>
  <a class="title" href="%(myreponame)s;a=commitdiff;h=%(hash)s">%(name)s</a>
</div>

<div class="title_text">
<table cellspacing="0">
<tr><td>author</td><td>%(author)s</td></tr>
<tr><td>local date</td><td>%(local_date)s</td></tr>
<tr><td>date</td><td>%(date)s</td></tr>
<tr><td>hash</td><td style="font-family: monospace">%(hash)s</td></tr>
</table>
</div>
	""" % {
		'myreponame': config.myreponame,
		'author': gen_authorlink(p.author),
		'local_date': p.local_date_str,
		'date': p.date_str,
		'hash': p.hash,
		'name': escape(p.name),
	}
	if p.comment:
		comment = replace_links(escape(p.comment))
		c = comment.replace('\n', '<br/>\n')
		print '<div class="page_body">'
		print replace_links(escape(p.name)), '<br/><br/>'
		print c
		print '</div>'

	changed = p.adds + p.removes + p.modifies.keys() + p.moves.keys() + \
			p.diradds + p.dirremoves + p.replaces.keys()

	if changed or p.moves:
		n = len(changed)
		print '<div class="list_head">%d file(s) changed:</div>' % n

	print '<table cellspacing="0">'
	changed.sort()
	alt = True
	for f in changed:
		if alt:
			print '<tr class="dark">'
		else:
			print '<tr class="light">'
		alt = not alt

		show_diff = 1
		if p.moves.has_key(f):
			# don't show diffs for moves, they're broken as of
			# darcs 1.0.3
			show_diff = 0

		if show_diff:
			print """
<td>
  <a class="list" href="%(myreponame)s;a=filediff;h=%(hash)s;f=%(file)s">
    %(fname)s</a>
</td>
			""" % {
				'myreponame': config.myreponame,
				'hash': p.hash,
				'file': urllib.quote(f),
				'fname': escape(f),
			}
		else:
			print "<td>%s</td>" % f

		show_diff = 1
		if f in p.adds:
			print '<td><span style="color:#008000">',
			print '[added]',
			print '</span></td>'
		elif f in p.diradds:
			print '<td><span style="color:#008000">',
			print '[added dir]',
			print '</span></td>'
		elif f in p.removes:
			print '<td><span style="color:#800000">',
			print '[removed]',
			print '</span></td>'
		elif f in p.dirremoves:
			print '<td><span style="color:#800000">',
			print '[removed dir]',
			print '</span></td>'
		elif p.replaces.has_key(f):
			print '<td><span style="color:#800000">',
			print '[replaced %d tokens]' % p.replaces[f],
			print '</span></td>'
		elif p.moves.has_key(f):
			print '<td><span style="color:#000080">',
			print '[moved to "%s"]' % p.moves[f]
			print '</span></td>'
			show_diff = 0
		else:
			print '<td><span style="color:#000080">',
			if p.modifies[f].has_key('b'):
				# binary modification
				print '(binary)'
			else:
				print '+%(+)d  -%(-)d' % p.modifies[f],
			print '</span></td>'

		if show_diff:
			print """
<td class="link">
  <a href="%(myreponame)s;a=filediff;h=%(hash)s;f=%(file)s">diff</a> |
  <a href="%(myreponame)s;a=filehistory;f=%(file)s">history</a> |
  <a href="%(myreponame)s;a=annotate_shade;h=%(hash)s;f=%(file)s">annotate</a>
</td>
			""" % {
				'myreponame': config.myreponame,
				'hash': p.hash,
				'file': urllib.quote(f)
			}
		print '</tr>'
	print '</table>'
	print_footer()


def do_tree(dname):
	print_header()
	print_navbar()

	# the head
	print """
<div><a class="title" href="%s;a=tree">Current tree</a></div>
<div class="page_path"><b>
	""" % config.myreponame

	# and the linked, with links
	parts = dname.split('/')
	print '/ '
	sofar = '/'
	for p in parts:
		if not p: continue
		sofar += '/' + p
		print '<a href="%s;a=tree;f=%s">%s</a> /' % \
				(config.myreponame, urllib.quote(sofar), p)

	print """
  </b></div>
<div class="page_body">
<table cellspacing="0">
	"""

	path = realpath(dname) + '/'

	alt = True
	files = os.listdir(path)
	files.sort()

	# list directories first
	dlist = []
	flist = []
	for f in files:
		if f == "_darcs":
			continue
		realfile = path + f
		if os.path.isdir(realfile):
			dlist.append(f)
		else:
			flist.append(f)
	files = dlist + flist

	for f in files:
		if alt:
			print '<tr class="dark">'
		else:
			print '<tr class="light">'
		alt = not alt
		realfile = path + f
		fullf = filter_file(dname + '/' + f)
		print '<td style="font-family:monospace">', fperms(realfile),
		print '</td>'
		print '<td style="font-family:monospace">', fsize(realfile),
		print '</td>'

		if f in dlist:
			print """
  <td>
    <a class="link" href="%(myrname)s;a=tree;f=%(fullf)s">%(f)s/</a>
  </td>
  <td class="link">
    <a href="%(myrname)s;a=filehistory;f=%(fullf)s">history</a> |
    <a href="%(myrname)s;a=tree;f=%(fullf)s">tree</a>
  </td>
			""" % {
				'myrname': config.myreponame,
				'f': escape(f),
				'fullf': urllib.quote(fullf),
			}
		else:
			print """
  <td><a class="list" href="%(myrname)s;a=headblob;f=%(fullf)s">%(f)s</a></td>
  <td class="link">
    <a href="%(myrname)s;a=filehistory;f=%(fullf)s">history</a> |
    <a href="%(myrname)s;a=headblob;f=%(fullf)s">headblob</a> |
    <a href="%(myrname)s;a=annotate_shade;f=%(fullf)s">annotate</a>
  </td>
			""" % {
				'myrname': config.myreponame,
				'f': escape(f),
				'fullf': urllib.quote(fullf),
			}
		print '</tr>'
	print '</table></div>'
	print_footer()


def do_headblob(fname):
	print_header()
	print_navbar(f = fname)
	filepath = os.path.dirname(fname)

	if filepath == '/':
		print '<div><a class="title" href="%s;a=tree">/</a></div>' % \
			(config.myreponame)
	else:
		print '<div class="title"><b>'

		# and the linked, with links
		parts = filepath.split('/')
		print '/ '
		sofar = '/'
		for p in parts:
			if not p: continue
			sofar += '/' + p
			print '<a href="%s;a=tree;f=%s">%s</a> /' % \
					(config.myreponame, sofar, p)

		print '</b></div>'

	print_blob(fname)
	print_footer()


def do_plainblob(fname):
	f = open(realpath(fname), 'r')

	if isbinary(fname):
		print_binary_header(os.path.basename(fname))
		for l in f:
			sys.stdout.write(l)
	else:
		print_plain_header()
		for l in f:
			sys.stdout.write(fixu8(l))


def do_annotate(fname, phash, style):
	print_header()
	ann = get_annotate(fname, phash)
	if not ann:
		print """
<i>The annotate feature has been disabled</i>
</div>
		"""
		print_footer()
		return
	print_navbar(f = fname, h = ann.lastchange_hash)

	print """
<div>
  <a class="title" href="%(myreponame)s;a=commit;h=%(hash)s">%(name)s</a>
</div>
<div class="page_path"><b>
  Annotate for file %(fname)s
</b></div>
	""" % {
		'myreponame': config.myreponame,
		'hash': ann.lastchange_hash,
		'name': escape(ann.lastchange_name),
		'fname': escape(fname),
	}

	print_annotate(ann, style)
	print_footer()

def do_annotate_plain(fname, phash):
	print_plain_header()
	ann = get_annotate(fname, phash)
	for l in ann.lines:
		sys.stdout.write(l.text)


def do_shortlog(topi, last=PATCHES_PER_PAGE):
	print_header()
	print_navbar()
	print_shortlog(topi = topi, last = last)
	print_footer()

def do_filehistory(topi, f, last=PATCHES_PER_PAGE):
	print_header()
	print_navbar(f = fname)
	print_shortlog(topi = topi, fname = fname, last = last)
	print_footer()

def do_log(topi, last=PATCHES_PER_PAGE):
	print_header()
	print_navbar()
	print_log(topi = topi, last = last)
	print_footer()

def do_atom():
	print "Content-type: application/atom+xml; charset=utf-8\n"
	print '<?xml version="1.0" encoding="utf-8"?>'
	inv = config.repodir + '/_darcs/patches'
	repo_lastmod = os.stat(inv).st_mtime
	str_lastmod = time.strftime(iso_datetime,
			time.localtime(repo_lastmod))

	print """
<feed xmlns="http://www.w3.org/2005/Atom">
  <title>%(reponame)s darcs repository</title>
  <link rel="alternate" type="text/html" href="%(url)s"/>
  <link rel="self" type="application/atom+xml" href="%(url)s;a=atom"/>
  <id>%(url)s</id> <!-- TODO: find a better <id>, see RFC 4151 -->
  <author><name>darcs repository (several authors)</name></author>
  <generator>darcsweb.cgi</generator>
  <updated>%(lastmod)s</updated> 
  <subtitle>%(desc)s</subtitle>
  	""" % {
		'reponame': config.reponame,
		'url': config.myurl + '/' + config.myreponame,
		'desc': escape(config.repodesc),
		'lastmod': str_lastmod,
	}

	ps = get_last_patches(20)
	for p in ps:
		title = time.strftime('%d %b %H:%M', time.localtime(p.date))
		title += ' - ' + p.name
		pdate = time.strftime(iso_datetime,
				time.localtime(p.date))
		link = '%s/%s;a=commit;h=%s' % (config.myurl,
				config.myreponame, p.hash)

		import email.Utils
		addr, author = email.Utils.parseaddr(p.author)
		if not addr:
			addr = "unknown_email@example.com"
		if not author:
			author = addr

		print """
  <entry>
    <title>%(title)s</title>
    <author>
      <name>%(author)s</name>
      <email>%(email)s</email>
    </author>
    <updated>%(pdate)s</updated>
    <id>%(link)s</id>
    <link rel="alternate" href="%(link)s"/>
    <summary>%(desc)s</summary>
    <content type="xhtml"><div xmlns="http://www.w3.org/1999/xhtml"><p>
	   	""" % {
			'title': escape(title),
			'author': author,
			'email': addr,
			'url': config.myurl + '/' + config.myreponame,
			'pdate': pdate,
			'myrname': config.myreponame,
			'hash': p.hash,
			'pname': escape(p.name),
			'link': link,
			'desc': escape(p.name),
		}

                # TODO: allow to get plain text, not HTML?
		print escape(p.name) + '<br/>'
		if p.comment:
			print '<br/>'
			print escape(p.comment).replace('\n', '<br/>\n')
			print '<br/>'
		print '<br/>'
		changed = p.adds + p.removes + p.modifies.keys() + \
				p.moves.keys() + p.diradds + p.dirremoves + \
				p.replaces.keys()
		for i in changed: # TODO: link to the file 
			print '<code>%s</code><br/>' % i
		print '</p></div>'
		print '</content></entry>'
	print '</feed>'

def do_rss():
	print "Content-type: text/xml; charset=utf-8\n"
	print '<?xml version="1.0" encoding="utf-8"?>'
	print """
<rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
<channel>
 <title>%(reponame)s</title>
  <link>%(url)s</link>
  <description>%(desc)s</description>
  <language>en</language>
  	""" % {
		'reponame': config.reponame,
		'url': config.myurl + '/' + config.myreponame,
		'desc': escape(config.repodesc),
	}

	ps = get_last_patches(20)
	for p in ps:
		title = time.strftime('%d %b %H:%M', time.localtime(p.date))
		title += ' - ' + p.name
		pdate = time.strftime("%a, %d %b %Y %H:%M:%S +0000",
				time.localtime(p.date))
		link = '%s/%s;a=commit;h=%s' % (config.myurl,
				config.myreponame, p.hash)

		# the author field is tricky because the standard requires it
		# has an email address; so we need to check that and lie
		# otherwise; there's more info at
		# http://feedvalidator.org/docs/error/InvalidContact.html
		if "@" in p.author:
			author = p.author
		else:
			author = "%s &lt;unknown@email&gt;" % p.author

		print """
  <item>
    <title>%(title)s</title>
    <author>%(author)s</author>
    <pubDate>%(pdate)s</pubDate>
    <link>%(link)s</link>
    <description>%(desc)s</description>
	   	""" % {
			'title': escape(title),
			'author': author,
			'pdate': pdate,
			'link': link,
			'desc': escape(p.name),
		}
		print '    <content:encoded><![CDATA['
		print escape(p.name) + '<br/>'
		if p.comment:
			print '<br/>'
			print escape(p.comment).replace('\n', '<br/>\n')
			print '<br/>'
		print '<br/>'
		changed = p.adds + p.removes + p.modifies.keys() + \
				p.moves.keys() + p.diradds + p.dirremoves + \
				p.replaces.keys()
		for i in changed:
			print '%s<br/>' % i
		print ']]>'
		print '</content:encoded></item>'

	print '</channel></rss>'


def do_search(s):
	print_header()
	print_navbar()
	ps = get_last_patches(config.searchlimit)

	print '<div class="title">Search last %d commits for "%s"</div>' \
			% (config.searchlimit, escape(s))
	print '<table cellspacing="0">'

	alt = True
	for p in ps:
		match = p.matches(s)
		if not match:
			continue

		if alt:
			print '<tr class="dark">'
		else:
			print '<tr class="light">'
		alt = not alt

		print """
  <td><i>%(age)s</i></td>
  <td>%(author)s</td>
  <td>
    <a class="list" title="%(fullname)s" href="%(myrname)s;a=commit;h=%(hash)s">
      <b>%(name)s</b>
    </a><br/>
    %(match)s
  </td>
  <td class="link">
    <a href="%(myrname)s;a=commit;h=%(hash)s">commit</a> |
    <a href="%(myrname)s;a=commitdiff;h=%(hash)s">commitdiff</a>
  </td>
		""" % {
			'age': how_old(p.local_date),
			'author': gen_authorlink(p.author, shorten_str(p.shortauthor, 26)),
			'myrname': config.myreponame,
			'hash': p.hash,
			'name': escape(shorten_str(p.name)),
			'fullname': escape(p.name),
			'match': highlight(s, shorten_str(match)),
		}
		print "</tr>"

	print '</table>'
	print_footer()


def do_die():
	print_header()
	print "<p><font color=red>Error! Malformed query</font></p>"
	print_footer()


def do_listrepos():
	import config as all_configs
	expand_multi_config(all_configs)

	# the header here is special since we don't have a repo
	print "Content-type: text/html; charset=utf-8\n"
	print '<?xml version="1.0" encoding="utf-8"?>'
	print """
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
		"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
<head>
<meta http-equiv="content-type" content="text/html; charset=utf-8"/>
<meta name="robots" content="index, nofollow"/>
<title>darcs - Repositories</title>
<link rel="stylesheet" type="text/css" href="%(css)s"/>
<link rel="shortcut icon" href="%(fav)s"/>
<link rel="icon" href="%(fav)s"/>
</head>

<body>
<div class="page_header">
<a href="http://darcs.net" title="darcs">
<img src="%(logo)s" alt="darcs logo" style="float:right; border-width:0px;"/>
</a>
<a href="%(myname)s">repos</a> / index
</div>
<div class="index_include">
%(summary)s
</div>
<table cellspacing="0">
<tr>
<th>Project</th>
<th>Description</th>
<th>Owner</th>
<th>Last Change</th>
<th></th>
</tr>
	""" % {
		'myname': config.myname,
		'css': config.cssfile,
		'fav': config.darcsfav,
		'logo': config.darcslogo,
		'summary': config.summary
	}

	# some python magic
	alt = True
	confs = dir(all_configs)
	confs.sort(key=str.lower)
	for conf in confs:
		if conf.startswith('__'):
			continue
		c = all_configs.__getattribute__(conf)
		if 'reponame' not in dir(c):
			continue
		name = escape(c.reponame)
		desc = escape(c.repodesc)

		if alt: print '<tr class="dark">'
		else: print '<tr class="light">'
		alt = not alt
		try: orig_repodir = config.repodir
		except: orig_repodir = None
		config.repodir = c.repodir
		print """
<td><a class="list" href="%(myname)s?r=%(name)s;a=summary">%(dname)s</a></td>
<td>%(desc)s</td>
<td>%(owner)s</td>
<td>%(lastchange)s</td>
<td class="link"><a href="%(myname)s?r=%(name)s;a=summary">summary</a> |
<a href="%(myname)s?r=%(name)s;a=shortlog">shortlog</a> |
<a href="%(myname)s?r=%(name)s;a=log">log</a> |
<a href="%(myname)s?r=%(name)s;a=tree">tree</a>
</td>
</tr>
		""" % {
			'myname': config.myname,
			'dname': name,
			'name': urllib.quote(name),
			'desc': shorten_str(desc, 60),
			'owner': escape(repo_get_owner() or ''),
			'lastchange': how_old(os.stat(c.repodir + '/_darcs/patches').st_mtime),
		}
		config.repodir = orig_repodir
	print "</table>"
	print_footer(put_rss = 0)

def expand_multi_config(config):
	"""Expand configuration entries that serve as "template" to others;
	this make it easier to have a single directory with all the repos,
	because they don't need specific entries in the configuration anymore.
	"""

	for conf in dir(config):
		if conf.startswith('__'):
			continue
		c = config.__getattribute__(conf)
		if 'multidir' not in dir(c):
			continue

		if not os.path.isdir(c.multidir):
			continue

		if 'exclude' not in dir(c):
			c.exclude = []

		entries = []
		if 'multidir_deep' in dir(c) and c.multidir_deep:
			for (root, dirs, files) in os.walk(c.multidir):
				# do not visit hidden directories
				dirs[:] = [d for d in dirs \
						if not d.startswith('.')]
				if '_darcs' in dirs:
					p = root[1 + len(c.multidir):]
					entries.append(p)
		else:
			entries = os.listdir(c.multidir)

		entries.sort()
		for name in entries:
			name = name.replace('\\', '/')
			if name.startswith('.'):
				continue
			fulldir = c.multidir + '/' + name
			if not os.path.isdir(fulldir + '/_darcs'):
				continue
			if name in c.exclude:
				continue

			# set the display name at the beginning, so it can be
			# used by the other replaces
			if 'displayname' in dir(c):
				dname = c.displayname % { 'name': name }
			else:
				dname = name

			rep_dict = { 'name': name, 'dname': dname }

			if 'autoexclude' in dir(c) and c.autoexclude:
				dpath = fulldir + \
					'/_darcs/third_party/darcsweb'
				if not os.path.isdir(dpath):
					continue

			if 'autodesc' in dir(c) and c.autodesc:
				dpath = fulldir + \
					'/_darcs/third_party/darcsweb/desc'
				if os.access(dpath, os.R_OK):
					desc = open(dpath).readline().rstrip("\n")
				else:
					desc = c.repodesc % rep_dict
			else:
				desc = c.repodesc % rep_dict

			if 'autourl' in dir(c) and c.autourl:
				dpath = fulldir + \
					'/_darcs/third_party/darcsweb/url'
				if os.access(dpath, os.R_OK):
					url = open(dpath).readline().rstrip("\n")
				else:
					url = c.repourl % rep_dict
			else:
				url = c.repourl % rep_dict

			if 'autoprojurl' in dir(c) and c.autoprojurl:
				dpath = fulldir + \
					'/_darcs/third_party/darcsweb/projurl'
				if os.access(dpath, os.R_OK):
					projurl = open(dpath).readline().rstrip("\n")
				elif 'repoprojurl' in dir(c):
					projurl = c.repoprojurl % rep_dict
				else:
					projurl = None
			elif 'repoprojurl' in dir(c):
				projurl = c.repoprojurl % rep_dict
			else:
				projurl = None

			if 'autolisturl' in dir(c) and c.autolisturl:
				dpath = fulldir + \
					'/_darcs/third_party/darcsweb/listurl'
				if os.access(dpath, os.R_OK):
					listurl = open(dpath).readline().rstrip("\n")
				elif 'repolisturl' in dir(c):
					listurl = c.repolisturl % rep_dict
				else:
					listurl = None
			elif 'repolisturl' in dir(c):
				listurl = c.repolisturl % rep_dict
			else:
				listurl = None

			rdir = fulldir
			class tmp_config:
				reponame = dname
				repodir = rdir
				repodesc = desc
				repourl = url
				repoencoding = c.repoencoding
				repoprojurl = projurl
				repolisturl = listurl

				if 'footer' in dir(c):
					footer = c.footer

			# index by display name to avoid clashes
			config.__setattr__(dname, tmp_config)

def fill_config(name = None):
	import config as all_configs
	expand_multi_config(all_configs)

	if name:
		# we only care about setting some configurations if a repo was
		# specified; otherwise we only set the common configuration
		# directives
		for conf in dir(all_configs):
			if conf.startswith('__'):
				continue
			c = all_configs.__getattribute__(conf)
			if 'reponame' not in dir(c):
				continue
			if c.reponame == name:
				break
		else:
			# not found
			raise Exception, "Repo not found: " + repr(name)

	# fill the configuration
	base = all_configs.base
	if 'myname' not in dir(base):
		# SCRIPT_NAME has the full path, we only take the file name
		config.myname = os.path.basename(os.environ['SCRIPT_NAME'])
	else:
		config.myname = base.myname

	if 'myurl' not in dir(base):
		n = os.environ['SERVER_NAME']
		p = os.environ['SERVER_PORT']
		s = os.path.dirname(os.environ['SCRIPT_NAME'])
		u = os.environ.get('HTTPS', 'off') in ('on', '1')
		if not u and p == '80' or u and p == '443':
			p = ''
		else:
			p = ':' + p
		config.myurl = 'http%s://%s%s%s' % (u and 's' or '', n, p, s)
	else:
		config.myurl = base.myurl

	config.darcslogo = base.darcslogo
	config.darcsfav = base.darcsfav
	config.cssfile = base.cssfile
	if name:
		config.myreponame = config.myname + '?r=' + urllib.quote(name)
		config.reponame = c.reponame
		config.repodesc = c.repodesc
		config.repodir = c.repodir
		config.repourl = c.repourl

		config.repoprojurl = None
		if 'repoprojurl' in dir(c):
			config.repoprojurl = c.repoprojurl

		config.repolisturl = None
		if 'repolisturl' in dir(c):
			config.repolisturl = c.repolisturl

		# repoencoding must be a tuple
		if isinstance(c.repoencoding, str):
			config.repoencoding = (c.repoencoding, )
		else:
			config.repoencoding = c.repoencoding

	# optional parameters
	if "darcspath" in dir(base):
		config.darcspath = base.darcspath + '/'
	else:
		config.darcspath = ""

	if "summary" in dir(base):
		config.summary = base.summary
	else:
		config.summary = """
This is the repository index for a darcsweb site.<br/>
These are all the available repositories.<br/>
		"""

	if "cachedir" in dir(base):
		config.cachedir = base.cachedir
	else:
		config.cachedir = None

	if "searchlimit" in dir(base):
		config.searchlimit = base.searchlimit
	else:
		config.searchlimit = 100

	if "logtimes" in dir(base):
		config.logtimes = base.logtimes
	else:
		config.logtimes = None

	if "url_links" in dir(base):
		config.url_links = base.url_links
	else:
		config.url_links = ()

	if name and "footer" in dir(c):
		config.footer = c.footer
	elif "footer" in dir(base):
		config.footer = base.footer
	else:
		config.footer = "Crece desde el pueblo el futuro / " \
				+ "crece desde el pie"
	if "author_links" in dir(base):
		config.author_links = base.author_links
	else:
		config.author_links = None
	if "disable_annotate" in dir(base):
		config.disable_annotate = base.disable_annotate
	else:
		config.disable_annotate = False

	if "readme_converter" in dir(base):
		config.readme_converter = base.readme_converter
	else:
		config.readme_converter = False



#
# main
#

if sys.version_info < (2, 3):
	print "Sorry, but Python 2.3 or above is required to run darcsweb."
	sys.exit(1)

form = cgi.FieldStorage()

# if they don't specify a repo, print the list and exit
if not form.has_key('r'):
	fill_config()
	do_listrepos()
	log_times(cache_hit = 0, event = 'index')
	sys.exit(0)

# get the repo configuration and fill the config class
current_repo = urllib.unquote(form['r'].value)
fill_config(current_repo)


# get the action, or default to summary
if not form.has_key("a"):
	action = "summary"
else:
	action = filter_act(form["a"].value)

# check if we have the page in the cache
if config.cachedir:
	url_request = os.environ['QUERY_STRING']
	# create a string representation of the request, ignoring all the
	# unused parameters to avoid DoS
	params = ['r', 'a', 'f', 'h', 'topi', 'last']
	params = [ x for x in form.keys() if x in params ]
	url_request = [ (x, form[x].value) for x in params ]
	url_request.sort()
	cache = Cache(config.cachedir, url_request)
	if cache.open():
		# we have a hit, dump and run
		cache.dump()
		cache.close()
		log_times(cache_hit = 1, repo = config.reponame)
		sys.exit(0)
	# if there is a miss, the cache will step over stdout, intercepting
	# all "print"s and writing them to the cache file automatically


# see what should we do according to the received action
if action == "summary":
	do_summary()

elif action == "commit":
	phash = filter_hash(form["h"].value)
	do_commit(phash)
elif action == "commitdiff":
	phash = filter_hash(form["h"].value)
	do_commitdiff(phash)
elif action == "plain_commitdiff":
	phash = filter_hash(form["h"].value)
	do_plain_commitdiff(phash)
elif action == "darcs_commitdiff":
	phash = filter_hash(form["h"].value)
	do_darcs_commitdiff(phash)
elif action == "raw_commitdiff":
	phash = filter_hash(form["h"].value)
	do_raw_commitdiff(phash)

elif action == 'headdiff':
	phash = filter_hash(form["h"].value)
	do_headdiff(phash)
elif action == "plain_headdiff":
	phash = filter_hash(form["h"].value)
	do_plain_headdiff(phash)
elif action == "darcs_headdiff":
        phash = filter_hash(form["h"].value)
        do_darcs_headdiff(phash)

elif action == "filediff":
	phash = filter_hash(form["h"].value)
	fname = filter_file(form["f"].value)
	do_filediff(phash, fname)
elif action == "plain_filediff":
	phash = filter_hash(form["h"].value)
	fname = filter_file(form["f"].value)
	do_plain_filediff(phash, fname)
elif action == "darcs_filediff":
        phash = filter_hash(form["h"].value)
	fname = filter_file(form["f"].value)
	do_darcs_filediff(phash, fname)

elif action == 'headfilediff':
	phash = filter_hash(form["h"].value)
	fname = filter_file(form["f"].value)
	do_file_headdiff(phash, fname)
elif action == "plain_headfilediff":
	phash = filter_hash(form["h"].value)
	fname = filter_file(form["f"].value)
	do_plain_fileheaddiff(phash, fname)
elif action == "darcs_headfilediff":
        phash = filter_hash(form["h"].value)
	fname = filter_file(form["f"].value)
        do_darcs_fileheaddiff(phash, fname)

elif action == "annotate_normal":
	fname = filter_file(form["f"].value)
	if form.has_key("h"):
		phash = filter_hash(form["h"].value)
	else:
		phash = None
	do_annotate(fname, phash, "normal")
elif action == "annotate_plain":
	fname = filter_file(form["f"].value)
	if form.has_key("h"):
		phash = filter_hash(form["h"].value)
	else:
		phash = None
        do_annotate_plain(fname, phash)
elif action == "annotate_zebra":
	fname = filter_file(form["f"].value)
	if form.has_key("h"):
		phash = filter_hash(form["h"].value)
	else:
		phash = None
	do_annotate(fname, phash, "zebra")
elif action == "annotate_shade":
	fname = filter_file(form["f"].value)
	if form.has_key("h"):
		phash = filter_hash(form["h"].value)
	else:
		phash = None
	do_annotate(fname, phash, "shade")

elif action == "shortlog":
	if form.has_key("topi"):
		topi = int(filter_num(form["topi"].value))
	else:
		topi = 0
	if form.has_key("last"):
		last = int(filter_num(form["last"].value))
	else:
		last = PATCHES_PER_PAGE
	do_shortlog(topi=topi,last=last)

elif action == "filehistory":
	if form.has_key("topi"):
		topi = int(filter_num(form["topi"].value))
	else:
		topi = 0
	fname = filter_file(form["f"].value)
	if form.has_key("last"):
		last = int(filter_num(form["last"].value))
	else:
		last = PATCHES_PER_PAGE
	do_filehistory(topi, fname, last=last)

elif action == "log":
	if form.has_key("topi"):
		topi = int(filter_num(form["topi"].value))
	else:
		topi = 0
	if form.has_key("last"):
		last = int(filter_num(form["last"].value))
	else:
		last = PATCHES_PER_PAGE
	do_log(topi, last=last)

elif action == 'headblob':
	fname = filter_file(form["f"].value)
	do_headblob(fname)

elif action == 'plainblob':
	fname = filter_file(form["f"].value)
	do_plainblob(fname)

elif action == 'tree':
	if form.has_key('f'):
		fname = filter_file(form["f"].value)
	else:
		fname = '/'
	do_tree(fname)

elif action == 'rss':
	do_rss()

elif action == 'atom':
	do_atom()

elif action == 'search':
	if form.has_key('s'):
		s = form["s"].value
	else:
		s = ''
	do_search(s)
	if config.cachedir:
		cache.cancel()

else:
	action = "invalid query"
	do_die()
	if config.cachedir:
		cache.cancel()


if config.cachedir:
	cache.close()

log_times(cache_hit = 0, repo = config.reponame)