return not cr(repo_name, config['base_path'])

    # The ErrorController route (handles 404/500 error pages); it should

    # likely stay at the top, ensuring it can always be resolved

    map.connect('/error/{action}', controller='error')

    map.connect('/error/{action}/{id}', controller='error')

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

    # CUSTOM ROUTES HERE

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

    #MAIN PAGE

    map.connect('bugtracker', "http://bitbucket.org/marcinkuzminski/rhodecode/issues", _static=True)

    map.connect('gpl_license', "http://www.gnu.org/licenses/gpl.html", _static=True)

    #ADMIN REPOSITORY REST ROUTES

    with map.submapper(path_prefix='/_admin', controller='admin/repos') as m:

        m.connect("repos", "/repos",

             action="create", conditions=dict(method=["POST"]))

        m.connect("repos", "/repos",

             action="index", conditions=dict(method=["GET"]))

        m.connect("formatted_repos", "/repos.{format}",

             action="index",

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

        m.connect("new_repo", "/repos/new",

                r,

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")      

        except Exception:

            log.error(traceback.format_exc())

            msg = _('error occured during creation of repository %s') \

                    % form_result.get('repo_name')

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

        if request.POST.get('user_created'):

        return redirect(url('repos'))

    @HasPermissionAllDecorator('hg.admin')

    def new(self, format='html'):

        """GET /repos/new: Form to create a new item"""

        new_repo = request.GET.get('repo', '')

        c.new_repo = h.repo_name_slug(new_repo)

        return render('admin/repos/repo_add.html')

    @HasPermissionAllDecorator('hg.admin')

    def update(self, repo_name):

                            items_per_page=c.size)

        self._graph(changesets, c.size, p)

        return render('changelog/changelog.html')

    def _graph(self, repo, size, p):

        revcount = size

        if not repo.revisions:return json.dumps([]), 0

        max_rev = repo.revisions[-1]

        offset = 1 if p == 1 else  ((p - 1) * revcount + 1)

        rev_start = repo.revisions[(-1 * offset)]

        revcount = min(max_rev, revcount)

        rev_end = max(0, rev_start - revcount)

        dag = graph_rev(repo.repo, rev_start, rev_end)

        c.dag = tree = list(colored(dag))

        data = []

        for (id, type, ctx, vtx, edges) in tree:

            if type != CHANGESET:

                continue

            data.append(('', vtx, edges))

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

                        <tr class="line">

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

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

                        </tr>

                      </table>''' % str

        try:

            c.changeset = hg_model.get_repo(c.repo_name).get_changeset(revision)

        except RepositoryError:

            log.error(traceback.format_exc())

        else:

            try:

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

            except IndexError:

                c.changeset_old = None

            c.changes = []

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

            # ADDED FILES

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

            c.sum_added = 0

            for node in c.changeset.added:

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

                else:

                    c.sum_added += node.size

                    if c.sum_added < cut_off_limit:

                        f_udiff = differ.get_udiff(filenode_old, node)

                        diff = differ.DiffProcessor(f_udiff).as_html()

                    else:

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

                                            ' off, see raw changeset instead'))

                cs1 = None

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

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

            # CHANGED FILES

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

            c.sum_removed = 0    

            for node in c.changeset.changed:

                try:

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

                except ChangesetError:

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

                else:

                    if c.sum_removed < cut_off_limit:

                        f_udiff = differ.get_udiff(filenode_old, node)

                        diff = differ.DiffProcessor(f_udiff).as_html()

                        if diff:

                            c.sum_removed += len(diff)

                    else:

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

                                            ' off, see raw changeset instead'))

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

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

            # REMOVED FILES    

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

            for node in c.changeset.removed:

                c.changes.append(('removed', node, None, None, None))            

        return render('changeset/changeset.html')

    def raw_changeset(self, revision):

        hg_model = HgModel()

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

        try:

            c.changeset = hg_model.get_repo(c.repo_name).get_changeset(revision)

        except RepositoryError:

            log.error(traceback.format_exc())

        else:

            try:

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

            except IndexError:

                c.changeset_old = 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')

                else:    

                    f_udiff = differ.get_udiff(filenode_old, node)

                    diff = differ.DiffProcessor(f_udiff).raw_diff()

                cs1 = None

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

            for node in c.changeset.changed:

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

                if filenode_old.is_binary or node.is_binary:

                    diff = _('binary file')

                else:    

                    f_udiff = differ.get_udiff(filenode_old, node)

                    diff = differ.DiffProcessor(f_udiff).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 

        parent = True if len(c.changeset.parents) > 0 else False

        c.parent_tmpl = 'Parent  %s' % c.changeset.parents[0].raw_id if parent else ''

        c.diffs = ''

        for x in c.changes:

            c.diffs += x[2]

        """Produce an atom-1.0 feed via feedgenerator module"""

        feed = Atom1Feed(title=self.title % repo_name,

                         link=url('summary_home', repo_name=repo_name, qualified=True),

                         description=self.description % repo_name,

                         language=self.language,

                         ttl=self.ttl)

        changesets = HgModel().get_repo(repo_name)

        for cs in changesets[:self.feed_nr]:

            feed.add_item(title=cs.message,

                          link=url('changeset_home', repo_name=repo_name,

                                   description=str(cs.date))

        response.content_type = feed.mime_type

        return feed.writeString('utf-8')

    def rss(self, repo_name):

        """Produce an rss2 feed via feedgenerator module"""

        feed = Rss201rev2Feed(title=self.title % repo_name,

                         link=url('summary_home', repo_name=repo_name, qualified=True),

                         description=self.description % repo_name,

                         language=self.language,

                         ttl=self.ttl)

        changesets = HgModel().get_repo(repo_name)

        for cs in changesets[:self.feed_nr]:

            feed.add_item(title=cs.message,

                          link=url('changeset_home', repo_name=repo_name,

                          description=str(cs.date))

        response.content_type = feed.mime_type

        return feed.writeString('utf-8')

                r = max_rev

            return r

        def get_prev_rev(cur):

            r = cur - 1

            return r

        c.f_path = f_path

        try:

            cur_rev = repo.get_changeset(revision).revision

            c.url_prev = url('files_home', repo_name=c.repo_name,

                             revision=prev_rev, f_path=f_path) 

            c.url_next = url('files_home', repo_name=c.repo_name,

                             revision=next_rev, f_path=f_path)   

            c.changeset = repo.get_changeset(revision)

            c.rev_nr = c.changeset.revision

            c.files_list = c.changeset.get_node(f_path)

            c.file_history = self._get_history(repo, c.files_list, f_path)

        except (RepositoryError, ChangesetError):

            c.files_list = None

        return render('files/files.html')

    def rawfile(self, repo_name, revision, f_path):

        hg_model = HgModel()

        c.repo = hg_model.get_repo(c.repo_name)

        c.repo = hg_model.get_repo(c.repo_name)

        file_node = c.repo.get_changeset(revision).get_node(f_path)

        response.content_type = 'text/plain'

        return file_node.content

    def annotate(self, repo_name, revision, f_path):

        hg_model = HgModel()

        c.repo = hg_model.get_repo(c.repo_name)

        cs = c.repo.get_changeset(revision)

        c.file = cs.get_node(f_path)

        c.file_msg = cs.get_file_message(f_path)

        c.rev_nr = cs.revision        

        c.f_path = f_path

        return render('files/files_annotate.html')

    def archivefile(self, repo_name, revision, fileformat):

        archive_specs = {

          '.tar.bz2': ('application/x-tar', 'tbz2'),

          '.tar.gz': ('application/x-tar', 'tgz'),

          '.zip': ('application/zip', 'zip'),

        }

        if not archive_specs.has_key(fileformat):

                node1 = FileNode('.', '', changeset=c.changeset_1)

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

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

                node2 = c.changeset_2.get_node(f_path)

            else:

                c.changeset_2 = EmptyChangeset()

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

        except RepositoryError:

            return redirect(url('files_home',

                                repo_name=c.repo_name, f_path=f_path))

        f_udiff = differ.get_udiff(node1, node2)

        diff = differ.DiffProcessor(f_udiff)

        if c.action == 'download':

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

            c.cur_diff = '<pre class="raw">%s</pre>' % h.escape(diff.raw_diff())

        if not c.cur_diff: c.no_changes = True    

        return render('files/file_diff.html')

    def _get_history(self, repo, node, f_path):

        from vcs.nodes import NodeKind

        if not node.kind is NodeKind.FILE:

            return []

        changesets = node.history

        hist_l = []

        for chs in changesets:

            n_desc = 'r%s:%s' % (chs.revision, chs.short_id)

        return hist_l

Created on February 18, 2010

hg controller for pylons

@author: marcink

"""

from operator import itemgetter

from pylons import tmpl_context as c, request

from rhodecode.lib.auth import LoginRequired

from rhodecode.lib.base import BaseController, render

from rhodecode.model.hg import HgModel

import logging

log = logging.getLogger(__name__)

    @LoginRequired()

    def __before__(self):

    def index(self):

        sortables = ['name', 'description', 'last_change', 'tip', 'contact']

        current_sort = request.GET.get('sort', 'name')

        current_sort_slug = current_sort.replace('-', '')

        if current_sort_slug not in sortables:

            c.sort_by = 'name'

            current_sort_slug = c.sort_by

        else:

            c.sort_by = current_sort

        c.sort_slug = current_sort_slug

log = logging.getLogger(__name__)

class LoginController(BaseController):

    def __before__(self):

        super(LoginController, self).__before__()

    def index(self):

        #redirect if already logged in

        c.came_from = request.GET.get('came_from', None)

        if c.rhodecode_user.is_authenticated:

        if request.POST:

            #import Login Form validator class

            login_form = LoginForm()

            try:

                c.form_result = login_form.to_python(dict(request.POST))

                username = c.form_result['username']

                user = UserModel().get_by_username(username)

                auth_user = AuthUser()

                auth_user.username = user.username

                auth_user.is_authenticated = True

                auth_user.is_admin = user.admin

                auth_user.user_id = user.user_id

                auth_user.name = user.name

                auth_user.lastname = user.lastname

                session['rhodecode_user'] = auth_user

                session.save()

                log.info('user %s is now authenticated', username)

                user.update_lastlogin()

                if c.came_from:

                    return redirect(c.came_from)

                else:

            except formencode.Invalid, errors:

                return htmlfill.render(

                    render('/login.html'),

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    encoding="UTF-8")

        return render('/login.html')

    @HasPermissionAnyDecorator('hg.admin', 'hg.register.auto_activate',

                    render('/password_reset.html'),

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    encoding="UTF-8")

        return render('/password_reset.html')

    def logout(self):

        session['rhodecode_user'] = AuthUser()

        session.save()

        log.info('Logging out and setting user as Empty')

        super(SettingsController, self).__before__()

    def index(self, repo_name):

        repo_model = RepoModel()

        c.repo_info = repo = repo_model.get(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps' 

                      ' it was created or renamed from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

        defaults = c.repo_info.__dict__

        defaults.update({'user':c.repo_info.user.username})

        c.users_array = repo_model.get_users_js()

        for p in c.repo_info.repo_to_perm:

            defaults.update({'perm_%s' % p.user.username: 

                             p.permission.permission_name})

        return htmlfill.render(

            render('settings/repo_settings.html'),

            defaults=defaults,

            encoding="UTF-8",

        #           method='delete')

        # url('repo_settings_delete', repo_name=ID)

        repo_model = RepoModel()

        repo = repo_model.get(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps' 

                      ' it was moved or renamed  from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

        try:

            action_logger(self.rhodecode_user, 'user_deleted_repo',

                              repo_name, '', self.sa)            

            repo_model.delete(repo)            

            invalidate_cache('cached_repo_list')

            h.flash(_('deleted repository %s') % repo_name, category='success')

        except Exception:

            h.flash(_('An error occurred during deletion of %s') % repo_name,

                    category='error')

    def fork(self, repo_name):

        repo_model = RepoModel()

        c.repo_info = repo = repo_model.get(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps' 

                      ' it was created or renamed from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

        return render('settings/repo_fork.html')

    def fork_create(self, repo_name):

        repo_model = RepoModel()

        c.repo_info = repo_model.get(repo_name)

        _form = RepoForkForm()()

        form_result = {}

        try:

            form_result = _form.to_python(dict(request.POST))

            action_logger(self.rhodecode_user, 'user_forked_repo',

                            repo_name, '', self.sa)                                                 

        except formencode.Invalid, errors:

            c.new_repo = errors.value['fork_name']

            r = render('settings/repo_fork.html')

            return htmlfill.render(

                r,

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")   

        else:

            col = color_dict[cs] = cgenerator.next()

        return "color: rgb(%s)! important;" % (', '.join(col))

    def url_func(changeset):

        tooltip_html = "<div style='font-size:0.8em'><b>Author:</b>" + \

        " %s<br/><b>Date:</b> %s</b><br/><b>Message:</b> %s<br/></div>"

        tooltip_html = tooltip_html % (changeset.author,

                                               changeset.date,

                                               tooltip(changeset.message))

        lnk_format = 'r%-5s:%s' % (changeset.revision,

        uri = link_to(

                lnk_format,

                url('changeset_home', repo_name=changeset.repository.name,

                class_='tooltip',

                tooltip_title=tooltip_html

              )

        uri += '\n'

        return uri

    return literal(annotate_highlight(filenode, url_func, **kwargs))

def repo_name_slug(value):

    """Return slug of name of repository

    This function is called on each creation/modification

    of repository to prevent bad names in repo

    pos = 1

    for scale in agescales:

        if scale[1] <= age_seconds:

            return time_ago_in_words(curdate, agescales[pos][0])

        pos += 1

age = lambda  x:_age(x)

capitalize = lambda x: x.capitalize()

email = util.email

email_or_none = lambda x: util.email(x) if util.email(x) != x else None

person = lambda x: _person(x)

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

# PERMS

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

from rhodecode.lib.auth import HasPermissionAny, HasPermissionAll, \

HasRepoPermissionAny, HasRepoPermissionAll

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

# GRAVATAR URL

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

import hashlib

import urllib

        from rhodecode.model.hg import _full_changelog_cached

        region_invalidate(_full_changelog_cached, None, *args)

class EmptyChangeset(BaseChangeset):

    """

    An dummy empty changeset.

    """

    revision = -1

    message = ''

    author = ''

    date = ''

    @LazyProperty

    def raw_id(self):

        """

        Returns raw string identifying this changeset, useful for web

        representation.

        """

        return '0' * 40

    @LazyProperty

    def short_id(self):

        return self.raw_id[:12]

                continue

            last_change = repo.last_change

            tip = h.get_changeset_safe(repo, 'tip')

            tmp_d = {}

            tmp_d['name'] = repo.name

            tmp_d['name_sort'] = tmp_d['name'].lower()

            tmp_d['description'] = repo.description

            tmp_d['description_sort'] = tmp_d['description']

            tmp_d['last_change'] = last_change

            tmp_d['last_change_sort'] = time.mktime(last_change.timetuple())

            tmp_d['tip_sort'] = tip.revision

            tmp_d['rev'] = tip.revision

            tmp_d['contact'] = repo.contact

            tmp_d['contact_sort'] = tmp_d['contact']

            tmp_d['repo_archives'] = list(repo._get_archives())

            tmp_d['last_msg'] = tip.message

            tmp_d['repo'] = repo

            yield tmp_d

    def get_repo(self, repo_name):

        try:

            repo = _get_repos_cached()[repo_name]

.yui-tt {

visibility:hidden;

position:absolute;

color:#666;

background-color:#FFF;

font-family:arial, helvetica, verdana, sans-serif;

border:2px solid #003367;

font:100% sans-serif;

width:auto;

opacity:1px;

padding:8px;

}

.ac {

vertical-align:top;

}

.ac .yui-ac {

position:relative;

font-family:arial;

font-size:100%;

}

	            </div>

	            <div class="account">

	            	${h.link_to('%s %s'%(c.rhodecode_user.name,c.rhodecode_user.lastname),h.url('admin_settings_my_account'))}<br/>

	            	${h.link_to(c.rhodecode_user.username,h.url('admin_settings_my_account'))}

	            </div>	

            </li>

            <li class="last highlight">${h.link_to(u'Logout',h.url('logout_home'))}</li>

        </ul>

        <!-- end user -->

        <div id="header-inner" class="title top-left-rounded-corner top-right-rounded-corner">

            <!-- logo -->

            <div id="logo">

            </div>

            <!-- end logo -->

            <!-- menu -->

            ${self.page_nav()}

            <!-- quick -->

        </div>

    </div>     

    <!-- end header -->

	<!-- CONTENT -->

	<div id="content"> 

        <div class="flash_msg">

                   <a title="${_('Switch to')}" href="#">

                   <span class="icon">

                       <img src="/images/icons/arrow_switch.png" alt="${_('Switch to')}" />

                   </span>

                   <span>${_('Switch to')}</span>                 

                   </a>    

                    <ul>

                        <li>

                            ${h.link_to(_('branches'),h.url('branches_home',repo_name=c.repo_name),class_='branches childs')}

                            <ul>

                            %if c.repository_branches.values():

						        %for cnt,branch in enumerate(c.repository_branches.items()):

						        %endfor

						    %else:

						    	<li>${h.link_to(_('There are no branches yet'),'#')}</li>

						    %endif

                            </ul>                        

                        </li>

                        <li>

                            ${h.link_to(_('tags'),h.url('tags_home',repo_name=c.repo_name),class_='tags childs')}

                            <ul>

                            %if c.repository_tags.values():

                                %for cnt,tag in enumerate(c.repository_tags.items()):

                                %endfor

                            %else:

                            	<li>${h.link_to(_('There are no tags yet'),'#')}</li>

                            %endif

                            </ul>                        

                        </li>                        

                    </ul>

                </li>

                <li ${is_current('files')}>

                   <a title="${_('Files')}" href="${h.url('files_home',repo_name=c.repo_name)}">

                   <span class="icon">

                       <img src="/images/icons/file.png" alt="${_('Files')}" />

##	                  ${h.form(url('repo_settings_delete', repo_name=c.repo_name),method='delete')}

##	                    ${h.submit('remove_%s' % c.repo_name,'delete',class_="delete_icon action_button",onclick="return confirm('Confirm to delete this repository');")}

##	                  ${h.end_form()}

##                   	</li>

##                   	%endif

                   </ul>             

                </li>

	        </ul>

		%else:

		    ##ROOT MENU

            <ul id="quick">

                <li>

                    <span class="icon">

                        <img src="/images/icons/home_16.png" alt="${_('Home')}" />

                    </span>

                    <span>${_('Home')}</span>                 

                    </a>        

                </li>

                <li>

                    <a title="${_('Search')}"  href="${h.url('search')}">

                    <span class="icon">

                        <img src="/images/icons/search_16.png" alt="${_('Search')}" />

                    </span>