another major code rafactor, reimplemented (almost from scratch)

the way caching works, Should be solid rock for now. Some code optymizations on scmModel.get() to make it don't load unneded things. Changed db cache to file that should also reduce memory size

rhodecode/controllers/admin/repos.py

@@ -1,340 +1,342 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.admin.repos
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     
     Admin controller for RhodeCode
     
     :created_on: Apr 7, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>    
     :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; version 2
 # of the License or (at your opinion) any later version of the license.
 # 
 # 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, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA  02110-1301, USA.
 
 import logging
 import traceback
 import formencode
 from operator import itemgetter
 from formencode import htmlfill
 
 from paste.httpexceptions import HTTPInternalServerError
 from pylons import request, response, session, tmpl_context as c, url
 from pylons.controllers.util import abort, redirect
 from pylons.i18n.translation import _
 
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, \
     HasPermissionAnyDecorator
 from rhodecode.lib.base import BaseController, render
 from rhodecode.lib.utils import invalidate_cache, action_logger, repo_name_slug
 from rhodecode.model.db import User
 from rhodecode.model.forms import RepoForm
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.repo import RepoModel
 
 
 log = logging.getLogger(__name__)
 
 class ReposController(BaseController):
     """REST Controller styled on the Atom Publishing Protocol"""
     # To properly map this controller, ensure your config/routing.py
     # file has a resource setup:
     #     map.resource('repo', 'repos')
 
     @LoginRequired()
     @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')
     def __before__(self):
         c.admin_user = session.get('admin_user')
         c.admin_username = session.get('admin_username')
         super(ReposController, self).__before__()
 
     @HasPermissionAllDecorator('hg.admin')
     def index(self, format='html'):
         """GET /repos: All items in the collection"""
         # url('repos')
         cached_repo_list = ScmModel().get_repos()
         c.repos_list = sorted(cached_repo_list, key=itemgetter('name_sort'))
         return render('admin/repos/repos.html')
 
     @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')
     def create(self):
         """POST /repos: Create a new item"""
         # url('repos')
         repo_model = RepoModel()
         _form = RepoForm()()
         form_result = {}
         try:
             form_result = _form.to_python(dict(request.POST))
             repo_model.create(form_result, c.rhodecode_user)
             h.flash(_('created repository %s') % form_result['repo_name'],
                     category='success')
 
             if request.POST.get('user_created'):
                 action_logger(self.rhodecode_user, 'user_created_repo',
                               form_result['repo_name'], '', self.sa)
             else:
                 action_logger(self.rhodecode_user, 'admin_created_repo',
                               form_result['repo_name'], '', self.sa)
 
         except formencode.Invalid, errors:
             c.new_repo = errors.value['repo_name']
 
             if request.POST.get('user_created'):
                 r = render('admin/repos/repo_add_create_repository.html')
             else:
                 r = render('admin/repos/repo_add.html')
 
             return htmlfill.render(
                 r,
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8")
 
         except Exception:
             log.error(traceback.format_exc())
             msg = _('error occurred during creation of repository %s') \
                     % form_result.get('repo_name')
             h.flash(msg, category='error')
         if request.POST.get('user_created'):
             return redirect(url('home'))
         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 = repo_name_slug(new_repo)
 
         return render('admin/repos/repo_add.html')
 
     @HasPermissionAllDecorator('hg.admin')
     def update(self, repo_name):
         """PUT /repos/repo_name: Update an existing item"""
         # Forms posted to this method should contain a hidden field:
         #    <input type="hidden" name="_method" value="PUT" />
         # Or using helpers:
         #    h.form(url('repo', repo_name=ID),
         #           method='put')
         # url('repo', repo_name=ID)
         repo_model = RepoModel()
         changed_name = repo_name
         _form = RepoForm(edit=True, old_data={'repo_name':repo_name})()
 
         try:
             form_result = _form.to_python(dict(request.POST))
             repo_model.update(repo_name, form_result)
             invalidate_cache('get_repo_cached_%s' % repo_name)
             h.flash(_('Repository %s updated successfully' % repo_name),
                     category='success')
             changed_name = form_result['repo_name']
             action_logger(self.rhodecode_user, 'admin_updated_repo',
                               changed_name, '', self.sa)
 
         except formencode.Invalid, errors:
             c.repo_info = repo_model.get_by_repo_name(repo_name)
+
             if c.repo_info.stats:
                 last_rev = c.repo_info.stats.stat_on_revision
             else:
                 last_rev = 0
             c.stats_revision = last_rev
             r = ScmModel().get(repo_name)
             c.repo_last_rev = r.revisions[-1] if r.revisions else 0
 
             if last_rev == 0:
                 c.stats_percentage = 0
             else:
                 c.stats_percentage = '%.2f' % ((float((last_rev)) /
                                                 c.repo_last_rev) * 100)
 
             c.users_array = repo_model.get_users_js()
             c.users_groups_array = repo_model.get_users_groups_js()
 
             errors.value.update({'user':c.repo_info.user.username})
             return htmlfill.render(
                 render('admin/repos/repo_edit.html'),
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8")
 
         except Exception:
             log.error(traceback.format_exc())
             h.flash(_('error occurred during update of repository %s') \
                     % repo_name, category='error')
 
         return redirect(url('edit_repo', repo_name=changed_name))
 
     @HasPermissionAllDecorator('hg.admin')
     def delete(self, repo_name):
         """DELETE /repos/repo_name: Delete an existing item"""
         # Forms posted to this method should contain a hidden field:
         #    <input type="hidden" name="_method" value="DELETE" />
         # Or using helpers:
         #    h.form(url('repo', repo_name=ID),
         #           method='delete')
         # url('repo', repo_name=ID)
 
         repo_model = RepoModel()
         repo = repo_model.get_by_repo_name(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')
 
             return redirect(url('repos'))
         try:
             action_logger(self.rhodecode_user, 'admin_deleted_repo',
                               repo_name, '', self.sa)
             repo_model.delete(repo)
             invalidate_cache('get_repo_cached_%s' % repo_name)
             h.flash(_('deleted repository %s') % repo_name, category='success')
 
         except Exception, e:
             log.error(traceback.format_exc())
             h.flash(_('An error occurred during deletion of %s') % repo_name,
                     category='error')
 
         return redirect(url('repos'))
 
     @HasPermissionAllDecorator('hg.admin')
     def delete_perm_user(self, repo_name):
         """DELETE an existing repository permission user
         
         :param repo_name:
         """
 
         try:
             repo_model = RepoModel()
             repo_model.delete_perm_user(request.POST, repo_name)
         except Exception, e:
             h.flash(_('An error occurred during deletion of repository user'),
                     category='error')
             raise HTTPInternalServerError()
 
     @HasPermissionAllDecorator('hg.admin')
     def delete_perm_users_group(self, repo_name):
         """DELETE an existing repository permission users group
         
         :param repo_name:
         """
         try:
             repo_model = RepoModel()
             repo_model.delete_perm_users_group(request.POST, repo_name)
         except Exception, e:
             h.flash(_('An error occurred during deletion of repository'
                       ' users groups'),
                     category='error')
             raise HTTPInternalServerError()
 
     @HasPermissionAllDecorator('hg.admin')
     def repo_stats(self, repo_name):
         """DELETE an existing repository statistics
         
         :param repo_name:
         """
 
         try:
             repo_model = RepoModel()
             repo_model.delete_stats(repo_name)
         except Exception, e:
             h.flash(_('An error occurred during deletion of repository stats'),
                     category='error')
         return redirect(url('edit_repo', repo_name=repo_name))
 
     @HasPermissionAllDecorator('hg.admin')
     def repo_cache(self, repo_name):
         """INVALIDATE existing repository cache
         
         :param repo_name:
         """
 
         try:
             ScmModel().mark_for_invalidation(repo_name)
         except Exception, e:
             h.flash(_('An error occurred during cache invalidation'),
                     category='error')
         return redirect(url('edit_repo', repo_name=repo_name))
 
     @HasPermissionAllDecorator('hg.admin')
     def show(self, repo_name, format='html'):
         """GET /repos/repo_name: Show a specific item"""
         # url('repo', repo_name=ID)
 
     @HasPermissionAllDecorator('hg.admin')
     def edit(self, repo_name, format='html'):
         """GET /repos/repo_name/edit: Form to edit an existing item"""
         # url('edit_repo', repo_name=ID)
+        r = ScmModel().get(repo_name)[0]
+
         repo_model = RepoModel()
-        r = ScmModel().get(repo_name)
         c.repo_info = repo_model.get_by_repo_name(repo_name)
 
         if c.repo_info is None:
             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 redirect(url('repos'))
 
         if c.repo_info.stats:
             last_rev = c.repo_info.stats.stat_on_revision
         else:
             last_rev = 0
         c.stats_revision = last_rev
 
         c.repo_last_rev = r.revisions[-1] if r.revisions else 0
 
         if last_rev == 0 or c.repo_last_rev == 0:
             c.stats_percentage = 0
         else:
             c.stats_percentage = '%.2f' % ((float((last_rev)) /
                                             c.repo_last_rev) * 100)
 
         c.users_array = repo_model.get_users_js()
         c.users_groups_array = repo_model.get_users_groups_js()
 
         defaults = c.repo_info.get_dict()
 
         #fill owner
         if c.repo_info.user:
             defaults.update({'user':c.repo_info.user.username})
         else:
             replacement_user = self.sa.query(User)\
             .filter(User.admin == True).first().username
             defaults.update({'user':replacement_user})
 
 
         #fill repository users
         for p in c.repo_info.repo_to_perm:
             defaults.update({'u_perm_%s' % p.user.username:
                              p.permission.permission_name})
 
         #fill repository groups
         for p in c.repo_info.users_group_to_perm:
             defaults.update({'g_perm_%s' % p.users_group.users_group_name:
                              p.permission.permission_name})
 
         return htmlfill.render(
             render('admin/repos/repo_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
         )

rhodecode/controllers/branches.py

@@ -1,54 +1,53 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.branches
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     branches controller for rhodecode
     
     :created_on: Apr 21, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>    
     :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; version 2
 # of the License or (at your opinion) any later version of the license.
 # 
 # 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, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA  02110-1301, USA.
 
 import logging
 
 from pylons import tmpl_context as c
 
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseController, render
 from rhodecode.lib.utils import OrderedDict
 from rhodecode.model.scm import ScmModel
 
 log = logging.getLogger(__name__)
 
 class BranchesController(BaseController):
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def __before__(self):
         super(BranchesController, self).__before__()
 
     def index(self):
-        hg_model = ScmModel()
-        c.repo_info = hg_model.get_repo(c.repo_name)
+        c.repo_info, dbrepo = ScmModel().get(c.repo_name, retval='repo')
         c.repo_branches = OrderedDict()
         for name, hash_ in c.repo_info.branches.items():
             c.repo_branches[name] = c.repo_info.get_changeset(hash_)
 
         return render('branches/branches.html')

rhodecode/controllers/changelog.py

@@ -1,106 +1,106 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.changelog
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     changelog controller for rhodecode
     
     :created_on: Apr 21, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>    
     :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; version 2
 # of the License or (at your opinion) any later version of the license.
 # 
 # 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, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA  02110-1301, USA.
 
 import logging
 
 try:
     import json
 except ImportError:
     #python 2.5 compatibility
     import simplejson as json
 
 from mercurial.graphmod import colored, CHANGESET, revisions as graph_rev
 from pylons import request, session, tmpl_context as c
 
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseController, render
 from rhodecode.model.scm import ScmModel
 
 from webhelpers.paginate import Page
 
 log = logging.getLogger(__name__)
 
 class ChangelogController(BaseController):
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def __before__(self):
         super(ChangelogController, self).__before__()
 
     def index(self):
         limit = 100
         default = 20
         if request.params.get('size'):
             try:
                 int_size = int(request.params.get('size'))
             except ValueError:
                 int_size = default
             int_size = int_size if int_size <= limit else limit
             c.size = int_size
             session['changelog_size'] = c.size
             session.save()
         else:
             c.size = int(session.get('changelog_size', default))
 
-        changesets = ScmModel().get_repo(c.repo_name)
+        repo, dbrepo = ScmModel().get(c.repo_name, retval='repo')
 
         p = int(request.params.get('page', 1))
-        c.total_cs = len(changesets)
-        c.pagination = Page(changesets, page=p, item_count=c.total_cs,
+        c.total_cs = len(repo)
+        c.pagination = Page(repo, page=p, item_count=c.total_cs,
                             items_per_page=c.size)
 
-        self._graph(changesets, c.size, p)
+        self._graph(repo, c.size, p)
 
         return render('changelog/changelog.html')
 
 
     def _graph(self, repo, size, p):
         revcount = size
         if not repo.revisions or repo.alias == 'git':
             c.jsdata = json.dumps([])
             return
 
         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))
 
         c.jsdata = json.dumps(data)
 

rhodecode/controllers/changeset.py

@@ -1,218 +1,216 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.changeset
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     changeset controller for pylons showoing changes beetween 
     revisions
     
     :created_on: Apr 25, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>    
     :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; version 2
 # of the License or (at your opinion) any later version of the license.
 # 
 # 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, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA  02110-1301, USA.
 import logging
 import traceback
 
 from pylons import tmpl_context as c, url, request, response
 from pylons.i18n.translation import _
 from pylons.controllers.util import redirect
 
 import rhodecode.lib.helpers as h
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseController, render
 from rhodecode.lib.utils import EmptyChangeset
 from rhodecode.model.scm import ScmModel
 
 from vcs.exceptions import RepositoryError, ChangesetError, \
 ChangesetDoesNotExistError
 from vcs.nodes import FileNode
 from vcs.utils import diffs as differ
 from vcs.utils.ordered_dict import OrderedDict
 
 log = logging.getLogger(__name__)
 
 class ChangesetController(BaseController):
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def __before__(self):
         super(ChangesetController, self).__before__()
 
     def index(self, revision):
-        hg_model = ScmModel()
 
         def wrap_to_table(str):
 
             return '''<table class="code-difftable">
                         <tr class="line">
                         <td class="lineno new"></td>
                         <td class="code"><pre>%s</pre></td>
                         </tr>
                       </table>''' % str
 
         #get ranges of revisions if preset
         rev_range = revision.split('...')[:2]
         range_limit = 50
         try:
-            repo = hg_model.get_repo(c.repo_name)
+            repo, dbrepo = ScmModel().get(c.repo_name, retval='repo')
             if len(rev_range) == 2:
                 rev_start = rev_range[0]
                 rev_end = rev_range[1]
                 rev_ranges = repo.get_changesets_ranges(rev_start, rev_end,
                                                        range_limit)
             else:
                 rev_ranges = [repo.get_changeset(revision)]
 
             c.cs_ranges = list(rev_ranges)
 
         except (RepositoryError, ChangesetDoesNotExistError, Exception), e:
             log.error(traceback.format_exc())
             h.flash(str(e), category='warning')
             return redirect(url('home'))
 
         c.changes = OrderedDict()
         c.sum_added = 0
         c.sum_removed = 0
 
 
         for changeset in c.cs_ranges:
             c.changes[changeset.raw_id] = []
             try:
                 changeset_parent = changeset.parents[0]
             except IndexError:
                 changeset_parent = None
 
 
             #==================================================================
             # ADDED FILES
             #==================================================================
             for node in changeset.added:
                 filenode_old = FileNode(node.path, '', EmptyChangeset())
                 if filenode_old.is_binary or node.is_binary:
                     diff = wrap_to_table(_('binary file'))
                 else:
                     c.sum_added += node.size
                     if c.sum_added < self.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
                 cs2 = node.last_changeset.raw_id
                 c.changes[changeset.raw_id].append(('added', node, diff, cs1, cs2))
 
             #==================================================================
             # CHANGED FILES
             #==================================================================
             for node in changeset.changed:
                 try:
                     filenode_old = changeset_parent.get_node(node.path)
                 except ChangesetError:
                     filenode_old = FileNode(node.path, '', EmptyChangeset())
 
                 if filenode_old.is_binary or node.is_binary:
                     diff = wrap_to_table(_('binary file'))
                 else:
 
                     if c.sum_removed < self.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'))
 
 
                 cs1 = filenode_old.last_changeset.raw_id
                 cs2 = node.last_changeset.raw_id
                 c.changes[changeset.raw_id].append(('changed', node, diff, cs1, cs2))
 
             #==================================================================
             # REMOVED FILES    
             #==================================================================
             for node in changeset.removed:
                 c.changes[changeset.raw_id].append(('removed', node, None, None, None))
 
         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):
 
-        hg_model = ScmModel()
         method = request.GET.get('diff', 'show')
         try:
-            r = hg_model.get_repo(c.repo_name)
-            c.scm_type = r.alias
-            c.changeset = r.get_changeset(revision)
+            repo, dbrepo = ScmModel().get(c.repo_name, retval='repo')
+            c.scm_type = repo.alias
+            c.changeset = 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_udiff = differ.get_udiff(filenode_old, node)
                     diff = differ.DiffProcessor(f_udiff).raw_diff()
 
                 cs1 = None
                 cs2 = node.last_changeset.raw_id
                 c.changes.append(('added', node, diff, cs1, cs2))
 
             for node in c.changeset.changed:
                 filenode_old = c.changeset_parent.get_node(node.path)
                 if filenode_old.is_binary or node.is_binary:
                     diff = _('binary file')
                 else:
                     f_udiff = differ.get_udiff(filenode_old, node)
                     diff = differ.DiffProcessor(f_udiff).raw_diff()
 
                 cs1 = filenode_old.last_changeset.raw_id
                 cs2 = node.last_changeset.raw_id
                 c.changes.append(('changed', node, diff, cs1, cs2))
 
         response.content_type = 'text/plain'
 
         if method == 'download':
             response.content_disposition = 'attachment; filename=%s.patch' % revision
 
         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]
 
         return render('changeset/raw_changeset.html')

rhodecode/controllers/feed.py

@@ -1,90 +1,91 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.feed
     ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Feed controller for rhodecode
     
     :created_on: Apr 23, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>    
     :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; version 2
 # of the License or (at your opinion) any later version of the license.
 # 
 # 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, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA  02110-1301, USA.
 
 import logging
 
 from pylons import url, response
+from pylons.i18n.translation import _
 
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseController
 from rhodecode.model.scm import ScmModel
 
 from webhelpers.feedgenerator import Atom1Feed, Rss201rev2Feed
 
 log = logging.getLogger(__name__)
 
 class FeedController(BaseController):
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def __before__(self):
         super(FeedController, self).__before__()
         #common values for feeds
-        self.description = 'Changes on %s repository'
+        self.description = _('Changes on %s repository')
         self.title = "%s feed"
         self.language = 'en-us'
         self.ttl = "5"
         self.feed_nr = 10
 
     def atom(self, repo_name):
         """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 = ScmModel().get_repo(repo_name)
+        repo, dbrepo = ScmModel().get(repo_name, retval='repo')
 
-        for cs in changesets[:self.feed_nr]:
+        for cs in repo[:self.feed_nr]:
             feed.add_item(title=cs.message,
                           link=url('changeset_home', repo_name=repo_name,
                                    revision=cs.raw_id, qualified=True),
                                    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 = ScmModel().get_repo(repo_name)
-        for cs in changesets[:self.feed_nr]:
+        repo, dbrepo = ScmModel().get(repo_name, retval='repo')
+        for cs in repo[:self.feed_nr]:
             feed.add_item(title=cs.message,
                           link=url('changeset_home', repo_name=repo_name,
                                    revision=cs.raw_id, qualified=True),
                           description=str(cs.date))
 
         response.content_type = feed.mime_type
         return feed.writeString('utf-8')

rhodecode/controllers/files.py

@@ -1,271 +1,267 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.files
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Files controller for RhodeCode
     
     :created_on: Apr 21, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>    
     :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; version 2
 # of the License or (at your opinion) any later version of the license.
 # 
 # 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, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA  02110-1301, USA.
 import tempfile
 import logging
 import rhodecode.lib.helpers as h
 
 from mercurial import archival
 
 from pylons import request, response, session, tmpl_context as c, url
 from pylons.i18n.translation import _
 from pylons.controllers.util import redirect
 
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseController, render
 from rhodecode.lib.utils import EmptyChangeset
 from rhodecode.model.scm import ScmModel
 
 from vcs.backends import ARCHIVE_SPECS
 from vcs.exceptions import RepositoryError, ChangesetError, \
     ChangesetDoesNotExistError, EmptyRepositoryError, ImproperArchiveTypeError
 from vcs.nodes import FileNode
 from vcs.utils import diffs as differ
 
 log = logging.getLogger(__name__)
 
 class FilesController(BaseController):
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def __before__(self):
         super(FilesController, self).__before__()
         c.cut_off_limit = self.cut_off_limit
 
     def index(self, repo_name, revision, f_path):
-        hg_model = ScmModel()
-        c.repo = hg_model.get_repo(c.repo_name)
+        c.repo, dbrepo = ScmModel().get(c.repo_name, retval='repo')
+
 
         try:
             #reditect to given revision from form
             post_revision = request.POST.get('at_rev', None)
             if post_revision:
                 post_revision = c.repo.get_changeset(post_revision).raw_id
                 redirect(url('files_home', repo_name=c.repo_name,
                              revision=post_revision, f_path=f_path))
 
             c.branch = request.GET.get('branch', None)
 
             c.f_path = f_path
 
             c.changeset = c.repo.get_changeset(revision)
             cur_rev = c.changeset.revision
 
             #prev link
             try:
                 prev_rev = c.repo.get_changeset(cur_rev).prev(c.branch).raw_id
                 c.url_prev = url('files_home', repo_name=c.repo_name,
                              revision=prev_rev, f_path=f_path)
                 if c.branch:
                     c.url_prev += '?branch=%s' % c.branch
             except ChangesetDoesNotExistError:
                 c.url_prev = '#'
 
             #next link
             try:
                 next_rev = c.repo.get_changeset(cur_rev).next(c.branch).raw_id
                 c.url_next = url('files_home', repo_name=c.repo_name,
                          revision=next_rev, f_path=f_path)
                 if c.branch:
                     c.url_next += '?branch=%s' % c.branch
             except ChangesetDoesNotExistError:
                 c.url_next = '#'
 
             #files
             try:
                 c.files_list = c.changeset.get_node(f_path)
                 c.file_history = self._get_history(c.repo, c.files_list, f_path)
             except RepositoryError, e:
                 h.flash(str(e), category='warning')
                 redirect(h.url('files_home', repo_name=repo_name, revision=revision))
 
         except EmptyRepositoryError, e:
             h.flash(_('There are no files yet'), category='warning')
             redirect(h.url('summary_home', repo_name=repo_name))
 
         except RepositoryError, e:
             h.flash(str(e), category='warning')
             redirect(h.url('files_home', repo_name=repo_name, revision='tip'))
 
 
 
         return render('files/files.html')
 
     def rawfile(self, repo_name, revision, f_path):
-        hg_model = ScmModel()
-        c.repo = hg_model.get_repo(c.repo_name)
+        c.repo, dbrepo = ScmModel().get(c.repo_name, retval='repo')
         file_node = c.repo.get_changeset(revision).get_node(f_path)
         response.content_type = file_node.mimetype
         response.content_disposition = 'attachment; filename=%s' \
                                                     % f_path.split('/')[-1]
         return file_node.content
 
     def raw(self, repo_name, revision, f_path):
-        hg_model = ScmModel()
-        c.repo = hg_model.get_repo(c.repo_name)
+        c.repo, dbrepo = ScmModel().get(c.repo_name, retval='repo')
         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 = ScmModel()
-        c.repo = hg_model.get_repo(c.repo_name)
+        c.repo, dbrepo = ScmModel().get(c.repo_name, retval='repo')
 
         try:
             c.cs = c.repo.get_changeset(revision)
             c.file = c.cs.get_node(f_path)
         except RepositoryError, e:
             h.flash(str(e), category='warning')
             redirect(h.url('files_home', repo_name=repo_name, revision=revision))
 
         c.file_history = self._get_history(c.repo, c.file, f_path)
 
         c.f_path = f_path
 
         return render('files/files_annotate.html')
 
     def archivefile(self, repo_name, fname):
 
         fileformat = None
         revision = None
         ext = None
 
         for a_type, ext_data in ARCHIVE_SPECS.items():
             archive_spec = fname.split(ext_data[1])
             if len(archive_spec) == 2 and archive_spec[1] == '':
                 fileformat = a_type or ext_data[1]
                 revision = archive_spec[0]
                 ext = ext_data[1]
 
         try:
-            repo = ScmModel().get_repo(repo_name)
+            repo, dbrepo = ScmModel().get(repo_name)
 
-            if repo.dbrepo.enable_downloads is False:
+            if dbrepo.enable_downloads is False:
                 return _('downloads disabled')
 
             cs = repo.get_changeset(revision)
             content_type = ARCHIVE_SPECS[fileformat][0]
         except ChangesetDoesNotExistError:
             return _('Unknown revision %s') % revision
         except EmptyRepositoryError:
             return _('Empty repository')
         except (ImproperArchiveTypeError, KeyError):
             return _('Unknown archive type')
 
         response.content_type = content_type
         response.content_disposition = 'attachment; filename=%s-%s%s' \
             % (repo_name, revision, ext)
 
         return cs.get_chunked_archive(kind=fileformat)
 
 
     def diff(self, repo_name, f_path):
-        hg_model = ScmModel()
         diff1 = request.GET.get('diff1')
         diff2 = request.GET.get('diff2')
         c.action = request.GET.get('diff')
         c.no_changes = diff1 == diff2
         c.f_path = f_path
-        c.repo = hg_model.get_repo(c.repo_name)
+        c.repo, dbrepo = ScmModel().get(c.repo_name, retval='repo')
 
         try:
             if diff1 not in ['', None, 'None', '0' * 12, '0' * 40]:
                 c.changeset_1 = c.repo.get_changeset(diff1)
                 node1 = c.changeset_1.get_node(f_path)
             else:
                 c.changeset_1 = EmptyChangeset()
                 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':
             response.content_type = 'text/plain'
             return diff.raw_diff()
 
         elif c.action == 'diff':
             if node1.size > self.cut_off_limit or node2.size > self.cut_off_limit:
                 c.cur_diff = _('Diff is to big to display')
             else:
                 c.cur_diff = diff.as_html()
         else:
             #default option
             if node1.size > self.cut_off_limit or node2.size > self.cut_off_limit:
                 c.cur_diff = _('Diff is to big to display')
             else:
                 c.cur_diff = diff.as_html()
 
         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 = []
 
         changesets_group = ([], _("Changesets"))
         branches_group = ([], _("Branches"))
         tags_group = ([], _("Tags"))
 
         for chs in changesets:
             n_desc = 'r%s:%s' % (chs.revision, chs.short_id)
             changesets_group[0].append((chs.raw_id, n_desc,))
 
         hist_l.append(changesets_group)
 
         for name, chs in c.repository_branches.items():
             #chs = chs.split(':')[-1]
             branches_group[0].append((chs, name),)
         hist_l.append(branches_group)
 
         for name, chs in c.repository_tags.items():
             #chs = chs.split(':')[-1]
             tags_group[0].append((chs, name),)
         hist_l.append(tags_group)
 
         return hist_l
 

rhodecode/controllers/shortlog.py

@@ -1,56 +1,56 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.shortlog
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Shortlog controller for rhodecode
     
     :created_on: Apr 18, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>    
     :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; version 2
 # of the License or (at your opinion) any later version of the license.
 # 
 # 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, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA  02110-1301, USA.
 
 import logging
 
 from pylons import tmpl_context as c, request
 
 from webhelpers.paginate import Page
 
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseController, render
 from rhodecode.model.scm import ScmModel
 
 log = logging.getLogger(__name__)
 
 class ShortlogController(BaseController):
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def __before__(self):
         super(ShortlogController, self).__before__()
 
     def index(self):
         p = int(request.params.get('page', 1))
-        repo = ScmModel().get_repo(c.repo_name)
+        repo, dbrepo = ScmModel().get(c.repo_name, 'repo')
         c.repo_changesets = Page(repo, page=p, items_per_page=20)
         c.shortlog_data = render('shortlog/shortlog_data.html')
         if request.params.get('partial'):
             return c.shortlog_data
         r = render('shortlog/shortlog.html')
         return r

rhodecode/controllers/summary.py

@@ -1,170 +1,171 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.summary
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Summary controller for Rhodecode
     
     :created_on: Apr 18, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>    
     :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; version 2
 # of the License or (at your opinion) any later version of the license.
 # 
 # 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, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA  02110-1301, USA.
 
 import calendar
 import logging
 from time import mktime
 from datetime import datetime, timedelta, date
 
 from vcs.exceptions import ChangesetError
 
 from pylons import tmpl_context as c, request, url
 from pylons.i18n.translation import _
 
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.db import Statistics
 
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseController, render
 from rhodecode.lib.utils import OrderedDict, EmptyChangeset
 
 from rhodecode.lib.celerylib import run_task
 from rhodecode.lib.celerylib.tasks import get_commits_stats
 
 from webhelpers.paginate import Page
 
 try:
     import json
 except ImportError:
     #python 2.5 compatibility
     import simplejson as json
 log = logging.getLogger(__name__)
 
 class SummaryController(BaseController):
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def __before__(self):
         super(SummaryController, self).__before__()
 
     def index(self):
         scm_model = ScmModel()
-        c.repo_info = scm_model.get_repo(c.repo_name)
+        c.repo, dbrepo = scm_model.get(c.repo_name)
+        c.dbrepo = dbrepo
         c.following = scm_model.is_following_repo(c.repo_name,
                                              c.rhodecode_user.user_id)
         def url_generator(**kw):
             return url('shortlog_home', repo_name=c.repo_name, **kw)
 
-        c.repo_changesets = Page(c.repo_info, page=1, items_per_page=10,
+        c.repo_changesets = Page(c.repo, page=1, items_per_page=10,
                                  url=url_generator)
 
         e = request.environ
 
         if self.rhodecode_user.username == 'default':
             #for default(anonymous) user we don't need to pass credentials
             username = ''
             password = ''
         else:
             username = str(c.rhodecode_user.username)
             password = '@'
 
         uri = u'%(protocol)s://%(user)s%(password)s%(host)s%(prefix)s/%(repo_name)s' % {
                                         'protocol': e.get('wsgi.url_scheme'),
                                         'user':username,
                                         'password':password,
                                         'host':e.get('HTTP_HOST'),
                                         'prefix':e.get('SCRIPT_NAME'),
                                         'repo_name':c.repo_name, }
         c.clone_repo_url = uri
         c.repo_tags = OrderedDict()
-        for name, hash in c.repo_info.tags.items()[:10]:
+        for name, hash in c.repo.tags.items()[:10]:
             try:
-                c.repo_tags[name] = c.repo_info.get_changeset(hash)
+                c.repo_tags[name] = c.repo.get_changeset(hash)
             except ChangesetError:
                 c.repo_tags[name] = EmptyChangeset(hash)
 
         c.repo_branches = OrderedDict()
-        for name, hash in c.repo_info.branches.items()[:10]:
+        for name, hash in c.repo.branches.items()[:10]:
             try:
-                c.repo_branches[name] = c.repo_info.get_changeset(hash)
+                c.repo_branches[name] = c.repo.get_changeset(hash)
             except ChangesetError:
                 c.repo_branches[name] = EmptyChangeset(hash)
 
         td = date.today() + timedelta(days=1)
         td_1m = td - timedelta(days=calendar.mdays[td.month])
         td_1y = td - timedelta(days=365)
 
         ts_min_m = mktime(td_1m.timetuple())
         ts_min_y = mktime(td_1y.timetuple())
         ts_max_y = mktime(td.timetuple())
 
-        if c.repo_info.dbrepo.enable_statistics:
+        if dbrepo.enable_statistics:
             c.no_data_msg = _('No data loaded yet')
-            run_task(get_commits_stats, c.repo_info.name, ts_min_y, ts_max_y)
+            run_task(get_commits_stats, c.repo.name, ts_min_y, ts_max_y)
         else:
             c.no_data_msg = _('Statistics update are disabled for this repository')
         c.ts_min = ts_min_m
         c.ts_max = ts_max_y
 
         stats = self.sa.query(Statistics)\
-            .filter(Statistics.repository == c.repo_info.dbrepo)\
+            .filter(Statistics.repository == dbrepo)\
             .scalar()
 
 
         if stats and stats.languages:
-            c.no_data = False is c.repo_info.dbrepo.enable_statistics
+            c.no_data = False is dbrepo.enable_statistics
             lang_stats = json.loads(stats.languages)
             c.commit_data = stats.commit_activity
             c.overview_data = stats.commit_activity_combined
             c.trending_languages = json.dumps(OrderedDict(
                                        sorted(lang_stats.items(), reverse=True,
                                             key=lambda k: k[1])[:10]
                                         )
                                     )
         else:
             c.commit_data = json.dumps({})
             c.overview_data = json.dumps([[ts_min_y, 0], [ts_max_y, 10] ])
             c.trending_languages = json.dumps({})
             c.no_data = True
 
-        c.enable_downloads = c.repo_info.dbrepo.enable_downloads
+        c.enable_downloads = dbrepo.enable_downloads
         if c.enable_downloads:
-            c.download_options = self._get_download_links(c.repo_info)
+            c.download_options = self._get_download_links(c.repo)
 
         return render('summary/summary.html')
 
 
 
     def _get_download_links(self, repo):
 
         download_l = []
 
         branches_group = ([], _("Branches"))
         tags_group = ([], _("Tags"))
 
         for name, chs in c.repository_branches.items():
             #chs = chs.split(':')[-1]
             branches_group[0].append((chs, name),)
         download_l.append(branches_group)
 
         for name, chs in c.repository_tags.items():
             #chs = chs.split(':')[-1]
             tags_group[0].append((chs, name),)
         download_l.append(tags_group)
 
         return download_l

rhodecode/controllers/tags.py

@@ -1,53 +1,52 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.tags
     ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Tags controller for rhodecode
     
     :created_on: Apr 21, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>    
     :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; version 2
 # of the License or (at your opinion) any later version of the license.
 # 
 # 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, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA  02110-1301, USA.
 import logging
 
 from pylons import tmpl_context as c
 
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseController, render
 from rhodecode.lib.utils import OrderedDict
 from rhodecode.model.scm import ScmModel
 
 log = logging.getLogger(__name__)
 
 class TagsController(BaseController):
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def __before__(self):
         super(TagsController, self).__before__()
 
     def index(self):
-        hg_model = ScmModel()
-        c.repo_info = hg_model.get_repo(c.repo_name)
+        c.repo_info, dbrepo = ScmModel().get(c.repo_name, retval='repo')
         c.repo_tags = OrderedDict()
         for name, hash_ in c.repo_info.tags.items():
             c.repo_tags[name] = c.repo_info.get_changeset(hash_)
 
         return render('tags/tags.html')

rhodecode/lib/base.py

@@ -1,54 +1,54 b''
 """The base Controller API
 
 Provides the BaseController class for subclassing.
 """
 from pylons import config, tmpl_context as c, request, session
 from pylons.controllers import WSGIController
 from pylons.templating import render_mako as render
 from rhodecode import __version__
 from rhodecode.lib import auth
 from rhodecode.lib.utils import get_repo_slug
 from rhodecode.model import meta
 from rhodecode.model.scm import ScmModel
 from rhodecode import BACKENDS
 
 class BaseController(WSGIController):
 
     def __before__(self):
         c.rhodecode_version = __version__
         c.rhodecode_name = config.get('rhodecode_title')
         c.ga_code = config.get('rhodecode_ga_code')
         c.repo_name = get_repo_slug(request)
         c.backends = BACKENDS.keys()
         self.cut_off_limit = int(config.get('cut_off_limit'))
 
         self.sa = meta.Session()
         scm_model = ScmModel(self.sa)
         c.cached_repo_list = scm_model.get_repos()
         #c.unread_journal = scm_model.get_unread_journal()
 
         if c.repo_name:
-            cached_repo = scm_model.get(c.repo_name)
-            if cached_repo:
-                c.repository_tags = cached_repo.tags
-                c.repository_branches = cached_repo.branches
-                c.repository_followers = scm_model.get_followers(cached_repo.dbrepo.repo_id)
-                c.repository_forks = scm_model.get_forks(cached_repo.dbrepo.repo_id)
+            repo, dbrepo = scm_model.get(c.repo_name)
+            if repo:
+                c.repository_tags = repo.tags
+                c.repository_branches = repo.branches
+                c.repository_followers = scm_model.get_followers(dbrepo.repo_id)
+                c.repository_forks = scm_model.get_forks(dbrepo.repo_id)
             else:
                 c.repository_tags = {}
                 c.repository_branches = {}
                 c.repository_followers = 0
                 c.repository_forks = 0
 
 
     def __call__(self, environ, start_response):
         """Invoke the Controller"""
         # WSGIController.__call__ dispatches to the Controller method
         # the request is routed to. This routing information is
         # available in environ['pylons.routes_dict']
         try:
             #putting this here makes sure that we update permissions every time
             self.rhodecode_user = c.rhodecode_user = auth.get_user(session)
             return WSGIController.__call__(self, environ, start_response)
         finally:
             meta.Session.remove()

rhodecode/lib/helpers.py

@@ -1,591 +1,591 b''
 """Helper functions
 
 Consists of functions to typically be used within templates, but also
 available to Controllers. This module is available to both as 'h'.
 """
 import random
 import hashlib
 import StringIO
 from pygments.formatters import HtmlFormatter
 from pygments import highlight as code_highlight
 from pylons import url
 from pylons.i18n.translation import _, ungettext
 from vcs.utils.annotate import annotate_highlight
 from rhodecode.lib.utils import repo_name_slug
 
 from webhelpers.html import literal, HTML, escape
 from webhelpers.html.tools import *
 from webhelpers.html.builder import make_tag
 from webhelpers.html.tags import auto_discovery_link, checkbox, css_classes, \
     end_form, file, form, hidden, image, javascript_link, link_to, link_to_if, \
     link_to_unless, ol, required_legend, select, stylesheet_link, submit, text, \
     password, textarea, title, ul, xml_declaration, radio
 from webhelpers.html.tools import auto_link, button_to, highlight, js_obfuscate, \
     mail_to, strip_links, strip_tags, tag_re
 from webhelpers.number import format_byte_size, format_bit_size
 from webhelpers.pylonslib import Flash as _Flash
 from webhelpers.pylonslib.secure_form import secure_form
 from webhelpers.text import chop_at, collapse, convert_accented_entities, \
     convert_misc_entities, lchop, plural, rchop, remove_formatting, \
     replace_whitespace, urlify, truncate, wrap_paragraphs
 from webhelpers.date import time_ago_in_words
 
 from webhelpers.html.tags import _set_input_attrs, _set_id_attr, \
     convert_boolean_attrs, NotGiven
 
 def _reset(name, value=None, id=NotGiven, type="reset", **attrs):
     """Reset button
     """
     _set_input_attrs(attrs, type, name, value)
     _set_id_attr(attrs, id, name)
     convert_boolean_attrs(attrs, ["disabled"])
     return HTML.input(**attrs)
 
 reset = _reset
 
 
 def get_token():
     """Return the current authentication token, creating one if one doesn't
     already exist.
     """
     token_key = "_authentication_token"
     from pylons import session
     if not token_key in session:
         try:
             token = hashlib.sha1(str(random.getrandbits(128))).hexdigest()
         except AttributeError: # Python < 2.4
             token = hashlib.sha1(str(random.randrange(2 ** 128))).hexdigest()
         session[token_key] = token
         if hasattr(session, 'save'):
             session.save()
     return session[token_key]
 
 class _GetError(object):
     """Get error from form_errors, and represent it as span wrapped error
     message
     
     :param field_name: field to fetch errors for
     :param form_errors: form errors dict
     """
 
     def __call__(self, field_name, form_errors):
         tmpl = """<span class="error_msg">%s</span>"""
         if form_errors and form_errors.has_key(field_name):
             return literal(tmpl % form_errors.get(field_name))
 
 get_error = _GetError()
 
 class _ToolTip(object):
 
     def __call__(self, tooltip_title, trim_at=50):
         """Special function just to wrap our text into nice formatted 
         autowrapped text
         
         :param tooltip_title:
         """
 
         return wrap_paragraphs(escape(tooltip_title), trim_at)\
                        .replace('\n', '<br/>')
 
     def activate(self):
         """Adds tooltip mechanism to the given Html all tooltips have to have 
         set class `tooltip` and set attribute `tooltip_title`.
         Then a tooltip will be generated based on that. All with yui js tooltip
         """
 
         js = '''
         YAHOO.util.Event.onDOMReady(function(){
             function toolTipsId(){
                 var ids = [];
                 var tts = YAHOO.util.Dom.getElementsByClassName('tooltip');
                 
                 for (var i = 0; i < tts.length; i++) {
                     //if element doesn't not have and id autogenerate one for tooltip
                     
                     if (!tts[i].id){
                         tts[i].id='tt'+i*100;
                     }
                     ids.push(tts[i].id);
                 }
                 return ids        
             };
             var myToolTips = new YAHOO.widget.Tooltip("tooltip", { 
                 context: toolTipsId(),
                 monitorresize:false,
                 xyoffset :[0,0],
                 autodismissdelay:300000,
                 hidedelay:5,
                 showdelay:20,
             });
             
             // Set the text for the tooltip just before we display it. Lazy method
             myToolTips.contextTriggerEvent.subscribe( 
                  function(type, args) { 
 
                         var context = args[0]; 
                         
                         //positioning of tooltip
                         var tt_w = this.element.clientWidth;//tooltip width
                         var tt_h = this.element.clientHeight;//tooltip height
                         
                         var context_w = context.offsetWidth;
                         var context_h = context.offsetHeight;
                         
                         var pos_x = YAHOO.util.Dom.getX(context);
                         var pos_y = YAHOO.util.Dom.getY(context);
 
                         var display_strategy = 'right';
                         var xy_pos = [0,0];
                         switch (display_strategy){
                         
                             case 'top':
                                 var cur_x = (pos_x+context_w/2)-(tt_w/2);
                                 var cur_y = (pos_y-tt_h-4);
                                 xy_pos = [cur_x,cur_y];                                
                                 break;
                             case 'bottom':
                                 var cur_x = (pos_x+context_w/2)-(tt_w/2);
                                 var cur_y = pos_y+context_h+4;
                                 xy_pos = [cur_x,cur_y];                                
                                 break;
                             case 'left':
                                 var cur_x = (pos_x-tt_w-4);
                                 var cur_y = pos_y-((tt_h/2)-context_h/2);
                                 xy_pos = [cur_x,cur_y];                                
                                 break;
                             case 'right':
                                 var cur_x = (pos_x+context_w+4);
                                 var cur_y = pos_y-((tt_h/2)-context_h/2);
                                 xy_pos = [cur_x,cur_y];                                
                                 break;
                              default:
                                 var cur_x = (pos_x+context_w/2)-(tt_w/2);
                                 var cur_y = pos_y-tt_h-4;
                                 xy_pos = [cur_x,cur_y];                                
                                 break;                             
                                  
                         }
 
                         this.cfg.setProperty("xy",xy_pos);
 
                   });
                   
             //Mouse out 
             myToolTips.contextMouseOutEvent.subscribe(
                 function(type, args) {
                     var context = args[0];
                     
                 });
         });
         '''
         return literal(js)
 
 tooltip = _ToolTip()
 
 class _FilesBreadCrumbs(object):
 
     def __call__(self, repo_name, rev, paths):
         if isinstance(paths, str):
             paths = paths.decode('utf-8')
         url_l = [link_to(repo_name, url('files_home',
                                         repo_name=repo_name,
                                         revision=rev, f_path=''))]
         paths_l = paths.split('/')
         for cnt, p in enumerate(paths_l):
             if p != '':
                 url_l.append(link_to(p, url('files_home',
                                             repo_name=repo_name,
                                             revision=rev,
                                             f_path='/'.join(paths_l[:cnt + 1]))))
 
         return literal('/'.join(url_l))
 
 files_breadcrumbs = _FilesBreadCrumbs()
 
 class CodeHtmlFormatter(HtmlFormatter):
     """My code Html Formatter for source codes
     """
 
     def wrap(self, source, outfile):
         return self._wrap_div(self._wrap_pre(self._wrap_code(source)))
 
     def _wrap_code(self, source):
         for cnt, it in enumerate(source):
             i, t = it
             t = '<div id="L%s">%s</div>' % (cnt + 1, t)
             yield i, t
 
     def _wrap_tablelinenos(self, inner):
         dummyoutfile = StringIO.StringIO()
         lncount = 0
         for t, line in inner:
             if t:
                 lncount += 1
             dummyoutfile.write(line)
 
         fl = self.linenostart
         mw = len(str(lncount + fl - 1))
         sp = self.linenospecial
         st = self.linenostep
         la = self.lineanchors
         aln = self.anchorlinenos
         nocls = self.noclasses
         if sp:
             lines = []
 
             for i in range(fl, fl + lncount):
                 if i % st == 0:
                     if i % sp == 0:
                         if aln:
                             lines.append('<a href="#%s%d" class="special">%*d</a>' %
                                          (la, i, mw, i))
                         else:
                             lines.append('<span class="special">%*d</span>' % (mw, i))
                     else:
                         if aln:
                             lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))
                         else:
                             lines.append('%*d' % (mw, i))
                 else:
                     lines.append('')
             ls = '\n'.join(lines)
         else:
             lines = []
             for i in range(fl, fl + lncount):
                 if i % st == 0:
                     if aln:
                         lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))
                     else:
                         lines.append('%*d' % (mw, i))
                 else:
                     lines.append('')
             ls = '\n'.join(lines)
 
         # in case you wonder about the seemingly redundant <div> here: since the
         # content in the other cell also is wrapped in a div, some browsers in
         # some configurations seem to mess up the formatting...
         if nocls:
             yield 0, ('<table class="%stable">' % self.cssclass +
                       '<tr><td><div class="linenodiv" '
                       'style="background-color: #f0f0f0; padding-right: 10px">'
                       '<pre style="line-height: 125%">' +
                       ls + '</pre></div></td><td class="code">')
         else:
             yield 0, ('<table class="%stable">' % self.cssclass +
                       '<tr><td class="linenos"><div class="linenodiv"><pre>' +
                       ls + '</pre></div></td><td class="code">')
         yield 0, dummyoutfile.getvalue()
         yield 0, '</td></tr></table>'
 
 
 def pygmentize(filenode, **kwargs):
     """pygmentize function using pygments
     
     :param filenode:
     """
 
     return literal(code_highlight(filenode.content,
                                   filenode.lexer, CodeHtmlFormatter(**kwargs)))
 
 def pygmentize_annotation(filenode, **kwargs):
     """pygmentize function for annotation
     
     :param filenode:
     """
 
     color_dict = {}
     def gen_color(n=10000):
         """generator for getting n of evenly distributed colors using 
         hsv color and golden ratio. It always return same order of colors
         
         :returns: RGB tuple
         """
         import colorsys
         golden_ratio = 0.618033988749895
         h = 0.22717784590367374
 
         for c in xrange(n):
             h += golden_ratio
             h %= 1
             HSV_tuple = [h, 0.95, 0.95]
             RGB_tuple = colorsys.hsv_to_rgb(*HSV_tuple)
             yield map(lambda x:str(int(x * 256)), RGB_tuple)
 
     cgenerator = gen_color()
 
     def get_color_string(cs):
         if color_dict.has_key(cs):
             col = color_dict[cs]
         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 = '%5s:%s' % ('r%s' % changeset.revision,
                                  short_id(changeset.raw_id))
         uri = link_to(
                 lnk_format,
                 url('changeset_home', repo_name=changeset.repository.name,
                     revision=changeset.raw_id),
                 style=get_color_string(changeset.raw_id),
                 class_='tooltip',
                 title=tooltip_html
               )
 
         uri += '\n'
         return uri
     return literal(annotate_highlight(filenode, url_func, **kwargs))
 
 def get_changeset_safe(repo, rev):
     from vcs.backends.base import BaseRepository
     from vcs.exceptions import RepositoryError
     if not isinstance(repo, BaseRepository):
         raise Exception('You must pass an Repository '
                         'object as first argument got %s', type(repo))
 
     try:
         cs = repo.get_changeset(rev)
     except RepositoryError:
         from rhodecode.lib.utils import EmptyChangeset
         cs = EmptyChangeset()
     return cs
 
 
 def is_following_repo(repo_name, user_id):
     from rhodecode.model.scm import ScmModel
     return ScmModel().is_following_repo(repo_name, user_id)
 
 flash = _Flash()
 
 
 #==============================================================================
 # MERCURIAL FILTERS available via h.
 #==============================================================================
 from mercurial import util
 from mercurial.templatefilters import person as _person
 
 def _age(curdate):
     """turns a datetime into an age string."""
 
     if not curdate:
         return ''
 
     from datetime import timedelta, datetime
 
     agescales = [("year", 3600 * 24 * 365),
                  ("month", 3600 * 24 * 30),
                  ("day", 3600 * 24),
                  ("hour", 3600),
                  ("minute", 60),
                  ("second", 1), ]
 
     age = datetime.now() - curdate
     age_seconds = (age.days * agescales[2][1]) + age.seconds
     pos = 1
     for scale in agescales:
         if scale[1] <= age_seconds:
             if pos == 6:pos = 5
             return time_ago_in_words(curdate, agescales[pos][0]) + ' ' + _('ago')
         pos += 1
 
     return _('just now')
 
 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)
 short_id = lambda x: x[:12]
 
 
 def bool2icon(value):
     """Returns True/False values represented as small html image of true/false
     icons
     
     :param value: bool value
     """
 
     if value is True:
         return HTML.tag('img', src="/images/icons/accept.png", alt=_('True'))
 
     if value is False:
         return HTML.tag('img', src="/images/icons/cancel.png", alt=_('False'))
 
     return value
 
 
 def action_parser(user_log):
     """This helper will map the specified string action into translated
     fancy names with icons and links
     
     :param user_log: user log instance
     """
 
     action = user_log.action
     action_params = ' '
 
     x = action.split(':')
 
     if len(x) > 1:
         action, action_params = x
 
     def get_cs_links():
         revs_limit = 5 #display this amount always
         revs_top_limit = 50 #show upto this amount of changesets hidden
         revs = action_params.split(',')
         repo_name = user_log.repository.repo_name
         from rhodecode.model.scm import ScmModel
 
         message = lambda rev: get_changeset_safe(ScmModel().get(repo_name),
                                                  rev).message
 
         cs_links = " " + ', '.join ([link_to(rev,
                 url('changeset_home',
                 repo_name=repo_name,
                 revision=rev), title=tooltip(message(rev)),
                 class_='tooltip') 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[0], revs[-1])),
                                     url('changeset_home', repo_name=repo_name,
                                         revision='%s...%s' % (revs[0], revs[-1])
                                     ),
                                     _('compare view'))
                         )
 
         if len(revs) > revs_limit:
             uniq_id = revs[0]
             html_tmpl = ('<span> %s '
             '<a class="show_more" id="_%s" href="#more">%s</a> '
             '%s</span>')
             cs_links += html_tmpl % (_('and'), uniq_id, _('%s more') \
                                         % (len(revs) - revs_limit),
                                         _('revisions'))
 
             html_tmpl = '<span id="%s" style="display:none"> %s </span>'
             cs_links += html_tmpl % (uniq_id, ', '.join([link_to(rev,
                 url('changeset_home',
                 repo_name=repo_name, revision=rev),
                 title=message(rev), class_='tooltip')
                 for rev in revs[revs_limit:revs_top_limit]]))
         if len(revs) > 1:
             cs_links += compare_view
         return cs_links
 
     def get_fork_name():
         from rhodecode.model.scm import ScmModel
         repo_name = action_params
-        repo = ScmModel().get(repo_name)
+        repo, dbrepo = ScmModel().get(repo_name)
         if repo is None:
             return repo_name
         return link_to(action_params, url('summary_home',
                                           repo_name=repo.name,),
-                                          title=repo.dbrepo.description)
+                                          title=dbrepo.description)
 
     map = {'user_deleted_repo':(_('User [deleted] repository'), None),
            'user_created_repo':(_('User [created] repository'), None),
            'user_forked_repo':(_('User [forked] repository as:'), get_fork_name),
            'user_updated_repo':(_('User [updated] repository'), None),
            'admin_deleted_repo':(_('Admin [delete] repository'), None),
            'admin_created_repo':(_('Admin [created] repository'), None),
            'admin_forked_repo':(_('Admin [forked] repository'), None),
            'admin_updated_repo':(_('Admin [updated] repository'), None),
            'push':(_('[Pushed]'), get_cs_links),
            'pull':(_('[Pulled]'), None),
            'started_following_repo':(_('User [started following] repository'), None),
            'stopped_following_repo':(_('User [stopped following] repository'), None),
             }
 
     action_str = map.get(action, action)
     action = action_str[0].replace('[', '<span class="journal_highlight">')\
                    .replace(']', '</span>')
     if action_str[1] is not None:
         action = action + " " + action_str[1]()
 
     return literal(action)
 
 def action_parser_icon(user_log):
     action = user_log.action
     action_params = None
     x = action.split(':')
 
     if len(x) > 1:
         action, action_params = x
 
     tmpl = """<img src="/images/icons/%s" alt="%s"/>"""
     map = {'user_deleted_repo':'database_delete.png',
            'user_created_repo':'database_add.png',
            'user_forked_repo':'arrow_divide.png',
            'user_updated_repo':'database_edit.png',
            'admin_deleted_repo':'database_delete.png',
            'admin_created_repo':'database_add.png',
            'admin_forked_repo':'arrow_divide.png',
            'admin_updated_repo':'database_edit.png',
            'push':'script_add.png',
            'pull':'down_16.png',
            'started_following_repo':'heart_add.png',
            'stopped_following_repo':'heart_delete.png',
             }
     return literal(tmpl % (map.get(action, action), action))
 
 
 #==============================================================================
 # PERMS
 #==============================================================================
 from rhodecode.lib.auth import HasPermissionAny, HasPermissionAll, \
 HasRepoPermissionAny, HasRepoPermissionAll
 
 #==============================================================================
 # GRAVATAR URL
 #==============================================================================
 import hashlib
 import urllib
 from pylons import request
 
 def gravatar_url(email_address, size=30):
     ssl_enabled = 'https' == request.environ.get('wsgi.url_scheme')
     default = 'identicon'
     baseurl_nossl = "http://www.gravatar.com/avatar/"
     baseurl_ssl = "https://secure.gravatar.com/avatar/"
     baseurl = baseurl_ssl if ssl_enabled else baseurl_nossl
 
 
     # construct the url
     gravatar_url = baseurl + hashlib.md5(email_address.lower()).hexdigest() + "?"
     gravatar_url += urllib.urlencode({'d':default, 's':str(size)})
 
     return gravatar_url
 
 def safe_unicode(str):
     """safe unicode function. In case of UnicodeDecode error we try to return
     unicode with errors replace, if this failes we return unicode with 
     string_escape decoding """
 
     try:
         u_str = unicode(str)
     except UnicodeDecodeError:
         try:
             u_str = unicode(str, 'utf-8', 'replace')
         except UnicodeDecodeError:
             #incase we have a decode error just represent as byte string
             u_str = unicode(str(str).encode('string_escape'))
 
     return u_str
 
 def changed_tooltip(nodes):
     if nodes:
         pref = ': <br/> '
         suf = ''
         if len(nodes) > 30:
             suf = '<br/>' + _(' and %s more') % (len(nodes) - 30)
         return literal(pref + '<br/> '.join([x.path for x in nodes[:30]]) + suf)
     else:
         return ': ' + _('No Files')

rhodecode/model/repo.py

@@ -1,342 +1,342 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.model.repo
     ~~~~~~~~~~~~~~~~~~~~
 
     Repository model for rhodecode
     
     :created_on: Jun 5, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>    
     :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; version 2
 # of the License or (at your opinion) any later version of the license.
 # 
 # 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, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA  02110-1301, USA.
 import os
 import shutil
 import logging
 import traceback
 from datetime import datetime
 
 from sqlalchemy.orm import joinedload
 
 from vcs.utils.lazy import LazyProperty
 from vcs.backends import get_backend
 
 from rhodecode.model import BaseModel
 from rhodecode.model.caching_query import FromCache
 from rhodecode.model.db import Repository, RepoToPerm, User, Permission, \
     Statistics, UsersGroup, UsersGroupToPerm, RhodeCodeUi
 from rhodecode.model.user import UserModel
 from rhodecode.model.users_group import UsersGroupMember, UsersGroupModel
 
 
 log = logging.getLogger(__name__)
 
 class RepoModel(BaseModel):
 
     @LazyProperty
     def repos_path(self):
         """Get's the repositories root path from database
         """
 
         q = self.sa.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/').one()
         return q.ui_value
 
     def get(self, repo_id, cache=False):
         repo = self.sa.query(Repository)\
             .filter(Repository.repo_id == repo_id)
 
         if cache:
             repo = repo.options(FromCache("sql_cache_short",
                                           "get_repo_%s" % repo_id))
         return repo.scalar()
 
 
     def get_by_repo_name(self, repo_name, cache=False):
         repo = self.sa.query(Repository)\
             .filter(Repository.repo_name == repo_name)
 
         if cache:
             repo = repo.options(FromCache("sql_cache_short",
                                           "get_repo_%s" % repo_name))
         return repo.scalar()
 
 
     def get_full(self, repo_name, cache=False, invalidate=False):
         repo = self.sa.query(Repository)\
             .options(joinedload(Repository.fork))\
             .options(joinedload(Repository.user))\
             .options(joinedload(Repository.followers))\
             .options(joinedload(Repository.repo_to_perm))\
             .options(joinedload(Repository.users_group_to_perm))\
             .filter(Repository.repo_name == repo_name)\
 
         if cache:
             repo = repo.options(FromCache("sql_cache_long",
                                           "get_repo_full_%s" % repo_name))
-        if invalidate:
+        if invalidate and cache:
             repo.invalidate()
 
         return repo.scalar()
 
 
     def get_users_js(self):
 
         users = self.sa.query(User).filter(User.active == True).all()
         u_tmpl = '''{id:%s, fname:"%s", lname:"%s", nname:"%s"},'''
         users_array = '[%s]' % '\n'.join([u_tmpl % (u.user_id, u.name,
                                                     u.lastname, u.username)
                                         for u in users])
         return users_array
 
 
     def get_users_groups_js(self):
         users_groups = self.sa.query(UsersGroup)\
             .filter(UsersGroup.users_group_active == True).all()
 
         g_tmpl = '''{id:%s, grname:"%s",grmembers:"%s"},'''
 
         users_groups_array = '[%s]' % '\n'.join([g_tmpl % \
                                     (gr.users_group_id, gr.users_group_name,
                                      len(gr.members))
                                         for gr in users_groups])
         return users_groups_array
 
     def update(self, repo_name, form_data):
         try:
             cur_repo = self.get_by_repo_name(repo_name, cache=False)
             user_model = UserModel(self.sa)
             users_group_model = UsersGroupModel(self.sa)
 
             #update permissions
             for member, perm, member_type in form_data['perms_updates']:
                 if member_type == 'user':
                     r2p = self.sa.query(RepoToPerm)\
                             .filter(RepoToPerm.user == user_model.get_by_username(member))\
                             .filter(RepoToPerm.repository == cur_repo)\
                             .one()
 
                     r2p.permission = self.sa.query(Permission)\
                                         .filter(Permission.permission_name == perm)\
                                         .scalar()
                     self.sa.add(r2p)
                 else:
                     g2p = self.sa.query(UsersGroupToPerm)\
                             .filter(UsersGroupToPerm.users_group == users_group_model.get_by_groupname(member))\
                             .filter(UsersGroupToPerm.repository == cur_repo)\
                             .one()
 
                     g2p.permission = self.sa.query(Permission)\
                                         .filter(Permission.permission_name == perm)\
                                         .scalar()
                     self.sa.add(g2p)
 
             #set new permissions
             for member, perm, member_type in form_data['perms_new']:
                 if member_type == 'user':
                     r2p = RepoToPerm()
                     r2p.repository = cur_repo
                     r2p.user = user_model.get_by_username(member)
 
                     r2p.permission = self.sa.query(Permission)\
                                         .filter(Permission.permission_name == perm)\
                                         .scalar()
                     self.sa.add(r2p)
                 else:
                     g2p = UsersGroupToPerm()
                     g2p.repository = cur_repo
                     g2p.users_group = users_group_model.get_by_groupname(member)
 
                     g2p.permission = self.sa.query(Permission)\
                                         .filter(Permission.permission_name == perm)\
                                         .scalar()
                     self.sa.add(g2p)
 
             #update current repo
             for k, v in form_data.items():
                 if k == 'user':
                     cur_repo.user = user_model.get(v)
                 else:
                     setattr(cur_repo, k, v)
 
             self.sa.add(cur_repo)
 
             if repo_name != form_data['repo_name']:
                 #rename our data
                 self.__rename_repo(repo_name, form_data['repo_name'])
 
             self.sa.commit()
         except:
             log.error(traceback.format_exc())
             self.sa.rollback()
             raise
 
     def create(self, form_data, cur_user, just_db=False, fork=False):
         try:
             if fork:
                 #force str since hg doesn't go with unicode
                 repo_name = str(form_data['fork_name'])
                 org_name = str(form_data['repo_name'])
 
             else:
                 org_name = repo_name = str(form_data['repo_name'])
             new_repo = Repository()
             new_repo.enable_statistics = True
             for k, v in form_data.items():
                 if k == 'repo_name':
                     v = repo_name
                 setattr(new_repo, k, v)
 
             if fork:
                 parent_repo = self.sa.query(Repository)\
                         .filter(Repository.repo_name == org_name).scalar()
                 new_repo.fork = parent_repo
 
             new_repo.user_id = cur_user.user_id
             self.sa.add(new_repo)
 
             #create default permission
             repo_to_perm = RepoToPerm()
             default = 'repository.read'
             for p in UserModel(self.sa).get_by_username('default', cache=False).user_perms:
                 if p.permission.permission_name.startswith('repository.'):
                     default = p.permission.permission_name
                     break
 
             default_perm = 'repository.none' if form_data['private'] else default
 
             repo_to_perm.permission_id = self.sa.query(Permission)\
                     .filter(Permission.permission_name == default_perm)\
                     .one().permission_id
 
             repo_to_perm.repository = new_repo
             repo_to_perm.user_id = UserModel(self.sa)\
                 .get_by_username('default', cache=False).user_id
 
             self.sa.add(repo_to_perm)
 
             if not just_db:
                 self.__create_repo(repo_name, form_data['repo_type'])
 
             self.sa.commit()
 
             #now automatically start following this repository as owner
             from rhodecode.model.scm import ScmModel
             ScmModel(self.sa).toggle_following_repo(new_repo.repo_id,
                                              cur_user.user_id)
 
         except:
             log.error(traceback.format_exc())
             self.sa.rollback()
             raise
 
     def create_fork(self, form_data, cur_user):
         from rhodecode.lib.celerylib import tasks, run_task
         run_task(tasks.create_repo_fork, form_data, cur_user)
 
     def delete(self, repo):
         try:
             self.sa.delete(repo)
             self.__delete_repo(repo)
             self.sa.commit()
         except:
             log.error(traceback.format_exc())
             self.sa.rollback()
             raise
 
     def delete_perm_user(self, form_data, repo_name):
         try:
             self.sa.query(RepoToPerm)\
                 .filter(RepoToPerm.repository \
                         == self.get_by_repo_name(repo_name))\
                 .filter(RepoToPerm.user_id == form_data['user_id']).delete()
             self.sa.commit()
         except:
             log.error(traceback.format_exc())
             self.sa.rollback()
             raise
 
     def delete_perm_users_group(self, form_data, repo_name):
         try:
             self.sa.query(UsersGroupToPerm)\
                 .filter(UsersGroupToPerm.repository \
                         == self.get_by_repo_name(repo_name))\
                 .filter(UsersGroupToPerm.users_group_id \
                         == form_data['users_group_id']).delete()
             self.sa.commit()
         except:
             log.error(traceback.format_exc())
             self.sa.rollback()
             raise
 
     def delete_stats(self, repo_name):
         try:
             self.sa.query(Statistics)\
                 .filter(Statistics.repository == \
                         self.get_by_repo_name(repo_name)).delete()
             self.sa.commit()
         except:
             log.error(traceback.format_exc())
             self.sa.rollback()
             raise
 
 
     def __create_repo(self, repo_name, alias):
         """
         makes repository on filesystem
         :param repo_name:
         :param alias:
         """
         from rhodecode.lib.utils import check_repo
         repo_path = os.path.join(self.repos_path, repo_name)
         if check_repo(repo_name, self.repos_path):
             log.info('creating repo %s in %s', repo_name, repo_path)
             backend = get_backend(alias)
             backend(repo_path, create=True)
 
     def __rename_repo(self, old, new):
         """
         renames repository on filesystem
         :param old: old name
         :param new: new name
         """
         log.info('renaming repo from %s to %s', old, new)
 
         old_path = os.path.join(self.repos_path, old)
         new_path = os.path.join(self.repos_path, new)
         if os.path.isdir(new_path):
             raise Exception('Was trying to rename to already existing dir %s',
                             new_path)
         shutil.move(old_path, new_path)
 
     def __delete_repo(self, repo):
         """
         removes repo from filesystem, the removal is acctually made by
         added rm__ prefix into dir, and rename internat .hg/.git dirs so this
         repository is no longer valid for rhodecode, can be undeleted later on
         by reverting the renames on this repository
         :param repo: repo object
         """
         rm_path = os.path.join(self.repos_path, repo.repo_name)
         log.info("Removing %s", rm_path)
         #disable hg/git
         alias = repo.repo_type
         shutil.move(os.path.join(rm_path, '.%s' % alias),
                     os.path.join(rm_path, 'rm__.%s' % alias))
         #disable repo
         shutil.move(rm_path, os.path.join(self.repos_path, 'rm__%s__%s' \
                                           % (datetime.today().isoformat(),
                                              repo.repo_name)))

rhodecode/model/scm.py

@@ -1,396 +1,384 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.model.scm
     ~~~~~~~~~~~~~~~~~~~
 
     Scm model for RhodeCode
 
     :created_on: Apr 9, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>    
     :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; version 2
 # of the License or (at your opinion) any later version of the license.
 # 
 # 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, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA  02110-1301, USA.
 import os
 import time
 import traceback
 import logging
 
 from mercurial import ui
 
-from sqlalchemy.orm import joinedload
-from sqlalchemy.orm.session import make_transient
 from sqlalchemy.exc import DatabaseError
 
 from beaker.cache import cache_region, region_invalidate
 
 from vcs import get_backend
 from vcs.utils.helpers import get_scm
 from vcs.exceptions import RepositoryError, VCSError
 from vcs.utils.lazy import LazyProperty
 
 from rhodecode import BACKENDS
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import HasRepoPermissionAny
-from rhodecode.lib.utils import get_repos as get_filesystem_repos, make_ui, action_logger
+from rhodecode.lib.utils import get_repos as get_filesystem_repos, make_ui, \
+    action_logger
 from rhodecode.model import BaseModel
 from rhodecode.model.user import UserModel
+from rhodecode.model.repo import RepoModel
 from rhodecode.model.db import Repository, RhodeCodeUi, CacheInvalidation, \
     UserFollowing, UserLog
 from rhodecode.model.caching_query import FromCache
 
 log = logging.getLogger(__name__)
 
 
 class UserTemp(object):
     def __init__(self, user_id):
         self.user_id = user_id
 
     def __repr__(self):
         return "<%s('id:%s')>" % (self.__class__.__name__, self.user_id)
 
 class RepoTemp(object):
     def __init__(self, repo_id):
         self.repo_id = repo_id
 
     def __repr__(self):
         return "<%s('id:%s')>" % (self.__class__.__name__, self.repo_id)
 
 class ScmModel(BaseModel):
     """Generic Scm Model
     """
 
     @LazyProperty
     def repos_path(self):
         """Get's the repositories root path from database
         """
 
         q = self.sa.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/').one()
 
         return q.ui_value
 
-    def repo_scan(self, repos_path, baseui):
+    def repo_scan(self, repos_path=None):
         """Listing of repositories in given path. This path should not be a 
         repository itself. Return a dictionary of repository objects
         
         :param repos_path: path to directory containing repositories
-        :param baseui: baseui instance to instantiate MercurialRepostitory with
         """
 
         log.info('scanning for repositories in %s', repos_path)
 
-        if not isinstance(baseui, ui.ui):
-            baseui = make_ui('db')
+        if repos_path is None:
+            repos_path = self.repos_path
+
+        baseui = make_ui('db')
         repos_list = {}
 
         for name, path in get_filesystem_repos(repos_path, recursive=True):
             try:
                 if repos_list.has_key(name):
                     raise RepositoryError('Duplicate repository name %s '
                                     'found in %s' % (name, path))
                 else:
 
                     klass = get_backend(path[0])
 
                     if path[0] == 'hg' and path[0] in BACKENDS.keys():
                         repos_list[name] = klass(path[1], baseui=baseui)
 
                     if path[0] == 'git' and path[0] in BACKENDS.keys():
                         repos_list[name] = klass(path[1])
             except OSError:
                 continue
 
         return repos_list
 
     def get_repos(self, all_repos=None):
         """Get all repos from db and for each repo create it's backend instance.
         and fill that backed with information from database
         
         :param all_repos: give specific repositories list, good for filtering
         """
 
         if all_repos is None:
             all_repos = self.sa.query(Repository)\
                 .order_by(Repository.repo_name).all()
 
         #get the repositories that should be invalidated
         invalidation_list = [str(x.cache_key) for x in \
                              self.sa.query(CacheInvalidation.cache_key)\
                              .filter(CacheInvalidation.cache_active == False)\
                              .all()]
 
         for r in all_repos:
 
-            repo = self.get(r.repo_name, invalidation_list)
+            repo, dbrepo = self.get(r.repo_name, invalidation_list)
 
             if repo is not None:
                 last_change = repo.last_change
                 tip = h.get_changeset_safe(repo, 'tip')
 
                 tmp_d = {}
                 tmp_d['name'] = r.repo_name
                 tmp_d['name_sort'] = tmp_d['name'].lower()
-                tmp_d['description'] = repo.dbrepo.description
+                tmp_d['description'] = dbrepo.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'] = tip.raw_id
                 tmp_d['tip_sort'] = tip.revision
                 tmp_d['rev'] = tip.revision
-                tmp_d['contact'] = repo.dbrepo.user.full_contact
+                tmp_d['contact'] = dbrepo.user.full_contact
                 tmp_d['contact_sort'] = tmp_d['contact']
                 tmp_d['owner_sort'] = tmp_d['contact']
                 tmp_d['repo_archives'] = list(repo._get_archives())
                 tmp_d['last_msg'] = tip.message
                 tmp_d['repo'] = repo
+                tmp_d['dbrepo'] = dbrepo
                 yield tmp_d
 
-    def get_repo(self, repo_name):
-        return self.get(repo_name)
-
-    def get(self, repo_name, invalidation_list=None):
-        """Get's repository from given name, creates BackendInstance and
+    def get(self, repo_name, invalidation_list=None, retval='all'):
+        """Returns a tuple of Repository,DbRepository,
+        Get's repository from given name, creates BackendInstance and
         propagates it's data from database with all additional information
         
         :param repo_name:
         :param invalidation_list: if a invalidation list is given the get
             method should not manually check if this repository needs 
             invalidation and just invalidate the repositories in list
-            
+        :param retval: string specifing what to return one of 'repo','dbrepo',
+            'all'if repo or dbrepo is given it'll just lazy load chosen type
+            and return None as the second
         """
         if not HasRepoPermissionAny('repository.read', 'repository.write',
                             'repository.admin')(repo_name, 'get repo check'):
             return
 
         #======================================================================
         # CACHE FUNCTION
         #======================================================================
         @cache_region('long_term')
         def _get_repo(repo_name):
 
             repo_path = os.path.join(self.repos_path, repo_name)
 
             try:
                 alias = get_scm(repo_path)[0]
                 log.debug('Creating instance of %s repository', alias)
                 backend = get_backend(alias)
             except VCSError:
                 log.error(traceback.format_exc())
-                log.error('Perhaps this repository is in db and not in filesystem'
-                          'run rescan repositories with "destroy old data "'
-                          'option from admin panel')
+                log.error('Perhaps this repository is in db and not in '
+                          'filesystem run rescan repositories with '
+                          '"destroy old data " option from admin panel')
                 return
 
             if alias == 'hg':
-                from pylons import app_globals as g
-                repo = backend(repo_path, create=False, baseui=g.baseui)
+                repo = backend(repo_path, create=False, baseui=make_ui('db'))
                 #skip hidden web repository
                 if repo._get_hidden():
                     return
             else:
                 repo = backend(repo_path, create=False)
 
-            dbrepo = self.sa.query(Repository)\
-                .options(joinedload(Repository.fork))\
-                .options(joinedload(Repository.user))\
-                .filter(Repository.repo_name == repo_name)\
-                .scalar()
-
-            self.sa.expunge_all()
-            log.debug('making transient %s', dbrepo)
-            make_transient(dbrepo)
-
-            for attr in ['user', 'forks', 'followers', 'group', 'repo_to_perm',
-                         'users_group_to_perm', 'stats', 'logs']:
-                attr = getattr(dbrepo, attr, False)
-                if attr:
-                    if isinstance(attr, list):
-                        for a in attr:
-                            log.debug('making transient %s', a)
-                            make_transient(a)
-                    else:
-                        log.debug('making transient %s', attr)
-                        make_transient(attr)
-
-            repo.dbrepo = dbrepo
             return repo
 
         pre_invalidate = True
+        dbinvalidate = False
+
         if invalidation_list is not None:
             pre_invalidate = repo_name in invalidation_list
 
         if pre_invalidate:
+            #this returns object to invalidate
             invalidate = self._should_invalidate(repo_name)
-
             if invalidate:
                 log.info('invalidating cache for repository %s', repo_name)
-                region_invalidate(_get_repo, None, repo_name)
+                #region_invalidate(_get_repo, None, repo_name)
                 self._mark_invalidated(invalidate)
+                dbinvalidate = True
 
-        return _get_repo(repo_name)
+        r, dbr = None, None
+        if retval == 'repo' or 'all':
+            r = _get_repo(repo_name)
+        if retval == 'dbrepo' or 'all':
+            dbr = RepoModel(self.sa).get_full(repo_name, cache=True,
+                                          invalidate=dbinvalidate)
+
+
+        return r, dbr
 
 
 
     def mark_for_invalidation(self, repo_name):
         """Puts cache invalidation task into db for 
         further global cache invalidation
         
         :param repo_name: this repo that should invalidation take place
         """
 
         log.debug('marking %s for invalidation', repo_name)
         cache = self.sa.query(CacheInvalidation)\
             .filter(CacheInvalidation.cache_key == repo_name).scalar()
 
         if cache:
             #mark this cache as inactive
             cache.cache_active = False
         else:
             log.debug('cache key not found in invalidation db -> creating one')
             cache = CacheInvalidation(repo_name)
 
         try:
             self.sa.add(cache)
             self.sa.commit()
         except (DatabaseError,):
             log.error(traceback.format_exc())
             self.sa.rollback()
 
 
     def toggle_following_repo(self, follow_repo_id, user_id):
 
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_repo_id == follow_repo_id)\
             .filter(UserFollowing.user_id == user_id).scalar()
 
         if f is not None:
 
             try:
                 self.sa.delete(f)
                 self.sa.commit()
                 action_logger(UserTemp(user_id),
                               'stopped_following_repo',
                               RepoTemp(follow_repo_id))
                 return
             except:
                 log.error(traceback.format_exc())
                 self.sa.rollback()
                 raise
 
 
         try:
             f = UserFollowing()
             f.user_id = user_id
             f.follows_repo_id = follow_repo_id
             self.sa.add(f)
             self.sa.commit()
             action_logger(UserTemp(user_id),
                           'started_following_repo',
                           RepoTemp(follow_repo_id))
         except:
             log.error(traceback.format_exc())
             self.sa.rollback()
             raise
 
     def toggle_following_user(self, follow_user_id , user_id):
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_user_id == follow_user_id)\
             .filter(UserFollowing.user_id == user_id).scalar()
 
         if f is not None:
             try:
                 self.sa.delete(f)
                 self.sa.commit()
                 return
             except:
                 log.error(traceback.format_exc())
                 self.sa.rollback()
                 raise
 
         try:
             f = UserFollowing()
             f.user_id = user_id
             f.follows_user_id = follow_user_id
             self.sa.add(f)
             self.sa.commit()
         except:
             log.error(traceback.format_exc())
             self.sa.rollback()
             raise
 
     def is_following_repo(self, repo_name, user_id, cache=False):
         r = self.sa.query(Repository)\
             .filter(Repository.repo_name == repo_name).scalar()
 
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_repository == r)\
             .filter(UserFollowing.user_id == user_id).scalar()
 
         return f is not None
 
     def is_following_user(self, username, user_id, cache=False):
         u = UserModel(self.sa).get_by_username(username)
 
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_user == u)\
             .filter(UserFollowing.user_id == user_id).scalar()
 
         return f is not None
 
     def get_followers(self, repo_id):
         return self.sa.query(UserFollowing)\
                 .filter(UserFollowing.follows_repo_id == repo_id).count()
 
     def get_forks(self, repo_id):
         return self.sa.query(Repository)\
                 .filter(Repository.fork_id == repo_id).count()
 
 
     def get_unread_journal(self):
         return self.sa.query(UserLog).count()
 
 
     def _should_invalidate(self, repo_name):
         """Looks up database for invalidation signals for this repo_name
         
         :param repo_name:
         """
 
         ret = self.sa.query(CacheInvalidation)\
