def initialize(cfg):
# import and initialize plugins
plugin_utils.initialize_plugins(cfg['plugin_dirs'], cfg['load_plugins'])
# entryparser callback is run here first to allow other
# plugins register what file extensions can be used
extensions = tools.run_callback(
"entryparser",
{'txt': blosxom_entry_parser},
mappingfunc=lambda x, y: y,
defaultfunc=lambda x: x)
# go through the config.py and override entryparser extensions
for ext, parser_module in cfg['entryparsers'].items():
module, callable_name = parser_module.rsplit(':', 1)
module = tools.importname(None, module)
extensions[ext] = getattr(module, callable_name)
# FIXME - this is a lousy place to store this
cfg['extensions'] = extensions
def blosxom_handler(request):
"""This is the default blosxom handler.
It calls the renderer callback to get a renderer. If there is no
renderer, it uses the blosxom renderer.
It calls the pathinfo callback to process the path_info http
variable.
It calls the filelist callback to build a list of entries to
display.
It calls the prepare callback to do any additional preparation
before rendering the entries.
Then it tells the renderer to render the entries.
:param request: the request object.
"""
config = request.get_configuration()
data = request.get_data()
# go through the renderer callback to see if anyone else wants to
# render. this renderer gets stored in the data dict for
# downstream processing.
rend = tools.run_callback('renderer',
{'request': request},
donefunc = lambda x: x != None,
defaultfunc = lambda x: None)
if not rend:
# get the renderer we want to use
rend = config.get("renderer", "jinjarenderer")
# import the renderer
rend = tools.importname("douglas.renderers", rend)
# get the renderer object
rend = rend.Renderer(request, config.get("stdoutput", sys.stdout))
data['renderer'] = rend
# generate the timezone variable
data["timezone"] = time.tzname[time.localtime()[8]]
# process the path info to determine what kind of blog entry(ies)
# this is
tools.run_callback("pathinfo",
{"request": request},
donefunc=lambda x:x != None,
defaultfunc=blosxom_process_path_info)
# call the filelist callback to generate a list of entries
data["entry_list"] = tools.run_callback(
"filelist",
{"request": request},
donefunc=lambda x:x != None,
defaultfunc=blosxom_file_list_handler)
# figure out the blog-level mtime which is the mtime of the head
# of the entry_list
entry_list = data["entry_list"]
if isinstance(entry_list, list) and len(entry_list) > 0:
mtime = entry_list[0].get("mtime", time.time())
else:
mtime = time.time()
mtime_tuple = time.localtime(mtime)
mtime_gmtuple = time.gmtime(mtime)
data["latest_date"] = time.strftime('%a, %d %b %Y', mtime_tuple)
# Make sure we get proper 'English' dates when using standards
loc = locale.getlocale(locale.LC_ALL)
locale.setlocale(locale.LC_ALL, 'C')
data["latest_w3cdate"] = time.strftime('%Y-%m-%dT%H:%M:%SZ',
mtime_gmtuple)
data['latest_rfc822date'] = time.strftime('%a, %d %b %Y %H:%M GMT',
mtime_gmtuple)
# set the locale back
locale.setlocale(locale.LC_ALL, loc)
# we pass the request with the entry_list through the prepare
# callback giving everyone a chance to transform the data. the
# request is modified in place.
tools.run_callback("prepare", {"request": request})
# now we pass the entry_list through the renderer
entry_list = data["entry_list"]
renderer = data['renderer']
if renderer and not renderer.rendered:
if entry_list:
renderer.set_content(entry_list)
else:
renderer.add_header('Status', '404 Not Found')
renderer.set_content(
{'title': 'The page you are looking for is not available',
'body': 'Somehow I cannot find the page you want. ' +
'Go Back to <a href="%s">%s</a>?'
% (config["base_url"], config["blog_title"])})
renderer.render()
elif not renderer:
output = config.get('stdoutput', sys.stdout)
output.write("Content-Type: text/plain\n\n" +
"There is something wrong with your setup.\n" +
"Check your config files and verify that your " +
"configuration is correct.\n")
def test_goodimport(self):
import string
self.eq_(tools.importname("", "string"), string)
import os.path
self.eq_(tools.importname("os", "path"), os.path)
def test_badimport(self):
self.eq_(tools.importname("", "foo"), None)
def _c(self, mn, n):
m = tools.importname(mn, n)
# print repr(m)
return m