self['renderers'] = []

        # Enable json in expose

        self['renderers'].append('json')

        # Configure template rendering

        self['renderers'].append('mako')

        self['default_renderer'] = 'mako'

        self['use_dotted_templatenames'] = False

        # Configure Sessions, store data as JSON to avoid pickle security issues

        self['session.enabled'] = True

        self['session.data_serializer'] = 'json'

        # Configure the base SQLALchemy Setup

        self['use_sqlalchemy'] = True

        self['model'] = kallithea.model.base

        self['DBSession'] = kallithea.model.meta.Session

        # Configure App without an authentication backend.

        self['auth_backend'] = None

        # Use custom error page for these errors. By default, Turbogears2 does not add

        # 400 in this list.

        # Explicitly listing all is considered more robust than appending to defaults,

        # in light of possible future framework changes.

        self['errorpage.status_codes'] = [400, 401, 403, 404]

        # Disable transaction manager -- currently Kallithea takes care of transactions itself

        self['tm.enabled'] = False

base_config = KallitheaAppConfig()

# TODO still needed as long as we use pylonslib

sys.modules['pylons'] = tg

# DebugBar, a debug toolbar for TurboGears2.

# (https://github.com/TurboGears/tgext.debugbar)

# To enable it, install 'tgext.debugbar' and 'kajiki', and run Kallithea with

# 'debug = true' (not in production!)

# See the Kallithea documentation for more information.

try:

    from tgext.debugbar import enable_debugbar

    import kajiki # only to check its existence

except ImportError:

    pass

else:

    base_config['renderers'].append('kajiki')

    enable_debugbar(base_config)

def setup_configuration(app):

    config = app.config

    if not kallithea.lib.locale.current_locale_is_valid():

        log.error("Terminating ...")

        sys.exit(1)

    # Mercurial sets encoding at module import time, so we have to monkey patch it

    hgencoding = config.get('hgencoding')

    if hgencoding:

        mercurial.encoding.encoding = hgencoding

    if config.get('ignore_alembic_revision', False):

        log.warn('database alembic revision checking is disabled')

    else:

        dbconf = config['sqlalchemy.url']

        alembic_cfg = alembic.config.Config()

        alembic_cfg.set_main_option('script_location', 'kallithea:alembic')

        alembic_cfg.set_main_option('sqlalchemy.url', dbconf)

        script_dir = ScriptDirectory.from_config(alembic_cfg)

        available_heads = sorted(script_dir.get_heads())

        engine = create_engine(dbconf)

        with engine.connect() as conn:

            context = MigrationContext.configure(conn)

            current_heads = sorted(str(s) for s in context.get_current_heads())

        if current_heads != available_heads:

            log.error('Failed to run Kallithea:\n\n'

                      'The database version does not match the Kallithea version.\n'

                      'Please read the documentation on how to upgrade or downgrade the database.\n'

                      'Current database version id(s): %s\n'

                      'Expected database version id(s): %s\n'

                      'If you are a developer and you know what you are doing, you can add `ignore_alembic_revision = True` '

                      'to your .ini file to skip the check.\n' % (' '.join(current_heads), ' '.join(available_heads)))

            sys.exit(1)

    # store some globals into kallithea

    kallithea.CELERY_ON = str2bool(config.get('use_celery'))

    kallithea.CELERY_EAGER = str2bool(config.get('celery.always.eager'))

    kallithea.CONFIG = config

    load_rcextensions(root_path=config['here'])

    config['base_path'] = repos_path

    set_app_settings(config)

    instance_id = kallithea.CONFIG.get('instance_id', '*')

    if instance_id == '*':

        instance_id = '%s-%s' % (platform.uname()[1], os.getpid())

        kallithea.CONFIG['instance_id'] = instance_id

    # update kallithea.CONFIG with the meanwhile changed 'config'

    kallithea.CONFIG.update(config)

    # configure vcs and indexer libraries (they are supposed to be independent

    # as much as possible and thus avoid importing tg.config or

    # kallithea.CONFIG).

    set_vcs_config(kallithea.CONFIG)

    set_indexer_config(kallithea.CONFIG)

    check_git_version()

    kallithea.model.meta.Session.remove()

