rmap.connect('toggle_following', '%s/toggle_following' % ADMIN_PREFIX,

                 controller='journal', action='toggle_following',

                 conditions=dict(method=["POST"]))

    #SEARCH

    rmap.connect('search', '%s/search' % ADMIN_PREFIX, controller='search',)

    rmap.connect('search_repo', '%s/search/{search_repo:.*}' % ADMIN_PREFIX,

                  controller='search')

    #LOGIN/LOGOUT/REGISTER/SIGN IN

    rmap.connect('login_home', '%s/login' % ADMIN_PREFIX, controller='login')

    rmap.connect('logout_home', '%s/logout' % ADMIN_PREFIX, controller='login',

                 action='logout')

    rmap.connect('register', '%s/register' % ADMIN_PREFIX, controller='login',

                 action='register')

    rmap.connect('reset_password', '%s/password_reset' % ADMIN_PREFIX,

                 controller='login', action='password_reset')

    rmap.connect('reset_password_confirmation',

                 '%s/password_reset_confirmation' % ADMIN_PREFIX,

                 controller='login', action='password_reset_confirmation')

    #FEEDS

    rmap.connect('rss_feed_home', '/{repo_name:.*?}/feed/rss',

                controller='feed', action='rss',

                conditions=dict(function=check_repo))

    rmap.connect('atom_feed_home', '/{repo_name:.*?}/feed/atom',

                controller='feed', action='atom',

                conditions=dict(function=check_repo))

    #==========================================================================

    # REPOSITORY ROUTES

    #==========================================================================

    rmap.connect('summary_home', '/{repo_name:.*?}',

                controller='summary',

                conditions=dict(function=check_repo))

    rmap.connect('repos_group_home', '/{group_name:.*}',

                controller='admin/repos_groups', action="show_by_name",

                conditions=dict(function=check_group))

    rmap.connect('changeset_home', '/{repo_name:.*?}/changeset/{revision}',

                controller='changeset', revision='tip',

                conditions=dict(function=check_repo))

    rmap.connect('changeset_comment',

                 '/{repo_name:.*?}/changeset/{revision}/comment',

                controller='changeset', revision='tip', action='comment',

                conditions=dict(function=check_repo))

    rmap.connect('changeset_comment_delete',

                 '/{repo_name:.*?}/changeset/comment/{comment_id}/delete',

                controller='changeset', action='delete_comment',

                conditions=dict(function=check_repo, method=["DELETE"]))

    rmap.connect('changeset_info', '/changeset_info/{repo_name:.*?}/{revision}',

                 controller='changeset', action='changeset_info')

    rmap.connect('compare_url',

                 '/{repo_name:.*?}/compare/{org_ref_type}@{org_ref:.*?}...{other_ref_type}@{other_ref:.*?}',

                 controller='compare', action='index',

                 conditions=dict(function=check_repo),

                 requirements=dict(

                            org_ref_type='(branch|book|tag|rev|org_ref_type)',

                            other_ref_type='(branch|book|tag|rev|other_ref_type)')

                 )

    rmap.connect('pullrequest_home',

                 '/{repo_name:.*?}/pull-request/new', controller='pullrequests',

                 action='index', conditions=dict(function=check_repo,

                                                 method=["GET"]))

    rmap.connect('pullrequest',

                 '/{repo_name:.*?}/pull-request/new', controller='pullrequests',

                 action='create', conditions=dict(function=check_repo,

                                                  method=["POST"]))

    rmap.connect('pullrequest_show',

                 '/{repo_name:.*?}/pull-request/{pull_request_id}',

                 controller='pullrequests',

                 action='show', conditions=dict(function=check_repo,

                                                method=["GET"]))

    rmap.connect('pullrequest_update',

                 '/{repo_name:.*?}/pull-request/{pull_request_id}',

                 controller='pullrequests',

                 action='update', conditions=dict(function=check_repo,

                                                method=["PUT"]))

    rmap.connect('pullrequest_delete',

                 '/{repo_name:.*?}/pull-request/{pull_request_id}',

                 controller='pullrequests',

                 action='delete', conditions=dict(function=check_repo,

                                                method=["DELETE"]))

    rmap.connect('pullrequest_show_all',

                 '/{repo_name:.*?}/pull-request',

                 controller='pullrequests',

                 action='show_all', conditions=dict(function=check_repo,

                                                method=["GET"]))

    rmap.connect('pullrequest_comment',

                 '/{repo_name:.*?}/pull-request-comment/{pull_request_id}',

                 controller='pullrequests',

                 action='comment', conditions=dict(function=check_repo,

    changeset controller for pylons showoing changes beetween

    revisions

    :created_on: Apr 25, 2010

    :author: marcink

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

    :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 logging

import traceback

from collections import defaultdict

from webob.exc import HTTPForbidden, HTTPBadRequest

from pylons import tmpl_context as c, url, request, response

from pylons.i18n.translation import _

from pylons.controllers.util import redirect

from pylons.decorators import jsonify

from rhodecode.lib.vcs.exceptions import RepositoryError, ChangesetError, \

    ChangesetDoesNotExistError

from rhodecode.lib.vcs.nodes import FileNode

import rhodecode.lib.helpers as h

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.utils import action_logger

from rhodecode.lib.compat import OrderedDict

from rhodecode.lib import diffs

from rhodecode.model.db import ChangesetComment, ChangesetStatus

from rhodecode.model.comment import ChangesetCommentsModel

from rhodecode.model.changeset_status import ChangesetStatusModel

from rhodecode.model.meta import Session

from rhodecode.lib.diffs import LimitedDiffContainer

from rhodecode.model.repo import RepoModel

from rhodecode.lib.exceptions import StatusChangeOnClosedPullRequestError

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

log = logging.getLogger(__name__)

def _update_with_GET(params, GET):

    for k in ['diff1', 'diff2', 'diff']:

        params[k] += GET.getall(k)

def anchor_url(revision, path, GET):

    fid = h.FID(revision, path)

    return h.url.current(anchor=fid, **dict(GET))

def get_ignore_ws(fid, GET):

    ig_ws_global = GET.get('ignorews')

    ig_ws = filter(lambda k: k.startswith('WS'), GET.getall(fid))

    if ig_ws:

        try:

            return int(ig_ws[0].split(':')[-1])

        except:

            pass

    return ig_ws_global

def _ignorews_url(GET, fileid=None):

    fileid = str(fileid) if fileid else None

    params = defaultdict(list)

    _update_with_GET(params, GET)

    lbl = _('show white space')

    ig_ws = get_ignore_ws(fileid, GET)

    ln_ctx = get_line_ctx(fileid, GET)

    # global option

    if fileid is None:

        if ig_ws is None:

            params['ignorews'] += [1]

            lbl = _('ignore white space')

        ctx_key = 'context'

        ctx_val = ln_ctx

    # per file options

    else:

        if ig_ws is None:

            params[fileid] += ['WS:1']

            lbl = _('ignore white space')

        ctx_key = fileid

        ctx_val = 'C:%s' % ln_ctx

    # if we have passed in ln_ctx pass it along to our params

    :param fileid:

    """

    fileid = str(fileid) if fileid else None

    ig_ws = get_ignore_ws(fileid, GET)

    ln_ctx = (get_line_ctx(fileid, GET) or 3) * 2

    params = defaultdict(list)

    _update_with_GET(params, GET)

    # global option

    if fileid is None:

        if ln_ctx > 0:

            params['context'] += [ln_ctx]

        if ig_ws:

            ig_ws_key = 'ignorews'

            ig_ws_val = 1

    # per file option

    else:

        params[fileid] += ['C:%s' % ln_ctx]

        ig_ws_key = fileid

        ig_ws_val = 'WS:%s' % 1

    if ig_ws:

        params[ig_ws_key] += [ig_ws_val]

    lbl = _('%s line context') % ln_ctx

    params['anchor'] = fileid

    img = h.image(h.url('/images/icons/table_add.png'), lbl, class_='icon')

    return h.link_to(img, h.url.current(**params), title=lbl, class_='tooltip')

class ChangesetController(BaseRepoController):

    @LoginRequired()

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

                                   'repository.admin')

    def __before__(self):

        super(ChangesetController, self).__before__()

        c.affected_files_cut_off = 60

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

        c.anchor_url = anchor_url

        c.ignorews_url = _ignorews_url

        c.context_url = _context_url

        #get ranges of revisions if preset

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

        enable_comments = True

        try:

            if len(rev_range) == 2:

                enable_comments = False

                rev_start = rev_range[0]

                rev_end = rev_range[1]

                rev_ranges = c.rhodecode_repo.get_changesets(start=rev_start,

                                                            end=rev_end)

            else:

                rev_ranges = [c.rhodecode_repo.get_changeset(revision)]

            c.cs_ranges = list(rev_ranges)

            if not c.cs_ranges:

                raise RepositoryError('Changeset range returned empty result')

        except (RepositoryError, ChangesetDoesNotExistError, Exception), e:

            log.error(traceback.format_exc())

            h.flash(str(e), category='warning')

            return redirect(url('home'))

        c.changes = OrderedDict()

        c.lines_added = 0  # count of lines added

        c.lines_deleted = 0  # count of lines removes

        c.changeset_statuses = ChangesetStatus.STATUSES

        c.comments = []

        c.statuses = []

        c.inline_comments = []

        c.inline_cnt = 0

        # Iterate over ranges (default changeset view is always one changeset)

        for changeset in c.cs_ranges:

            inlines = []

            if method == 'show':

                c.statuses.extend([ChangesetStatusModel()\

                                  .get_status(c.rhodecode_db_repo.repo_id,

                                              changeset.raw_id)])

                c.comments.extend(ChangesetCommentsModel()\

                                  .get_comments(c.rhodecode_db_repo.repo_id,

                                                revision=changeset.raw_id))

                inlines = ChangesetCommentsModel()\

                            .get_inline_comments(c.rhodecode_db_repo.repo_id,

                                                 revision=changeset.raw_id)

                c.inline_comments.extend(inlines)

            c.changes[changeset.raw_id] = []

            cs2 = changeset.raw_id

            cs1 = changeset.parents[0].raw_id if changeset.parents else EmptyChangeset()

            context_lcl = get_line_ctx('', request.GET)

            ign_whitespace_lcl = ign_whitespace_lcl = get_ignore_ws('', request.GET)

            _diff = c.rhodecode_repo.get_diff(cs1, cs2,

                ignore_whitespace=ign_whitespace_lcl, context=context_lcl)

            diff_processor = diffs.DiffProcessor(_diff,

                                                 vcs=c.rhodecode_repo.alias,

                                                 format='gitdiff',

                                                 diff_limit=diff_limit)

            cs_changes = OrderedDict()

            if method == 'show':

                _parsed = diff_processor.prepare()

                c.limited_diff = False

                if isinstance(_parsed, LimitedDiffContainer):

                    c.limited_diff = True

                for f in _parsed:

                    st = f['stats']

                    if st[0] != 'b':

                        c.lines_added += st[0]

                        c.lines_deleted += st[1]

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

                    diff = diff_processor.as_html(enable_comments=enable_comments,

                                                  parsed_lines=[f])

                    cs_changes[fid] = [cs1, cs2, f['operation'], f['filename'],

                                       diff, st]

            else:

                # downloads/raw we only need RAW diff nothing else

                diff = diff_processor.as_raw()

                cs_changes[''] = [None, None, None, None, diff, None]

            c.changes[changeset.raw_id] = cs_changes

        # count inline comments

        for __, 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.parent_tmpl = ''.join(['# Parent  %s\n' % x.raw_id

                                     for x in c.changeset.parents])

        if method == 'download':

            response.content_type = 'text/plain'

        elif method == 'raw':

            response.content_type = 'text/plain'

        elif method == 'show':

            if len(c.cs_ranges) == 1:

                return render('changeset/changeset.html')

            else:

                return render('changeset/changeset_range.html')

    @jsonify

    def comment(self, repo_name, revision):

        status = request.POST.get('changeset_status')

        change_status = request.POST.get('change_changeset_status')

        text = request.POST.get('text')

        if status and change_status:

            text = text or (_('Status change -> %s')

                            % ChangesetStatus.get_status_lbl(status))

        comm = ChangesetCommentsModel().create(

            text=text,

            repo=c.rhodecode_db_repo.repo_id,

            user=c.rhodecode_user.user_id,

            revision=revision,

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

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

            status_change=(ChangesetStatus.get_status_lbl(status)

                           if status and change_status else None)

        )

        # get status if set !

        if status and change_status:

            # if latest status was from pull request and it's closed

            # disallow changing status !

            # dont_allow_on_closed_pull_request = True !

            try:

                ChangesetStatusModel().set_status(

                    c.rhodecode_db_repo.repo_id,

                    status,

                    c.rhodecode_user.user_id,

                    comm,

                    revision=revision,

                    dont_allow_on_closed_pull_request=True

                )

            except StatusChangeOnClosedPullRequestError:

                log.error(traceback.format_exc())

                msg = _('Changing status on a changeset associated with'

                        'a closed pull request is not allowed')

                h.flash(msg, category='warning')

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

                                      revision=revision))

        action_logger(self.rhodecode_user,

                      'user_commented_revision:%s' % revision,

                      c.rhodecode_db_repo, self.ip_addr, self.sa)

        Session().commit()

        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:

        :type 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

    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 = re.split(r'(\W)', old['line'])

        newwords = re.split(r'(\W)', new['line'])

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

        oldfragments, newfragments = [], []

        for tag, i1, i2, j1, j2 in sequence.get_opcodes():

            oldfrag = ''.join(oldwords[i1:i2])

            newfrag = ''.join(newwords[j1:j2])

            if tag != 'equal':

                if oldfrag:

                    oldfrag = '<del>%s</del>' % oldfrag

                if newfrag:

                    newfrag = '<ins>%s</ins>' % newfrag

            oldfragments.append(oldfrag)

            newfragments.append(newfrag)

        old['line'] = "".join(oldfragments)

        new['line'] = "".join(newfragments)

    def _highlight_line_udiff(self, line, next_):

        """

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

                    if line == self._newline_marker:

                        # we need to append to lines, since this is not

                        # counted in the line specs of diff

                        lines.append({

                            'old_lineno':   '...',

                            'new_lineno':   '...',

                            'action':       'context',

                            'line':         line

                        })

        except StopIteration:

            pass

        return chunks, stats

    def _safe_id(self, idstring):

        """Make a string safe for including in an id attribute.

        The HTML spec says that id attributes 'must begin with

        a letter ([A-Za-z]) and may be followed by any number

        of letters, digits ([0-9]), hyphens ("-"), underscores

        ("_"), colons (":"), and periods (".")'. These regexps

        are slightly over-zealous, in that they remove colons

        and periods unnecessarily.

        Whitespace is transformed into underscores, and then

        anything which is not a hyphen or a character that

        matches \w (alphanumerics and underscore) is removed.

        """

        # Transform all whitespace to underscore

        idstring = re.sub(r'\s', "_", '%s' % idstring)

        # Remove everything that is not a hyphen or a member of \w

        idstring = re.sub(r'(?!-)\W', "", idstring).lower()

        return idstring

    def prepare(self, inline_diff=True):

        """

        Prepare the passed udiff for HTML rendering. It'l return a list

        of dicts with diff information

        """

        parsed = self._parser(inline_diff=inline_diff)

        self.parsed = True

        self.parsed_diff = parsed

        return parsed

    def as_raw(self, diff_lines=None):

        """

        """

    def as_html(self, table_class='code-difftable', line_class='line',

                new_lineno_class='lineno old', old_lineno_class='lineno new',

                code_class='code', enable_comments=False, parsed_lines=None):

        """

        Return given diff as html table with customized css classes

        """

        def _link_to_if(condition, label, url):

            """

            Generates a link if condition is meet or just the label if not.

            """

            if condition:

                return '''<a href="%(url)s">%(label)s</a>''' % {

                    'url': url,

                    'label': label

                }

            else:

                return label

        if not self.parsed:

            self.prepare()

        diff_lines = self.parsed_diff

        if parsed_lines:

            diff_lines = parsed_lines

        _html_empty = True

        _html = []

        _html.append('''<table class="%(table_class)s">\n''' % {

            'table_class': table_class

        })

        for diff in diff_lines:

            for line in diff['chunks']:

                _html_empty = False

                for change in line:

                    _html.append('''<tr class="%(lc)s %(action)s">\n''' % {

                        'lc': line_class,

                        'action': change['action']

                    })

                    anchor_old_id = ''

                    anchor_new_id = ''

                    anchor_old = "%(filename)s_o%(oldline_no)s" % {

                        'filename': self._safe_id(diff['filename']),

                        'oldline_no': change['old_lineno']

                    }

                    anchor_new = "%(filename)s_n%(oldline_no)s" % {

                        'filename': self._safe_id(diff['filename']),

								<span class="logtags">

									%if len(cs.parents)>1:

									<span class="merge">${_('merge')}</span>

									%endif

									%if cs.branch:

									<span class="branchtag" title="${'%s %s' % (_('branch'),cs.branch)}">

									   ${h.link_to(h.shorter(cs.branch),h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id))}

                                    </span>

									%endif

                                    %if h.is_hg(c.rhodecode_repo):

                                      %for book in cs.bookmarks:

                                      <span class="bookbook" title="${'%s %s' % (_('bookmark'),book)}">

                                         ${h.link_to(h.shorter(book),h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id))}

                                      </span>

                                      %endfor

                                    %endif

									%for tag in cs.tags:

										<span class="tagtag"  title="${'%s %s' % (_('tag'),tag)}">

										${h.link_to(h.shorter(tag),h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id))}</span>

									%endfor

								</span>

						</div>

					</div>

				%endfor

				<div class="pagination-wh pagination-left">

					${c.pagination.pager('$link_previous ~2~ $link_next')}

				</div>

				</div>

			</div>

			<script type="text/javascript" src="${h.url('/js/graph.js')}"></script>

			<script type="text/javascript">

				YAHOO.util.Event.onDOMReady(function(){

                    //Monitor range checkboxes and build a link to changesets

                    //ranges

                    var checkboxes = YUD.getElementsByClassName('changeset_range');

                    var url_tmpl = "${h.url('changeset_home',repo_name=c.repo_name,revision='__REVRANGE__')}";

                    YUE.on(checkboxes,'click',function(e){

                    	var clicked_cb = e.currentTarget;

                        var checked_checkboxes = [];

                        for (pos in checkboxes){

                            if(checkboxes[pos].checked){

                                checked_checkboxes.push(checkboxes[pos]);

                            }

                        }

                        if(checked_checkboxes.length>0){

                          // modify open pull request to show we have selected cs

                          YUD.get('open_new_pr').innerHTML = _TM['Open new pull request for selected changesets'];

                        }else{

                          YUD.get('open_new_pr').innerHTML = _TM['Open new pull request'];

                        }

                        if(checked_checkboxes.length>1){

                        	var rev_end = checked_checkboxes[0].name;

                        	var rev_start = checked_checkboxes[checked_checkboxes.length-1].name;

                        	// now select all checkboxes in the middle.

                        	var checked = false;

                        	for (var i=0; i<checkboxes.length; i++){

                        		var cb = checkboxes[i];

                        		var rev = cb.name;

                        		if (rev == rev_end){

                        			checked = true;

                        		}

                                if (checked){

                                    cb.checked = true;

                                }

                                else{

                                    cb.checked = false;

                                }

                        		if (rev == rev_start){

                                    checked = false;

                                }

                        	}

                            var url = url_tmpl.replace('__REVRANGE__',

                            		rev_start+'...'+rev_end);

                            var link = _TM['Show selected changes __S -> __E'];

                            link = link.replace('__S',rev_start.substr(0,6));

                            link = link.replace('__E',rev_end.substr(0,6));

                            YUD.get('rev_range_container').href = url;

                            YUD.get('rev_range_container').innerHTML = link;

                            YUD.setStyle('rev_range_container','display','');

                            YUD.setStyle('rev_range_clear','display','');

                        }

                        else{

                        	YUD.setStyle('rev_range_container','display','none');

                        	YUD.setStyle('rev_range_clear','display','none');

                        }

                    });

                    YUE.on('rev_range_clear','click',function(e){

                        for (var i=0; i<checkboxes.length; i++){

                            var cb = checkboxes[i];

                            cb.checked = false;

                        }

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

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

<%def name="title()">

    ${_('%s Changeset') % c.repo_name} - r${c.changeset.revision}:${h.short_id(c.changeset.raw_id)} - ${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))}

    »

    ${_('Changeset')} - <span class='hash'>r${c.changeset.revision}:${h.short_id(c.changeset.raw_id)}</span>

</%def>

<%def name="page_nav()">

    ${self.menu('changelog')}

</%def>

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

    </div>

    <script>

    var _USERS_AC_DATA = ${c.users_array|n};

    var _GROUPS_AC_DATA = ${c.users_groups_array|n};

    AJAX_COMMENT_URL = "${url('changeset_comment',repo_name=c.repo_name,revision=c.changeset.raw_id)}";

    AJAX_COMMENT_DELETE_URL = "${url('changeset_comment_delete',repo_name=c.repo_name,comment_id='__COMMENT_ID__')}";

    </script>

    <div class="table">

		<div class="diffblock">

			<div class="code-header">

                <div class="hash">

                 r${c.changeset.revision}:${h.short_id(c.changeset.raw_id)}

                </div>

                <div class="date">

                  ${h.fmt_date(c.changeset.date)}

                </div>

                <div class="changeset-status-container">

                    %if c.statuses:

                      <div title="${_('Changeset status')}" class="changeset-status-lbl">[${h.changeset_status_lbl(c.statuses[0])}]</div>

                      <div class="changeset-status-ico"><img src="${h.url('/images/icons/flag_status_%s.png' % c.statuses[0])}" /></div>

                    %endif

                </div>

                <div class="diff-actions">

                  ${c.ignorews_url(request.GET)}

                  ${c.context_url(request.GET)}

                </div>

                <div class="comments-number" style="float:right;padding-right:5px">${ungettext("%d comment", "%d comments", len(c.comments)) % len(c.comments)} ${ungettext("(%d inline)", "(%d inline)", c.inline_cnt) % c.inline_cnt}</div>

			</div>

		</div>

	    <div id="changeset_content">

			<div class="container">

	             <div class="left">

	                 <div class="author">

	                     <div class="gravatar">

	                         <img alt="gravatar" src="${h.gravatar_url(h.email_or_none(c.changeset.author),20)}"/>