first implementation of #34 changeset raw diff based on udiff from python

pylons_app/templates/changeset/raw_changeset.html

@@ -0,0 +1,8 b''
+# HG changeset patch
+# User ${c.changeset.author}
+# Date ${"%d %d" % c.changeset._ctx.date()}
+# Node ID ${c.changeset._hex}
+# ${c.parent_tmpl}
+${c.changeset.message}
+
+${c.diffs|n}
  No newline at end of file

pylons_app/config/routing.py

@@ -1,164 +1,167 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 __future__ import with_statement
 from routes import Mapper
 from pylons_app.lib.utils import check_repo_fast as cr
 
 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')
     
     def check_repo(environ, match_dict):
         """
         check for valid repository for proper 404 handling
         @param environ:
         @param match_dict:
         """
         repo_name = match_dict.get('repo_name')
         return not cr(repo_name, config['base_path'])
  
     #REST REPO MAP
     with map.submapper(path_prefix='/_admin', controller='admin/repos') as m:
         m.connect("repos", "/repos",
              action="create", conditions=dict(method=["POST"]))
         m.connect("repos", "/repos",
              action="index", conditions=dict(method=["GET"]))
         m.connect("formatted_repos", "/repos.{format}",
              action="index",
             conditions=dict(method=["GET"]))
         m.connect("new_repo", "/repos/new",
              action="new", conditions=dict(method=["GET"]))
         m.connect("formatted_new_repo", "/repos/new.{format}",
              action="new", conditions=dict(method=["GET"]))
         m.connect("/repos/{repo_name:.*}",
              action="update", conditions=dict(method=["PUT"],
                                               function=check_repo))
         m.connect("/repos/{repo_name:.*}",
              action="delete", conditions=dict(method=["DELETE"],
                                               function=check_repo))
         m.connect("edit_repo", "/repos/{repo_name:.*}/edit",
              action="edit", conditions=dict(method=["GET"],
                                             function=check_repo))
         m.connect("formatted_edit_repo", "/repos/{repo_name:.*}.{format}/edit",
              action="edit", conditions=dict(method=["GET"],
                                             function=check_repo))
         m.connect("repo", "/repos/{repo_name:.*}",
              action="show", conditions=dict(method=["GET"],
                                             function=check_repo))
         m.connect("formatted_repo", "/repos/{repo_name:.*}.{format}",
              action="show", conditions=dict(method=["GET"],
                                             function=check_repo))
         #ajax delete repo perm user
         m.connect('delete_repo_user', "/repos_delete_user/{repo_name:.*}",
              action="delete_perm_user", conditions=dict(method=["DELETE"],
                                                         function=check_repo))
         
     map.resource('user', 'users', controller='admin/users', path_prefix='/_admin')
     map.resource('permission', 'permissions', controller='admin/permissions', path_prefix='/_admin')
     
     #REST SETTINGS MAP
     with map.submapper(path_prefix='/_admin', controller='admin/settings') as m:
         m.connect("admin_settings", "/settings",
              action="create", conditions=dict(method=["POST"]))
         m.connect("admin_settings", "/settings",
              action="index", conditions=dict(method=["GET"]))
         m.connect("formatted_admin_settings", "/settings.{format}",
              action="index", conditions=dict(method=["GET"]))
         m.connect("admin_new_setting", "/settings/new",
              action="new", conditions=dict(method=["GET"]))
         m.connect("formatted_admin_new_setting", "/settings/new.{format}",
              action="new", conditions=dict(method=["GET"]))
         m.connect("/settings/{setting_id}",
              action="update", conditions=dict(method=["PUT"]))
         m.connect("/settings/{setting_id}",
              action="delete", conditions=dict(method=["DELETE"]))
         m.connect("admin_edit_setting", "/settings/{setting_id}/edit",
              action="edit", conditions=dict(method=["GET"]))
         m.connect("formatted_admin_edit_setting", "/settings/{setting_id}.{format}/edit",
              action="edit", conditions=dict(method=["GET"]))
         m.connect("admin_setting", "/settings/{setting_id}",
              action="show", conditions=dict(method=["GET"]))
         m.connect("formatted_admin_setting", "/settings/{setting_id}.{format}",
              action="show", conditions=dict(method=["GET"]))
         m.connect("admin_settings_my_account", "/my_account",
              action="my_account", conditions=dict(method=["GET"]))
         m.connect("admin_settings_my_account_update", "/my_account_update",
              action="my_account_update", conditions=dict(method=["PUT"]))
         m.connect("admin_settings_create_repository", "/create_repository",
              action="create_repository", conditions=dict(method=["GET"]))
     
     #ADMIN
     with map.submapper(path_prefix='/_admin', controller='admin/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')
     #SEARCH
     map.connect('search', '/_admin/search', controller='search')
     
     #LOGIN/LOGOUT
     map.connect('login_home', '/_admin/login', controller='login')
     map.connect('logout_home', '/_admin/logout', controller='login', action='logout')
     map.connect('register', '/_admin/register', controller='login', action='register')
         
     #FEEDS
     map.connect('rss_feed_home', '/{repo_name:.*}/feed/rss',
                 controller='feed', action='rss',
                 conditions=dict(function=check_repo))
     map.connect('atom_feed_home', '/{repo_name:.*}/feed/atom',
                 controller='feed', action='atom',
                 conditions=dict(function=check_repo))
     
     
     #OTHERS
     map.connect('changeset_home', '/{repo_name:.*}/changeset/{revision}',
                 controller='changeset', revision='tip',
                 conditions=dict(function=check_repo))
