name, val = org.split(':')

            return _repo, (name, val)

        def other_parser(other):

            _other_repo = request.GET.get('repo')

            _repo = org_repo

            name, val = other.split(':')

            if _other_repo:

                #TODO: do an actual repo loookup within rhodecode

                _repo = _other_repo

            return _repo, (name, val)

        if '...' in ref:

            try:

                org, other = ref.split('...')

                org_repo, org_ref = org_parser(org)

                other_repo, other_ref = other_parser(other)

                return org_repo, org_ref, other_repo, other_ref

            except:

                log.error(traceback.format_exc())

        raise HTTPNotFound

        changesets = []

        #case two independent repos

        if org_repo != other_repo:

            common, incoming, rheads = tmp

            if not incoming:

                revs = []

            else:

                changesets.append(org_repo.get_changeset(cs))

        else:

            revs = ['ancestors(%s) and not ancestors(%s)' % (org_ref[1],

                                                             other_ref[1])]

            from mercurial import scmutil

            out = scmutil.revrange(org_repo._repo, revs)

            for cs in reversed(out):

                changesets.append(org_repo.get_changeset(cs))

        return changesets

    def index(self, ref):

        org_repo, org_ref, other_repo, other_ref = self._handle_ref(ref)

                           ref='%s...%s' % (':'.join(other_ref),

        c.org_repo = org_repo = Repository.get_by_repo_name(org_repo)

        c.other_repo = other_repo = Repository.get_by_repo_name(other_repo)

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

                                           org_ref,

                                           other_repo.scm_instance,

        c.org_ref = org_ref[1]

        c.other_ref = other_ref[1]

        # diff needs to have swapped org with other to generate proper diff

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

        _parsed = diff_processor.prepare()

        c.files = []

        c.changes = {}

        # sort Added first then Modified last Deleted files

        sorter = lambda info: {'A': 0, 'M': 1, 'D': 2}.get(info['operation'])

        for f in sorted(_parsed, key=sorter):

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

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

            diff = diff_processor.as_html(enable_comments=False, diff_lines=[f])

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

        return render('compare/compare_diff.html')

    Set of diffing helpers, previously part of vcs

    :created_on: Dec 4, 2011

    :author: marcink

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

    :original copyright: 2007-2008 by Armin Ronacher

    :license: GPLv3, see COPYING for more details.

"""

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

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

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

# (at your option) any later version.

#

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

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

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

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

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

import re

import difflib

import markupsafe

from itertools import tee, imap

from pylons.i18n.translation import _

from rhodecode.lib.vcs.exceptions import VCSError

from rhodecode.lib.vcs.nodes import FileNode, SubModuleNode

from rhodecode.lib.helpers import escape

def wrap_to_table(str_):

    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>''' % str_

def wrapped_diff(filenode_old, filenode_new, cut_off_limit=None,

                ignore_whitespace=True, line_context=3,

                enable_comments=False):

    """

    returns a wrapped diff into a table, checks for cut_off_limit and presents

    proper message

    """

    if filenode_old is None:

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

    if filenode_old.is_binary or filenode_new.is_binary:

        diff = wrap_to_table(_('binary file'))

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

    """

    General differ between branches, bookmarks or separate but releated 

    repositories

    :param org_repo:

    :type org_repo:

    :param org_ref:

    :type org_ref:

    :param other_repo:

    :type other_repo:

    :param other_ref:

    :type other_ref:

    """

    ignore_whitespace = False

    context = 3

    org_repo = org_repo.scm_instance._repo

    other_repo = other_repo.scm_instance._repo

    org_ref = org_ref[1]

    other_ref = other_ref[1]