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 sqlalchemy import engine_from_config

import logging

import os

import rhodecode.lib.app_globals as app_globals

import rhodecode.lib.helpers

    init_model(sa_engine_db1)

    #init baseui

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

    g = config['pylons.app_globals']

    set_available_permissions(config)

    set_base_path(config)

    set_rhodecode_config(config)

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

    # any Pylons config options)

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, \

    HasPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import invalidate_cache, action_logger

from rhodecode.model.db import User

from rhodecode.model.forms import RepoForm

from rhodecode.model.repo import RepoModel

import formencode

import logging

import traceback

log = logging.getLogger(__name__)

        super(ReposController, self).__before__()

    @HasPermissionAllDecorator('hg.admin')

    def index(self, format='html'):

        """GET /repos: All items in the collection"""

        # url('repos')

        c.repos_list = sorted(cached_repo_list, key=itemgetter('name_sort'))

        return render('admin/repos/repos.html')

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

    def create(self):

        """POST /repos: Create a new item"""

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import repo2db_mapper, invalidate_cache, \

    set_rhodecode_config, get_hg_settings, get_hg_ui_settings

from rhodecode.model.db import RhodeCodeSettings, RhodeCodeUi, Repository

from rhodecode.model.forms import UserForm, ApplicationSettingsForm, \

    ApplicationUiSettingsForm

from rhodecode.model.user import UserModel

from rhodecode.lib.celerylib import tasks, run_task

from sqlalchemy import func

import formencode

import logging

