:param repo_name:

        """

        try:

            fork_id = request.POST.get('id_fork_of')

            repo = ScmModel().mark_as_fork(repo_name, fork_id,

                                           request.authuser.username)

            fork = repo.fork.repo_name if repo.fork else _('Nothing')

            Session().commit()

            h.flash(_('Marked repository %s as fork of %s') % (repo_name, fork),

                    category='success')

        except RepositoryError as e:

            log.error(traceback.format_exc())

        except Exception as e:

            log.error(traceback.format_exc())

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

                    category='error')

        raise HTTPFound(location=url('edit_repo_advanced', repo_name=repo_name))

    @HasRepoPermissionLevelDecorator('admin')

    def edit_caches(self, repo_name):

        c.repo_info = self._load_repo()

        c.active = 'caches'

        if request.POST:

        Safe way to get changeset. If error occur fail with error message.

        :param rev: revision to fetch

        :param repo: repo instance

        """

        try:

            return c.db_repo_scm_instance.get_changeset(rev)

        except EmptyRepositoryError as e:

            h.flash(_('There are no changesets yet'), category='error')

        except RepositoryError as e:

            log.error(traceback.format_exc())

        raise HTTPBadRequest()

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

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

        limit = 2000

        default = 100

        if request.GET.get('size'):

            c.size = max(min(safe_int(request.GET.get('size')), limit), 1)

            session['changelog_size'] = c.size

            session.save()

        else:

            if f_path:

                log.debug('generating changelog for path %s', f_path)

                # get the history for the file !

                tip_cs = c.db_repo_scm_instance.get_changeset()

                try:

                    collection = tip_cs.get_file_history(f_path)

                except (NodeDoesNotExistError, ChangesetError):

                    # this node is not present at tip !

                    try:

                        cs = self.__get_cs(revision, repo_name)

                        collection = cs.get_file_history(f_path)

                    except RepositoryError as e:

                        raise HTTPFound(location=h.url('changelog_home', repo_name=repo_name))

            else:

                collection = c.db_repo_scm_instance.get_changesets(start=0, end=revision,

                                                        branch_name=branch_name, reverse=True)

            c.total_cs = len(collection)

            c.cs_pagination = Page(collection, page=p, item_count=c.total_cs, items_per_page=c.size,

                                   branch=branch_name)

            page_revisions = [x.raw_id for x in c.cs_pagination]

            c.cs_comments = c.db_repo.get_comments(page_revisions)

            c.cs_statuses = c.db_repo.statuses(page_revisions)

        except EmptyRepositoryError as e:

            raise HTTPFound(location=url('summary_home', repo_name=c.repo_name))

        except (RepositoryError, ChangesetDoesNotExistError, Exception) as e:

            log.error(traceback.format_exc())

            raise HTTPFound(location=url('changelog_home', repo_name=c.repo_name))

        c.branch_name = branch_name

        c.branch_filters = [('', _('None'))] + \

            [(k, k) for k in c.db_repo_scm_instance.branches.keys()]

        if c.db_repo_scm_instance.closed_branches:

            prefix = _('(closed)') + ' '

            c.branch_filters += [('-', '-')] + \

                [(k, prefix + k) for k in c.db_repo_scm_instance.closed_branches.keys()]

        revs = []

        if not f_path:

            revs = [x.revision for x in c.cs_pagination]

                return None

            url_ = url('files_add_home',

                       repo_name=c.repo_name,

                       revision=0, f_path='', anchor='edit')

            add_new = h.link_to(_('Click here to add new file'), url_, class_="alert-link")

            h.flash(_('There are no files yet.') + ' ' + add_new, category='warning')

            raise HTTPNotFound()

        except (ChangesetDoesNotExistError, LookupError):

            msg = _('Such revision does not exist for this repository')

            h.flash(msg, category='error')

            raise HTTPNotFound()

        except RepositoryError as e:

            raise HTTPNotFound()

    def __get_filenode(self, cs, path):

        """

        Returns file_node or raise HTTP error.

        :param cs: given changeset

        :param path: path to lookup

        """

        try:

            file_node = cs.get_node(path)

            if file_node.is_dir():

                raise RepositoryError('given path is a directory')

        except ChangesetDoesNotExistError:

            msg = _('Such revision does not exist for this repository')

            h.flash(msg, category='error')

            raise HTTPNotFound()

        except RepositoryError as e:

            raise HTTPNotFound()

        return file_node

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def index(self, repo_name, revision, f_path, annotate=False):

        # redirect to given revision from form if given

        post_revision = request.POST.get('at_rev', None)

        if post_revision:

            cs = self.__get_cs(post_revision) # FIXME - unused!

                c.on_branch_head = revision in _branches or revision in _branches.values()

                _hist = []

                c.file_history = []

                if c.load_full_history:

                    c.file_history, _hist = self._get_node_history(c.changeset, f_path)

                c.authors = []

                for a in set([x.author for x in _hist]):

                    c.authors.append((h.email(a), h.person(a)))

            else:

                c.authors = c.file_history = []

        except RepositoryError as e:

            raise HTTPNotFound()

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            return render('files/files_ypjax.html')

        # TODO: tags and bookmarks?

        c.revision_options = [(c.changeset.raw_id,

                              _('%s at %s') % (b, h.short_id(c.changeset.raw_id))) for b in c.changeset.branches] + \

            [(n, b) for b, n in c.db_repo_scm_instance.branches.items()]

        if c.db_repo_scm_instance.closed_branches:

            prefix = _('(closed)') + ' '

            c.revision_options += [('-', '-')] + \

        other_ref = _form['other_ref'] # will have symbolic name and head revision

        other_repo = Repository.guess_instance(_form['other_repo'])

        reviewers = []

        title = _form['pullrequest_title']

        description = _form['pullrequest_desc'].strip()

        owner = User.get(request.authuser.user_id)

        try:

            cmd = CreatePullRequestAction(org_repo, other_repo, org_ref, other_ref, title, description, owner, reviewers)

        except CreatePullRequestAction.ValidationError as e:

            raise HTTPNotFound

        try:

            pull_request = cmd.execute()

            Session().commit()

        except Exception:

            h.flash(_('Error occurred while creating pull request'),

                    category='error')

            log.error(traceback.format_exc())

            raise HTTPFound(location=url('pullrequest_home', repo_name=repo_name))

        h.flash(_('Successfully opened new pull request'),

                category='success')

        raise HTTPFound(location=pull_request.url())

    def create_new_iteration(self, old_pull_request, new_rev, title, description, reviewers):

        owner = User.get(request.authuser.user_id)

        new_org_rev = self._get_ref_rev(old_pull_request.org_repo, 'rev', new_rev)

        new_other_rev = self._get_ref_rev(old_pull_request.other_repo, old_pull_request.other_ref_parts[0], old_pull_request.other_ref_parts[1])

        try:

            cmd = CreatePullRequestIterationAction(old_pull_request, new_org_rev, new_other_rev, title, description, owner, reviewers)

        except CreatePullRequestAction.ValidationError as e:

            raise HTTPNotFound

        try:

            pull_request = cmd.execute()

            Session().commit()

        except Exception:

            h.flash(_('Error occurred while creating pull request'),

                    category='error')

            log.error(traceback.format_exc())

            raise HTTPFound(location=old_pull_request.url())

        h.flash(_('New pull request iteration created'),

        kind = 'README'

        return _get_readme_from_cache(repo_name, kind, c.db_repo.changeset_cache.get('raw_id'))

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def index(self, repo_name):

        p = safe_int(request.GET.get('page'), 1)

        size = safe_int(request.GET.get('size'), 10)

        try:

            collection = c.db_repo_scm_instance.get_changesets(reverse=True)

        except EmptyRepositoryError as e:

            collection = []

        c.cs_pagination = Page(collection, page=p, items_per_page=size)

        page_revisions = [x.raw_id for x in list(c.cs_pagination)]

        c.cs_comments = c.db_repo.get_comments(page_revisions)

        c.cs_statuses = c.db_repo.statuses(page_revisions)

        c.ssh_repo_url = None

        if request.authuser.is_default_user:

            username = None

        else:

            username = request.authuser.username

            if c.ssh_enabled:

        except EmptyRepositoryError as e:

            if returnempty:

                return repo.scm_instance.EMPTY_CHANGESET

            h.flash(_('There are no changesets yet'), category='error')

            raise webob.exc.HTTPNotFound()

        except ChangesetDoesNotExistError as e:

            h.flash(_('Changeset for %s %s not found in %s') %

                              (ref_type, ref_name, repo.repo_name),

                    category='error')

            raise webob.exc.HTTPNotFound()

        except RepositoryError as e:

            log.error(traceback.format_exc())

            raise webob.exc.HTTPBadRequest()

@decorator.decorator

def jsonify(func, *args, **kwargs):

    """Action decorator that formats output for JSON

    Given a function that will return content, this decorator will turn

    the result into JSON, with a content-type of 'application/json' and

    output it.

    """

    response.headers['Content-Type'] = 'application/json; charset=utf-8'

            return uri

        return _url_func

    return literal(markup_whitespace(annotate_highlight(filenode, url_func(repo_name), **kwargs)))

class _Message(object):

    """A message returned by ``pop_flash_messages()``.

    Converting the message to a string returns the message text. Instances

    also have the following attributes:

    * ``category``: the category specified when the message was created.

    """

    def __init__(self, category, message):

        self.category = category

        self.message = message

def _session_flash_messages(append=None, clear=False):

    """Manage a message queue in tg.session: return the current message queue

    after appending the given message, and possibly clearing the queue."""

    key = 'flash'

    from tg import session

    if key in session:

        flash_messages = session[key]

    else:

        if append is None:  # common fast path - also used for clearing empty queue

            return []  # don't bother saving

        flash_messages = []

        session[key] = flash_messages

    if append is not None and append not in flash_messages:

        flash_messages.append(append)

    if clear:

        session.pop(key, None)

    session.save()

    return flash_messages

    """

    Show a message to the user _and_ log it through the specified function

    category: notice (default), warning, error, success

    logf: a custom log function - such as log.debug

    logf defaults to log.info, unless category equals 'success', in which

    case logf defaults to log.debug.

    """

    if logf is None:

        logf = log.info

        if category == 'success':

            logf = log.debug

def pop_flash_messages():

    """Return all accumulated messages and delete them from the session.

    The return value is a list of ``Message`` objects.

    """

age = lambda x, y=False: _age(x, y)

capitalize = lambda x: x.capitalize()

email = author_email

short_id = lambda x: x[:12]

hide_credentials = lambda x: ''.join(credentials_filter(x))

def show_id(cs):

    """

    Configurable function that shows ID

<div class="flash_msg">

    <% messages = h.pop_flash_messages() %>

    % if messages:

        <% alert_categories = {'warning': 'alert-warning', 'notice': 'alert-info', 'error': 'alert-danger', 'success': 'alert-success'} %>

        % for message in messages:

            <div class="alert alert-dismissable ${alert_categories[message.category]}" role="alert">

              <button type="button" class="close" data-dismiss="alert" aria-hidden="true"><i class="icon-cancel-circled"></i></button>

            </div>

        % endfor

    % endif

    <script>

    if (typeof jQuery != 'undefined') {

        $(".alert").alert();

    }

    </script>

</div>

    def test_delete_repo_err(self):

        self.log_user()

        username = 'repoerr'

        reponame = u'repoerr_fail'

        fixture.create_user(name=username)

        fixture.create_repo(name=reponame, cur_user=username)

        new_user = Session().query(User) \

            .filter(User.username == username).one()

        response = self.app.post(url('delete_user', id=new_user.user_id),

            params={'_session_csrf_secret_token': self.session_csrf_secret_token()})

                               'owns 1 repositories and cannot be removed. '

                               'Switch owners or remove those repositories: '

                               '%s' % (username, reponame))

        response = self.app.post(url('delete_repo', repo_name=reponame),

            params={'_session_csrf_secret_token': self.session_csrf_secret_token()})

        self.checkSessionFlash(response, 'Deleted repository %s' % reponame)

        response = self.app.post(url('delete_user', id=new_user.user_id),

            params={'_session_csrf_secret_token': self.session_csrf_secret_token()})

        self.checkSessionFlash(response, 'Successfully deleted user')

    def test_delete_repo_group_err(self, user_and_repo_group_fail):

        new_user, repo_group = user_and_repo_group_fail

        username = new_user.username

        groupname = repo_group.group_name

        self.log_user()

        response = self.app.post(url('delete_user', id=new_user.user_id),

            params={'_session_csrf_secret_token': self.session_csrf_secret_token()})

                               'owns 1 repository groups and cannot be removed. '

                               'Switch owners or remove those repository groups: '

                               '%s' % (username, groupname))

        # Relevant _if_ the user deletion succeeded to make sure we can render groups without owner

        # rg = RepoGroup.get_by_group_name(group_name=groupname)

        # response = self.app.get(url('repos_groups', id=rg.group_id))

        response = self.app.post(url('delete_repo_group', group_name=groupname),

            params={'_session_csrf_secret_token': self.session_csrf_secret_token()})

        self.checkSessionFlash(response, 'Removed repository group %s' % groupname)

    def test_delete_user_group_err(self):

        self.log_user()

        username = 'usergrouperr'

        groupname = u'usergroup_fail'

        fixture.create_user(name=username)

        ug = fixture.create_user_group(name=groupname, cur_user=username)

        new_user = Session().query(User) \

            .filter(User.username == username).one()

        response = self.app.post(url('delete_user', id=new_user.user_id),

            params={'_session_csrf_secret_token': self.session_csrf_secret_token()})

                               'owns 1 user groups and cannot be removed. '

                               'Switch owners or remove those user groups: '

                               '%s' % (username, groupname))

        # TODO: why do this fail?

        #response = self.app.delete(url('delete_users_group', id=groupname))

        #self.checkSessionFlash(response, 'Removed user group %s' % groupname)

        fixture.destroy_user_group(ug.users_group_id)

        response = self.app.post(url('delete_user', id=new_user.user_id),

            params={'_session_csrf_secret_token': self.session_csrf_secret_token()})

        msg = """Such revision does not exist for this repository"""

        response.mustcontain(msg)

    def test_raw_file_wrong_f_path(self):

        self.log_user()

        rev = '27cd5cce30c96924232dffcd24178a07ffeb5dfc'

        f_path = 'vcs/ERRORnodes.py'

        response = self.app.get(url(controller='files', action='rawfile',

                                    repo_name=HG_REPO,

                                    revision=rev,

                                    f_path=f_path), status=404)

        response.mustcontain(msg)

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

    # RAW RESPONSE - PLAIN

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

    def test_raw_ok(self):

        self.log_user()

        response = self.app.get(url(controller='files', action='raw',

                                    repo_name=HG_REPO,

                                    revision='27cd5cce30c96924232dffcd24178a07ffeb5dfc',

                                    f_path='vcs/nodes.py'))

        msg = """Such revision does not exist for this repository"""

        response.mustcontain(msg)

    def test_raw_wrong_f_path(self):

        self.log_user()

        rev = '27cd5cce30c96924232dffcd24178a07ffeb5dfc'

        f_path = 'vcs/ERRORnodes.py'

        response = self.app.get(url(controller='files', action='raw',

                                    repo_name=HG_REPO,

                                    revision=rev,

                                    f_path=f_path), status=404)

        response.mustcontain(msg)

    def test_ajaxed_files_list(self):

        self.log_user()

        rev = '27cd5cce30c96924232dffcd24178a07ffeb5dfc'

        response = self.app.get(

            url('files_nodelist_home', repo_name=HG_REPO, f_path='/',

                revision=rev),

            extra_environ={'HTTP_X_PARTIAL_XHR': '1'},

        )

        response.mustcontain("vcs/web/simplevcs/views/repository.py")

        # update it

        response = self.app.post(url(controller='pullrequests', action='post',

                                     repo_name=HG_REPO, pull_request_id=pull_request_id),

                                 {

                                  'updaterev': '4f7e2131323e0749a740c0a56ab68ae9269c562a',

                                  'pullrequest_title': 'title',

                                  'pullrequest_desc': 'description',

                                  'owner': TEST_USER_ADMIN_LOGIN,

                                  '_session_csrf_secret_token': self.session_csrf_secret_token(),

                                  'review_members': [str(invalid_user_id)],

                                 },

                                 status=400)

    def test_edit_with_invalid_reviewer(self):

        invalid_user_id = 99999

        self.log_user()

        # create a valid pull request

        response = self.app.post(url(controller='pullrequests', action='create',

                                     repo_name=HG_REPO),

                                 {

                                  'org_repo': HG_REPO,

                                  'org_ref': 'branch:stable:4f7e2131323e0749a740c0a56ab68ae9269c562a',

                                  'other_repo': HG_REPO,

                                  'other_ref': 'branch:default:96507bd11ecc815ebc6270fdf6db110928c09c1e',

        # edit it

        response = self.app.post(url(controller='pullrequests', action='post',

                                     repo_name=HG_REPO, pull_request_id=pull_request_id),

                                 {

                                  'pullrequest_title': 'title',

                                  'pullrequest_desc': 'description',

                                  'owner': TEST_USER_ADMIN_LOGIN,

                                  '_session_csrf_secret_token': self.session_csrf_secret_token(),

                                  'review_members': [str(invalid_user_id)],

                                 },

                                 status=400)

    def test_iteration_refs(self):

        # Repo graph excerpt:

        #   o   fb95b340e0d0 webvcs

        #  /:

        # o :   41d2568309a0 default

        # : :

        # : o   5ec21f21aafe webvcs

        # : :

        # : o   9e6119747791 webvcs

        # : :

        # o :   3d1091ee5a53 default