Changeset - 54199f3aab93
Parent rev.
Child rev.
[Not reviewed]
default
0 4 0
Mads Kiilerich - 8 years ago 2017-10-03 00:14:40
mads@kiilerich.com
diffs: drop the noop as_raw method - just use the raw diff directly and with proper variable naming
4 files changed with 26 insertions and 37 deletions:
kallithea/controllers/changeset.py
8
9
kallithea/controllers/feed.py
14
15
kallithea/controllers/files.py
4
7
kallithea/lib/diffs.py
6
0 comments (0 inline, 0 general)
kallithea/controllers/changeset.py
➞
Show inline comments
 
@@ -82,380 +82,379 @@ def _ignorews_url(GET, fileid=None):
 
    fileid = str(fileid) if fileid else None
 
    params = defaultdict(list)
 
    _update_with_GET(params, GET)
 
    lbl = _('Show whitespace')
 
    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 whitespace')
 
        ctx_key = 'context'
 
        ctx_val = ln_ctx
 
    # per file options
 
    else:
 
        if ig_ws is None:
 
            params[fileid] += ['WS:1']
 
            lbl = _('Ignore whitespace')
 

			




	
	
	
		
 
        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, **{'data-toggle': '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, **{'data-toggle': '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,

			




	
	
	
		
 
        author=request.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, *args, **kwargs):

			




	
	
	
		
 
        super(ChangesetController, self)._before(*args, **kwargs)

			




	
	
	
		
 
        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 = request.GET.get('fulldiff') # for reporting number of changed files

			




	
	
	
		
 
        # 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.comment_id, st.comment)

			




	
	
	
		
 
                                for st in ChangesetStatusModel()

			




	
	
	
		
 
                                .get_statuses(c.db_repo.repo_id,

			




	
	
	
		
 
                                              changeset.raw_id, with_revisions=True)

			




	
	
	
		
 
                                if st.comment_id is not None)

			




	
	
	
		
 

			




	
	
	
		
 
                inlines = ChangesetCommentsModel() \

			




	
	
	
		
 
                            .get_inline_comments(c.db_repo.repo_id,

			




	
	
	
		
 
                                                 revision=changeset.raw_id)

			




	
	
	
		
 
                c.inline_comments.extend(inlines)

			




	
	
	
		
 

			




	
	
	
		
 
            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,

			




	
	
	
		
 
            raw_diff = c.db_repo_scm_instance.get_diff(cs1, cs2,

			




	
	
	
		
 
                ignore_whitespace=ign_whitespace_lcl, context=context_lcl)

			




	
	
	
		
 
            diff_limit = None if c.fulldiff else self.cut_off_limit

			




	
	
	
		
 
            diff_processor = diffs.DiffProcessor(_diff,

			




	
	
	
		
 
                                                 vcs=c.db_repo_scm_instance.alias,

			




	
	
	
		
 
                                                 diff_limit=diff_limit)

			




	
	
	
		
 
            file_diff_data = []

			




	
	
	
		
 
            if method == 'show':

			




	
	
	
		
 
                diff_processor = diffs.DiffProcessor(raw_diff,

			




	
	
	
		
 
                                                     vcs=c.db_repo_scm_instance.alias,

			




	
	
	
		
 
                                                     diff_limit=diff_limit)

			




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

			




	
	
	
		
 
                    filename = f['filename']

			




	
	
	
		
 
                    fid = h.FID(changeset.raw_id, filename)

			




	
	
	
		
 
                    url_fid = h.FID('', filename)

			




	
	
	
		
 
                    diff = diff_processor.as_html(enable_comments=enable_comments,

			




	
	
	
		
 
                                                  parsed_lines=[f])

			




	
	
	
		
 
                    file_diff_data.append((fid, url_fid, f['operation'], f['old_filename'], filename, diff, st))

			




	
	
	
		
 
            else:

			




	
	
	
		
 
                # downloads/raw we only need RAW diff nothing else

			




	
	
	
		
 
                diff = diff_processor.as_raw()

			




	
	
	
		
 
                file_diff_data.append(('', None, None, None, diff, None))

			




	
	
	
		
 
                file_diff_data.append(('', None, None, None, raw_diff, None))

			




	
	
	
		
 
            c.changes[changeset.raw_id] = (cs1, cs2, file_diff_data)

			




	
	
	
		
 

			




	
	
	
		
 
        # 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

			




	
	
	
		
 
            return raw_diff

			




	
	
	
		
 
        elif method == 'patch':

			




	
	
	
		
 
            response.content_type = 'text/plain'

			




	
	
	
		
 
            c.diff = safe_unicode(diff)

			




	
	
	
		
 
            c.diff = safe_unicode(raw_diff)

			




	
	
	
		
 
            return render('changeset/patch_changeset.html')

			




	
	
	
		
 
        elif method == 'raw':

			




	
	
	
		
 
            response.content_type = 'text/plain'

			




	
	
	
		
 
            return diff

			




	
	
	
		
 
            return raw_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 = graph_data(c.db_repo_scm_instance, revs)

			




	
	
	
		
 
                return render('changeset/changeset_range.html')

			




	
	
	
		
 

			




	
	
	
		
 
    @LoginRequired()

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




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

			




	
	
	
		
 
        return self._index(revision, method=method)

			




	
	
	
		
 

			




	
	
	
		
 
    @LoginRequired()

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




	
	
	
		
 
    def changeset_raw(self, revision):

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    @LoginRequired()

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




	
	
	
		
 
    def changeset_patch(self, revision):

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    @LoginRequired()

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




	
	
	
		
 
    def changeset_download(self, revision):

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    @LoginRequired()

			




	
	
	
		
 
    @NotAnonymous()

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




	
	
	
		
 
    @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,

			




	
	
	
		
 
                    request.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(request.authuser,

			




	
	
	
		
 
                      'user_commented_revision:%s' % revision,

			




	
	
	
		
 
                      c.db_repo, request.ip_addr)

			




	
	
	
		
 

			




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

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




	
	
	
		
 
    @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_id == request.authuser.user_id

			




	
	
	
		
 
        repo_admin = h.HasRepoPermissionLevel('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()

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




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

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




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

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




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

			




        

    


    
    

    

        

                

                    kallithea/controllers/feed.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



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

			




	
	
	
		
 
# 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/>.

			




	
	
	
		
 
"""

			




	
	
	
		
 
kallithea.controllers.feed

			




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

			




	
	
	
		
 

			




	
	
	
		
 
Feed controller for Kallithea

			




	
	
	
		
 

			




	
	
	
		
 
This file was forked by the Kallithea project in July 2014.

			




	
	
	
		
 
Original author and date, and relevant copyright and licensing information is below:

			




	
	
	
		
 
:created_on: Apr 23, 2010

			




	
	
	
		
 
:author: marcink

			




	
	
	
		
 
:copyright: (c) 2013 RhodeCode GmbH, and others.

			




	
	
	
		
 
:license: GPLv3, see LICENSE.md for more details.

			




	
	
	
		
 
"""

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
import logging

			




	
	
	
		
 

			




	
	
	
		
 
from tg import response, tmpl_context as c

			




	
	
	
		
 
from tg.i18n import ugettext as _

			




	
	
	
		
 

			




	
	
	
		
 
from beaker.cache import cache_region, region_invalidate

			




	
	
	
		
 
from webhelpers.feedgenerator import Atom1Feed, Rss201rev2Feed

			




	
	
	
		
 

			




	
	
	
		
 
from kallithea import CONFIG

			




	
	
	
		
 
from kallithea.lib import helpers as h

			




	
	
	
		
 
from kallithea.lib.auth import LoginRequired, HasRepoPermissionLevelDecorator

			




	
	
	
		
 
from kallithea.lib.base import BaseRepoController

			




	
	
	
		
 
from kallithea.lib.diffs import DiffProcessor, LimitedDiffContainer

			




	
	
	
		
 
from kallithea.model.db import CacheInvalidation

			




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

			




	
	
	
		
 

			




	
	
	
		
 
log = logging.getLogger(__name__)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
language = 'en-us'

			




	
	
	
		
 
ttl = "5"

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class FeedController(BaseRepoController):

			




	
	
	
		
 

			




	
	
	
		
 
    @LoginRequired(api_access=True)

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




	
	
	
		
 
    def _before(self, *args, **kwargs):

			




	
	
	
		
 
        super(FeedController, self)._before(*args, **kwargs)

			




	
	
	
		
 

			




	
	
	
		
 
    def _get_title(self, cs):

			




	
	
	
		
 
        return h.shorter(cs.message, 160)

			




	
	
	
		
 

			




	
	
	
		
 
    def __changes(self, cs):

			




	
	
	
		
 
    def __get_desc(self, cs):

			




	
	
	
		
 
        desc_msg = [(_('%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)

			




	
	
	
		
 
        for book in cs.bookmarks:

			




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

			




	
	
	
		
 
        for tag in cs.tags:

			




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

			




	
	
	
		
 

			




	
	
	
		
 
        changes = []

			




	
	
	
		
 
        diff_limit = safe_int(CONFIG.get('rss_cut_off_limit', 32 * 1024))

			




	
	
	
		
 
        diff_processor = DiffProcessor(cs.diff(),

			




	
	
	
		
 
        raw_diff = cs.diff()

			




	
	
	
		
 
        diff_processor = DiffProcessor(raw_diff,

			




	
	
	
		
 
                                       diff_limit=diff_limit)

			




	
	
	
		
 
        _parsed = diff_processor.prepare(inline_diff=False)

			




	
	
	
		
 
        limited_diff = False

			




	
	
	
		
 
        if isinstance(_parsed, LimitedDiffContainer):

			




	
	
	
		
 
            limited_diff = True

			




	
	
	
		
 

			




	
	
	
		
 
        for st in _parsed:

			




	
	
	
		
 
            st.update({'added': st['stats']['added'],

			




	
	
	
		
 
                       'removed': st['stats']['deleted']})

			




	
	
	
		
 
            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 = [(_('%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)

			




	
	
	
		
 
        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 = h.canonical_url('changeset_home', repo_name=c.db_repo.repo_name,

			




	
	
	
		
 
                   revision=cs.raw_id)

			




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

			




	
	
	
		
 

			




	
	
	
		
 
        desc_msg.append('<pre>')

			




	
	
	
		
 
        desc_msg.append(h.urlify_text(cs.message))

			




	
	
	
		
 
        desc_msg.append('\n')

			




	
	
	
		
 
        desc_msg.extend(changes)

			




	
	
	
		
 
        if str2bool(CONFIG.get('rss_include_diff', False)):

			




	
	
	
		
 
            desc_msg.append('\n\n')

			




	
	
	
		
 
            desc_msg.append(diff_processor.as_raw())

			




	
	
	
		
 
            desc_msg.append(raw_diff)

			




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

			




	
	
	
		
 
        def _get_feed_from_cache(key, kind):

			




	
	
	
		
 
            feed = Atom1Feed(

			




	
	
	
		
 
                title=_('%s %s feed') % (c.site_name, repo_name),

			




	
	
	
		
 
                link=h.canonical_url('summary_home', repo_name=repo_name),

			




	
	
	
		
 
                description=_('Changes on %s repository') % repo_name,

			




	
	
	
		
 
                language=language,

			




	
	
	
		
 
                ttl=ttl

			




	
	
	
		
 
            )

			




	
	
	
		
 

			




	
	
	
		
 
            rss_items_per_page = safe_int(CONFIG.get('rss_items_per_page', 20))

			




	
	
	
		
 
            for cs in reversed(list(c.db_repo_scm_instance[-rss_items_per_page:])):

			




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

			




	
	
	
		
 
                              link=h.canonical_url('changeset_home', repo_name=repo_name,

			




	
	
	
		
 
                                       revision=cs.raw_id),

			




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

			




	
	
	
		
 
        def _get_feed_from_cache(key, kind):

			




	
	
	
		
 
            feed = Rss201rev2Feed(

			




	
	
	
		
 
                title=_('%s %s feed') % (c.site_name, repo_name),

			




	
	
	
		
 
                link=h.canonical_url('summary_home', repo_name=repo_name),

			




	
	
	
		
 
                description=_('Changes on %s repository') % repo_name,

			




	
	
	
		
 
                language=language,

			




	
	
	
		
 
                ttl=ttl

			




	
	
	
		
 
            )

			




	
	
	
		
 

			




	
	
	
		
 
            rss_items_per_page = safe_int(CONFIG.get('rss_items_per_page', 20))

			




	
	
	
		
 
            for cs in reversed(list(c.db_repo_scm_instance[-rss_items_per_page:])):

			




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

			




	
	
	
		
 
                              link=h.canonical_url('changeset_home', repo_name=repo_name,

			




	
	
	
		
 
                                       revision=cs.raw_id),

			




	
	
	
		
 
                              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, '_get_feed_from_cache', repo_name, kind)

			




	
	
	
		
 
        return _get_feed_from_cache(repo_name, kind)

			




        

    


    
    

    

        

                

                    kallithea/controllers/files.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -462,324 +462,321 @@ class FilesController(BaseRepoController

			




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

			




	
	
	
		
 
                                    revision='tip'))

			




	
	
	
		
 
            # strip all crap out of file, just leave the basename

			




	
	
	
		
 
            filename = os.path.basename(filename)

			




	
	
	
		
 
            node_path = posixpath.join(location, filename)

			




	
	
	
		
 
            author = request.authuser.full_contact

			




	
	
	
		
 

			




	
	
	
		
 
            try:

			




	
	
	
		
 
                nodes = {

			




	
	
	
		
 
                    node_path: {

			




	
	
	
		
 
                        'content': content

			




	
	
	
		
 
                    }

			




	
	
	
		
 
                }

			




	
	
	
		
 
                self.scm_model.create_nodes(

			




	
	
	
		
 
                    user=request.authuser.user_id, repo=c.db_repo,

			




	
	
	
		
 
                    message=message,

			




	
	
	
		
 
                    nodes=nodes,

			




	
	
	
		
 
                    parent_cs=c.cs,

			




	
	
	
		
 
                    author=author,

			




	
	
	
		
 
                )

			




	
	
	
		
 

			




	
	
	
		
 
                h.flash(_('Successfully committed to %s') % node_path,

			




	
	
	
		
 
                        category='success')

			




	
	
	
		
 
            except NonRelativePathError as e:

			




	
	
	
		
 
                h.flash(_('Location must be relative path and must not '

			




	
	
	
		
 
                          'contain .. in path'), category='warning')

			




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

			




	
	
	
		
 
                                    revision='tip'))

			




	
	
	
		
 
            except (NodeError, NodeAlreadyExistsError) as e:

			




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

			




	
	
	
		
 
            except Exception:

			




	
	
	
		
 
                log.error(traceback.format_exc())

			




	
	
	
		
 
                h.flash(_('Error occurred during commit'), category='error')

			




	
	
	
		
 
            raise HTTPFound(location=url('changeset_home',

			




	
	
	
		
 
                                repo_name=c.repo_name, revision='tip'))

			




	
	
	
		
 

			




	
	
	
		
 
        return render('files/files_add.html')

			




	
	
	
		
 

			




	
	
	
		
 
    @LoginRequired()

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




	
	
	
		
 
    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=request.authuser,

			




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

			




	
	
	
		
 
                      repo=repo_name, ipaddr=request.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()

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




	
	
	
		
 
    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

			




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

			




	
	
	
		
 
        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,

			




	
	
	
		
 
            raw_diff = diffs.get_gitdiff(node1, node2,

			




	
	
	
		
 
                                      ignore_whitespace=ignore_whitespace,

			




	
	
	
		
 
                                      context=line_context)

			




	
	
	
		
 
            diff = diffs.DiffProcessor(_diff)

			




	
	
	
		
 

			




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

			




	
	
	
		
 
            return raw_diff

			




	
	
	
		
 

			




	
	
	
		
 
        elif c.action == 'raw':

			




	
	
	
		
 
            _diff = diffs.get_gitdiff(node1, node2,

			




	
	
	
		
 
            raw_diff = diffs.get_gitdiff(node1, node2,

			




	
	
	
		
 
                                      ignore_whitespace=ignore_whitespace,

			




	
	
	
		
 
                                      context=line_context)

			




	
	
	
		
 
            diff = diffs.DiffProcessor(_diff)

			




	
	
	
		
 
            response.content_type = 'text/plain'

			




	
	
	
		
 
            return diff.as_raw()

			




	
	
	
		
 
            return raw_diff

			




	
	
	
		
 

			




	
	
	
		
 
        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)

			




	
	
	
		
 

			




	
	
	
		
 
            diff_limit = None if fulldiff else self.cut_off_limit

			




	
	
	
		
 
            c.a_rev, c.cs_rev, a_path, diff, st, op = diffs.wrapped_diff(filenode_old=node1,

			




	
	
	
		
 
                                         filenode_new=node2,

			




	
	
	
		
 
                                         diff_limit=diff_limit,

			




	
	
	
		
 
                                         ignore_whitespace=ign_whitespace_lcl,

			




	
	
	
		
 
                                         line_context=line_context_lcl,

			




	
	
	
		
 
                                         enable_comments=False)

			




	
	
	
		
 
            c.file_diff_data = [(fid, fid, op, a_path, node2.path, diff, st)]

			




	
	
	
		
 

			




	
	
	
		
 
            return render('files/file_diff.html')

			




	
	
	
		
 

			




	
	
	
		
 
    @LoginRequired()

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




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

			




	
	
	
		
 
        hist_l.append(tags_group)

			




	
	
	
		
 

			




	
	
	
		
 
        return hist_l, changesets

			




	
	
	
		
 

			




	
	
	
		
 
    @LoginRequired()

			




	
	
	
		
 
    @HasRepoPermissionLevelDecorator('read')

			




	
	
	
		
 
    @jsonify

			




	
	
	
		
 
    def nodelist(self, repo_name, revision, f_path):

			




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

			




	
	
	
		
 
            cs = self.__get_cs(revision)

			




	
	
	
		
 
            _d, _f = ScmModel().get_nodes(repo_name, cs.raw_id, f_path,

			




	
	
	
		
 
                                          flat=False)

			




	
	
	
		
 
            return {'nodes': _d + _f}

			




        

    


    
    

    

        

                

                    kallithea/lib/diffs.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -403,311 +403,305 @@ class DiffProcessor(object):

			




	
	
	
		
 
                # Git binary patch

			




	
	
	
		
 
                if head['bin_patch']:

			




	
	
	
		
 
                    stats['ops'][BIN_FILENODE] = 'binary diff not shown'

			




	
	
	
		
 
                chunks = []

			




	
	
	
		
 

			




	
	
	
		
 
            if op == 'D' and chunks:

			




	
	
	
		
 
                # a way of seeing deleted content could perhaps be nice - but

			




	
	
	
		
 
                # not with the current UI

			




	
	
	
		
 
                chunks = []

			




	
	
	
		
 

			




	
	
	
		
 
            chunks.insert(0, [{

			




	
	
	
		
 
                'old_lineno': '',

			




	
	
	
		
 
                'new_lineno': '',

			




	
	
	
		
 
                'action':     'context',

			




	
	
	
		
 
                'line':       msg,

			




	
	
	
		
 
                } for _op, msg in stats['ops'].iteritems()

			




	
	
	
		
 
                  if _op not in [MOD_FILENODE]])

			




	
	
	
		
 

			




	
	
	
		
 
            _files.append({

			




	
	
	
		
 
                'old_filename':     head['a_path'],

			




	
	
	
		
 
                'filename':         head['b_path'],

			




	
	
	
		
 
                'old_revision':     head['a_blob_id'],

			




	
	
	
		
 
                'new_revision':     head['b_blob_id'],

			




	
	
	
		
 
                'chunks':           chunks,

			




	
	
	
		
 
                'operation':        op,

			




	
	
	
		
 
                'stats':            stats,

			




	
	
	
		
 
            })

			




	
	
	
		
 

			




	
	
	
		
 
        if not inline_diff:

			




	
	
	
		
 
            return diff_container(_files)

			




	
	
	
		
 

			




	
	
	
		
 
        # highlight inline changes when one del is followed by one add

			




	
	
	
		
 
        for diff_data in _files:

			




	
	
	
		
 
            for chunk in diff_data['chunks']:

			




	
	
	
		
 
                lineiter = iter(chunk)

			




	
	
	
		
 
                try:

			




	
	
	
		
 
                    peekline = lineiter.next()

			




	
	
	
		
 
                    while True:

			




	
	
	
		
 
                        # find a first del line

			




	
	
	
		
 
                        while peekline['action'] != 'del':

			




	
	
	
		
 
                            peekline = lineiter.next()

			




	
	
	
		
 
                        delline = peekline

			




	
	
	
		
 
                        peekline = lineiter.next()

			




	
	
	
		
 
                        # if not followed by add, eat all following del lines

			




	
	
	
		
 
                        if peekline['action'] != 'add':

			




	
	
	
		
 
                            while peekline['action'] == 'del':

			




	
	
	
		
 
                                peekline = lineiter.next()

			




	
	
	
		
 
                            continue

			




	
	
	
		
 
                        # found an add - make sure it is the only one

			




	
	
	
		
 
                        addline = peekline

			




	
	
	
		
 
                        try:

			




	
	
	
		
 
                            peekline = lineiter.next()

			




	
	
	
		
 
                        except StopIteration:

			




	
	
	
		
 
                            # add was last line - ok

			




	
	
	
		
 
                            self._highlight_inline_diff(delline, addline)

			




	
	
	
		
 
                            raise

			




	
	
	
		
 
                        if peekline['action'] != 'add':

			




	
	
	
		
 
                            # there was only one add line - ok

			




	
	
	
		
 
                            self._highlight_inline_diff(delline, addline)

			




	
	
	
		
 
                except StopIteration:

			




	
	
	
		
 
                    pass

			




	
	
	
		
 

			




	
	
	
		
 
        return diff_container(_files)

			




	
	
	
		
 

			




	
	
	
		
 
    def _parse_lines(self, diff):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Given an iterator of diff body lines, parse them and return a dict per

			




	
	
	
		
 
        line and added/removed totals.

			




	
	
	
		
 
        """

			




	
	
	
		
 
        added = deleted = 0

			




	
	
	
		
 
        old_line = old_end = new_line = new_end = None

			




	
	
	
		
 

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            chunks = []

			




	
	
	
		
 
            line = diff.next()

			




	
	
	
		
 

			




	
	
	
		
 
            while True:

			




	
	
	
		
 
                lines = []

			




	
	
	
		
 
                chunks.append(lines)

			




	
	
	
		
 

			




	
	
	
		
 
                match = self._chunk_re.match(line)

			




	
	
	
		
 

			




	
	
	
		
 
                if not match:

			




	
	
	
		
 
                    raise Exception('error parsing diff @@ line %r' % line)

			




	
	
	
		
 

			




	
	
	
		
 
                gr = match.groups()

			




	
	
	
		
 
                (old_line, old_end,

			




	
	
	
		
 
                 new_line, new_end) = [int(x or 1) for x in gr[:-1]]

			




	
	
	
		
 
                old_line -= 1

			




	
	
	
		
 
                new_line -= 1

			




	
	
	
		
 

			




	
	
	
		
 
                context = len(gr) == 5

			




	
	
	
		
 
                old_end += old_line

			




	
	
	
		
 
                new_end += new_line

			




	
	
	
		
 

			




	
	
	
		
 
                if context:

			




	
	
	
		
 
                    # skip context only if it's first line

			




	
	
	
		
 
                    if int(gr[0]) > 1:

			




	
	
	
		
 
                        lines.append({

			




	
	
	
		
 
                            'old_lineno': '...',

			




	
	
	
		
 
                            'new_lineno': '...',

			




	
	
	
		
 
                            'action':     'context',

			




	
	
	
		
 
                            'line':       line,

			




	
	
	
		
 
                        })

			




	
	
	
		
 

			




	
	
	
		
 
                line = diff.next()

			




	
	
	
		
 

			




	
	
	
		
 
                while old_line < old_end or new_line < new_end:

			




	
	
	
		
 
                    if not line:

			




	
	
	
		
 
                        raise Exception('error parsing diff - empty line at -%s+%s' % (old_line, new_line))

			




	
	
	
		
 

			




	
	
	
		
 
                    affects_old = affects_new = False

			




	
	
	
		
 

			




	
	
	
		
 
                    command = line[0]

			




	
	
	
		
 
                    if command == '+':

			




	
	
	
		
 
                        affects_new = True

			




	
	
	
		
 
                        action = 'add'

			




	
	
	
		
 
                        added += 1

			




	
	
	
		
 
                    elif command == '-':

			




	
	
	
		
 
                        affects_old = True

			




	
	
	
		
 
                        action = 'del'

			




	
	
	
		
 
                        deleted += 1

			




	
	
	
		
 
                    elif command == ' ':

			




	
	
	
		
 
                        affects_old = affects_new = True

			




	
	
	
		
 
                        action = 'unmod'

			




	
	
	
		
 
                    else:

			




	
	
	
		
 
                        raise Exception('error parsing diff - unknown command in line %r at -%s+%s' % (line, old_line, new_line))

			




	
	
	
		
 

			




	
	
	
		
 
                    if not self._newline_marker.match(line):

			




	
	
	
		
 
                        old_line += affects_old

			




	
	
	
		
 
                        new_line += affects_new

			




	
	
	
		
 
                        lines.append({

			




	
	
	
		
 
                            'old_lineno':   affects_old and old_line or '',

			




	
	
	
		
 
                            'new_lineno':   affects_new and new_line or '',

			




	
	
	
		
 
                            'action':       action,

			




	
	
	
		
 
                            'line':         self._clean_line(line, command)

			




	
	
	
		
 
                        })

			




	
	
	
		
 

			




	
	
	
		
 
                    line = diff.next()

			




	
	
	
		
 

			




	
	
	
		
 
                    if self._newline_marker.match(line):

			




	
	
	
		
 
                        # we need to append to lines, since this is not

			




	
	
	
		
 
                        # counted in the line specs of diff

			




	
	
	
		
 
                        lines.append({

			




	
	
	
		
 
                            'old_lineno':   '...',

			




	
	
	
		
 
                            'new_lineno':   '...',

			




	
	
	
		
 
                            'action':       'context',

			




	
	
	
		
 
                            'line':         self._clean_line(line, command)

			




	
	
	
		
 
                        })

			




	
	
	
		
 
                        line = diff.next()

			




	
	
	
		
 
                if old_line > old_end:

			




	
	
	
		
 
                    raise Exception('error parsing diff - more than %s "-" lines at -%s+%s' % (old_end, old_line, new_line))

			




	
	
	
		
 
                if new_line > new_end:

			




	
	
	
		
 
                    raise Exception('error parsing diff - more than %s "+" lines at -%s+%s' % (new_end, old_line, new_line))

			




	
	
	
		
 
        except StopIteration:

			




	
	
	
		
 
            pass

			




	
	
	
		
 
        if old_line != old_end or new_line != new_end:

			




	
	
	
		
 
            raise Exception('diff processing broken when old %s<>%s or new %s<>%s line %r' % (old_line, old_end, new_line, new_end, line))

			




	
	
	
		
 

			




	
	
	
		
 
        return chunks, added, deleted

			




	
	
	
		
 

			




	
	
	
		
 
    def _safe_id(self, idstring):

			




	
	
	
		
 
        """Make a string safe for including in an id attribute.

			




	
	
	
		
 

			




	
	
	
		
 
        The HTML spec says that id attributes 'must begin with

			




	
	
	
		
 
        a letter ([A-Za-z]) and may be followed by any number

			




	
	
	
		
 
        of letters, digits ([0-9]), hyphens ("-"), underscores

			




	
	
	
		
 
        ("_"), colons (":"), and periods (".")'. These regexps

			




	
	
	
		
 
        are slightly over-zealous, in that they remove colons

			




	
	
	
		
 
        and periods unnecessarily.

			




	
	
	
		
 

			




	
	
	
		
 
        Whitespace is transformed into underscores, and then

			




	
	
	
		
 
        anything which is not a hyphen or a character that

			




	
	
	
		
 
        matches \w (alphanumerics and underscore) is removed.

			




	
	
	
		
 

			




	
	
	
		
 
        """

			




	
	
	
		
 
        # Transform all whitespace to underscore

			




	
	
	
		
 
        idstring = re.sub(r'\s', "_", idstring)

			




	
	
	
		
 
        # Remove everything that is not a hyphen or a member of \w

			




	
	
	
		
 
        idstring = re.sub(r'(?!-)\W', "", idstring).lower()

			




	
	
	
		
 
        return idstring

			




	
	
	
		
 

			




	
	
	
		
 
    def prepare(self, inline_diff=True):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Prepare the passed udiff for HTML rendering. It'll return a list

			




	
	
	
		
 
        of dicts with diff information

			




	
	
	
		
 
        """

			




	
	
	
		
 
        parsed = self._parse_gitdiff(inline_diff=inline_diff)

			




	
	
	
		
 
        self.parsed = True

			




	
	
	
		
 
        self.parsed_diff = parsed

			




	
	
	
		
 
        return parsed

			




	
	
	
		
 

			




	
	
	
		
 
    def as_raw(self):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Returns raw string diff, exactly as it was passed in the first place.

			




	
	
	
		
 
        """

			




	
	
	
		
 
        return self._diff

			




	
	
	
		
 

			




	
	
	
		
 
    def as_html(self, table_class='code-difftable', line_class='line',

			




	
	
	
		
 
                old_lineno_class='lineno old', new_lineno_class='lineno new',

			




	
	
	
		
 
                no_lineno_class='lineno',

			




	
	
	
		
 
                code_class='code', enable_comments=False, parsed_lines=None):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Return given diff as html table with customized css classes

			




	
	
	
		
 
        """

			




	
	
	
		
 
        def _link_to_if(condition, label, url):

			




	
	
	
		
 
            """

			




	
	
	
		
 
            Generates a link if condition is meet or just the label if not.

			




	
	
	
		
 
            """

			




	
	
	
		
 

			




	
	
	
		
 
            if condition:

			




	
	
	
		
 
                return '''<a href="%(url)s">%(label)s</a>''' % {

			




	
	
	
		
 
                    'url': url,

			




	
	
	
		
 
                    'label': label

			




	
	
	
		
 
                }

			




	
	
	
		
 
            else:

			




	
	
	
		
 
                return label

			




	
	
	
		
 
        if not self.parsed:

			




	
	
	
		
 
            self.prepare()

			




	
	
	
		
 

			




	
	
	
		
 
        diff_lines = self.parsed_diff

			




	
	
	
		
 
        if parsed_lines:

			




	
	
	
		
 
            diff_lines = parsed_lines

			




	
	
	
		
 

			




	
	
	
		
 
        _html_empty = True

			




	
	
	
		
 
        _html = []

			




	
	
	
		
 
        _html.append('''<table class="%(table_class)s">\n''' % {

			




	
	
	
		
 
            'table_class': table_class

			




	
	
	
		
 
        })

			




	
	
	
		
 

			




	
	
	
		
 
        for diff in diff_lines:

			




	
	
	
		
 
            for line in diff['chunks']:

			




	
	
	
		
 
                _html_empty = False

			




	
	
	
		
 
                for change in line:

			




	
	
	
		
 
                    _html.append('''<tr class="%(lc)s %(action)s">\n''' % {

			




	
	
	
		
 
                        'lc': line_class,

			




	
	
	
		
 
                        'action': change['action']

			




	
	
	
		
 
                    })

			




	
	
	
		
 
                    anchor_old_id = ''

			




	
	
	
		
 
                    anchor_new_id = ''

			




	
	
	
		
 
                    anchor_old = "%(filename)s_o%(oldline_no)s" % {

			




	
	
	
		
 
                        'filename': self._safe_id(diff['filename']),

			




	
	
	
		
 
                        'oldline_no': change['old_lineno']

			




	
	
	
		
 
                    }

			




	
	
	
		
 
                    anchor_new = "%(filename)s_n%(oldline_no)s" % {

			




	
	
	
		
 
                        'filename': self._safe_id(diff['filename']),

			




	
	
	
		
 
                        'oldline_no': change['new_lineno']

			




	
	
	
		
 
                    }

			




	
	
	
		
 
                    cond_old = (change['old_lineno'] != '...' and

			




	
	
	
		
 
                                change['old_lineno'])

			




	
	
	
		
 
                    cond_new = (change['new_lineno'] != '...' and

			




	
	
	
		
 
                                change['new_lineno'])

			




	
	
	
		
 
                    no_lineno = (change['old_lineno'] == '...' and

			




	
	
	
		
 
                                 change['new_lineno'] == '...')

			




	
	
	
		
 
                    if cond_old:

			




	
	
	
		
 
                        anchor_old_id = 'id="%s"' % anchor_old

			




	
	
	
		
 
                    if cond_new:

			




	
	
	
		
 
                        anchor_new_id = 'id="%s"' % anchor_new

			




	
	
	
		
 
                    ###########################################################

			




	
	
	
		
 
                    # OLD LINE NUMBER

			




	
	
	
		
 
                    ###########################################################

			




	
	
	
		
 
                    _html.append('''\t<td %(a_id)s class="%(olc)s" %(colspan)s>''' % {

			




	
	
	
		
 
                        'a_id': anchor_old_id,

			




	
	
	
		
 
                        'olc': no_lineno_class if no_lineno else old_lineno_class,

			




	
	
	
		
 
                        'colspan': 'colspan="2"' if no_lineno else ''

			




	
	
	
		
 
                    })

			




	
	
	
		
 

			




	
	
	
		
 
                    _html.append('''%(link)s''' % {

			




	
	
	
		
 
                        'link': _link_to_if(not no_lineno, change['old_lineno'],

			




	
	
	
		
 
                                            '#%s' % anchor_old)

			




	
	
	
		
 
                    })

			




	
	
	
		
 
                    _html.append('''</td>\n''')

			




	
	
	
		
 
                    ###########################################################

			




	
	
	
		
 
                    # NEW LINE NUMBER

			




	
	
	
		
 
                    ###########################################################

			




	
	
	
		
 

			




	
	
	
		
 
                    if not no_lineno:

			




	
	
	
		
 
                        _html.append('''\t<td %(a_id)s class="%(nlc)s">''' % {

			




	
	
	
		
 
                            'a_id': anchor_new_id,

			




	
	
	
		
 
                            'nlc': new_lineno_class

			




	
	
	
		
 
                        })

			




	
	
	
		
 

			




	
	
	
		
 
                        _html.append('''%(link)s''' % {

			




	
	
	
		
 
                            'link': _link_to_if(True, change['new_lineno'],

			




	
	
	
		
 
                                                '#%s' % anchor_new)

			




	
	
	
		
 
                        })

			




	
	
	
		
 
                        _html.append('''</td>\n''')

			




	
	
	
		
 
                    ###########################################################

			




	
	
	
		
 
                    # CODE

			




	
	
	
		
 
                    ###########################################################

			




	
	
	
		
 
                    comments = '' if enable_comments else 'no-comment'

			




	
	
	
		
 
                    _html.append('''\t<td class="%(cc)s %(inc)s">''' % {

			




	
	
	
		
 
                        'cc': code_class,

			




	
	
	
		
 
                        'inc': comments

			




	
	
	
		
 
                    })

			




	
	
	
		
 
                    _html.append('''\n\t\t<div class="add-bubble"><div>&nbsp;</div></div><pre>%(code)s</pre>\n''' % {

			




	
	
	
		
 
                        'code': change['line']

			




	
	
	
		
 
                    })

			




	
	
	
		
 

			




	
	
	
		
 
                    _html.append('''\t</td>''')

			




	
	
	
		
 
                    _html.append('''\n</tr>\n''')

			




	
	
	
		
 
        _html.append('''</table>''')

			




	
	
	
		
 
        if _html_empty:

			




	
	
	
		
 
            return None

			




	
	
	
		
 
        return ''.join(_html)

			




	
	
	
		
 

			




	
	
	
		
 
    def stat(self):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Returns tuple of added, and removed lines for this instance

			




	
	
	
		
 
        """

			




	
	
	
		
 
        return self.adds, self.removes

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        
    
    
        This site is powered by
            Kallithea 0.7.0,
        which is
        © 2010–2025 by various authors & licensed under GPLv3.