from pylons.i18n.translation import _

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.utils2 import safe_unicode, safe_str

log = logging.getLogger(__name__)

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

        stats = (0, 0)

        size = 0

    elif cut_off_limit != -1 and (cut_off_limit is None or

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

        f_gitdiff = get_gitdiff(filenode_old, filenode_new,

                                ignore_whitespace=ignore_whitespace,

                                context=line_context)

        diff_processor = DiffProcessor(f_gitdiff, format='gitdiff')

        diff = diff_processor.as_html(enable_comments=enable_comments)

        stats = diff_processor.stat()

        size = len(diff or '')

    else:

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

                               'diff menu to display this diff'))

        stats = (0, 0)

        size = 0

    if not diff:

        submodules = filter(lambda o: isinstance(o, SubModuleNode),

                            [filenode_new, filenode_old])

        if submodules:

            diff = wrap_to_table(escape('Submodule %r' % submodules[0]))

        else:

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

    cs1 = filenode_old.changeset.raw_id

    cs2 = filenode_new.changeset.raw_id

    return size, cs1, cs2, diff, stats

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

    """

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

    :param ignore_whitespace: ignore whitespaces in diff

    """

    # make sure we pass in default context

    context = context or 3

    submodules = filter(lambda o: isinstance(o, SubModuleNode),

                        [filenode_new, filenode_old])

    if submodules:

        return ''

    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 = repo.get_diff(old_raw_id, new_raw_id, filenode_new.path,

                                ignore_whitespace, context)

    return vcs_gitdiff

NEW_FILENODE = 1

DEL_FILENODE = 2

MOD_FILENODE = 3

RENAMED_FILENODE = 4

class DiffLimitExceeded(Exception):

    pass

