:author: marcink

    :copyright: (C) 2009-2011 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# 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.

import platform

VERSION = (1, 2, 0, 'beta')

__version__ = '.'.join((str(each) for each in VERSION[:4]))

__dbversion__ = 3 #defines current db version for migrations

__platform__ = platform.system()

try:

    from rhodecode.lib.utils import get_current_revision

    _rev = get_current_revision()

except ImportError:

    #this is needed when doing some setup.py operations

    _rev = False

if len(VERSION) > 3 and _rev:

    __version__ += ' [rev:%s]' % _rev[0]

def get_version():

    """Returns shorter version (digit parts only) as string."""

    return '.'.join((str(each) for each in VERSION[:3]))

BACKENDS = {

    'hg': 'Mercurial repository',

    #'git': 'Git repository',

}

"""Pylons environment configuration"""

import os

import logging

from mako.lookup import TemplateLookup

from pylons.configuration import PylonsConfig

from pylons.error import handle_mako_error

from sqlalchemy import engine_from_config

import rhodecode.lib.app_globals as app_globals

import rhodecode.lib.helpers

from rhodecode.config.routing import make_map

from rhodecode.lib import celerypylons

from rhodecode.lib.auth import set_available_permissions

from rhodecode.lib.utils import repo2db_mapper, make_ui, set_rhodecode_config

from rhodecode.model import init_model

from rhodecode.model.scm import ScmModel

from rhodecode.lib.timerproxy import TimerProxy

log = logging.getLogger(__name__)

def load_environment(global_conf, app_conf, initial=False):

    """Configure the Pylons environment via the ``pylons.config``

    object

    """

    config = PylonsConfig()

    # Pylons paths

    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

    paths = dict(root=root,

                 controllers=os.path.join(root, 'controllers'),

                 static_files=os.path.join(root, 'public'),

                 templates=[os.path.join(root, 'templates')])

    # Initialize config with the basic options

    config.init_app(global_conf, app_conf, package='rhodecode', paths=paths)

    config['routes.map'] = make_map(config)

    config['pylons.app_globals'] = app_globals.Globals(config)

    config['pylons.h'] = rhodecode.lib.helpers

    # Setup cache object as early as possible

    import pylons

    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

    test = os.path.split(config['__file__'])[-1] == 'test.ini'

    if test:

        from rhodecode.lib.utils import create_test_env, create_test_index

        from rhodecode.tests import  TESTS_TMP_PATH

        create_test_env(TESTS_TMP_PATH, config)

        create_test_index(TESTS_TMP_PATH, True)

    #MULTIPLE DB configs

    # Setup the SQLAlchemy database engine

    if config['debug'] and not test:

        #use query time debugging.

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

    else:

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

    init_model(sa_engine_db1)

    repos_path = make_ui('db').configitems('paths')[0][1]

    repo2db_mapper(ScmModel().repo_scan(repos_path))

    set_available_permissions(config)

    config['base_path'] = repos_path

    set_rhodecode_config(config)

    # CONFIGURATION OPTIONS HERE (note: all config options will override

    # any Pylons config options)

    return config

"""Pylons middleware initialization"""

from beaker.middleware import SessionMiddleware

from routes.middleware import RoutesMiddleware

from paste.cascade import Cascade

from paste.registry import RegistryManager

from paste.urlparser import StaticURLParser

from paste.deploy.converters import asbool

from paste.gzipper import make_gzip_middleware

from pylons.middleware import ErrorHandler, StatusCodeRedirect

from pylons.wsgiapp import PylonsApp

from rhodecode.lib.middleware.simplehg import SimpleHg

from rhodecode.lib.middleware.simplegit import SimpleGit

from rhodecode.lib.middleware.https_fixup import HttpsFixup

from rhodecode.config.environment import load_environment

def make_app(global_conf, full_stack=True, static_files=True, **app_conf):

    """Create a Pylons WSGI application and return it

    ``global_conf``

        The inherited configuration for this application. Normally from

        the [DEFAULT] section of the Paste ini file.

    ``full_stack``

        Whether or not this application provides a full WSGI stack (by

        default, meaning it handles its own exceptions and errors).

        Disable full_stack when this application is "managed" by

        another WSGI middleware.

    ``app_conf``

        The application's local configuration. Normally specified in

        the [app:<name>] section of the Paste ini file (where <name>

        defaults to main).

    """

    # Configure the Pylons environment

    config = load_environment(global_conf, app_conf)

    # The Pylons WSGI app

    app = PylonsApp(config=config)

