[CMF-checkins] CVS: CMF/CMFCore - DirectoryView.py:1.43.2.1
utils.py:1.53.2.1
Yvo Schubbe
y.2004_ at wcm-solutions.de
Sun May 16 13:13:22 EDT 2004
Update of /cvs-repository/CMF/CMFCore
In directory cvs.zope.org:/tmp/cvs-serv9014/CMFCore
Modified Files:
Tag: yuppie-collector210-branch
DirectoryView.py utils.py
Log Message:
- refactored path handling to make it work with any products path: 'filepath' is now always the absolute filepath, minimal_fp the cross-platform / cross-setup relative path.
=== CMF/CMFCore/DirectoryView.py 1.43 => 1.43.2.1 ===
--- CMF/CMFCore/DirectoryView.py:1.43 Thu Apr 29 12:13:16 2004
+++ CMF/CMFCore/DirectoryView.py Sun May 16 13:12:51 2004
@@ -17,8 +17,8 @@
import re
from os import path, listdir, stat
-import sys
from sys import exc_info
+from sys import platform
from types import StringType
from AccessControl import ClassSecurityInfo
@@ -33,13 +33,14 @@
from OFS.ObjectManager import bad_id
from zLOG import LOG, ERROR
-from permissions import AccessContentsInformation
-from permissions import ManagePortal
from FSMetadata import FSMetadata
from FSObject import BadFile
+from permissions import AccessContentsInformation
+from permissions import ManagePortal
from utils import _dtmldir
-from utils import expandpath
from utils import minimalpath
+from utils import normalize
+
__reload_module__ = 0
@@ -68,12 +69,13 @@
_v_last_read = 0
_v_last_filelist = [] # Only used on Win32
- def __init__(self, expanded_fp, minimal_fp):
- self.filepath = minimal_fp
+ def __init__(self, filepath, minimal_fp):
+ self._filepath = filepath
+ self._minimal_fp = minimal_fp
subdirs = []
- for entry in _filtered_listdir(expanded_fp):
- e_fp = path.join(expanded_fp, entry)
- if path.isdir(e_fp):
+ for entry in _filtered_listdir(self._filepath):
+ entry_filepath = path.join(self._filepath, entry)
+ if path.isdir(entry_filepath):
subdirs.append(entry)
self.subdirs = tuple(subdirs)
@@ -91,13 +93,11 @@
self.data = None
def _readTypesFile(self):
- '''
- Reads the .objects file produced by FSDump.
- '''
+ """ Read the .objects file produced by FSDump.
+ """
types = {}
- fp = expandpath(self.filepath)
try:
- f = open( path.join(fp, '.objects'), 'rt' )
+ f = open( path.join(self._filepath, '.objects'), 'rt' )
except IOError:
pass
else:
@@ -118,14 +118,13 @@
mtime=0
filelist=[]
try:
- fp = expandpath(self.filepath)
- mtime = stat(fp)[8]
- if sys.platform == 'nt':
+ mtime = stat(self._filepath)[8]
+ if platform == 'nt':
# some Windows directories don't change mtime
# when a file is added to or deleted from them :-(
# So keep a list of files as well, and see if that
# changes
- path.walk(fp,_walker,filelist)
+ path.walk(self._filepath, _walker, filelist)
filelist.sort()
except:
LOG('DirectoryView',
@@ -164,23 +163,22 @@
def prepareContents(self, registry, register_subdirs=0):
# Creates objects for each file.
- fp = expandpath(self.filepath)
data = {}
objects = []
types = self._readTypesFile()
- for entry in _filtered_listdir(fp):
+ for entry in _filtered_listdir(self._filepath):
if not self._isAllowableFilename(entry):
continue
- e_filepath = path.join(self.filepath, entry)
- e_fp = expandpath(e_filepath)
- if path.isdir(e_fp):
+ entry_minimal_fp = '/'.join( (self._minimal_fp, entry) )
+ entry_filepath = path.join(self._filepath, entry)
+ if path.isdir(entry_filepath):
# Add a subdirectory only if it was previously registered,
# unless register_subdirs is set.
- info = registry.getDirectoryInfo(e_filepath)
+ info = registry.getDirectoryInfo(entry_minimal_fp)
if info is None and register_subdirs:
# Register unknown subdirs
- registry.registerDirectoryByPath(e_fp)
- info = registry.getDirectoryInfo(e_filepath)
+ registry.registerDirectoryByPath(entry_filepath)
+ info = registry.getDirectoryInfo(entry_minimal_fp)
if info is not None:
mt = types.get(entry)
t = None
@@ -188,7 +186,7 @@
t = registry.getTypeByMetaType(mt)
if t is None:
t = DirectoryView
- ob = t(entry, e_filepath)
+ ob = t(entry, entry_minimal_fp)
ob_id = ob.getId()
data[ob_id] = ob
objects.append({'id': ob_id, 'meta_type': ob.meta_type})
@@ -217,10 +215,10 @@
t = registry.getTypeByExtension(ext)
if t is not None:
- metadata = FSMetadata(e_fp)
+ metadata = FSMetadata(entry_filepath)
metadata.read()
try:
- ob = t(name, e_filepath, fullname=entry,
+ ob = t(name, entry_minimal_fp, fullname=entry,
properties=metadata.getProperties())
except:
import traceback
@@ -233,7 +231,7 @@
'\n'.join(exc_lines) )
ob = BadFile( name,
- e_filepath,
+ entry_minimal_fp,
exc_str='\r\n'.join(exc_lines),
fullname=entry )
finally:
@@ -312,26 +310,23 @@
# The idea is that the registry will only contain
# small paths that are likely to work across platforms
# and SOFTWARE_HOME, INSTANCE_HOME and PRODUCTS_PATH setups
- fp = minimalpath(filepath)
- normfilepath = path.normpath(filepath)
- self._directories[fp] = di = DirectoryInformation(normfilepath, fp)
+ minimal_fp = minimalpath(filepath)
+ info = DirectoryInformation(filepath, minimal_fp)
+ self._directories[minimal_fp] = info
if subdirs:
- for entry in di.getSubdirs():
- e_filepath = path.join(normfilepath, entry)
- self.registerDirectoryByPath(e_filepath, subdirs)
+ for entry in info.getSubdirs():
+ entry_filepath = path.join(filepath, entry)
+ self.registerDirectoryByPath(entry_filepath, subdirs)
- def reloadDirectory(self, filepath):
- info = self.getDirectoryInfo(filepath)
+ def reloadDirectory(self, minimal_fp):
+ info = self.getDirectoryInfo(minimal_fp)
if info is not None:
info.reload()
- def getDirectoryInfo(self, filepath):
+ def getDirectoryInfo(self, minimal_fp):
# This is called when we need to get hold of the information
- # for a minimal path.
- # minimalpath is called on the supplied path on the hope
- # that if it is incorrect, something can be done to fix it.
- # Can return None.
- return self._directories.get(minimalpath(filepath), None)
+ # for a minimal path. Can return None.
+ return self._directories.get(minimal_fp, None)
def listDirectories(self):
dirs = self._directories.keys()
@@ -380,8 +375,8 @@
class DirectoryView (Persistent):
- '''
- '''
+ """ Directory views link to filesystem directories.
+ """
meta_type = 'Filesystem Directory View'
_dirpath = None
_objects = ()
@@ -392,13 +387,21 @@
def __of__(self, parent):
info = _dirreg.getDirectoryInfo(self._dirpath)
- if info is not None:
- info = info.getContents(_dirreg)
+ if info is None:
+ # for DirectoryViews created with CMF versions before 1.5
+ # this is basically the old minimalpath() code
+ self._dirpath = normalize(self._dirpath)
+ index = self._dirpath.rfind('Products')
+ if index == -1:
+ index = self._dirpath.rfind('products')
+ if index != -1:
+ self._dirpath = self._dirpath[index+len('products/'):]
+ info = _dirreg.getDirectoryInfo(self._dirpath)
if info is None:
data = {}
objects = ()
else:
- data, objects = info
+ data, objects = info.getContents(_dirreg)
s = DirectoryViewSurrogate(self, data, objects)
res = s.__of__(parent)
return res
@@ -438,8 +441,7 @@
security.declareProtected(ManagePortal, 'manage_properties')
def manage_properties( self, dirpath, REQUEST=None ):
- """
- Update the directory path of the DV.
+ """ Update the directory path of the DirectoryView.
"""
self.__dict__['_real']._dirpath = dirpath
if REQUEST is not None:
@@ -455,10 +457,8 @@
security.declareProtected(AccessContentsInformation, 'listCustFolderPaths')
def listCustFolderPaths(self, adding_meta_type=None):
- '''
- Returns a list of possible customization folders
- as key, value pairs.
- '''
+ """ List possible customization folders as key, value pairs.
+ """
rval = []
ob = self.getCustomizableObject()
listFolderHierarchy(ob, '', rval, adding_meta_type)
@@ -478,49 +478,45 @@
manage_addDirectoryViewForm = HTMLFile('dtml/addFSDirView', globals())
-def createDirectoryView(parent, filepath, id=None):
- '''
- Adds either a DirectoryView or a derivative object.
- '''
- info = _dirreg.getDirectoryInfo(filepath)
+def createDirectoryView(parent, minimal_fp, id=None):
+ """ Add either a DirectoryView or a derivative object.
+ """
+ info = _dirreg.getDirectoryInfo(minimal_fp)
if info is None:
- raise ValueError('Not a registered directory: %s' % filepath)
+ raise ValueError('Not a registered directory: %s' % minimal_fp)
if not id:
- id = path.split(filepath)[-1]
+ id = minimal_fp.split('/')[-1]
else:
id = str(id)
- ob = DirectoryView(id, filepath)
+ ob = DirectoryView(id, minimal_fp)
parent._setObject(id, ob)
def addDirectoryViews(ob, name, _prefix):
- '''
- Adds a directory view for every subdirectory of the
- given directory.
- '''
- # Meant to be called by filesystem-based code.
- # Note that registerDirectory() still needs to be called
- # by product initialization code to satisfy
- # persistence demands.
+ """ Add a directory view for every subdirectory of the given directory.
+
+ Meant to be called by filesystem-based code. Note that registerDirectory()
+ still needs to be called by product initialization code to satisfy
+ persistence demands.
+ """
if not isinstance(_prefix, StringType):
_prefix = package_home(_prefix)
- fp = path.join(_prefix, name)
- filepath = minimalpath(fp)
- info = _dirreg.getDirectoryInfo(filepath)
+ filepath = path.join(_prefix, name)
+ minimal_fp = minimalpath(filepath)
+ info = _dirreg.getDirectoryInfo(minimal_fp)
if info is None:
- raise ValueError('Not a registered directory: %s' % filepath)
+ raise ValueError('Not a registered directory: %s' % minimal_fp)
for entry in info.getSubdirs():
- filepath2 = path.join(filepath, entry)
- createDirectoryView(ob, filepath2, entry)
+ entry_minimal_fp = '/'.join( (minimal_fp, entry) )
+ createDirectoryView(ob, entry_minimal_fp, entry)
-def manage_addDirectoryView(self, filepath, id=None, REQUEST=None):
- '''
- Adds either a DirectoryView or a derivative object.
- '''
- createDirectoryView(self, filepath, id)
+def manage_addDirectoryView(self, minimal_fp, id=None, REQUEST=None):
+ """ Add either a DirectoryView or a derivative object.
+ """
+ createDirectoryView(self, minimal_fp, id)
if REQUEST is not None:
return self.manage_main(self, REQUEST)
def manage_listAvailableDirectories(*args):
- '''
- '''
+ """ List registered directories.
+ """
return list(_dirreg.listDirectories())
=== CMF/CMFCore/utils.py 1.53 => 1.53.2.1 ===
--- CMF/CMFCore/utils.py:1.53 Sun May 16 11:35:58 2004
+++ CMF/CMFCore/utils.py Sun May 16 13:12:51 2004
@@ -17,6 +17,7 @@
import os
from os import path as os_path
+from os.path import abspath
import re
from types import StringType
from types import UnicodeType
@@ -668,27 +669,20 @@
#
security.declarePublic('normalize')
def normalize(p):
- # the weird .replace is needed to help normpath
- # when dealing with Windows paths under *nix
- return os_path.normpath(p.replace('\\','/'))
-
-separators = (os.sep, os.altsep)
+ # the first .replace is needed to help normpath when dealing with Windows
+ # paths under *nix, the second to normalize to '/'
+ return os_path.normpath(p.replace('\\','/')).replace('\\','/')
import Products
-ProductsPath = []
-ProductsPath = map(normalize,Products.__path__)
+ProductsPath = [ abspath(ppath) for ppath in Products.__path__ ]
security.declarePublic('expandpath')
def expandpath(p):
- # Converts a minimal path to an absolute path.
-
- # This has a slight weakness in that if someone creates a new
- # product with the same name as an old one, then the skins may
- # become confused between the two.
- # However, that's an acceptable risk as people don't seem
- # to re-use product names ever (it would create ZODB persistence
- # problems too ;-)
+ """ Convert minimal filepath to (expanded) filepath.
+ The (expanded) filepath is the valid absolute path on the current platform
+ and setup.
+ """
p = os_path.normpath(p)
if os_path.isabs(p):
return p
@@ -704,14 +698,17 @@
security.declarePublic('minimalpath')
def minimalpath(p):
- # This trims down to just beyond a 'Products' root if it can.
- # otherwise, it returns what it was given.
- # In either case, the path is normalized.
- p = normalize(p)
- index = p.rfind('Products')
- if index == -1:
- index = p.rfind('products')
- if index == -1:
- # couldn't normalise
- return p
- return p[index+len('products/'):]
+ """ Convert (expanded) filepath to minimal filepath.
+
+ The minimal filepath is the cross-platform / cross-setup path stored in
+ persistent objects and used as key in the directory registry.
+
+ Returns a slash-separated path relative to the Products path. If it can't
+ be found, a normalized path is returned.
+ """
+ p = abspath(p)
+ for ppath in ProductsPath:
+ if p.startswith(ppath):
+ p = p[len(ppath)+1:]
+ break
+ return p.replace('\\','/')
More information about the CMF-checkins
mailing list