added empty controllers for branches tags files graph, routing and test for them

pylons_app/controllers/branches.py

@@ -0,0 +1,16 b''
+import logging
+
+from pylons import request, response, session, tmpl_context as c, url
+from pylons.controllers.util import abort, redirect
+
+from pylons_app.lib.base import BaseController, render
+
+log = logging.getLogger(__name__)
+
+class BranchesController(BaseController):
+
+    def index(self):
+        # Return a rendered template
+        #return render('/branches.mako')
+        # or, return a string
+        return 'Hello World'

pylons_app/controllers/changelog.py

@@ -0,0 +1,29 b''
+import logging
+
+from pylons import tmpl_context as c, app_globals as g, session, request, config, url
+from pylons.controllers.util import abort, redirect
+
+from pylons_app.lib.base import BaseController, render
+from pylons_app.lib.utils import get_repo_slug
+from pylons_app.model.hg_model import HgModel
+from webhelpers.paginate import Page
+
+log = logging.getLogger(__name__)
+
+class ChangelogController(BaseController):
+    def __before__(self):
+        c.repos_prefix = config['repos_name']
+        c.staticurl = g.statics
+        c.repo_name = get_repo_slug(request)
+        
+        
+    def index(self):
+        hg_model = HgModel()
+        p = int(request.params.get('page', 1))
+        repo = hg_model.get_repo(c.repo_name)
+        c.repo_changesets = Page(repo, page=p, items_per_page=20)
+        c.shortlog_data = render('shortlog_data.html')
+        if request.params.get('partial'):
+            return c.shortlog_data
+        r = render('/shortlog.html')
+        return r

pylons_app/controllers/file.py

@@ -0,0 +1,16 b''
+import logging
+
+from pylons import request, response, session, tmpl_context as c, url
+from pylons.controllers.util import abort, redirect
+
+from pylons_app.lib.base import BaseController, render
+
+log = logging.getLogger(__name__)
+
+class FileController(BaseController):
+
+    def index(self):
+        # Return a rendered template
+        #return render('/file.mako')
+        # or, return a string
+        return 'Hello World'

pylons_app/controllers/files.py

@@ -0,0 +1,16 b''
+import logging
+
+from pylons import request, response, session, tmpl_context as c, url
+from pylons.controllers.util import abort, redirect
+
+from pylons_app.lib.base import BaseController, render
+
+log = logging.getLogger(__name__)
+
+class FilesController(BaseController):
+
+    def index(self):
+        # Return a rendered template
+        #return render('/files.mako')
+        # or, return a string
+        return 'Hello World'

pylons_app/controllers/graph.py

@@ -0,0 +1,16 b''
+import logging
+
+from pylons import request, response, session, tmpl_context as c, url
+from pylons.controllers.util import abort, redirect
+
+from pylons_app.lib.base import BaseController, render
+
+log = logging.getLogger(__name__)
+
+class GraphController(BaseController):
+
+    def index(self):
+        # Return a rendered template
+        #return render('/graph.mako')
+        # or, return a string
+        return 'Hello World'

pylons_app/controllers/tags.py

@@ -0,0 +1,16 b''
+import logging
+
+from pylons import request, response, session, tmpl_context as c, url
+from pylons.controllers.util import abort, redirect
+
+from pylons_app.lib.base import BaseController, render
+
+log = logging.getLogger(__name__)
+
+class TagsController(BaseController):
+
+    def index(self):
+        # Return a rendered template
+        #return render('/tags.mako')
+        # or, return a string
+        return 'Hello World'

pylons_app/tests/functional/test_branches.py

@@ -0,0 +1,7 b''
+from pylons_app.tests import *
+
+class TestBranchesController(TestController):
+
+    def test_index(self):
+        response = self.app.get(url(controller='branches', action='index'))
+        # Test response...

pylons_app/tests/functional/test_changelog.py

