Updated template for summary (archives links)

added nex prev revision to file browser.
updated logic in files to implement next and prev revison switch

pylons_app/config/routing.py

@@ -1,53 +1,56 b''
 """Routes configuration
 
 The more specific and detailed routes should be defined first so they
 may take precedent over the more generic routes. For more information
 refer to the routes manual at http://routes.groovie.org/docs/
 """
 from routes import Mapper
 
 def make_map(config):
     """Create, configure and return the routes Mapper"""
     map = Mapper(directory=config['pylons.paths']['controllers'],
                  always_scan=config['debug'])
     map.minimization = False
     map.explicit = False
 
     # The ErrorController route (handles 404/500 error pages); it should
     # likely stay at the top, ensuring it can always be resolved
     map.connect('/error/{action}', controller='error')
     map.connect('/error/{action}/{id}', controller='error')
 
     # CUSTOM ROUTES HERE
     map.connect('hg_home', '/', controller='hg', action='index')
     
     
     #REST controllers
     map.resource('repo', 'repos', path_prefix='/_admin')
     map.resource('user', 'users', path_prefix='/_admin')
     
     #ADMIN
     with map.submapper(path_prefix='/_admin', controller='admin') as m:
         m.connect('admin_home', '/', action='index')#main page
-        m.connect('admin_add_repo', '/add_repo/{new_repo:[a-z0-9\. _-]*}', action='add_repo')
+        m.connect('admin_add_repo', '/add_repo/{new_repo:[a-z0-9\. _-]*}',
+                  action='add_repo')
     
     
     map.connect('changeset_home', '/{repo_name}/changeset/{revision}',
                 controller='changeset', revision='tip')
     map.connect('summary_home', '/{repo_name}/summary',
                 controller='summary')
     map.connect('shortlog_home', '/{repo_name}/shortlog/{revision}',
                 controller='shortlog', revision='tip')
     map.connect('branches_home', '/{repo_name}/branches',
                 controller='branches')
     map.connect('tags_home', '/{repo_name}/tags',
                 controller='tags')
     map.connect('changelog_home', '/{repo_name}/changelog/{revision}',
                 controller='changelog', revision='tip')    
     map.connect('files_home', '/{repo_name}/files/{revision}/{f_path:.*}',
                 controller='files', revision='tip', f_path='')
     map.connect('files_diff_home', '/{repo_name}/diff/{f_path:.*}',
                 controller='files', action='diff', revision='tip', f_path='')
     map.connect('files_raw_home', '/{repo_name}/rawfile/{revision}/{f_path:.*}',
                 controller='files', action='rawfile', revision='tip', f_path='')
+    map.connect('files_archive_home', '/{repo_name}/archive/{revision}/{fileformat}',
+                controller='files', action='archivefile', revision='tip')
     return map

pylons_app/controllers/files.py

@@ -1,93 +1,108 b''
 import logging
 
 from pylons import request, response, session, tmpl_context as c, url, config, app_globals as g
 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 difflib import unified_diff
 from pylons_app.lib.differ import render_udiff
 from vcs.exceptions import RepositoryError, ChangesetError
         
 log = logging.getLogger(__name__)
 
 class FilesController(BaseController):
     def __before__(self):
         c.repos_prefix = config['repos_name']
         c.repo_name = get_repo_slug(request)
 
     def index(self, repo_name, revision, f_path):
         hg_model = HgModel()
         c.repo = repo = hg_model.get_repo(c.repo_name)
+        revision = request.POST.get('at_rev', None) or revision
         
-        revision = request.POST.get('at_rev', None) or revision
-        if request.POST.get('view_low'):
-            revision = int(revision) - 1
-        if request.POST.get('view_high'):
-            revision = int(revision) + 1
+        def get_next_rev(cur):
             max_rev = len(c.repo.revisions) - 1
-            if revision > max_rev:
-                revision = max_rev
+            r = cur + 1
+            if r > max_rev:
+                r = max_rev
+            return r
+            
+        def get_prev_rev(cur):
+            r = cur - 1
+            return r
                 
         c.f_path = f_path
 
         
         try:
-            c.changeset = repo.get_changeset(repo._get_revision(revision))
+            cur_rev = repo.get_changeset(revision).revision
+            prev_rev = repo.get_changeset(get_prev_rev(cur_rev)).raw_id
+            next_rev = repo.get_changeset(get_next_rev(cur_rev)).raw_id
+                    
+            c.url_prev = url('files_home', repo_name=c.repo_name,
+                             revision=prev_rev, f_path=f_path) 
+            c.url_next = url('files_home', repo_name=c.repo_name,
+                             revision=next_rev, f_path=f_path)   
+                    
+            c.changeset = repo.get_changeset(revision)
             try:
                 c.file_msg = c.changeset.get_file_message(f_path)
             except:
                 c.file_msg = None
                         
             c.cur_rev = c.changeset.raw_id
             c.rev_nr = c.changeset.revision
             c.files_list = c.changeset.get_node(f_path)
             c.file_history = self._get_history(repo, c.files_list, f_path)
             
         except (RepositoryError, ChangesetError):
             c.files_list = None
         
         return render('files/files.html')
 
     def rawfile(self, repo_name, revision, f_path):
         hg_model = HgModel()
         c.repo = hg_model.get_repo(c.repo_name)
         file_node = c.repo.get_changeset(revision).get_node(f_path)
         response.headers['Content-type'] = file_node.mimetype
         response.headers['Content-disposition'] = 'attachment; filename=%s' \
                                                     % f_path.split('/')[-1] 
         return file_node.content
     
