pass

    return ig_ws_global

def _ignorews_url(GET, fileid=None):

    fileid = str(fileid) if fileid else None

    params = defaultdict(list)

    _update_with_GET(params, GET)

    lbl = _('Show white space')

    ig_ws = get_ignore_ws(fileid, GET)

    ln_ctx = get_line_ctx(fileid, GET)

    # global option

    if fileid is None:

        if ig_ws is None:

            params['ignorews'] += [1]

            lbl = _('Ignore white space')

        ctx_key = 'context'

        ctx_val = ln_ctx

    # per file options

    else:

        if ig_ws is None:

            params[fileid] += ['WS:1']

            lbl = _('Ignore white space')

        ctx_key = fileid

        ctx_val = 'C:%s' % ln_ctx

    # if we have passed in ln_ctx pass it along to our params

    if ln_ctx:

        params[ctx_key] += [ctx_val]

    params['anchor'] = fileid

    img = h.image(h.url('/images/icons/text_strikethrough.png'), lbl, class_='icon')

    return h.link_to(img, h.url.current(**params), title=lbl, class_='tooltip')

def get_line_ctx(fid, GET):

    ln_ctx_global = GET.get('context')

    if fid:

        ln_ctx = filter(lambda k: k.startswith('C'), GET.getall(fid))

    else:

        _ln_ctx = filter(lambda k: k.startswith('C'), GET)

        ln_ctx = GET.get(_ln_ctx[0]) if _ln_ctx  else ln_ctx_global

        if ln_ctx:

            ln_ctx = [ln_ctx]

    if ln_ctx:

        retval = ln_ctx[0].split(':')[-1]

    else:

        retval = ln_ctx_global

    try:

        return int(retval)

    except Exception:

        return 3

def _context_url(GET, fileid=None):

    """

    Generates url for context lines

    :param fileid:

    """

    fileid = str(fileid) if fileid else None

    ig_ws = get_ignore_ws(fileid, GET)

    ln_ctx = (get_line_ctx(fileid, GET) or 3) * 2

    params = defaultdict(list)

    _update_with_GET(params, GET)

    # global option

    if fileid is None:

        if ln_ctx > 0:

            params['context'] += [ln_ctx]

        if ig_ws:

            ig_ws_key = 'ignorews'

            ig_ws_val = 1

    # per file option

    else:

        params[fileid] += ['C:%s' % ln_ctx]

        ig_ws_key = fileid

        ig_ws_val = 'WS:%s' % 1

    if ig_ws:

        params[ig_ws_key] += [ig_ws_val]

    lbl = _('%s line context') % ln_ctx

    params['anchor'] = fileid

    img = h.image(h.url('/images/icons/table_add.png'), lbl, class_='icon')

    return h.link_to(img, h.url.current(**params), title=lbl, class_='tooltip')

