Merge branch 'master' of https://github.com/Pylons/pyramid

9 files changed, 266 insertions, 153 deletions

diff --git a/CHANGES.txt b/CHANGES.txt
index d329c260d..5916fa1ab 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -187,6 +187,26 @@ Deprecations
   now issued when any view-related parameter is passed to
   ``Configurator.add_route``.
 
+- Passing an ``environ`` dictionary to the ``__call__`` method of a
+  "traverser" (e.g. an object that implements
+  ``pyramid.interfaces.ITraverser`` such as an instance of
+  ``pyramid.traversal.ResourceTreeTraverser``) as its ``request`` argument
+  now causes a deprecation warning to be emitted.  Consumer code should pass a
+  ``request`` object instead.  The fact that passing an environ dict is
+  permitted has been documentation-deprecated since ``repoze.bfg`` 1.1, and
+  this capability will be removed entirely in a future version.
+
+- The following (undocumented, dictionary-like) methods of the
+  ``pyramid.request.Request`` object have been deprecated: ``__contains__``,
+  ``__delitem__``, ``__getitem__``, ``__iter__``, ``__setitem__``, ``get``,
+  ``has_key``, ``items``, ``iteritems``, ``itervalues``, ``keys``, ``pop``,
+  ``popitem``, ``setdefault``, ``update``, and ``values``.  Usage of any of
+  these methods will cause a deprecation warning to be emitted.  These
+  methods were added for internal compatibility in ``repoze.bfg`` 1.1 (code
+  that currently expects a request object expected an environ object in BFG
+  1.0 and before).  In a future version, these methods will be removed
+  entirely.
+
 Behavior Changes
 ----------------
 
@@ -211,6 +231,16 @@ Behavior Changes
   the perspective of the downstream application (for example, ``SCRIPT_NAME``
   will now never possess a trailing slash).
 
+- Previously, ``pyramid.request.Request`` inherited from
+  ``webob.request.Request`` and implemented ``__getattr__``, ``__setattr__``
+  and ``__delattr__`` itself in order to overidde "adhoc attr" WebOb behavior
+  where attributes of the request are stored in the environ.  Now,
+  ``pyramid.request.Request`` object inherits from (the more recent)
+  ``webob.request.BaseRequest`` instead of ``webob.request.Request``, which
+  provides the same behavior.  ``pyramid.request.Request`` no longer
+  implements its own ``__getattr__``, ``__setattr__`` or ``__delattr__`` as a
+  result.
+
 Dependencies
 ------------
 
diff --git a/pyramid/config.py b/pyramid/config.py
index ca76cafb4..9c547d736 100644
--- a/pyramid/config.py
+++ b/pyramid/config.py
@@ -2356,7 +2356,7 @@ class Configurator(object):
                 self.context = context
 
             def __call__(self, request):
