Changelog

=========

1.1.2 (**2011-01-12**)

======================

- fixed large tooltips problems on main page

- fixed #92 whoosh indexer is more error proof

1.1.0 (**2010-12-18**)

======================

# MA  02110-1301, USA.

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

__dbversion__ = 2 #defines current db version for migrations

####################################

###         BEAKER CACHE        ####

####################################

beaker.cache.regions=super_short_term,short_term,long_term,sql_cache_short,sql_cache_med,sql_cache_long

beaker.cache.super_short_term.type=memory

### LOGGING CONFIGURATION   ####

################################

[loggers]

[handlers]

keys = console

# "level = DEBUG" logs the route matched and routing variables.

propagate = 0

[logger_rhodecode]

level = DEBUG

handlers = console

"""Pylons environment configuration"""

from mako.lookup import TemplateLookup

from pylons.configuration import PylonsConfig

from pylons.error import handle_mako_error

from rhodecode.config.routing import make_map

from rhodecode.lib.auth import set_available_permissions, set_base_path

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

from rhodecode.model import init_model

from rhodecode.model.scm import ScmModel

log = logging.getLogger(__name__)

    # Setup the SQLAlchemy database engine

    if config['debug'] and not test:

        #use query time debugging.

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

                                                            proxy=TimerProxy())

    else:

"""Pylons middleware initialization"""

from beaker.middleware import SessionMiddleware

from paste.cascade import Cascade

from paste.registry import RegistryManager

from paste.urlparser import StaticURLParser

from paste.deploy.converters import asbool

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

# -*- coding: utf-8 -*-

"""

    RhodeCode error controller

import logging

import paste.fileapp

from pylons.i18n.translation import _

from pylons.middleware import  media_path

    """

    def __before__(self):

    def document(self):

        resp = request.environ.get('pylons.original_response')

    :created_on: Jun 30, 2010

    :author: marcink

    :license: GPLv3, see COPYING for more details.

"""

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

import traceback

import formencode

from pylons import tmpl_context as c, request, url

from pylons.controllers.util import redirect

from pylons.i18n.translation import _

import rhodecode.lib.helpers as h

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import invalidate_cache, action_logger

from rhodecode.model.forms import RepoSettingsForm, RepoForkForm

class SettingsController(BaseController):

    @LoginRequired()

    def __before__(self):

        super(SettingsController, self).__before__()

    def index(self, repo_name):

        repo_model = RepoModel()

        c.repo_info = repo = repo_model.get_by_repo_name(repo_name)

            defaults.update({'perm_%s' % p.user.username:

                             p.permission.permission_name})

            render('settings/repo_settings.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

    def update(self, repo_name):

        repo_model = RepoModel()

        changed_name = repo_name

            c.repo_info = repo_model.get_by_repo_name(repo_name)

            c.users_array = repo_model.get_users_js()

            errors.value.update({'user':c.repo_info.user.username})

                render('settings/repo_settings.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

        return redirect(url('repo_settings_home', repo_name=changed_name))

    def delete(self, repo_name):

        """DELETE /repos/repo_name: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        return redirect(url('home'))

    def fork(self, repo_name):

        repo_model = RepoModel()

        c.repo_info = repo = repo_model.get_by_repo_name(repo_name)

        return render('settings/repo_fork.html')

    def fork_create(self, repo_name):

        repo_model = RepoModel()

        c.repo_info = repo_model.get_by_repo_name(repo_name)

            c.new_repo = errors.value['fork_name']

            r = render('settings/repo_fork.html')

                r,

                defaults=errors.value,

                errors=errors.error_dict or {},

from celery.decorators import task

import os

import traceback

from time import mktime

from operator import itemgetter

    q = sa.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/').one()

    return q.ui_value

@locked_task

def whoosh_index(repo_location, full_index):

    from rhodecode.lib.indexers.daemon import WhooshIndexingDaemon

    index_location = config['index_dir']

    WhooshIndexingDaemon(index_location=index_location,

                         repo_location=repo_location, sa=get_session())\

                         .run(full_index=full_index)

@locked_task

def get_commits_stats(repo_name, ts_min_y, ts_max_y):

    from rhodecode.model.db import Statistics, Repository

    #for js data compatibilty

    author_key_cleaner = lambda k: person(k).replace('"', "")

    return True

def reset_user_password(user_email):

    from rhodecode.lib import auth

    from rhodecode.model.db import User

    return True

def send_email(recipients, subject, body):

    """

    Sends an email with defined parameters from the .ini files.

    :param subject: subject of the mail

    :param body: body of the mail

    """

    email_config = config

    if not recipients:

        return False

    return True