class ChangesetController(BaseRepoController):

    def __before__(self):

        super(ChangesetController, self).__before__()

        c.affected_files_cut_off = 60

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

    def _index(self, revision, method):

        c.anchor_url = anchor_url

        c.ignorews_url = _ignorews_url

        c.context_url = _context_url

        c.fulldiff = fulldiff = request.GET.get('fulldiff')

        #get ranges of revisions if preset

        rev_range = revision.split('...')[:2]

        enable_comments = True

        try:

            if len(rev_range) == 2:

                enable_comments = False

                rev_start = rev_range[0]

                rev_end = rev_range[1]

                rev_ranges = c.rhodecode_repo.get_changesets(start=rev_start,

                                                             end=rev_end)

            else:

                rev_ranges = [c.rhodecode_repo.get_changeset(revision)]

            c.cs_ranges = list(rev_ranges)

            if not c.cs_ranges:

                raise RepositoryError('Changeset range returned empty result')

        except (RepositoryError, ChangesetDoesNotExistError, Exception), e:

            log.error(traceback.format_exc())

            h.flash(str(e), category='error')

            raise HTTPNotFound()

        c.changes = OrderedDict()

        c.lines_added = 0  # count of lines added

        c.lines_deleted = 0  # count of lines removes

        c.changeset_statuses = ChangesetStatus.STATUSES

        c.comments = []

        c.statuses = []

        c.inline_comments = []

        c.inline_cnt = 0

        # Iterate over ranges (default changeset view is always one changeset)

        for changeset in c.cs_ranges:

            inlines = []

            if method == 'show':

                c.statuses.extend([ChangesetStatusModel().get_status(

                            c.rhodecode_db_repo.repo_id, changeset.raw_id)])

                c.comments.extend(ChangesetCommentsModel()\

                                  .get_comments(c.rhodecode_db_repo.repo_id,

                                                revision=changeset.raw_id))

                #comments from PR

                st = ChangesetStatusModel().get_statuses(

                            c.rhodecode_db_repo.repo_id, changeset.raw_id,

                            with_revisions=True)

                # from associated statuses, check the pull requests, and

                # show comments from them

                prs = set([x.pull_request for x in

                           filter(lambda x: x.pull_request != None, st)])

                for pr in prs:

                    c.comments.extend(pr.comments)

                inlines = ChangesetCommentsModel()\

                            .get_inline_comments(c.rhodecode_db_repo.repo_id,

                                                 revision=changeset.raw_id)

                c.inline_comments.extend(inlines)

            c.changes[changeset.raw_id] = []

            cs2 = changeset.raw_id

            cs1 = changeset.parents[0].raw_id if changeset.parents else EmptyChangeset()

            context_lcl = get_line_ctx('', request.GET)

            ign_whitespace_lcl = ign_whitespace_lcl = get_ignore_ws('', request.GET)

            _diff = c.rhodecode_repo.get_diff(cs1, cs2,

                ignore_whitespace=ign_whitespace_lcl, context=context_lcl)

            diff_limit = self.cut_off_limit if not fulldiff else None

            diff_processor = diffs.DiffProcessor(_diff,

                                                 vcs=c.rhodecode_repo.alias,

                                                 format='gitdiff',

                                                 diff_limit=diff_limit)

            cs_changes = OrderedDict()

            if method == 'show':

                _parsed = diff_processor.prepare()

                c.limited_diff = False

                if isinstance(_parsed, LimitedDiffContainer):

                    c.limited_diff = True

                for f in _parsed:

                    st = f['stats']

                    fid = h.FID(changeset.raw_id, f['filename'])

                    diff = diff_processor.as_html(enable_comments=enable_comments,

                                                  parsed_lines=[f])

                    cs_changes[fid] = [cs1, cs2, f['operation'], f['filename'],

                                       diff, st]

            else:

                # downloads/raw we only need RAW diff nothing else

                diff = diff_processor.as_raw()

                cs_changes[''] = [None, None, None, None, diff, None]

            c.changes[changeset.raw_id] = cs_changes

        #sort comments by how they were generated

        c.comments = sorted(c.comments, key=lambda x: x.comment_id)

        # count inline comments

        for __, lines in c.inline_comments:

            for comments in lines.values():

                c.inline_cnt += len(comments)

        if len(c.cs_ranges) == 1:

            c.changeset = c.cs_ranges[0]

            c.parent_tmpl = ''.join(['# Parent  %s\n' % x.raw_id

                                     for x in c.changeset.parents])

        if method == 'download':

            response.content_type = 'text/plain'

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

                                            % revision[:12]

            return diff

        elif method == 'patch':

            response.content_type = 'text/plain'

            c.diff = safe_unicode(diff)

            return render('changeset/patch_changeset.html')

        elif method == 'raw':

            response.content_type = 'text/plain'

            return diff

        elif method == 'show':

            if len(c.cs_ranges) == 1:

                return render('changeset/changeset.html')

            else:

                return render('changeset/changeset_range.html')

    @LoginRequired()

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

                                   'repository.admin')

    def index(self, revision, method='show'):

        return self._index(revision, method=method)

    @LoginRequired()

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

                                   'repository.admin')

    def changeset_raw(self, revision):

        return self._index(revision, method='raw')

    @LoginRequired()

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

                                   'repository.admin')

    def changeset_patch(self, revision):

        return self._index(revision, method='patch')

    @LoginRequired()

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

                                   'repository.admin')

    def changeset_download(self, revision):

        return self._index(revision, method='download')

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    @jsonify

    def comment(self, repo_name, revision):

        status = request.POST.get('changeset_status')

        change_status = request.POST.get('change_changeset_status')

        text = request.POST.get('text')

        if status and change_status:

            text = text or (_('Status change -> %s')

                            % ChangesetStatus.get_status_lbl(status))

        c.co = comm = ChangesetCommentsModel().create(

            text=text,

            repo=c.rhodecode_db_repo.repo_id,

            user=c.rhodecode_user.user_id,

            revision=revision,

            f_path=request.POST.get('f_path'),

            line_no=request.POST.get('line'),

            status_change=(ChangesetStatus.get_status_lbl(status)

                           if status and change_status else None)

        )

        # get status if set !

        if status and change_status:

            # if latest status was from pull request and it's closed

            # disallow changing status !

            # dont_allow_on_closed_pull_request = True !

            try:

                ChangesetStatusModel().set_status(

                    c.rhodecode_db_repo.repo_id,

                    status,

                    c.rhodecode_user.user_id,

                    comm,

                    revision=revision,

                    dont_allow_on_closed_pull_request=True

                )

            except StatusChangeOnClosedPullRequestError:

                log.error(traceback.format_exc())

                msg = _('Changing status on a changeset associated with '

                        'a closed pull request is not allowed')

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

                return redirect(h.url('changeset_home', repo_name=repo_name,

                                      revision=revision))

        action_logger(self.rhodecode_user,

                      'user_commented_revision:%s' % revision,

                      c.rhodecode_db_repo, self.ip_addr, self.sa)

        Session().commit()

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

            return redirect(h.url('changeset_home', repo_name=repo_name,

                                  revision=revision))

        #only ajax below

        data = {

           'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),

        }

        if comm:

            data.update(comm.get_dict())

            data.update({'rendered_text':

                         render('changeset/changeset_comment_block.html')})

        return data

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    def preview_comment(self):

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

            raise HTTPBadRequest()

        text = request.POST.get('text')

        if text:

            return h.rst_w_mentions(text)

        return ''

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    @jsonify

    def delete_comment(self, repo_name, comment_id):

        co = ChangesetComment.get(comment_id)

        owner = co.author.user_id == c.rhodecode_user.user_id

        if h.HasPermissionAny('hg.admin', 'repository.admin')() or owner:

            ChangesetCommentsModel().delete(comment=co)

            Session().commit()

            return True

        else:

            raise HTTPForbidden()

    @LoginRequired()

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

                                   'repository.admin')

    @jsonify

    def changeset_info(self, repo_name, revision):

        if request.is_xhr:

            try:

                return c.rhodecode_repo.get_changeset(revision)

            except ChangesetDoesNotExistError, e:

                return EmptyChangeset(message=str(e))

        else:

            raise HTTPBadRequest()

            type_, rev = rev

            return repo.scm_instance.get_changeset(rev)

        except EmptyRepositoryError, e:

            if not redirect_after:

                return None

            h.flash(h.literal(_('There are no changesets yet')),

                    category='warning')

            redirect(url('summary_home', repo_name=repo.repo_name))

        except RepositoryError, e:

            log.error(traceback.format_exc())

            h.flash(str(e), category='warning')

            if not partial:

                redirect(h.url('summary_home', repo_name=repo.repo_name))

            raise HTTPBadRequest()

    def _get_changesets(self, alias, org_repo, org_ref, other_repo, other_ref, merge):

        """

        Returns a list of changesets that can be merged from org_repo@org_ref

        to other_repo@other_ref ... and the ancestor that would be used for merge

        :param org_repo:

        :param org_ref:

        :param other_repo:

        :param other_ref:

        :param tmp:

        """

        ancestor = None

        if alias == 'hg':

            # lookup up the exact node id

            _revset_predicates = {

                    'branch': 'branch',

                    'book': 'bookmark',

                    'tag': 'tag',

                    'rev': 'id',

                }

            org_rev_spec = "max(%s(%%s))" % _revset_predicates[org_ref[0]]

            org_revs = org_repo._repo.revs(org_rev_spec, safe_str(org_ref[1]))

            org_rev = org_repo._repo[org_revs[-1] if org_revs else -1].hex()

            other_revs_spec = "max(%s(%%s))" % _revset_predicates[other_ref[0]]

            other_revs = other_repo._repo.revs(other_revs_spec, safe_str(other_ref[1]))

            other_rev = other_repo._repo[other_revs[-1] if other_revs else -1].hex()

            #case two independent repos

            if org_repo != other_repo:

                hgrepo = unionrepo.unionrepository(other_repo.baseui,

                                                   other_repo.path,

                                                   org_repo.path)

                # all the changesets we are looking for will be in other_repo,

                # so rev numbers from hgrepo can be used in other_repo

            #no remote compare do it on the same repository

            else:

                hgrepo = other_repo._repo

            if merge:

                revs = hgrepo.revs("ancestors(id(%s)) and not ancestors(id(%s)) and not id(%s)",

                                   other_rev, org_rev, org_rev)

                ancestors = hgrepo.revs("ancestor(id(%s), id(%s))", org_rev, other_rev)

                if ancestors:

                    # pick arbitrary ancestor - but there is usually only one

                    ancestor = hgrepo[ancestors[0]].hex()

            else:

                # TODO: have both + and - changesets

                revs = hgrepo.revs("id(%s) :: id(%s) - id(%s)",

                                   org_rev, other_rev, org_rev)

            changesets = [other_repo.get_changeset(rev) for rev in revs]

        elif alias == 'git':

            if org_repo != other_repo:

                raise Exception('Comparing of different GIT repositories is not'

                                'allowed. Got %s != %s' % (org_repo, other_repo))

            so, se = org_repo.run_git_command(

                'log --reverse --pretty="format: %%H" -s -p %s..%s'

                    % (org_ref[1], other_ref[1])

            )

            changesets = [org_repo.get_changeset(cs)

                          for cs in re.findall(r'[0-9a-fA-F]{40}', so)]

        return changesets, ancestor

    @LoginRequired()

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

                                   'repository.admin')

    def index(self, org_ref_type, org_ref, other_ref_type, other_ref):

        # org_ref will be evaluated in org_repo

        org_repo = c.rhodecode_db_repo.repo_name

        org_ref = (org_ref_type, org_ref)

        # other_ref will be evaluated in other_repo

        other_ref = (other_ref_type, other_ref)

        other_repo = request.GET.get('other_repo', org_repo)

        # If merge is True:

        #   Show what org would get if merged with other:

        #   List changesets that are ancestors of other but not of org.

        #   New changesets in org is thus ignored.

        #   Diff will be from common ancestor, and merges of org to other will thus be ignored.

        # If merge is False:

        #   Make a raw diff from org to other, no matter if related or not.

        #   Changesets in one and not in the other will be ignored

        merge = bool(request.GET.get('merge'))

        # fulldiff disables cut_off_limit

        c.fulldiff = request.GET.get('fulldiff')

        # partial uses compare_cs.html template directly

        partial = request.environ.get('HTTP_X_PARTIAL_XHR')

        # as_form puts hidden input field with changeset revisions

        c.as_form = partial and request.GET.get('as_form')

        # swap url for compare_diff page - never partial and never as_form

        c.swap_url = h.url('compare_url',

            repo_name=other_repo,

            org_ref_type=other_ref[0], org_ref=other_ref[1],

            other_repo=org_repo,

            other_ref_type=org_ref[0], other_ref=org_ref[1],

            merge=merge or '')

        org_repo = Repository.get_by_repo_name(org_repo)

        other_repo = Repository.get_by_repo_name(other_repo)

        if org_repo is None:

            log.error('Could not find org repo %s' % org_repo)

            raise HTTPNotFound

        if other_repo is None:

            log.error('Could not find other repo %s' % other_repo)

            raise HTTPNotFound

        if org_repo != other_repo and h.is_git(org_repo):

            log.error('compare of two remote repos not available for GIT REPOS')

            raise HTTPNotFound

        if org_repo.scm_instance.alias != other_repo.scm_instance.alias:

            log.error('compare of two different kind of remote repos not available')

            raise HTTPNotFound

        self.__get_cs_or_redirect(rev=org_ref, repo=org_repo, partial=partial)

        self.__get_cs_or_redirect(rev=other_ref, repo=other_repo, partial=partial)

        c.org_repo = org_repo

        c.other_repo = other_repo

        c.org_ref = org_ref[1]

        c.other_ref = other_ref[1]

        c.org_ref_type = org_ref[0]

        c.other_ref_type = other_ref[0]

        c.cs_ranges, c.ancestor = self._get_changesets(org_repo.scm_instance.alias,

                                                       org_repo.scm_instance, org_ref,

                                                       other_repo.scm_instance, other_ref,

                                                       merge)

        c.statuses = c.rhodecode_db_repo.statuses([x.raw_id for x in

                                                   c.cs_ranges])

        if not c.ancestor:

            log.warning('Unable to find ancestor revision')

        if partial:

            return render('compare/compare_cs.html')

        if c.ancestor:

            assert merge

            # case we want a simple diff without incoming changesets,

            # previewing what will be merged.

            # Make the diff on the other repo (which is known to have other_ref)

            log.debug('Using ancestor %s as org_ref instead of %s'

                      % (c.ancestor, org_ref))

            org_ref = ('rev', c.ancestor)

            org_repo = other_repo

        diff_limit = self.cut_off_limit if not c.fulldiff else None

        log.debug('running diff between %s and %s in %s'

                  % (org_ref, other_ref, org_repo.scm_instance.path))

        txtdiff = org_repo.scm_instance.get_diff(rev1=safe_str(org_ref[1]), rev2=safe_str(other_ref[1]))

        diff_processor = diffs.DiffProcessor(txtdiff or '', format='gitdiff',

                                             diff_limit=diff_limit)

        _parsed = diff_processor.prepare()

        c.limited_diff = False

        if isinstance(_parsed, LimitedDiffContainer):

            c.limited_diff = True

        c.files = []

        c.changes = {}

        c.lines_added = 0

        c.lines_deleted = 0

        for f in _parsed:

            st = f['stats']

            fid = h.FID('', f['filename'])

            c.files.append([fid, f['operation'], f['filename'], f['stats']])

            htmldiff = diff_processor.as_html(enable_comments=False, parsed_lines=[f])

            c.changes[fid] = [f['operation'], f['filename'], htmldiff]

        return render('compare/compare_diff.html')