@@ -0,0 +1,7 b''
+from pylons_app.tests import *
+
+class TestChangelogController(TestController):
+
+    def test_index(self):
+        response = self.app.get(url(controller='changelog', action='index'))
+        # Test response...

pylons_app/tests/functional/test_file.py

@@ -0,0 +1,7 b''
+from pylons_app.tests import *
+
+class TestFileController(TestController):
+
+    def test_index(self):
+        response = self.app.get(url(controller='file', action='index'))
+        # Test response...

pylons_app/tests/functional/test_files.py

@@ -0,0 +1,7 b''
+from pylons_app.tests import *
+
+class TestFilesController(TestController):
+
+    def test_index(self):
+        response = self.app.get(url(controller='files', action='index'))
+        # Test response...

pylons_app/tests/functional/test_graph.py

@@ -0,0 +1,7 b''
+from pylons_app.tests import *
+
+class TestGraphController(TestController):
+
+    def test_index(self):
+        response = self.app.get(url(controller='graph', action='index'))
+        # Test response...

pylons_app/tests/functional/test_tags.py

@@ -0,0 +1,7 b''
+from pylons_app.tests import *
+
+class TestTagsController(TestController):
+
+    def test_index(self):
+        response = self.app.get(url(controller='tags', action='index'))
+        # Test response...

development.ini

@@ -1,127 +1,128 b''
 ################################################################################
 ################################################################################
 # pylons_app - Pylons environment configuration                                #
 #                                                                              # 
 # The %(here)s variable will be replaced with the parent directory of this file#
 ################################################################################
 
 [DEFAULT]
 debug = true
 ############################################
 ## Uncomment and replace with the address ##
 ## which should receive any error reports ##
 ############################################
 #email_to = [e-mail]
 #smtp_server = mail.etelko.pl
 #error_email_from = paste_error@localhost
 #smtp_username = 
 #smtp_password = 
 #error_message = 'mercurial crash !'
 
 [server:main]
 ##nr of threads to spawn
 threadpool_workers = 5
 
 ##max request before
 threadpool_max_requests = 2
 
 ##option to use threads of process
 use_threadpool = true
 
 use = egg:Paste#http
 host = 127.0.0.1
 port = 5000
 
 [app:main]
 use = egg:pylons_app
 full_stack = true
 static_files = true
 lang=en
 cache_dir = %(here)s/data
 repos_name = Python-works
 
 ####################################
 ###         BEAKER CACHE        ####
 ####################################
 beaker.cache.data_dir=/tmp/cache/data
 beaker.cache.lock_dir=/tmp/cache/lock
 beaker.cache.regions=short_term
 beaker.cache.short_term.type=memory
-beaker.cache.short_term.expire=3600
+beaker.cache.short_term.expire=60
     
 ################################################################################
 ## WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*  ##
 ## Debug mode will enable the interactive debugging tool, allowing ANYONE to  ##
 ## execute malicious code after an exception is raised.                       ##
 ################################################################################
 #set debug = false
 
 ##################################
 ###       LOGVIEW CONFIG       ###
 ##################################
 logview.sqlalchemy = #faa
 logview.pylons.templating = #bfb
 logview.pylons.util = #eee
 
 #########################################################
 ### DB CONFIGS - EACH DB WILL HAVE IT'S OWN CONFIG    ###
 #########################################################
 sqlalchemy.db1.url = sqlite:///%(here)s/hg_app.db
-#sqlalchemy.db1.echo = True
+#sqlalchemy.db1.echo = False
 #sqlalchemy.db1.pool_recycle = 3600
 sqlalchemy.convert_unicode = true
 
 ################################
 ### LOGGING CONFIGURATION   ####
 ################################
 [loggers]
 keys = root, routes, pylons_app, sqlalchemy
 
 [handlers]
 keys = console
 
 [formatters]
 keys = generic
 
 #############
 ## LOGGERS ##
 #############
 [logger_root]
 level = NOTSET
 handlers = console
 
 [logger_routes]
 level = DEBUG
 handlers = console
 qualname = routes.middleware
 # "level = DEBUG" logs the route matched and routing variables.
 
 [logger_pylons_app]
 level = DEBUG
 handlers = console
 qualname = pylons_app
 
 
 [logger_sqlalchemy]