hooks.register('configure_new_app', setup_configuration)

def setup_application(app):

    config = app.config

    # we want our low level middleware to get to the request ASAP. We don't

    # need any stack middleware in them - especially no StatusCodeRedirect buffering

    app = SimpleHg(app, config)

    app = SimpleGit(app, config)

    # Enable https redirects based on HTTP_X_URL_SCHEME set by proxy

    if any(asbool(config.get(x)) for x in ['https_fixup', 'force_https', 'use_htsts']):

        app = HttpsFixup(app, config)

    app = PermanentRepoUrl(app, config)

    # Optional and undocumented wrapper - gives more verbose request/response logging, but has a slight overhead

    if str2bool(config.get('use_wsgi_wrapper')):

        app = RequestWrapper(app, config)

    return app

hooks.register('before_config', setup_application)

kallithea.controllers.compare

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

compare controller showing differences between two

repos, branches, bookmarks or tips

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: May 6, 2012

:author: marcink

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

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

"""

import logging

import re

from tg import request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest, HTTPFound, HTTPNotFound

from kallithea.config.routing import url

from kallithea.controllers.changeset import _context_url, _ignorews_url

from kallithea.lib import diffs

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.graphmod import graph_data

from kallithea.lib.utils2 import safe_int, safe_str

from kallithea.lib.vcs.utils.hgcompat import unionrepo

from kallithea.model.db import Repository

log = logging.getLogger(__name__)

class CompareController(BaseRepoController):

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

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

        # The base repository has already been retrieved.

        c.a_repo = c.db_repo

        # Retrieve the "changeset" repository (default: same as base).

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

        if other_repo is None:

            c.cs_repo = c.a_repo

        else:

            c.cs_repo = Repository.get_by_repo_name(other_repo)

            if c.cs_repo is None:

                msg = _('Could not find other repository %s') % other_repo

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

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

        # Verify that it's even possible to compare these two repositories.

        if c.a_repo.scm_instance.alias != c.cs_repo.scm_instance.alias:

            msg = _('Cannot compare repositories of different types')

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

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

    @staticmethod

    def _get_changesets(alias, org_repo, org_rev, other_repo, other_rev):

        """

        Returns lists of changesets that can be merged from org_repo@org_rev

        to other_repo@other_rev

        ... and the other way

        ... and the ancestors that would be used for merge

        :param org_repo: repo object, that is most likely the original repo we forked from

        :param org_rev: the revision we want our compare to be made

        :param other_repo: repo object, most likely the fork of org_repo. It has

            all changesets that we need to obtain

        :param other_rev: revision we want out compare to be made on other_repo

        """

        ancestors = None

        if org_rev == other_rev:

            org_changesets = []

            other_changesets = []

        elif alias == 'hg':

            # case two independent repos

            if org_repo != other_repo:

                hgrepo = unionrepo.makeunionrepository(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

            ancestors = [hgrepo[ancestor].hex() for ancestor in

            if ancestors:

                log.debug("shortcut found: %s is already an ancestor of %s", other_rev, org_rev)

            else:

                log.debug("no shortcut found: %s is not an ancestor of %s", other_rev, org_rev)

                ancestors = [hgrepo[ancestor].hex() for ancestor in

                                     other_rev, org_rev, org_rev)

                                   org_rev, other_rev, other_rev)

        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 = [

                    x.commit.id

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

                                                       exclude=[org_rev])

                ]

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

                if other_changesets:

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

                else:

                    # no changesets from other repo, ancestor is the other_rev

                    ancestors = [other_rev]

                gitrepo.close()

                gitrepo_remote.close()

            else:

                so = 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 = org_repo.run_git_command(

                    ['merge-base', org_rev, other_rev]

                )

                ancestors = [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, ancestors

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def index(self, repo_name):

        c.compare_home = True

        c.a_ref_name = c.cs_ref_name = None

        return render('compare/compare_diff.html')

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    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

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

        # partial uses compare_cs.html template directly

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

        # is_ajax_preview puts hidden input field with changeset revisions

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

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

        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

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

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

pull requests controller for Kallithea for initializing pull requests

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: May 7, 2012

:author: marcink

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

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

"""

