PloneSVNView-0.1/skins/svnview_edit.cpy.metadata 0100644 0001750 0001750 00000000240 10246413450 021062 0 ustar quest quest [validators]
validators=validate_id,validate_title
[actions]
action.failure=redirect_to_action:string:edit
action.success=redirect_to_action:string:view
PloneSVNView-0.1/config.py 0100644 0001750 0001750 00000001006 10253111044 014541 0 ustar quest quest #
# PloneSVNView - a Subeversion repository viewer for Plone
#
# Author: Quest
#
# Released under GNU GPL v2 or later
#
# $Id: config.py 26 2005-06-12 19:51:00Z quest $
from Products.CMFCore import CMFCorePermissions
add_permission = CMFCorePermissions.AddPortalContent
edit_permission = CMFCorePermissions.ModifyPortalContent
view_permission = CMFCorePermissions.View
product_name = "PloneSVNView"
plone_product_name = "SVN View"
layer_name = "svnview"
layer_location = "PloneSVNView/skins"
PloneSVNView-0.1/version.txt 0100644 0001750 0001750 00000000003 10253111044 015144 0 ustar quest quest 0.1 PloneSVNView-0.1/refresh.txt 0100644 0001750 0001750 00000000031 10253111044 015116 0 ustar quest quest Placeholder for refresh
PloneSVNView-0.1/SVNView.py 0100644 0001750 0001750 00000032361 10256642716 014627 0 ustar quest quest #
# PloneSVNView - a Subeversion repository viewer for Plone
#
# Author: Quest
#
# Released under GNU GPL v2 or later
#
# $Id: SVNView.py 45 2005-06-23 23:29:18Z quest $
import os
import pysvn
import zipfile
# Plone imports; security for our objects
from Globals import InitializeClass
from AccessControl import ClassSecurityInfo
# Standard python imports
from DateTime import DateTime
from time import strftime
def join_url(*parts):
url = []
for p in parts:
if not p:
continue
if p[0] == "/":
p = p[1:]
if p[-1] == "/":
p = p[:-1]
url.append(p)
return "/".join(url)
class SVNEntry:
def __init__(self, repository, **entry):
name = entry['name']
self._repository = repository
self._path = name[len(repository):name.rfind("/")]
self._relative_name = name[name.rfind("/") + 1:]
self._url = join_url(self._repository, self._path,
self._relative_name)
self._kind = entry['kind']
self._size = entry['size']
self._last_author = entry['last_author']
self._time = DateTime(entry['time'], "GMT+0000")
self._created_rev = entry['created_rev']
self._properties = entry.get('properties', None)
self._revision = entry['revision']
security = ClassSecurityInfo()
security.declareObjectPublic()
security.setDefaultAccess("allow")
def loadProperties(self, client=pysvn.Client()):
# 0 == there should be 1 item in list
# 1 == first value is filename, second is properties
tmp = client.proplist(self._url, revision=self._revision)
if tmp:
# There are properties
self._properties = tmp[0][1]
else:
# To note that we have checked props
self._properties = { "svnview:empty": True }
def getName(self):
return self._relative_name
def getKindName(self):
if self._kind == pysvn.node_kind.file:
return 'File'
elif self._kind == pysvn.node_kind.dir:
return 'Directory'
elif self._kind == pysvn.node_kind.none:
return 'None'
else:
return repr(self._kind)
def isDirectory(self):
return self._kind == pysvn.node_kind.dir
def isFile(self):
return self._kind == pysvn.node_kind.file
def isBinary(self):
mime = self.getMimeType()
if not mime or mime.startswith("text/"):
return False
else:
return True
def getLastAuthor(self):
return self._last_author
def getSize(self):
return self._size
# plone_scripts/getObjSize expects a method with this name:
get_size = getSize
def getChangeTime(self):
return self._time
def getRevisionNumber(self):
return "%d" % self._revision.number
def getModifiedRevisionNumber(self):
return "%d" % self._created_rev.number
def getInitialRevisionDate(self):
return DateTime(self._revision.date, "GMT+0000")
def getSubPath(self):
return join_url(self._path, self._relative_name)
def getProperties(self):
return self._properties
def getMimeType(self):
if not self._properties:
self.loadProperties()
return self._properties.get("svn:mime-type", None)
def getFile(self):
if self.isDirectory():
raise RuntimeError("Cannot get file; this is a dir entry.")
client = pysvn.Client()
return client.cat(self._url, self._revision)
def getZippedArchive(self):
# Create a temporary dir do checkout in
workdir = os.tmpnam()
os.mkdir(workdir)
# checkout revision
client = pysvn.Client()
client.checkout(self._url, workdir)
# Now put it all in a zip file
tmpfile = os.tmpfile()
dazip = zipfile.ZipFile(tmpfile, 'w')
# Traverse working copy and add each file to zip
for root, dirs, files in os.walk(workdir):
for f in files:
afname = os.path.join(root, f)[len(workdir) + 1:]
if self._path:
afname = join_url(self._path, afname)
dazip.write(os.path.join(root, f), afname)
# Closing the zip file appends the metadata
dazip.close()
# Delete working directory
for root, dirs, files in os.walk(workdir, topdown=False):
for name in files:
os.remove(os.path.join(root, name))
for name in dirs:
os.rmdir(os.path.join(root, name))
# Clean up
os.rmdir(workdir)
# Prepare result file
tmpfile.seek(0)
return tmpfile
class SVNLogEntry:
def __init__(self, path, **log):
# path may be ''
if path and path[0] != '/':
path = '/' + path
self._path = path
self._date = DateTime(log['date'], "GMT+0000")
self._message = log['message']
self._author = log['author']
self._revision = log['revision']
self._changed_paths = log['changed_paths']
self._oldpath = None
self._oldrevision = None
# Algorithm: the longest matching path changed should be the
# one that is significant for this entry
p_entry = {}
for entry in [x for x in self._changed_paths if x['copyfrom_path']]:
if self._path.startswith(entry['path']) and \
len(p_entry.get('path', '')) < len(entry['path']):
p_entry = entry
if p_entry:
self._oldpath = p_entry['copyfrom_path'] + \
self._path[len(p_entry['path']):]
self._oldrevision = p_entry['copyfrom_revision']
security = ClassSecurityInfo()
security.declareObjectPublic()
security.setDefaultAccess("allow")
def getPath(self):
# Convention is to not keep initial /
return self._path[1:]
def getChangeDate(self):
return self._date
def getMessage(self):
return self._message
def getAuthor(self):
return self._author
def getRevisionNumber(self):
return "%d" % self._revision.number
def getRevisionDate(self):
return DateTime(self._revision.date, "GMT+0000")
def getOldPath(self):
# Convention is to not keep initial /
if self._oldpath:
return self._oldpath[1:]
else:
return None
def getOldRevision(self):
return "%d" % self._oldrevision.number
def getChangedPaths(self):
return [SVNLogChangedPath(**x) for x in self._changed_paths]
class SVNLogChangedPath:
def __init__(self, **entry):
self._action = entry['action']
self._path = entry['path']
self._copyfrom_path = entry['copyfrom_path']
self._copyfrom_revision = entry['copyfrom_revision']
security = ClassSecurityInfo()
security.declareObjectPublic()
security.setDefaultAccess("allow")
def getAction(self):
return self._action
def getPath(self):
return self._path
InitializeClass(SVNEntry)
InitializeClass(SVNLogEntry)
InitializeClass(SVNLogChangedPath)
def getSVNSingleEntry(repository, path, revno=None, include_props=False):
if revno:
revision = pysvn.Revision(pysvn.opt_revision_kind.number, revno)
else:
revision = pysvn.Revision(pysvn.opt_revision_kind.head)
x = pysvn.Client()
if not path:
last = x.log(repository, revision_start=revision,
revision_end=revision)[0]
last_author = last['author']
time = last['date']
created_rev = last['revision']
entry = {'name': '.', 'kind': pysvn.node_kind.dir,
'size': 0, 'last_author': last_author,
'time': time, 'created_rev': created_rev}
else:
url = join_url(repository, path)
tmp = x.ls(url, revision=revision)
if len(tmp) > 1:
# directory; look in parent for info
dirpart = url[:url.rfind("/")]
entries = x.ls(dirpart, revision=revision)
for entry in entries:
if entry['name'] == url:
break
else:
entry = tmp[0]
# Ye ugly hack; bug in pysvn
entry['name'] = entry['name'][:entry['name'].rfind("/")]
# created_rev is the revision at which the file was last
# _modified_ (as opposed to moved/copied) Thus we save request rev too
entry['revision'] = revision
e = SVNEntry(repository, **entry)
if include_props:
e.loadProperties(client=x)
return e
def getSVNEntryList(repository, subpath, revno=None):
if revno:
revision = pysvn.Revision(pysvn.opt_revision_kind.number, revno)
else:
revision = pysvn.Revision(pysvn.opt_revision_kind.head)
url = join_url(repository, subpath)
client = pysvn.Client()
files = client.ls(url, revision=revision)
# created_rev is the revision at which the file was last
# _modified_ (as opposed to moved/copied) Thus we save request rev too
for x in files:
x.update({'revision': revision})
return [SVNEntry(repository, **x) for x in files]
def getSVNLog(repository, file, start_revno=None, end_revno=None):
url = join_url(repository, file)
logargs = { 'discover_changed_paths': True,
'strict_node_history': False }
if start_revno:
logargs['revision_end'] = \
pysvn.Revision(pysvn.opt_revision_kind.number,
start_revno)
if end_revno:
logargs['revision_start'] = \
pysvn.Revision(pysvn.opt_revision_kind.number,
end_revno)
client = pysvn.Client()
entries = client.log(url, **logargs)
log_entries = []
for x in entries:
le = SVNLogEntry(file, **x)
if le.getOldPath():
file = le.getOldPath()
log_entries.append(le)
return log_entries
# start and end are revision numbers. If start is None, diff between
# end and previous revision is assumed
# start is _chronologically prior to end
def getSVNDiff(repository, file, start, end):
url = join_url(repository, file)
client = pysvn.Client()
client.exception_style = 1
if start and not end:
raise ValueError("Won't accept start revision without end revision.")
if end:
endrev = pysvn.Revision(pysvn.opt_revision_kind.number, end)
else:
endrev = pysvn.Revision(pysvn.opt_revision_kind.head)
if start:
startrev = pysvn.Revision(pysvn.opt_revision_kind.number, start)
else:
# We need to find out which revision was the previous one
# Confusing? SVN revision_start means the youngest version
log = client.log(url, revision_start=endrev)
if len(log) == 1:
startrev = pysvn.Revision(pysvn.opt_revision_kind.number, 1)
else:
startrev = log[1]["revision"]
try:
return client.diff(os.tempnam(), url,
revision1=startrev, revision2=endrev)
except pysvn.ClientError, x:
if x[1][0][1] == 160013:
raise ValueError, "Unfortunately pysvn can't diff across renames"
else:
raise x
def getSVNHeadRevision(repository):
client = pysvn.Client()
return client.log(repository)[0]['revision'].number
def trackSVNPathForward(repository, path, from_revno, to_revno=None):
"""
Return path of object at to_revno, which is identified by path at
from_revno. This is a reasonably expensive operation and should be
used only when necessary.
"""
if path[0] != '/':
path = '/' + path
if to_revno:
torev = pysvn.Revision(pysvn.opt_revision_kind.number, to_revno)
else:
torev = pysvn.Revision(pysvn.opt_revision_kind.head)
fromrev = pysvn.Revision(pysvn.opt_revision_kind.number, from_revno)
x = pysvn.Client()
entries = x.log(repository, discover_changed_paths=True,
revision_start=torev, revision_end=fromrev)
entries.reverse()
found = False
prevpath = path
for entry in entries:
dapath = {}
for potpath in [x for x in entry['changed_paths']
if x['copyfrom_path'] and x['action'] == 'A']:
if prevpath.startswith(potpath['copyfrom_path']):
if len(potpath['path']) > len(dapath.get('path', '')):
dapath = potpath
else:
raise ValueError, "multiple addition of %s in rev %d" % \
(prevpath, entry['revision'].number)
if dapath:
found = False
# make certain there is a 'D' entry; only follow moves, not copys
for potpath in [x for x in entry['changed_paths']
if x['action'] == 'D']:
if prevpath.startswith(potpath['path']):
found = True
break
if not found:
raise ValueError, "%s (%s) duplicated in rev %d" % \
(path, prevpath, entry['revision'].number)
prevpath = dapath['path'] + prevpath[len(dapath['copyfrom_path']):]
# Dump initial /
return prevpath[1:]
PloneSVNView-0.1/readme.txt 0100644 0001750 0001750 00000000726 10253111044 014730 0 ustar quest quest PloneSVNView
Author: Quest
This is a Plone product which displays the contents of your
Subversion-held source repository.
Major features
* Navigate source tree
* Diff between arbitrary versions of a file
* Review revision history
* Get single files or zip bundles of whole or parts of repository
Installation
Installation instructions are contained in install.txt
License
This product is licensed under the GPL.
PloneSVNView-0.1/Extensions/ 0040755 0001750 0001750 00000000000 10256650117 015103 5 ustar quest quest PloneSVNView-0.1/Extensions/Install.py 0100644 0001750 0001750 00000003517 10253100471 017054 0 ustar quest quest #
# PloneSVNView - a Subeversion repository viewer for Plone
#
# Author: Quest
#
# Released under GNU GPL v2 or later
#
# $Id: Install.py 25 2005-06-12 18:38:49Z quest $
from Products.CMFCore.DirectoryView import createDirectoryView
from Products.CMFCore.utils import getToolByName
from Products.CMFCore.TypesTool import FactoryTypeInformation as fti_klass
from Products.PloneSVNView.config import plone_product_name, product_name
from Products.PloneSVNView.config import layer_name, layer_location
def install(self):
""" Install this product """
out = []
typesTool = getToolByName(self, 'portal_types')
skinsTool = getToolByName(self, 'portal_skins')
if id not in typesTool.objectIds():
typesTool.manage_addTypeInformation(
fti_klass.meta_type,
id = plone_product_name,
typeinfo_name = "%s: %s" % (product_name, product_name)
)
out.append('Registered with the types tool')
else:
out.append('Object "%s" already existed in the types tool' % (id))
# add in the directory view pointing to our skin
if layer_name not in skinsTool.objectIds():
createDirectoryView(skinsTool, layer_location, layer_name)
out.append('Added "%s" directory view to portal_skins' % layer_name)
# add in the layer to all our skins
skins = skinsTool.getSkinSelections()
for skin in skins:
path = skinsTool.getSkinPath(skin)
path = [ p.strip() for p in path.split(',') ]
if layer_name not in path:
path.insert(path.index('custom')+1, layer_name)
path = ", ".join(path)
skinsTool.addSkinSelection(skin, path)
out.append('Added "%s" to "%s" skins' % (layer_name, skin))
else:
out.append('Skipping "%s" skin' % skin)
return "\n".join(out)
PloneSVNView-0.1/PloneSVNView.py 0100644 0001750 0001750 00000016076 10256361331 015621 0 ustar quest quest #
# PloneSVNView - a Subeversion repository viewer for Plone
#
# Author: Quest
#
# Released under GNU GPL v2 or later
#
# $Id: PloneSVNView.py 43 2005-06-22 22:14:49Z quest $
from Globals import InitializeClass
from App.Common import rfc1123_date
from AccessControl import ClassSecurityInfo
from Products.CMFDefault.DublinCore import DefaultDublinCoreImpl
from Products.CMFCore.PortalContent import PortalContent
from webdav.Lockable import ResourceLockedError
from config import product_name, plone_product_name
from config import add_permission, edit_permission, view_permission
from SVNView import *
from types import IntType, StringType
factory_type_information = {
'id': plone_product_name,
'meta_type': product_name,
'description': ('Exposes an SVN repository, or a part of it.'),
'product': product_name,
'factory': 'addPloneSVNView',
'content_icon': 'icons/svnview.gif',
'immediate_view': 'view',
'actions': (
{'id': 'view',
'name': 'View',
'action': 'svnview_view',
'permissions': (view_permission,)},
{'id': 'revisions',
'name': 'Revisions',
'action': 'svnview_revisions',
'permissions': (view_permission,)},
{'id': 'edit',
'name': 'Edit',
'action': 'svnview_edit_form',
'permissions': (edit_permission,)},
),
}
def addPloneSVNView(self, id, REQUEST=None):
""" This is our factory function and creates an empty PloneSVNView
object inside our Plone site"""
obj = PloneSVNView(id)
self._setObject(id, obj)
class PloneSVNView(PortalContent, DefaultDublinCoreImpl):
meta_type = product_name
__implements__ = (
PortalContent.__implements__,
DefaultDublinCoreImpl.__implements__
)
security = ClassSecurityInfo()
def __init__(self, id):
DefaultDublinCoreImpl.__init__(self)
self.id = id
self._repository_url = ""
security.declareProtected(view_permission, "getEntry")
def getEntry(self, path, revision=None, include_props=False):
return getSVNSingleEntry(self._repository_url,
path, revno=revision,
include_props=include_props)
security.declareProtected(edit_permission, "getRepositoryUrl")
def getRepositoryUrl(self):
return self._repository_url
security.declareProtected(view_permission, "getRepositoryList")
def getRepositoryList(self, subpath=None, revision=None):
return getSVNEntryList(self._repository_url, subpath, revno=revision)
security.declareProtected(view_permission, "getLog")
def getLog(self, path, revision=None):
return getSVNLog(self._repository_url, path, end_revno=revision)
security.declareProtected(view_permission, "getDiff")
def getDiff(self, file, revisions):
if type(revisions) is StringType or type(revisions) is IntType:
revisions = [revisions]
if len(revisions) > 1:
end = revisions[0]
start = revisions[1]
elif len(revisions) == 1:
start = None
end = revisions[0]
else:
start, end = (None, None)
return getSVNDiff(self._repository_url, file, start, end)
security.declareProtected(view_permission, "getArchive")
def getArchive(self, REQUEST, RESPONSE):
"""The doc string."""
directory = REQUEST.form['path']
revision = REQUEST.form.get('revision', None)
entry = getSVNSingleEntry(self._repository_url, directory, revno=revision)
f = entry.getZippedArchive()
fname = "%s-%s-%s.zip" % \
(self.title,
entry.getSubPath().replace("/", "_"),
entry.getRevisionNumber())
RESPONSE.setHeader('Last-Modified', rfc1123_date(entry.getChangeTime()))
RESPONSE.setHeader('Content-Type', "application/zip")
#RESPONSE.setHeader('Content-Length', entry.getSize())
RESPONSE.setHeader('Content-Disposition',
'attachment; filename="%s"' % fname)
while 1:
data = f.read()
if not data:
break
RESPONSE.write(data)
f.close()
security.declareProtected(view_permission, "getRawFile")
def getRawFile(self, REQUEST, RESPONSE):
"""The doc string."""
# Get required parameters
file = REQUEST.form['path']
revno = REQUEST.form.get('revision', None)
# Get an SVNEntry representing file
entry = self.getEntry(file, revision=revno)
# Do some mimetype guessing
mime = entry.getMimeType()
if not mime or mime == "application/octet-stream":
# Subversion didn't know mimetype (octet-stream just means
# it knows it's binary)
if self.mimetypes_registry:
# There is an Archetypes registry installed; use it
mti = self.mimetypes_registry.lookupExtension(entry.getName())
if mti:
# We got a MimeTypeItem; get its normalized name
mime = mti.normalized()
if not mime:
mime = "text/plain"
RESPONSE.setHeader('Last-Modified', rfc1123_date(entry.getChangeTime()))
RESPONSE.setHeader('Content-Type', mime)
RESPONSE.setHeader('Content-Length', entry.getSize())
RESPONSE.setHeader('Content-Disposition',
'attachment; filename="%s"' % entry.getName())
RESPONSE.write(entry.getFile())
security.declareProtected(edit_permission, "edit")
def edit(self, url, safety_belt=""):
self._repository_url = url
security.declareProtected(view_permission, "getLatestRevision")
def getLatestRevision(self):
return getSVNHeadRevision(self._repository_url)
security.declareProtected(view_permission, "findPathAtPeg")
def findPathAtPeg(self, path, peg_revno, revno):
"""This function returns the location of (path, peg_revno) at
revision revno. So if /skins moved to /trunk/skins at rev 26, and
path=/trunk/skins, peg_revno=27, revno=25, this function will
return /skins. This may be an expensive operation if peg - revno
is large."""
oldpath = None
peg_revno = int(peg_revno)
revno = int(revno)
if peg_revno >= revno:
# This is the easy case; we just need to track the path
# changes detected by SVNLogEntry
entries = getSVNLog(self._repository_url, path,
start_revno=revno, end_revno=peg_revno)
entries.reverse()
for x in entries:
oldpath = x.getOldPath()
if oldpath:
break
else:
oldpath = trackSVNPathForward(self._repository_url, path,
to_revno=revno, from_revno=peg_revno)
return oldpath or path
InitializeClass(PloneSVNView)
PloneSVNView-0.1/__init__.py 0100644 0001750 0001750 00000001455 10253111044 015043 0 ustar quest quest #
# PloneSVNView - a Subeversion repository viewer for Plone
#
# Author: Quest
#
# Released under GNU GPL v2 or later
#
# $Id: __init__.py 26 2005-06-12 19:51:00Z quest $
import PloneSVNView
from Products.CMFCore import utils
from Products.CMFCore.DirectoryView import registerDirectory
from config import product_name, add_permission
contentConstructors = (PloneSVNView.addPloneSVNView,)
contentClasses = (PloneSVNView.PloneSVNView,)
contentFTI = (PloneSVNView.factory_type_information,)
registerDirectory('skins', globals())
def initialize(context):
product = utils.ContentInit(product_name,
content_types = contentClasses,
permission = add_permission,
extra_constructors = contentConstructors,
fti = contentFTI)
product.initialize(context)