-level = DEBUG
+level = INFO
 handlers = console
 qualname = sqlalchemy.engine
+propagate = 0
 
 ##############
 ## HANDLERS ##
 ##############
 
 [handler_console]
 class = StreamHandler
 args = (sys.stderr,)
 level = NOTSET
 formatter = generic
 
 ################
 ## FORMATTERS ##
 ################
 
 [formatter_generic]
 format = %(asctime)s,%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
 datefmt = %Y-%m-%d %H:%M:%S
 

pylons_app/controllers/hg.py

@@ -1,65 +1,84 b''
 #!/usr/bin/python
 # -*- coding: utf-8 -*-
-import logging
+from mako.template import Template
+from mercurial.hg import repository
+from mercurial.hgweb import hgweb
+from mercurial.hgweb.request import wsgiapplication
+from mercurial.localrepo import localrepository
+from operator import itemgetter
 from pylons import tmpl_context as c, app_globals as g, session, request, config
+from pylons.controllers.util import abort
 from pylons_app.lib import helpers as h
 from pylons_app.lib.base import BaseController, render
-from mako.template import Template
-from pylons.controllers.util import abort
 from pylons_app.lib.utils import get_repo_slug
-from operator import itemgetter
 from pylons_app.model.hg_model import HgModel
+import logging
+import os
+from beaker.cache import cache_region
 log = logging.getLogger(__name__)
 
 class HgController(BaseController):
 
     def __before__(self):
         c.repos_prefix = config['repos_name']
         c.staticurl = g.statics
         c.repo_name = get_repo_slug(request)
         
     def index(self):
+        
+
         hg_model = HgModel()
-        c.repos_list = list(hg_model.get_repos())
+        @cache_region('short_term', 'repo_list')
+        def _list():
+            return list(hg_model.get_repos())
+        
+        c.repos_list = _list()
         c.current_sort = request.GET.get('sort', 'name')
         
         cs = c.current_sort
         c.cs_slug = cs.replace('-', '')
         sortables = ['name', 'description', 'last_change', 'tip', 'contact']
         
         if cs and c.cs_slug in sortables:
             sort_key = c.cs_slug + '_sort'
             if cs.startswith('-'):
                 c.repos_list.sort(key=itemgetter(sort_key), reverse=True)
             else:
                 c.repos_list.sort(key=itemgetter(sort_key), reverse=False)
             
         return render('/index.html')
 
-    def view(self, *args, **kwargs):
-        #TODO: reimplement this not tu use hgwebdir
+    def view(self, environ, start_response, path_info):
+        print path_info
+        
+        def app_maker():           
     
-        response = g.hgapp(request.environ, self.start_response)
+            path = os.path.join(g.base_path, c.repo_name)
+            repo = repository(g.baseui, path)
+            hgwebapp = hgweb(repo, c.repo_name)
+            return hgwebapp
+        
+        a = wsgiapplication(app_maker)
+        resp = a(environ, start_response)
         
         http_accept = request.environ.get('HTTP_ACCEPT', False)
         if not http_accept:
             return abort(status_code=400, detail='no http accept in header')
         
         #for mercurial protocols and raw files we can't wrap into mako
         if http_accept.find("mercurial") != -1 or \
         request.environ['PATH_INFO'].find('raw-file') != -1:
-                    return response
+                    return resp
         try:
-            tmpl = u''.join(response)
+            tmpl = u''.join(resp)
             template = Template(tmpl, lookup=request.environ['pylons.pylons']\
                             .config['pylons.app_globals'].mako_lookup)
                         
         except (RuntimeError, UnicodeDecodeError):
             log.info('disabling unicode due to encoding error')