"""

Routes configuration

The more specific and detailed routes should be defined first so they

may take precedent over the more generic routes. For more information

refer to the routes manual at http://routes.groovie.org/docs/

"""

from __future__ import with_statement

from routes import Mapper

from rhodecode.lib.utils import check_repo_fast as cr

def make_map(config):

    """Create, configure and return the routes Mapper"""

    routes_map = Mapper(directory=config['pylons.paths']['controllers'],

                 always_scan=config['debug'])

    routes_map.minimization = False

    routes_map.explicit = False

    def check_repo(environ, match_dict):

        """

        check for valid repository for proper 404 handling

        :param environ:

        :param match_dict:

        """

        repo_name = match_dict.get('repo_name')

        return not cr(repo_name, config['base_path'])

    # The ErrorController route (handles 404/500 error pages); it should

    # likely stay at the top, ensuring it can always be resolved

    routes_map.connect('/error/{action}', controller='error')

    routes_map.connect('/error/{action}/{id}', controller='error')

    #==========================================================================

    # CUSTOM ROUTES HERE

    #==========================================================================

    #MAIN PAGE

    routes_map.connect('home', '/', controller='home', action='index')

    routes_map.connect('repo_switcher', '/repos', controller='home', action='repo_switcher')

    routes_map.connect('bugtracker', "http://bitbucket.org/marcinkuzminski/rhodecode/issues", _static=True)

    routes_map.connect('rhodecode_official', "http://rhodecode.org", _static=True)

    #ADMIN REPOSITORY REST ROUTES

    with routes_map.submapper(path_prefix='/_admin', controller='admin/repos') as m:

        m.connect("repos", "/repos",

             action="create", conditions=dict(method=["POST"]))

        m.connect("repos", "/repos",

             action="index", conditions=dict(method=["GET"]))

        m.connect("formatted_repos", "/repos.{format}",

             action="index",

            conditions=dict(method=["GET"]))

        m.connect("new_repo", "/repos/new",

             action="new", conditions=dict(method=["GET"]))

        m.connect("formatted_new_repo", "/repos/new.{format}",

             action="new", conditions=dict(method=["GET"]))

        m.connect("/repos/{repo_name:.*}",

             action="update", conditions=dict(method=["PUT"],

                                              function=check_repo))

        m.connect("/repos/{repo_name:.*}",

             action="delete", conditions=dict(method=["DELETE"],

                                              function=check_repo))

        m.connect("edit_repo", "/repos/{repo_name:.*}/edit",

             action="edit", conditions=dict(method=["GET"],

                                            function=check_repo))

             action="repo_public_journal", conditions=dict(method=["PUT"],

                                                        function=check_repo))

        m.connect('repo_pull', "/repo_pull/{repo_name:.*}",

             action="repo_pull", conditions=dict(method=["PUT"],

                                                        function=check_repo))

    #ADMIN REPOS GROUP REST ROUTES

    routes_map.resource('repos_group', 'repos_groups', controller='admin/repos_groups', path_prefix='/_admin')

    #ADMIN USER REST ROUTES

    routes_map.resource('user', 'users', controller='admin/users', path_prefix='/_admin')

    #ADMIN USERS REST ROUTES

    routes_map.resource('users_group', 'users_groups', controller='admin/users_groups', path_prefix='/_admin')

    #ADMIN GROUP REST ROUTES

    routes_map.resource('group', 'groups', controller='admin/groups', path_prefix='/_admin')

    #ADMIN PERMISSIONS REST ROUTES

    routes_map.resource('permission', 'permissions', controller='admin/permissions', path_prefix='/_admin')

    ##ADMIN LDAP SETTINGS

    routes_map.connect('ldap_settings', '/_admin/ldap', controller='admin/ldap_settings',

                action='ldap_settings', conditions=dict(method=["POST"]))

    #ADMIN SETTINGS REST ROUTES

    with routes_map.submapper(path_prefix='/_admin', controller='admin/settings') as m:

        m.connect("admin_settings", "/settings",

             action="create", conditions=dict(method=["POST"]))

        m.connect("admin_settings", "/settings",

             action="index", conditions=dict(method=["GET"]))

        m.connect("formatted_admin_settings", "/settings.{format}",

             action="index", conditions=dict(method=["GET"]))

        m.connect("admin_new_setting", "/settings/new",

             action="new", conditions=dict(method=["GET"]))

        m.connect("formatted_admin_new_setting", "/settings/new.{format}",

             action="new", conditions=dict(method=["GET"]))

        m.connect("/settings/{setting_id}",

             action="update", conditions=dict(method=["PUT"]))

        m.connect("/settings/{setting_id}",

             action="delete", conditions=dict(method=["DELETE"]))

        m.connect("admin_edit_setting", "/settings/{setting_id}/edit",

             action="edit", conditions=dict(method=["GET"]))

        m.connect("formatted_admin_edit_setting", "/settings/{setting_id}.{format}/edit",

             action="edit", conditions=dict(method=["GET"]))

        m.connect("admin_setting", "/settings/{setting_id}",

             action="show", conditions=dict(method=["GET"]))

        m.connect("formatted_admin_setting", "/settings/{setting_id}.{format}",

             action="show", conditions=dict(method=["GET"]))

        m.connect("admin_settings_my_account", "/my_account",

             action="my_account", conditions=dict(method=["GET"]))

        m.connect("admin_settings_my_account_update", "/my_account_update",

             action="my_account_update", conditions=dict(method=["PUT"]))

        m.connect("admin_settings_create_repository", "/create_repository",

             action="create_repository", conditions=dict(method=["GET"]))

    #ADMIN MAIN PAGES

    with routes_map.submapper(path_prefix='/_admin', controller='admin/admin') as m:

        m.connect('admin_home', '', action='index')#main page

        m.connect('admin_add_repo', '/add_repo/{new_repo:[a-z0-9\. _-]*}',

                  action='add_repo')

    #USER JOURNAL

    routes_map.connect('public_journal', '/_admin/public_journal', controller='journal', action="public_journal")

    routes_map.connect('public_journal_rss', '/_admin/public_journal_rss', controller='journal', action="public_journal_rss")

    routes_map.connect('public_journal_atom', '/_admin/public_journal_atom', controller='journal', action="public_journal_atom")

    routes_map.connect('toggle_following', '/_admin/toggle_following', controller='journal',

                action='toggle_following', conditions=dict(method=["POST"]))

    #SEARCH

    routes_map.connect('search_repo', '/_admin/search/{search_repo:.*}', controller='search')

    #LOGIN/LOGOUT/REGISTER/SIGN IN

    routes_map.connect('login_home', '/_admin/login', controller='login')

    routes_map.connect('logout_home', '/_admin/logout', controller='login', action='logout')

    routes_map.connect('register', '/_admin/register', controller='login', action='register')

    routes_map.connect('reset_password', '/_admin/password_reset', controller='login', action='password_reset')

    #FEEDS

    routes_map.connect('rss_feed_home', '/{repo_name:.*}/feed/rss',

                controller='feed', action='rss',

                conditions=dict(function=check_repo))

    routes_map.connect('atom_feed_home', '/{repo_name:.*}/feed/atom',

                controller='feed', action='atom',

                conditions=dict(function=check_repo))

    #REPOSITORY ROUTES

    routes_map.connect('changeset_home', '/{repo_name:.*}/changeset/{revision}',

                controller='changeset', revision='tip',

                conditions=dict(function=check_repo))

    routes_map.connect('raw_changeset_home', '/{repo_name:.*}/raw-changeset/{revision}',

                controller='changeset', action='raw_changeset', revision='tip',

                conditions=dict(function=check_repo))