# -*- coding: utf-8 -*-

"""

    rhodecode.controllers.feed

    ~~~~~~~~~~~~~~~~~~~~~~~~~~

    Feed controller for rhodecode

    :created_on: Apr 23, 2010

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

from pylons import url, response, tmpl_context as c

from pylons.i18n.translation import _

from beaker.cache import cache_region, region_invalidate

from webhelpers.feedgenerator import Atom1Feed, Rss201rev2Feed

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController

from rhodecode.lib.diffs import DiffProcessor, LimitedDiffContainer

from rhodecode.model.db import CacheInvalidation

from rhodecode.lib.utils2 import safe_int, str2bool, safe_unicode

log = logging.getLogger(__name__)

class FeedController(BaseRepoController):

    @LoginRequired(api_access=True)

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

                                   'repository.admin')

    def __before__(self):

        super(FeedController, self).__before__()

        #common values for feeds

        self.description = _('Changes on %s repository')

        self.title = self.title = _('%s %s feed') % (c.rhodecode_name, '%s')

        self.language = 'en-us'

        self.ttl = "5"

        import rhodecode

        CONF = rhodecode.CONFIG

        self.include_diff = str2bool(CONF.get('rss_include_diff', False))

        self.feed_nr = safe_int(CONF.get('rss_items_per_page', 20))

        # we need to protect from parsing huge diffs here other way

        # we can kill the server

        self.feed_diff_limit = safe_int(CONF.get('rss_cut_off_limit', 32 * 1024))

    def _get_title(self, cs):

        return "%s" % (

            h.shorter(cs.message, 160)

        )

    def __changes(self, cs):

        changes = []

        diff_processor = DiffProcessor(cs.diff(),

                                       diff_limit=self.feed_diff_limit)

        _parsed = diff_processor.prepare(inline_diff=False)

        limited_diff = False

        if isinstance(_parsed, LimitedDiffContainer):

            limited_diff = True

        for st in _parsed:

            changes.append('\n %(operation)s %(filename)s '

                           '(%(added)s lines added, %(removed)s lines removed)'

                            % st)

        if limited_diff:

            changes = changes + ['\n ' +

                                 _('Changeset was too big and was cut off...')]

        return diff_processor, changes

    def __get_desc(self, cs):

        desc_msg = []

        desc_msg.append((_('%s committed on %s')

                         % (h.person(cs.author), h.fmt_date(cs.date))) + '<br/>')

        #branches, tags, bookmarks

        if cs.branch:

            desc_msg.append('branch: %s<br/>' % cs.branch)

        if h.is_hg(c.rhodecode_repo):

            for book in cs.bookmarks:

                desc_msg.append('bookmark: %s<br/>' % book)

        for tag in cs.tags:

            desc_msg.append('tag: %s<br/>' % tag)

        diff_processor, changes = self.__changes(cs)

        # rev link

        _url = url('changeset_home', repo_name=cs.repository.name,

                   revision=cs.raw_id, qualified=True)

        desc_msg.append('changeset: <a href="%s">%s</a>' % (_url, cs.raw_id[:8]))

        desc_msg.append('<pre>')

        desc_msg.append(cs.message)

        desc_msg.append('\n')

        desc_msg.extend(changes)

        if self.include_diff:

            desc_msg.append('\n\n')

            desc_msg.append(diff_processor.as_raw())

        desc_msg.append('</pre>')

        return map(safe_unicode, desc_msg)

    def atom(self, repo_name):

        """Produce an atom-1.0 feed via feedgenerator module"""

        @cache_region('long_term')

        def _get_feed_from_cache(key, kind):

            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 reversed(list(c.rhodecode_repo[-self.feed_nr:])):

                feed.add_item(title=self._get_title(cs),

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

                                       revision=cs.raw_id, qualified=True),

                              author_name=cs.author,

                              description=''.join(self.__get_desc(cs)),

                              pubdate=cs.date,

                              )

            response.content_type = feed.mime_type

            return feed.writeString('utf-8')

        kind = 'ATOM'

        valid = CacheInvalidation.test_and_set_valid(repo_name, kind)

        if not valid:

            region_invalidate(_get_feed_from_cache, None, repo_name, kind)

        return _get_feed_from_cache(repo_name, kind)

    def rss(self, repo_name):

        """Produce an rss2 feed via feedgenerator module"""

        @cache_region('long_term')

        def _get_feed_from_cache(key, kind):

            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 reversed(list(c.rhodecode_repo[-self.feed_nr:])):

                feed.add_item(title=self._get_title(cs),

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

                                       revision=cs.raw_id, qualified=True),

                              author_name=cs.author,

                              description=''.join(self.__get_desc(cs)),

                              pubdate=cs.date,

                             )

            response.content_type = feed.mime_type

            return feed.writeString('utf-8')

        kind = 'RSS'

        valid = CacheInvalidation.test_and_set_valid(repo_name, kind)

        if not valid:

            region_invalidate(_get_feed_from_cache, None, repo_name, kind)

        return _get_feed_from_cache(repo_name, kind)

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

import traceback

import formencode

from webob.exc import HTTPNotFound, HTTPForbidden

from collections import defaultdict

from itertools import groupby

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

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

from rhodecode.lib.compat import json

from rhodecode.lib.base import BaseRepoController, render

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

    NotAnonymous

from rhodecode.lib.helpers import Page

from rhodecode.lib import helpers as h

from rhodecode.lib import diffs

from rhodecode.lib.utils import action_logger, jsonify

from rhodecode.lib.vcs.utils import safe_str

from rhodecode.lib.vcs.exceptions import EmptyRepositoryError

from rhodecode.lib.vcs.backends.base import EmptyChangeset

from rhodecode.lib.diffs import LimitedDiffContainer

from rhodecode.model.db import User, PullRequest, ChangesetStatus,\

    ChangesetComment

from rhodecode.model.pull_request import PullRequestModel

from rhodecode.model.meta import Session

from rhodecode.model.repo import RepoModel

from rhodecode.model.comment import ChangesetCommentsModel

from rhodecode.model.changeset_status import ChangesetStatusModel

from rhodecode.model.forms import PullRequestForm

from mercurial import scmutil

from rhodecode.lib.utils2 import safe_int

log = logging.getLogger(__name__)

class PullrequestsController(BaseRepoController):

    def __before__(self):

        super(PullrequestsController, self).__before__()

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

    def _get_repo_refs(self, repo, rev=None, branch=None, branch_rev=None):

        """return a structure with repo's interesting changesets, suitable for

        the selectors in pullrequest.html

        rev: a revision that must be in the list somehow and selected by default

        branch: a branch that must be in the list and selected by default - even if closed

        branch_rev: a revision of which peers should be preferred and available."""

        # list named branches that has been merged to this named branch - it should probably merge back

        peers = []

        if rev:

            rev = safe_str(rev)

        if branch:

            branch = safe_str(branch)

        if branch_rev:

            branch_rev = safe_str(branch_rev)

            # not restricting to merge() would also get branch point and be better

            # (especially because it would get the branch point) ... but is currently too expensive

            otherbranches = {}

            for i in repo._repo.revs(

                "sort(parents(branch(id(%s)) and merge()) - branch(id(%s)))",

                branch_rev, branch_rev):

                cs = repo.get_changeset(i)

                otherbranches[cs.branch] = cs.raw_id

            for abranch, node in otherbranches.iteritems():

                selected = 'branch:%s:%s' % (abranch, node)

                peers.append((selected, abranch))

        selected = None

        branches = []

        for abranch, branchrev in repo.branches.iteritems():

            n = 'branch:%s:%s' % (abranch, branchrev)

            branches.append((n, abranch))

            if rev == branchrev:

                selected = n

            if branch == abranch:

                selected = n

                branch = None

        if branch: # branch not in list - it is probably closed

            revs = repo._repo.revs('max(branch(%s))', branch)

            if revs:

                cs = repo.get_changeset(revs[0])

                selected = 'branch:%s:%s' % (branch, cs.raw_id)

                branches.append((selected, branch))

        bookmarks = []

        for bookmark, bookmarkrev in repo.bookmarks.iteritems():

            n = 'book:%s:%s' % (bookmark, bookmarkrev)

            bookmarks.append((n, bookmark))

            if rev == bookmarkrev:

                selected = n