def __bobo_traverse__(self, REQUEST, name):
        """Hook for Zope 2 traversal

        This method is called by Zope 2's ZPublisher upon traversal.
        It allows us to trick it into faking the Zope 3 traversal system
        by using an ITraverser adapter.
        """
        if not IBrowserRequest.providedBy(REQUEST):
            # Try to get the REQUEST by acquisition
            REQUEST = getattr(self, 'REQUEST', None)
            if not IBrowserRequest.providedBy(REQUEST):
                REQUEST = FakeRequest()
        try:
            kw = dict(path=[name], request=REQUEST)
            return ITraverser(self).traverse(**kw).__of__(self)
        except (ComponentLookupError, NotFoundError,
                AttributeError, KeyError, NotFound):
            pass
        try:
            return getattr(self, name)
        except AttributeError:
            pass
        try:
            return self[name]
        except (AttributeError, KeyError):
            pass
        return self.__fallback_traverse__(REQUEST, name)

    def test_stub_request(self):
        html_request = self.stub_request()
        js_request = self.stub_request(
            content_type='text/javascript', status=401, interfaces=IFoo)
        iface_request = self.stub_request(interfaces=[IFoo, IBar])

        self.replay()

        self.assertTrue(IDefaultBrowserLayer.providedBy(html_request))
        self.assertTrue(IBrowserRequest.providedBy(html_request))
        self.assertEqual(html_request.debug, False)
        self.assertEqual(html_request.response.getHeader(
                'Content-Type'), 'text/html')
        self.assertEqual(html_request.response.getStatus(), 200)

        self.assertTrue(IDefaultBrowserLayer.providedBy(js_request))
        self.assertTrue(IBrowserRequest.providedBy(js_request))
        self.assertTrue(IFoo.providedBy(js_request))
        self.assertEqual(js_request.debug, False)
        self.assertEqual(js_request.response.getHeader(
                'Content-Type'), 'text/javascript')
        self.assertEqual(js_request.response.getStatus(), 401)

        self.assertTrue(IFoo.providedBy(iface_request))
        self.assertTrue(IBar.providedBy(iface_request))
        self.assertTrue(IDefaultBrowserLayer.providedBy(iface_request))
        self.assertTrue(IBrowserRequest.providedBy(iface_request))
        self.assertEqual(html_request.debug, False)
        self.assertEqual(html_request.response.getHeader(
                'Content-Type'), 'text/html')
        self.assertEqual(html_request.response.getStatus(), 200)

    def translate(self, domain, msgid, mapping=None, context=None,
                  target_language=None, default=None):
        """
        Translate a message using Unicode.
        """
        if not msgid:
            # refuse to translate an empty msgid
            return default

        # ZPT passes the object as context.  That's wrong according to spec.
        if not IBrowserRequest.providedBy(context):
            context = aq_acquire(context, 'REQUEST')
        text = msgid

        catalogs = self.getCatalogsForTranslation(context, domain, target_language)
        for catalog in catalogs:
            try:
                text = getMessage(catalog, msgid, default)
            except KeyError:
                # it's not in this catalog, try the next one
                continue
            # found!
            break
        else:
            # Did the fallback fail? Sigh, use the default if it is not None.
            if default is not None:
                text = default

        # Now we need to do the interpolation
        return self.interpolate(text, mapping)

 def traverse(self, name, furtherPath):
     # For some reason, when the adapter is constructed, the adapted
     # object is stored as self._subject rather than self.context.
     # I like self.context.
     #import pdb; pdb.set_trace()
     self.context = self._subject
     if name == 'keywords':
         tag_class = Keyword
     else:
         # We ignore it...
         return super(ImageRepositoryTraversable, self).traverse(name, furtherPath)
     # Now the guts of it...
     subpath = self.popFurtherPath(furtherPath)
     # furtherPath is now an empty list
     # Find the REQUEST
     REQUEST = getattr(self.context, 'REQUEST', None)
     if not IBrowserRequest.providedBy(REQUEST):
         REQUEST = FakeRequest()
     if len(subpath) == 0:
         return zapi.getView(self.context, name, REQUEST)
     #print name, furtherPath, subpath
     if len(subpath) == 1:
         furtherPath.append('index.html')
         tag = tag_class(subpath[0]).__of__(self.context)
     elif subpath[-1].startswith('@@'):
         furtherPath.append(subpath[-1])
         tag = tag_class(subpath[:-1]).__of__(self.context)
     else:
         furtherPath.append('index.html')
         tag = tag_class(subpath).__of__(self.context)
     return tag

    def endRequest(self, request, object):
        superclass = zope.app.publication.browser.BrowserPublication
        superclass.endRequest(self, request, object)

        da.clear_request_started()

        getUtility(IOpenLaunchBag).clear()

        # Maintain operational statistics.
        if getattr(request, '_wants_retry', False):
            OpStats.stats['retries'] += 1
        else:
            OpStats.stats['requests'] += 1

            # Increment counters for HTTP status codes we track individually
            # NB. We use IBrowserRequest, as other request types such as
            # IXMLRPCRequest use IHTTPRequest as a superclass.
            # This should be fine as Launchpad only deals with browser
            # and XML-RPC requests.
            if IBrowserRequest.providedBy(request):
                OpStats.stats['http requests'] += 1
                status = request.response.getStatus()
                if status == 404:  # Not Found
                    OpStats.stats['404s'] += 1
                elif status == 500:  # Unhandled exceptions
                    OpStats.stats['500s'] += 1
                elif status == 503:  # Timeouts
                    OpStats.stats['503s'] += 1

                # Increment counters for status code groups.
                status_group = str(status)[0] + 'XXs'
                OpStats.stats[status_group] += 1

                # Increment counter for 5XXs_b.
                if is_browser(request) and status_group == '5XXs':
                    OpStats.stats['5XXs_b'] += 1

        # Make sure our databases are in a sane state for the next request.
        thread_name = threading.currentThread().getName()
        for name, store in getUtility(IZStorm).iterstores():
            try:
                assert store._connection._state != STATE_DISCONNECTED, (
                    "Bug #504291: Store left in a disconnected state.")
            except AssertionError:
                # The Store is in a disconnected state. This should
                # not happen, as store.rollback() should have been called
                # by now. Log an OOPS so we know about this. This
                # is Bug #504291 happening.
                getUtility(IErrorReportingUtility).raising(
                    sys.exc_info(), request)
                # Repair things so the server can remain operational.
                store.rollback()
            # Reset all Storm stores when not running the test suite.
            # We could reset them when running the test suite but
            # that'd make writing tests a much more painful task. We
            # still reset the slave stores though to minimize stale
            # cache issues.
            if thread_name != 'MainThread' or name.endswith('-slave'):
                store.reset()

