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

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

                 controller='changeset', action='raw_changeset',

                 revision='tip', conditions=dict(function=check_repo))

    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,

                                                method=["POST"]))

    rmap.connect('pullrequest_comment_delete',

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

"""

    rhodecode.controllers.changeset

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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

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

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

        if not request.environ.get('HTTP_X_PARTIAL_XHR'):

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

                                  revision=revision))

        data = {

           'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),

        }

        if comm:

            c.co = comm

            data.update(comm.get_dict())

            data.update({'rendered_text':

                         render('changeset/changeset_comment_block.html')})

        return data

    @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()

    if value is False:

        return HTML.tag('img', src=url("/images/icons/cancel.png"),

                        alt=_('False'))

    return value

def action_parser(user_log, feed=False, parse_cs=False):

    """

    This helper will action_map the specified string action into translated

    fancy names with icons and links

    :param user_log: user log instance

    :param feed: use output for feeds (no html and fancy icons)

    :param parse_cs: parse Changesets into VCS instances

    """

    action = user_log.action

    action_params = ' '

    x = action.split(':')

    if len(x) > 1:

        action, action_params = x

    def get_cs_links():

        revs_limit = 3  # display this amount always

        revs_top_limit = 50  # show upto this amount of changesets hidden

        revs_ids = action_params.split(',')

        deleted = user_log.repository is None

        if deleted:

            return ','.join(revs_ids)

        repo_name = user_log.repository.repo_name

        def lnk(rev, repo_name):

            if isinstance(rev, BaseChangeset) or isinstance(rev, AttributeDict):

                lbl = '%s' % (rev.short_id[:8])

                _url = url('changeset_home', repo_name=repo_name,

                           revision=rev.raw_id)

                title = tooltip(rev.message)

            else:

                ## changeset cannot be found/striped/removed etc.

                lbl = ('%s' % rev)[:12]

                _url = '#'

                title = _('Changeset not found')

            if parse_cs:

                return link_to(lbl, _url, title=title, class_='tooltip')

        revs = []

        if len(filter(lambda v: v != '', revs_ids)) > 0:

            repo = None

            for rev in revs_ids[:revs_top_limit]:

                # we want parsed changesets, or new log store format is bad

                if parse_cs:

                    try:

                        if repo is None:

                            repo = user_log.repository.scm_instance

                        _rev = repo.get_changeset(rev)

                        revs.append(_rev)

                    except ChangesetDoesNotExistError:

                        log.error('cannot find revision %s in this repo' % rev)

                        revs.append(rev)

                        continue

                else:

                    _rev = AttributeDict({

                        'short_id': rev[:12],

                        'raw_id': rev,

                        'message': '',

                    })

                    revs.append(_rev)

        cs_links = []

        cs_links.append(" " + ', '.join(

            [lnk(rev, repo_name) for rev in revs[:revs_limit]]

            )

        )

        compare_view = (

            ' <div class="compare_view tooltip" title="%s">'

            '<a href="%s">%s</a> </div>' % (

                _('Show all combined changesets %s->%s') % (

                    revs_ids[0][:12], revs_ids[-1][:12]

                ),

                url('changeset_home', repo_name=repo_name,

                    revision='%s...%s' % (revs_ids[0], revs_ids[-1])

                ),

                _('compare view')

            )

        )

        # if we have exactly one more than normally displayed

        # just display it, takes less space than displaying

        # "and 1 more revisions"

        if len(revs_ids) == revs_limit + 1:

            rev = revs[revs_limit]

            cs_links.append(", " + lnk(rev, repo_name))

        ``raw_id``

            raw changeset representation (i.e. full 40 length sha for git

            backend)

        ``short_id``

            shortened (if apply) version of ``raw_id``; it would be simple

            shortcut for ``raw_id[:12]`` for git/mercurial backends or same

            as ``raw_id`` for subversion

        ``revision``

            revision number as integer

        ``files``

            list of ``FileNode`` (``Node`` with NodeKind.FILE) objects

        ``dirs``

            list of ``DirNode`` (``Node`` with NodeKind.DIR) objects

        ``nodes``

            combined list of ``Node`` objects

        ``author``

            author of the changeset, as unicode

        ``message``

            message of the changeset, as unicode

        ``parents``

            list of parent changesets

        ``last``

            ``True`` if this is last changeset in repository, ``False``

            otherwise; trying to access this attribute while there is no

            changesets would raise ``EmptyRepositoryError``

    """

    def __str__(self):

        return '<%s at %s:%s>' % (self.__class__.__name__, self.revision,

            self.short_id)

    def __repr__(self):

        return self.__str__()

    def __unicode__(self):

        return u'%s:%s' % (self.revision, self.short_id)

    def __eq__(self, other):

        return self.raw_id == other.raw_id

    @LazyProperty

    def last(self):

        if self.repository is None:

            raise ChangesetError("Cannot check if it's most recent revision")

        return self.raw_id == self.repository.revisions[-1]

    @LazyProperty

    def parents(self):

        """

        Returns list of parents changesets.

        """

        raise NotImplementedError

    @LazyProperty

    def id(self):

        """

        Returns string identifying this changeset.

        """

        raise NotImplementedError

    @LazyProperty

    def raw_id(self):

        """

        Returns raw string identifying this changeset.

        """

        raise NotImplementedError

    @LazyProperty

    def short_id(self):

        """

        Returns shortened version of ``raw_id`` attribute, as string,

        identifying this changeset, useful for web representation.

        """

        raise NotImplementedError

    @LazyProperty

    def revision(self):

        """

        Returns integer identifying this changeset.

        """

        raise NotImplementedError

    @LazyProperty

    def author(self):

        """

        Returns Author for given commit

        """

.box .search div.search_path div.link a {

	color: #003367;

	cursor: pointer;

	text-decoration: none;

}

#path_unlock {

	color: red;

	font-size: 1.2em;

	padding-left: 4px;

}