-            .options(FromCache('sql_cache_short',
-                           'get_invalidation_%s' % repo_name))\
             .filter(CacheInvalidation.cache_key == repo_name)\
             .filter(CacheInvalidation.cache_active == False)\
             .scalar()
 
         return ret
 
     def _mark_invalidated(self, cache_key):
-        """ Marks all occurences of cache to invaldation as already invalidated
+        """ Marks all occurrences of cache to invalidation as already 
+        invalidated
         
         :param cache_key:
         """
 
         if cache_key:
             log.debug('marking %s as already invalidated', cache_key)
         try:
             cache_key.cache_active = True
             self.sa.add(cache_key)
             self.sa.commit()
         except (DatabaseError,):
             log.error(traceback.format_exc())
             self.sa.rollback()
 

rhodecode/templates/admin/repos/repos.html

@@ -1,88 +1,88 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${_('Repositories administration')} - ${c.rhodecode_name}
 </%def>
 
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_('Admin'),h.url('admin_home'))} &raquo; ${_('Repositories')}
 </%def>
 <%def name="page_nav()">
 	${self.menu('admin')}
 </%def>
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
         <ul class="links">
           <li>
             <span>${h.link_to(u'ADD NEW REPOSITORY',h.url('new_repo'))}</span>
           </li>          
         </ul>        
     </div>
     <!-- end box / title -->
     <div class="table">
         <table class="table_disp">
         <tr class="header">
 	        <th class="left">${_('Name')}</th>
 	        <th class="left">${_('Description')}</th>
 	        <th class="left">${_('Last change')}</th>
 	        <th class="left">${_('Tip')}</th>
 	        <th class="left">${_('Contact')}</th>
             <th class="left">${_('action')}</th>
         </tr>
             %for cnt,repo in enumerate(c.repos_list):
             <tr class="parity${cnt%2}">
                  <td>
                  ## TYPE OF REPO
-                 %if repo['repo'].dbrepo.repo_type =='hg':
+                 %if repo['dbrepo'].repo_type =='hg':
                    <img class="icon" title="${_('Mercurial repository')}" alt="${_('Mercurial repository')}" src="/images/icons/hgicon.png"/>
-                 %elif repo['repo'].dbrepo.repo_type =='git':
+                 %elif repo['dbrepo'].repo_type =='git':
                    <img class="icon" title="${_('Git repository')}" alt="${_('Git repository')}" src="/images/icons/giticon.png"/>
                  %else:
                    
                  %endif
                  
                  ## PRIVATE/PUBLIC REPO                  
-                 %if repo['repo'].dbrepo.private:
+                 %if repo['dbrepo'].private:
                     <img alt="${_('private')}" src="/images/icons/lock.png"/>
                  %else:
                     <img alt="${_('public')}" src="/images/icons/lock_open.png"/>
                  %endif         
                 ${h.link_to(repo['name'],h.url('edit_repo',repo_name=repo['name']))}
                 
-	            %if repo['repo'].dbrepo.fork:
-	            	<a href="${h.url('summary_home',repo_name=repo['repo'].dbrepo.fork.repo_name)}">
+	            %if repo['dbrepo'].fork:
+	            	<a href="${h.url('summary_home',repo_name=repo['dbrepo'].fork.repo_name)}">
 	            	<img class="icon" alt="${_('public')}"
-	            	title="${_('Fork of')} ${repo['repo'].dbrepo.fork.repo_name}" 
+	            	title="${_('Fork of')} ${repo['dbrepo'].fork.repo_name}" 
 	            	src="/images/icons/arrow_divide.png"/></a>
 	            %endif                
                 </td>
 				<td title="${repo['description']}">${h.truncate(repo['description'],60)}</td>
 	            <td>${h.age(repo['last_change'])}</td>
 	            <td>
 	            	%if repo['rev']>=0:
 	            	${h.link_to('r%s:%s' % (repo['rev'],h.short_id(repo['tip'])),
 	                h.url('changeset_home',repo_name=repo['name'],revision=repo['tip']),
 	                class_="tooltip",
 	                title=h.tooltip(repo['last_msg']))}
 	            	%else:
 	            		${_('No changesets yet')}
 	            	%endif    
 	            </td>
 	            <td title="${repo['contact']}">${h.person(repo['contact'])}</td>
                 <td>
                   ${h.form(url('repo', repo_name=repo['name']),method='delete')}
                     ${h.submit('remove_%s' % repo['name'],'delete',class_="delete_icon action_button",onclick="return confirm('Confirm to delete this repository');")}
                   ${h.end_form()}
                 </td>
             </tr>
             %endfor
         </table>
     </div>
 </div> 
 		   
 </%def>    

rhodecode/templates/admin/users/user_edit_my_account.html

@@ -1,207 +1,207 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${_('My account')} ${c.rhodecode_user.username} - ${c.rhodecode_name}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${_('My Account')}
 </%def>
 
 <%def name="page_nav()">
 	${self.menu('admin')}
 </%def>
 
 <%def name="main()">
 
 <div class="box box-left">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}       
     </div>
     <!-- end box / title -->
     <div>
     ${h.form(url('admin_settings_my_account_update'),method='put')}
 	    <div class="form">
 	    
              <div class="field">
                 <div class="gravatar_box">
                     <div class="gravatar"><img alt="gravatar" src="${h.gravatar_url(c.user.email)}"/></div>
                     <p>
                     <strong>Change your avatar at <a href="http://gravatar.com">gravatar.com</a></strong><br/> 
                     ${_('Using')} ${c.user.email}
                     </p>
                 </div>
              </div>   	    
 	    
 	        <div class="fields">
 	             <div class="field">
 	                <div class="label">
 	                    <label for="username">${_('Username')}:</label>
 	                </div>
 	                <div class="input">
 	                    ${h.text('username',class_="medium")}
 	                </div>
 	             </div>
 	            
 	             <div class="field">
 	                <div class="label">
 	                    <label for="new_password">${_('New password')}:</label>
 	                </div>
 	                <div class="input">
 	                    ${h.password('new_password',class_="medium")}
 	                </div>
 	             </div>
 	            
 	             <div class="field">
 	                <div class="label">
 	                    <label for="name">${_('First Name')}:</label>
 	                </div>
 	                <div class="input">
 	                    ${h.text('name',class_="medium")}
 	                </div>
 	             </div>
 	            
 	             <div class="field">
 	                <div class="label">
 	                    <label for="lastname">${_('Last Name')}:</label>
 	                </div>
 	                <div class="input">
 	                    ${h.text('lastname',class_="medium")}
 	                </div>
 	             </div>
 	            
 	             <div class="field">
 	                <div class="label">
 	                    <label for="email">${_('Email')}:</label>
 	                </div>
 	                <div class="input">
 	                    ${h.text('email',class_="medium")}
 	                </div>
 	             </div>
 	            
 	            <div class="buttons">
 	              ${h.submit('save','Save',class_="ui-button")}
 	              ${h.reset('reset','Reset',class_="ui-button")}
 	            </div>             
 	    	</div>
 	    </div>    	
     ${h.end_form()}
     </div>
 </div>    
 
 <div class="box box-right">
     <!-- box / title -->
     <div class="title">
         <h5>${_('My repositories')} 
         <input class="top-right-rounded-corner top-left-rounded-corner bottom-left-rounded-corner bottom-right-rounded-corner" id="q_filter" size="15" type="text" name="filter" value="${_('quick filter...')}"/>
         </h5>
          %if h.HasPermissionAny('hg.admin','hg.create.repository')():
          <ul class="links">
            <li>
              <span>${h.link_to(_('ADD REPOSITORY'),h.url('admin_settings_create_repository'))}</span>
            </li>          
          </ul>           
          %endif        
     </div>
     <!-- end box / title -->
     <div class="table">
 	    <table>
 	    <thead>
             <tr>
             <th class="left">${_('Name')}</th>
             <th class="left">${_('revision')}</th>
             <th colspan="2" class="left">${_('action')}</th>            
 	    </thead>
 	     <tbody>
 	     %if c.user_repos:
 		     %for repo in c.user_repos:
 		        <tr>
 		            <td>
-                     %if repo['repo'].dbrepo.repo_type =='hg':
+                     %if repo['dbrepo'].repo_type =='hg':
                        <img class="icon" title="${_('Mercurial repository')}" alt="${_('Mercurial repository')}" src="/images/icons/hgicon.png"/>
-                     %elif repo['repo'].dbrepo.repo_type =='git':
+                     %elif repo['dbrepo'].repo_type =='git':
                        <img class="icon" title="${_('Git repository')}" alt="${_('Git repository')}" src="/images/icons/giticon.png"/>
                      %else:
                        
                      %endif 		            
-		             %if repo['repo'].dbrepo.private:
+		             %if repo['dbrepo'].private:
 		                <img class="icon" alt="${_('private')}" src="/images/icons/lock.png"/>
 		             %else:
 		                <img class="icon" alt="${_('public')}" src="/images/icons/lock_open.png"/>
 		             %endif
 		                                             
 		            ${h.link_to(repo['repo'].name, h.url('summary_home',repo_name=repo['repo'].name),class_="repo_name")}
-		            %if repo['repo'].dbrepo.fork:
-		            	<a href="${h.url('summary_home',repo_name=repo['repo'].dbrepo.fork.repo_name)}">
+		            %if repo['dbrepo'].fork:
+		            	<a href="${h.url('summary_home',repo_name=repo['dbrepo'].fork.repo_name)}">
 		            	<img class="icon" alt="${_('public')}"
-		            	title="${_('Fork of')} ${repo['repo'].dbrepo.fork.repo_name}" 
+		            	title="${_('Fork of')} ${repo['dbrepo'].fork.repo_name}" 
 		            	src="/images/icons/arrow_divide.png"/></a>
 		            %endif		            
 		            </td> 
 		            <td><span class="tooltip" title="${repo['repo'].last_change}">${("r%s:%s") % (h.get_changeset_safe(repo['repo'],'tip').revision,h.short_id(h.get_changeset_safe(repo['repo'],'tip').raw_id))}</span></td>
 		            <td><a href="${h.url('repo_settings_home',repo_name=repo['repo'].name)}" title="${_('edit')}"><img class="icon" alt="${_('private')}" src="/images/icons/application_form_edit.png"/></a></td>
 		            <td>
 	                  ${h.form(url('repo_settings_delete', repo_name=repo['repo'].name),method='delete')}
 	                    ${h.submit('remove_%s' % repo['repo'].name,'',class_="delete_icon action_button",onclick="return confirm('Confirm to delete this repository');")}
 	                  ${h.end_form()}	            
 		            </td>
 		        </tr>
 		     %endfor
 	     %else:
 	     	${_('No repositories yet')} 
 	     	%if h.HasPermissionAny('hg.admin','hg.create.repository')():
 	     		${h.link_to(_('create one now'),h.url('admin_settings_create_repository'))}
 	     	%endif
 	     %endif
 	     </tbody>
 	     </table>
     </div>
     
 </div>
     <script type="text/javascript">
      var D = YAHOO.util.Dom;
      var E = YAHOO.util.Event;
      var S = YAHOO.util.Selector;
      
      var q_filter = D.get('q_filter');
      var F = YAHOO.namespace('q_filter'); 
      
      E.on(q_filter,'click',function(){
         q_filter.value = '';
      });
 
      F.filterTimeout = null;
      
      F.updateFilter  = function() { 
         // Reset timeout 
         F.filterTimeout = null;
         
         var obsolete = [];
         var nodes = S.query('div.table tr td a.repo_name');
         var req = D.get('q_filter').value;
         for (n in nodes){
             D.setStyle(nodes[n].parentNode.parentNode,'display','')
         }
         if (req){
             for (n in nodes){
                 if (nodes[n].innerHTML.toLowerCase().indexOf(req) == -1) {
                     obsolete.push(nodes[n]); 
                 }
             }
             if(obsolete){
                 for (n in obsolete){
                     D.setStyle(obsolete[n].parentNode.parentNode,'display','none');
                 }
             }
         }
      }
      
      E.on(q_filter,'keyup',function(e){
          clearTimeout(F.filterTimeout); 
          setTimeout(F.updateFilter,600); 
      });
      
     </script>
 </%def>  
  No newline at end of file

rhodecode/templates/base/base.html

@@ -1,392 +1,392 b''
 ## -*- coding: utf-8 -*-
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml" id="mainhtml">
 <head>
     <title>${next.title()}</title>
     <link rel="icon" href="/images/icons/database_gear.png" type="image/png" />
     <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
     <meta name="robots" content="index, nofollow"/>
     <!-- stylesheets -->
     ${self.css()}
     <!-- scripts -->
     ${self.js()}
 %if c.ga_code:
 <script type="text/javascript">
 
   var _gaq = _gaq || [];
   _gaq.push(['_setAccount', '${c.ga_code}']);
   _gaq.push(['_trackPageview']);
 
   (function() {
     var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
     ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
     var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
   })();
 
 
 </script>
 %endif
 </head>
 <body>
     <!-- header -->
     <div id="header">
         <!-- user -->
         <ul id="logged-user">
 	            <li class="first">
 	                <div class="gravatar">
 	                    <img alt="gravatar" src="${h.gravatar_url(c.rhodecode_user.email,20)}" />
 	                </div>
 		            <div class="account">
 		            %if c.rhodecode_user.username == 'default':
                         %if h.HasPermissionAny('hg.admin', 'hg.register.auto_activate', 'hg.register.manual_activate')(): 
                             ${h.link_to('anonymous',h.url('register'),title='%s %s'%(c.rhodecode_user.name,c.rhodecode_user.lastname))}
                         %else:
                             ${h.link_to('anonymous',h.url('#'),title='%s %s'%(c.rhodecode_user.name,c.rhodecode_user.lastname))}
                         %endif		            
                         
                     %else:                        		            
 		            	${h.link_to(c.rhodecode_user.username,h.url('admin_settings_my_account'),title='%s %s'%(c.rhodecode_user.name,c.rhodecode_user.lastname))}
 		            %endif
 		            </div>	
 	            </li>
 	            <li>
 	               <a href="${h.url('home')}">${_('Home')}</a>
 	            </li>
 	            %if c.rhodecode_user.username != 'default':
                 <li>
                    <a href="${h.url('journal')}">${_('Journal')}</a> 
                    ##(${c.unread_journal})</a>
                 </li>
                 %endif
                 %if c.rhodecode_user.username == 'default':
                     <li class="last highlight">${h.link_to(u'Login',h.url('login_home'))}</li>
                 %else:
                     <li class="last highlight">${h.link_to(u'Log Out',h.url('logout_home'))}</li>
                 %endif
         </ul>
         <!-- end user -->
         <div id="header-inner" class="title top-left-rounded-corner top-right-rounded-corner">
             <!-- logo -->
             <div id="logo">
                 <h1><a href="${h.url('home')}">${c.rhodecode_name}</a></h1>
             </div>
             <!-- end logo -->
             <!-- menu -->
             ${self.page_nav()}
             <!-- quick -->
         </div>
     </div>     
     <!-- end header -->
     
 	<!-- CONTENT -->
 	<div id="content"> 
         <div class="flash_msg">
             <% messages = h.flash.pop_messages() %>
             % if messages:
             <ul id="flash-messages">
                 % for message in messages:
                 <li class="${message.category}_msg">${message}</li>
                 % endfor
             </ul>
             % endif
         </div>	    
 	    <div id="main"> 
 	        ${next.main()}
 	    </div>
 	</div> 
     <!-- END CONTENT -->
 
 	<!-- footer -->
 	<div id="footer">
 	   <div id="footer-inner" class="title bottom-left-rounded-corner bottom-right-rounded-corner">
 	       <div>
 	           <p class="footer-link">${h.link_to(_('Submit a bug'),h.url('bugtracker'))}</p>
 		       <p class="footer-link">${h.link_to(_('GPL license'),h.url('gpl_license'))}</p>
 		       <p>RhodeCode ${c.rhodecode_version} &copy; 2010-2011 by Marcin Kuzminski</p>
 	       </div>
 	   </div>
         <script type="text/javascript">
         function tooltip_activate(){
         ${h.tooltip.activate()}
         }
         tooltip_activate();
         </script>
 	</div>
 	<!-- end footer -->
 </body>
 
 </html>
 
 ### MAKO DEFS ### 
 <%def name="page_nav()">
 	${self.menu()}
 </%def>
 
 <%def name="menu(current=None)">
 		<% 
 		def is_current(selected):
 			if selected == current:
 				return h.literal('class="current"')
 		%>
 		%if current not in ['home','admin']:           		
 		   ##REGULAR MENU            
 	        <ul id="quick">
 				<!-- repo switcher -->
 				<li>
 					<a id="repo_switcher" title="${_('Switch repository')}" href="#">
                     <span class="icon">
                         <img src="/images/icons/database.png" alt="${_('Products')}" />
                     </span>
                     <span>&darr;</span>					
 					</a>
 					<ul class="repo_switcher">
                         %for repo in c.cached_repo_list:
                         
-                          %if repo['repo'].dbrepo.private:
-                             <li><img src="/images/icons/lock.png" alt="${_('Private repository')}" class="repo_switcher_type"/>${h.link_to(repo['repo'].name,h.url('summary_home',repo_name=repo['repo'].name),class_="%s" % repo['repo'].dbrepo.repo_type)}</li>
+                          %if repo['dbrepo'].private:
+                             <li><img src="/images/icons/lock.png" alt="${_('Private repository')}" class="repo_switcher_type"/>${h.link_to(repo['repo'].name,h.url('summary_home',repo_name=repo['repo'].name),class_="%s" % repo['dbrepo'].repo_type)}</li>
                           %else:
-                             <li><img src="/images/icons/lock_open.png" alt="${_('Public repository')}" class="repo_switcher_type" />${h.link_to(repo['repo'].name,h.url('summary_home',repo_name=repo['repo'].name),class_="%s" % repo['repo'].dbrepo.repo_type)}</li>
+                             <li><img src="/images/icons/lock_open.png" alt="${_('Public repository')}" class="repo_switcher_type" />${h.link_to(repo['repo'].name,h.url('summary_home',repo_name=repo['repo'].name),class_="%s" % repo['dbrepo'].repo_type)}</li>
                           %endif  
                         %endfor					
 					</ul>			
 				</li>
 				
 	            <li ${is_current('summary')}>
 	               <a title="${_('Summary')}" href="${h.url('summary_home',repo_name=c.repo_name)}">
 	               <span class="icon">
 	                   <img src="/images/icons/clipboard_16.png" alt="${_('Summary')}" />
 	               </span>
 	               <span>${_('Summary')}</span>                 
 	               </a>	            
 	            </li>
                 ##<li ${is_current('shortlog')}>
                 ##   <a title="${_('Shortlog')}" href="${h.url('shortlog_home',repo_name=c.repo_name)}">
                 ##   <span class="icon">
                 ##       <img src="/images/icons/application_view_list.png" alt="${_('Shortlog')}" />
                 ##   </span>
                 ##   <span>${_('Shortlog')}</span>                 
                 ##   </a>             
                 ##</li>	            
                 <li ${is_current('changelog')}>
                    <a title="${_('Changelog')}" href="${h.url('changelog_home',repo_name=c.repo_name)}">
                    <span class="icon">
                        <img src="/images/icons/time.png" alt="${_('Changelog')}" />
                    </span>
                    <span>${_('Changelog')}</span>                 
                    </a>             
                 </li>   	
                 
                 <li ${is_current('switch_to')}>
                    <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('%s (%s)' % (_('branches'),len(c.repository_branches.values()),),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()):
 						            <li>${h.link_to('%s - %s' % (branch[0],h.short_id(branch[1])),h.url('files_home',repo_name=c.repo_name,revision=branch[1]))}</li>
 						        %endfor
 						    %else:
 						    	<li>${h.link_to(_('There are no branches yet'),'#')}</li>
 						    %endif
                             </ul>                        
                         </li>
                         <li>
                             ${h.link_to('%s (%s)' % (_('tags'),len(c.repository_tags.values()),),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()):
                                  <li>${h.link_to('%s - %s' % (tag[0],h.short_id(tag[1])),h.url('files_home',repo_name=c.repo_name,revision=tag[1]))}</li>
                                 %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')}" />
                    </span>
                    <span>${_('Files')}</span>                 
                    </a>             
                 </li>                            
 				
                 <li ${is_current('options')}>
                    <a title="${_('Options')}" href="#">
                    <span class="icon">
                        <img src="/images/icons/table_gear.png" alt="${_('Admin')}" />
                    </span>
                    <span>${_('Options')}</span>                 
                    </a>
                    <ul>
                    %if h.HasRepoPermissionAll('repository.admin')(c.repo_name):
                      %if h.HasPermissionAll('hg.admin')('access settings on repository'):
                          <li>${h.link_to(_('settings'),h.url('edit_repo',repo_name=c.repo_name),class_='settings')}</li>
                      %else:
                          <li>${h.link_to(_('settings'),h.url('repo_settings_home',repo_name=c.repo_name),class_='settings')}</li>
                      %endif
                    	<li>${h.link_to(_('fork'),h.url('repo_fork_home',repo_name=c.repo_name),class_='fork')}</li>
                    %endif  
                    	<li>${h.link_to(_('search'),h.url('search_repo',search_repo=c.repo_name),class_='search')}</li>
                     
                     %if h.HasPermissionAll('hg.admin')('access admin main page'):
                     <li>
                        ${h.link_to(_('admin'),h.url('admin_home'),class_='admin')}  
                         <%def name="admin_menu()">
                         <ul>
                             <li>${h.link_to(_('journal'),h.url('admin_home'),class_='journal')}</li>
                             <li>${h.link_to(_('repositories'),h.url('repos'),class_='repos')}</li>
                             <li>${h.link_to(_('users'),h.url('users'),class_='users')}</li>
                             <li>${h.link_to(_('users groups'),h.url('users_groups'),class_='groups')}</li>
                             <li>${h.link_to(_('permissions'),h.url('edit_permission',id='default'),class_='permissions')}</li>
                             <li>${h.link_to(_('ldap'),h.url('ldap_home'),class_='ldap')}</li>
                             <li class="last">${h.link_to(_('settings'),h.url('admin_settings'),class_='settings')}</li>        
                         </ul>
                         </%def>
                         
                         ${admin_menu()}
                     </li>
                     %endif
 
                    </ul>             
                 </li>
                 
                 <li>
                     <a title="${_('Followers')}" href="#">
                     <span class="icon_short">
                         <img src="/images/icons/heart.png" alt="${_('Followers')}" />
                     </span>
                     <span class="short">${c.repository_followers}</span>
                     </a>
                 </li>
                 <li>
                     <a title="${_('Forks')}" href="#">
                     <span class="icon_short">
                         <img src="/images/icons/arrow_divide.png" alt="${_('Forks')}" />
                     </span>
                     <span class="short">${c.repository_forks}</span>
                     </a>
                 </li>                
                 
                 
                 
 	        </ul>
 		%else:
 		    ##ROOT MENU
             <ul id="quick">
                 <li>
                     <a title="${_('Home')}"  href="${h.url('home')}">
                     <span class="icon">
                         <img src="/images/icons/home_16.png" alt="${_('Home')}" />
                     </span>
                     <span>${_('Home')}</span>                 
                     </a>        
                 </li>
                 %if c.rhodecode_user.username != 'default':
                 <li>
                     <a title="${_('Journal')}"  href="${h.url('journal')}">
                     <span class="icon">
                         <img src="/images/icons/book.png" alt="${_('Journal')}" />
                     </span>
                     <span>${_('Journal')}</span>                 
                     </a>        
                 </li>
                 %endif          
                 <li>
                     <a title="${_('Search')}"  href="${h.url('search')}">
                     <span class="icon">
                         <img src="/images/icons/search_16.png" alt="${_('Search')}" />
                     </span>
                     <span>${_('Search')}</span>                 
                     </a>        
                 </li>
                 
 				%if h.HasPermissionAll('hg.admin')('access admin main page'):
                 <li ${is_current('admin')}>
                    <a title="${_('Admin')}" href="${h.url('admin_home')}">
                    <span class="icon">
                        <img src="/images/icons/cog_edit.png" alt="${_('Admin')}" />
                    </span>
                    <span>${_('Admin')}</span>                 
                    </a>
                     ${admin_menu()}
                 </li>
 				%endif
 			</ul>
 		%endif    
 </%def>
 
 
 <%def name="css()">
 <link rel="stylesheet" type="text/css" href="/css/style.css" media="screen" />
 <link rel="stylesheet" type="text/css" href="/css/pygments.css"  />
 <link rel="stylesheet" type="text/css" href="/css/diff.css"  />
 </%def>
 
 <%def name="js()">
 ##<script type="text/javascript" src="/js/yui/utilities/utilities.js"></script>
 ##<script type="text/javascript" src="/js/yui/container/container.js"></script>
 ##<script type="text/javascript" src="/js/yui/datasource/datasource.js"></script>
 ##<script type="text/javascript" src="/js/yui/autocomplete/autocomplete.js"></script>
 ##<script type="text/javascript" src="/js/yui/selector/selector-min.js"></script>
 
 <script type="text/javascript" src="/js/yui2a.js"></script>
 <!--[if IE]><script language="javascript" type="text/javascript" src="/js/excanvas.min.js"></script><![endif]-->
 <script type="text/javascript" src="/js/yui.flot.js"></script>
 
 <script type="text/javascript">
 var base_url  ='/_admin/toggle_following';
 var YUC = YAHOO.util.Connect;
 var YUD = YAHOO.util.Dom;
 var YUE = YAHOO.util.Event;
 
 function onSuccess(target){
 	
 	var f = YUD.get(target.id);
     if(f.getAttribute('class')=='follow'){
         f.setAttribute('class','following');
         f.setAttribute('title',"${_('Stop following this repository')}");
     }
     else{
         f.setAttribute('class','follow');
         f.setAttribute('title',"${_('Start following this repository')}");
     }
 }
 
 function toggleFollowingUser(fallows_user_id,token){
     args = 'follows_user_id='+fallows_user_id;
     args+= '&amp;auth_token='+token;
     YUC.asyncRequest('POST',base_url,{
         success:function(o){
         	onSuccess();
         }
     },args); return false;
 }
 
 function toggleFollowingRepo(target,fallows_repo_id,token){
 
     args = 'follows_repo_id='+fallows_repo_id;
     args+= '&amp;auth_token='+token;
     YUC.asyncRequest('POST',base_url,{
         success:function(o){
         	onSuccess(target);
         }
     },args); return false;
 }    
 </script>
 
 </%def>
 
 <%def name="breadcrumbs()">
     <div class="breadcrumbs">
     ${self.breadcrumbs_links()}
     </div>
 </%def>
  No newline at end of file

rhodecode/templates/index.html

@@ -1,168 +1,168 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="base/base.html"/>
 <%def name="title()">
     ${_('Dashboard')} - ${c.rhodecode_name}
 </%def>
 <%def name="breadcrumbs()">
 	${c.rhodecode_name}
 </%def>
 <%def name="page_nav()">
 	${self.menu('home')}
 </%def>
 <%def name="main()">
 	<%def name="get_sort(name)">
 		<%name_slug = name.lower().replace(' ','_') %>
 		
 		%if name_slug == c.sort_slug:
 		  %if c.sort_by.startswith('-'):
 		    <a href="?sort=${name_slug}">${name}&uarr;</a>
 		  %else:
 		    <a href="?sort=-${name_slug}">${name}&darr;</a>
 		  %endif:
 		%else:
 		    <a href="?sort=${name_slug}">${name}</a>
 		%endif
 	</%def>
 	
     <div class="box">
 	    <!-- box / title -->
 	    <div class="title">
 	        <h5>${_('Dashboard')}
 	        <input class="top-right-rounded-corner top-left-rounded-corner bottom-left-rounded-corner bottom-right-rounded-corner" id="q_filter" size="15" type="text" name="filter" value="${_('quick filter...')}"/>
 	        </h5>
 	        %if c.rhodecode_user.username != 'default':
 		        %if h.HasPermissionAny('hg.admin','hg.create.repository')():
 		        <ul class="links">
 		          <li>
 		            <span>${h.link_to(_('ADD NEW REPOSITORY'),h.url('admin_settings_create_repository'))}</span>
 		          </li>          
 		        </ul>  	        
 		        %endif
 		    %endif
 	    </div>
 	    <!-- end box / title -->
         <div class="table">
             <table>
             <thead>
 	            <tr>
 			        <th class="left">${get_sort(_('Name'))}</th>
 			        <th class="left">${get_sort(_('Description'))}</th>
 			        <th class="left">${get_sort(_('Last change'))}</th>
 			        <th class="left">${get_sort(_('Tip'))}</th>
 			        <th class="left">${get_sort(_('Owner'))}</th>
 			        <th class="left">${_('RSS')}</th>
 			        <th class="left">${_('Atom')}</th>
 	            </tr>
             </thead>
             <tbody>
 		    %for cnt,repo in enumerate(c.repos_list):
 		        <tr class="parity${cnt%2}">
 		            <td>
 		            <div style="white-space: nowrap">
 		             ## TYPE OF REPO
-		             %if repo['repo'].dbrepo.repo_type =='hg':
+		             %if repo['dbrepo'].repo_type =='hg':
 		               <img class="icon" title="${_('Mercurial repository')}" alt="${_('Mercurial repository')}" src="/images/icons/hgicon.png"/>
-		             %elif repo['repo'].dbrepo.repo_type =='git':
+		             %elif repo['dbrepo'].repo_type =='git':
 		               <img class="icon" title="${_('Git repository')}" alt="${_('Git repository')}" src="/images/icons/giticon.png"/>
 		             %else:
 		               
 		             %endif 
 		            
 		             ##PRIVATE/PUBLIC
-		             %if repo['repo'].dbrepo.private:
+		             %if repo['dbrepo'].private:
 		                <img class="icon" title="${_('private repository')}" alt="${_('private repository')}" src="/images/icons/lock.png"/>
 		             %else:
 		                <img class="icon" title="${_('public repository')}" alt="${_('public repository')}" src="/images/icons/lock_open.png"/>
 		             %endif
 		            
 		            ##NAME   
 		            ${h.link_to(repo['name'],
 		                h.url('summary_home',repo_name=repo['name']),class_="repo_name")}
-		            %if repo['repo'].dbrepo.fork:
-		            	<a href="${h.url('summary_home',repo_name=repo['repo'].dbrepo.fork.repo_name)}">
+		            %if repo['dbrepo'].fork:
+		            	<a href="${h.url('summary_home',repo_name=repo['dbrepo'].fork.repo_name)}">
 		            	<img class="icon" alt="${_('fork')}"
-		            	title="${_('Fork of')} ${repo['repo'].dbrepo.fork.repo_name}" 
+		            	title="${_('Fork of')} ${repo['dbrepo'].fork.repo_name}" 
 		            	src="/images/icons/arrow_divide.png"/></a>
 		            %endif
 		            </div>
 		            </td>
 		            ##DESCRIPTION
 		            <td><span class="tooltip" title="${h.tooltip(repo['description'])}">
 		               ${h.truncate(repo['description'],60)}</span>
 		            </td>
 		            ##LAST CHANGE
 		            <td>
 		              <span class="tooltip" title="${repo['last_change']}">
 		              ${h.age(repo['last_change'])}</span>
 		            </td>
 		            <td>
 		            	%if repo['rev']>=0:
 		            	${h.link_to('r%s:%s' % (repo['rev'],h.short_id(repo['tip'])),
 		                h.url('changeset_home',repo_name=repo['name'],revision=repo['tip']),
 		                class_="tooltip",
 		                title=h.tooltip(repo['last_msg']))}
 		            	%else:
 		            		${_('No changesets yet')}
 		            	%endif    
 		            </td>
 		            <td title="${repo['contact']}">${h.person(repo['contact'])}</td>
 		            <td>
 		                <a title="${_('Subscribe to %s rss feed')%repo['name']}" class="rss_icon"  href="${h.url('rss_feed_home',repo_name=repo['name'])}"></a>
 		            </td>        
 		            <td>
 		                <a title="${_('Subscribe to %s atom feed')%repo['name']}"  class="atom_icon" href="${h.url('atom_feed_home',repo_name=repo['name'])}"></a>
 		            </td>
 		        </tr>
 		    %endfor
             </tbody>
             </table>
             </div>
     </div>
     
     
     <script type="text/javascript">
      var D = YAHOO.util.Dom;
      var E = YAHOO.util.Event;
      var S = YAHOO.util.Selector;
      
      var q_filter = D.get('q_filter');
      var F = YAHOO.namespace('q_filter'); 
      
      E.on(q_filter,'click',function(){
     	q_filter.value = '';
      });
 
      F.filterTimeout = null;
      
      F.updateFilter  = function() { 
     	// Reset timeout 
         F.filterTimeout = null;
     	
         var obsolete = [];
         var nodes = S.query('div.table tr td div a.repo_name');
         var req = D.get('q_filter').value;
         for (n in nodes){
             D.setStyle(nodes[n].parentNode.parentNode.parentNode,'display','')
         }
         if (req){
 	        for (n in nodes){
 	        	if (nodes[n].innerHTML.toLowerCase().indexOf(req) == -1) {
 	        		obsolete.push(nodes[n]); 
 	        	}
 	    	}
 	        if(obsolete){
 		        for (n in obsolete){
 		        	D.setStyle(obsolete[n].parentNode.parentNode.parentNode,'display','none');
 		        }
 	        }
         }
      }
      
      E.on(q_filter,'keyup',function(e){
     	 clearTimeout(F.filterTimeout); 
     	 setTimeout(F.updateFilter,600); 
      });
      
     </script>
     	
 </%def>    

rhodecode/templates/summary/summary.html

@@ -1,674 +1,674 b''
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${c.repo_name} ${_('Summary')} - ${c.rhodecode_name}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(u'Home',h.url('/'))}
     &raquo; 
     ${h.link_to(c.repo_name,h.url('summary_home',repo_name=c.repo_name))}
     &raquo;
     ${_('summary')}
 </%def>
 
 <%def name="page_nav()">
 	${self.menu('summary')}    
 </%def>
 
 <%def name="main()">
 <div class="box box-left">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     <!-- end box / title -->
 	<div class="form">
 	  <div class="fields">
 		 
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Name')}:</label>
 			  </div>
 			  <div class="input-short">
-		         %if c.repo_info.dbrepo.repo_type =='hg':
+		         %if c.dbrepo.repo_type =='hg':
 		           <img style="margin-bottom:2px" class="icon" title="${_('Mercurial repository')}" alt="${_('Mercurial repository')}" src="/images/icons/hgicon.png"/>
 		         %endif
-		         %if c.repo_info.dbrepo.repo_type =='git':
+		         %if c.dbrepo.repo_type =='git':
 		           <img style="margin-bottom:2px" class="icon" title="${_('Git repository')}" alt="${_('Git repository')}" src="/images/icons/giticon.png"/>
 		         %endif 
                                  			  
-	             %if c.repo_info.dbrepo.private:
+	             %if c.dbrepo.private:
 	                <img style="margin-bottom:2px" class="icon" title="${_('private repository')}" alt="${_('private repository')}" src="/images/icons/lock.png"/>
 	             %else:
 	                <img style="margin-bottom:2px" class="icon" title="${_('public repository')}" alt="${_('public repository')}" src="/images/icons/lock_open.png"/>
 	             %endif
-			      <span style="font-size: 1.6em;font-weight: bold;vertical-align: baseline;">${c.repo_info.name}</span>
+			      <span style="font-size: 1.6em;font-weight: bold;vertical-align: baseline;">${c.repo.name}</span>
 			      %if c.rhodecode_user.username != 'default':
 				      %if c.following:
 	                  <span id="follow_toggle" class="following" title="${_('Stop following this repository')}"
-	                        onclick="javascript:toggleFollowingRepo(this,${c.repo_info.dbrepo.repo_id},'${str(h.get_token())}')">
+	                        onclick="javascript:toggleFollowingRepo(this,${c.dbrepo.repo_id},'${str(h.get_token())}')">
 	                  </span>			      
 				      %else:
 				      <span id="follow_toggle" class="follow" title="${_('Start following this repository')}"
-				            onclick="javascript:toggleFollowingRepo(this,${c.repo_info.dbrepo.repo_id},'${str(h.get_token())}')">
+				            onclick="javascript:toggleFollowingRepo(this,${c.dbrepo.repo_id},'${str(h.get_token())}')">
 				      </span>
 				      %endif
 				  %endif:
 			      <br/>
-		            %if c.repo_info.dbrepo.fork:
+		            %if c.dbrepo.fork:
 		            	<span style="margin-top:5px">
-		            	<a href="${h.url('summary_home',repo_name=c.repo_info.dbrepo.fork.repo_name)}">
+		            	<a href="${h.url('summary_home',repo_name=c.dbrepo.fork.repo_name)}">
 		            	<img class="icon" alt="${_('public')}"
-		            	title="${_('Fork of')} ${c.repo_info.dbrepo.fork.repo_name}" 
+		            	title="${_('Fork of')} ${c.dbrepo.fork.repo_name}" 
 		            	src="/images/icons/arrow_divide.png"/>
-		            	${_('Fork of')} ${c.repo_info.dbrepo.fork.repo_name}
+		            	${_('Fork of')} ${c.dbrepo.fork.repo_name}
 		            	</a>
 		            	</span>
 		            %endif			      
 			  </div>
 			 </div>
 			
 			
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Description')}:</label>
 			  </div>
 			  <div class="input-short">
-			      ${c.repo_info.dbrepo.description}
+			      ${c.dbrepo.description}
 			  </div>
 			 </div>
 			
 			
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Contact')}:</label>
 			  </div>
 			  <div class="input-short">
 			  	<div class="gravatar">
-			  		<img alt="gravatar" src="${h.gravatar_url(c.repo_info.dbrepo.user.email)}"/>
+			  		<img alt="gravatar" src="${h.gravatar_url(c.dbrepo.user.email)}"/>
 			  	</div>
-			  		${_('Username')}: ${c.repo_info.dbrepo.user.username}<br/>
-			  		${_('Name')}: ${c.repo_info.dbrepo.user.name} ${c.repo_info.dbrepo.user.lastname}<br/>
-			  		${_('Email')}: <a href="mailto:${c.repo_info.dbrepo.user.email}">${c.repo_info.dbrepo.user.email}</a>
+			  		${_('Username')}: ${c.dbrepo.user.username}<br/>
+			  		${_('Name')}: ${c.dbrepo.user.name} ${c.dbrepo.user.lastname}<br/>
+			  		${_('Email')}: <a href="mailto:${c.dbrepo.user.email}">${c.dbrepo.user.email}</a>
 			  </div>
 			 </div>
 			
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Last change')}:</label>
 			  </div>
 			  <div class="input-short">
-			      ${h.age(c.repo_info.last_change)} - ${c.repo_info.last_change} 
-			      ${_('by')} ${h.get_changeset_safe(c.repo_info,'tip').author} 
+			      ${h.age(c.repo.last_change)} - ${c.repo.last_change} 
+			      ${_('by')} ${h.get_changeset_safe(c.repo,'tip').author} 
 			      
 			  </div>
 			 </div>
 			
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Clone url')}:</label>
 			  </div>
 			  <div class="input-short">
 			      <input type="text" id="clone_url" readonly="readonly" value="hg clone ${c.clone_repo_url}" size="70"/>
 			  </div>
 			 </div>
 			 
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Trending source files')}:</label>
 			  </div>
 			  <div class="input-short">
 			    <div id="lang_stats"></div> 			   
 			  </div>
 			 </div>
 			 			
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Download')}:</label>
 			  </div>
 			  <div class="input-short">
-		        %if len(c.repo_info.revisions) == 0:
+		        %if len(c.repo.revisions) == 0:
 		          ${_('There are no downloads yet')}
 		        %elif c.enable_downloads is False:
 		          ${_('Downloads are disabled for this repository')}
                     %if h.HasPermissionAll('hg.admin')('enable stats on from summary'):
                         [${h.link_to(_('enable'),h.url('edit_repo',repo_name=c.repo_name))}]
                     %endif  		          
 		        %else:
-			        ${h.select('download_options',c.repo_info.get_changeset().raw_id,c.download_options)}
-			        %for cnt,archive in enumerate(c.repo_info._get_archives()):
+			        ${h.select('download_options',c.repo.get_changeset().raw_id,c.download_options)}
+			        %for cnt,archive in enumerate(c.repo._get_archives()):
 			             %if cnt >=1:
 			             |
 			             %endif
 			             <span class="tooltip" title="${_('Download %s as %s') %('tip',archive['type'])}" 
 			                  id="${archive['type']+'_link'}">${h.link_to(archive['type'],
-			                h.url('files_archive_home',repo_name=c.repo_info.name,
+			                h.url('files_archive_home',repo_name=c.repo.name,
 			                fname='tip'+archive['extension']),class_="archive_icon")}</span>
 			        %endfor
 			    %endif
 			  </div>
 			 </div>
 			 
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Feeds')}:</label>
 			  </div>
 			  <div class="input-short">
-	            ${h.link_to(_('RSS'),h.url('rss_feed_home',repo_name=c.repo_info.name),class_='rss_icon')}
-	            ${h.link_to(_('Atom'),h.url('atom_feed_home',repo_name=c.repo_info.name),class_='atom_icon')}
+	            ${h.link_to(_('RSS'),h.url('rss_feed_home',repo_name=c.repo.name),class_='rss_icon')}
+	            ${h.link_to(_('Atom'),h.url('atom_feed_home',repo_name=c.repo.name),class_='atom_icon')}
 			  </div>
 			 </div>				 			 			 
 	  </div>		 
 	</div>
   	<script type="text/javascript">
 	  	YUE.onDOMReady(function(e){
 	  	    id = 'clone_url';
 	  	    YUE.on(id,'click',function(e){
 	  	        YUD.get('clone_url').select();
 	  	    })
 	  	})
   		var data = ${c.trending_languages|n};
   		var total = 0;
   		var no_data = true;
   		for (k in data){
   		    total += data[k];
   		    no_data = false;
   		} 
 		var tbl = document.createElement('table');
 		tbl.setAttribute('class','trending_language_tbl');
 		var cnt =0;
   		for (k in data){
   			cnt+=1;
   			var hide = cnt>2;
 	  		var tr = document.createElement('tr');
 	  		if (hide){
 	  			tr.setAttribute('style','display:none');
 	  			tr.setAttribute('class','stats_hidden');
 	  		}
 	  		var percentage = Math.round((data[k]/total*100),2);
 			var value = data[k];
 	  		var td1 = document.createElement('td');
 	  		td1.width=150;
 	  		var trending_language_label = document.createElement('div');
 	  		trending_language_label.innerHTML = k;
 	  		td1.appendChild(trending_language_label);
 
 	  		var td2 = document.createElement('td');
 	  		td2.setAttribute('style','padding-right:14px !important');
   		    var trending_language = document.createElement('div');
   		    var nr_files = value+" ${_('files')}";
   		    
   		    trending_language.title = k+" "+nr_files;
   		    
   		    if (percentage>20){
   		    	trending_language.innerHTML = "<b style='font-size:0.8em'>"+percentage+"% "+nr_files+ "</b>";	
   		    }
   		    else{
   		    	trending_language.innerHTML = "<b style='font-size:0.8em'>"+percentage+"%</b>";
   		    }
   		    
   		    trending_language.setAttribute("class", 'trending_language top-right-rounded-corner bottom-right-rounded-corner');
   		    trending_language.style.width=percentage+"%";
 			td2.appendChild(trending_language);
 			
 			tr.appendChild(td1);
 			tr.appendChild(td2);
   		    tbl.appendChild(tr);
   		    if(cnt == 2){
   		    	var show_more = document.createElement('tr');
   		    	var td=document.createElement('td');
   		    	lnk = document.createElement('a');
   		    	lnk.href='#';
   		    	lnk.innerHTML = "${_("show more")}";
   		    	lnk.id='code_stats_show_more';
   		        td.appendChild(lnk);
   		    	show_more.appendChild(td);
   		    	show_more.appendChild(document.createElement('td'));
   		    	tbl.appendChild(show_more);
   		    }
   		    
   		}
   		if(no_data){
   			var tr = document.createElement('tr');
   			var td1 = document.createElement('td');
   			td1.innerHTML = "${c.no_data_msg}";
   			tr.appendChild(td1);
   			tbl.appendChild(tr);
 		}
   		YUD.get('lang_stats').appendChild(tbl);
   		YUE.on('code_stats_show_more','click',function(){
   			l = YUD.getElementsByClassName('stats_hidden')
   			for (e in l){
   			    YUD.setStyle(l[e],'display','');
   			};
   			YUD.setStyle(YUD.get('code_stats_show_more'),
   					'display','none');
   		})
   	
              
              YUE.on('download_options','change',function(e){
                  var new_cs = e.target.options[e.target.selectedIndex];
                  var tmpl_links = {}
-                 %for cnt,archive in enumerate(c.repo_info._get_archives()):
+                 %for cnt,archive in enumerate(c.repo._get_archives()):
                 	 tmpl_links['${archive['type']}'] = '${h.link_to(archive['type'],
-                        h.url('files_archive_home',repo_name=c.repo_info.name,
+                        h.url('files_archive_home',repo_name=c.repo.name,
                         fname='__CS__'+archive['extension']),class_="archive_icon")}';
                  %endfor
                 
                  
                  for(k in tmpl_links){
                 	 var s = YUD.get(k+'_link')
                 	 title_tmpl = "${_('Download %s as %s') % ('__CS_NAME__',archive['type'])}";
                 	 s.title = title_tmpl.replace('__CS_NAME__',new_cs.text)
                 	 s.innerHTML = tmpl_links[k].replace('__CS__',new_cs.value);
                  }
                  
              })
              	
   	</script>    				
 </div>
         
 <div class="box box-right"  style="min-height:455px">
     <!-- box / title -->
     <div class="title">
         <h5>${_('Commit activity by day / author')}</h5>
     </div>
     
     <div class="table">
          %if c.no_data:
            <div style="padding:0 10px 10px 15px;font-size: 1.2em;">${c.no_data_msg}
            %if h.HasPermissionAll('hg.admin')('enable stats on from summary'):
                 [${h.link_to(_('enable'),h.url('edit_repo',repo_name=c.repo_name))}]
            %endif         
            </div>
         %endif:  
         <div id="commit_history" style="width:460px;height:300px;float:left"></div>
         <div style="clear: both;height: 10px"></div>
         <div id="overview" style="width:460px;height:100px;float:left"></div>
         
     	<div id="legend_data" style="clear:both;margin-top:10px;">
 	    	<div id="legend_container"></div>
 	    	<div id="legend_choices">
 				<table id="legend_choices_tables" style="font-size:smaller;color:#545454"></table>
 	    	</div>
     	</div>
 		<script type="text/javascript">
 		/**
 		 * Plots summary graph
 		 *
 		 * @class SummaryPlot
 		 * @param {from} initial from for detailed graph
 		 * @param {to} initial to for detailed graph
 		 * @param {dataset}
 		 * @param {overview_dataset}
 		 */
 		function SummaryPlot(from,to,dataset,overview_dataset) {
 			var initial_ranges = {
 			    "xaxis":{
 				    "from":from,
 				   	"to":to,
 				},
 			};
 		    var dataset = dataset;
 		    var overview_dataset = [overview_dataset];
 		    var choiceContainer = YUD.get("legend_choices");
 		    var choiceContainerTable = YUD.get("legend_choices_tables");
 		    var plotContainer = YUD.get('commit_history');
 		    var overviewContainer = YUD.get('overview');
 		    
 		    var plot_options = {
 				bars: {show:true,align:'center',lineWidth:4},
 				legend: {show:true, container:"legend_container"},
 				points: {show:true,radius:0,fill:false},
 				yaxis: {tickDecimals:0,},
 				xaxis: {
 					mode: "time", 
 					timeformat: "%d/%m",
 				    min:from,
 				    max:to,	
 				}, 
 				grid: {
 					hoverable: true, 
 				    clickable: true,
 				    autoHighlight:true,
 				    color: "#999"
 				},
 				//selection: {mode: "x"}
 		    };
 		    var overview_options = {
 				legend:{show:false},
 			    bars: {show:true,barWidth: 2,},
 			    shadowSize: 0,
 			    xaxis: {mode: "time", timeformat: "%d/%m/%y",},
 			    yaxis: {ticks: 3, min: 0,tickDecimals:0,},
 			    grid: {color: "#999",},
 			    selection: {mode: "x"}
 			};
 
 			/**
 			*get dummy data needed in few places
 			*/
 		    function getDummyData(label){
 		    	return {"label":label,
                	 "data":[{"time":0,
                		 "commits":0,
 	                     "added":0,
 	                     "changed":0,
 	                     "removed":0,
                     }],
                     "schema":["commits"],
                     "color":'#ffffff',
            		}
 			}
 			
 		    /**
 		     * generate checkboxes accordindly to data
 		     * @param keys
 		     * @returns
 		     */
 		    function generateCheckboxes(data) {
 			    //append checkboxes
 			    var i = 0;
 			    choiceContainerTable.innerHTML = '';
 			    for(var pos in data) {
 			    	
 			    	data[pos].color = i;
 			        i++;
 			        if(data[pos].label != ''){
 				        choiceContainerTable.innerHTML += '<tr><td>'+
 				        '<input type="checkbox" name="' + data[pos].label +'" checked="checked" />'
 				        +data[pos].label+
 				        '</td></tr>';
 			        }
 			    }	
 		    }
 		    
 		    /**
 		     * ToolTip show
 		     */
 		    function showTooltip(x, y, contents) {
 		        var div=document.getElementById('tooltip');
 		        if(!div) {
 		            div = document.createElement('div');
 		            div.id="tooltip";
 		            div.style.position="absolute";
 		            div.style.border='1px solid #fdd';
 		            div.style.padding='2px';
 		            div.style.backgroundColor='#fee';
 		            document.body.appendChild(div);
 		        }
 		        YUD.setStyle(div, 'opacity', 0);
 		        div.innerHTML = contents;
 		        div.style.top=(y + 5) + "px";
 		        div.style.left=(x + 5) + "px";
 
 		        var anim = new YAHOO.util.Anim(div, {opacity: {to: 0.8}}, 0.2);
 		        anim.animate();
 		    }
 		    
 			/**
 			 * This function will detect if selected period has some changesets 
 			   for this user if it does this data is then pushed for displaying
 			   Additionally it will only display users that are selected by the checkbox
 			*/
 		    function getDataAccordingToRanges(ranges) {
 		    	
 		        var data = [];
 		        var keys = [];
 				for(var key in dataset){
 					var push = false;
 					
 					//method1 slow !!
 		            //*
 		            for(var ds in dataset[key].data){
 			            commit_data = dataset[key].data[ds];
 			            if (commit_data.time >= ranges.xaxis.from && commit_data.time <= ranges.xaxis.to){
 			            	push = true;
 			            	break;
 					    }
 				    }
 					//*/
 				    
 				    /*//method2 sorted commit data !!!
 				    
 				    var first_commit = dataset[key].data[0].time;
 				    var last_commit = dataset[key].data[dataset[key].data.length-1].time;
 				    
 				    if (first_commit >= ranges.xaxis.from && last_commit <= ranges.xaxis.to){
 						push = true;
 					}
 				    //*/
 				    
 				    if(push){			
 				    	data.push(dataset[key]);
 				    }
 				}
 				if(data.length >= 1){
 					return data;
 				} 
 				else{
 					//just return dummy data for graph to plot itself
 					return [getDummyData('')];	
 				}
 				
 		    }
 		    
 			/**
 			* redraw using new checkbox data
 			*/
 		    function plotchoiced(e,args){
 			    var cur_data = args[0];
 			    var cur_ranges = args[1];
 		    	
 				var new_data = [];
 		    	var inputs = choiceContainer.getElementsByTagName("input");
 
 		    	//show only checked labels
 		        for(var i=0; i<inputs.length; i++) {
 		            var checkbox_key = inputs[i].name;
 		            
 	                if(inputs[i].checked){
 						for(var d in cur_data){
 							if(cur_data[d].label == checkbox_key){
 								new_data.push(cur_data[d]);
 							}
 						}			                
 	    	        }
 	                else{
 		                //push dummy data to not hide the label
 						new_data.push(getDummyData(checkbox_key));
 			        }
 		        }
 					        
 		    	var new_options = YAHOO.lang.merge(plot_options, {
 		            xaxis: { 
 		  	      		min: cur_ranges.xaxis.from, 
 		  	      		max: cur_ranges.xaxis.to,
 		  	      		mode:"time",
 		  	      		timeformat: "%d/%m",
 		        	},
 		    	});
 		    	if (!new_data){
 					new_data = [[0,1]];
 				}
 		    	// do the zooming
 		       plot = YAHOO.widget.Flot(plotContainer, new_data, new_options);
 		       
 		       plot.subscribe("plotselected", plotselected);
 	
 		       //resubscribe plothover
 		       plot.subscribe("plothover", plothover);
 		        
 		       // don't fire event on the overview to prevent eternal loop
 		       overview.setSelection(cur_ranges, true);
 	
 		    }
 		    
 			/**
 		     * plot only selected items from overview
 		     * @param ranges
 		     * @returns
 		     */
 		    function plotselected(ranges,cur_data) {
 			    //updates the data for new plot
 	    		data = getDataAccordingToRanges(ranges);
 	    		generateCheckboxes(data);
 	    		
 		    	var new_options = YAHOO.lang.merge(plot_options, {
 		            xaxis: { 
 		  	      		min: ranges.xaxis.from, 
 		  	      		max: ranges.xaxis.to,
 		  	      		mode:"time",
 		  	      		timeformat: "%d/%m",
 		        	},
 		        	yaxis: { 
                         min: ranges.yaxis.from, 
                         max: ranges.yaxis.to,
                     },
                     		        	
 		    	});
 		    	// do the zooming
 		        plot = YAHOO.widget.Flot(plotContainer, data, new_options);
 
 		        plot.subscribe("plotselected", plotselected);
 
 		        //resubscribe plothover
 		        plot.subscribe("plothover", plothover);
 		        
 		        // don't fire event on the overview to prevent eternal loop
 		        overview.setSelection(ranges, true);
 
 		        //resubscribe choiced
 		        YUE.on(choiceContainer.getElementsByTagName("input"), "click", plotchoiced, [data, ranges]);
 		    }
 		    
 		    var previousPoint = null;
 
 			function plothover(o) {
 		        var pos = o.pos;
 		        var item = o.item;
 		        
 		        //YUD.get("x").innerHTML = pos.x.toFixed(2);
 		        //YUD.get("y").innerHTML = pos.y.toFixed(2);
 		        if (item) {
 		            if (previousPoint != item.datapoint) {
 		                previousPoint = item.datapoint;
 		                
 		                var tooltip = YUD.get("tooltip");
 		                if(tooltip) {
 		                	  tooltip.parentNode.removeChild(tooltip);
 		                }
 		                var x = item.datapoint.x.toFixed(2);
 		                var y = item.datapoint.y.toFixed(2);
 						
 		                if (!item.series.label){
 		                    item.series.label = 'commits';
 		                }
 		                var d = new Date(x*1000);
 		                var fd = d.toDateString()
 		                var nr_commits = parseInt(y);
 		                
 		                var cur_data = dataset[item.series.label].data[item.dataIndex];
 		                var added = cur_data.added;
 		                var changed = cur_data.changed;
 		                var removed = cur_data.removed;
 		                
 		                var nr_commits_suffix = " ${_('commits')} ";
 		                var added_suffix = " ${_('files added')} ";
 		                var changed_suffix = " ${_('files changed')} ";
 		                var removed_suffix = " ${_('files removed')} ";
 
 		                
 		                if(nr_commits == 1){nr_commits_suffix = " ${_('commit')} ";}
 						if(added==1){added_suffix=" ${_('file added')} ";}
 						if(changed==1){changed_suffix=" ${_('file changed')} ";}
 						if(removed==1){removed_suffix=" ${_('file removed')} ";}
 										                
 		                showTooltip(item.pageX, item.pageY, item.series.label + " on " + fd
 								 +'<br/>'+
 		                         nr_commits + nr_commits_suffix+'<br/>'+
 		                         added + added_suffix +'<br/>'+
 		                         changed + changed_suffix + '<br/>'+
 		                         removed + removed_suffix + '<br/>');
 		            }
 		        }
 		        else {
 		        	  var tooltip = YUD.get("tooltip");
 		        	  
 			          if(tooltip) {
 			                tooltip.parentNode.removeChild(tooltip);
 			          }
 		            previousPoint = null;
 		        }
 		    }
 			
 		    /**
 		     * MAIN EXECUTION
 		     */
 			
 			var data = getDataAccordingToRanges(initial_ranges);
 			generateCheckboxes(data);
 			
 		    //main plot
 		    var plot = YAHOO.widget.Flot(plotContainer,data,plot_options);
 		    
 			//overview
 			var overview = YAHOO.widget.Flot(overviewContainer, overview_dataset, overview_options);
 			
 			//show initial selection on overview
 			overview.setSelection(initial_ranges);    
 			
 		    plot.subscribe("plotselected", plotselected);
 		    
 		    overview.subscribe("plotselected", function (ranges) {
 		        plot.setSelection(ranges);
 		    });		
 				
 		    plot.subscribe("plothover", plothover);
 
 		    YUE.on(choiceContainer.getElementsByTagName("input"), "click", plotchoiced, [data, initial_ranges]);
 		}
 			SummaryPlot(${c.ts_min},${c.ts_max},${c.commit_data|n},${c.overview_data|n});		
 		</script>
 
     </div>
 </div>    
 
 <div class="box">    
     <div class="title">
         <div class="breadcrumbs">${h.link_to(_('Shortlog'),h.url('shortlog_home',repo_name=c.repo_name))}</div>
     </div>    
     <div class="table">
         <div id="shortlog_data">
             <%include file='../shortlog/shortlog_data.html'/>
         </div>
         ##%if c.repo_changesets:
         ##	${h.link_to(_('show more'),h.url('changelog_home',repo_name=c.repo_name))}
         ##%endif
     </div>
 </div>
 <div class="box">    
     <div class="title">
         <div class="breadcrumbs">${h.link_to(_('Tags'),h.url('tags_home',repo_name=c.repo_name))}</div>
     </div>    
     <div class="table">
         <%include file='../tags/tags_data.html'/>
         %if c.repo_changesets:
         	${h.link_to(_('show more'),h.url('tags_home',repo_name=c.repo_name))}
         %endif
     </div>
 </div>
 <div class="box">
     <div class="title">
         <div class="breadcrumbs">${h.link_to(_('Branches'),h.url('branches_home',repo_name=c.repo_name))}</div>
     </div>    
     <div class="table">
         <%include file='../branches/branches_data.html'/>
         %if c.repo_changesets:
         	${h.link_to(_('show more'),h.url('branches_home',repo_name=c.repo_name))}
         %endif
     </div>      
 </div> 
 
 </%def>