Deactivted all BBB to ensure that we use only the latest code in zope…

….app

Made almost all tests pass again, except the few that heavily depended on
the old way of doing things: apidoc, module, presentation

browser.py

@@ -0,0 +1,75 @@
+##############################################################################
+#
+# Copyright (c) 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+"""Browser Publication Code
+
+This module implements browser-specific publication and traversal components
+for the publisher.
+
+$Id$
+"""
+__docformat__ = 'restructuredtext'
+
+from zope.app import zapi
+from zope.app.publication.publicationtraverse \
+     import PublicationTraverser as PublicationTraverser_
+from zope.app.publication.http import BaseHTTPPublication
+from zope.publisher.interfaces.browser import IBrowserPublisher
+from zope.security.checker import ProxyFactory
+
+class PublicationTraverser(PublicationTraverser_):
+
+    def traverseRelativeURL(self, request, ob, path):
+        ob = self.traversePath(request, ob, path)
+
+        while True:
+            adapter = IBrowserPublisher(ob, None)
+            if adapter is None:
+                return ob
+            ob, path = adapter.browserDefault(request)
+            ob = ProxyFactory(ob)
+            if not path:
+                return ob
+
+            ob = self.traversePath(request, ob, path)
+
+class BrowserPublication(BaseHTTPPublication):
+    """Web browser publication handling."""
+
+    def getDefaultTraversal(self, request, ob):
+        if IBrowserPublisher.providedBy(ob):
+            # ob is already proxied, so the result of calling a method will be
+            return ob.browserDefault(request)
+        else:
+            adapter = zapi.queryMultiAdapter((ob, request), IBrowserPublisher)
+            if adapter is not None:
+                ob, path = adapter.browserDefault(request)
+                ob = ProxyFactory(ob)
+                return ob, path
+            else:
+                # ob is already proxied
+                return ob, None
+
+    def afterCall(self, request, ob):
+        super(BrowserPublication, self).afterCall(request, ob)
+        if request.method == 'HEAD':
+            request.response.setBody('')
+
+# For now, have a factory that returns a singleton
+class PublicationFactory(object):
+
+    def __init__(self, db):
+        self.__pub = BrowserPublication(db)
+
+    def __call__(self):
+        return self.__pub

http.py

@@ -0,0 +1,43 @@
+##############################################################################
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+"""HTTP Publication
+
+$Id$
+"""
+__docformat__ = 'restructuredtext'
+from zope.publisher.publish import mapply
+
+from zope.app import zapi
+from zope.app.http.interfaces import IHTTPException
+from zope.app.publication.zopepublication import ZopePublication
+
+class BaseHTTPPublication(ZopePublication):
+    """Base for HTTP-based protocol publications"""
+
+    def annotateTransaction(self, txn, request, ob):
+        txn = super(BaseHTTPPublication, self).annotateTransaction(
+            txn, request, ob)
+        request_info = request.method + ' ' + request.getURL()
+        txn.setExtendedInfo('request_info', request_info)
+        return txn
+
+class HTTPPublication(BaseHTTPPublication):
+    """HTTP-specific publication"""
+
+    def callObject(self, request, ob):
+        # Exception handling, dont try to call request.method
+        if not IHTTPException.providedBy(ob):
+            ob = zapi.getMultiAdapter((ob, request), name=request.method)
+            ob = getattr(ob, request.method)
+        return mapply(ob, request.getPositionalArguments(), request)

httpfactory.py

@@ -0,0 +1,69 @@
+##############################################################################
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+"""HTTP Factory
+
+$Id$
+"""
+__docformat__ = 'restructuredtext'
+
+from zope.interface import implements, providedBy
+from zope.interface import directlyProvides, directlyProvidedBy
+from zope.publisher.http import HTTPRequest
+from zope.publisher.browser import BrowserRequest
+from zope.publisher.interfaces.browser import IDefaultSkin
+from zope.publisher.interfaces.browser import IDefaultBrowserLayer
+from zope.publisher.xmlrpc import XMLRPCRequest
+
+from zope.app import zapi
+from zope.app.publication.interfaces import IPublicationRequestFactory
+from zope.app.publication.http import HTTPPublication
+from zope.app.publication.browser import BrowserPublication
+from zope.app.publication.xmlrpc import XMLRPCPublication
+
+_browser_methods = 'GET', 'POST', 'HEAD'
+
+class HTTPPublicationRequestFactory(object):
+    implements(IPublicationRequestFactory)
+
+    def __init__(self, db):
+        """See `zope.app.publication.interfaces.IPublicationRequestFactory`"""
+        self._http = HTTPPublication(db)
+        self._brower = BrowserPublication(db)
+        self._xmlrpc = XMLRPCPublication(db)
+
+    def __call__(self, input_stream, output_steam, env):
+        """See `zope.app.publication.interfaces.IPublicationRequestFactory`"""
+        method = env.get('REQUEST_METHOD', 'GET').upper()
+
+        if method in _browser_methods:
+            if (method == 'POST' and
+                env.get('CONTENT_TYPE', '').startswith('text/xml')
+                ):
+                request = XMLRPCRequest(input_stream, output_steam, env)
+                request.setPublication(self._xmlrpc)
+            else:
+                request = BrowserRequest(input_stream, output_steam, env)
+                request.setPublication(self._brower)
+                # Set the default skin
+                adapters = zapi.getSiteManager().adapters
+                skin = adapters.lookup((providedBy(request),), IDefaultSkin, '')
+                if skin is not None:
+                    directlyProvides(request, directlyProvidedBy(request)+skin)
+                else:
+                    directlyProvides(request, IDefaultBrowserLayer)
+        else:
+            request = HTTPRequest(input_stream, output_steam, env)
+            request.setPublication(self._http)
+
+        return request

publicationtraverse.py

@@ -0,0 +1,98 @@
+##############################################################################
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+"""Publication Traverser
+
+$Id$
+"""
+__docformat__ = 'restructuredtext'
+from types import StringTypes
+
+from zope.publisher.interfaces import NotFound
+from zope.security.checker import ProxyFactory
+
+from zope.app import zapi
+from zope.app.traversing.namespace import namespaceLookup
+from zope.app.traversing.namespace import nsParse
+from zope.app.traversing.interfaces import TraversalError
+from zope.publisher.interfaces import IPublishTraverse
+
+class DuplicateNamespaces(Exception):
+    """More than one namespace was specified in a request"""
+
+class UnknownNamespace(Exception):
+    """A parameter specified an unknown namespace"""
+
+class PublicationTraverse(object):
+
+    def traverseName(self, request, ob, name):
+        nm = name # the name to look up the object with
+
+        if name and name[:1] in '@+':
+            # Process URI segment parameters.
+            ns, nm = nsParse(name)
+            if ns:
+                try:
+                    ob2 = namespaceLookup(ns, nm, ob, request)
+                except TraversalError:
+                    raise NotFound(ob, name)
+
+                return ProxyFactory(ob2)
+
+        if nm == '.':
+            return ob
+
+        if IPublishTraverse.providedBy(ob):
+            ob2 = ob.publishTraverse(request, nm)
+        else:
+            # self is marker
+            adapter = zapi.queryMultiAdapter((ob, request), IPublishTraverse,
+                                             default=self)
+            if adapter is not self:
+                ob2 = adapter.publishTraverse(request, nm)
+            else:
+                raise NotFound(ob, name, request)
+
+        return ProxyFactory(ob2)
+
+class PublicationTraverser(PublicationTraverse):
+
+    def traversePath(self, request, ob, path):
+
+        if isinstance(path, StringTypes):
+            path = path.split('/')
+            if len(path) > 1 and not path[-1]:
+                # Remove trailing slash
+                path.pop()
+        else:
+            path = list(path)
+
+        # Remove single dots
+        path = [x for x in path if x != '.']
+
+        path.reverse()
+
+        # Remove double dots
+        while '..' in path:
+            l = path.index('..')
+            if l < 0 or l+2 > len(path):
+                break
+            del path[l:l+2]
+
+        pop = path.pop
+
+        while path:
+            name = pop()
+            ob = self.traverseName(request, ob, name)
+
+        return ob