import logging

import traceback

import formencode

from tg import request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest, HTTPForbidden, HTTPFound, HTTPNotFound

from kallithea.config.routing import url

from kallithea.controllers.changeset import _context_url, _ignorews_url, create_cs_pr_comment, delete_cs_pr_comment

from kallithea.lib import diffs

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, jsonify, render

from kallithea.lib.graphmod import graph_data

from kallithea.lib.page import Page

from kallithea.lib.utils2 import safe_int

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, EmptyRepositoryError

from kallithea.lib.vcs.utils import safe_str

from kallithea.lib.vcs.utils.hgcompat import unionrepo

from kallithea.model.changeset_status import ChangesetStatusModel

from kallithea.model.comment import ChangesetCommentsModel

from kallithea.model.db import ChangesetStatus, PullRequest, PullRequestReviewer, Repository, User

from kallithea.model.forms import PullRequestForm, PullRequestPostForm

from kallithea.model.meta import Session

from kallithea.model.pull_request import CreatePullRequestAction, CreatePullRequestIterationAction, PullRequestModel

log = logging.getLogger(__name__)

def _get_reviewer(user_id):

    """Look up user by ID and validate it as a potential reviewer."""

    try:

        user = User.get(int(user_id))

    except ValueError:

        user = None

    if user is None or user.is_default_user:

        h.flash(_('Invalid reviewer "%s" specified') % user_id, category='error')

        raise HTTPBadRequest()

    return user

class PullrequestsController(BaseRepoController):

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

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

        the selectors in pullrequest.html

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

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

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

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

        peers = []

        if rev:

            rev = safe_str(rev)

        if branch:

            branch = safe_str(branch)

        if branch_rev:

            branch_rev = safe_str(branch_rev)

            # a revset not restricting to merge() would be better

            # (especially because it would get the branch point)

            # ... but is currently too expensive

            # including branches of children could be nice too

            peerbranches = set()

            for i in repo._repo.revs(

                branch_rev, branch_rev

            ):

                for abranch in repo.get_changeset(i).branches:

                    if abranch not in peerbranches:

                        n = 'branch:%s:%s' % (abranch, repo.get_changeset(abranch).raw_id)

                        peers.append((n, abranch))

                        peerbranches.add(abranch)

        selected = None

        tiprev = repo.tags.get('tip')

        tipbranch = None

        branches = []

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

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

            desc = abranch

            if branchrev == tiprev:

                tipbranch = abranch

                desc = '%s (current tip)' % desc

            branches.append((n, desc))

            if rev == branchrev:

                selected = n

            if branch == abranch:

                if not rev:

                    selected = n

                branch = None

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

            branchrev = repo.closed_branches.get(branch)

            if branchrev:

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

                branches.append((n, _('%s (closed)') % branch))

                selected = n

                branch = None

            if branch:

                log.debug('branch %r not found in %s', branch, repo)

        bookmarks = []

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

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

            bookmarks.append((n, bookmark))

            if rev == bookmarkrev:

                selected = n

        tags = []

        for tag, tagrev in repo.tags.iteritems():

            if tag == 'tip':

                continue

            n = 'tag:%s:%s' % (tag, tagrev)

            tags.append((n, tag))

            # note: even if rev == tagrev, don't select the static tag - it must be chosen explicitly

        # prio 1: rev was selected as existing entry above

        # prio 2: create special entry for rev; rev _must_ be used

        specials = []

        if rev and selected is None:

            selected = 'rev:%s:%s' % (rev, rev)

            specials = [(selected, '%s: %s' % (_("Changeset"), rev[:12]))]

        # prio 3: most recent peer branch

        if peers and not selected:

            selected = peers[0][0]

        # prio 4: tip revision

        if not selected:

            if h.is_hg(repo):

                if tipbranch:

                    selected = 'branch:%s:%s' % (tipbranch, tiprev)

                else:

                    selected = 'tag:null:' + repo.EMPTY_CHANGESET

                    tags.append((selected, 'null'))

            else:

                if 'master' in repo.branches:

                    selected = 'branch:master:%s' % repo.branches['master']

                else:

                    k, v = list(repo.branches.items())[0]

                    selected = 'branch:%s:%s' % (k, v)

        groups = [(specials, _("Special")),

                  (peers, _("Peer branches")),

                  (bookmarks, _("Bookmarks")),

                  (branches, _("Branches")),

                  (tags, _("Tags")),

                  ]

        return [g for g in groups if g[0]], selected

    def _is_allowed_to_change_status(self, pull_request):

        if pull_request.is_closed():

            return False

        owner = request.authuser.user_id == pull_request.owner_id

        reviewer = PullRequestReviewer.query() \

            .filter(PullRequestReviewer.pull_request == pull_request) \

            .filter(PullRequestReviewer.user_id == request.authuser.user_id) \

            .count() != 0

                    _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 wrap_to_table(html):

    """Given a string with html, return it wrapped in a table, similar to what

    DiffProcessor returns."""

    return '''\

              <table class="code-difftable">

                <tr class="line no-comment">

                <td class="lineno new"></td>

                <td class="code no-comment"><pre>%s</pre></td>

                </tr>

              </table>''' % html

