for node in changeset.removed:

                c.changes[changeset.raw_id].append(

                    ('removed', node, None, None, None, (0, 0))

                )

        # count inline comments

        for path, lines in c.inline_comments:

            for comments in lines.values():

                c.inline_cnt += len(comments)

        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'

        line_context = request.GET.get('context', 3)

        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,

                                           ignore_whitespace=ignore_whitespace,

                                           context=line_context)

                    diff = diffs.DiffProcessor(f_gitdiff,

                                                format='gitdiff').raw_diff()

                cs1 = None

                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,

                                           ignore_whitespace=ignore_whitespace,

                                           context=line_context)

                    diff = diffs.DiffProcessor(f_gitdiff,

                                                format='gitdiff').raw_diff()

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

        response.content_type = 'text/plain'

        if method == 'download':

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

                                            % revision

        c.parent_tmpl = ''.join(['# Parent  %s\n' % x.raw_id

                                 for x in c.changeset.parents])

        c.diffs = ''

        for x in c.changes:

            c.diffs += x[2]

        return render('changeset/raw_changeset.html')

    def comment(self, repo_name, revision):

        ChangesetCommentsModel().create(text=request.POST.get('text'),

                                        repo_id=c.rhodecode_db_repo.repo_id,

                                        user_id=c.rhodecode_user.user_id,

                                        revision=revision,

                                        f_path=request.POST.get('f_path'),

                                        line_no=request.POST.get('line'))

        Session.commit()

        return redirect(h.url('changeset_home', repo_name=repo_name,

                              revision=revision))

    @jsonify

    def delete_comment(self, repo_name, comment_id):

        co = ChangesetComment.get(comment_id)

        owner = lambda: co.author.user_id == c.rhodecode_user.user_id

        if h.HasPermissionAny('hg.admin', 'repository.admin')() or owner:

            ChangesetCommentsModel().delete(comment=co)

            Session.commit()

            return True

        else:

            raise HTTPForbidden()

