class ChangesetController(BaseRepoController):

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def __before__(self):

        super(ChangesetController, self).__before__()

        c.affected_files_cut_off = 60

    def index(self, revision):

        ignore_whitespace = request.GET.get('ignorews') == '1'

        def wrap_to_table(str):

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

                        <tr class="line">

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

                        <td class="code"><pre>%s</pre></td>

                        </tr>

                      </table>''' % str

        #get ranges of revisions if preset

        rev_range = revision.split('...')[:2]

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

                if filenode_old.is_binary or node.is_binary:

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

                    st = (0, 0)

                else:

                    # in this case node.size is good parameter since those are

                    # added nodes and their size defines how many changes were

                    # made

                    c.sum_added += node.size

                    if c.sum_added < self.cut_off_limit:

                        f_gitdiff = diffs.get_gitdiff(filenode_old, node,

                        d = diffs.DiffProcessor(f_gitdiff, format='gitdiff')

                        st = d.stat()

                        diff = d.as_html()

                    else:

                        diff = wrap_to_table(_('Changeset is to big and '

                                               'was cut off, see raw '

                                               'changeset instead'))

                        c.cut_off = True

                        break

                    except ChangesetError:

                        log.warning('Unable to fetch parent node for diff')

                        filenode_old = FileNode(node.path, '',

                                                EmptyChangeset())

                    if filenode_old.is_binary or node.is_binary:

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

                        st = (0, 0)

                    else:

                        if c.sum_removed < self.cut_off_limit:

                            f_gitdiff = diffs.get_gitdiff(filenode_old, node,

                            d = diffs.DiffProcessor(f_gitdiff,

                                                     format='gitdiff')

                            st = d.stat()

                            if (st[0] + st[1]) * 256 > self.cut_off_limit:

                                diff = wrap_to_table(_('Diff is to big '

                                                       'and was cut off, see '

                                                       'raw diff instead'))

                            else:

                                diff = d.as_html()

                            if diff:

                                c.sum_removed += len(diff)

        if len(c.cs_ranges) == 1:

            c.changeset = c.cs_ranges[0]

            c.changes = c.changes[c.changeset.raw_id]

            return render('changeset/changeset.html')

        else:

            return render('changeset/changeset_range.html')

    def raw_changeset(self, revision):

        method = request.GET.get('diff', 'show')

        ignore_whitespace = request.GET.get('ignorews') == '1'

        try:

            c.scm_type = c.rhodecode_repo.alias

            c.changeset = c.rhodecode_repo.get_changeset(revision)

        except RepositoryError:

            log.error(traceback.format_exc())

            return redirect(url('home'))

        else:

            try:

                c.changeset_parent = c.changeset.parents[0]

            except IndexError:

                c.changeset_parent = None

            c.changes = []

            for node in c.changeset.added:

                filenode_old = FileNode(node.path, '')

                if filenode_old.is_binary or node.is_binary:

                    diff = _('binary file') + '\n'

                else:

                    f_gitdiff = diffs.get_gitdiff(filenode_old, node,

                    diff = diffs.DiffProcessor(f_gitdiff,

                                                format='gitdiff').raw_diff()

                cs1 = None

                cs2 = node.last_changeset.raw_id

                c.changes.append(('added', node, diff, cs1, cs2))

            for node in c.changeset.changed:

                filenode_old = c.changeset_parent.get_node(node.path)

                if filenode_old.is_binary or node.is_binary:

                    diff = _('binary file')

                else:

                    f_gitdiff = diffs.get_gitdiff(filenode_old, node,

                    diff = diffs.DiffProcessor(f_gitdiff,

                                                format='gitdiff').raw_diff()

                cs1 = filenode_old.last_changeset.raw_id

                cs2 = node.last_changeset.raw_id

                c.changes.append(('changed', node, diff, cs1, cs2))

        response.content_type = 'text/plain'

        if method == 'download':

            response.content_disposition = 'attachment; filename=%s.patch' \

                                            % revision

                data = stream.read(4096)

                if not data:

                    os.remove(archive)

                    break

                yield data

        return get_chunked_archive(archive)

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def diff(self, repo_name, f_path):

        ignore_whitespace = request.GET.get('ignorews') == '1'

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

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

        c.action = request.GET.get('diff')

        c.no_changes = diff1 == diff2

        c.f_path = f_path

        c.big_diff = False

        try:

            if diff1 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_1 = c.rhodecode_repo.get_changeset(diff1)

                node1 = c.changeset_1.get_node(f_path)

            else:

            if diff2 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_2 = c.rhodecode_repo.get_changeset(diff2)

                node2 = c.changeset_2.get_node(f_path)

            else:

                c.changeset_2 = EmptyChangeset(repo=c.rhodecode_repo)

                node2 = FileNode('.', '', changeset=c.changeset_2)

        except RepositoryError:

            return redirect(url('files_home',

                                repo_name=c.repo_name, f_path=f_path))

        if c.action == 'download':

            _diff = diffs.get_gitdiff(node1, node2,

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

            diff_name = '%s_vs_%s.diff' % (diff1, diff2)

            response.content_type = 'text/plain'

            response.content_disposition = 'attachment; filename=%s' \

                                                    % diff_name

            return diff.raw_diff()

        elif c.action == 'raw':

            _diff = diffs.get_gitdiff(node1, node2,

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

            response.content_type = 'text/plain'

            return diff.raw_diff()

        elif c.action == 'diff':

            if node1.is_binary or node2.is_binary:

                c.cur_diff = _('Binary file')

            elif node1.size > self.cut_off_limit or \

                    node2.size > self.cut_off_limit:

                c.cur_diff = ''

                c.big_diff = True

            else:

                _diff = diffs.get_gitdiff(node1, node2,

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

                c.cur_diff = diff.as_html()

        else:

            #default option

            if node1.is_binary or node2.is_binary:

                c.cur_diff = _('Binary file')

            elif node1.size > self.cut_off_limit or \

                    node2.size > self.cut_off_limit:

                c.cur_diff = ''

                c.big_diff = True

            else:

                _diff = diffs.get_gitdiff(node1, node2,

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

                c.cur_diff = diff.as_html()

        if not c.cur_diff and not c.big_diff:

            c.no_changes = True

        return render('files/file_diff.html')

    def _get_node_history(self, cs, f_path):

        changesets = cs.get_file_history(f_path)

        hist_l = []

        changesets_group = ([], _("Changesets"))

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

import re

import difflib

from itertools import tee, imap

from mercurial.match import match

from vcs.exceptions import VCSError

from vcs.nodes import FileNode

    """

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

    :param ignore_whitespace: ignore whitespaces in diff

    """

    for filenode in (filenode_old, filenode_new):

        if not isinstance(filenode, FileNode):

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

                % filenode.__class__)

    old_raw_id = getattr(filenode_old.changeset, 'raw_id', '0' * 40)

    new_raw_id = getattr(filenode_new.changeset, 'raw_id', '0' * 40)

    repo = filenode_new.changeset.repository

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

    return vcs_gitdiff

class DiffProcessor(object):

    """

    Give it a unified 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+))? @@(.*)')