- mercurial branch graph and yui-flot powered graphs with zooming

- full text search of source codes with indexing daemons using whoosh

  (no external search servers required all in one application)

- async tasks for speed and performance using celery (works without them too)  

- git support (when vcs can handle it - almost there !)

- commit based wikis

- in server forks

- clonning from remote repositories into hg-app 

- other cools stuff that i can figure out (or You can help me figure out)

- download hg app from default branch from bitbucket and run 

  and an admin account make sure You specify correct path to repositories. 

- in order to use full power of async tasks, You must install message broker

  preferrably rabbitmq and start celeryd daemon. The app should gain some speed 

  than. For installation instructions 

  You can visit: http://ask.github.com/celery/getting-started/index.html. All

  needed configs are inside hg-app ie. celeryconfig.py

# List of modules to import when celery starts.

import sys

import os

import ConfigParser

root = os.getcwd()

PYLONS_CONFIG_NAME = 'development.ini'

sys.path.append(root)

config = ConfigParser.ConfigParser({'here':root})

config.read('%s/%s' % (root, PYLONS_CONFIG_NAME))

PYLONS_CONFIG = config

CELERY_IMPORTS = ("pylons_app.lib.celerylib.tasks",)

## Result store settings.

CELERY_RESULT_BACKEND = "database"

CELERY_RESULT_DBURI = dict(config.items('app:main'))['sqlalchemy.db1.url']

CELERY_RESULT_SERIALIZER = 'json'

BROKER_CONNECTION_MAX_RETRIES = 30

## Broker settings.

BROKER_HOST = "localhost"

BROKER_PORT = 5672

BROKER_VHOST = "rabbitmqhost"

BROKER_USER = "rabbitmq"

BROKER_PASSWORD = "qweqwe"

## Worker settings

## If you're doing mostly I/O you can have more processes,

## but if mostly spending CPU, try to keep it close to the

## number of CPUs on your machine. If not set, the number of CPUs/cores

## available will be used.

CELERYD_CONCURRENCY = 2

# CELERYD_LOG_FILE = "celeryd.log"

CELERYD_LOG_LEVEL = "DEBUG"

CELERYD_MAX_TASKS_PER_CHILD = 1

#Tasks will never be sent to the queue, but executed locally instead.

CELERY_ALWAYS_EAGER = False

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

# EMAIL SETTINGS

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

pylons_email_config = dict(config.items('DEFAULT'))

CELERY_SEND_TASK_ERROR_EMAILS = True

#List of (name, email_address) tuples for the admins that should receive error e-mails.

ADMINS = [('Administrator', pylons_email_config.get('email_to'))]

#The e-mail address this worker sends e-mails from. Default is "celery@localhost".

SERVER_EMAIL = pylons_email_config.get('error_email_from')

#The mail server to use. Default is "localhost".

MAIL_HOST = pylons_email_config.get('smtp_server')

#Username (if required) to log on to the mail server with.

MAIL_HOST_USER = pylons_email_config.get('smtp_username')

#Password (if required) to log on to the mail server with.

MAIL_HOST_PASSWORD = pylons_email_config.get('smtp_password')

MAIL_PORT = pylons_email_config.get('smtp_port')

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

# INSTRUCTIONS FOR RABBITMQ

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

# rabbitmqctl add_user rabbitmq qweqwe

# rabbitmqctl add_vhost rabbitmqhost

# rabbitmqctl set_permissions -p rabbitmqhost rabbitmq ".*" ".*" ".*"

# hg-app - Pylons environment configuration                                    #

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

## Uncomment and replace with the address which should receive                ## 

## any error reports after application crash								  ##

## Additionally those settings will be used by hg-app mailing system          ##

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

#error_email_from = paste_error@localhost

#app_email_from = hg-app-noreply@localhost

#error_message =

#smtp_password =

#smtp_port = 

#smtp_use_tls = 

threadpool_max_requests = 6

use_threadpool = false

## "dbm", "file", "memcached", "database", and "memory". 

# hg-app - Pylons environment configuration                                    #

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

## Uncomment and replace with the address which should receive                ## 

## any error reports after application crash								  ##

## Additionally those settings will be used by hg-app mailing system          ##

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

#error_email_from = paste_error@localhost

#app_email_from = hg-app-noreply@localhost

#error_message =

#smtp_port = 

#smtp_use_tls = false

##max request before thread respawn

versioning implementation: http://semver.org/

VERSION = (0, 8, 3, 'beta')

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

## Uncomment and replace with the address which should receive                ## 

## any error reports after application crash								  ##

## Additionally those settings will be used by hg-app mailing system          ##

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

#error_email_from = paste_error@localhost

#app_email_from = hg-app-noreply@localhost

#error_message =

#smtp_port = 