def wrapped_diff(filenode_old, filenode_new, diff_limit=None,

                ignore_whitespace=True, line_context=3,

                enable_comments=False):

    """

    Returns a file diff wrapped into a table.

    Checks for diff_limit and presents a message if the diff is too big.

    """

    if filenode_old is None:

        filenode_old = FileNode(filenode_new.path, '', EmptyChangeset())

    op = None

    a_path = filenode_old.path # default, might be overriden by actual rename in diff

    if filenode_old.is_binary or filenode_new.is_binary:

        html_diff = wrap_to_table(_('Binary file'))

        stats = (0, 0)

    elif diff_limit != -1 and (

            diff_limit is None or

            (filenode_old.size < diff_limit and filenode_new.size < diff_limit)):

        raw_diff = get_gitdiff(filenode_old, filenode_new,

                                ignore_whitespace=ignore_whitespace,

                                context=line_context)

        diff_processor = DiffProcessor(raw_diff)

        if diff_processor.parsed: # there should be exactly one element, for the specified file

            f = diff_processor.parsed[0]

            op = f['operation']

            a_path = f['old_filename']

        html_diff = as_html(parsed_lines=diff_processor.parsed, enable_comments=enable_comments)

        stats = diff_processor.stat()

    else:

        html_diff = wrap_to_table(_('Changeset was too big and was cut off, use '

                               'diff menu to display this diff'))

        stats = (0, 0)

    if not html_diff:

        submodules = [o for o in [filenode_new, filenode_old] if isinstance(o, SubModuleNode)]

        if submodules:

            html_diff = wrap_to_table(h.escape('Submodule %r' % submodules[0]))

        else:

            html_diff = wrap_to_table(_('No changes detected'))

    cs1 = filenode_old.changeset.raw_id

    cs2 = filenode_new.changeset.raw_id

    return cs1, cs2, a_path, html_diff, stats, op

def get_gitdiff(filenode_old, filenode_new, ignore_whitespace=True, context=3):

    """

    Returns git style diff between given ``filenode_old`` and ``filenode_new``.

    """

    # make sure we pass in default context

    context = context or 3

    submodules = [o for o in [filenode_new, filenode_old] if isinstance(o, SubModuleNode)]

    if submodules:

    for filenode in (filenode_old, filenode_new):

        if not isinstance(filenode, FileNode):

            raise VCSError("Given object should be FileNode object, not %s"

                % filenode.__class__)

    repo = filenode_new.changeset.repository

    old_raw_id = getattr(filenode_old.changeset, 'raw_id', repo.EMPTY_CHANGESET)

    new_raw_id = getattr(filenode_new.changeset, 'raw_id', repo.EMPTY_CHANGESET)

    vcs_gitdiff = get_diff(repo, old_raw_id, new_raw_id, filenode_new.path,

                           ignore_whitespace, context)

    return vcs_gitdiff