-            response = g.hgapp(request.environ, self.start_response)
-            tmpl = ''.join(response)
+            resp = g.hgapp(request.environ, self.start_response)
+            tmpl = ''.join(resp)
             template = Template(tmpl, lookup=request.environ['pylons.pylons']\
                             .config['pylons.app_globals'].mako_lookup, disable_unicode=True)
 
-
         return template.render(g=g, c=c, session=session, h=h)

pylons_app/controllers/shortlog.py

@@ -1,34 +1,29 b''
 import logging
 
 from pylons import tmpl_context as c, app_globals as g, session, request, config, url
 from pylons.controllers.util import abort, redirect
 
 from pylons_app.lib.base import BaseController, render
 from pylons_app.lib.utils import get_repo_slug
 from pylons_app.model.hg_model import HgModel
 from webhelpers.paginate import Page
 
 log = logging.getLogger(__name__)
 
 class ShortlogController(BaseController):
     def __before__(self):
         c.repos_prefix = config['repos_name']
         c.staticurl = g.statics
         c.repo_name = get_repo_slug(request)
         
         
     def index(self):
         hg_model = HgModel()
-        lim = 20
         p = int(request.params.get('page', 1))
         repo = hg_model.get_repo(c.repo_name)
-        cnt = repo.revisions[-1]
-        gen = repo.get_changesets(None)
-        repo_changesets = list(gen)
-         
-        c.repo_changesets = Page(repo_changesets, page=p, item_count=cnt, items_per_page=lim)
+        c.repo_changesets = Page(repo, page=p, items_per_page=20)
         c.shortlog_data = render('shortlog_data.html')
         if request.params.get('partial'):
             return c.shortlog_data
         r = render('/shortlog.html')
         return r

pylons_app/lib/app_globals.py

@@ -1,74 +1,92 b''
 """The application's Globals object"""
 #uncomment the following if you want to serve a single repo
 #from mercurial.hgweb.hgweb_mod import hgweb
 from mercurial.hgweb.hgwebdir_mod import hgwebdir
 from mercurial import templater
 from mercurial.hgweb.request import wsgiapplication
 from mercurial import ui, config
 import os
 from beaker.cache import CacheManager
 from beaker.util import parse_cache_config_options
 
 class Globals(object):
 
     """Globals acts as a container for objects available throughout the
     life of the application
 
     """
 
     def __init__(self, config):
         """One instance of Globals is created during application
         initialization and is available during requests via the
         'app_globals' variable
 
         """
         self.cache = CacheManager(**parse_cache_config_options(config))
-        self.hgapp = wsgiapplication(self.make_web_app)
+        self.baseui = self.make_ui('hgwebdir.config')
+
+
+    def make_ui(self, path='hgwebdir.config'):        
+        """
+        A funcion that will read python rc files and make an ui from read options
 
-    def make_web_app(self):
-        repos = "hgwebdir.config"
+        @param path: path to mercurial config file
+        """
+        #propagated from mercurial documentation
+        sections = [
+                    'alias',
+                    'auth',
+                    'decode/encode',
+                    'defaults',
+                    'diff',
+                    'email',
+                    'extensions',
+                    'format',
+                    'merge-patterns',
+                    'merge-tools',
+                    'hooks',
+                    'http_proxy',
+                    'smtp',
+                    'patch',
+                    'paths',
+                    'profiling',
+                    'server',
+                    'trusted',
+                    'ui',
+                    'web',
+                    ]
+    
+        repos = path
         baseui = ui.ui()
         cfg = config.config()
         cfg.read(repos)
-        paths = cfg.items('paths')
-        self.paths = paths
-        self.check_repo_dir(paths)
-        
+        self.paths = cfg.items('paths')
+        self.base_path = self.paths[0][1].replace('*', '')
+        self.check_repo_dir(self.paths)
         self.set_statics(cfg)
 