-                path = request['PATH_INFO']
+                path = request.environ['PATH_INFO']
                 ob = resources[path]
                 traversed = traversal_path(path)
                 return {'context':ob, 'view_name':'','subpath':(),
diff --git a/pyramid/interfaces.py b/pyramid/interfaces.py
index 2364757ab..dbea91c99 100644
--- a/pyramid/interfaces.py
+++ b/pyramid/interfaces.py
@@ -271,24 +271,23 @@ class ITraverser(Interface):
         """ Return a dictionary with (at least) the keys ``root``,
         ``context``, ``view_name``, ``subpath``, ``traversed``,
         ``virtual_root``, and ``virtual_root_path``.  These values are
-        typically the result of an object graph traversal.  ``root``
-        is the physical root object, ``context`` will be a model
-        object, ``view_name`` will be the view name used (a Unicode
-        name), ``subpath`` will be a sequence of Unicode names that
-        followed the view name but were not traversed, ``traversed``
-        will be a sequence of Unicode names that were traversed
-        (including the virtual root path, if any) ``virtual_root``
-        will be a model object representing the virtual root (or the
-        physical root if traversal was not performed), and
-        ``virtual_root_path`` will be a sequence representing the
-        virtual root path (a sequence of Unicode names) or None if
-        traversal was not performed.
-
-        Extra keys for special purpose functionality can be added as
+        typically the result of an object graph traversal.  ``root`` is the
+        physical root object, ``context`` will be a model object,
+        ``view_name`` will be the view name used (a Unicode name),
+        ``subpath`` will be a sequence of Unicode names that followed the
+        view name but were not traversed, ``traversed`` will be a sequence of
+        Unicode names that were traversed (including the virtual root path,
+        if any) ``virtual_root`` will be a model object representing the
+        virtual root (or the physical root if traversal was not performed),
+        and ``virtual_root_path`` will be a sequence representing the virtual
+        root path (a sequence of Unicode names) or ``None`` if traversal was
+        not performed.
+
+        Extra keys for special purpose functionality can be returned as
         necessary.
 
         All values returned in the dictionary will be made available
-        as attributes of the ``request`` object.
+        as attributes of the ``request`` object by the :term:`router`.
         """
 
 ITraverserFactory = ITraverser # b / c for 1.0 code
diff --git a/pyramid/request.py b/pyramid/request.py
index 0fe8b9379..d387a0b2f 100644
--- a/pyramid/request.py
+++ b/pyramid/request.py
@@ -1,7 +1,8 @@
+from zope.deprecation import deprecate
 from zope.interface import implements
 from zope.interface.interface import InterfaceClass
 
-from webob import Request as WebobRequest
+from webob import BaseRequest
 
 from pyramid.interfaces import IRequest
 from pyramid.interfaces import ISessionFactory
@@ -10,7 +11,6 @@ from pyramid.interfaces import IResponseFactory
 from pyramid.exceptions import ConfigurationError
 from pyramid.decorator import reify
 from pyramid.response import Response
-from pyramid.traversal import quote_path_segment
 from pyramid.url import resource_url
 from pyramid.url import route_url
 from pyramid.url import static_url
@@ -19,7 +19,7 @@ from pyramid.url import route_path
 class TemplateContext(object):
     pass
 
-class Request(WebobRequest):
+class Request(BaseRequest):
     """
     A subclass of the :term:`WebOb` Request class.  An instance of
     this class is created by the :term:`router` and is provided to a
@@ -321,63 +321,80 @@ class Request(WebobRequest):
                                                  default=Response)
         return response_factory()
 
-    # override default WebOb "environ['adhoc_attr']" mutation behavior
-    __getattr__ = object.__getattribute__
-    __setattr__ = object.__setattr__
-    __delattr__ = object.__delattr__
-
     # b/c dict interface for "root factory" code that expects a bare
     # environ.  Explicitly omitted dict methods: clear (unnecessary),
-    # copy (implemented by WebOb), fromkeys (unnecessary)
+    # copy (implemented by WebOb), fromkeys (unnecessary); deprecated
+    # as of Pyramid 1.1.
+
+    dictlike = ('Use of the request as a dict-like object is deprecated as '
+                'of Pyramid 1.1.  Use dict-like methods of "request.environ" '
+                'instead.')
 
+    @deprecate(dictlike)
     def __contains__(self, k):
         return self.environ.__contains__(k)
 
+    @deprecate(dictlike)
     def __delitem__(self, k):
         return self.environ.__delitem__(k)
 
+    @deprecate(dictlike)
     def __getitem__(self, k):
         return self.environ.__getitem__(k)
 
+    @deprecate(dictlike)
     def __iter__(self):
         return iter(self.environ)
 
+    @deprecate(dictlike)
     def __setitem__(self, k, v):
         self.environ[k] = v
 
+    @deprecate(dictlike)
     def get(self, k, default=None):
         return self.environ.get(k, default)
 
+    @deprecate(dictlike)
     def has_key(self, k):
         return k in self.environ
 
+    @deprecate(dictlike)
     def items(self):
         return self.environ.items()
 
+    @deprecate(dictlike)
     def iteritems(self):
         return self.environ.iteritems()
 
+    @deprecate(dictlike)
     def iterkeys(self):
         return self.environ.iterkeys()
 
+    @deprecate(dictlike)
     def itervalues(self):
         return self.environ.itervalues()
 
+    @deprecate(dictlike)
     def keys(self):
         return self.environ.keys()
 
+    @deprecate(dictlike)
     def pop(self, k):
         return self.environ.pop(k)
 
+    @deprecate(dictlike)
     def popitem(self):
         return self.environ.popitem()
 
+    @deprecate(dictlike)
     def setdefault(self, v, default):
         return self.environ.setdefault(v, default)
 
+    @deprecate(dictlike)
     def update(self, v, **kw):
         return self.environ.update(v, **kw)
 
+    @deprecate(dictlike)
     def values(self):
         return self.environ.values()
 
diff --git a/pyramid/tests/test_config.py b/pyramid/tests/test_config.py
index f583cc783..d8f8d89a0 100644
--- a/pyramid/tests/test_config.py
+++ b/pyramid/tests/test_config.py
@@ -2689,21 +2689,21 @@ class ConfiguratorTests(unittest.TestCase):
         config = self._makeOne(autocommit=True)
         config.testing_resources(resources)
         adapter = config.registry.getAdapter(None, ITraverser)
-        result = adapter({'PATH_INFO':'/ob1'})
+        result = adapter(DummyRequest({'PATH_INFO':'/ob1'}))
         self.assertEqual(result['context'], ob1)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ())
         self.assertEqual(result['traversed'], (u'ob1',))
         self.assertEqual(result['virtual_root'], ob1)
         self.assertEqual(result['virtual_root_path'], ())
-        result = adapter({'PATH_INFO':'/ob2'})
+        result = adapter(DummyRequest({'PATH_INFO':'/ob2'}))
         self.assertEqual(result['context'], ob2)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ())
         self.assertEqual(result['traversed'], (u'ob2',))
         self.assertEqual(result['virtual_root'], ob2)
         self.assertEqual(result['virtual_root_path'], ())
-        self.assertRaises(KeyError, adapter, {'PATH_INFO':'/ob3'})
+        self.assertRaises(KeyError, adapter, DummyRequest({'PATH_INFO':'/ob3'}))
         try:
             config.begin()
             self.assertEqual(find_resource(None, '/ob1'), ob1)
@@ -4953,8 +4953,10 @@ class Test_isexception(unittest.TestCase):
 class DummyRequest:
     subpath = ()
     matchdict = None
-    def __init__(self):
-        self.environ = {'PATH_INFO':'/static'}
+    def __init__(self, environ=None):
+        if environ is None:
+            environ = {}
+        self.environ = environ
         self.params = {}
         self.cookies = {}
     def copy(self):
diff --git a/pyramid/tests/test_request.py b/pyramid/tests/test_request.py
index 60d59ece6..e35856ce0 100644
--- a/pyramid/tests/test_request.py
+++ b/pyramid/tests/test_request.py
@@ -4,10 +4,9 @@ from pyramid import testing
 class TestRequest(unittest.TestCase):
     def setUp(self):
         self.config = testing.setUp()
-        self.config.begin()
 
     def tearDown(self):
-        self.config.end()
+        testing.tearDown()
 
     def _makeOne(self, environ):
         return self._getTargetClass()(environ)
@@ -83,7 +82,7 @@ class TestRequest(unittest.TestCase):
         from pyramid.exceptions import ConfigurationError
         inst = self._makeOne({})
         inst.registry = self.config.registry
-        self.assertRaises(ConfigurationError, inst.__getattr__, 'session')
+        self.assertRaises(ConfigurationError, getattr, inst, 'session')
 
     def test_setattr_and_getattr_dotnotation(self):
         inst = self._makeOne({})
@@ -91,106 +90,11 @@ class TestRequest(unittest.TestCase):
         self.assertEqual(inst.foo, 1)
 
     def test_setattr_and_getattr(self):
-        inst = self._makeOne({})
-        setattr(inst, 'bar', 1)
-        self.assertEqual(getattr(inst, 'bar'), 1)
-
-    def test___contains__(self):
-        environ ={'zooma':1}
-        inst = self._makeOne(environ)
-        self.assertTrue('zooma' in inst)
-
-    def test___delitem__(self):
-        environ = {'zooma':1}
-        inst = self._makeOne(environ)
-        del inst['zooma']
-        self.assertFalse('zooma' in environ)
-
-    def test___getitem__(self):
-        environ = {'zooma':1}
-        inst = self._makeOne(environ)
-        self.assertEqual(inst['zooma'], 1)
-
-    def test___iter__(self):
-        environ = {'zooma':1}
-        inst = self._makeOne(environ)
-        iterator = iter(inst)
-        self.assertEqual(list(iterator), list(iter(environ)))
-
-    def test___setitem__(self):
-        environ = {}
-        inst = self._makeOne(environ)
-        inst['zooma'] = 1
-        self.assertEqual(environ, {'zooma':1})
-
-    def test_get(self):
-        environ = {'zooma':1}
-        inst = self._makeOne(environ)
-        self.assertEqual(inst.get('zooma'), 1)
-
-    def test_has_key(self):
-        environ = {'zooma':1}
-        inst = self._makeOne(environ)
-        self.assertEqual(inst.has_key('zooma'), True)
-
-    def test_items(self):
-        environ = {'zooma':1}
-        inst = self._makeOne(environ)
-        self.assertEqual(inst.items(), environ.items())
-
-    def test_iteritems(self):
-        environ = {'zooma':1}
-        inst = self._makeOne(environ)
-        self.assertEqual(list(inst.iteritems()), list(environ.iteritems()))
-
-    def test_iterkeys(self):
-        environ = {'zooma':1}
-        inst = self._makeOne(environ)
-        self.assertEqual(list(inst.iterkeys()), list(environ.iterkeys()))
-
-    def test_itervalues(self):
-        environ = {'zooma':1}
-        inst = self._makeOne(environ)
-        self.assertEqual(list(inst.itervalues()), list(environ.itervalues()))
-
-    def test_keys(self):
-        environ = {'zooma':1}
-        inst = self._makeOne(environ)
-        self.assertEqual(inst.keys(), environ.keys())
-
-    def test_pop(self):
-        environ = {'zooma':1}
-        inst = self._makeOne(environ)
-        popped = inst.pop('zooma')
-        self.assertEqual(environ, {})
-        self.assertEqual(popped, 1)
-
-    def test_popitem(self):
-        environ = {'zooma':1}
-        inst = self._makeOne(environ)
-        popped = inst.popitem()
-        self.assertEqual(environ, {})
-        self.assertEqual(popped, ('zooma', 1))
-
-    def test_setdefault(self):
         environ = {}
         inst = self._makeOne(environ)
-        marker = []
-        result = inst.setdefault('a', marker)
-        self.assertEqual(environ, {'a':marker})
-        self.assertEqual(result, marker)
-
-    def test_update(self):
-        environ = {}
-        inst = self._makeOne(environ)
-        inst.update({'a':1}, b=2)
-        self.assertEqual(environ, {'a':1, 'b':2})
-
-    def test_values(self):
-        environ = {'zooma':1}
-        inst = self._makeOne(environ)
-        result = inst.values()
-        self.assertEqual(result, environ.values())
+        setattr(inst, 'bar', 1)
+        self.assertEqual(getattr(inst, 'bar'), 1)
+        self.assertEqual(environ, {}) # make sure we're not using adhoc attrs
 
     def test_add_response_callback(self):
         inst = self._makeOne({})
@@ -301,6 +205,122 @@ class TestRequest(unittest.TestCase):
                          ('pyramid.tests:static/foo.css', request, {}) )
         
 
+class TestRequestDeprecatedMethods(unittest.TestCase):
+    def setUp(self):
+        self.config = testing.setUp()
+        self.config.begin()
+        import warnings
+        warnings.filterwarnings('ignore')
+
+    def tearDown(self):
+        testing.tearDown()
+        import warnings
+        warnings.resetwarnings()
+
+    def _getTargetClass(self):
+        from pyramid.request import Request
+        return Request
+
+    def _makeOne(self, environ):
+        return self._getTargetClass()(environ)
+
+    def test___contains__(self):
+        environ ={'zooma':1}
+        inst = self._makeOne(environ)
+        self.assertTrue('zooma' in inst)
+
+    def test___delitem__(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        del inst['zooma']
+        self.assertFalse('zooma' in environ)
+
+    def test___getitem__(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        self.assertEqual(inst['zooma'], 1)
+
+    def test___iter__(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        iterator = iter(inst)
+        self.assertEqual(list(iterator), list(iter(environ)))
+
+    def test___setitem__(self):
+        environ = {}
+        inst = self._makeOne(environ)
+        inst['zooma'] = 1
+        self.assertEqual(environ, {'zooma':1})
+
+    def test_get(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        self.assertEqual(inst.get('zooma'), 1)
+
+    def test_has_key(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        self.assertEqual(inst.has_key('zooma'), True)
+
+    def test_items(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        self.assertEqual(inst.items(), environ.items())
+
+    def test_iteritems(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        self.assertEqual(list(inst.iteritems()), list(environ.iteritems()))
+
+    def test_iterkeys(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        self.assertEqual(list(inst.iterkeys()), list(environ.iterkeys()))
+
+    def test_itervalues(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        self.assertEqual(list(inst.itervalues()), list(environ.itervalues()))
+
+    def test_keys(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        self.assertEqual(inst.keys(), environ.keys())
+
+    def test_pop(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        popped = inst.pop('zooma')
+        self.assertEqual(environ, {})
+        self.assertEqual(popped, 1)
+
+    def test_popitem(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        popped = inst.popitem()
+        self.assertEqual(environ, {})
+        self.assertEqual(popped, ('zooma', 1))
+
+    def test_setdefault(self):
+        environ = {}
+        inst = self._makeOne(environ)
+        marker = []
+        result = inst.setdefault('a', marker)
+        self.assertEqual(environ, {'a':marker})
+        self.assertEqual(result, marker)
+
+    def test_update(self):
+        environ = {}
+        inst = self._makeOne(environ)
+        inst.update({'a':1}, b=2)
+        self.assertEqual(environ, {'a':1, 'b':2})
+
+    def test_values(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        result = inst.values()
+        self.assertEqual(result, environ.values())
+
 class Test_route_request_iface(unittest.TestCase):
     def _callFUT(self, name):
         from pyramid.request import route_request_iface
diff --git a/pyramid/tests/test_testing.py b/pyramid/tests/test_testing.py
index 0c94a2803..58ca2b7d9 100644
--- a/pyramid/tests/test_testing.py
+++ b/pyramid/tests/test_testing.py
@@ -42,21 +42,21 @@ class Test_registerResources(TestBase):
         testing.registerResources(resources)
         from pyramid.interfaces import ITraverser
         adapter = self.registry.getAdapter(None, ITraverser)
-        result = adapter({'PATH_INFO':'/ob1'})
+        result = adapter(DummyRequest({'PATH_INFO':'/ob1'}))
         self.assertEqual(result['context'], ob1)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ())
         self.assertEqual(result['traversed'], (u'ob1',))
         self.assertEqual(result['virtual_root'], ob1)
         self.assertEqual(result['virtual_root_path'], ())
-        result = adapter({'PATH_INFO':'/ob2'})
+        result = adapter(DummyRequest({'PATH_INFO':'/ob2'}))
         self.assertEqual(result['context'], ob2)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ())
         self.assertEqual(result['traversed'], (u'ob2',))
         self.assertEqual(result['virtual_root'], ob2)
         self.assertEqual(result['virtual_root_path'], ())
-        self.assertRaises(KeyError, adapter, {'PATH_INFO':'/ob3'})
+        self.assertRaises(KeyError, adapter, DummyRequest({'PATH_INFO':'/ob3'}))
         from pyramid.traversal import find_resource
         self.assertEqual(find_resource(None, '/ob1'), ob1)
 
@@ -897,6 +897,10 @@ class DummyEvent:
 
 class DummyRequest:
     application_url = 'http://example.com'
+    def __init__(self, environ=None):
+        if environ is None:
+            environ = {}
+        self.environ = environ
 
 class DummyFactory:
     def __init__(self, environ):
diff --git a/pyramid/tests/test_traversal.py b/pyramid/tests/test_traversal.py
index 89edb230b..0ead63703 100644
--- a/pyramid/tests/test_traversal.py
+++ b/pyramid/tests/test_traversal.py
@@ -96,7 +96,8 @@ class ResourceTreeTraverserTests(unittest.TestCase):
     def test_call_with_no_pathinfo(self):
         policy = self._makeOne(None)
         environ = self._getEnviron()
-        result = policy(environ)
+        request = DummyRequest(environ)
+        result = policy(request)
         self.assertEqual(result['context'], None)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ())
@@ -108,7 +109,8 @@ class ResourceTreeTraverserTests(unittest.TestCase):
     def test_call_pathel_with_no_getitem(self):
         policy = self._makeOne(None)
         environ = self._getEnviron(PATH_INFO='/foo/bar')
-        result = policy(environ)
+        request = DummyRequest(environ)
+        result = policy(request)
         self.assertEqual(result['context'], None)
         self.assertEqual(result['view_name'], 'foo')
         self.assertEqual(result['subpath'], ('bar',))
@@ -121,7 +123,8 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         root = DummyContext()
         policy = self._makeOne(root)
         environ = self._getEnviron(PATH_INFO='')
-        result = policy(environ)
+        request = DummyRequest(environ)
+        result = policy(request)
         self.assertEqual(result['context'], root)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ())
@@ -135,7 +138,8 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         root = DummyContext(foo)
         policy = self._makeOne(root)
         environ = self._getEnviron(PATH_INFO='/foo/bar')
-        result = policy(environ)
+        request = DummyRequest(environ)
+        result = policy(request)
         self.assertEqual(result['context'], foo)
         self.assertEqual(result['view_name'], 'bar')
         self.assertEqual(result['subpath'], ())
@@ -149,7 +153,8 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         root = DummyContext(foo)
         policy = self._makeOne(root)
         environ = self._getEnviron(PATH_INFO='/foo/bar/baz/buz')
-        result = policy(environ)
+        request = DummyRequest(environ)
+        result = policy(request)
         self.assertEqual(result['context'], foo)
         self.assertEqual(result['view_name'], 'bar')
         self.assertEqual(result['subpath'], ('baz', 'buz'))
@@ -163,7 +168,8 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         root = DummyContext(foo)
         policy = self._makeOne(root)
         environ = self._getEnviron(PATH_INFO='/@@foo')
-        result = policy(environ)
+        request = DummyRequest(environ)
+        result = policy(request)
         self.assertEqual(result['context'], root)
         self.assertEqual(result['view_name'], 'foo')
         self.assertEqual(result['subpath'], ())
@@ -180,7 +186,8 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         foo = DummyContext(bar, 'foo')
         root = DummyContext(foo, 'root')
         policy = self._makeOne(root)
-        result = policy(environ)
+        request = DummyRequest(environ)
+        result = policy(request)
         self.assertEqual(result['context'], baz)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ())
@@ -197,7 +204,8 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         foo = DummyContext(bar, 'foo')
         root = DummyContext(foo, 'root')
         policy = self._makeOne(root)
-        result = policy(environ)
+        request = DummyRequest(environ)
+        result = policy(request)
         self.assertEqual(result['context'], baz)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ())
@@ -214,7 +222,8 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         foo = DummyContext(bar)
         root = DummyContext(foo)
         policy = self._makeOne(root)
-        result = policy(environ)
+        request = DummyRequest(environ)
+        result = policy(request)
         self.assertEqual(result['context'], baz)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ())
@@ -231,7 +240,8 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         foo = DummyContext(bar, 'foo')
         root = DummyContext(foo, 'root')
         policy = self._makeOne(root)
-        result = policy(environ)
+        request = DummyRequest(environ)
+        result = policy(request)
         self.assertEqual(result['context'], baz)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ())
@@ -244,7 +254,8 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         policy = self._makeOne(None)
         environ = self._getEnviron(HTTP_X_VHM_ROOT='/',
                                    PATH_INFO='/')
-        result = policy(environ)
+        request = DummyRequest(environ)
+        result = policy(request)
         self.assertEqual(result['context'], None)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ())
@@ -259,8 +270,9 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         policy = self._makeOne(root)
         segment = unicode('LaPe\xc3\xb1a', 'utf-8').encode('utf-16')
         environ = self._getEnviron(PATH_INFO='/%s' % segment)
+        request = DummyRequest(environ)
         from pyramid.exceptions import URLDecodeError
-        self.assertRaises(URLDecodeError, policy, environ)
+        self.assertRaises(URLDecodeError, policy, request)
 
     def test_non_utf8_path_segment_settings_unicode_path_segments_fails(self):
         foo = DummyContext()
@@ -268,14 +280,16 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         policy = self._makeOne(root)
         segment = unicode('LaPe\xc3\xb1a', 'utf-8').encode('utf-16')
         environ = self._getEnviron(PATH_INFO='/%s' % segment)
+        request = DummyRequest(environ)
         from pyramid.exceptions import URLDecodeError
-        self.assertRaises(URLDecodeError, policy, environ)
+        self.assertRaises(URLDecodeError, policy, request)
 
     def test_withroute_nothingfancy(self):
         resource = DummyContext()
         traverser = self._makeOne(resource)
         environ = {'bfg.routes.matchdict': {}}
-        result = traverser(environ)
+        request = DummyRequest(environ)
+        result = traverser(request)
         self.assertEqual(result['context'], resource)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ())
@@ -288,7 +302,8 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         resource = DummyContext()
         traverser = self._makeOne(resource)
         environ = {'bfg.routes.matchdict': {'subpath':'/a/b/c'}}
-        result = traverser(environ)
+        request = DummyRequest(environ)
+        result = traverser(request)
         self.assertEqual(result['context'], resource)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ('a', 'b','c'))
@@ -301,7 +316,8 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         resource = DummyContext()
         traverser = self._makeOne(resource)
         environ = {'bfg.routes.matchdict': {'subpath':('a', 'b', 'c')}}
-        result = traverser(environ)
+        request = DummyRequest(environ)
+        result = traverser(request)
         self.assertEqual(result['context'], resource)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ('a', 'b','c'))
@@ -314,7 +330,8 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         resource = DummyContext()
         traverser = self._makeOne(resource)
         environ = {'bfg.routes.matchdict': {'traverse':'foo/bar'}}
-        result = traverser(environ)
+        request = DummyRequest(environ)
+        result = traverser(request)
         self.assertEqual(result['context'], resource)
         self.assertEqual(result['view_name'], 'foo')
         self.assertEqual(result['subpath'], ('bar',))
@@ -327,7 +344,8 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         resource = DummyContext()
         traverser = self._makeOne(resource)
         environ = {'bfg.routes.matchdict': {'traverse':('foo', 'bar')}}
-        result = traverser(environ)
+        request = DummyRequest(environ)
+        result = traverser(request)
         self.assertEqual(result['context'], resource)
         self.assertEqual(result['view_name'], 'foo')
         self.assertEqual(result['subpath'], ('bar',))
@@ -340,7 +358,8 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         resource = DummyContext()
         traverser = self._makeOne(resource)
         environ = {'bfg.routes.matchdict': {'traverse':''}}
-        result = traverser(environ)
+        request = DummyRequest(environ)
+        result = traverser(request)
         self.assertEqual(result['context'], resource)
         self.assertEqual(result['view_name'], '')
         self.assertEqual(result['subpath'], ())
@@ -349,6 +368,23 @@ class ResourceTreeTraverserTests(unittest.TestCase):
         self.assertEqual(result['virtual_root'], resource)
         self.assertEqual(result['virtual_root_path'], ())
 
+    def test_call_with_environ(self):
+        import warnings
+        warnings.filterwarnings('ignore')
+        try:
+            policy = self._makeOne(None)
+            environ = self._getEnviron()
+            result = policy(environ)
+            self.assertEqual(result['context'], None)
+            self.assertEqual(result['view_name'], '')
+            self.assertEqual(result['subpath'], ())
+            self.assertEqual(result['traversed'], ())
+            self.assertEqual(result['root'], policy.root)
+            self.assertEqual(result['virtual_root'], policy.root)
+            self.assertEqual(result['virtual_root_path'], ())
+        finally:
+            warnings.resetwarnings()
+
 class FindInterfaceTests(unittest.TestCase):
     def _callFUT(self, context, iface):
         from pyramid.traversal import find_interface
diff --git a/pyramid/traversal.py b/pyramid/traversal.py
index 540f17a31..48f8017f6 100644
--- a/pyramid/traversal.py
+++ b/pyramid/traversal.py
@@ -1,4 +1,5 @@
 import urllib
+import warnings
 
 from zope.interface import implements
 from zope.interface.interfaces import IInterface
@@ -573,6 +574,10 @@ class ResourceTreeTraverser(object):
             # rather than a request; some bit of code may still be
             # passing us an environ.  If so, deal.
             environ = request
+            depwarn = ('Passing an environ dictionary directly to a traverser '
+                       'is deprecated in Pyramid 1.1.  Pass a request object '
+                       'instead.')
+            warnings.warn(depwarn, DeprecationWarning, 2)
 
         if 'bfg.routes.matchdict' in environ:
             matchdict = environ['bfg.routes.matchdict']