def utranslate(domain, msgid, mapping=None, context=None, target_language=None, default=None):
    # We used to pass an object as context.
    if not IBrowserRequest.providedBy(context):
        context = aq_acquire(context, "REQUEST")
    # The signature of zope.i18n's translate has the msgid and domain switched
    return translate(
        msgid, domain=domain, mapping=mapping, context=context, target_language=target_language, default=default
    )

def schoolToolTraverseSubscriber(event):
    """A subscriber to BeforeTraverseEvent.

    Adds DevMode layer to the request.
    """
    if (ISchoolToolApplication.providedBy(event.object) and
        IBrowserRequest.providedBy(event.request)):
        directlyProvides(event.request,
                         directlyProvidedBy(event.request) + IDevModeLayer)

 def __call__(self, objectId, instance, *args, **kw):
     request = instance.request
     if IBrowserRequest.providedBy(request):
         return {'request:SERVER_NAME':
                     (request.get('SERVER_NAME', u''),
                      request.get('SERVER_PORT', u''),
                      request.getApplicationURL(),)}
     else:
         return ()

def _translate(context, msg):
    """helper to translate a term if its a messageid
    """
    if not isinstance(msg, Message):
        return msg
    if not IBrowserRequest.providedBy(context):
        context = aq_acquire(context, 'REQUEST')
    msg = translate(msg, context=context).strip()
    msg = '\n'.join([_.strip() for _ in msg.split('\n')])  # needed if vdex
    return msg

