updated docs on every controller

rhodecode/controllers/admin/ldap_settings.py

@@ -1,104 +1,105 b''
 # -*- coding: utf-8 -*-
 """
-    package.rhodecode.controllers.admin.ldap_settings
-    ~~~~~~~~~~~~~~
+    rhodecode.controllers.admin.ldap_settings
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     ldap controller for RhodeCode
+    
     :created_on: Nov 26, 2010
     :author: marcink
     :copyright: (C) 2009-2010 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 formencode
 import traceback
 
 from formencode import htmlfill
 
 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.base import BaseController, render
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator
 from rhodecode.lib.auth_ldap import LdapImportError
 from rhodecode.model.settings import SettingsModel
 from rhodecode.model.forms import LdapSettingsForm
 from sqlalchemy.exc import DatabaseError
 
 log = logging.getLogger(__name__)
 
 
 
 class LdapSettingsController(BaseController):
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     def __before__(self):
         c.admin_user = session.get('admin_user')
         c.admin_username = session.get('admin_username')
         super(LdapSettingsController, self).__before__()
 
     def index(self):
         defaults = SettingsModel().get_ldap_settings()
 
         return htmlfill.render(
                     render('admin/ldap/ldap.html'),
                     defaults=defaults,
                     encoding="UTF-8",
                     force_defaults=True,)
 
     def ldap_settings(self):
         """POST ldap create and store ldap settings"""
 
         settings_model = SettingsModel()
         _form = LdapSettingsForm()()
 
         try:
             form_result = _form.to_python(dict(request.POST))
             try:
 
                 for k, v in form_result.items():
                     if k.startswith('ldap_'):
                         setting = settings_model.get(k)
                         setting.app_settings_value = v
                         self.sa.add(setting)
 
                 self.sa.commit()
                 h.flash(_('Ldap settings updated successfully'),
                     category='success')
             except (DatabaseError,):
                 raise
         except LdapImportError:
             h.flash(_('Unable to activate ldap. The "python-ldap" library '
                       'is missing.'), category='warning')
 
         except formencode.Invalid, errors:
 
             return htmlfill.render(
                 render('admin/ldap/ldap.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 ldap settings'),
                     category='error')
 
         return redirect(url('ldap_home'))

rhodecode/controllers/branches.py

@@ -1,47 +1,54 b''
-#!/usr/bin/env python
-# encoding: utf-8
-# branches controller for pylons
-# Copyright (C) 2009-2010 Marcin Kuzminski <[e-mail]>
-# 
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.controllers.branches
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    branches controller for rhodecode
+    
+    :created_on: Apr 21, 2010
+    :author: marcink
+    :copyright: (C) 2009-2010 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.
-"""
-Created on April 21, 2010
-branches controller for pylons
-@author: marcink
-"""
+
+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
-import logging
+
 log = logging.getLogger(__name__)
 
 class BranchesController(BaseController):
     
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write', 'repository.admin')
+    @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_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,99 +1,106 b''
-#!/usr/bin/env python
-# encoding: utf-8
-# changelog controller for pylons
-# Copyright (C) 2009-2010 Marcin Kuzminski <[e-mail]>
-# 
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.controllers.changelog
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    changelog controller for rhodecode
+    
+    :created_on: Apr 21, 2010
+    :author: marcink
+    :copyright: (C) 2009-2010 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.
-"""
-Created on April 21, 2010
-changelog controller for pylons
-@author: marcink
-"""
+
+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
-import logging
+
 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)
 
         p = int(request.params.get('page', 1))
         c.total_cs = len(changesets)
         c.pagination = Page(changesets, page=p, item_count=c.total_cs,
                             items_per_page=c.size)
 
         self._graph(changesets, c.size, p)
 
         return render('changelog/changelog.html')
 
 
     def _graph(self, repo, size, p):
         revcount = size
         if not repo.revisions 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/feed.py

@@ -1,80 +1,86 b''
-#!/usr/bin/env python
-# encoding: utf-8
-# feed controller for pylons
-# Copyright (C) 2009-2010 Marcin Kuzminski <[e-mail]>
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.controllers.feed
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
  
+    Feed controller for rhodecode
+    
+    :created_on: Apr 23, 2010
+    :author: marcink
+    :copyright: (C) 2009-2010 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.
-"""
-Created on April 23, 2010
-feed controller for pylons
-@author: marcink
-"""
-from pylons import tmpl_context as c, url, response
-from rhodecode.lib.base import BaseController, render
+
+
+import logging
+
+from pylons import url, response
+from rhodecode.lib.base import BaseController
 from rhodecode.model.scm import ScmModel
 from webhelpers.feedgenerator import Atom1Feed, Rss201rev2Feed
-import logging
+
 log = logging.getLogger(__name__)
 
 class FeedController(BaseController):
     
     #secure it or not ?
     def __before__(self):
         super(FeedController, self).__before__()
         #common values for feeds
         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)
 
         for cs in changesets[: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]:
             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/home.py

@@ -1,58 +1,66 b''
-#!/usr/bin/env python
-# encoding: utf-8
-# hg controller for pylons
-# Copyright (C) 2009-2010 Marcin Kuzminski <[e-mail]>
-# 
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.controllers.home
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Home controller for Rhodecode
+    
+    :created_on: Feb 18, 2010
+    :author: marcink
+    :copyright: (C) 2009-2010 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.
-"""
-Created on February 18, 2010
-hg controller for pylons
-@author: marcink
-"""
+
+import logging
 from operator import itemgetter
+
 from pylons import tmpl_context as c, request
+
 from rhodecode.lib.auth import LoginRequired
 from rhodecode.lib.base import BaseController, render
 from rhodecode.model.scm import ScmModel
-import logging
+
 log = logging.getLogger(__name__)
 
 class HomeController(BaseController):
 
     @LoginRequired()
     def __before__(self):
         super(HomeController, self).__before__()
 
     def index(self):
         sortables = ['name', 'description', 'last_change', 'tip', 'contact']
         current_sort = request.GET.get('sort', 'name')
         current_sort_slug = current_sort.replace('-', '')
 
         if current_sort_slug not in sortables:
             c.sort_by = 'name'
             current_sort_slug = c.sort_by
         else:
             c.sort_by = current_sort
         c.sort_slug = current_sort_slug
         cached_repo_list = ScmModel().get_repos()
 
         sort_key = current_sort_slug + '_sort'
         if c.sort_by.startswith('-'):
-            c.repos_list = sorted(cached_repo_list, key=itemgetter(sort_key), reverse=True)
+            c.repos_list = sorted(cached_repo_list, key=itemgetter(sort_key),
+                                  reverse=True)
         else:
-            c.repos_list = sorted(cached_repo_list, key=itemgetter(sort_key), reverse=False)
+            c.repos_list = sorted(cached_repo_list, key=itemgetter(sort_key),
+                                  reverse=False)
 
         return render('/index.html')

rhodecode/controllers/journal.py

@@ -1,93 +1,97 b''
-#!/usr/bin/env python
-# encoding: utf-8
-# journal controller for pylons
-# Copyright (C) 2009-2010 Marcin Kuzminski <[e-mail]>
-# 
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.controllers.journal
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Journal controller for pylons
+    
+    :created_on: Nov 21, 2010
+    :author: marcink
+    :copyright: (C) 2009-2010 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.
-"""
-Created on November 21, 2010
-journal controller for pylons
-@author: marcink
-"""
+
+import logging
+from sqlalchemy import or_
 
 from pylons import request, response, session, tmpl_context as c, url
-from pylons.controllers.util import abort, redirect
+
 from rhodecode.lib.auth import LoginRequired, NotAnonymous
 from rhodecode.lib.base import BaseController, render
 from rhodecode.lib.helpers import get_token
 from rhodecode.model.db import UserLog, UserFollowing
 from rhodecode.model.scm import ScmModel
-from sqlalchemy import or_
-import logging
-from paste.httpexceptions import HTTPInternalServerError, HTTPNotFound
+
+from paste.httpexceptions import HTTPInternalServerError
 
 log = logging.getLogger(__name__)
 
 class JournalController(BaseController):
 
 
     @LoginRequired()
     @NotAnonymous()
     def __before__(self):
         super(JournalController, self).__before__()
 
     def index(self):
         # Return a rendered template
 
         c.following = self.sa.query(UserFollowing)\
             .filter(UserFollowing.user_id == c.rhodecode_user.user_id).all()
 
         repo_ids = [x.follows_repository.repo_id for x in c.following
                     if x.follows_repository is not None]
         user_ids = [x.follows_user.user_id for x in c.following
                     if x.follows_user is not None]
 
         c.journal = self.sa.query(UserLog)\
             .filter(or_(
                         UserLog.repository_id.in_(repo_ids),
                         UserLog.user_id.in_(user_ids),
                         ))\
             .order_by(UserLog.action_date.desc())\
             .limit(20)\
             .all()
         return render('/journal.html')
 
     def toggle_following(self):
 
         if request.POST.get('auth_token') == get_token():
             scm_model = ScmModel()
 
             user_id = request.POST.get('follows_user_id')
             if user_id:
                 try:
                     scm_model.toggle_following_user(user_id,
                                                     c.rhodecode_user.user_id)
                     return 'ok'
                 except:
                     raise HTTPInternalServerError()
 
             repo_id = request.POST.get('follows_repo_id')
             if repo_id:
                 try:
                     scm_model.toggle_following_repo(repo_id,
                                                     c.rhodecode_user.user_id)
                     return 'ok'
                 except:
                     raise HTTPInternalServerError()
 
 
 
         raise HTTPInternalServerError()

rhodecode/controllers/login.py

@@ -1,146 +1,152 b''
-#!/usr/bin/env python
-# encoding: utf-8
-# login controller for pylons
-# Copyright (C) 2009-2010 Marcin Kuzminski <[e-mail]>
-# 
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.controllers.login
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Login controller for rhodeocode
+    
+    :created_on: Apr 22, 2010
+    :author: marcink
+    :copyright: (C) 2009-2010 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.
 
-"""
-Created on April 22, 2010
-login controller for pylons
-@author: marcink
-"""
+import logging
+import formencode
+
 from formencode import htmlfill
+
+from pylons.i18n.translation import _
+from pylons.controllers.util import abort, redirect
 from pylons import request, response, session, tmpl_context as c, url
-from pylons.controllers.util import abort, redirect
+
+import rhodecode.lib.helpers as h
 from rhodecode.lib.auth import AuthUser, HasPermissionAnyDecorator
 from rhodecode.lib.base import BaseController, render
-import rhodecode.lib.helpers as h
-from pylons.i18n.translation import _
 from rhodecode.model.forms import LoginForm, RegisterForm, PasswordResetForm
 from rhodecode.model.user import UserModel
-import formencode
-import logging
+
 
 log = logging.getLogger(__name__)
 
 class LoginController(BaseController):
 
     def __before__(self):
         super(LoginController, self).__before__()
 
     def index(self):
         #redirect if already logged in
         c.came_from = request.GET.get('came_from', None)
 
         if c.rhodecode_user.is_authenticated \
                             and c.rhodecode_user.username != 'default':
 
             return redirect(url('home'))
 
         if request.POST:
             #import Login Form validator class
             login_form = LoginForm()
             try:
                 c.form_result = login_form.to_python(dict(request.POST))
                 username = c.form_result['username']
                 user = UserModel().get_by_username(username, case_insensitive=True)
                 auth_user = AuthUser()
                 auth_user.username = user.username
                 auth_user.is_authenticated = True
                 auth_user.is_admin = user.admin
                 auth_user.user_id = user.user_id
                 auth_user.name = user.name
                 auth_user.lastname = user.lastname
                 session['rhodecode_user'] = auth_user
                 session.save()
                 log.info('user %s is now authenticated', username)
 
                 user.update_lastlogin()
 
                 if c.came_from:
                     return redirect(c.came_from)
                 else:
                     return redirect(url('home'))
 
             except formencode.Invalid, errors:
                 return htmlfill.render(
                     render('/login.html'),
                     defaults=errors.value,
                     errors=errors.error_dict or {},
                     prefix_error=False,
                     encoding="UTF-8")
 
         return render('/login.html')
 
     @HasPermissionAnyDecorator('hg.admin', 'hg.register.auto_activate',
                                'hg.register.manual_activate')
     def register(self):
         user_model = UserModel()
         c.auto_active = False
         for perm in user_model.get_by_username('default', cache=False).user_perms:
             if perm.permission.permission_name == 'hg.register.auto_activate':
                 c.auto_active = True
                 break
 
         if request.POST:
 
             register_form = RegisterForm()()
             try:
                 form_result = register_form.to_python(dict(request.POST))
                 form_result['active'] = c.auto_active
                 user_model.create_registration(form_result)
                 h.flash(_('You have successfully registered into rhodecode'),
                             category='success')
                 return redirect(url('login_home'))
 
             except formencode.Invalid, errors:
                 return htmlfill.render(
                     render('/register.html'),
                     defaults=errors.value,
                     errors=errors.error_dict or {},
                     prefix_error=False,
                     encoding="UTF-8")
 
         return render('/register.html')
 
     def password_reset(self):
         user_model = UserModel()
         if request.POST:
 
             password_reset_form = PasswordResetForm()()
             try:
                 form_result = password_reset_form.to_python(dict(request.POST))
                 user_model.reset_password(form_result)
                 h.flash(_('Your new password was sent'),
                             category='success')
                 return redirect(url('login_home'))
 
             except formencode.Invalid, errors:
                 return htmlfill.render(
                     render('/password_reset.html'),
                     defaults=errors.value,
                     errors=errors.error_dict or {},
                     prefix_error=False,
                     encoding="UTF-8")
 
         return render('/password_reset.html')
 
     def logout(self):
         session['rhodecode_user'] = AuthUser()
         session.save()
         log.info('Logging out and setting user as Empty')
         redirect(url('home'))

rhodecode/controllers/search.py

@@ -1,113 +1,120 b''
-#!/usr/bin/env python
-# encoding: utf-8
-# search controller for pylons
-# Copyright (C) 2009-2010 Marcin Kuzminski <[e-mail]>
-# 
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.controllers.search
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Search controller for rhodecode
+    
+    :created_on: Aug 7, 2010
+    :author: marcink
+    :copyright: (C) 2009-2010 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.
-"""
-Created on Aug 7, 2010
-search controller for pylons
-@author: marcink
-"""
+import logging
+import traceback
+
+from pylons.i18n.translation import _
 from pylons import request, response, config, session, tmpl_context as c, url
 from pylons.controllers.util import abort, redirect
+
 from rhodecode.lib.auth import LoginRequired
 from rhodecode.lib.base import BaseController, render
 from rhodecode.lib.indexers import SCHEMA, IDX_NAME, ResultWrapper
+
 from webhelpers.paginate import Page
 from webhelpers.util import update_params
-from pylons.i18n.translation import _
+
 from whoosh.index import open_dir, EmptyIndexError
 from whoosh.qparser import QueryParser, QueryParserError
 from whoosh.query import Phrase
-import logging
-import traceback
 
 log = logging.getLogger(__name__)
 
 class SearchController(BaseController):
 
     @LoginRequired()
     def __before__(self):
         super(SearchController, self).__before__()
 
     def index(self, search_repo=None):
         c.repo_name = search_repo
         c.formated_results = []
         c.runtime = ''
         c.cur_query = request.GET.get('q', None)
         c.cur_type = request.GET.get('type', 'source')
         c.cur_search = search_type = {'content':'content',
                                       'commit':'content',
                                       'path':'path',
                                       'repository':'repository'}\
                                       .get(c.cur_type, 'content')
 
 
         if c.cur_query:
             cur_query = c.cur_query.lower()
 
         if c.cur_query:
             p = int(request.params.get('page', 1))
             highlight_items = set()
             try:
                 idx = open_dir(config['app_conf']['index_dir']
                                , indexname=IDX_NAME)
                 searcher = idx.searcher()
 
                 qp = QueryParser(search_type, schema=SCHEMA)
                 if c.repo_name:
                     cur_query = u'repository:%s %s' % (c.repo_name, cur_query)
                 try:
                     query = qp.parse(unicode(cur_query))
 
                     if isinstance(query, Phrase):
                         highlight_items.update(query.words)
                     else:
                         for i in query.all_terms():
                             if i[0] == 'content':
                                 highlight_items.add(i[1])
 
                     matcher = query.matcher(searcher)
 
                     log.debug(query)
                     log.debug(highlight_items)
                     results = searcher.search(query)
                     res_ln = len(results)
                     c.runtime = '%s results (%.3f seconds)' \
                         % (res_ln, results.runtime)
 
                     def url_generator(**kw):
                         return update_params("?q=%s&type=%s" \
                                            % (c.cur_query, c.cur_search), **kw)
 
                     c.formated_results = Page(
                                 ResultWrapper(search_type, searcher, matcher,
                                               highlight_items),
                                 page=p, item_count=res_ln,
                                 items_per_page=10, url=url_generator)
 
 
                 except QueryParserError:
                     c.runtime = _('Invalid search query. Try quoting it.')
                 searcher.close()
             except (EmptyIndexError, IOError):
                 log.error(traceback.format_exc())
                 log.error('Empty Index data')
-                c.runtime = _('There is no index to search in. Please run whoosh indexer')
+                c.runtime = _('There is no index to search in. '
+                              'Please run whoosh indexer')
 
         # Return a rendered template
         return render('/search/search.html')

rhodecode/controllers/settings.py

@@ -1,178 +1,184 b''
-#!/usr/bin/env python
-# encoding: utf-8
-# settings controller for pylons
-# Copyright (C) 2009-2010 Marcin Kuzminski <[e-mail]>
-# 
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.controllers.settings
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Settings controller for rhodecode
+    
+    :created_on: Jun 30, 2010
+    :author: marcink
+    :copyright: (C) 2009-2010 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.
-"""
-Created on June 30, 2010
-settings controller for pylons
-@author: marcink
-"""
+
+import logging
+import traceback
+
+import formencode
 from formencode import htmlfill
+
 from pylons import tmpl_context as c, request, url
 from pylons.controllers.util import redirect
 from pylons.i18n.translation import _
+
+import rhodecode.lib.helpers as h
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAllDecorator
 from rhodecode.lib.base import BaseController, render
 from rhodecode.lib.utils import invalidate_cache, action_logger
 from rhodecode.model.forms import RepoSettingsForm, RepoForkForm
 from rhodecode.model.repo import RepoModel
-import formencode
-import logging
-import rhodecode.lib.helpers as h
-import traceback
 
 log = logging.getLogger(__name__)
 
 class SettingsController(BaseController):
 
     @LoginRequired()
     @HasRepoPermissionAllDecorator('repository.admin')
     def __before__(self):
         super(SettingsController, self).__before__()
 
     def index(self, repo_name):
         repo_model = RepoModel()
         c.repo_info = repo = repo_model.get_by_repo_name(repo_name)
         if not repo:
             h.flash(_('%s repository is not mapped to db perhaps'
                       ' it was created or renamed from the file system'
                       ' please run the application again'
                       ' in order to rescan repositories') % repo_name,
                       category='error')
 
             return redirect(url('home'))
         defaults = c.repo_info.get_dict()
         defaults.update({'user':c.repo_info.user.username})
         c.users_array = repo_model.get_users_js()
 
         for p in c.repo_info.repo_to_perm:
             defaults.update({'perm_%s' % p.user.username:
                              p.permission.permission_name})
 
         return htmlfill.render(
             render('settings/repo_settings.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
         )
 
     def update(self, repo_name):
         repo_model = RepoModel()
         changed_name = repo_name
         _form = RepoSettingsForm(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, 'user_updated_repo',
                               changed_name, '', self.sa)
         except formencode.Invalid, errors:
             c.repo_info = repo_model.get_by_repo_name(repo_name)
             c.users_array = repo_model.get_users_js()
             errors.value.update({'user':c.repo_info.user.username})
             return htmlfill.render(
                 render('settings/repo_settings.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('repo_settings_home', repo_name=changed_name))
 
 
 
     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_settings_delete', repo_name=ID),
         #           method='delete')
         # url('repo_settings_delete', 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('home'))
         try:
             action_logger(self.rhodecode_user, 'user_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:
             h.flash(_('An error occurred during deletion of %s') % repo_name,
                     category='error')
 
         return redirect(url('home'))
 
     def fork(self, repo_name):
         repo_model = RepoModel()
         c.repo_info = repo = repo_model.get_by_repo_name(repo_name)
         if not repo:
             h.flash(_('%s repository is not mapped to db perhaps'
                       ' it was created or renamed from the file system'
                       ' please run the application again'
                       ' in order to rescan repositories') % repo_name,
                       category='error')
 
             return redirect(url('home'))
 
         return render('settings/repo_fork.html')
 
 
 
     def fork_create(self, repo_name):
         repo_model = RepoModel()
         c.repo_info = repo_model.get_by_repo_name(repo_name)
         _form = RepoForkForm(old_data={'repo_type':c.repo_info.repo_type})()
         form_result = {}
         try:
             form_result = _form.to_python(dict(request.POST))
             form_result.update({'repo_name':repo_name})
             repo_model.create_fork(form_result, c.rhodecode_user)
             h.flash(_('forked %s repository as %s') \
                       % (repo_name, form_result['fork_name']),
                     category='success')
             action_logger(self.rhodecode_user,
                           'user_forked_repo:%s' % form_result['fork_name'],
                            repo_name, '', self.sa)
         except formencode.Invalid, errors:
             c.new_repo = errors.value['fork_name']
             r = render('settings/repo_fork.html')
 
             return htmlfill.render(
                 r,
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8")
         return redirect(url('home'))

rhodecode/controllers/shortlog.py

@@ -1,49 +1,56 b''
-#!/usr/bin/env python
-# encoding: utf-8
-# shortlog controller for pylons
-# Copyright (C) 2009-2010 Marcin Kuzminski <[e-mail]>
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.controllers.shortlog
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  
+    Shortlog controller for rhodecode
+    
+    :created_on: Apr 18, 2010
+    :author: marcink
+    :copyright: (C) 2009-2010 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.
-"""
-Created on April 18, 2010
-shortlog controller for pylons
-@author: marcink
-"""
+
+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
-from webhelpers.paginate import Page
-import logging
+
 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)
         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/tags.py

@@ -1,47 +1,53 b''
-#!/usr/bin/env python
-# encoding: utf-8
-# tags controller for pylons
-# Copyright (C) 2009-2010 Marcin Kuzminski <[e-mail]>
-# 
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.controllers.tags
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Tags controller for rhodecode
+    
+    :created_on: Apr 21, 2010
+    :author: marcink
+    :copyright: (C) 2009-2010 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.
-"""
-Created on April 21, 2010
-tags controller for pylons
-@author: marcink
-"""
+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
-import logging
+
 log = logging.getLogger(__name__)
 
 class TagsController(BaseController):
     
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write', 'repository.admin')       
+    @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_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')