import traceback

        #           method='put')

        # url('admin_setting', setting_id=ID)

        if setting_id == 'mapping':

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

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

            for repo_name in initial.keys():

                invalidate_cache('get_repo_cached_%s' % repo_name)

            repo2db_mapper(initial, rm_obsolete)

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

        # url('admin_settings_my_account')

        c.user = UserModel(self.sa).get(c.rhodecode_user.user_id, cache=False)

        all_repos = self.sa.query(Repository)\

            .filter(Repository.user_id == c.user.user_id)\

            .order_by(func.lower(Repository.repo_name))\

            .all()

        if c.user.username == 'default':

            h.flash(_("You can't edit this user since it's"

              " crucial for entire application"), category='warning')

            return redirect(url('users'))

            c.user = user_model.get(c.rhodecode_user.user_id, cache=False)

            c.user = UserModel(self.sa).get(c.rhodecode_user.user_id, cache=False)

            all_repos = self.sa.query(Repository)\

                .filter(Repository.user_id == c.user.user_id)\

                .order_by(func.lower(Repository.repo_name))\

                .all()

            return htmlfill.render(

                render('admin/users/user_edit_my_account.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

@author: marcink

"""

from pylons import tmpl_context as c

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import OrderedDict

import logging

log = logging.getLogger(__name__)

class BranchesController(BaseController):

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write', 'repository.admin')

    def __before__(self):

        super(BranchesController, self).__before__()

    def index(self):

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

        c.repo_branches = OrderedDict()

        for name, hash_ in c.repo_info.branches.items():

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

        return render('branches/branches.html')

    #python 2.5 compatibility

    import simplejson as json

from mercurial.graphmod import colored, CHANGESET, revisions as graph_rev

from pylons import request, session, tmpl_context as c

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from webhelpers.paginate import Page

import logging

log = logging.getLogger(__name__)

class ChangelogController(BaseController):

            c.size = int_size

            session['changelog_size'] = c.size

            session.save()

        else:

            c.size = int(session.get('changelog_size', default))

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

        c.total_cs = len(changesets)

        c.pagination = Page(changesets, page=p, item_count=c.total_cs,

                            items_per_page=c.size)

from pylons.i18n.translation import _

from pylons.controllers.util import redirect

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import EmptyChangeset

import rhodecode.lib.helpers as h

from vcs.exceptions import RepositoryError, ChangesetError

from vcs.nodes import FileNode

from vcs.utils import diffs as differ

import logging

import traceback

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def __before__(self):

        super(ChangesetController, self).__before__()

    def index(self, revision):

        cut_off_limit = 1024 * 250

        def wrap_to_table(str):

            return '''<table class="code-difftable">

                        <tr class="line">

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

        return render('changeset/changeset.html')

    def raw_changeset(self, revision):

        method = request.GET.get('diff', 'show')

        try:

            r = hg_model.get_repo(c.repo_name)

            c.scm_type = r.alias

            c.changeset = r.get_changeset(revision)

        except RepositoryError:

Created on April 23, 2010

feed controller for pylons

@author: marcink

"""

from pylons import tmpl_context as c, url, response

from rhodecode.lib.base import BaseController, render

from webhelpers.feedgenerator import Atom1Feed, Rss201rev2Feed

import logging

log = logging.getLogger(__name__)

class FeedController(BaseController):

        feed = Atom1Feed(title=self.title % repo_name,

                         link=url('summary_home', repo_name=repo_name, qualified=True),

                         description=self.description % repo_name,

                         language=self.language,

                         ttl=self.ttl)

        for cs in changesets[:self.feed_nr]:

            feed.add_item(title=cs.message,

                          link=url('changeset_home', repo_name=repo_name,

                                   revision=cs.raw_id, qualified=True),

                                   description=str(cs.date))

        feed = Rss201rev2Feed(title=self.title % repo_name,

                         link=url('summary_home', repo_name=repo_name, qualified=True),

                         description=self.description % repo_name,

                         language=self.language,

                         ttl=self.ttl)

        for cs in changesets[:self.feed_nr]:

            feed.add_item(title=cs.message,

                          link=url('changeset_home', repo_name=repo_name,

                                   revision=cs.raw_id, qualified=True),

                          description=str(cs.date))

from pylons import request, response, session, tmpl_context as c, url

from pylons.i18n.translation import _

from pylons.controllers.util import redirect

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import EmptyChangeset

from vcs.exceptions import RepositoryError, ChangesetError

from vcs.nodes import FileNode

from vcs.utils import diffs as differ

import logging

import rhodecode.lib.helpers as h

import tempfile

                                   'repository.admin')

    def __before__(self):

        super(FilesController, self).__before__()

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

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

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

        revision = request.POST.get('at_rev', None) or revision

        def get_next_rev(cur):

            max_rev = len(c.repo.revisions) - 1

            r = cur + 1

        return render('files/files.html')

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

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

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

        response.content_type = file_node.mimetype

        response.content_disposition = 'attachment; filename=%s' \

                                                    % f_path.split('/')[-1]

        return file_node.content

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

        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

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

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

        c.cs = c.repo.get_changeset(revision)

        c.file = c.cs.get_node(f_path)

        c.file_history = self._get_history(c.repo, c.file, f_path)

        c.f_path = f_path

                data = file_object.read(chunk_size)

                if not data:

                    break

                yield data

        archive = tempfile.TemporaryFile()

        fname = '%s-%s%s' % (repo_name, revision, fileformat)

        archival.archive(repo, archive, revision, archive_specs[fileformat][1],

                         prefix='%s-%s' % (repo_name, revision))

        response.content_type = archive_specs[fileformat][0]

        response.content_disposition = 'attachment; filename=%s' % fname

        archive.seek(0)

        return read_in_chunks(archive)

    def diff(self, repo_name, f_path):

        diff1 = request.GET.get('diff1')

        diff2 = request.GET.get('diff2')

        c.action = request.GET.get('diff')

        c.no_changes = diff1 == diff2

        c.f_path = f_path

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

@author: marcink

"""

from operator import itemgetter

from pylons import tmpl_context as c, request

from rhodecode.lib.auth import LoginRequired

from rhodecode.lib.base import BaseController, render

import logging

log = logging.getLogger(__name__)

class HomeController(BaseController):

    @LoginRequired()

        if current_sort_slug not in sortables:

            c.sort_by = 'name'

            current_sort_slug = c.sort_by

        else:

            c.sort_by = current_sort

        c.sort_slug = current_sort_slug

        sort_key = current_sort_slug + '_sort'

        if c.sort_by.startswith('-'):

            c.repos_list = sorted(cached_repo_list, key=itemgetter(sort_key), reverse=True)

        else:

            c.repos_list = sorted(cached_repo_list, key=itemgetter(sort_key), reverse=False)

shortlog controller for pylons

@author: marcink

"""

from pylons import tmpl_context as c, request

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from webhelpers.paginate import Page

import logging

log = logging.getLogger(__name__)

class ShortlogController(BaseController):

                                   'repository.admin')       

    def __before__(self):

        super(ShortlogController, self).__before__()

    def index(self):

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

        c.repo_changesets = Page(repo, page=p, items_per_page=20)

        c.shortlog_data = render('shortlog/shortlog_data.html')

        if request.params.get('partial'):

            return c.shortlog_data

        r = render('shortlog/shortlog.html')

        return r

