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

    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)

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

    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')

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

            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)

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

                .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'),

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__)

        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():

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__)

        else:

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

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

        c.total_cs = len(changesets)

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

        super(ChangesetController, self).__before__()

    def index(self, revision):

        cut_off_limit = 1024 * 250

        def wrap_to_table(str):

    def raw_changeset(self, revision):

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

        try:

            r = hg_model.get_repo(c.repo_name)

"""

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__)

                         language=self.language,

                         ttl=self.ttl)

        for cs in changesets[:self.feed_nr]:

            feed.add_item(title=cs.message,

                         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,

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

        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

        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

        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)

                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))

        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')

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__)

        else:

            c.sort_by = current_sort

        c.sort_slug = current_sort_slug

        sort_key = current_sort_slug + '_sort'

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

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__)

    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'):

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

        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)

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__)

        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():

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):

        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

import os

import traceback

from vcs.backends import get_repo

try:

    import json

except ImportError:

    commits_by_day_author_aggregate = {}

    commits_by_day_aggregate = {}

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

    repo = get_repo(p)

    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']

    '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()

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

sys.path.append(project_path)

from rhodecode.lib.helpers import safe_unicode

from whoosh.index import create_in, open_dir

from shutil import rmtree

        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 = logging.getLogger(__name__)

    """

    Mercurial Model

    """

from rhodecode.tests import *

    def test_index(self):

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

from rhodecode.model.db import Repository

from rhodecode.tests import *

    def test_index(self):

        self.log_user()

                                                '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

                                                '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

                                               '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

        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()

from rhodecode.tests import *

from rhodecode.model.db import User

    def test_index(self):

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

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

        print response

        assert 'value="test_admin' in response.body

    def test_my_account_update(self):

        self.log_user()

        new_email = 'new@mail.pl'

                                                            email=new_email,))

        response.follow()

        print response

        print 'x' * 100

        print response.session

        assert 'Your account was updated succesfully' in response.session['flash'][0][1], 'no flash message about success of change'

        user = self.sa.query(User).filter(User.username == 'test_admin').one()

        assert user.email == new_email , 'incorrect user email after update got %s vs %s' % (user.email, new_email)

    def test_my_account_update_own_email_ok(self):

        self.log_user()

        new_email = 'new@mail.pl'

        response = self.app.post(url('admin_settings_my_account_update'), params=dict(

                                                            _method='put',

                                                            lastname='NewLastname',

                                                            email=new_email,))

        print response

    def test_my_account_update_err_email_exists(self):

        self.log_user()

        new_email = 'test_regular@mail.com'#already exisitn email

        response = self.app.post(url('admin_settings_my_account_update'), params=dict(

                                                            _method='put',

                                                            lastname='NewLastname',

                                                            email=new_email,))

        print response

        assert 'That e-mail address is already taken' in response.body, 'Missing error message about existing email'

    def test_my_account_update_err(self):

        self.log_user('test_regular2', 'test12')

        new_email = 'newmail.pl'

        response = self.app.post(url('admin_settings_my_account_update'), params=dict(

                                                            _method='put',

from rhodecode.tests import *

    def test_index(self):

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

    def test_create(self):

        self.log_user()

    def test_new(self):

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

        response = self.app.post(url('user', id=1), params=dict(_method='put'))

    def test_delete(self):

    def test_delete_browser_fakeout(self):

        response = self.app.post(url('user', id=1), params=dict(_method='delete'))

from rhodecode.tests import *

    def test_index(self):

        self.log_user()

                                             'email':email,

                                             'name':name,

                                             'lastname':lastname})

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

        assert 'You have successfully registered into rhodecode' in response.session['flash'][0], 'No flash message about user registration'

requirements = [

        "Pylons>=1.0.0",

        "SQLAlchemy>=0.6.5",

        "vcs>=0.1.10",

        "pygments>=1.3.0",

        "mercurial>=1.6.4",