+    def archivefile(self, repo_name, revision, fileformat):
+        return '%s %s %s' % (repo_name, revision, fileformat)
+    
     def diff(self, repo_name, f_path):
         hg_model = HgModel()
         diff1 = request.GET.get('diff1')
         diff2 = request.GET.get('diff2')
         c.no_changes = diff1 == diff2
         c.f_path = f_path
         c.repo = hg_model.get_repo(c.repo_name)
         c.changeset_1 = c.repo.get_changeset(diff1)
         c.changeset_2 = c.repo.get_changeset(diff2)
         
         c.file_1 = c.changeset_1.get_file_content(f_path)
         c.file_2 = c.changeset_2.get_file_content(f_path)
         c.diff1 = 'r%s:%s' % (c.changeset_1.revision, c.changeset_1._short)
         c.diff2 = 'r%s:%s' % (c.changeset_2.revision, c.changeset_2._short)
 
         d2 = unified_diff(c.file_1.splitlines(1), c.file_2.splitlines(1))
         c.diff_files = render_udiff(udiff=d2)
         
         if len(c.diff_files) < 1:
             c.no_changes = True
         return render('files/file_diff.html')
     
     def _get_history(self, repo, node, f_path):
         from vcs.nodes import NodeKind
         if not node.kind is NodeKind.FILE:
             return []
         changesets = node.history
         hist_l = []
         for chs in changesets:
             n_desc = 'r%s:%s' % (chs.revision, chs._short)
             hist_l.append((chs._short, n_desc,))
         return hist_l

pylons_app/templates/files/files_browser.html

@@ -1,66 +1,66 b''
 <%def name="file_class(node)">
 	%if node.is_file():
 		<%return "browser-file" %>
 	%else:
 		<%return "browser-dir"%>
 	%endif
 </%def>
 <div id="body" class="browserblock">
 	<div class="browser-header">
 		${h.form(h.url.current())}
-		<span>${_('view')}@rev ${h.submit('view_low','-')}${h.text('at_rev',value=c.rev_nr,size='5')}${h.submit('view_high','+')}</span>
+		<span>${_('view')}@rev <a style="font-size: 1.3em"  href="${c.url_prev}">&laquo;</a>${h.text('at_rev',value=c.rev_nr,size='5')}<a style="font-size: 1.3em" href="${c.url_next}">&raquo;</a></span>
 		${h.submit('view','view')}
 		${h.end_form()}
 	</div>
 	<div class="browser-body">		
 		<table class="code-browser">
 		         <thead>
 		             <tr>
 		                 <th>${_('Name')}</th>
 		                 <th>${_('Size')}</th>
 		                 <th>${_('Revision')}</th>
 		                 <th>${_('Last modified')}</th>
 		                 <th>${_('Last commiter')}</th>
 		             </tr>
 		         </thead>
 		         	<tr class="parity0">
 		          		<td>
 		          		% if c.files_list.parent:
 		          			${h.link_to('..',h.url('files_home',repo_name=c.repo_name,revision=c.cur_rev,f_path=c.files_list.parent.path),class_="browser-dir")}
 		          		%endif
 		          		</td>
 		          		<td></td>
 		          		<td></td>
 		          		<td></td>
 		          		<td></td>
 		         	</tr>
 		    %for cnt,node in enumerate(c.files_list,1):
 				<tr class="parity${cnt%2}">
 		             <td>
 						${h.link_to(node.name,h.url('files_home',repo_name=c.repo_name,revision=c.cur_rev,f_path=node.path),class_=file_class(node))}
 		             </td>
 		             <td>
 		                %if node.is_file():
 		             		${h.filesizeformat(node.size)}
 		             	%endif
 		             </td>
 		             <td>
 		             	%if node.is_file():
 		             		${node.last_changeset.revision}
 		             	%endif
 		             </td>
 		             <td>
 		             	%if node.is_file():
 		             		${node.last_changeset.date}
 		             	%endif
 		             </td>
 		             <td>
 		             	%if node.is_file():
 		             		${node.last_changeset.author}
 		             	%endif                    
 		             </td>
 				</tr>
 			%endfor
 		</table>
 	</div>
 </div>
  No newline at end of file

pylons_app/templates/summary.html