def get_diff(scm_instance, rev1, rev2, path=None, ignore_whitespace=False, context=3):

    """

    A thin wrapper around vcs lib get_diff.

    """

    try:

        return scm_instance.get_diff(rev1, rev2, path=path,

                                     ignore_whitespace=ignore_whitespace, context=context)

    except MemoryError:

        h.flash('MemoryError: Diff is too big', category='error')

NEW_FILENODE = 1

DEL_FILENODE = 2

MOD_FILENODE = 3

RENAMED_FILENODE = 4

COPIED_FILENODE = 5

CHMOD_FILENODE = 6

BIN_FILENODE = 7

class DiffProcessor(object):

    """

    Give it a unified or git diff and it returns a list of the files that were

    mentioned in the diff together with a dict of meta information that

    can be used to render it in a HTML template.

    """

    def __init__(self, diff, vcs='hg', diff_limit=None, inline_diff=True):

        """

        :param diff:   a text in diff format

        :param vcs: type of version control hg or git

        :param diff_limit: define the size of diff that is considered "big"

            based on that parameter cut off will be triggered, set to None

            to show full diff

        """

        if not isinstance(diff, bytes):

            raise Exception('Diff must be bytes - got %s' % type(diff))

        self._diff = diff

        self.adds = 0

        self.removes = 0

        self.diff_limit = diff_limit

        self.limited_diff = False

        self.vcs = vcs

        self.parsed = self._parse_gitdiff(inline_diff=inline_diff)

    def _parse_gitdiff(self, inline_diff):

        """Parse self._diff and return a list of dicts with meta info and chunks for each file.

        Might set limited_diff.

        Optionally, do an extra pass and to extra markup of one-liner changes.

        """

        _files = [] # list of dicts with meta info and chunks

        starts = [m.start() for m in self._diff_git_re.finditer(self._diff)]

        starts.append(len(self._diff))

        for start, end in zip(starts, starts[1:]):

            if self.diff_limit and end > self.diff_limit:

                self.limited_diff = True

                continue

            head, diff_lines = _get_header(self.vcs, buffer(self._diff, start, end - start))

            op = None

            stats = {

                'added': 0,

                'deleted': 0,

                'binary': False,

                'ops': {},

            }

            if head['deleted_file_mode']:

                op = 'removed'

                stats['binary'] = True

                stats['ops'][DEL_FILENODE] = 'deleted file'

            elif head['new_file_mode']:

                op = 'added'

                stats['binary'] = True

                stats['ops'][NEW_FILENODE] = 'new file %s' % head['new_file_mode']

            else:  # modify operation, can be cp, rename, chmod

                # CHMOD

                if head['new_mode'] and head['old_mode']:

                    op = 'modified'

                    stats['binary'] = True

                    stats['ops'][CHMOD_FILENODE] = ('modified file chmod %s => %s'

                                        % (head['old_mode'], head['new_mode']))

                # RENAME

                if (head['rename_from'] and head['rename_to']

                      and head['rename_from'] != head['rename_to']):

                    op = 'renamed'

                    stats['binary'] = True

                    stats['ops'][RENAMED_FILENODE] = ('file renamed from %s to %s'

                                    % (head['rename_from'], head['rename_to']))

                # COPY

                if head.get('copy_from') and head.get('copy_to'):

                    op = 'modified'

                    stats['binary'] = True

                    stats['ops'][COPIED_FILENODE] = ('file copied from %s to %s'

                                        % (head['copy_from'], head['copy_to']))

                # FALL BACK: detect missed old style add or remove

                if op is None:

                    if not head['a_file'] and head['b_file']:

                        op = 'added'

                        stats['binary'] = True

                        stats['ops'][NEW_FILENODE] = 'new file'

                    elif head['a_file'] and not head['b_file']:

                        op = 'removed'

                        stats['binary'] = True

                        stats['ops'][DEL_FILENODE] = 'deleted file'

                # it's not ADD not DELETE

                if op is None:

                    op = 'modified'

                    stats['binary'] = True

                    stats['ops'][MOD_FILENODE] = 'modified file'

            # a real non-binary diff

            if head['a_file'] or head['b_file']:

                chunks, added, deleted = _parse_lines(diff_lines)

                stats['binary'] = False

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

                chunks = []

            if op == 'removed' 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 _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':