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

    if config['debug'] and not test:

        #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

        if setting_id == 'mapping':

            rm_obsolete = request.POST.get('destroy', False)

            log.debug('Rescanning directories with destroy=%s', rm_obsolete)

            initial = HgModel.repo_scan(g.paths[0][0], g.paths[0][1], g.baseui)

            repo2db_mapper(initial, rm_obsolete)

            invalidate_cache('cached_repo_list')

            h.flash(_('Repositories sucessfully rescanned'), category='success')            

        if setting_id == 'whoosh':

            repo_location = get_hg_ui_settings()['paths_root_path']

            full_index = request.POST.get('full_index',False)

            h.flash(_('Whoosh reindex task scheduled'), category='success')

        if setting_id == 'global':

            application_form = ApplicationSettingsForm()()

            try:

                form_result = application_form.to_python(dict(request.POST))

                try:

                    hgsettings1 = self.sa.query(HgAppSettings)\

                    .filter(HgAppSettings.app_settings_name == 'title').one()

                    hgsettings1.app_settings_value = form_result['hg_app_title'] 

                                        'user':str(c.hg_app_user.username),

                                        'host':e.get('HTTP_HOST'),

                                        'repo_name':c.repo_name, }

        c.clone_repo_url = uri

        c.repo_tags = OrderedDict()

        for name, hash in c.repo_info.tags.items()[:10]:

            c.repo_tags[name] = c.repo_info.get_changeset(hash)

        c.repo_branches = OrderedDict()

        for name, hash in c.repo_info.branches.items()[:10]:

            c.repo_branches[name] = c.repo_info.get_changeset(hash)

        c.ts_min = task.result[0]

        c.ts_max = task.result[1]

        c.commit_data = task.result[2]

        return render('summary/summary.html')

# as published by the Free Software Foundation; version 2

# of the License or (at your opinion) any later version of the license.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

"""

Created on April 18, 2010

Utilities for hg app

@author: marcink

"""

from beaker.cache import cache_region

from mercurial import ui, config, hg

from mercurial.error import RepoError

from pylons_app.model import meta

from pylons_app.model.db import Repository, User, HgAppUi, HgAppSettings

from vcs.backends.base import BaseChangeset

from vcs.utils.lazy import LazyProperty

import logging

import os

log = logging.getLogger(__name__)

def get_repo_slug(request):

    return request.environ['pylons.routes_dict'].get('repo_name')

def is_mercurial(environ):

    """

    Returns True if request's target is mercurial server - header

    ``HTTP_ACCEPT`` of such request would start with ``application/mercurial``.

    """

    http_accept = environ.get('HTTP_ACCEPT')

        d = cls()

        for key in iterable:

            d[key] = value

        return d

    def __eq__(self, other):

        if isinstance(other, OrderedDict):

            return len(self) == len(other) and self.items() == other.items()

        return dict.__eq__(self, other)

    def __ne__(self, other):

        return not self == other

"""The application's model objects"""

import logging

from pylons_app.model import meta

log = logging.getLogger(__name__)

def init_model(engine):

    """Call me before using any of the tables or classes in the model"""

    log.info("INITIALIZING DB MODELS")

    meta.Base.metadata.bind = engine

    #meta.Base2.metadata.bind = engine2

#THIS IS A TEST FOR EXECUTING SCRIPT AND LOAD PYLONS APPLICATION GLOBALS

#from paste.deploy import appconfig

#from pylons import config

#from sqlalchemy import engine_from_config

#from pylons_app.config.environment import load_environment

#

