diff --width=126 -u -r ../../../1-6-7b80735ede14/MoinMoin/Page.py MoinMoin/Page.py
--- ../../../1-6-7b80735ede14/MoinMoin/Page.py 2006-11-28 12:00:33.000000000 -0700
+++ MoinMoin/Page.py 2006-11-28 12:10:40.000000000 -0700
@@ -155,28 +155,33 @@
def reset(self):
""" Reset page state """
- page_name = self.page_name
# page_name quoted for file system usage, needs to be reset to
# None when pagename changes
- qpagename = wikiutil.quoteWikinameFS(page_name)
- self.page_name_fs = qpagename
+ self.page_name_fs = wikiutil.quoteWikinameFS(self.page_name)
# the normal and the underlay path used for this page
- normalpath = os.path.join(self.cfg.data_dir, "pages", qpagename)
+ self.underlaypath = None
if not self.cfg.data_underlay_dir is None:
- underlaypath = os.path.join(self.cfg.data_underlay_dir, "pages", qpagename)
- else:
- underlaypath = None
+ self.underlaypath = os.path.join(self.cfg.data_underlay_dir, "pages", self.page_name_fs)
- # TUNING - remember some essential values
+ self.default_base_path = os.path.join(self.cfg.data_dir, "pages", self.page_name_fs)
- # does the page come from normal page storage (0) or from
- # underlay dir (1) (can be used as index into following list)
- self._underlay = None
+ pos = self.page_name.rfind('/')
+ if pos > 0:
+ parent = Page(self.request, self.page_name[:pos])
+ parent_base = os.path.dirname(parent.getPageBasePath())
+ self.default_base_path = os.path.join(parent_base, self.page_name_fs)
+
+ if hasattr(self, 'is_rootpage') and self.is_rootpage:
+ self.default_base_path = os.path.dirname( os.path.dirname( self.default_base_path ) )
+
+ # reset the page path
+ self.pagepath = None
+ self.getPageBasePath()
+
+ # TUNING - remember some essential values
- # path to normal / underlay page dir
- self._pagepath = [normalpath, underlaypath]
def get_current_from_pagedir(self, pagedir):
""" get the current revision number from an arbitrary pagedir.
@@ -274,10 +279,13 @@
return cache_data
# Figure out if we should use underlay or not, if needed.
- if use_underlay == -1:
- underlay, pagedir = self.getPageStatus(check_create=0)
+ if use_underlay == 1:
+ pagedir = self.underlaypath
else:
- underlay, pagedir = use_underlay, self._pagepath[use_underlay]
+ pagedir = self.getPageBasePath( )
+ if pagedir == self.underlaypath :
+ if use_underlay == 0:
+ pagedir = self.default_base_path
# Find current revision, if automatic selection is requested.
if rev == 0:
@@ -294,13 +302,20 @@
def current_rev(self):
"""Return number of current revision.
-
+
This is the same as get_rev()[1].
-
+
@return: int revision
"""
- pagefile, rev, exists = self.get_rev()
- return rev
+ if self.rev:
+ return self.rev
+
+ page_path = self.getPageBasePath( )
+ pagefile, realrev, exists = self.get_rev_dir(page_path)
+ #if realrev != 99999999:
+ # self.rev = realrev
+
+ return realrev
def get_real_rev(self):
"""Returns the real revision number of this page. A rev=0 is
@@ -313,41 +328,56 @@
return self.current_rev()
return self.rev
- def getPageBasePath(self, use_underlay):
+ def _find_page(self, use_underlay=-1):
"""
- Get full path to a page-specific storage area. `args` can
- contain additional path components that are added to the base path.
+ Find the full path to a page-specific storage area.
+
+ @param use_underlay: 0 == no underlay, 1 == only underlay, other values default to look everywhere
- @param use_underlay: force using a specific pagedir, default '-1'
- '-1' = automatically choose page dir
- '1' = use underlay page dir
- '0' = use standard page dir
@rtype: string
- @return: int underlay,
- str the full path to the storage area
+ @return: str the full path to the storage area, '' if no page not found
"""
- standardpath, underlaypath = self._pagepath
- if underlaypath is None:
- use_underlay = 0
-
- if use_underlay == -1: # automatic
- if self._underlay is None:
- underlay, path = 0, standardpath
- pagefile, rev, exists = self.get_rev(use_underlay=0)
- if not exists:
- pagefile, rev, exists = self.get_rev(use_underlay=1)
- if exists:
- underlay, path = 1, underlaypath
- self._underlay = underlay
+
+ search_path = self.cfg.page_data_dirs
+
+ if self.request.cfg.data_underlay_dir:
+ if use_underlay == 1: # only look in the underlay dir
+ search_path = [ self.request.cfg.data_underlay_dir ]
+ elif use_underlay == 0: #dont look in underlay dir
+ search_path = []
+ for dir in self.cfg.page_data_dirs:
+ if not dir == self.request.cfg.data_underlay_dir:
+ search_path.append( dir )
+
+ for dir in search_path:
+ if self.page_name_fs:
+ fullpath = os.path.join( dir, "pages", self.page_name_fs)
+ if os.path.exists(fullpath) :
+ return fullpath
else:
- underlay = self._underlay
- path = self._pagepath[underlay]
- else: # normal or underlay
- underlay, path = use_underlay, self._pagepath[use_underlay]
+ return dir
+
+ return ''
+
+ def getPageBasePath(self):
+ """
+ Get full path to a page-specific storage area.
+
+ @rtype: string
+ @return: str the full path to the storage area
+ """
+
+ if hasattr(self, 'pagepath') and self.pagepath:
+ return self.pagepath
+
+ self.pagepath = self._find_current_page(rev=self.rev)
+ if not self.pagepath:
+ self.pagepath = self.default_base_path
- return underlay, path
+ return self.pagepath
- def getPageStatus(self, *args, **kw):
+
+ def getPagePath(self, *args, **kw):
"""
Get full path to a page-specific storage area. `args` can
contain additional path components that are added to the base path.
@@ -362,27 +392,55 @@
(default true)
@keyword isfile: is the last component in args a filename? (default is false)
@rtype: string
- @return: (int underlay (1 if using underlay, 0 otherwise),
- str the full path to the storage area )
+ @return: str the full path to the storage area
"""
+
check_create = kw.get('check_create', 1)
- isfile = kw.get('isfile', 0)
use_underlay = kw.get('use_underlay', -1)
- underlay, path = self.getPageBasePath(use_underlay)
- fullpath = os.path.join(*((path,) + args))
+
+ if use_underlay == 1:
+ page_path = self.underlaypath
+ else:
+ page_path = self.getPageBasePath( )
+ if use_underlay == 0 and page_path == self.underlaypath:
+ page_path = self.default_base_path
+
+ fullpath = os.path.join(*((page_path,) + args))
+
if check_create:
+ isfile = kw.get('isfile', 0)
if isfile:
dirname, filename = os.path.split(fullpath)
else:
dirname = fullpath
if not os.path.exists(dirname):
os.makedirs(dirname)
- return underlay, fullpath
+ return fullpath
- def getPagePath(self, *args, **kw):
- """Return path to the page storage area."""
+ def _find_current_page(self, rev=0, use_underlay=-1):
+ """
+ Find the current full path to a page-specific storage area.
+
+ @param use_underlay: -1 == auto, 0 == normal, 1 == underlay
+ @param rev: int revision to get (default is 0 and means the current
+ revision )
+
+ @rtype: string
+ @return: str the full path to the storage area, '' if no page not found
+ """
+
+ if not rev and self.rev:
+ rev = self.rev
+
+ fullpath = self._find_page(use_underlay)
+ if fullpath :
+ pagefile, realrev, exists = self.get_rev_dir(fullpath, rev)
+ if exists:
+ return fullpath
+ return ''
+
+ return ''
- return self.getPageStatus(*args, **kw)[1]
def split_title(self, request, force=0):
"""
@@ -419,17 +477,6 @@
fname, rev, exists = self.get_rev(-1, rev)
return fname
- def _tmp_filename(self):
- """
- The name of the temporary file used while saving.
-
- @rtype: string
- @return: temporary filename (complete path + filename)
- """
- rnd = random.randint(0, 1000000000)
- tmpname = os.path.join(self.cfg.data_dir, '#%s.%d#' % (self.page_name_fs, rnd))
- return tmpname
-
# XXX TODO clean up the mess, rewrite _last_edited, last_edit, lastEditInfo for new logs,
# XXX TODO do not use mtime() calls any more
def _last_edited(self, request):
@@ -532,7 +579,23 @@
@rtype: bool
@return: true if page lives in the underlay dir
"""
- return self.exists(domain='underlay', includeDeleted=includeDeleted)
+ # page cant be an underlay page
+ if not self.request.cfg.data_underlay_dir:
+ return False
+
+ if includeDeleted:
+ page_dir = self._find_page(use_underlay=1)
+ else:
+ page_dir = self._find_current_page(use_underlay=1)
+
+ if page_dir:
+ underlay_dir = self.request.cfg.data_underlay_dir
+
+ # we found the page in a dir that is the underlay dir
+ if underlay_dir == os.path.commonprefix( [ underlay_dir, page_dir ] ):
+ return True
+
+ return False
def isStandardPage(self, includeDeleted=True):
""" Does this page live in the data dir?
@@ -544,9 +607,25 @@
@rtype: bool
@return: true if page lives in the data dir
"""
- return self.exists(domain='standard', includeDeleted=includeDeleted)
+ # page cant be an underlay page
+ if not self.request.cfg.data_underlay_dir:
+ return True
+
+ if includeDeleted:
+ page_dir = self._find_page()
+ else:
+ page_dir = self._find_current_page()
+
+ if page_dir:
+ underlay_dir = self.request.cfg.data_underlay_dir
+
+ # we found the page in a dir that is not the underlay dir
+ if not underlay_dir == os.path.commonprefix( [ underlay_dir, page_dir ] ):
+ return True
+
+ return False
- def exists(self, rev=0, domain=None, includeDeleted=False):
+ def exists(self, rev=0, includeDeleted=False):
""" Does this page exist?
This is the lower level method for checking page existence. Use
@@ -554,38 +633,19 @@
cleaner code.
@param rev: revision to look for. Default check current
- @param domain: where to look for the page. Default look in all,
- available values: 'underlay', 'standard'
@param includeDeleted: ignore page state, just check its pagedir
@rtype: bool
@return: true, if page exists
"""
- # Edge cases
- if domain == 'underlay' and not self.request.cfg.data_underlay_dir:
- return False
if includeDeleted:
- # Look for page directory, ignore page state
- if domain is None:
- checklist = [0, 1]
- else:
- checklist = [domain == 'underlay']
- for use_underlay in checklist:
- pagedir = self.getPagePath(use_underlay=use_underlay, check_create=0)
- if os.path.exists(pagedir):
- return True
- return False
+ page_dir = self._find_page()
else:
- # Look for non-deleted pages only, using get_rev
- if not rev and self.rev:
- rev = self.rev
+ page_dir = self._find_current_page(rev)
- if domain is None:
- use_underlay = -1
- else:
- use_underlay = domain == 'underlay'
- d, d, exists = self.get_rev(use_underlay, rev)
- return exists
+ if page_dir:
+ return True
+ return False
def size(self, rev=0):
""" Get Page size.
@@ -1070,7 +1130,7 @@
# send the page header
if self.default_formatter:
- if self.rev:
+ if self.rev and self.rev != 99999999:
msg = "%s
%s" % (
_('Revision %(rev)d as of %(date)s') % {
'rev': self.rev,
@@ -1273,7 +1333,7 @@
def loadCache(self, request):
""" Return page content cache or raises 'CacheNeedsUpdate' """
cache = caching.CacheEntry(request, self, self.getFormatterName(), scope='item')
- attachmentsPath = self.getPagePath('attachments', check_create=0)
+ attachmentsPath = os.path.join( self.getPageBasePath(), 'attachments')
if cache.needsUpdate(self._text_filename(), attachmentsPath):
raise Exception('CacheNeedsUpdate')
@@ -1337,7 +1397,7 @@
import dircache
revisions = []
if self.page_name:
- rev_dir = self.getPagePath('revisions', check_create=0)
+ rev_dir = os.path.join( self.getPageBasePath(), 'revisions')
if os.path.isdir(rev_dir):
for rev in dircache.listdir(rev_dir):
try:
@@ -1608,34 +1668,10 @@
def __init__(self, request):
page_name = u''
Page.__init__(self, request, page_name)
+ self.is_rootpage = 1
- def getPageBasePath(self, use_underlay):
- """
- Get full path to a page-specific storage area. `args` can
- contain additional path components that are added to the base path.
- @param use_underlay: force using a specific pagedir, default '-1'
- '-1' = automatically choose page dir
- '1' = use underlay page dir
- '0' = use standard page dir
- @rtype: string
- @return: int underlay,
- str the full path to the storage area
- """
- if self.cfg.data_underlay_dir is None:
- use_underlay = 0
-
- # 'auto' doesn't make sense here. maybe not even 'underlay':
- if use_underlay == 1:
- underlay, path = 1, self.cfg.data_underlay_dir
- # no need to check 'standard' case, we just use path in that case!
- else:
- # this is the location of the virtual root page
- underlay, path = 0, self.cfg.data_dir
-
- return underlay, path
-
- def getPageList(self, user=None, exists=1, filter=None, include_underlay=True, return_objects=False):
+ def getPageList(self, user=None, exists=1, filter=None, return_objects=False):
""" List user readable pages under current page
Currently only request.rootpage is used to list pages, but if we
@@ -1659,7 +1695,6 @@
@param user: the user requesting the pages (MoinMoin.user.User)
@param filter: filter function
@param exists: filter existing pages
- @param include_underlay: determines if underlay pages are returned as well
@param return_objects: lets it return a list of Page objects instead of
names
@rtype: list of unicode strings
@@ -1688,7 +1723,7 @@
cachedlist[pagename] = None
request.cfg.cache.pagelists.putItem(request, 'all', None, cachedlist)
- if user or exists or filter or not include_underlay or return_objects:
+ if user or exists or filter or return_objects:
# Filter names
pages = []
for name in cachedlist:
@@ -1699,10 +1734,6 @@
page = Page(request, name)
- # Filter underlay pages
- if not include_underlay and page.getPageStatus()[0]: # is an underlay page
- continue
-
# Filter deleted pages
if exists and not page.exists():
continue
@@ -1749,16 +1780,12 @@
@rtype: dict
@return: dict of page names using file system encoding
"""
- # Get pages in standard dir
- path = self.getPagePath('pages')
- pages = self._listPageInPath(path)
-
- if self.cfg.data_underlay_dir is not None:
- # Merge with pages from underlay
- path = self.getPagePath('pages', use_underlay=1)
- underlay = self._listPageInPath(path)
- pages.update(underlay)
+ pages = {}
+ for dir in self.cfg.page_data_dirs:
+ path = os.path.join( dir, 'pages' )
+ more_pages = self._listPageInPath(path)
+ pages.update(more_pages)
return pages
def _listPageInPath(self, path):
diff --width=126 -u -r ../../../1-6-7b80735ede14/MoinMoin/PageEditor.py MoinMoin/PageEditor.py
--- ../../../1-6-7b80735ede14/MoinMoin/PageEditor.py 2006-11-28 12:00:33.000000000 -0700
+++ MoinMoin/PageEditor.py 2006-11-28 12:10:45.000000000 -0700
@@ -909,7 +909,10 @@
llog = editlog.EditLog(self.request, filename=pagelog,
uid_override=self.uid_override)
# Open the global log
- glog = editlog.EditLog(self.request, uid_override=self.uid_override)
+ root_dir = os.path.dirname( os.path.dirname( pagedir ) )
+ gpagelog = os.path.join( root_dir, 'edit-log')
+ glog = editlog.EditLog(self.request, filename=gpagelog,
+ uid_override=self.uid_override)
if not os.path.exists(pagedir): # new page, create and init pagedir
os.mkdir(pagedir)
@@ -961,9 +964,6 @@
# set in-memory content
self.set_raw_body(text)
- # reset page object
- self.reset()
-
# write the editlog entry
# for now simply make 2 logs, better would be some multilog stuff maybe
if self.do_revision_backup:
@@ -977,6 +977,9 @@
if got_lock:
filesys.rename(clfn, cfn)
+ # reset page object
+ self.reset()
+
# add event log entry
elog = eventlog.EventLog(self.request)
elog.add(self.request, 'SAVEPAGE', {'pagename': self.page_name}, 1, mtime_usecs)
@@ -1022,7 +1025,7 @@
other = False
pagelog = self.getPagePath('edit-log', use_underlay=0, isfile=1)
next_line = None
- for line in editlog.EditLog(self.request, pagelog).reverse():
+ for line in editlog.EditLog(self.request, filename=pagelog).reverse():
if int(line.rev) == int(rev):
break
if not line.is_from_current_user(self.request):
Only in ../../../1-6-7b80735ede14/MoinMoin/_tests: broken
diff --width=126 -u -r ../../../1-6-7b80735ede14/MoinMoin/action/info.py MoinMoin/action/info.py
--- ../../../1-6-7b80735ede14/MoinMoin/action/info.py 2006-11-28 12:00:33.000000000 -0700
+++ MoinMoin/action/info.py 2006-11-28 12:10:18.000000000 -0700
@@ -33,6 +33,15 @@
f.text(_("Page size: %d") % page.size()),
f.paragraph(0))
+ page_location = 'Overlay'
+ page_path = page.getPageBasePath()
+ if request.cfg.data_underlay_dir and \
+ request.cfg.data_underlay_dir == os.path.commonprefix( [ request.cfg.data_underlay_dir, page_path ] ):
+ page_location = 'Underlay'
+ elif request.cfg.data_dir == os.path.commonprefix( [ request.cfg.data_dir, page_path ] ):
+ page_location = 'Standard'
+ request.write(("%s
" % _("Page Location: %s")) % page_location)
+
import sha
digest = sha.new(page.get_raw_body().encode(config.charset)).hexdigest().upper()
request.write(f.paragraph(1),
diff --width=126 -u -r ../../../1-6-7b80735ede14/MoinMoin/config/multiconfig.py MoinMoin/config/multiconfig.py
--- ../../../1-6-7b80735ede14/MoinMoin/config/multiconfig.py 2006-11-28 12:00:33.000000000 -0700
+++ MoinMoin/config/multiconfig.py 2006-11-28 12:11:43.000000000 -0700
@@ -736,17 +736,28 @@
Both data and underlay should exists and allow read, write and
execute.
"""
- mode = os.F_OK | os.R_OK | os.W_OK | os.X_OK
- for attr in ('data_dir', 'data_underlay_dir'):
- path = getattr(self, attr)
+ if not hasattr(self, 'page_data_dirs'):
+ data_dir = getattr(self, 'data_dir')
+ underlay_dir = getattr(self, 'underlay_dir')
+ self.page_data_dirs = [ data_dir, ]
+ if underlay_dir:
+ self.page_data_dirs = [ data_dir, underlay_dir, ]
+ mode = os.F_OK | os.R_OK | os.W_OK | os.X_OK
+ for attr in ('data_dir', 'data_underlay_dir', 'page_data_dirs'):
+ if attr == 'data_dir' or attr == 'data_underlay_dir':
+ paths_to_check = ( getattr(self, attr), )
+ else:
+ paths_to_check = getattr(self, attr)
+
# allow an empty underlay path or None
- if attr == 'data_underlay_dir' and not path:
+ if attr == 'data_underlay_dir' and not paths_to_check:
continue
- path_pages = os.path.join(path, "pages")
- if not (os.path.isdir(path_pages) and os.access(path_pages, mode)):
- msg = '''
+ for path in paths_to_check:
+ path_pages = os.path.join(path, "pages")
+ if not (os.path.isdir(path_pages) and os.access(path_pages, mode)):
+ msg = '''
%(attr)s "%(path)s" does not exists, or has incorrect ownership or
permissions.
@@ -756,8 +767,8 @@
It is recommended to use absolute paths and not relative paths. Check
also the spelling of the directory name.
-''' % {'attr': attr, 'path': path, }
- raise error.ConfigurationError(msg)
+''' % {'attr': attr, 'path': path,}
+ raise error.ConfigurationError(msg)
def _loadPluginModule(self):
""" import plugin module under configname.plugin
diff --width=126 -u -r ../../../1-6-7b80735ede14/MoinMoin/script/maint/mkpagepacks.py MoinMoin/script/maint/mkpagepacks.py
--- ../../../1-6-7b80735ede14/MoinMoin/script/maint/mkpagepacks.py 2006-11-28 12:00:33.000000000 -0700
+++ MoinMoin/script/maint/mkpagepacks.py 2006-11-28 12:08:14.000000000 -0700
@@ -110,7 +110,7 @@
pagename = pagename.strip()
page = Page(request, pagename)
try:
- underlay, path = page.getPageBasePath(-1)
+ path = page.getPageBasePath()
shutil.rmtree(path)
except:
pass