from rhodecode.lib.utils import EmptyChangeset

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 to big and was cut off, use '

                               'diff menu to display this diff'))

        stats = (0, 0)

        size = 0

    if not diff:

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

    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

    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

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

    def __init__(self, diff, differ='diff', format='udiff'):

        """

        :param diff:   a text in diff format or generator

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

        """

        if isinstance(diff, basestring):

            diff = [diff]

        self.__udiff = diff

        self.__format = format

        self.adds = 0

        self.removes = 0

        return safe_str(path)

    def _get_kind(self, path):

        path = self._fix_path(path)

        if path in self._file_paths:

            return NodeKind.FILE

        elif path in self._dir_paths:

            return NodeKind.DIR

        else:

            raise ChangesetError("Node does not exist at the given path %r"

                % (path))

    def _get_filectx(self, path):

        path = self._fix_path(path)

        if self._get_kind(path) != NodeKind.FILE:

            raise ChangesetError("File does not exist for revision %r at "

                " %r" % (self.revision, path))

        return self._ctx.filectx(path)

    def get_file_mode(self, path):

        """

        Returns stat mode of the file at the given ``path``.

        """

        fctx = self._get_filectx(path)

        if 'x' in fctx.flags():

            return 0100755

        else:

            return 0100644

    def get_file_content(self, path):

        """

        Returns content of the file at given ``path``.

        """

        fctx = self._get_filectx(path)

        return fctx.data()

    def get_file_size(self, path):

        """

        Returns size of the file at given ``path``.

        """

        fctx = self._get_filectx(path)

        return fctx.size()

    def get_file_changeset(self, path):

        """

        Returns last commit of the file at the given ``path``.

        """

    def get_file_history(self, path):

        """

        Returns history of file as reversed list of ``Changeset`` objects for

        which file at given ``path`` has been modified.

        """

        fctx = self._get_filectx(path)

        nodes = [fctx.filectx(x).node() for x in fctx.filelog()]

        changesets = [self.repository.get_changeset(hex(node))

            for node in reversed(nodes)]

        return changesets

    def get_file_annotate(self, path):

        """

        Returns a list of three element tuples with lineno,changeset and line

        """

        fctx = self._get_filectx(path)

        annotate = []

        for i, annotate_data in enumerate(fctx.annotate()):

            ln_no = i + 1

            annotate.append((ln_no, self.repository\

                             .get_changeset(hex(annotate_data[0].node())),

                             annotate_data[1],))

        return annotate

    def fill_archive(self, stream=None, kind='tgz', prefix=None,

                     subrepos=False):

        """

        Fills up given stream.

        :param stream: file like object.

        :param kind: one of following: ``zip``, ``tgz`` or ``tbz2``.

            Default: ``tgz``.

        :param prefix: name of root directory in archive.

            Default is repository name and changeset's raw_id joined with dash

            (``repo-tip.<KIND>``).

        :param subrepos: include subrepos in this archive.

        :raise ImproperArchiveTypeError: If given kind is wrong.

        :raise VcsError: If given stream is None

        """

        allowed_kinds = settings.ARCHIVE_SPECS.keys()

        if kind not in allowed_kinds:

            raise ImproperArchiveTypeError('Archive kind not supported use one'

                'of %s', allowed_kinds)

        else:

            mode = self._mode

        return mode

    @property

    def content(self):

        """

        Returns lazily content of the FileNode. If possible, would try to

        decode content from UTF-8.

        """

        if self.changeset:

            content = self.changeset.get_file_content(self.path)

        else:

            content = self._content

        if bool(content and '\0' in content):

            return content

        return safe_unicode(content)

    @LazyProperty

    def size(self):

        if self.changeset:

            return self.changeset.get_file_size(self.path)

        raise NodeError("Cannot retrieve size of the file without related "

            "changeset attribute")

    @LazyProperty

    def message(self):

        if self.changeset:

            return self.last_changeset.message

        raise NodeError("Cannot retrieve message of the file without related "

            "changeset attribute")

    @LazyProperty

    def last_changeset(self):

        if self.changeset:

            return self.changeset.get_file_changeset(self.path)

        raise NodeError("Cannot retrieve last changeset of the file without "

            "related changeset attribute")

    def get_mimetype(self):

        """

        Mimetype is calculated based on the file's content. If ``_mimetype``

        attribute is available, it will be returned (backends which store

        mimetypes or can easily recognize them, should set this private

        attribute to indicate that type should *NOT* be calculated).

        """

        if hasattr(self, '_mimetype'):

                len(self._mimetype) == 2):

                return self._mimetype

            else:

                raise NodeError('given _mimetype attribute must be an 2 '

                               'element list or tuple')

        if mtype is None:

            if self.is_binary:

                mtype = 'application/octet-stream'

                encoding = None

            else:

                mtype = 'text/plain'

                encoding = None

    @LazyProperty

    def mimetype(self):

        """

        Wrapper around full mimetype info. It returns only type of fetched

        mimetype without the encoding part. use get_mimetype function to fetch

        full set of (type,encoding)

        """

        return self.get_mimetype()[0]

    @LazyProperty

    def mimetype_main(self):

        return self.mimetype.split('/')[0]

    @LazyProperty

    def lexer(self):

        """

        Returns pygment's lexer class. Would try to guess lexer taking file's

        content, name and mimetype.

        """

        try:

            lexer = lexers.guess_lexer_for_filename(self.name, self.content)

        except lexers.ClassNotFound:

            lexer = lexers.TextLexer()

        # returns first alias

        return lexer

    @LazyProperty

    def lexer_alias(self):

        """

        Returns first alias of the lexer guessed for this file.

        """

        return self.lexer.aliases[0]

    @LazyProperty

    def history(self):

        """

        Returns a list of changeset for this file in which the file was changed

        """

        if self.changeset is None:

            raise NodeError('Unable to get changeset for this FileNode')

        return self.changeset.get_file_history(self.path)

    @LazyProperty

    def annotate(self):

        """

        Returns a list of three element tuples with lineno,changeset and line

        """

        if self.changeset is None:

            raise NodeError('Unable to get changeset for this FileNode')

        return self.changeset.get_file_annotate(self.path)

    @LazyProperty

    def state(self):

        if not self.changeset:

            raise NodeError("Cannot check state of the node if it's not "

                "linked with changeset")

        elif self.path in (node.path for node in self.changeset.added):

            return NodeState.ADDED

        elif self.path in (node.path for node in self.changeset.changed):

            return NodeState.CHANGED

        else:

            return NodeState.NOT_CHANGED

    @property

    def is_binary(self):

        """

        Returns True if file has binary content.

        """

    @LazyProperty

    def extension(self):

        """Returns filenode extension"""

        return self.name.split('.')[-1]

    def is_executable(self):

        """

        Returns ``True`` if file has executable flag turned on.

        """

        return bool(self.mode & stat.S_IXUSR)

