changed_name = repo_name

        self.__load_defaults()

        _form = RepoSettingsForm(edit=True,

                                 old_data={'repo_name': repo_name},

                                 repo_groups=c.repo_groups_choices,

                                 landing_revs=c.landing_revs_choices)()

        try:

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

            repo_model.update(repo_name, form_result)

            invalidate_cache('get_repo_cached_%s' % repo_name)

            h.flash(_('Repository %s updated successfully') % repo_name,

                    category='success')

            changed_name = form_result['repo_name_full']

            action_logger(self.rhodecode_user, 'user_updated_repo',

                          changed_name, self.ip_addr, self.sa)

            Session().commit()

        except formencode.Invalid, errors:

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

            return htmlfill.render(

                render('settings/repo_settings.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during update of repository %s') \

                    % repo_name, category='error')

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

    @HasRepoPermissionAllDecorator('repository.admin')

    def delete(self, repo_name):

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

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

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('repo_settings_delete', repo_name=ID),

        #           method='delete')

        # url('repo_settings_delete', repo_name=ID)

        repo_model = RepoModel()

        repo = repo_model.get_by_repo_name(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps'

                      ' it was moved or renamed  from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('home'))

        try:

            action_logger(self.rhodecode_user, 'user_deleted_repo',

                              repo_name, self.ip_addr, self.sa)

            repo_model.delete(repo)

            invalidate_cache('get_repo_cached_%s' % repo_name)

            h.flash(_('deleted repository %s') % repo_name, category='success')

            Session().commit()

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of %s') % repo_name,

                    category='error')

        return redirect(url('home'))

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

    def toggle_locking(self, repo_name):

        """

        Toggle locking of repository by simple GET call to url

        :param repo_name:

        """

        try:

            repo = Repository.get_by_repo_name(repo_name)

            if repo.enable_locking:

                if repo.locked[0]:

                    Repository.unlock(repo)

                    action = _('unlocked')

                else:

                    Repository.lock(repo, c.rhodecode_user.user_id)

                    action = _('locked')

                h.flash(_('Repository has been %s') % action,

                        category='success')

        except Exception, e:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during unlocking'),

                    category='error')

        return redirect(url('summary_home', repo_name=repo_name))

        web3.ui_value = '*'

        web4 = RhodeCodeUi()

        web4.ui_section = 'web'

        web4.ui_key = 'baseurl'

        web4.ui_value = '/'

        paths = RhodeCodeUi()

        paths.ui_section = 'paths'

        paths.ui_key = '/'

        paths.ui_value = path

        phases = RhodeCodeUi()

        phases.ui_section = 'phases'

        phases.ui_key = 'publish'

        phases.ui_value = False

        sett1 = RhodeCodeSetting('realm', 'RhodeCode authentication')

        sett2 = RhodeCodeSetting('title', 'RhodeCode')

        sett3 = RhodeCodeSetting('ga_code', '')

        sett4 = RhodeCodeSetting('show_public_icon', True)

        sett5 = RhodeCodeSetting('show_private_icon', True)

        sett6 = RhodeCodeSetting('stylify_metatags', False)

        self.sa.add(web1)

        self.sa.add(web2)

        self.sa.add(web3)

        self.sa.add(web4)

        self.sa.add(paths)

        self.sa.add(sett1)

        self.sa.add(sett2)

        self.sa.add(sett3)

        self.sa.add(sett4)

        self.sa.add(sett5)

        self.sa.add(sett6)

        self.create_ldap_options()

        log.info('created ui config')

    def create_user(self, username, password, email='', admin=False):

        log.info('creating user %s' % username)

        UserModel().create_or_update(username, password, email,

                                     firstname='RhodeCode', lastname='Admin',

                                     active=True, admin=admin)

    def create_default_user(self):

        log.info('creating default user')

        # create default user for handling default permissions.

        UserModel().create_or_update(username='default',

                              password=str(uuid.uuid1())[:8],

                              email='anonymous@rhodecode.org',

                              firstname='Anonymous', lastname='User')

    def create_permissions(self):

        # module.(access|create|change|delete)_[name]

        # module.(none|read|write|admin)

        for p in Permission.PERMS:

            if not Permission.get_by_key(p[0]):

                new_perm = Permission()

                new_perm.permission_name = p[0]

                new_perm.permission_longname = p[0]

                self.sa.add(new_perm)

    def populate_default_permissions(self):

        log.info('creating default user permissions')

        default_user = User.get_by_username('default')

        for def_perm in User.DEFAULT_PERMISSIONS:

            perm = self.sa.query(Permission)\

             .filter(Permission.permission_name == def_perm)\

             .scalar()

            if not perm:

                raise Exception(

                  'CRITICAL: permission %s not found inside database !!'

                  % def_perm

                )

            if not UserToPerm.query()\

                .filter(UserToPerm.permission == perm)\

                .filter(UserToPerm.user == default_user).scalar():

                reg_perm = UserToPerm()

                reg_perm.user = default_user

                reg_perm.permission = perm

                self.sa.add(reg_perm)

    def finish(self):

        """

        Function executed at the end of setup

        """

        if not __py_version__ >= (2, 6):

            notify('Python2.5 detected, please switch '

                   'egg:waitress#main -> egg:Paste#http '

        r1_id = repo1.repo_id

        r1_name = repo1.repo_name

        #commit something initially !

        cs0 = ScmModel().create_node(

            repo=repo1.scm_instance, repo_name=r1_name,

            cs=EmptyChangeset(alias='hg'), user=TEST_USER_ADMIN_LOGIN,

            author=TEST_USER_ADMIN_LOGIN,

            message='commit1',

            content='line1',

            f_path='file1'

        )

        Session().commit()

        self.assertEqual(repo1.scm_instance.revisions, [cs0.raw_id])

        #fork the repo1

        repo2 = RepoModel().create_repo(repo_name='one-fork', repo_type='hg',

                                description='compare-test',

                                clone_uri=repo1.repo_full_path,

                                owner=TEST_USER_ADMIN_LOGIN, fork_of='one')

        Session().commit()

        self.assertEqual(repo2.scm_instance.revisions, [cs0.raw_id])

        r2_id = repo2.repo_id

        r2_name = repo2.repo_name

        #make 3 new commits in fork

        cs1 = ScmModel().create_node(

            repo=repo2.scm_instance, repo_name=r2_name,

            cs=repo2.scm_instance[-1], user=TEST_USER_ADMIN_LOGIN,

            author=TEST_USER_ADMIN_LOGIN,

            message='commit1-fork',

            content='file1-line1-from-fork',

            f_path='file1-fork'

        )

        cs2 = ScmModel().create_node(

            repo=repo2.scm_instance, repo_name=r2_name,

            cs=cs1, user=TEST_USER_ADMIN_LOGIN,

            author=TEST_USER_ADMIN_LOGIN,

            message='commit2-fork',

            content='file2-line1-from-fork',

            f_path='file2-fork'

        )

        cs3 = ScmModel().create_node(

            repo=repo2.scm_instance, repo_name=r2_name,

            cs=cs2, user=TEST_USER_ADMIN_LOGIN,

            author=TEST_USER_ADMIN_LOGIN,

            message='commit3-fork',

            content='file3-line1-from-fork',

            f_path='file3-fork'

        )

        #compare !

        rev1 = 'default'

        rev2 = 'default'

        response = self.app.get(url(controller='compare', action='index',

                                    repo_name=r2_name,

                                    org_ref_type="branch",

                                    org_ref=rev1,

                                    other_ref_type="branch",

                                    other_ref=rev2,

                                    repo=r1_name,

                                    bundle=False,

                                    ))

        try:

            #response.mustcontain('%s@%s -> %s@%s' % (r2_name, rev1, r1_name, rev2))

            #add new commit into parent !

            cs0 = ScmModel().create_node(

                repo=repo1.scm_instance, repo_name=r1_name,

                cs=EmptyChangeset(alias='hg'), user=TEST_USER_ADMIN_LOGIN,

                author=TEST_USER_ADMIN_LOGIN,

                message='commit2',

                content='line1',

                f_path='file2'

            )

            #compare !

            rev1 = 'default'

            rev2 = 'default'

            response = self.app.get(url(controller='compare', action='index',

                                        repo_name=r2_name,

                                        org_ref_type="branch",

                                        org_ref=rev1,

                                        other_ref_type="branch",

                                        other_ref=rev2,

                                        repo=r1_name,

                                        bundle=False

                                        ))

            rev2 = cs0.parents[0].raw_id

            response.mustcontain('%s@%s -> %s@%s' % (r2_name, rev1, r1_name, rev2))

            response.mustcontain("""file1-line1-from-fork""")

            response.mustcontain("""file2-line1-from-fork""")

            response.mustcontain("""file3-line1-from-fork""")

            self.assertFalse("""<a href="#">file2</a>""" in response.body)  # new commit from parent

            self.assertFalse("""line1-from-new-parent"""  in response.body)

        finally:

            RepoModel().delete(r2_id)

        'marian.user', 'marco-polo', 'marco_polo'

        ], key=lambda k: k.lower())

        self.assertEqual(s, extract_mentioned_users(sample))

    def test_age(self):

        import calendar

        from rhodecode.lib.utils2 import age

        n = datetime.datetime.now()

        delt = lambda *args, **kwargs: datetime.timedelta(*args, **kwargs)

        self.assertEqual(age(n), u'just now')

        self.assertEqual(age(n - delt(seconds=1)), u'1 second ago')

        self.assertEqual(age(n - delt(seconds=60 * 2)), u'2 minutes ago')

        self.assertEqual(age(n - delt(hours=1)), u'1 hour ago')

        self.assertEqual(age(n - delt(hours=24)), u'1 day ago')

        self.assertEqual(age(n - delt(hours=24 * 5)), u'5 days ago')

        self.assertEqual(age(n - delt(hours=24 * (calendar.mdays[n.month - 1] + 2))),

                         u'1 month and 2 days ago')

        self.assertEqual(age(n - delt(hours=24 * 400)), u'1 year and 1 month ago')

    def test_age_in_future(self):

        import calendar

        from rhodecode.lib.utils2 import age

        n = datetime.datetime.now()

        delt = lambda *args, **kwargs: datetime.timedelta(*args, **kwargs)

        self.assertEqual(age(n), u'just now')

        self.assertEqual(age(n + delt(seconds=1)), u'in 1 second')

        self.assertEqual(age(n + delt(seconds=60 * 2)), u'in 2 minutes')

        self.assertEqual(age(n + delt(hours=1)), u'in 1 hour')

        self.assertEqual(age(n + delt(hours=24)), u'in 1 day')

        self.assertEqual(age(n + delt(hours=24 * 5)), u'in 5 days')

        self.assertEqual(age(n + delt(hours=24 * (calendar.mdays[n.month - 1] + 2))),

                         u'in 1 month and 1 day')

        self.assertEqual(age(n + delt(hours=24 * 400)), u'in 1 year and 1 month')

    def test_tag_exctrator(self):

        sample = (

            "hello pta[tag] gog [[]] [[] sda ero[or]d [me =>>< sa]"

            "[requires] [stale] [see<>=>] [see => http://url.com]"

            "[requires => url] [lang => python] [just a tag]"

            "[,d] [ => ULR ] [obsolete] [desc]]"

        )

        from rhodecode.lib.helpers import desc_stylize

        res = desc_stylize(sample)

        self.assertTrue('<div class="metatag" tag="tag">tag</div>' in res)

        self.assertTrue('<div class="metatag" tag="obsolete">obsolete</div>' in res)

        self.assertTrue('<div class="metatag" tag="stale">stale</div>' in res)

        self.assertTrue('<div class="metatag" tag="lang">python</div>' in res)

        self.assertTrue('<div class="metatag" tag="requires">requires =&gt; <a href="/url">url</a></div>' in res)

        self.assertTrue('<div class="metatag" tag="tag">tag</div>' in res)

    def test_alternative_gravatar(self):

        from rhodecode.lib.helpers import gravatar_url

        _md5 = lambda s: hashlib.md5(s).hexdigest()

        def fake_conf(**kwargs):

            from pylons import config

            config['app_conf'] = {}

            config['app_conf']['use_gravatar'] = True

            config['app_conf'].update(kwargs)

            return config

        class fake_url():

            @classmethod

            def current(cls, *args, **kwargs):

                return 'https://server.com'

        with mock.patch('pylons.url', fake_url):

            fake = fake_conf(alternative_gravatar_url='http://test.com/{email}')

            with mock.patch('pylons.config', fake):

                    from pylons import url

                    assert url.current() == 'https://server.com'

                    grav = gravatar_url(email_address='test@foo.com', size=24)

                    assert grav == 'http://test.com/test@foo.com'

            fake = fake_conf(alternative_gravatar_url='http://test.com/{email}')

            with mock.patch('pylons.config', fake):

                grav = gravatar_url(email_address='test@foo.com', size=24)

                assert grav == 'http://test.com/test@foo.com'

            fake = fake_conf(alternative_gravatar_url='http://test.com/{md5email}')

            with mock.patch('pylons.config', fake):

                em = 'test@foo.com'

                grav = gravatar_url(email_address=em, size=24)

                assert grav == 'http://test.com/%s' % (_md5(em))

            fake = fake_conf(alternative_gravatar_url='http://test.com/{md5email}/{size}')

            with mock.patch('pylons.config', fake):

                em = 'test@foo.com'

                grav = gravatar_url(email_address=em, size=24)

                assert grav == 'http://test.com/%s/%s' % (_md5(em), 24)

            fake = fake_conf(alternative_gravatar_url='{scheme}://{netloc}/{md5email}/{size}')

            with mock.patch('pylons.config', fake):

                em = 'test@foo.com'

                grav = gravatar_url(email_address=em, size=24)

                assert grav == 'https://server.com/%s/%s' % (_md5(em), 24)