-        for k, v in cfg.items('web'):
-            baseui.setconfig('web', k, v)
-        #magic trick to make our custom template dir working
-        templater.path.append(cfg.get('web', 'templates', None))
-        self.baseui = baseui
-        #baseui.setconfig('web', 'description', '')
-        #baseui.setconfig('web', 'name', '')
-        #baseui.setconfig('web', 'contact', '')
-        #baseui.setconfig('web', 'allow_archive', '')
-        #baseui.setconfig('web', 'style', 'monoblue_plain')
-        #baseui.setconfig('web', 'baseurl', '')
-        #baseui.setconfig('web', 'staticurl', '')
+        for section in sections:
+            for k, v in cfg.items(section):
+                baseui.setconfig(section, k, v)
         
-        hgwebapp = hgwebdir(paths, baseui=baseui)
-        return hgwebapp
-
+        return baseui
 
     def set_statics(self, cfg):
         '''
         set's the statics for use in mako templates
         @param cfg:
         '''
         self.statics = cfg.get('web', 'staticurl', '/static')
         if not self.statics.endswith('/'):
             self.statics += '/'
 
 
     def check_repo_dir(self, paths):
         repos_path = paths[0][1].split('/')
         if repos_path[-1] in ['*', '**']:
             repos_path = repos_path[:-1]
         if repos_path[0] != '/':
             repos_path[0] = '/'
         if not os.path.isdir(os.path.join(*repos_path)):
             raise Exception('Not a valid repository in %s' % paths[0][1])
 

pylons_app/lib/utils.py

@@ -1,7 +1,8 b''
    
 def get_repo_slug(request):
     path_info = request.environ.get('PATH_INFO')
-    repo_name = path_info.split('/')[-2]
-    action = path_info.split('/')[-1]
-    
+    uri_lst = path_info.split('/')
+    print uri_lst
+    print 'len', len(uri_lst)    
+    repo_name = uri_lst[1]
     return repo_name

pylons_app/model/hg_model.py

@@ -1,59 +1,60 b''
 #!/usr/bin/env python
 # encoding: utf-8
 #
 # Copyright (c) 2010 marcink.  All rights reserved.
 #
 '''
 Created on Apr 9, 2010
 
 @author: marcink
 '''
 import os
 from pylons import tmpl_context as c, app_globals as g, session, request, config
 from pylons.controllers.util import abort
 try:
     from vcs.backends.hg import get_repositories, MercurialRepository
 except ImportError:
     print 'You have to import vcs module'
+    raise
 
 class HgModel(object):
     """
     Mercurial Model
     """
 
 
     def __init__(self):
         """
         Constructor
         """
         pass
 
     def get_repos(self):
         for mercurial_repo in get_repositories(g.paths[0][0], g.paths[0][1], g.baseui):
             
             if mercurial_repo._get_hidden():
                 #skip hidden web repository
                 continue
             
             last_change = mercurial_repo.last_change
             tip = mercurial_repo.repo.changectx('tip')
             tmp_d = {}
             tmp_d['name'] = mercurial_repo.name
             tmp_d['name_sort'] = tmp_d['name']
             tmp_d['description'] = mercurial_repo.description
             tmp_d['description_sort'] = tmp_d['description']
             tmp_d['last_change'] = last_change
             tmp_d['last_change_sort'] = last_change[1] - last_change[0]
             tmp_d['tip'] = str(tip)
             tmp_d['tip_sort'] = tip.rev()
             tmp_d['rev'] = tip.rev()
             tmp_d['contact'] = mercurial_repo.contact
             tmp_d['contact_sort'] = tmp_d['contact']
-            tmp_d['repo_archives'] = mercurial_repo._get_archives()
+            tmp_d['repo_archives'] = list(mercurial_repo._get_archives())
             
             yield tmp_d
 
     def get_repo(self, repo_name):
         path = g.paths[0][1].replace('*', '')
         repo = MercurialRepository(os.path.join(path, repo_name), baseui=g.baseui)
         return repo