diff options
26 files changed, 553 insertions, 546 deletions
diff --git a/pyramid/authentication.py b/pyramid/authentication.py index 445d6fcd2..9d61e4d90 100644 --- a/pyramid/authentication.py +++ b/pyramid/authentication.py @@ -34,6 +34,7 @@ from pyramid.security import ( ) from pyramid.util import strings_differ +from pyramid.util import SimpleSerializer VALID_TOKEN = re.compile(r"^[A-Za-z][A-Za-z0-9+_-]*$") @@ -797,7 +798,7 @@ class AuthTktCookieHelper(object): max_age=None, http_only=False, path="/", wild_domain=True, hashalg='md5', parent_domain=False, domain=None): - serializer = _SimpleSerializer() + serializer = SimpleSerializer() self.cookie_profile = CookieProfile( cookie_name=cookie_name, @@ -1125,14 +1126,6 @@ class BasicAuthAuthenticationPolicy(CallbackAuthenticationPolicy): return self.check(username, password, request) -class _SimpleSerializer(object): - def loads(self, bstruct): - return native_(bstruct) - - def dumps(self, appstruct): - return bytes_(appstruct) - - HTTPBasicCredentials = namedtuple( 'HTTPBasicCredentials', ['username', 'password']) diff --git a/pyramid/config/__init__.py b/pyramid/config/__init__.py index 886eec0df..f4fcf413e 100644 --- a/pyramid/config/__init__.py +++ b/pyramid/config/__init__.py @@ -58,12 +58,17 @@ from pyramid.settings import aslist from pyramid.threadlocal import manager from pyramid.util import ( - ActionInfo, WeakOrderedSet, - action_method, object_description, ) +from pyramid.config.util import ( + ActionInfo, + PredicateList, + action_method, + not_, +) + from pyramid.config.adapters import AdaptersConfiguratorMixin from pyramid.config.assets import AssetsConfiguratorMixin from pyramid.config.factories import FactoriesConfiguratorMixin @@ -74,7 +79,6 @@ from pyramid.config.security import SecurityConfiguratorMixin from pyramid.config.settings import SettingsConfiguratorMixin from pyramid.config.testing import TestingConfiguratorMixin from pyramid.config.tweens import TweensConfiguratorMixin -from pyramid.config.util import PredicateList, not_ from pyramid.config.views import ViewsConfiguratorMixin from pyramid.config.zca import ZCAConfiguratorMixin @@ -83,9 +87,7 @@ from pyramid.path import DottedNameResolver empty = text_('') _marker = object() -ConfigurationError = ConfigurationError # pyflakes - -not_ = not_ # pyflakes, this is an API +not_ = not_ # api PHASE0_CONFIG = PHASE0_CONFIG # api PHASE1_CONFIG = PHASE1_CONFIG # api diff --git a/pyramid/config/adapters.py b/pyramid/config/adapters.py index a68070134..945faa3c6 100644 --- a/pyramid/config/adapters.py +++ b/pyramid/config/adapters.py @@ -10,10 +10,9 @@ from pyramid.interfaces import ( IResourceURL, ) -from pyramid.config.util import ( - action_method, - takes_one_arg, - ) +from pyramid.util import takes_one_arg + +from pyramid.config.util import action_method class AdaptersConfiguratorMixin(object): diff --git a/pyramid/config/assets.py b/pyramid/config/assets.py index 6eafc1eb1..b9536df42 100644 --- a/pyramid/config/assets.py +++ b/pyramid/config/assets.py @@ -12,7 +12,7 @@ from pyramid.interfaces import ( from pyramid.exceptions import ConfigurationError from pyramid.threadlocal import get_current_registry -from pyramid.util import action_method +from pyramid.config.util import action_method class OverrideProvider(pkg_resources.DefaultProvider): def __init__(self, module): diff --git a/pyramid/config/factories.py b/pyramid/config/factories.py index 202c3ef61..7a5b589cf 100644 --- a/pyramid/config/factories.py +++ b/pyramid/config/factories.py @@ -15,11 +15,11 @@ from pyramid.router import default_execution_policy from pyramid.traversal import DefaultRootFactory from pyramid.util import ( - action_method, get_callable_name, InstancePropertyHelper, ) +from pyramid.config.util import action_method class FactoriesConfiguratorMixin(object): @action_method diff --git a/pyramid/config/i18n.py b/pyramid/config/i18n.py index 9c5b7e682..5dabe2845 100644 --- a/pyramid/config/i18n.py +++ b/pyramid/config/i18n.py @@ -5,7 +5,8 @@ from pyramid.interfaces import ( from pyramid.exceptions import ConfigurationError from pyramid.path import AssetResolver -from pyramid.util import action_method + +from pyramid.config.util import action_method class I18NConfiguratorMixin(object): @action_method diff --git a/pyramid/config/predicates.py b/pyramid/config/predicates.py index 5d99d6564..bda763161 100644 --- a/pyramid/config/predicates.py +++ b/pyramid/config/predicates.py @@ -1,2 +1,2 @@ import zope.deprecation -zope.deprecation.moved('pyramid.predicates', 'Pyramid 2.0') +zope.deprecation.moved('pyramid.predicates', 'Pyramid 1.10') diff --git a/pyramid/config/rendering.py b/pyramid/config/rendering.py index 68671d08e..0d55c41e8 100644 --- a/pyramid/config/rendering.py +++ b/pyramid/config/rendering.py @@ -3,8 +3,8 @@ from pyramid.interfaces import ( PHASE1_CONFIG, ) -from pyramid.util import action_method from pyramid import renderers +from pyramid.config.util import action_method DEFAULT_RENDERERS = ( ('json', renderers.json_renderer_factory), diff --git a/pyramid/config/routes.py b/pyramid/config/routes.py index 20fdb2b5d..904c7bd4e 100644 --- a/pyramid/config/routes.py +++ b/pyramid/config/routes.py @@ -10,15 +10,18 @@ from pyramid.interfaces import ( ) from pyramid.exceptions import ConfigurationError -from pyramid.registry import predvalseq from pyramid.request import route_request_iface from pyramid.urldispatch import RoutesMapper -from pyramid.config.util import action_method from pyramid.util import as_sorted_tuple import pyramid.predicates +from pyramid.config.util import ( + action_method, + predvalseq, +) + class RoutesConfiguratorMixin(object): @action_method def add_route(self, diff --git a/pyramid/config/security.py b/pyramid/config/security.py index 20b816161..c7afbcf4e 100644 --- a/pyramid/config/security.py +++ b/pyramid/config/security.py @@ -12,9 +12,9 @@ from pyramid.interfaces import ( from pyramid.csrf import LegacySessionCSRFStoragePolicy from pyramid.exceptions import ConfigurationError -from pyramid.util import action_method from pyramid.util import as_sorted_tuple +from pyramid.config.util import action_method class SecurityConfiguratorMixin(object): diff --git a/pyramid/config/testing.py b/pyramid/config/testing.py index 5df726a31..1daf5cdeb 100644 --- a/pyramid/config/testing.py +++ b/pyramid/config/testing.py @@ -14,7 +14,7 @@ from pyramid.traversal import ( split_path_info, ) -from pyramid.util import action_method +from pyramid.config.util import action_method class TestingConfiguratorMixin(object): # testing API diff --git a/pyramid/config/tweens.py b/pyramid/config/tweens.py index 16712ab16..8bf21cf71 100644 --- a/pyramid/config/tweens.py +++ b/pyramid/config/tweens.py @@ -15,11 +15,12 @@ from pyramid.tweens import ( EXCVIEW, ) -from pyramid.config.util import ( - action_method, +from pyramid.util import ( + is_string_or_iterable, TopologicalSorter, ) -from pyramid.util import is_string_or_iterable + +from pyramid.config.util import action_method class TweensConfiguratorMixin(object): def add_tween(self, tween_factory, under=None, over=None): diff --git a/pyramid/config/util.py b/pyramid/config/util.py index 63f06ff9b..aedebd9e2 100644 --- a/pyramid/config/util.py +++ b/pyramid/config/util.py @@ -1,28 +1,81 @@ +import functools from hashlib import md5 -import inspect +import traceback +from zope.interface import implementer from pyramid.compat import ( bytes_, - getargspec, is_nonstr_iter - ) +) +from pyramid.interfaces import IActionInfo -from pyramid.compat import im_func from pyramid.exceptions import ConfigurationError +from pyramid.predicates import Notted from pyramid.registry import predvalseq - from pyramid.util import ( TopologicalSorter, - action_method, - ActionInfo, - ) + takes_one_arg, +) + +TopologicalSorter = TopologicalSorter # support bw-compat imports +takes_one_arg = takes_one_arg # support bw-compat imports + +@implementer(IActionInfo) +class ActionInfo(object): + def __init__(self, file, line, function, src): + self.file = file + self.line = line + self.function = function + self.src = src + + def __str__(self): + srclines = self.src.split('\n') + src = '\n'.join(' %s' % x for x in srclines) + return 'Line %s of file %s:\n%s' % (self.line, self.file, src) + +def action_method(wrapped): + """ Wrapper to provide the right conflict info report data when a method + that calls Configurator.action calls another that does the same. Not a + documented API but used by some external systems.""" + def wrapper(self, *arg, **kw): + if self._ainfo is None: + self._ainfo = [] + info = kw.pop('_info', None) + # backframes for outer decorators to actionmethods + backframes = kw.pop('_backframes', 0) + 2 + if is_nonstr_iter(info) and len(info) == 4: + # _info permitted as extract_stack tuple + info = ActionInfo(*info) + if info is None: + try: + f = traceback.extract_stack(limit=4) + + # Work around a Python 3.5 issue whereby it would insert an + # extra stack frame. This should no longer be necessary in + # Python 3.5.1 + last_frame = ActionInfo(*f[-1]) + if last_frame.function == 'extract_stack': # pragma: no cover + f.pop() + info = ActionInfo(*f[-backframes]) + except Exception: # pragma: no cover + info = ActionInfo(None, 0, '', '') + self._ainfo.append(info) + try: + result = wrapped(self, *arg, **kw) + finally: + self._ainfo.pop() + return result + + if hasattr(wrapped, '__name__'): + functools.update_wrapper(wrapper, wrapped) + wrapper.__docobj__ = wrapped + return wrapper -action_method = action_method # support bw compat imports -ActionInfo = ActionInfo # support bw compat imports MAX_ORDER = 1 << 30 DEFAULT_PHASH = md5().hexdigest() + class not_(object): """ @@ -61,30 +114,6 @@ class not_(object): def __init__(self, value): self.value = value -class Notted(object): - def __init__(self, predicate): - self.predicate = predicate - - def _notted_text(self, val): - # if the underlying predicate doesnt return a value, it's not really - # a predicate, it's just something pretending to be a predicate, - # so dont update the hash - if val: - val = '!' + val - return val - - def text(self): - return self._notted_text(self.predicate.text()) - - def phash(self): - return self._notted_text(self.predicate.phash()) - - def __call__(self, context, request): - result = self.predicate(context, request) - phash = self.phash() - if phash: - result = not result - return result # under = after # over = before @@ -189,52 +218,3 @@ class PredicateList(object): score = score | bit order = (MAX_ORDER - score) / (len(preds) + 1) return order, preds, phash.hexdigest() - -def takes_one_arg(callee, attr=None, argname=None): - ismethod = False - if attr is None: - attr = '__call__' - if inspect.isroutine(callee): - fn = callee - elif inspect.isclass(callee): - try: - fn = callee.__init__ - except AttributeError: - return False - ismethod = hasattr(fn, '__call__') - else: - try: - fn = getattr(callee, attr) - except AttributeError: - return False - - try: - argspec = getargspec(fn) - except TypeError: - return False - - args = argspec[0] - - if hasattr(fn, im_func) or ismethod: - # it's an instance method (or unbound method on py2) - if not args: - return False - args = args[1:] - - if not args: - return False - - if len(args) == 1: - return True - - if argname: - - defaults = argspec[3] - if defaults is None: - defaults = () - - if args[0] == argname: - if len(args) - len(defaults) == 1: - return True - - return False diff --git a/pyramid/config/views.py b/pyramid/config/views.py index e5ebc8e07..eb002ec2d 100644 --- a/pyramid/config/views.py +++ b/pyramid/config/views.py @@ -1,3 +1,4 @@ +import functools import inspect import posixpath import operator @@ -54,10 +55,7 @@ from pyramid.httpexceptions import ( default_exceptionresponse_view, ) -from pyramid.registry import ( - predvalseq, - Deferred, - ) +from pyramid.registry import Deferred from pyramid.security import NO_PERMISSION_REQUIRED from pyramid.static import static_view @@ -66,10 +64,7 @@ from pyramid.url import parse_url_overrides from pyramid.view import AppendSlashNotFoundViewFactory -import pyramid.util from pyramid.util import ( - viewdefaults, - action_method, as_sorted_tuple, TopologicalSorter, ) @@ -88,8 +83,10 @@ from pyramid.viewderivers import ( ) from pyramid.config.util import ( + action_method, DEFAULT_PHASH, MAX_ORDER, + predvalseq, ) urljoin = urlparse.urljoin @@ -183,6 +180,68 @@ class MultiView(object): continue raise PredicateMismatch(self.name) +def attr_wrapped_view(view, info): + accept, order, phash = (info.options.get('accept', None), + getattr(info, 'order', MAX_ORDER), + getattr(info, 'phash', DEFAULT_PHASH)) + # this is a little silly but we don't want to decorate the original + # function with attributes that indicate accept, order, and phash, + # so we use a wrapper + if ( + (accept is None) and + (order == MAX_ORDER) and + (phash == DEFAULT_PHASH) + ): + return view # defaults + def attr_view(context, request): + return view(context, request) + attr_view.__accept__ = accept + attr_view.__order__ = order + attr_view.__phash__ = phash + attr_view.__view_attr__ = info.options.get('attr') + attr_view.__permission__ = info.options.get('permission') + return attr_view + +attr_wrapped_view.options = ('accept', 'attr', 'permission') + +def predicated_view(view, info): + preds = info.predicates + if not preds: + return view + def predicate_wrapper(context, request): + for predicate in preds: + if not predicate(context, request): + view_name = getattr(view, '__name__', view) + raise PredicateMismatch( + 'predicate mismatch for view %s (%s)' % ( + view_name, predicate.text())) + return view(context, request) + def checker(context, request): + return all((predicate(context, request) for predicate in + preds)) + predicate_wrapper.__predicated__ = checker + predicate_wrapper.__predicates__ = preds + return predicate_wrapper + +def viewdefaults(wrapped): + """ Decorator for add_view-like methods which takes into account + __view_defaults__ attached to view it is passed. Not a documented API but + used by some external systems.""" + def wrapper(self, *arg, **kw): + defaults = {} + if arg: + view = arg[0] + else: + view = kw.get('view') + view = self.maybe_dotted(view) + if inspect.isclass(view): + defaults = getattr(view, '__view_defaults__', {}).copy() + if '_backframes' not in kw: + kw['_backframes'] = 1 # for action_method + defaults.update(kw) + return wrapped(self, *arg, **defaults) + return functools.wraps(wrapped)(wrapper) + class ViewsConfiguratorMixin(object): @viewdefaults @action_method @@ -1106,11 +1165,9 @@ class ViewsConfiguratorMixin(object): raise ConfigurationError('Unknown view options: %s' % (kw,)) def _apply_view_derivers(self, info): - d = pyramid.viewderivers - # These derivers are not really derivers and so have fixed order - outer_derivers = [('attr_wrapped_view', d.attr_wrapped_view), - ('predicated_view', d.predicated_view)] + outer_derivers = [('attr_wrapped_view', attr_wrapped_view), + ('predicated_view', predicated_view)] view = info.original_view derivers = self.registry.getUtility(IViewDerivers) diff --git a/pyramid/csrf.py b/pyramid/csrf.py index 7c836e5ad..b023bda5f 100644 --- a/pyramid/csrf.py +++ b/pyramid/csrf.py @@ -4,8 +4,6 @@ from webob.cookies import CookieProfile from zope.interface import implementer -from pyramid.authentication import _SimpleSerializer - from pyramid.compat import ( bytes_, urlparse, @@ -18,6 +16,7 @@ from pyramid.exceptions import ( from pyramid.interfaces import ICSRFStoragePolicy from pyramid.settings import aslist from pyramid.util import ( + SimpleSerializer, is_same_domain, strings_differ ) @@ -112,7 +111,7 @@ class CookieCSRFStoragePolicy(object): def __init__(self, cookie_name='csrf_token', secure=False, httponly=False, domain=None, max_age=None, path='/'): - serializer = _SimpleSerializer() + serializer = SimpleSerializer() self.cookie_profile = CookieProfile( cookie_name=cookie_name, secure=secure, diff --git a/pyramid/predicates.py b/pyramid/predicates.py index 3d7bb1b4b..5e54badff 100644 --- a/pyramid/predicates.py +++ b/pyramid/predicates.py @@ -12,8 +12,10 @@ from pyramid.traversal import ( ) from pyramid.urldispatch import _compile_route -from pyramid.util import object_description -from pyramid.util import as_sorted_tuple +from pyramid.util import ( + as_sorted_tuple, + object_description, +) _marker = object() @@ -298,3 +300,27 @@ class EffectivePrincipalsPredicate(object): return True return False +class Notted(object): + def __init__(self, predicate): + self.predicate = predicate + + def _notted_text(self, val): + # if the underlying predicate doesnt return a value, it's not really + # a predicate, it's just something pretending to be a predicate, + # so dont update the hash + if val: + val = '!' + val + return val + + def text(self): + return self._notted_text(self.predicate.text()) + + def phash(self): + return self._notted_text(self.predicate.phash()) + + def __call__(self, context, request): + result = self.predicate(context, request) + phash = self.phash() + if phash: + result = not result + return result diff --git a/pyramid/registry.py b/pyramid/registry.py index 7b75aeefc..a741c495e 100644 --- a/pyramid/registry.py +++ b/pyramid/registry.py @@ -2,7 +2,6 @@ import operator import threading from zope.interface import implementer - from zope.interface.registry import Components from pyramid.compat import text_ @@ -294,6 +293,5 @@ def undefer(v): class predvalseq(tuple): """ A subtype of tuple used to represent a sequence of predicate values """ - pass global_registry = Registry('global') diff --git a/pyramid/tests/test_authentication.py b/pyramid/tests/test_authentication.py index b9a4c6be4..aeb4a467b 100644 --- a/pyramid/tests/test_authentication.py +++ b/pyramid/tests/test_authentication.py @@ -1549,21 +1549,6 @@ class TestExtractHTTPBasicCredentials(unittest.TestCase): self.assertEqual(result.username, 'chrisr') self.assertEqual(result.password, 'pass') - - - -class TestSimpleSerializer(unittest.TestCase): - def _makeOne(self): - from pyramid.authentication import _SimpleSerializer - return _SimpleSerializer() - - def test_loads(self): - inst = self._makeOne() - self.assertEqual(inst.loads(b'abc'), text_('abc')) - - def test_dumps(self): - inst = self._makeOne() - self.assertEqual(inst.dumps('abc'), bytes_('abc')) class DummyContext: pass diff --git a/pyramid/tests/test_config/test_init.py b/pyramid/tests/test_config/test_init.py index ab584cc3d..76a3d703d 100644 --- a/pyramid/tests/test_config/test_init.py +++ b/pyramid/tests/test_config/test_init.py @@ -852,7 +852,7 @@ pyramid.tests.test_config.dummy_include2""", self.assertEqual(config.action('discrim', kw={'a':1}), None) def test_action_autocommit_with_introspectables(self): - from pyramid.util import ActionInfo + from pyramid.config.util import ActionInfo config = self._makeOne(autocommit=True) intr = DummyIntrospectable() config.action('discrim', introspectables=(intr,)) diff --git a/pyramid/tests/test_config/test_util.py b/pyramid/tests/test_config/test_util.py index bb86a1f56..99c67e8c6 100644 --- a/pyramid/tests/test_config/test_util.py +++ b/pyramid/tests/test_config/test_util.py @@ -1,6 +1,38 @@ import unittest + from pyramid.compat import text_ +class TestActionInfo(unittest.TestCase): + def _getTargetClass(self): + from pyramid.config.util import ActionInfo + return ActionInfo + + def _makeOne(self, filename, lineno, function, linerepr): + return self._getTargetClass()(filename, lineno, function, linerepr) + + def test_class_conforms(self): + from zope.interface.verify import verifyClass + from pyramid.interfaces import IActionInfo + verifyClass(IActionInfo, self._getTargetClass()) + + def test_instance_conforms(self): + from zope.interface.verify import verifyObject + from pyramid.interfaces import IActionInfo + verifyObject(IActionInfo, self._makeOne('f', 0, 'f', 'f')) + + def test_ctor(self): + inst = self._makeOne('filename', 10, 'function', 'src') + self.assertEqual(inst.file, 'filename') + self.assertEqual(inst.line, 10) + self.assertEqual(inst.function, 'function') + self.assertEqual(inst.src, 'src') + + def test___str__(self): + inst = self._makeOne('filename', 0, 'function', ' linerepr ') + self.assertEqual(str(inst), + "Line 0 of file filename:\n linerepr ") + + class TestPredicateList(unittest.TestCase): def _makeOne(self): @@ -391,220 +423,6 @@ class TestPredicateList(unittest.TestCase): self.assertEqual(predicates[1](None, request), True) self.assertEqual(predicates[2](None, request), True) - -class Test_takes_one_arg(unittest.TestCase): - def _callFUT(self, view, attr=None, argname=None): - from pyramid.config.util import takes_one_arg - return takes_one_arg(view, attr=attr, argname=argname) - - def test_requestonly_newstyle_class_no_init(self): - class foo(object): - """ """ - self.assertFalse(self._callFUT(foo)) - - def test_requestonly_newstyle_class_init_toomanyargs(self): - class foo(object): - def __init__(self, context, request): - """ """ - self.assertFalse(self._callFUT(foo)) - - def test_requestonly_newstyle_class_init_onearg_named_request(self): - class foo(object): - def __init__(self, request): - """ """ - self.assertTrue(self._callFUT(foo)) - - def test_newstyle_class_init_onearg_named_somethingelse(self): - class foo(object): - def __init__(self, req): - """ """ - self.assertTrue(self._callFUT(foo)) - - def test_newstyle_class_init_defaultargs_firstname_not_request(self): - class foo(object): - def __init__(self, context, request=None): - """ """ - self.assertFalse(self._callFUT(foo)) - - def test_newstyle_class_init_defaultargs_firstname_request(self): - class foo(object): - def __init__(self, request, foo=1, bar=2): - """ """ - self.assertTrue(self._callFUT(foo, argname='request')) - - def test_newstyle_class_init_firstname_request_with_secondname(self): - class foo(object): - def __init__(self, request, two): - """ """ - self.assertFalse(self._callFUT(foo)) - - def test_newstyle_class_init_noargs(self): - class foo(object): - def __init__(): - """ """ - self.assertFalse(self._callFUT(foo)) - - def test_oldstyle_class_no_init(self): - class foo: - """ """ - self.assertFalse(self._callFUT(foo)) - - def test_oldstyle_class_init_toomanyargs(self): - class foo: - def __init__(self, context, request): - """ """ - self.assertFalse(self._callFUT(foo)) - - def test_oldstyle_class_init_onearg_named_request(self): - class foo: - def __init__(self, request): - """ """ - self.assertTrue(self._callFUT(foo)) - - def test_oldstyle_class_init_onearg_named_somethingelse(self): - class foo: - def __init__(self, req): - """ """ - self.assertTrue(self._callFUT(foo)) - - def test_oldstyle_class_init_defaultargs_firstname_not_request(self): - class foo: - def __init__(self, context, request=None): - """ """ - self.assertFalse(self._callFUT(foo)) - - def test_oldstyle_class_init_defaultargs_firstname_request(self): - class foo: - def __init__(self, request, foo=1, bar=2): - """ """ - self.assertTrue(self._callFUT(foo, argname='request'), True) - - def test_oldstyle_class_init_noargs(self): - class foo: - def __init__(): - """ """ - self.assertFalse(self._callFUT(foo)) - - def test_function_toomanyargs(self): - def foo(context, request): - """ """ - self.assertFalse(self._callFUT(foo)) - - def test_function_with_attr_false(self): - def bar(context, request): - """ """ - def foo(context, request): - """ """ - foo.bar = bar - self.assertFalse(self._callFUT(foo, 'bar')) - - def test_function_with_attr_true(self): - def bar(context, request): - """ """ - def foo(request): - """ """ - foo.bar = bar - self.assertTrue(self._callFUT(foo, 'bar')) - - def test_function_onearg_named_request(self): - def foo(request): - """ """ - self.assertTrue(self._callFUT(foo)) - - def test_function_onearg_named_somethingelse(self): - def foo(req): - """ """ - self.assertTrue(self._callFUT(foo)) - - def test_function_defaultargs_firstname_not_request(self): - def foo(context, request=None): - """ """ - self.assertFalse(self._callFUT(foo)) - - def test_function_defaultargs_firstname_request(self): - def foo(request, foo=1, bar=2): - """ """ - self.assertTrue(self._callFUT(foo, argname='request')) - - def test_function_noargs(self): - def foo(): - """ """ - self.assertFalse(self._callFUT(foo)) - - def test_instance_toomanyargs(self): - class Foo: - def __call__(self, context, request): - """ """ - foo = Foo() - self.assertFalse(self._callFUT(foo)) - - def test_instance_defaultargs_onearg_named_request(self): - class Foo: - def __call__(self, request): - """ """ - foo = Foo() - self.assertTrue(self._callFUT(foo)) - - def test_instance_defaultargs_onearg_named_somethingelse(self): - class Foo: - def __call__(self, req): - """ """ - foo = Foo() - self.assertTrue(self._callFUT(foo)) - - def test_instance_defaultargs_firstname_not_request(self): - class Foo: - def __call__(self, context, request=None): - """ """ - foo = Foo() - self.assertFalse(self._callFUT(foo)) - - def test_instance_defaultargs_firstname_request(self): - class Foo: - def __call__(self, request, foo=1, bar=2): - """ """ - foo = Foo() - self.assertTrue(self._callFUT(foo, argname='request'), True) - - def test_instance_nocall(self): - class Foo: pass - foo = Foo() - self.assertFalse(self._callFUT(foo)) - - def test_method_onearg_named_request(self): - class Foo: - def method(self, request): - """ """ - foo = Foo() - self.assertTrue(self._callFUT(foo.method)) - - def test_function_annotations(self): - def foo(bar): - """ """ - # avoid SyntaxErrors in python2, this if effectively nop - getattr(foo, '__annotations__', {}).update({'bar': 'baz'}) - self.assertTrue(self._callFUT(foo)) - -class TestNotted(unittest.TestCase): - def _makeOne(self, predicate): - from pyramid.config.util import Notted - return Notted(predicate) - - def test_it_with_phash_val(self): - pred = DummyPredicate('val') - inst = self._makeOne(pred) - self.assertEqual(inst.text(), '!val') - self.assertEqual(inst.phash(), '!val') - self.assertEqual(inst(None, None), False) - - def test_it_without_phash_val(self): - pred = DummyPredicate('') - inst = self._makeOne(pred) - self.assertEqual(inst.text(), '') - self.assertEqual(inst.phash(), '') - self.assertEqual(inst(None, None), True) - - class TestDeprecatedPredicates(unittest.TestCase): def test_it(self): import warnings @@ -613,18 +431,6 @@ class TestDeprecatedPredicates(unittest.TestCase): from pyramid.config.predicates import XHRPredicate self.assertEqual(len(w), 1) -class DummyPredicate(object): - def __init__(self, result): - self.result = result - - def text(self): - return self.result - - phash = text - - def __call__(self, context, request): - return True - class DummyCustomPredicate(object): def __init__(self): self.__text__ = 'custom predicate' @@ -636,8 +442,9 @@ class DummyCustomPredicate(object): @classmethod def classmethod_predicate_no_text(*args): pass # pragma: no cover -class Dummy: - pass +class Dummy(object): + def __init__(self, **kw): + self.__dict__.update(**kw) class DummyRequest: subpath = () @@ -652,4 +459,3 @@ class DummyRequest: class DummyConfigurator(object): def maybe_dotted(self, thing): return thing - diff --git a/pyramid/tests/test_config/test_views.py b/pyramid/tests/test_config/test_views.py index 860254385..cb554a816 100644 --- a/pyramid/tests/test_config/test_views.py +++ b/pyramid/tests/test_config/test_views.py @@ -542,8 +542,8 @@ class TestViewsConfigurationMixin(unittest.TestCase): self.assertEqual(wrapper(None, request), 'OK') def test_add_view_default_phash_overrides_default_phash(self): - from pyramid.renderers import null_renderer from pyramid.config.util import DEFAULT_PHASH + from pyramid.renderers import null_renderer from zope.interface import Interface from pyramid.interfaces import IRequest from pyramid.interfaces import IView @@ -564,8 +564,8 @@ class TestViewsConfigurationMixin(unittest.TestCase): self.assertEqual(wrapper(None, request), 'OK') def test_add_view_exc_default_phash_overrides_default_phash(self): - from pyramid.renderers import null_renderer from pyramid.config.util import DEFAULT_PHASH + from pyramid.renderers import null_renderer from zope.interface import implementedBy from pyramid.interfaces import IRequest from pyramid.interfaces import IView @@ -3385,6 +3385,18 @@ class Test_view_description(unittest.TestCase): self.assertEqual(result, 'function pyramid.tests.test_config.test_views.view') +class Test_viewdefaults(unittest.TestCase): + def _makeOne(self, wrapped): + from pyramid.decorator import reify + return reify(wrapped) + + def test_dunder_attrs_copied(self): + from pyramid.config.views import viewdefaults + decorator = self._makeOne(viewdefaults) + self.assertEqual(decorator.__doc__, viewdefaults.__doc__) + self.assertEqual(decorator.__name__, viewdefaults.__name__) + self.assertEqual(decorator.__module__, viewdefaults.__module__) + class DummyRegistry: utility = None diff --git a/pyramid/tests/test_decorator.py b/pyramid/tests/test_decorator.py index 0a98a512d..4b9313e06 100644 --- a/pyramid/tests/test_decorator.py +++ b/pyramid/tests/test_decorator.py @@ -21,13 +21,6 @@ class TestReify(unittest.TestCase): result = decorator.__get__(None) self.assertEqual(result, decorator) - def test_dunder_attrs_copied(self): - from pyramid.util import viewdefaults - decorator = self._makeOne(viewdefaults) - self.assertEqual(decorator.__doc__, viewdefaults.__doc__) - self.assertEqual(decorator.__name__, viewdefaults.__name__) - self.assertEqual(decorator.__module__, viewdefaults.__module__) - class Dummy(object): pass diff --git a/pyramid/tests/test_predicates.py b/pyramid/tests/test_predicates.py index 8a002c24e..da0b44708 100644 --- a/pyramid/tests/test_predicates.py +++ b/pyramid/tests/test_predicates.py @@ -514,13 +514,43 @@ class Test_EffectivePrincipalsPredicate(unittest.TestCase): context = Dummy() self.assertFalse(inst(context, request)) + +class TestNotted(unittest.TestCase): + def _makeOne(self, predicate): + from pyramid.predicates import Notted + return Notted(predicate) + + def test_it_with_phash_val(self): + pred = DummyPredicate('val') + inst = self._makeOne(pred) + self.assertEqual(inst.text(), '!val') + self.assertEqual(inst.phash(), '!val') + self.assertEqual(inst(None, None), False) + + def test_it_without_phash_val(self): + pred = DummyPredicate('') + inst = self._makeOne(pred) + self.assertEqual(inst.text(), '') + self.assertEqual(inst.phash(), '') + self.assertEqual(inst(None, None), True) + class predicate(object): def __repr__(self): return 'predicate' def __hash__(self): return 1 - + class Dummy(object): - def __init__(self, **kw): - self.__dict__.update(**kw) - + pass + +class DummyPredicate(object): + def __init__(self, result): + self.result = result + + def text(self): + return self.result + + phash = text + + def __call__(self, context, request): + return True diff --git a/pyramid/tests/test_util.py b/pyramid/tests/test_util.py index 0f7671d59..a76cd2017 100644 --- a/pyramid/tests/test_util.py +++ b/pyramid/tests/test_util.py @@ -1,5 +1,9 @@ import unittest -from pyramid.compat import PY2 +from pyramid.compat import ( + PY2, + text_, + bytes_, + ) class Test_InstancePropertyHelper(unittest.TestCase): @@ -747,36 +751,6 @@ class TestSentinel(unittest.TestCase): r = repr(Sentinel('ABC')) self.assertEqual(r, 'ABC') -class TestActionInfo(unittest.TestCase): - def _getTargetClass(self): - from pyramid.util import ActionInfo - return ActionInfo - - def _makeOne(self, filename, lineno, function, linerepr): - return self._getTargetClass()(filename, lineno, function, linerepr) - - def test_class_conforms(self): - from zope.interface.verify import verifyClass - from pyramid.interfaces import IActionInfo - verifyClass(IActionInfo, self._getTargetClass()) - - def test_instance_conforms(self): - from zope.interface.verify import verifyObject - from pyramid.interfaces import IActionInfo - verifyObject(IActionInfo, self._makeOne('f', 0, 'f', 'f')) - - def test_ctor(self): - inst = self._makeOne('filename', 10, 'function', 'src') - self.assertEqual(inst.file, 'filename') - self.assertEqual(inst.line, 10) - self.assertEqual(inst.function, 'function') - self.assertEqual(inst.src, 'src') - - def test___str__(self): - inst = self._makeOne('filename', 0, 'function', ' linerepr ') - self.assertEqual(str(inst), - "Line 0 of file filename:\n linerepr ") - class TestCallableName(unittest.TestCase): def test_valid_ascii(self): @@ -927,3 +901,211 @@ class Test_make_contextmanager(unittest.TestCase): mgr = self._callFUT(mygen) with mgr() as ctx: self.assertEqual(ctx, 'a') + + +class Test_takes_one_arg(unittest.TestCase): + def _callFUT(self, view, attr=None, argname=None): + from pyramid.util import takes_one_arg + return takes_one_arg(view, attr=attr, argname=argname) + + def test_requestonly_newstyle_class_no_init(self): + class foo(object): + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_requestonly_newstyle_class_init_toomanyargs(self): + class foo(object): + def __init__(self, context, request): + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_requestonly_newstyle_class_init_onearg_named_request(self): + class foo(object): + def __init__(self, request): + """ """ + self.assertTrue(self._callFUT(foo)) + + def test_newstyle_class_init_onearg_named_somethingelse(self): + class foo(object): + def __init__(self, req): + """ """ + self.assertTrue(self._callFUT(foo)) + + def test_newstyle_class_init_defaultargs_firstname_not_request(self): + class foo(object): + def __init__(self, context, request=None): + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_newstyle_class_init_defaultargs_firstname_request(self): + class foo(object): + def __init__(self, request, foo=1, bar=2): + """ """ + self.assertTrue(self._callFUT(foo, argname='request')) + + def test_newstyle_class_init_firstname_request_with_secondname(self): + class foo(object): + def __init__(self, request, two): + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_newstyle_class_init_noargs(self): + class foo(object): + def __init__(): + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_oldstyle_class_no_init(self): + class foo: + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_oldstyle_class_init_toomanyargs(self): + class foo: + def __init__(self, context, request): + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_oldstyle_class_init_onearg_named_request(self): + class foo: + def __init__(self, request): + """ """ + self.assertTrue(self._callFUT(foo)) + + def test_oldstyle_class_init_onearg_named_somethingelse(self): + class foo: + def __init__(self, req): + """ """ + self.assertTrue(self._callFUT(foo)) + + def test_oldstyle_class_init_defaultargs_firstname_not_request(self): + class foo: + def __init__(self, context, request=None): + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_oldstyle_class_init_defaultargs_firstname_request(self): + class foo: + def __init__(self, request, foo=1, bar=2): + """ """ + self.assertTrue(self._callFUT(foo, argname='request'), True) + + def test_oldstyle_class_init_noargs(self): + class foo: + def __init__(): + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_function_toomanyargs(self): + def foo(context, request): + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_function_with_attr_false(self): + def bar(context, request): + """ """ + def foo(context, request): + """ """ + foo.bar = bar + self.assertFalse(self._callFUT(foo, 'bar')) + + def test_function_with_attr_true(self): + def bar(context, request): + """ """ + def foo(request): + """ """ + foo.bar = bar + self.assertTrue(self._callFUT(foo, 'bar')) + + def test_function_onearg_named_request(self): + def foo(request): + """ """ + self.assertTrue(self._callFUT(foo)) + + def test_function_onearg_named_somethingelse(self): + def foo(req): + """ """ + self.assertTrue(self._callFUT(foo)) + + def test_function_defaultargs_firstname_not_request(self): + def foo(context, request=None): + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_function_defaultargs_firstname_request(self): + def foo(request, foo=1, bar=2): + """ """ + self.assertTrue(self._callFUT(foo, argname='request')) + + def test_function_noargs(self): + def foo(): + """ """ + self.assertFalse(self._callFUT(foo)) + + def test_instance_toomanyargs(self): + class Foo: + def __call__(self, context, request): + """ """ + foo = Foo() + self.assertFalse(self._callFUT(foo)) + + def test_instance_defaultargs_onearg_named_request(self): + class Foo: + def __call__(self, request): + """ """ + foo = Foo() + self.assertTrue(self._callFUT(foo)) + + def test_instance_defaultargs_onearg_named_somethingelse(self): + class Foo: + def __call__(self, req): + """ """ + foo = Foo() + self.assertTrue(self._callFUT(foo)) + + def test_instance_defaultargs_firstname_not_request(self): + class Foo: + def __call__(self, context, request=None): + """ """ + foo = Foo() + self.assertFalse(self._callFUT(foo)) + + def test_instance_defaultargs_firstname_request(self): + class Foo: + def __call__(self, request, foo=1, bar=2): + """ """ + foo = Foo() + self.assertTrue(self._callFUT(foo, argname='request'), True) + + def test_instance_nocall(self): + class Foo: pass + foo = Foo() + self.assertFalse(self._callFUT(foo)) + + def test_method_onearg_named_request(self): + class Foo: + def method(self, request): + """ """ + foo = Foo() + self.assertTrue(self._callFUT(foo.method)) + + def test_function_annotations(self): + def foo(bar): + """ """ + # avoid SyntaxErrors in python2, this if effectively nop + getattr(foo, '__annotations__', {}).update({'bar': 'baz'}) + self.assertTrue(self._callFUT(foo)) + + +class TestSimpleSerializer(unittest.TestCase): + def _makeOne(self): + from pyramid.util import SimpleSerializer + return SimpleSerializer() + + def test_loads(self): + inst = self._makeOne() + self.assertEqual(inst.loads(b'abc'), text_('abc')) + + def test_dumps(self): + inst = self._makeOne() + self.assertEqual(inst.dumps('abc'), bytes_('abc')) diff --git a/pyramid/util.py b/pyramid/util.py index 77a0f306b..6655455bf 100644 --- a/pyramid/util.py +++ b/pyramid/util.py @@ -6,26 +6,25 @@ try: except ImportError: # pragma: no cover compare_digest = None import inspect -import traceback import weakref -from zope.interface import implementer - from pyramid.exceptions import ( ConfigurationError, CyclicDependencyError, ) from pyramid.compat import ( + getargspec, + im_func, is_nonstr_iter, integer_types, string_types, + bytes_, text_, PY2, native_ ) -from pyramid.interfaces import IActionInfo from pyramid.path import DottedNameResolver as _DottedNameResolver _marker = object() @@ -528,76 +527,6 @@ class TopologicalSorter(object): return result -def viewdefaults(wrapped): - """ Decorator for add_view-like methods which takes into account - __view_defaults__ attached to view it is passed. Not a documented API but - used by some external systems.""" - def wrapper(self, *arg, **kw): - defaults = {} - if arg: - view = arg[0] - else: - view = kw.get('view') - view = self.maybe_dotted(view) - if inspect.isclass(view): - defaults = getattr(view, '__view_defaults__', {}).copy() - if '_backframes' not in kw: - kw['_backframes'] = 1 # for action_method - defaults.update(kw) - return wrapped(self, *arg, **defaults) - return functools.wraps(wrapped)(wrapper) - -@implementer(IActionInfo) -class ActionInfo(object): - def __init__(self, file, line, function, src): - self.file = file - self.line = line - self.function = function - self.src = src - - def __str__(self): - srclines = self.src.split('\n') - src = '\n'.join(' %s' % x for x in srclines) - return 'Line %s of file %s:\n%s' % (self.line, self.file, src) - -def action_method(wrapped): - """ Wrapper to provide the right conflict info report data when a method - that calls Configurator.action calls another that does the same. Not a - documented API but used by some external systems.""" - def wrapper(self, *arg, **kw): - if self._ainfo is None: - self._ainfo = [] - info = kw.pop('_info', None) - # backframes for outer decorators to actionmethods - backframes = kw.pop('_backframes', 0) + 2 - if is_nonstr_iter(info) and len(info) == 4: - # _info permitted as extract_stack tuple - info = ActionInfo(*info) - if info is None: - try: - f = traceback.extract_stack(limit=4) - - # Work around a Python 3.5 issue whereby it would insert an - # extra stack frame. This should no longer be necessary in - # Python 3.5.1 - last_frame = ActionInfo(*f[-1]) - if last_frame.function == 'extract_stack': # pragma: no cover - f.pop() - info = ActionInfo(*f[-backframes]) - except Exception: # pragma: no cover - info = ActionInfo(None, 0, '', '') - self._ainfo.append(info) - try: - result = wrapped(self, *arg, **kw) - finally: - self._ainfo.pop() - return result - - if hasattr(wrapped, '__name__'): - functools.update_wrapper(wrapper, wrapped) - wrapper.__docobj__ = wrapped - return wrapper - def get_callable_name(name): """ @@ -662,3 +591,61 @@ def make_contextmanager(fn): def wrapper(*a, **kw): yield fn(*a, **kw) return wrapper + + +def takes_one_arg(callee, attr=None, argname=None): + ismethod = False + if attr is None: + attr = '__call__' + if inspect.isroutine(callee): + fn = callee + elif inspect.isclass(callee): + try: + fn = callee.__init__ + except AttributeError: + return False + ismethod = hasattr(fn, '__call__') + else: + try: + fn = getattr(callee, attr) + except AttributeError: + return False + + try: + argspec = getargspec(fn) + except TypeError: + return False + + args = argspec[0] + + if hasattr(fn, im_func) or ismethod: + # it's an instance method (or unbound method on py2) + if not args: + return False + args = args[1:] + + if not args: + return False + + if len(args) == 1: + return True + + if argname: + + defaults = argspec[3] + if defaults is None: + defaults = () + + if args[0] == argname: + if len(args) - len(defaults) == 1: + return True + + return False + + +class SimpleSerializer(object): + def loads(self, bstruct): + return native_(bstruct) + + def dumps(self, appstruct): + return bytes_(appstruct) diff --git a/pyramid/viewderivers.py b/pyramid/viewderivers.py index d2869b162..d914a4752 100644 --- a/pyramid/viewderivers.py +++ b/pyramid/viewderivers.py @@ -28,18 +28,14 @@ from pyramid.compat import ( is_unbound_method, ) -from pyramid.config.util import ( - DEFAULT_PHASH, - MAX_ORDER, - takes_one_arg, - ) - from pyramid.exceptions import ( ConfigurationError, - PredicateMismatch, ) from pyramid.httpexceptions import HTTPForbidden -from pyramid.util import object_description +from pyramid.util import ( + object_description, + takes_one_arg, +) from pyramid.view import render_view_to_response from pyramid import renderers @@ -353,49 +349,6 @@ def _authdebug_view(view, info): return wrapped_view -def predicated_view(view, info): - preds = info.predicates - if not preds: - return view - def predicate_wrapper(context, request): - for predicate in preds: - if not predicate(context, request): - view_name = getattr(view, '__name__', view) - raise PredicateMismatch( - 'predicate mismatch for view %s (%s)' % ( - view_name, predicate.text())) - return view(context, request) - def checker(context, request): - return all((predicate(context, request) for predicate in - preds)) - predicate_wrapper.__predicated__ = checker - predicate_wrapper.__predicates__ = preds - return predicate_wrapper - -def attr_wrapped_view(view, info): - accept, order, phash = (info.options.get('accept', None), - getattr(info, 'order', MAX_ORDER), - getattr(info, 'phash', DEFAULT_PHASH)) - # this is a little silly but we don't want to decorate the original - # function with attributes that indicate accept, order, and phash, - # so we use a wrapper - if ( - (accept is None) and - (order == MAX_ORDER) and - (phash == DEFAULT_PHASH) - ): - return view # defaults - def attr_view(context, request): - return view(context, request) - attr_view.__accept__ = accept - attr_view.__order__ = order - attr_view.__phash__ = phash - attr_view.__view_attr__ = info.options.get('attr') - attr_view.__permission__ = info.options.get('permission') - return attr_view - -attr_wrapped_view.options = ('accept', 'attr', 'permission') - def rendered_view(view, info): # one way or another this wrapper must produce a Response (unless # the renderer is a NullRendererHelper) |