class LimitedDiffContainer(object):

    def __init__(self, diff_limit, cur_diff_size, diff):

        self.diff = diff

        self.diff_limit = diff_limit

        self.cur_diff_size = cur_diff_size

    def __iter__(self):

        for l in self.diff:

            yield l

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.

    """

    _chunk_re = re.compile(r'^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)')

    _newline_marker = re.compile(r'^\\ No newline at end of file')

    _git_header_re = re.compile(r"""

        #^diff[ ]--git

            [ ]a/(?P<a_path>.+?)[ ]b/(?P<b_path>.+?)\n

        (?:^similarity[ ]index[ ](?P<similarity_index>\d+)%\n

           ^rename[ ]from[ ](?P<rename_from>\S+)\n

           ^rename[ ]to[ ](?P<rename_to>\S+)(?:\n|$))?

        (?:^old[ ]mode[ ](?P<old_mode>\d+)\n

           ^new[ ]mode[ ](?P<new_mode>\d+)(?:\n|$))?

        (?:^new[ ]file[ ]mode[ ](?P<new_file_mode>.+)(?:\n|$))?

        (?:^deleted[ ]file[ ]mode[ ](?P<deleted_file_mode>.+)(?:\n|$))?

        (?:^index[ ](?P<a_blob_id>[0-9A-Fa-f]+)

            \.\.(?P<b_blob_id>[0-9A-Fa-f]+)[ ]?(?P<b_mode>.+)?(?:\n|$))?

        (?:^(?P<bin_patch>GIT[ ]binary[ ]patch)(?:\n|$))?

        (?:^---[ ](a/(?P<a_file>.+)|/dev/null)(?:\n|$))?

        (?:^\+\+\+[ ](b/(?P<b_file>.+)|/dev/null)(?:\n|$))?

    """, re.VERBOSE | re.MULTILINE)

    _hg_header_re = re.compile(r"""

        #^diff[ ]--git

            [ ]a/(?P<a_path>.+?)[ ]b/(?P<b_path>.+?)\n

        (?:^old[ ]mode[ ](?P<old_mode>\d+)\n

           ^new[ ]mode[ ](?P<new_mode>\d+)(?:\n|$))?

        (?:^similarity[ ]index[ ](?P<similarity_index>\d+)%(?:\n|$))?

        (?:^rename[ ]from[ ](?P<rename_from>\S+)\n

           ^rename[ ]to[ ](?P<rename_to>\S+)(?:\n|$))?

        (?:^new[ ]file[ ]mode[ ](?P<new_file_mode>.+)(?:\n|$))?

        (?:^deleted[ ]file[ ]mode[ ](?P<deleted_file_mode>.+)(?:\n|$))?

        (?:^index[ ](?P<a_blob_id>[0-9A-Fa-f]+)

            \.\.(?P<b_blob_id>[0-9A-Fa-f]+)[ ]?(?P<b_mode>.+)?(?:\n|$))?

        (?:^(?P<bin_patch>GIT[ ]binary[ ]patch)(?:\n|$))?

        (?:^---[ ](a/(?P<a_file>.+)|/dev/null)(?:\n|$))?

        (?:^\+\+\+[ ](b/(?P<b_file>.+)|/dev/null)(?:\n|$))?

    """, re.VERBOSE | re.MULTILINE)

    #used for inline highlighter word split

    _token_re = re.compile(r'()(>|<|&|\W+?)')

    def __init__(self, diff, vcs='hg', format='gitdiff', diff_limit=None):

        """

        :param diff:   a text in diff format

        :param vcs: type of version controll hg or git

        :param format: format of diff passed, `udiff` or `gitdiff`

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

            raise Exception('Diff must be a basestring got %s instead' % type(diff))

        self._diff = diff

        self._format = format

        self.adds = 0

        self.removes = 0

        # calculate diff size

        self.diff_size = len(diff)

        self.diff_limit = diff_limit

        self.cur_diff_size = 0

        self.parsed = False

        self.parsed_diff = []

        self.vcs = vcs

        if format == 'gitdiff':

            self.differ = self._highlight_line_difflib

            self._parser = self._parse_gitdiff

        else:

            self.differ = self._highlight_line_udiff

            self._parser = self._parse_udiff

    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 _escaper(self, string):

        """

        Escaper for diff escapes special chars and checks the diff limit

        :param string:

        """

        self.cur_diff_size += len(string)

        # escaper get's iterated on each .next() call and it checks if each

        # parsed line doesn't exceed the diff limit

        if self.diff_limit is not None and self.cur_diff_size > self.diff_limit:

            raise DiffLimitExceeded('Diff Limit Exceeded')

        return safe_unicode(string).replace('&', '&')\

                .replace('<', '&lt;')\

                .replace('>', '>')

    def _line_counter(self, l):

        """

        Checks each line and bumps total adds/removes for this diff

        :param l:

        """

        if l.startswith('+') and not l.startswith('+++'):

            self.adds += 1

        elif l.startswith('-') and not l.startswith('---'):

            self.removes += 1

        return safe_unicode(l)

    def _highlight_line_difflib(self, line, next_):

        """

        Highlight inline changes in both lines.

        """

        if line['action'] == 'del':

            old, new = line, next_

        else:

            old, new = next_, line

        oldwords = self._token_re.split(old['line'])

        newwords = self._token_re.split(new['line'])

        sequence = difflib.SequenceMatcher(None, oldwords, newwords)

        Highlight inline changes in both lines.

        """

        start = 0

        limit = min(len(line['line']), len(next_['line']))

        while start < limit and line['line'][start] == next_['line'][start]:

            start += 1

        end = -1

        limit -= start

        while -end <= limit and line['line'][end] == next_['line'][end]:

            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 _get_header(self, diff_chunk):

        """

        parses the diff header, and returns parts, and leftover diff

        parts consists of 14 elements::

            a_path, b_path, similarity_index, rename_from, rename_to,

            old_mode, new_mode, new_file_mode, deleted_file_mode,

            a_blob_id, b_blob_id, b_mode, a_file, b_file

        :param diff_chunk:

        """

        if self.vcs == 'git':

            match = self._git_header_re.match(diff_chunk)

            diff = diff_chunk[match.end():]

            return match.groupdict(), imap(self._escaper, diff.splitlines(1))

        elif self.vcs == 'hg':

            match = self._hg_header_re.match(diff_chunk)

            diff = diff_chunk[match.end():]

            return match.groupdict(), imap(self._escaper, diff.splitlines(1))

        else:

            raise Exception('VCS type %s is not supported' % self.vcs)

    def _clean_line(self, line, command):

        if command in ['+', '-', ' ']:

            #only modify the line if it's actually a diff thing

            line = line[1:]

        return line

    def _parse_gitdiff(self, inline_diff=True):

        _files = []

        diff_container = lambda arg: arg

        ##split the diff in chunks of separate --git a/file b/file chunks

        for raw_diff in ('\n' + self._diff).split('\ndiff --git')[1:]:

            head, diff = self._get_header(raw_diff)

            op = None

            stats = {

                'added': 0,

                'deleted': 0,

                'binary': False,

                'ops': {},

            }

            if head['deleted_file_mode']:

                op = 'D'

                stats['binary'] = True

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

            elif head['new_file_mode']:

                op = 'A'

                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 = 'M'

                    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 = 'M'

                    stats['binary'] = True

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

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

                # FALL BACK: detect missed old style add or remove

                if op is None:

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

                        op = 'A'

                        stats['binary'] = True

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

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

                        op = 'D'

                        stats['binary'] = True

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

                # it's not ADD not DELETE

                if op is None:

                    op = 'M'

                    stats['binary'] = True

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

            # a real non-binary diff

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

                try:

                    chunks, _stats = self._parse_lines(diff)

                    stats['binary'] = False

                    stats['added'] = _stats[0]

                    stats['deleted'] = _stats[1]

                    # explicit mark that it's a modified file

                    if op == 'M':

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

                except DiffLimitExceeded:

                    diff_container = lambda _diff: \

                        LimitedDiffContainer(self.diff_limit,

                                            self.cur_diff_size, _diff)

                    break

            else:  # GIT binary patch (or empty diff)

                # GIT Binary patch

                if head['bin_patch']:

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

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

                'filename':         head['b_path'],

                'old_revision':     head['a_blob_id'],

                'new_revision':     head['b_blob_id'],

                'chunks':           chunks,

                'operation':        op,

                'stats':            stats,

            })

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

        if not inline_diff:

            return diff_container(sorted(_files, key=sorter))

        # highlight inline changes

        for diff_data in _files:

            for chunk in diff_data['chunks']:

                lineiter = iter(chunk)

                try:

                    while 1:

                        line = lineiter.next()

                        if line['action'] not in ['unmod', 'context']:

                            nextline = lineiter.next()

                            if nextline['action'] in ['unmod', 'context'] or \

                               nextline['action'] == line['action']:

                                continue

                            self.differ(line, nextline)

                except StopIteration:

                    pass

        return diff_container(sorted(_files, key=sorter))

    def _parse_udiff(self, inline_diff=True):

        raise NotImplementedError()

    def _parse_lines(self, diff):

        """

        Parse the diff an return data for the template.

        """

        lineiter = iter(diff)

        stats = [0, 0]

        try:

            chunks = []

            line = lineiter.next()

            while line:

from __future__ import with_statement

import os

from rhodecode.tests import *

from rhodecode.lib.diffs import DiffProcessor, NEW_FILENODE, DEL_FILENODE, \

dn = os.path.dirname

FIXTURES = os.path.join(dn(dn(os.path.abspath(__file__))), 'fixtures')

DIFF_FIXTURES = {

    'hg_diff_add_single_binary_file.diff': [

        ('US Warszawa.jpg', 'A',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {NEW_FILENODE: 'new file 100755',

                  BIN_FILENODE: 'binary diff not shown'}}),

    ],

    'hg_diff_mod_single_binary_file.diff': [

        ('US Warszawa.jpg', 'M',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {MOD_FILENODE: 'modified file',

                  BIN_FILENODE: 'binary diff not shown'}}),

    ],

    'hg_diff_mod_single_file_and_rename_and_chmod.diff': [

        ('README', 'M',

         {'added': 3,

          'deleted': 0,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file',

                  RENAMED_FILENODE: 'file renamed from README.rst to README',

                  CHMOD_FILENODE: 'modified file chmod 100755 => 100644'}}),

    ],

    'hg_diff_mod_file_and_rename.diff': [

        ('README.rst', 'M',

         {'added': 3,

          'deleted': 0,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file',

                  RENAMED_FILENODE: 'file renamed from README to README.rst'}}),

    ],

    'hg_diff_del_single_binary_file.diff': [

        ('US Warszawa.jpg', 'D',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {DEL_FILENODE: 'deleted file',

                  BIN_FILENODE: 'binary diff not shown'}}),

    ],

    'hg_diff_chmod_and_mod_single_binary_file.diff': [

        ('gravatar.png', 'M',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {CHMOD_FILENODE: 'modified file chmod 100644 => 100755',

                  BIN_FILENODE: 'binary diff not shown'}}),

    ],

    'hg_diff_chmod.diff': [

        ('file', 'M',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {CHMOD_FILENODE: 'modified file chmod 100755 => 100644'}}),

    ],

    'hg_diff_rename_file.diff': [

        ('file_renamed', 'M',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {RENAMED_FILENODE: 'file renamed from file to file_renamed'}}),

    ],

    'hg_diff_rename_and_chmod_file.diff': [

        ('README', 'M',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {CHMOD_FILENODE: 'modified file chmod 100644 => 100755',

                  RENAMED_FILENODE: 'file renamed from README.rst to README'}}),

    ],

    'hg_diff_binary_and_normal.diff': [

        ('img/baseline-10px.png', 'A',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {NEW_FILENODE: 'new file 100644',

                  BIN_FILENODE: 'binary diff not shown'}}),

        ('js/jquery/hashgrid.js', 'A',

         {'added': 340,

          'deleted': 0,

          'binary': False,

          'ops': {NEW_FILENODE: 'new file 100755'}}),

        ('index.html', 'M',

         {'added': 3,

          'deleted': 2,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('less/docs.less', 'M',

         {'added': 34,

          'binary': False,

          'ops': {DEL_FILENODE: 'deleted file'}})

    ],

    'git_diff_chmod.diff': [

        ('work-horus.xls', 'M',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {CHMOD_FILENODE: 'modified file chmod 100644 => 100755'}})

    ],

    'git_diff_rename_file.diff': [

        ('file.xls', 'M',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {RENAMED_FILENODE: 'file renamed from work-horus.xls to file.xls'}})

    ],

    'git_diff_mod_single_binary_file.diff': [

        ('US Warszawa.jpg', 'M',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {MOD_FILENODE: 'modified file',

                  BIN_FILENODE: 'binary diff not shown'}})

    ],

    'git_diff_binary_and_normal.diff': [

        ('img/baseline-10px.png', 'A',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {NEW_FILENODE: 'new file 100644',

                  BIN_FILENODE: 'binary diff not shown'}}),

        ('js/jquery/hashgrid.js', 'A',

         {'added': 340,

          'deleted': 0,

          'binary': False,

          'ops': {NEW_FILENODE: 'new file 100755'}}),

        ('index.html', 'M',

         {'added': 3,

          'deleted': 2,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('less/docs.less', 'M',

         {'added': 34,

          'deleted': 0,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('less/scaffolding.less', 'M',

         {'added': 1,

          'deleted': 3,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('readme.markdown', 'M',

         {'added': 1,

          'deleted': 10,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('img/baseline-20px.png', 'D',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {DEL_FILENODE: 'deleted file',

                  BIN_FILENODE: 'binary diff not shown'}}),

        ('js/global.js', 'D',

         {'added': 0,

          'deleted': 75,

          'binary': False,

          'ops': {DEL_FILENODE: 'deleted file'}}),

    ],

    'diff_with_diff_data.diff': [

        ('vcs/backends/base.py', 'M',

         {'added': 18,

          'deleted': 2,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('vcs/backends/git/repository.py', 'M',

         {'added': 46,

          'deleted': 15,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('vcs/backends/hg.py', 'M',

         {'added': 22,

          'deleted': 3,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('vcs/tests/test_git.py', 'M',

         {'added': 5,

          'deleted': 5,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('vcs/tests/test_repository.py', 'M',

         {'added': 174,

          'deleted': 2,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

    ],

#     'large_diff.diff': [

#         ('.hgignore', 'A', {'deleted': 0, 'binary': False, 'added': 3, 'ops': {1: 'new file 100644'}}),

#         ('MANIFEST.in', 'A', {'deleted': 0, 'binary': False, 'added': 3, 'ops': {1: 'new file 100644'}}),

#         ('README.txt', 'A', {'deleted': 0, 'binary': False, 'added': 19, 'ops': {1: 'new file 100644'}}),

#         ('development.ini', 'A', {'deleted': 0, 'binary': False, 'added': 116, 'ops': {1: 'new file 100644'}}),

#         ('docs/index.txt', 'A', {'deleted': 0, 'binary': False, 'added': 19, 'ops': {1: 'new file 100644'}}),

#         ('ez_setup.py', 'A', {'deleted': 0, 'binary': False, 'added': 276, 'ops': {1: 'new file 100644'}}),

#         ('hgapp.py', 'A', {'deleted': 0, 'binary': False, 'added': 26, 'ops': {1: 'new file 100644'}}),

#         ('hgwebdir.config', 'A', {'deleted': 0, 'binary': False, 'added': 21, 'ops': {1: 'new file 100644'}}),

#         ('pylons_app.egg-info/PKG-INFO', 'A', {'deleted': 0, 'binary': False, 'added': 10, 'ops': {1: 'new file 100644'}}),

#         ('pylons_app.egg-info/SOURCES.txt', 'A', {'deleted': 0, 'binary': False, 'added': 33, 'ops': {1: 'new file 100644'}}),

#         ('pylons_app.egg-info/dependency_links.txt', 'A', {'deleted': 0, 'binary': False, 'added': 1, 'ops': {1: 'new file 100644'}}),

#         #TODO:

#     ],

}

class DiffLibTest(BaseTestCase):

    @parameterized.expand([(x,) for x in DIFF_FIXTURES])

    def test_diff(self, diff_fixture):

        with open(os.path.join(FIXTURES, diff_fixture)) as f:

            diff = f.read()

        diff_proc = DiffProcessor(diff)

        diff_proc_d = diff_proc.prepare()

        data = [(x['filename'], x['operation'], x['stats']) for x in diff_proc_d]

        expected_data = DIFF_FIXTURES[diff_fixture]

        self.assertListEqual(expected_data, data)