@@ -1,125 +1,127 b''
 <%inherit file="/base/base.html"/>
 <%!
 from pylons_app.lib import filters
 %>
 <%def name="title()">
     ${_('Repository managment')}
 </%def>
 <%def name="breadcrumbs()">
     ${h.link_to(u'Home',h.url('/'))}
     / 
     ${h.link_to(c.repo_name,h.url('summary_home',repo_name=c.repo_name))}
     /
     ${_('summary')}
 </%def>
 <%def name="page_nav()">
         <form action="log">
             <dl class="search">
                 <dt><label>Search: </label></dt>
                 <dd><input type="text" name="rev" /></dd>
             </dl>
         </form>
 
 		${self.menu('summary')}    
 </%def>
 <%def name="main()">
 
     <h2 class="no-link no-border">${_('Mercurial Repository Overview')}</h2>
     <dl class="overview">
         <dt>${_('name')}</dt>
         <dd>${c.repo_info.name}</dd>
         <dt>${_('description')}</dt>
         <dd>${c.repo_info.description}</dd>
         <dt>${_('contact')}</dt>
         <dd>${c.repo_info.contact}</dd>
         <dt>${_('last change')}</dt>
         <dd>${c.repo_info.last_change|n,filters.rfc822date} - ${c.repo_info.last_change|n,filters.age}</dd>
         <dt>${_('url')}</dt>
         <dd><pre>hg clone <a href="${c.clone_repo_url}">${c.clone_repo_url}</a></pre></dd>
         <dt>${_('Download')}</dt>
         <dd>
-       	%for archive in c.repo_info._get_archives():
-				| <a href="/${c.repo_info.name}/archive/${archive['node']}${archive['extension']}">
-				${c.repo_info.name}.${archive['type']}
-				</a>
+       	%for cnt,archive in enumerate(c.repo_info._get_archives()):
+       		 %if cnt >=1:
+       		 |
+       		 %endif
+       		 ${h.link_to(c.repo_info.name+'.'+archive['type'],
+       			h.url('files_archive_home',repo_name=c.repo_info.name,
+       			revision='tip',fileformat=archive['extension']))}
 		%endfor
-		| 
         </dd>
     </dl>
 
     <h2>${h.link_to(_('Changes'),h.url('changelog_home',repo_name=c.repo_name))}</h2>
     <table>
 	<%def name="message_slug(msg)">
 		<%
 		limit = 60
 		if len(msg) > limit:
 			return msg[:limit]+'...'
 		else:
 			return msg
 		%>
 	</%def>    
 	%for cnt,cs in enumerate(c.repo_changesets):
 		<tr class="parity${cnt%2}">
 			<td>${cs._ctx.date()|n,filters.age}</td>
 			<td>${cs.author|n,filters.person}</td>
 			<td>
 				${h.link_to(message_slug(cs.message),
 				h.url('changeset_home',repo_name=c.repo_name,revision=cs._short),
 				title=cs.message)}
 			</td>
 			<td>
 				<span class="logtags">
 					<span class="branchtag">${cs.branch}</span>
 					%for tag in cs.tags:
 						<span class="tagtag">${tag}</span>
 					%endfor
 				</span>
 			</td>
 			<td class="nowrap">
 			${h.link_to(_('changeset'),h.url('changeset_home',repo_name=c.repo_name,revision=cs._short))}
 			|
 			${h.link_to(_('files'),h.url('files_home',repo_name=c.repo_name,revision=cs._short))}
 			</td>
 		</tr>
 	%endfor
     </table>
 
     <h2>${h.link_to(_('Tags'),h.url('tags_home',repo_name=c.repo_name))}</h2>
     <table>
 		%for cnt,tag in enumerate(c.repo_tags):
 		<tr class="parity${cnt%2}">
 			<td>${tag._ctx.date()|n,filters.age}</td>
 			<td>
 				<span class="logtags">
 					<span class="tagtag">${h.link_to(tag.tags[-1],h.url('changeset_home',repo_name=c.repo_name,revision=tag._short))}</span>
 				</span>
 			</td>
 			<td class="nowrap">
 			${h.link_to(_('changeset'),h.url('changeset_home',repo_name=c.repo_name,revision=tag._short))}
 			|
 			${h.link_to(_('files'),h.url('files_home',repo_name=c.repo_name,revision=tag._short))}
 			</td>
 		</tr>	
 		%endfor
     </table>
 
     <h2>${h.link_to(_('Branches'),h.url('branches_home',repo_name=c.repo_name))}</h2>
     <table>
 		%for cnt,branch in enumerate(c.repo_branches):
 		<tr class="parity${cnt%2}">
 			<td>${branch._ctx.date()|n,filters.age}</td>
 			<td>
 				<span class="logtags">
 					<span class="branchtag">${h.link_to(branch.branch,h.url('changeset_home',repo_name=c.repo_name,revision=branch._short))}</span>
 				</span>			
 			</td>
 			<td class="nowrap">
 			${h.link_to(_('changeset'),h.url('changeset_home',repo_name=c.repo_name,revision=branch._short))}
 			|
 			${h.link_to(_('files'),h.url('files_home',repo_name=c.repo_name,revision=branch._short))}
 			</td>
 		</tr>	
 		%endfor
     </table>
 
 </%def>    
  No newline at end of file