+    map.connect('raw_changeset_home', '/{repo_name:.*}/raw-changeset/{revision}',
+                controller='changeset',action='raw_changeset', revision='tip',
+                conditions=dict(function=check_repo))
     map.connect('summary_home', '/{repo_name:.*}/summary',
                 controller='summary', conditions=dict(function=check_repo))
     map.connect('shortlog_home', '/{repo_name:.*}/shortlog',
                 controller='shortlog', conditions=dict(function=check_repo))
     map.connect('branches_home', '/{repo_name:.*}/branches',
                 controller='branches', conditions=dict(function=check_repo))
     map.connect('tags_home', '/{repo_name:.*}/tags',
                 controller='tags', conditions=dict(function=check_repo))
     map.connect('changelog_home', '/{repo_name:.*}/changelog',
                 controller='changelog', conditions=dict(function=check_repo))    
     map.connect('files_home', '/{repo_name:.*}/files/{revision}/{f_path:.*}',
                 controller='files', revision='tip', f_path='',
                 conditions=dict(function=check_repo))
     map.connect('files_diff_home', '/{repo_name:.*}/diff/{f_path:.*}',
                 controller='files', action='diff', revision='tip', f_path='',
                 conditions=dict(function=check_repo))
     map.connect('files_raw_home', '/{repo_name:.*}/rawfile/{revision}/{f_path:.*}',
                 controller='files', action='rawfile', revision='tip', f_path='',
                 conditions=dict(function=check_repo))
     map.connect('files_annotate_home', '/{repo_name:.*}/annotate/{revision}/{f_path:.*}',
                 controller='files', action='annotate', revision='tip', f_path='',
                 conditions=dict(function=check_repo))    
     map.connect('files_archive_home', '/{repo_name:.*}/archive/{revision}/{fileformat}',
                 controller='files', action='archivefile', revision='tip',
                 conditions=dict(function=check_repo))
     map.connect('repo_settings_update', '/{repo_name:.*}/settings',
                 controller='settings', action="update",
                 conditions=dict(method=["PUT"], function=check_repo))
     map.connect('repo_settings_home', '/{repo_name:.*}/settings',
                 controller='settings', action='index',
                 conditions=dict(function=check_repo))
 
     
     return map

pylons_app/controllers/changeset.py

@@ -1,97 +1,136 b''
 #!/usr/bin/env python
 # encoding: utf-8
 # changeset controller for pylons
 # Copyright (C) 2009-2010 Marcin Kuzminski <[e-mail]>