def create_repo_fork(form_data, cur_user):

    from rhodecode.model.repo import RepoModel

    from vcs import get_backend

    repo_model = RepoModel(get_session())

    repo_model.create(form_data, cur_user, just_db=True, fork=True)

    repo_name = form_data['repo_name']

from rhodecode.lib.utils import BasePasterCommand, Command

__all__ = ['CeleryDaemonCommand', 'CeleryBeatCommand',

           'CAMQPAdminCommand', 'CeleryEventCommand']

    """Start the celery worker

    Starts the celery worker that uses a paste.deploy configuration

    description = "".join(__doc__.splitlines()[2:])

    parser = Command.standard_parser(quiet=True)

    """Start the celery beat server

    Starts the celery beat server using a paste.deploy configuration

    description = "".join(__doc__.splitlines()[2:])

    parser = Command.standard_parser(quiet=True)

    """CAMQP Admin

    CAMQP celery admin tool.

    description = "".join(__doc__.splitlines()[2:])

    parser = Command.standard_parser(quiet=True)

    Capture celery events.

    """

    description = "".join(__doc__.splitlines()[2:])

    parser = Command.standard_parser(quiet=True)

        pylons_key = to_pylons(key)

        try:

            value = config[pylons_key]

            return self.type_converter(value)

        except KeyError:

            raise AttributeError(pylons_key)

    def __setattr__(self, key, value):

        pylons_key = to_pylons(key)

        config[pylons_key] = value

    def type_converter(self, value):

        #cast to int

        #cast to bool

        if value.lower() in ['true', 'false']:

            return value.lower() == 'true'

        return value

class PylonsLoader(BaseLoader):

    :created_on: Apr 10, 2010

    :author: marcink

    :license: GPLv3, see COPYING for more details.

"""

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

        self.tests = tests

        self.root = root

        self.dburi = dbconf

        init_model(engine)

        self.sa = meta.Session()

    def check_for_db(self, override):

        db_path = jn(self.root, self.dbname)

                self.db_exists = True

                if not override:

                    raise Exception('database already exists')

    def create_tables(self, override=False):

        """Create a auth database

        """

        if self.db_exists:

            log.info("database exist and it's going to be destroyed")

            if self.tests:

            if not destroy:

                sys.exit()

            if self.db_exists and destroy:

        checkfirst = not override

        meta.Base.metadata.create_all(checkfirst=checkfirst)

        log.info('Created tables for %s', self.dbname)

    def upgrade(self):

        """Upgrades given database schema to given revision following 

        :param revision: revision to upgrade to

        """

        # UPGRADE STEPS

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

        class UpgradeSteps(object):

            def __init__(self, klass):

                self.klass = klass

                var tts = YAHOO.util.Dom.getElementsByClassName('tooltip');

                for (var i = 0; i < tts.length; i++) {

                    if (!tts[i].id){

                        tts[i].id='tt'+i*100;

                            case 'top':

                                var cur_x = (pos_x+context_w/2)-(tt_w/2);

                                xy_pos = [cur_x,cur_y];                                

                                break;

                            case 'bottom':

        return ''

    def get_fork_name():

            }

    action_str = map.get(action, action)

def action_parser_icon(user_log):

    action = user_log.action

    if len(x) > 1:

        action, action_params = x

    map = {'user_deleted_repo':'database_delete.png',

           'user_created_repo':'database_add.png',

           'user_forked_repo':'arrow_divide.png',

           'user_updated_repo':'database_edit.png',

           'admin_deleted_repo':'database_delete.png',

           'admin_forked_repo':'arrow_divide.png',

           'admin_updated_repo':'database_edit.png',

           'push':'script_add.png',

           'started_following_repo':'heart_add.png',

           'stopped_following_repo':'heart_delete.png',

            }

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

from pylons import request

def gravatar_url(email_address, size=30):

    default = 'identicon'

    baseurl_nossl = "http://www.gravatar.com/avatar/"

    baseurl_ssl = "https://secure.gravatar.com/avatar/"

            u_str = unicode(str(str).encode('string_escape'))

    return u_str

# 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

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

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

# MA  02110-1301, USA.

from mercurial.cmdutil import revrange

from mercurial.node import nullrev

from rhodecode.lib import helpers as h

from rhodecode.lib.utils import action_logger

def repo_size(ui, repo, hooktype=None, **kwargs):

    if hooktype != 'changegroup':

        return False

                     % (size_hg_f, size_root_f, size_total_f))

def log_pull_action(ui, repo, **kwargs):

    :param ui:

    :param repo:

    """