#smtp_use_tls = false

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

    if test:

        from pylons_app.lib.utils import create_test_env, create_test_index

        create_test_env('/tmp', config)

        create_test_index('/tmp/*', True)

    #LOGIN/LOGOUT/REGISTER/SIGN IN

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

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

    map.connect('files_rawfile_home', '/{repo_name:.*}/rawfile/{revision}/{f_path:.*}',

    map.connect('files_raw_home', '/{repo_name:.*}/raw/{revision}/{f_path:.*}',

                controller='files', action='raw', revision='tip', f_path='',

                conditions=dict(function=check_repo))

from pylons_app.lib.celerylib import tasks, run_task

        if setting_id == 'whoosh':

            repo_location = get_hg_ui_settings()['paths_root_path']

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

            task = run_task(tasks.whoosh_index, repo_location, full_index)

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

        _form = UserForm(edit=True, old_data={'user_id':uid,

                                              'email':c.hg_app_user.email})()

            c.user = self.sa.query(User).get(c.hg_app_user.user_id)

            c.user_repos = []

            for repo in c.cached_repo_list.values():

                if repo.dbrepo.user.username == c.user.username:

                    c.user_repos.append(repo)            

        c.user = user_model.get_user(id)

        _form = UserForm(edit=True, old_data={'user_id':id,

                                              'email':c.user.email})()

        if not c.user:

            return redirect(url('users'))

        c.file_size_limit = 250 * 1024 #limit of file size to display

    def raw(self, repo_name, revision, f_path):

        hg_model = HgModel()

        c.repo = hg_model.get_repo(c.repo_name)

        file_node = c.repo.get_changeset(revision).get_node(f_path)

        response.content_type = 'text/plain'

        return file_node.content

import pylons_app.lib.helpers as h 

from pylons.i18n.translation import _

from pylons_app.model.forms import LoginForm, RegisterForm, PasswordResetForm

        c.came_from = request.GET.get('came_from', None)

    @HasPermissionAnyDecorator('hg.admin', 'hg.register.auto_activate',

                h.flash(_('You have successfully registered into hg-app'),

                            category='success')                

    def password_reset(self):

        user_model = UserModel()

        if request.POST:

            password_reset_form = PasswordResetForm()()

            try:

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

                user_model.reset_password(form_result)

                h.flash(_('Your new password was sent'),

                            category='success')                 

                return redirect(url('login_home'))

            except formencode.Invalid as errors:

                return htmlfill.render(

                    render('/password_reset.html'),

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    encoding="UTF-8")

        return render('/password_reset.html')

from pylons_app.lib.indexers import IDX_LOCATION, SCHEMA, IDX_NAME, ResultWrapper

from webhelpers.paginate import Page

from webhelpers.util import update_params

            p = int(request.params.get('page', 1))

            highlight_items = set()

                        highlight_items.update(query.words)

                            if i[0] == 'content':

                                highlight_items.add(i[1])

                    matcher = query.matcher(searcher)

                    log.debug(query)

                    log.debug(highlight_items)

                    results = searcher.search(query)

                    res_ln = len(results)

                    c.runtime = '%s results (%.3f seconds)' \

                    % (res_ln, results.runtime)

                    def url_generator(**kw):

                        return update_params("?q=%s" % c.cur_query, **kw)

                    c.formated_results = Page(

                                ResultWrapper(searcher, matcher, highlight_items),

                                page=p, item_count=res_ln,

                                items_per_page=10, url=url_generator)

                searcher.close()

from pylons import tmpl_context as c, request, url

from pylons_app.model.db import Statistics

from webhelpers.paginate import Page

from pylons_app.lib.celerylib import run_task

from pylons_app.lib.celerylib.tasks import get_commits_stats

from datetime import datetime, timedelta

        td = datetime.today() + timedelta(days=1) 

        y, m, d = td.year, td.month, td.day

        ts_min_y = mktime((y - 1, (td - timedelta(days=calendar.mdays[m])).month,

                            d, 0, 0, 0, 0, 0, 0,))

        ts_min_m = mktime((y, (td - timedelta(days=calendar.mdays[m])).month,

                            d, 0, 0, 0, 0, 0, 0,))

        ts_max_y = mktime((y, m, d, 0, 0, 0, 0, 0, 0,))

        run_task(get_commits_stats, c.repo_info.name, ts_min_y, ts_max_y)

        c.ts_min = ts_min_m

        c.ts_max = ts_max_y

        stats = self.sa.query(Statistics)\

            .filter(Statistics.repository == c.repo_info.dbrepo)\

            .scalar()

        if stats:

            c.commit_data = stats.commit_activity

            c.overview_data = stats.commit_activity_combined

        else:

            import json

            c.commit_data = json.dumps({})

            c.overview_data = json.dumps([[ts_min_y, 0], [ts_max_y, 0] ])

import random

class PasswordGenerator(object):

    """This is a simple class for generating password from

        different sets of characters

        usage:

        passwd_gen = PasswordGenerator()

        #print 8-letter password containing only big and small letters of alphabet

        print passwd_gen.gen_password(8, passwd_gen.ALPHABETS_BIG_SMALL)        

    """

    ALPHABETS_NUM = r'''1234567890'''#[0]

    ALPHABETS_SMALL = r'''qwertyuiopasdfghjklzxcvbnm'''#[1]

    ALPHABETS_BIG = r'''QWERTYUIOPASDFGHJKLZXCVBNM'''#[2]

    ALPHABETS_SPECIAL = r'''`-=[]\;',./~!@#$%^&*()_+{}|:"<>?'''    #[3]

    ALPHABETS_FULL = ALPHABETS_BIG + ALPHABETS_SMALL + ALPHABETS_NUM + ALPHABETS_SPECIAL#[4]

    ALPHABETS_ALPHANUM = ALPHABETS_BIG + ALPHABETS_SMALL + ALPHABETS_NUM#[5]

    ALPHABETS_BIG_SMALL = ALPHABETS_BIG + ALPHABETS_SMALL

    ALPHABETS_ALPHANUM_BIG = ALPHABETS_BIG + ALPHABETS_NUM#[6]

    ALPHABETS_ALPHANUM_SMALL = ALPHABETS_SMALL + ALPHABETS_NUM#[7]

    def __init__(self, passwd=''):

        self.passwd = passwd

    def gen_password(self, len, type):

        self.passwd = ''.join([random.choice(type) for _ in xrange(len)])

        return self.passwd

                p += '?' + request.environ.get('QUERY_STRING')

            log.debug('redirecting to login page with %s', p)