class RemovedFileNode(FileNode):

    """

    Dummy FileNode class - trying to access any public attribute except path,

    name, kind or state (or methods/attributes checking those two) would raise

    RemovedFileNodeError.

    """

    ALLOWED_ATTRIBUTES = ['name', 'path', 'state', 'is_root', 'is_file',

        'is_dir', 'kind', 'added', 'changed', 'not_changed', 'removed']

    def __init__(self, path):

        """

        :param path: relative path to the node

        """

        super(RemovedFileNode, self).__init__(path=path)

    def __getattribute__(self, attr):

        if attr.startswith('_') or attr in RemovedFileNode.ALLOWED_ATTRIBUTES:

            return super(RemovedFileNode, self).__getattribute__(attr)

        raise RemovedFileNodeError("Cannot access attribute %s on "

            "RemovedFileNode" % attr)

    @LazyProperty

    def state(self):

        return NodeState.REMOVED

class DirNode(Node):

    """

    DirNode stores list of files and directories within this node.

    Nodes may be used standalone but within repository context they

    lazily fetch data within same repositorty's changeset.

    """

    def __init__(self, path, nodes=(), changeset=None):

        """

        Only one of ``nodes`` and ``changeset`` may be given. Passing both

        would raise ``NodeError`` exception.

        :param path: relative path to the node

        :param nodes: content may be passed to constructor

        :param changeset: if given, will use it to lazily fetch content

        :param size: always 0 for ``DirNode``

        """

        if nodes and changeset:

            raise NodeError("Cannot use both nodes and changeset")

        super(DirNode, self).__init__(path, NodeKind.DIR)

        self.changeset = changeset

           docs = root.get_node('docs')

           docs.get_node('api').get_node('index.rst')

        :param: path - relative to the current node

        .. note::

           To access lazily (as in example above) node have to be initialized

           with related changeset object - without it node is out of

           context and may know nothing about anything else than nearest

           (located at same level) nodes.

        """

        try:

            path = path.rstrip('/')

            if path == '':

                raise NodeError("Cannot retrieve node without path")

            self.nodes  # access nodes first in order to set _nodes_dict

            paths = path.split('/')

            if len(paths) == 1:

                if not self.is_root():

                    path = '/'.join((self.path, paths[0]))

                else:

                    path = paths[0]

                return self._nodes_dict[path]

            elif len(paths) > 1:

                if self.changeset is None:

                    raise NodeError("Cannot access deeper "

                                    "nodes without changeset")

                else:

                    path1, path2 = paths[0], '/'.join(paths[1:])

                    return self.get_node(path1).get_node(path2)

            else:

                raise KeyError

        except KeyError:

            raise NodeError("Node does not exist at %s" % path)

    @LazyProperty

    def state(self):

        raise NodeError("Cannot access state of DirNode")

    @LazyProperty

    def size(self):

        size = 0

        for root, dirs, files in self.changeset.walk(self.path):

            for f in files:

                size += f.size

        return size

class RootNode(DirNode):

    """

    DirNode being the root node of the repository.

    """

    def __init__(self, nodes=(), changeset=None):

        super(RootNode, self).__init__(path='', nodes=nodes,

            changeset=changeset)

    def __repr__(self):

        return '<%s>' % self.__class__.__name__

# -*- coding: utf-8 -*-

# original copyright: 2007-2008 by Armin Ronacher

# licensed under the BSD license.

import re

import difflib

import logging

from difflib import unified_diff

from itertools import tee, imap

from mercurial.match import match

from rhodecode.lib.vcs.exceptions import VCSError

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

    """

    Returns unified diff between given ``filenode_old`` and ``filenode_new``.

    """

    try:

    except NodeError:

        filenode_old_date = None

    try:

    except NodeError:

        filenode_new_date = None

    for filenode in (filenode_old, filenode_new):

        if not isinstance(filenode, FileNode):

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

                % filenode.__class__)

    if filenode_old_date and filenode_new_date:

        if not filenode_old_date < filenode_new_date:

            logging.debug("Generating udiff for filenodes with not increasing "

                "dates")

    vcs_udiff = unified_diff(filenode_old.content.splitlines(True),

                               filenode_new.content.splitlines(True),

                               filenode_old.name,

                               filenode_new.name,

                               filenode_old_date,

                               filenode_old_date)

    return vcs_udiff

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

    """

    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,

                                 ignore_whitespace)

    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