def getEmptyTitle(context, translated=True):
    """Returns string to be used for objects with no title or id"""
    # The default is an extra fancy unicode elipsis
    empty = unicode("\x5b\xc2\xb7\xc2\xb7\xc2\xb7\x5d", "utf-8")
    if translated:
        if context is not None:
            if not IBrowserRequest.providedBy(context):
                context = aq_get(context, "REQUEST", None)
        empty = translate("title_unset", domain="plone", context=context, default=empty)
    return empty

    def translate(self, msgid, domain=None, mapping=None, context=None,
                  target_language=None, default=None):
        # Translate method for resticted code like skins.
        if context is not None:
            if not IBrowserRequest.providedBy(context):
                context = aq_get(context, 'REQUEST', None)

        return translate(msgid, domain=domain, mapping=mapping,
                         context=context, target_language=target_language,
                         default=default)

 def unauthorized(self, id, request):
     if not IBrowserRequest.providedBy(request) or request.method == 'PUT':
         next = getNextUtility(self, IAuthentication)
         return next.unauthorized(id, request)
     if str(request.URL).endswith('.ics'):
         # Special case: testing shows that Mozilla Calendar does not send
         # the Authorization header unless challenged.  It is pointless
         # to redirect an iCalendar client to an HTML login form.
         next = getNextUtility(self, IAuthentication)
         return next.unauthorized(id, request)
     return self.authPlugin.unauthorized(id, request)

    def translate(self, domain, msgid, mapping=None, context=None, target_language=None, default=None):
        # Translate a message using Unicode.
        if not msgid:
            # refuse to translate an empty msgid
            return default

        # ZPT passes the object as context.  That's wrong according to spec.
        if not IBrowserRequest.providedBy(context):
            context = aq_acquire(context, "REQUEST")
        text = msgid

        return z3translate(msgid, domain, mapping, context, target_language, default)

 def traverse(self, name, furtherPath):
     context = self._subject
     __traceback_info__ = (context, name, furtherPath)
     # Find the REQUEST
     REQUEST = getattr(context, 'REQUEST', None)
     if not IBrowserRequest.providedBy(REQUEST):
         REQUEST = FakeRequest()
     # Try to lookup a view
     try:
         return getView(context, name, REQUEST)
     except ComponentLookupError:
         pass

 def traverse(self, name, furtherPath):
     context = self._subject
     __traceback_info__ = (context, name, furtherPath)
     # Find the REQUEST
     REQUEST = getattr(context, "REQUEST", None)
     if not IBrowserRequest.providedBy(REQUEST):
         REQUEST = FakeRequest()
         setDefaultSkin(REQUEST)
     # Try to lookup a view
     try:
         return getMultiAdapter((context, REQUEST), Interface, name)
     except ComponentLookupError:
         pass

    def getSubObject(self, name, REQUEST, RESPONSE=None):
        obj = self.__p4a_z2utils_orig_getSubObject(name, REQUEST, RESPONSE)
        if obj is not None:
            return obj

        # The following is a copy from Five's __bobo_traverse__ stuff,
        # see Products.Five.traversable for details.
        # Basically we're forcing Archetypes to look up the correct
        # Five way:
        #   1) check for data object first
        #   2) check for zope3 view 
        #   3) return nothing so that AT's default __bobo_traverse__ will use aq

        if not IBrowserRequest.providedBy(REQUEST):
            # Try to get the REQUEST by acquisition
            REQUEST = getattr(self, 'REQUEST', None)
            if not IBrowserRequest.providedBy(REQUEST):
                REQUEST = FakeRequest()
                setDefaultSkin(REQUEST)

        # Con Zope 3 into using Zope 2's checkPermission
        Products.Five.security.newInteraction()

        # Use the ITraverser adapter (which in turn uses ITraversable
       # adapters) to traverse to a view.  Note that we're mixing
        # object-graph and object-publishing traversal here, but Zope
        # 2 has no way to tell us when to use which...
        # TODO Perhaps we can decide on object-graph vs.
        # object-publishing traversal depending on whether REQUEST is
        # a stub or not?
        try:
            return ITraverser(self).traverse(
                path=[name], request=REQUEST).__of__(self)
        except (ComponentLookupError, LookupError, TypeError,
                AttributeError, KeyError, NotFound):
            pass

        return None

    def translate(self, msgid, mapping=None, context=None,
                  target_language=None, default=None):

        pts  = getTranslationService()
        if pts is None or context is None:
            # If we don't have enough context use interpolate
            return interpolate(default, mapping)

        # Don't accept anything which isn't a real request
        if not IBrowserRequest.providedBy(context) or 'PARENTS' not in context:
            raise ValueError, "You didn't pass in a request as the context."

        parent = context['PARENTS'][-1]
        return pts.translate(self.domain, msgid, mapping, parent,
                             target_language, default)

     def _curried(*args, **kw):
         request = args[r_index]
         if IBrowserRequest.providedBy(request):
             if request.method not in methods:
                 raise Forbidden('Request must be %s' % methodsstr)
 
         # Reconstruct keyword arguments
         if defaults is not None:
             args, kwparams = args[:arglen], args[arglen:]
             for positional, (key, default) in zip(kwparams, defaults):
                 if positional is _default:
                     kw[key] = default
                 else:
                     kw[key] = positional
                     
         return callable(*args, **kw)

def translate(message, context):
    """ Translate i18n message.
    """
    if isinstance(message, Exception):
        try:
            message = message[0]
        except (TypeError, IndexError):
            pass
    # in Zope3, context is adapted to IUserPreferredLanguages,
    # which means context should be the request in this case.
    # Do not attempt to acquire REQUEST from the context, when we already
    # got a request as the context
    if context is not None:
        if not IBrowserRequest.providedBy(context):
            context = aq_get(context, 'REQUEST', None)

    return i18n.translate(message, domain='cmf_default', context=context)

def get_change_note(request, default=None):
    """Returns the changeNote submitted with this request. The changeNote
    is read from the form-field (see behaviors.IVersionable)
    """

    _marker = object()

    value = _marker
    if IBrowserRequest.providedBy(request):
        annotations = IAnnotations(request)
        value = annotations.get(
            'plone.app.versioningbehavior-changeNote', _marker)

    if not value or value == _marker:
        return default

    return value