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 logging

from itertools import tee, imap

from mercurial import patch

from mercurial.mdiff import diffopts

from mercurial.bundlerepo import bundlerepository

from pylons.i18n.translation import _

from rhodecode.lib.compat import BytesIO

from rhodecode.lib.vcs.utils.hgcompat import localrepo

from rhodecode.lib.vcs.exceptions import VCSError

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

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

from rhodecode.lib.helpers import escape

from rhodecode.lib.utils import make_ui

from rhodecode.lib.utils2 import safe_unicode

log = logging.getLogger(__name__)

def wrap_to_table(str_):

    return '''<table class="code-difftable">

            diff = [diff]

        self.__udiff = diff

        self.__format = format

        self.adds = 0

        self.removes = 0

        if isinstance(self.__udiff, basestring):

            self.lines = iter(self.__udiff.splitlines(1))

        elif self.__format == 'gitdiff':

            udiff_copy = self.copy_iterator()

            self.lines = imap(self.escaper, self._parse_gitdiff(udiff_copy))

        else:

            udiff_copy = self.copy_iterator()

            self.lines = imap(self.escaper, udiff_copy)

        # Select a differ.

        if differ == 'difflib':

            self.differ = self._highlight_line_difflib

        else:

            self.differ = self._highlight_line_udiff

    def escaper(self, string):

    def copy_iterator(self):

        """

        make a fresh copy of generator, we should not iterate thru

        an original as it's needed for repeating operations on

        this instance of DiffProcessor

        """

        self.__udiff, iterator_copy = tee(self.__udiff)

        return iterator_copy

    def _extract_rev(self, line1, line2):

        """

        Extract the operation (A/M/D), filename and revision hint from a line.

        """

        try:

            if line1.startswith('--- ') and line2.startswith('+++ '):

                l1 = line1[4:].split(None, 1)

                old_filename = (l1[0].replace('a/', '', 1)

                                if len(l1) >= 1 else None)

                old_rev = l1[1] if len(l1) == 2 else 'old'

                l2 = line2[4:].split(None, 1)

                new_filename = (l2[0].replace('b/', '', 1)

            end -= 1

        end += 1

        if start or end:

            def do(l):

                last = end + len(l['line'])

                if l['action'] == 'add':

                    tag = 'ins'

                else:

                    tag = 'del'

                l['line'] = '%s<%s>%s</%s>%s' % (

                    l['line'][:start],

                    tag,

                    l['line'][start:last],

                    tag,

                    l['line'][last:]

                )

            do(line)

            do(next_)

    def _parse_udiff(self, inline_diff=True):

        """

        Parse the diff an return data for the template.

        """

        lineiter = self.lines

        files = []

        try:

            line = lineiter.next()

            while 1:

                # continue until we found the old file

                if not line.startswith('--- '):

                    line = lineiter.next()

                    continue

                chunks = []

                stats = [0, 0]

                operation, filename, old_rev, new_rev = \

                    self._extract_rev(line, lineiter.next())

                files.append({

                    'filename':         filename,

                    'old_revision':     old_rev,

                    'new_revision':     new_rev,

                    'chunks':           chunks,

                    'operation':        operation,

                    'stats':            stats,

                })

                line = lineiter.next()

                while line:

                    match = self._chunk_re.match(line)

                    if not match:

                        break

                    lines = []

                    chunks.append(lines)

                    old_line, old_end, new_line, new_end = \

                        [int(x or 1) for x in match.groups()[:-1]]

                    old_line -= 1

                    new_line -= 1

                    gr = match.groups()

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

                    # NEW LINE NUMBER

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

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

class InMemoryBundleRepo(bundlerepository):

    def __init__(self, ui, path, bundlestream):

        self._tempparent = None

        localrepo.localrepository.__init__(self, ui, path)

        self.ui.setconfig('phases', 'publish', False)

        self.bundle = bundlestream

        # dict with the mapping 'filename' -> position in the bundle

        self.bundlefilespos = {}