pylons.cache._push_object(config['pylons.app_globals'].cache)

    # Create the Mako TemplateLookup, with the default auto-escaping

    config['pylons.app_globals'].mako_lookup = TemplateLookup(

        directories=paths['templates'],

        error_handler=handle_mako_error,

        module_directory=os.path.join(app_conf['cache_dir'], 'templates'),

        input_encoding='utf-8', default_filters=['escape'],

        imports=['from webhelpers.html import escape'])

    #sets the c attribute access when don't existing attribute are accessed

    config['pylons.strict_tmpl_context'] = True

    #MULTIPLE DB configs

    # Setup the SQLAlchemy database engine

        #use query time debugging.

        from pylons_app.lib.timerproxy import TimerProxy

        sa_engine_db1 = engine_from_config(config, 'sqlalchemy.db1.',

                                                            proxy=TimerProxy())

    else:

        sa_engine_db1 = engine_from_config(config, 'sqlalchemy.db1.')

    init_model(sa_engine_db1)

    #init baseui

    config['pylons.app_globals'].baseui = make_ui('db')

    repo2db_mapper(_get_repos_cached_initial(config['pylons.app_globals'], initial))

                cs1 = filenode_old.last_changeset.raw_id

                cs2 = node.last_changeset.raw_id                    

                c.changes.append(('changed', node, diff, cs1, cs2))

            for node in c.changeset.removed:

                c.changes.append(('removed', node, None, None, None))            

        return render('changeset/changeset.html')

    def raw_changeset(self,revision):

        hg_model = HgModel()

        try:

            c.changeset = hg_model.get_repo(c.repo_name).get_changeset(revision)

        except RepositoryError:

            log.error(traceback.format_exc())

            return redirect(url('hg_home'))

        else:

            try:

                c.changeset_old = c.changeset.parents[0]

            except IndexError:

                c.changeset_old = None

            c.changes = []

                filenode_old = c.changeset_old.get_node(node.path)

                if filenode_old.is_binary or node.is_binary:

                    diff = 'binary file'

                else:    

                    f_udiff = differ.get_udiff(filenode_old, node)

                    diff = differ.DiffProcessor(f_udiff).raw_diff()

                cs1 = filenode_old.last_changeset.raw_id

                cs2 = node.last_changeset.raw_id                    

                c.changes.append(('changed', node, diff, cs1, cs2))      

        response.content_type = 'text/plain'

        parent = True if len(c.changeset.parents) > 0 else False

        c.parent_tmpl = 'Parent  %s' % c.changeset.parents[0]._hex if parent else ''

        c.diffs = ''

        for x in c.changes:

            c.diffs += x[2]

        return render('changeset/raw_changeset.html')

<%def name="page_nav()">

    ${self.menu('changelog')}     

</%def>

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

    </div>

    <div class="table">

    <div id="changeset_content">

		<div class="container">

			<div class="left">

				<div class="date">${_('Date')}: ${c.changeset.date}</div>

				<div class="author">${_('Author')}: ${c.changeset.author}</div>

				<div class="message">${h.wrap_paragraphs(c.changeset.message)}</div>

			</div>	

			<div class="right">

				<span class="logtags">

					<span class="branchtag">${c.changeset.branch}</span>

					%for tag in c.changeset.tags:

						<span class="tagtag">${tag}</span>

# HG changeset patch

# Date ${"%d %d" % c.changeset._ctx.date()}

# Node ID ${c.changeset._hex}

# ${c.parent_tmpl}

${c.changeset.message}

${c.diffs|n}

# Invoke websetup with the current config file

SetupCommand('setup-app').run([pylons.test.pylonsapp.config['__file__']])

environ = {}

class TestController(TestCase):

    def __init__(self, *args, **kwargs):

        wsgiapp = pylons.test.pylonsapp

        config = wsgiapp.config

        self.app = TestApp(wsgiapp)

        url._push_object(URLGenerator(config['routes.map'], environ))

        self.sa = meta.Session

        TestCase.__init__(self, *args, **kwargs)

    def log_user(self):

        response = self.app.post(url(controller='login', action='index'),

                                 {'username':'test_admin',

                                  'password':'test'})

        assert response.status == '302 Found', 'Wrong response code from login got %s' % response.status

        assert response.session['hg_app_user'].username == 'test_admin', 'wrong logged in user'

        return response.follow()        

from pylons_app.tests import *

class TestSearchController(TestController):

    def test_index(self):

        self.log_user()

        response = self.app.get(url(controller='search', action='index'))

        print response.body

        assert 'class="small" id="q" name="q" type="text"' in response.body,'Search box content error'

        # Test response...

    def test_empty_search(self):

        self.log_user()

"""Setup the pylons_app application"""

from os.path import dirname as dn, join as jn

from pylons_app.config.environment import load_environment

from pylons_app.lib.db_manage import DbManage

import datetime

from time import mktime

import logging

import os

import sys

log = logging.getLogger(__name__)

ROOT = dn(dn(os.path.realpath(__file__)))

sys.path.append(ROOT)

def setup_app(command, conf, vars):

    """Place any commands to setup pylons_app here"""

    log_sql = True

    tests = False

    dbname = os.path.split(conf['sqlalchemy.db1.url'])[-1]

    filename = os.path.split(conf.filename)[-1]

    if filename == 'tests.ini':

        uniq_suffix = str(int(mktime(datetime.datetime.now().timetuple())))

        REPO_TEST_PATH = '/tmp/hg_app_test_%s' % uniq_suffix

        if not os.path.isdir(REPO_TEST_PATH):

            os.mkdir(REPO_TEST_PATH)

        tests = True    

    dbmanage = DbManage(log_sql, dbname, tests)

    dbmanage.create_tables(override=True)

    dbmanage.config_prompt(REPO_TEST_PATH)

    dbmanage.create_default_user()

    dbmanage.admin_prompt()

    dbmanage.create_permissions()

    dbmanage.populate_default_permissions()

    load_environment(conf.global_conf, conf.local_conf, initial=True)