class HgAppUi(Base):

    __tablename__ = 'hg_app_ui'

    __table_args__ = {'useexisting':True}

    ui_id = Column("ui_id", INTEGER(), nullable=False, unique=True, default=None, primary_key=True)

    ui_section = Column("ui_section", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    ui_key = Column("ui_key", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    ui_value = Column("ui_value", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    ui_active = Column("ui_active", BOOLEAN(), nullable=True, unique=None, default=True)

class User(Base): 

    __tablename__ = 'users'

    user_id = Column("user_id", INTEGER(), nullable=False, unique=True, default=None, primary_key=True)

    username = Column("username", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    password = Column("password", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    active = Column("active", BOOLEAN(), nullable=True, unique=None, default=None)

    admin = Column("admin", BOOLEAN(), nullable=True, unique=None, default=False)

    name = Column("name", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    lastname = Column("lastname", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    email = Column("email", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    last_login = Column("last_login", DATETIME(timezone=False), nullable=True, unique=None, default=None)

    user_log = relation('UserLog')

    user_perms = relation('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id")

        sa = meta.Session()

        def check_repo_dir(path):

            """

            Checks the repository

            :param path:

            """

            repos_path = path.split('/')

            if repos_path[-1] in ['*', '**']:

                repos_path = repos_path[:-1]

            if repos_path[0] != '/':

                repos_path[0] = '/'

            if not os.path.isdir(os.path.join(*repos_path)):

        if not repos_path.endswith('*'):

            raise VCSError('You need to specify * or ** at the end of path '

                            'for recursive scanning')

        check_repo_dir(repos_path)

        log.info('scanning for repositories in %s', repos_path)

        repos = findrepos([(repos_prefix, repos_path)])

        if not isinstance(baseui, ui.ui):

            baseui = ui.ui()

        repos_list = {}

        for name, path in repos:

This module initializes the application via ``websetup`` (`paster

setup-app`) and provides the base testing objects.

"""

from unittest import TestCase

from paste.deploy import loadapp

from paste.script.appinstall import SetupCommand

from pylons import config, url

from routes.util import URLGenerator

from webtest import TestApp

import os

from pylons_app.model import meta

import pylons.test

__all__ = ['environ', 'url', 'TestController']

# Invoke websetup with the current 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'

from pylons_app.tests import *

class TestAdminController(TestController):

    def test_index(self):

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

        # Test response...

from pylons_app.tests import *

class TestBranchesController(TestController):

    def test_index(self):

        response = self.app.get(url(controller='branches', action='index',repo_name='vcs_test'))

        # Test response...

from pylons_app.tests import *

class TestChangelogController(TestController):

    def test_index(self):

        response = self.app.get(url(controller='changelog', action='index',repo_name='vcs_test'))

        # Test response...

from pylons_app.tests import *

class TestFeedController(TestController):

    def test_rss(self):

        response = self.app.get(url(controller='feed', action='rss',

                                    repo_name='vcs_test'))

        # Test response...

    def test_atom(self):

        response = self.app.get(url(controller='feed', action='atom',

                                    repo_name='vcs_test'))

        # Test response...

from pylons_app.tests import *

class TestFilesController(TestController):

    def test_index(self):

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

                                    repo_name='vcs_test',

                                    revision='tip',

                                    f_path='/'))

        # Test response...

                                             'email':'goodmailm',

                                             'name':'test',

                                             'lastname':'test'})

        assert response.status == '200 OK', 'Wrong response from register page got %s' % response.status

        assert 'An email address must contain a single @' in response.body

        assert 'Enter a value 3 characters long or more' in response.body

        assert 'Please enter a value<' in response.body

    def test_register_ok(self):

        password = 'qweqwe'

        name = 'testname'

        lastname = 'testlastname'

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

                                            {'username':username,

                                             'password':password,

                                             'email':email,

                                             'name':name,

                                             'lastname':lastname})

        assert response.status == '302 Found', 'Wrong response from register page got %s' % response.status        

        assert ret.username == username , 'field mismatch %s %s' % (ret.username, username)

        assert check_password(password,ret.password) == True , 'password mismatch'

        assert ret.email == email , 'field mismatch %s %s' % (ret.email, email)

        assert ret.name == name , 'field mismatch %s %s' % (ret.name, name)

        assert ret.lastname == lastname , 'field mismatch %s %s' % (ret.lastname, lastname)

from pylons_app.tests import *

class TestSettingsController(TestController):

    def test_index(self):

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

                                    repo_name='vcs_test'))

        # Test response...

from pylons_app.tests import *

class TestShortlogController(TestController):

    def test_index(self):

        response = self.app.get(url(controller='shortlog', action='index',repo_name='vcs_test'))

        # Test response...

from pylons_app.tests import *

class TestSummaryController(TestController):

    def test_index(self):

        response = self.app.get(url(controller='summary', action='index',repo_name='vcs_test'))

        # Test response...

from pylons_app.tests import *

class TestTagsController(TestController):

    def test_index(self):

        response = self.app.get(url(controller='tags', action='index',repo_name='vcs_test'))

        # Test response...

"""Setup the pylons_app application"""

from pylons_app.config.environment import load_environment

from pylons_app.lib.db_manage import DbManage

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]

    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)

[egg_info]

tag_build = dev

tag_svn_revision = true

[easy_install]

find_links = http://www.pylonshq.com/download/

[nosetests]

verbose=True

verbosity=2

detailed-errors=1

# Babel configuration

[compile_catalog]

domain = pylons_app

directory = pylons_app/i18n

statistics = true

[extract_messages]

add_comments = TRANSLATORS:

output_file = pylons_app/i18n/pylons_app.pot

width = 80