<%inherit file="/base/base.html"/>

<%def name="title()">

    ${c.repo_name} ${_('File annotate')} - ${c.rhodecode_name}

</%def>

<%def name="breadcrumbs_links()">

    ${h.link_to(u'Home',h.url('/'))}

    »

    ${h.link_to(c.repo_name,h.url('summary_home',repo_name=c.repo_name))}

    »

    ${_('annotate')} @ R${c.cs.revision}:${h.short_id(c.cs.raw_id)}

</%def>

<%def name="page_nav()">

		${self.menu('files')}

</%def>

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

        <ul class="links">

            <li>

              <span style="text-transform: uppercase;"><a href="#">${_('branch')}: ${c.cs.branch}</a></span>

            </li>

        </ul>

    </div>

    <div class="table">

		<div id="files_data">

			<h3 class="files_location">${_('Location')}: ${h.files_breadcrumbs(c.repo_name,c.cs.revision,c.file.path)}</h3>

			<dl>

			    <dt style="padding-top:10px;font-size:16px">${_('History')}</dt>

			    <dd>

			        <div>

			        ${h.form(h.url('files_diff_home',repo_name=c.repo_name,f_path=c.f_path),method='get')}

			        ${h.submit('diff','diff to revision',class_="ui-btn")}

			        ${h.submit('show_rev','show at revision',class_="ui-btn")}

			        ${h.end_form()}

			        </div>

			    </dd>

			</dl>

			<div id="body" class="codeblock">

                <div class="code-header">

                    <div class="stats">

                        <div class="left"><img src="${h.url('/images/icons/file.png')}"/></div>

                        <div class="left item">${h.format_byte_size(c.file.size,binary=True)}</div>

                        <div class="left item last">${c.file.mimetype}</div>

                        <div class="buttons">

                          ${h.link_to(_('show source'),h.url('files_home',repo_name=c.repo_name,revision=c.cs.raw_id,f_path=c.f_path),class_="ui-btn")}

                          ${h.link_to(_('show as raw'),h.url('files_raw_home',repo_name=c.repo_name,revision=c.cs.raw_id,f_path=c.f_path),class_="ui-btn")}

                          ${h.link_to(_('download as raw'),h.url('files_rawfile_home',repo_name=c.repo_name,revision=c.cs.raw_id,f_path=c.f_path),class_="ui-btn")}

                          % if h.HasRepoPermissionAny('repository.write','repository.admin')(c.repo_name):

                           % if not c.file.is_binary:

                            ${h.link_to(_('edit'),h.url('files_edit_home',repo_name=c.repo_name,revision=c.cs.raw_id,f_path=c.f_path),class_="ui-btn")}

                           % endif

                          % endif

                        </div>

                    </div>

                    <div class="author">

                        <div class="gravatar">

                            <img alt="gravatar" src="${h.gravatar_url(h.email(c.cs.author),16)}"/>

                        </div>

                        <div title="${c.cs.author}" class="user">${h.person(c.cs.author)}</div>

                    </div>

                    <div class="commit">${c.file.last_changeset.message}</div>

                </div>

				<div class="code-body">

			       %if c.file.is_binary:

			           ${_('Binary file (%s)') % c.file.mimetype}

			       %else:

					% if c.file.size < c.cut_off_limit:

						${h.pygmentize_annotation(c.repo_name,c.file,linenos=True,anchorlinenos=True,lineanchors='L',cssclass="code-highlight")}

					%else:

						${_('File is too big to display')} ${h.link_to(_('show as raw'),

						h.url('files_raw_home',repo_name=c.repo_name,revision=c.cs.revision,f_path=c.f_path))}

					%endif

			       <script type="text/javascript">

			           function highlight_lines(lines){

			               for(pos in lines){

			                 YUD.setStyle('L'+lines[pos],'background-color','#FFFFBE');

			               }

			           }

			           page_highlights = location.href.substring(location.href.indexOf('#')+1).split('L');

			           if (page_highlights.length == 2){

			              highlight_ranges  = page_highlights[1].split(",");

			              var h_lines = [];

			              for (pos in highlight_ranges){

			                   var _range = highlight_ranges[pos].split('-');

			                   if(_range.length == 2){

			                       var start = parseInt(_range[0]);

			                       var end = parseInt(_range[1]);

			                       if (start < end){

	%if node.is_file():

		<%return "browser-file" %>

	%else:

		<%return "browser-dir"%>

	%endif

</%def>

<div id="body" class="browserblock">

    <div class="browser-header">

		<div class="browser-nav">

			${h.form(h.url.current())}

			<div class="info_box">

	          <span class="rev">${_('view')}@rev</span>

	          <a class="ui-btn" href="${c.url_prev}" title="${_('previous revision')}">&laquo;</a>

	          ${h.text('at_rev',value=c.changeset.revision,size=5)}

	          <a class="ui-btn" href="${c.url_next}" title="${_('next revision')}">&raquo;</a>

	          ## ${h.submit('view',_('view'),class_="ui-btn")}

		    </div>

			${h.end_form()}

		</div>

	    <div class="browser-branch">

	       ${h.checkbox('stay_at_branch',c.changeset.branch,c.changeset.branch==c.branch)}

	       <label>${_('follow current branch')}</label>

	    </div>

        <div class="browser-search">

              <div id="search_activate_id" class="search_activate">

                  <a class="ui-btn" id="filter_activate" href="#">${_('search file list')}</a>

              </div>

              % if h.HasRepoPermissionAny('repository.write','repository.admin')(c.repo_name):

                    <div id="add_node_id" class="add_node">

                        <a class="ui-btn" href="${h.url('files_add_home',repo_name=c.repo_name,revision=c.changeset.raw_id,f_path=c.f_path)}">${_('add new file')}</a>

                    </div>

              % endif

        <div>

            <div id="node_filter_box_loading" style="display:none">${_('Loading file list...')}</div>

            <div id="node_filter_box" style="display:none">

            ${h.files_breadcrumbs(c.repo_name,c.changeset.raw_id,c.file.path)}/<input class="init" type="text" value="type to search..." name="filter" size="25" id="node_filter" autocomplete="off">

            </div>

        </div>

        </div>

    </div>

	<div class="browser-body">

		<table class="code-browser">

		         <thead>

		             <tr>

		                 <th>${_('Name')}</th>

		                 <th>${_('Size')}</th>

		                 <th>${_('Mimetype')}</th>

		                 <th>${_('Last modified')}</th>

		                 <th>${_('Last commiter')}</th>

		             </tr>

		         </thead>

                <tbody id="tbody">

          		%if c.file.parent:

         		<tr class="parity0">

	          		<td>

	          			${h.link_to('..',h.url('files_home',repo_name=c.repo_name,revision=c.changeset.raw_id,f_path=c.file.parent.path),class_="browser-dir ypjax-link")}

	          		</td>

	          		<td></td>

	          		<td></td>

	          		<td></td>

	          		<td></td>

	          		<td></td>