.info_box span {

	margin-left: 3px;

	margin-right: 3px;

}

.info_box .rev {

	color: #003367;

	font-size: 1.6em;

	font-weight: bold;

	vertical-align: sub;

}

.info_box input#at_rev,.info_box input#size {

	background: #FFF;

	border-top: 1px solid #b3b3b3;

	border-left: 1px solid #b3b3b3;

	border-right: 1px solid #eaeaea;

	border-bottom: 1px solid #eaeaea;

	color: #000;

	font-size: 12px;

	margin: 0;

	padding: 1px 5px 1px;

}

.info_box input#view {

	text-align: center;

	padding: 4px 3px 2px 2px;

}

.yui-overlay,.yui-panel-container {

	visibility: hidden;

	position: absolute;

	z-index: 2;

}

	position: absolute;

	background-color: #FFF;

	border: 2px solid #003367;

	font: 100% sans-serif;

	width: auto;

	opacity: 1px;

	padding: 8px;

	white-space: pre-wrap;

	-webkit-border-radius: 8px 8px 8px 8px;

	-khtml-border-radius: 8px 8px 8px 8px;

	-moz-border-radius: 8px 8px 8px 8px;

	border-radius: 8px 8px 8px 8px;

	box-shadow: 0 2px 2px rgba(0, 0, 0, 0.6);

}

.mentions-container{

	width: 90% !important;

}

.mentions-container .yui-ac-content{

	width: 100% !important;

}

.ac {

	vertical-align: top;

}

.ac .yui-ac {

	position: inherit;

	font-size: 100%;

}

.ac .perm_ac {

	width: 20em;

}

.ac .yui-ac-input {

	width: 100%;

}

.ac .yui-ac-container {

	position: absolute;

	top: 1.6em;

	width: auto;

}

.ac .yui-ac-content {

	position: absolute;

	border: 1px solid gray;

	background: #fff;

	z-index: 9050;

}

.ac .yui-ac-shadow {

	position: absolute;

	width: 100%;

	background: #000;

	-moz-opacity: 0.1px;

	opacity: .10;

	filter: alpha(opacity = 10);

	z-index: 9049;

 * 

 * @param url: defines url to make partial request

 * @param container: defines id of container to input partial result

 * @param s_call: success callback function that takes o as arg

 *  o.tId

 *  o.status

 *  o.statusText

 *  o.getResponseHeader[ ]

 *  o.getAllResponseHeaders

 *  o.responseText

 *  o.responseXML

 *  o.argument

 * @param f_call: failure callback

 * @param args arguments 

 */

function ypjax(url,container,s_call,f_call,args){

	var method='GET';

	if(args===undefined){

		args=null;

	}

	// Set special header for partial ajax == HTTP_X_PARTIAL_XHR

	YUC.initHeader('X-PARTIAL-XHR',true);

	// wrapper of passed callback

	var s_wrapper = (function(o){

		return function(o){

			YUD.get(container).innerHTML=o.responseText;

			YUD.setStyle(container,'opacity','1.0');

    		//execute the given original callback

    		if (s_call !== undefined){

    			s_call(o);

    		}

		}

	})()	

	YUD.setStyle(container,'opacity','0.3');

	YUC.asyncRequest(method,url,{

		success:s_wrapper,

		failure:function(o){

			console.log(o);

			YUD.get(container).innerHTML='<span class="error_red">ERROR: {0}</span>'.format(o.status);

			YUD.setStyle(container,'opacity','1.0');

		},

		cache:false

	},args);

};

var ajaxPOST = function(url,postData,success) {

	// Set special header for ajax == HTTP_X_PARTIAL_XHR

	YUC.initHeader('X-PARTIAL-XHR',true);

	var toQueryString = function(o) {

	    if(typeof o !== 'object') {

	        return false;

	    }

	    var _p, _qs = [];

	    for(_p in o) {

	        _qs.push(encodeURIComponent(_p) + '=' + encodeURIComponent(o[_p]));

	    }

	    return _qs.join('&');

	};

    var sUrl = url;

    var callback = {

        success: success,

        failure: function (o) {

            alert("error");

        },

    };

    var postData = toQueryString(postData);

    var request = YAHOO.util.Connect.asyncRequest('POST', sUrl, callback, postData);

    return request;

};

/**

 * tooltip activate

 */

var tooltip_activate = function(){

};

/**

 * show more

 */

var show_more_event = function(){

    YUE.on(YUD.getElementsByClassName('show_more'),'click',function(e){

        var el = e.target;

        YUD.setStyle(YUD.get(el.id.substring(1)),'display','');

        YUD.setStyle(el.parentNode,'display','none');

    });

};