<div id="content"> 

    <div class="flash_msg">

        <% messages = h.flash.pop_messages() %>

        % if messages:

        <ul id="flash-messages">

            % for message in messages:

            <li class="${message.category}_msg">${message}</li>

            % endfor

        </ul>

        % endif

    </div>	    

    <div id="main"> 

        ${next.main()}

    </div>

</div> 

<!-- END CONTENT -->

<!-- FOOTER -->

<div id="footer">

   <div id="footer-inner" class="title bottom-left-rounded-corner bottom-right-rounded-corner">

       <div>

           <p class="footer-link">

                <a href="${h.url('bugtracker')}">${_('Submit a bug')}</a>

           </p>

	       <p class="footer-link-right">

	           <a href="${h.url('rhodecode_official')}">RhodeCode</a> 

	           ${c.rhodecode_version} © 2010-${h.datetime.today().year} by Marcin Kuzminski

	       </p>

       </div>

   </div>

   <script type="text/javascript">

   function tooltip_activate(){

	    ${h.tooltip.activate()}

   }

   tooltip_activate();

   </script>

</div>

<!-- END FOOTER -->

### MAKO DEFS ###

<%def name="page_nav()">

    ${self.menu()}

</%def>

<%def name="breadcrumbs()">

    <div class="breadcrumbs">

    ${self.breadcrumbs_links()}

    </div>

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# 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.

