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

    icon = h.literal('<i class="icon-strike"></i>')

    return h.link_to(icon, 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 = _('Increase diff context to %(num)s lines') % {'num': ln_ctx}

    params['anchor'] = fileid

    icon = h.literal('<i class="icon-sort"></i>')

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

# Could perhaps be nice to have in the model but is too high level ...

def create_comment(text, status, f_path, line_no, revision=None, pull_request_id=None, closing_pr=None):

    """Comment functionality shared between changesets and pullrequests"""

    f_path = f_path or None

    line_no = line_no or None

    comment = ChangesetCommentsModel().create(

        text=text,

        repo=c.db_repo.repo_id,

        user=c.authuser.user_id,

        revision=revision,

        pull_request=pull_request_id,

        f_path=f_path,

        line_no=line_no,

        status_change=ChangesetStatus.get_status_lbl(status) if status else None,

        closing_pr=closing_pr,

    )

    return comment

class ChangesetController(BaseRepoController):

    def __before__(self):

        super(ChangesetController, self).__before__()

        c.affected_files_cut_off = 60

    def __load_data(self):

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.user_groups_array = repo_model.get_user_groups_js()

    def _index(self, revision, method):

        c.pull_request = None

        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

        c.cs_repo = c.db_repo

        try:

            if len(rev_range) == 2:

                enable_comments = False

                rev_start = rev_range[0]

                rev_end = rev_range[1]

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

                                                             end=rev_end)

            else:

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

            c.cs_ranges = list(rev_ranges)

            if not c.cs_ranges:

                raise RepositoryError('Changeset range returned empty result')

        except (ChangesetDoesNotExistError, EmptyRepositoryError):

            log.debug(traceback.format_exc())

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

            h.flash(msg, 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

        comments = dict()

        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:

            if method == 'show':

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

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

                # Changeset comments

                comments.update((com.comment_id, com)

                                for com in ChangesetCommentsModel()

                                .get_comments(c.db_repo.repo_id,

                                              revision=changeset.raw_id))

                # Status change comments - mostly from pull requests

                comments.update((st.changeset_comment_id, st.comment)

                                for st in ChangesetStatusModel()

                                .get_statuses(c.db_repo.repo_id,

                                              changeset.raw_id, with_revisions=True)

                                if st.changeset_comment_id is not None)

                inlines = ChangesetCommentsModel() \

                            .get_inline_comments(c.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().raw_id

            context_lcl = get_line_ctx('', request.GET)

            ign_whitespace_lcl = get_ignore_ws('', request.GET)

            _diff = c.db_repo_scm_instance.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.db_repo_scm_instance.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']

                    c.lines_added += st['added']

                    c.lines_deleted += st['deleted']

                    diff = diff_processor.as_html(enable_comments=enable_comments,

                                                  parsed_lines=[f])

                                       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 in creation order

        c.comments = [com for com_id, com in sorted(comments.items())]

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

            self.__load_data()

            if len(c.cs_ranges) == 1:

                return render('changeset/changeset.html')

            else:

                c.cs_ranges_org = None

                c.cs_comments = {}

                revs = [ctx.revision for ctx in reversed(c.cs_ranges)]

                c.jsdata = json.dumps(graph_data(c.db_repo_scm_instance, revs))

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

        assert request.environ.get('HTTP_X_PARTIAL_XHR')

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

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

        c.comment = create_comment(

            text,

            status,

            revision=revision,

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

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

        )

        # get status if set !

        if status:

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

            # disallow changing status ! RLY?

            try:

                ChangesetStatusModel().set_status(

                    c.db_repo.repo_id,

                    status,

                    c.authuser.user_id,

                    c.comment,

                    revision=revision,

                    dont_allow_on_closed_pull_request=True,

                )

            except StatusChangeOnClosedPullRequestError:

                log.debug('cannot change status on %s with closed pull request', revision)

                raise HTTPBadRequest()

        action_logger(self.authuser,

                      'user_commented_revision:%s' % revision,

                      c.db_repo, self.ip_addr, self.sa)

        Session().commit()

        data = {

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

        }

        if c.comment is not None:

            data.update(c.comment.get_dict())

            data.update({'rendered_text':

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

        return data

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    @jsonify

    def delete_comment(self, repo_name, comment_id):

        co = ChangesetComment.get_or_404(comment_id)

        if co.repo.repo_name != repo_name:

            raise HTTPNotFound()

        owner = co.author.user_id == c.authuser.user_id

        repo_admin = h.HasRepoPermissionAny('repository.admin')(repo_name)

        if h.HasPermissionAny('hg.admin')() or repo_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.db_repo_scm_instance.get_changeset(revision)

            except ChangesetDoesNotExistError as e:

                return EmptyChangeset(message=str(e))

        else:

            raise HTTPBadRequest()

    @LoginRequired()

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

                                   'repository.admin')

    @jsonify

    def changeset_children(self, repo_name, revision):

        if request.is_xhr:

            changeset = c.db_repo_scm_instance.get_changeset(revision)

            result = {"results": []}

            if changeset.children:

                result = {"results": changeset.children}

            return result

        else:

            raise HTTPBadRequest()

    @LoginRequired()

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

                                   'repository.admin')

    @jsonify

    def changeset_parents(self, repo_name, revision):

        if request.is_xhr:

            changeset = c.db_repo_scm_instance.get_changeset(revision)

            result = {"results": []}

            if changeset.parents:

                result = {"results": changeset.parents}

            return result

        else:

            raise HTTPBadRequest()

            other_changesets = []

            ancestor = org_rev

        elif alias == 'hg':

            #case two independent repos

            if org_repo != other_repo:

                hgrepo = unionrepo.unionrepository(other_repo.baseui,

                                                   other_repo.path,

                                                   org_repo.path)

                # all ancestors of other_rev will be in other_repo and

                # rev numbers from hgrepo can be used in other_repo - org_rev ancestors cannot

            #no remote compare do it on the same repository

            else:

                hgrepo = other_repo._repo

            if org_repo.EMPTY_CHANGESET in (org_rev, other_rev):

                # work around unexpected behaviour in Mercurial < 3.4

                ancestor = org_repo.EMPTY_CHANGESET

            else:

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

                if ancestors:

                    # FIXME: picks arbitrary ancestor - but there is usually only one

                    try:

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

                    except AttributeError:

                        # removed in hg 3.2

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

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

                                     other_rev, org_rev, org_rev)

            other_changesets = [other_repo.get_changeset(rev) for rev in other_revs]

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

                                   org_rev, other_rev, other_rev)

            org_changesets = [org_repo.get_changeset(hgrepo[rev].hex()) for rev in org_revs]

        elif alias == 'git':

            if org_repo != other_repo:

                from dulwich.repo import Repo

                from dulwich.client import SubprocessGitClient

                gitrepo = Repo(org_repo.path)

                SubprocessGitClient(thin_packs=False).fetch(safe_str(other_repo.path), gitrepo)

                gitrepo_remote = Repo(other_repo.path)

                SubprocessGitClient(thin_packs=False).fetch(safe_str(org_repo.path), gitrepo_remote)

                revs = []

                for x in gitrepo_remote.get_walker(include=[other_rev],

                                                   exclude=[org_rev]):

                    revs.append(x.commit.id)

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

                if other_changesets:

                    ancestor = other_changesets[0].parents[0].raw_id

                else:

                    # no changesets from other repo, ancestor is the other_rev

                    ancestor = other_rev

                # dulwich 0.9.9 doesn't have a Repo.close() so we have to mess with internals:

                gitrepo.object_store.close()

                gitrepo_remote.object_store.close()

            else:

                so, se = org_repo.run_git_command(

                    ['log', '--reverse', '--pretty=format:%H',

                     '-s', '%s..%s' % (org_rev, other_rev)]

                )

                other_changesets = [org_repo.get_changeset(cs)

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

                so, se = org_repo.run_git_command(

                    ['merge-base', org_rev, other_rev]

                )

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

            org_changesets = []

        else:

            raise Exception('Bad alias only git and hg is allowed')

        return other_changesets, org_changesets, ancestor

    @LoginRequired()

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

                                   'repository.admin')

    def index(self, repo_name):

        c.compare_home = True

        c.a_ref_name = c.cs_ref_name = _('Select changeset')

        return render('compare/compare_diff.html')

    @LoginRequired()

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

                                   'repository.admin')

    def compare(self, repo_name, org_ref_type, org_ref_name, other_ref_type, other_ref_name):

        org_ref_name = org_ref_name.strip()

        other_ref_name = other_ref_name.strip()

        # 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=c.cs_repo.repo_name,

            org_ref_type=other_ref_type, org_ref_name=other_ref_name,

            other_repo=c.a_repo.repo_name,

            other_ref_type=org_ref_type, other_ref_name=org_ref_name,

            merge=merge or '')

        # set callbacks for generating markup for icons

        c.ignorews_url = _ignorews_url

        c.context_url = _context_url

        ignore_whitespace = request.GET.get('ignorews') == '1'

        line_context = safe_int(request.GET.get('context'), 3)

        c.a_rev = self._get_ref_rev(c.a_repo, org_ref_type, org_ref_name,

            returnempty=True)

        c.cs_rev = self._get_ref_rev(c.cs_repo, other_ref_type, other_ref_name)

        c.compare_home = False

        c.a_ref_name = org_ref_name

        c.a_ref_type = org_ref_type

        c.cs_ref_name = other_ref_name

        c.cs_ref_type = other_ref_type

        c.cs_ranges, c.cs_ranges_org, c.ancestor = self._get_changesets(

            c.a_repo.scm_instance.alias, c.a_repo.scm_instance, c.a_rev,

            c.cs_repo.scm_instance, c.cs_rev)

        raw_ids = [x.raw_id for x in c.cs_ranges]

        c.cs_comments = c.cs_repo.get_comments(raw_ids)

        c.statuses = c.cs_repo.statuses(raw_ids)

        revs = [ctx.revision for ctx in reversed(c.cs_ranges)]

        c.jsdata = json.dumps(graph_data(c.cs_repo.scm_instance, revs))

        if partial:

            return render('compare/compare_cs.html')

        org_repo = c.a_repo

        other_repo = c.cs_repo

        if merge and c.ancestor:

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

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

                      c.ancestor, c.a_rev)

            rev1 = c.ancestor

            org_repo = other_repo

        else: # comparing tips, not necessarily linearly related

            if merge:

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

            if org_repo != other_repo:

                # TODO: we could do this by using hg unionrepo

                log.error('cannot compare across repos %s and %s', org_repo, other_repo)

                h.flash(_('Cannot compare repositories without using common ancestor'), category='error')

                raise HTTPBadRequest

            rev1 = c.a_rev

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

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

                  rev1, c.cs_rev, org_repo.scm_instance.path)

        txtdiff = org_repo.scm_instance.get_diff(rev1=rev1, rev2=c.cs_rev,

                                      ignore_whitespace=ignore_whitespace,

                                      context=line_context)

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

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

        return render('compare/compare_diff.html')

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

                                   'repository.admin')

    def archivefile(self, repo_name, fname):

        fileformat = None

        revision = None

        ext = None

        subrepos = request.GET.get('subrepos') == 'true'

        for a_type, ext_data in settings.ARCHIVE_SPECS.items():

            archive_spec = fname.split(ext_data[1])

            if len(archive_spec) == 2 and archive_spec[1] == '':

                fileformat = a_type or ext_data[1]

                revision = archive_spec[0]

                ext = ext_data[1]

        try:

            dbrepo = RepoModel().get_by_repo_name(repo_name)

            if not dbrepo.enable_downloads:

                return _('Downloads disabled') # TODO: do something else?

            if c.db_repo_scm_instance.alias == 'hg':

                # patch and reset hooks section of UI config to not run any

                # hooks on fetching archives with subrepos

                for k, v in c.db_repo_scm_instance._repo.ui.configitems('hooks'):

                    c.db_repo_scm_instance._repo.ui.setconfig('hooks', k, None)

            cs = c.db_repo_scm_instance.get_changeset(revision)

            content_type = settings.ARCHIVE_SPECS[fileformat][0]

        except ChangesetDoesNotExistError:

            return _('Unknown revision %s') % revision

        except EmptyRepositoryError:

            return _('Empty repository')

        except (ImproperArchiveTypeError, KeyError):

            return _('Unknown archive type')

        from kallithea import CONFIG

        rev_name = cs.raw_id[:12]

        archive_name = '%s-%s%s' % (safe_str(repo_name.replace('/', '_')),

                                    safe_str(rev_name), ext)

        archive_path = None

        cached_archive_path = None

        archive_cache_dir = CONFIG.get('archive_cache_dir')

        if archive_cache_dir and not subrepos: # TODO: subrepo caching?

            if not os.path.isdir(archive_cache_dir):

                os.makedirs(archive_cache_dir)

            cached_archive_path = os.path.join(archive_cache_dir, archive_name)

            if os.path.isfile(cached_archive_path):

                log.debug('Found cached archive in %s', cached_archive_path)

                archive_path = cached_archive_path

            else:

                log.debug('Archive %s is not yet cached', archive_name)

        if archive_path is None:

            # generate new archive

            fd, archive_path = tempfile.mkstemp()

            log.debug('Creating new temp archive in %s', archive_path)

            with os.fdopen(fd, 'wb') as stream:

                cs.fill_archive(stream=stream, kind=fileformat, subrepos=subrepos)

                # stream (and thus fd) has been closed by cs.fill_archive

            if cached_archive_path is not None:

                # we generated the archive - move it to cache

                log.debug('Storing new archive in %s', cached_archive_path)

                shutil.move(archive_path, cached_archive_path)

                archive_path = cached_archive_path

        def get_chunked_archive(archive_path):

            stream = open(archive_path, 'rb')

            while True:

                data = stream.read(16 * 1024)

                if not data:

                    break

                yield data

            stream.close()

            if archive_path != cached_archive_path:

                log.debug('Destroying temp archive %s', archive_path)

                os.remove(archive_path)

        action_logger(user=c.authuser,

                      action='user_downloaded_archive:%s' % (archive_name),

                      repo=repo_name, ipaddr=self.ip_addr, commit=True)

        response.content_disposition = str('attachment; filename=%s' % (archive_name))

        response.content_type = str(content_type)

        return get_chunked_archive(archive_path)

    @LoginRequired()

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

                                   'repository.admin')

    def diff(self, repo_name, f_path):

        ignore_whitespace = request.GET.get('ignorews') == '1'

        line_context = safe_int(request.GET.get('context'), 3)

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

        diff1 = request.GET.get('diff1', '') or diff2

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

        c.no_changes = diff1 == diff2

        c.f_path = f_path

        c.big_diff = False

        c.anchor_url = anchor_url

        c.ignorews_url = _ignorews_url

        c.context_url = _context_url

        c.changes = OrderedDict()

        c.changes[diff2] = []

        #special case if we want a show rev only, it's impl here

        #to reduce JS and callbacks

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

            if str2bool(request.GET.get('annotate', 'False')):

                _url = url('files_annotate_home', repo_name=c.repo_name,

                           revision=diff1, f_path=c.f_path)

            else:

                _url = url('files_home', repo_name=c.repo_name,

                           revision=diff1, f_path=c.f_path)

            raise HTTPFound(location=_url)

        try:

            if diff1 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_1 = c.db_repo_scm_instance.get_changeset(diff1)

                try:

                    node1 = c.changeset_1.get_node(f_path)

                    if node1.is_dir():

                        raise NodeError('%s path is a %s not a file'

                                        % (node1, type(node1)))

                except NodeDoesNotExistError:

                    c.changeset_1 = EmptyChangeset(cs=diff1,

                                                   revision=c.changeset_1.revision,

                                                   repo=c.db_repo_scm_instance)

                    node1 = FileNode(f_path, '', changeset=c.changeset_1)

            else:

                c.changeset_1 = EmptyChangeset(repo=c.db_repo_scm_instance)

                node1 = FileNode(f_path, '', changeset=c.changeset_1)

            if diff2 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_2 = c.db_repo_scm_instance.get_changeset(diff2)

                try:

                    node2 = c.changeset_2.get_node(f_path)

                    if node2.is_dir():

                        raise NodeError('%s path is a %s not a file'

                                        % (node2, type(node2)))

                except NodeDoesNotExistError:

                    c.changeset_2 = EmptyChangeset(cs=diff2,

                                                   revision=c.changeset_2.revision,

                                                   repo=c.db_repo_scm_instance)

                    node2 = FileNode(f_path, '', changeset=c.changeset_2)

            else:

                c.changeset_2 = EmptyChangeset(repo=c.db_repo_scm_instance)

                node2 = FileNode(f_path, '', changeset=c.changeset_2)

        except (RepositoryError, NodeError):

            log.error(traceback.format_exc())

            raise HTTPFound(location=url('files_home', repo_name=c.repo_name,

                                f_path=f_path))

        if c.action == 'download':

            _diff = diffs.get_gitdiff(node1, node2,

                                      ignore_whitespace=ignore_whitespace,

                                      context=line_context)

            diff = diffs.DiffProcessor(_diff, format='gitdiff')

            diff_name = '%s_vs_%s.diff' % (diff1, diff2)

            response.content_type = 'text/plain'

            response.content_disposition = (

                'attachment; filename=%s' % diff_name

            )

            return diff.as_raw()

        elif c.action == 'raw':

            _diff = diffs.get_gitdiff(node1, node2,

                                      ignore_whitespace=ignore_whitespace,

                                      context=line_context)

            diff = diffs.DiffProcessor(_diff, format='gitdiff')

            response.content_type = 'text/plain'

            return diff.as_raw()

        else:

            fid = h.FID(diff2, node2.path)

            line_context_lcl = get_line_ctx(fid, request.GET)

            ign_whitespace_lcl = get_ignore_ws(fid, request.GET)

            lim = request.GET.get('fulldiff') or self.cut_off_limit

            cs1, cs2, op, diff, st = diffs.wrapped_diff(filenode_old=node1,

                                         filenode_new=node2,

                                         cut_off_limit=lim,

                                         ignore_whitespace=ign_whitespace_lcl,

                                         line_context=line_context_lcl,

                                         enable_comments=False)

            filename = node1.path

            cs_changes = {

                'fid': [cs1, cs2, op, filename, diff, st]

            }

            c.changes = cs_changes

    @LoginRequired()

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

                                   'repository.admin')

    def diff_2way(self, repo_name, f_path):

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

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

        try:

            if diff1 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_1 = c.db_repo_scm_instance.get_changeset(diff1)

                try:

                    node1 = c.changeset_1.get_node(f_path)

                    if node1.is_dir():

                        raise NodeError('%s path is a %s not a file'

                                        % (node1, type(node1)))

                except NodeDoesNotExistError:

                    c.changeset_1 = EmptyChangeset(cs=diff1,

                                                   revision=c.changeset_1.revision,

                                                   repo=c.db_repo_scm_instance)

                    node1 = FileNode(f_path, '', changeset=c.changeset_1)

            else:

                c.changeset_1 = EmptyChangeset(repo=c.db_repo_scm_instance)

                node1 = FileNode(f_path, '', changeset=c.changeset_1)

            if diff2 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_2 = c.db_repo_scm_instance.get_changeset(diff2)

                try:

                    node2 = c.changeset_2.get_node(f_path)

                    if node2.is_dir():

                        raise NodeError('%s path is a %s not a file'

                                        % (node2, type(node2)))

                except NodeDoesNotExistError:

                    c.changeset_2 = EmptyChangeset(cs=diff2,

                                                   revision=c.changeset_2.revision,

                                                   repo=c.db_repo_scm_instance)

                    node2 = FileNode(f_path, '', changeset=c.changeset_2)

            else:

                c.changeset_2 = EmptyChangeset(repo=c.db_repo_scm_instance)

                node2 = FileNode(f_path, '', changeset=c.changeset_2)

        except ChangesetDoesNotExistError as e:

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

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

            raise HTTPNotFound()

        c.node1 = node1

        c.node2 = node2

        c.cs1 = c.changeset_1

        c.cs2 = c.changeset_2

        return render('files/diff_2way.html')

    def _get_node_history(self, cs, f_path, changesets=None):

        """

        get changesets history for given node

        :param cs: changeset to calculate history

        :param f_path: path for node to calculate history for

        :param changesets: if passed don't calculate history and take

            changesets defined in this list

        """

        # calculate history based on tip

        tip_cs = c.db_repo_scm_instance.get_changeset()

        if changesets is None:

            try:

                changesets = tip_cs.get_file_history(f_path)

            except (NodeDoesNotExistError, ChangesetError):

                #this node is not present at tip !

                changesets = cs.get_file_history(f_path)

        hist_l = []

        changesets_group = ([], _("Changesets"))

        branches_group = ([], _("Branches"))

        tags_group = ([], _("Tags"))

        for chs in changesets:

            #_branch = '(%s)' % chs.branch if (cs.repository.alias == 'hg') else ''

            _branch = chs.branch

            n_desc = '%s (%s)' % (h.show_id(chs), _branch)

            changesets_group[0].append((chs.raw_id, n_desc,))

        hist_l.append(changesets_group)

        for name, chs in c.db_repo_scm_instance.branches.items():

            branches_group[0].append((chs, name),)

        hist_l.append(branches_group)

        for name, chs in c.db_repo_scm_instance.tags.items():

            tags_group[0].append((chs, name),)