"""

from pylons import tmpl_context as c, request, url

from vcs.exceptions import ChangesetError

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import OrderedDict, EmptyChangeset

from rhodecode.model.db import Statistics

from webhelpers.paginate import Page

from rhodecode.lib.celerylib import run_task

from rhodecode.lib.celerylib.tasks import get_commits_stats

from datetime import datetime, timedelta

from time import mktime

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def __before__(self):

        super(SummaryController, self).__before__()

    def index(self):

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

        def url_generator(**kw):

            return url('shortlog_home', repo_name=c.repo_name, **kw)

        c.repo_changesets = Page(c.repo_info, page=1, items_per_page=10,

                                 url=url_generator)

@author: marcink

"""

from pylons import tmpl_context as c

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import OrderedDict

import logging

log = logging.getLogger(__name__)

class TagsController(BaseController):

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write', 'repository.admin')       

    def __before__(self):

        super(TagsController, self).__before__()

    def index(self):

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

        c.repo_tags = OrderedDict()

        for name, hash_ in c.repo_info.tags.items():

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

        return render('tags/tags.html')

from pylons.controllers import WSGIController

from pylons.templating import render_mako as render

from rhodecode import __version__

from rhodecode.lib import auth

from rhodecode.lib.utils import get_repo_slug

from rhodecode.model import meta

from vcs import BACKENDS

class BaseController(WSGIController):

    def __before__(self):

        c.rhodecode_version = __version__

        c.rhodecode_name = config['rhodecode_title']

        c.repo_name = get_repo_slug(request)

        c.backends = BACKENDS.keys()

        if c.repo_name:

            if cached_repo:

                c.repository_tags = cached_repo.tags

                c.repository_branches = cached_repo.branches

            else:

                c.repository_tags = {}

from rhodecode.lib.smtp_mailer import SmtpMailer

from rhodecode.lib.utils import OrderedDict

from time import mktime

import os

import traceback

from vcs.backends import get_repo

try:

    import json

except ImportError:

    #python 2.5 compatibility

    import simplejson as json

    from rhodecode.model.db import Statistics, Repository

    log = get_commits_stats.get_logger()

    author_key_cleaner = lambda k: person(k).replace('"', "") #for js data compatibilty

    commits_by_day_author_aggregate = {}

    commits_by_day_aggregate = {}

    p = os.path.join(repos_path, repo_name)

    repo = get_repo(p)

    skip_date_limit = True

    parse_limit = 250 #limit for single task changeset parsing optimal for

    last_rev = 0

    from rhodecode.model.repo import RepoModel

    from vcs import get_backend

    log = create_repo_fork.get_logger()

    repo_model = RepoModel(get_session())

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

    repo_name = form_data['repo_name']

    repo_path = os.path.join(repos_path, repo_name)

    repo_fork_path = os.path.join(repos_path, form_data['fork_name'])

    alias = form_data['repo_type']

    log.info('creating repo fork %s as %s', repo_name, repo_path)

    backend = get_backend(alias)

    'aspx', 'asx', 'axd', 'c', 'cfg', 'cfm', 'cpp', 'cs', 'diff', 'do', 'el',

    'erl', 'h', 'java', 'js', 'jsp', 'jspx', 'lisp', 'lua', 'm', 'mako', 'ml',

    'pas', 'patch', 'php', 'php3', 'php4', 'phtml', 'pm', 'py', 'rb', 'rst',

    's', 'sh', 'tpl', 'txt', 'vim', 'wss', 'xhtml', 'xml', 'xsl', 'xslt', 'yaws']

    p = os.path.join(repos_path, repo_name)

    repo = get_repo(p)

    tip = repo.get_changeset()

    code_stats = {}

    def aggregate(cs):

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