import os

import logging

from rhodecode.config.environment import load_environment

from rhodecode.lib.db_manage import DbManage

log = logging.getLogger(__name__)

def setup_app(command, conf, vars):

    """Place any commands to setup rhodecode here"""

    dbconf = conf['sqlalchemy.db1.url']

    dbmanage.create_tables(override=True)

    dbmanage.set_db_version()

    dbmanage.create_settings(dbmanage.config_prompt(None))

    dbmanage.create_default_user()

    dbmanage.admin_prompt()

    dbmanage.create_permissions()

    dbmanage.populate_default_permissions()

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

import sys

from rhodecode import get_version

from rhodecode import __platform__

py_version = sys.version_info

if py_version < (2, 5):

    raise Exception('RhodeCode requires python 2.5 or later')

requirements = [

        "Pylons==1.0.0",

        "WebHelpers>=1.2",

        "SQLAlchemy>=0.6.6",

        "Mako>=0.4.0",

        "vcs>=0.2.0",

        "pygments>=1.4",

        "mercurial>=1.8.1",

        "whoosh>=1.8.0",

        "celery>=2.2.5",

        "babel",

        "python-dateutil>=1.5.0,<2.0.0",

    ]

classifiers = ['Development Status :: 4 - Beta',

               'Environment :: Web Environment',

               'Framework :: Pylons',

               'Intended Audience :: Developers',

               'Operating System :: OS Independent',

               'Programming Language :: Python',

               'Programming Language :: Python :: 2.5',

               'Programming Language :: Python :: 2.6',

               'Programming Language :: Python :: 2.7', ]

if py_version < (2, 6):

    requirements.append("simplejson")

    requirements.append("pysqlite")

if __platform__ in ('Linux', 'Darwin'):

    requirements.append("py-bcrypt")

#additional files from project that goes somewhere in the filesystem

#relative to sys.prefix

data_files = []

#additional files that goes into package itself

package_data = {'rhodecode': ['i18n/*/LC_MESSAGES/*.mo', ], }

description = ('Mercurial repository browser/management with '

               'build in push/pull server and full text search')

keywords = ' '.join(['rhodecode', 'rhodiumcode', 'mercurial', 'git',

        open(changelog_file).read()

except IOError, err:

    sys.stderr.write("[WARNING] Cannot find file specified as "

        "long_description (%s)\n or changelog (%s) skipping that file" \

            % (readme_file, changelog_file))

    long_description = description

try:

    from setuptools import setup, find_packages

except ImportError:

    from ez_setup import use_setuptools

    use_setuptools()

    from setuptools import setup, find_packages

#packages

packages = find_packages(exclude=['ez_setup'])

setup(

    name='RhodeCode',

    version=get_version(),

    description=description,

    long_description=long_description,

    keywords=keywords,

    author='Marcin Kuzminski',

    author_email='marcin@python-works.com',

    url='http://rhodecode.org',

    install_requires=requirements,

    classifiers=classifiers,

    setup_requires=["PasteScript>=1.6.3"],

    data_files=data_files,

    packages=packages,

    include_package_data=True,

    test_suite='nose.collector',

    package_data=package_data,

    message_extractors={'rhodecode': [

            ('**.py', 'python', None),

            ('templates/**.mako', 'mako', {'input_encoding': 'utf-8'}),

            ('templates/**.html', 'mako', {'input_encoding': 'utf-8'}),

            ('public/**', 'ignore', None)]},

    zip_safe=False,

    paster_plugins=['PasteScript', 'Pylons'],

    entry_points="""

    [paste.app_factory]

    main = rhodecode.config.middleware:make_app

    [paste.app_install]

    main = pylons.util:PylonsInstaller