- 
 # 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 25, 2010
 changeset controller for pylons
 @author: marcink
 """
-from pylons import tmpl_context as c, url, request
+from pylons import tmpl_context as c, url, request, response
 from pylons.controllers.util import redirect
 from pylons_app.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from pylons_app.lib.base import BaseController, render
 from pylons_app.model.hg_model import HgModel
 from vcs.exceptions import RepositoryError
 from vcs.nodes import FileNode
 from vcs.utils import diffs as differ
 import logging
 import traceback
 
 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 = HgModel()
         try:
             c.changeset = hg_model.get_repo(c.repo_name).get_changeset(revision)
         except RepositoryError:
             log.error(traceback.format_exc())
             return redirect(url('hg_home'))
         else:
             try:
                 c.changeset_old = c.changeset.parents[0]
             except IndexError:
                 c.changeset_old = None
             c.changes = []
             
             for node in c.changeset.added:
                 filenode_old = FileNode(node.path, '')
                 if filenode_old.is_binary or node.is_binary:
                     diff = 'binary file'
                 else:    
                     f_udiff = differ.get_udiff(filenode_old, node)
                     diff = differ.DiffProcessor(f_udiff).as_html()
-                    try:
-                        diff = unicode(diff)
-                    except:
-                        log.warning('Decoding failed of %s', filenode_old)
-                        log.warning('Decoding failed of %s', node)
-                        diff = 'unsupported type'
+
                 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_old.get_node(node.path)
                 if filenode_old.is_binary or node.is_binary:
                     diff = 'binary file'
                 else:    
                     f_udiff = differ.get_udiff(filenode_old, node)
                     diff = differ.DiffProcessor(f_udiff).as_html()
-                    try:
-                        diff = unicode(diff)
-                    except:
-                        log.warning('Decoding failed of %s', filenode_old)
-                        log.warning('Decoding failed of %s', node)                    
-                        diff = 'unsupported type'
+
                 cs1 = filenode_old.last_changeset.raw_id
                 cs2 = node.last_changeset.raw_id                    
                 c.changes.append(('changed', node, diff, cs1, cs2))
                 
             for node in c.changeset.removed:
                 c.changes.append(('removed', node, None, None, None))            
             
         return render('changeset/changeset.html')
+
+    def raw_changeset(self,revision):
+        
+        hg_model = HgModel()
+        try:
+            c.changeset = hg_model.get_repo(c.repo_name).get_changeset(revision)
+        except RepositoryError:
+            log.error(traceback.format_exc())
+            return redirect(url('hg_home'))
+        else:
+            try:
+                c.changeset_old = c.changeset.parents[0]
+            except IndexError:
+                c.changeset_old = None
+            c.changes = []
+            
+            for node in c.changeset.added:
+                filenode_old = FileNode(node.path, '')
+                if filenode_old.is_binary or node.is_binary:
+                    diff = 'binary file'
+                else:    
+                    f_udiff = differ.get_udiff(filenode_old, node)
+                    diff = differ.DiffProcessor(f_udiff).raw_diff()
+
+                cs1 = None
+                cs2 = node.last_changeset.raw_id                                        
+                c.changes.append(('added', node, diff, cs1, cs2))
+                
+            for node in c.changeset.changed:
+                filenode_old = c.changeset_old.get_node(node.path)
+                if filenode_old.is_binary or node.is_binary:
+                    diff = 'binary file'
+                else:    
+                    f_udiff = differ.get_udiff(filenode_old, node)
+                    diff = differ.DiffProcessor(f_udiff).raw_diff()
+
+                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'
+
+        parent = True if len(c.changeset.parents) > 0 else False
+        c.parent_tmpl = 'Parent  %s' % c.changeset.parents[0]._hex if parent else ''
+    
+        c.diffs = ''
+        for x in c.changes:
+            c.diffs += x[2]
+            
+        return render('changeset/raw_changeset.html')