#to get the rhodecode import

sys.path.append(dn(dn(dn(os.path.realpath(__file__)))))

from rhodecode.config.environment import load_environment

from shutil import rmtree

from webhelpers.html.builder import escape

from vcs.utils.lazy import LazyProperty

from whoosh.analysis import RegexTokenizer, LowercaseFilter, StopFilter

from whoosh.fields import TEXT, ID, STORED, Schema, FieldType

#to get the rhodecode import

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

sys.path.append(project_path)

from rhodecode.lib.helpers import safe_unicode

from whoosh.index import create_in, open_dir

from shutil import rmtree

from rhodecode.lib.indexers import INDEX_EXTENSIONS, SCHEMA, IDX_NAME

from time import mktime

            raise Exception('You have to provide index location')

        self.repo_location = repo_location

        if not repo_location:

            raise Exception('You have to provide repositories location')

        self.initial = False

        if not os.path.isdir(self.index_location):

            os.mkdir(self.index_location)

            log.info('Cannot run incremental index since it does not'

                     ' yet exist running full build')

            self.initial = True

import logging

import os

import time

log = logging.getLogger(__name__)

    """

    Mercurial Model

    """

    def __init__(self, sa=None):

        if not sa:

from rhodecode.tests import *

    def test_index(self):

        response = self.app.get(url('permissions'))

        # Test response...

    def test_index_as_xml(self):

from rhodecode.model.db import Repository

from rhodecode.tests import *

    def test_index(self):

        self.log_user()

        response = self.app.get(url('repos'))

        # Test response...

        private = False

        response = self.app.post(url('repos'), {'repo_name':repo_name,

                                                'repo_type':'hg',

                                                'description':description,

                                                'private':private})

        #test if we have a message for that repository

        assert '''created repository %s''' % (repo_name) in response.session['flash'][0], 'No flash message about new repo'

        #test if the fork was created in the database

        new_repo = self.sa.query(Repository).filter(Repository.repo_name == repo_name).one()

        assert new_repo.repo_name == repo_name, 'wrong name of repo name in db'

        private = False

        response = self.app.post(url('repos'), {'repo_name':repo_name,

                                                'repo_type':'git',

                                                'description':description,

                                                'private':private})

        #test if we have a message for that repository

        assert '''created repository %s''' % (repo_name) in response.session['flash'][0], 'No flash message about new repo'

        #test if the fork was created in the database

        new_repo = self.sa.query(Repository).filter(Repository.repo_name == repo_name).one()

        assert new_repo.repo_name == repo_name, 'wrong name of repo name in db'

        private = False

        response = self.app.post(url('repos'), {'repo_name':repo_name,

                                                'repo_type':'hg',

                                               'description':description,

                                               'private':private})

        #test if we have a message for that repository

        assert '''created repository %s''' % (repo_name) in response.session['flash'][0], 'No flash message about new repo'

        #test if the repo was created in the database

        new_repo = self.sa.query(Repository).filter(Repository.repo_name == repo_name).one()

        assert new_repo.repo_name == repo_name, 'wrong name of repo name in db'

        assert repo_name in response.body, 'missing new repo from the main repos list'

        response = self.app.delete(url('repo', repo_name=repo_name))

        assert '''deleted repository %s''' % (repo_name) in response.session['flash'][0], 'No flash message about delete repo'

        response.follow()

        #check if repo was deleted from db

        deleted_repo = self.sa.query(Repository).filter(Repository.repo_name == repo_name).scalar()

from rhodecode.tests import *

from rhodecode.model.db import User

    def test_index(self):

        response = self.app.get(url('admin_settings'))

        # Test response...

    def test_index_as_xml(self):

from rhodecode.tests import *

    def test_index(self):

        response = self.app.get(url('users'))

        # Test response...

    def test_index_as_xml(self):

        response = self.app.get(url('formatted_users', format='xml'))

    def test_create(self):

        self.log_user()