def testTrivialities(self): [dispatch.on('x')] def f1(x,*y,**z): "foo bar" [dispatch.on('x')] def f2(x,*y,**z): "baz spam" for f,doc in (f1,"foo bar"),(f2,"baz spam"): self.assertEqual(f.__doc__, doc) # Empty generic should raise NoApplicableMethods self.assertRaises(dispatch.NoApplicableMethods, f, 1, 2, 3) self.assertRaises(dispatch.NoApplicableMethods, f, "x", y="z") # Must have at least one argument to do dispatching self.assertRaises(TypeError, f) self.assertRaises(TypeError, f, foo="bar")
def testAdaptedDefinition(self): class Classic: pass class IFoo(protocols.Interface): pass class A(protocols.Adapter): protocols.advise(instancesProvide=[IFoo], asAdapterForTypes=[Classic]) [dispatch.on('xx')] def g(xx, *y, **z): pass [g.when(IFoo)] def g(thing, *args, **kw): return thing c = Classic() it = g(c) self.assertNotEqual(it, c) self.failUnless(IFoo(it) is it)
def testTrivialities(self): [dispatch.on('x')] def f1(x, *y, **z): "foo bar" [dispatch.on('x')] def f2(x, *y, **z): "baz spam" for f, doc in (f1, "foo bar"), (f2, "baz spam"): self.assertEqual(f.__doc__, doc) # Empty generic should raise NoApplicableMethods self.assertRaises(dispatch.NoApplicableMethods, f, 1, 2, 3) self.assertRaises(dispatch.NoApplicableMethods, f, "x", y="z") # Must have at least one argument to do dispatching self.assertRaises(TypeError, f) self.assertRaises(TypeError, f, foo="bar")
class X: [dispatch.on('v')] def s(x, v): """X""" [s.when(LandVehicle)] def bar(x, v): return "land" [s.when(WaterVehicle)] def s(x, v): return "water"
def testAltArg(self): [dispatch.on('v')] def s(x,v): """X""" [s.when(LandVehicle)] def bar(x,v): return "land" [s.when(WaterVehicle)] def s(x,v): return "water" self.assertEqual(s(None,LandVehicle()),"land") self.assertEqual(s(None,v=WaterVehicle()),"water")
def testAdaptedDefinition(self): class Classic: pass class IFoo(protocols.Interface): pass class A(protocols.Adapter): protocols.advise( instancesProvide=[IFoo],asAdapterForTypes=[Classic] ) [dispatch.on('xx')] def g(xx,*y,**z): pass [g.when(IFoo)] def g(thing, *args,**kw): return thing c=Classic(); it = g(c) self.assertNotEqual(it, c) self.failUnless(IFoo(it) is it)
def testAltArg(self): [dispatch.on('v')] def s(x, v): """X""" [s.when(LandVehicle)] def bar(x, v): return "land" [s.when(WaterVehicle)] def s(x, v): return "water" self.assertEqual(s(None, LandVehicle()), "land") self.assertEqual(s(None, v=WaterVehicle()), "water")
def testWhenMethods(self): m = GenericFunction(lambda v: None) m.when(Signature(v=LandVehicle)) def foo(v): return "land" import types self.failUnless(isinstance(m, GenericFunction)) self.failUnless(isinstance(foo, types.FunctionType)) m.when(Signature(v=WaterVehicle)) def m(v): return "water" self.failUnless(isinstance(m, types.FunctionType)) self.assertEqual(m(LandVehicle()), "land") self.assertEqual(m(WaterVehicle()), "water") [dispatch.on('v')] def s(v): """Blah""" [s.when(LandVehicle)] def bar(v): return "land" self.failUnless(hasattr(s, 'when')) self.failUnless(isinstance(bar, types.FunctionType)) [s.when(WaterVehicle)] def s(v): return "water" self.failUnless(hasattr(s, 'when')) self.assertEqual(s(LandVehicle()), "land") self.assertEqual(s(WaterVehicle()), "water")
def testSimpleDefinitions(self): [dispatch.on('xx')] def g(xx,*y,**z): pass class Classic: pass class NewStyle(object): pass class IFoo(protocols.Interface): pass class Impl: protocols.advise(instancesProvide=[IFoo]) c=Classic() n=NewStyle() i=Impl() for item in c,n,i,1,"blue",TestCase: self.assertRaises(dispatch.NoApplicableMethods, g, item) g.addMethod(Classic,lambda *args,**kw: ("classic!",args,kw)) g.addMethod(NewStyle,lambda *args,**kw: ("new!",args,kw)) g.addMethod(IFoo,lambda *args,**kw: ("foo!",args,kw)) self.assertEqual(g(c,"foo"), ("classic!",(c,"foo",),{})) self.assertEqual(g(n,foo="bar"), ("new!",(n,),{'foo':'bar'})) self.assertEqual(g(i,"foo",x="y"), ("foo!",(i,"foo",),{"x":"y"})) for item in 1,"blue",TestCase: self.assertRaises(dispatch.NoApplicableMethods, g, item)
def testMultiDefinition(self): class Classic: pass class NewStyle(object): pass class IFoo(protocols.Interface): pass class Impl: protocols.advise(instancesProvide=[IFoo]) c = Classic() n = NewStyle() i = Impl() [dispatch.on('xx')] def g(xx, q=27, *y, **z): pass [g.when([Classic, NewStyle, IFoo])] def g(*args, **kw): return ("yes!", args, kw) self.assertEqual(g(c, "foo"), ("yes!", ( c, "foo", ), {})) self.assertEqual(g(n, foo="bar"), ("yes!", (n, 27), {'foo': 'bar'})) self.assertEqual(g(i, "foo", x="y"), ("yes!", ( i, "foo", ), { "x": "y" })) for item in 1, "blue", TestCase: self.assertRaises(dispatch.NoApplicableMethods, g, item)
def testSimpleDefinitions(self): [dispatch.on('xx')] def g(xx, *y, **z): pass class Classic: pass class NewStyle(object): pass class IFoo(protocols.Interface): pass class Impl: protocols.advise(instancesProvide=[IFoo]) c = Classic() n = NewStyle() i = Impl() for item in c, n, i, 1, "blue", TestCase: self.assertRaises(dispatch.NoApplicableMethods, g, item) g.addMethod(Classic, lambda *args, **kw: ("classic!", args, kw)) g.addMethod(NewStyle, lambda *args, **kw: ("new!", args, kw)) g.addMethod(IFoo, lambda *args, **kw: ("foo!", args, kw)) self.assertEqual(g(c, "foo"), ("classic!", ( c, "foo", ), {})) self.assertEqual(g(n, foo="bar"), ("new!", (n, ), {'foo': 'bar'})) self.assertEqual(g(i, "foo", x="y"), ("foo!", ( i, "foo", ), { "x": "y" })) for item in 1, "blue", TestCase: self.assertRaises(dispatch.NoApplicableMethods, g, item)
def testMultiDefinition(self): class Classic: pass class NewStyle(object): pass class IFoo(protocols.Interface): pass class Impl: protocols.advise(instancesProvide=[IFoo]) c=Classic() n=NewStyle() i=Impl() [dispatch.on('xx')] def g(xx,q=27,*y,**z): pass [g.when([Classic,NewStyle,IFoo])] def g(*args,**kw): return ("yes!",args,kw) self.assertEqual(g(c,"foo"), ("yes!",(c,"foo",),{})) self.assertEqual(g(n,foo="bar"), ("yes!",(n,27),{'foo':'bar'})) self.assertEqual(g(i,"foo",x="y"), ("yes!",(i,"foo",),{"x":"y"})) for item in 1,"blue",TestCase: self.assertRaises(dispatch.NoApplicableMethods, g, item)
def testWhenMethods(self): m = GenericFunction(lambda v:None) m.when(Signature(v=LandVehicle)) def foo(v): return "land" import types self.failUnless(isinstance(m,GenericFunction)) self.failUnless(isinstance(foo,types.FunctionType)) m.when(Signature(v=WaterVehicle)) def m(v): return "water" self.failUnless(isinstance(m,types.FunctionType)) self.assertEqual(m(LandVehicle()),"land") self.assertEqual(m(WaterVehicle()),"water") [dispatch.on('v')] def s(v): """Blah""" [s.when(LandVehicle)] def bar(v): return "land" self.failUnless(hasattr(s,'when')) self.failUnless(isinstance(bar,types.FunctionType)) [s.when(WaterVehicle)] def s(v): return "water" self.failUnless(hasattr(s,'when')) self.assertEqual(s(LandVehicle()),"land") self.assertEqual(s(WaterVehicle()),"water")
# Bootstrap SimpleGeneric declaration helper function -- itself a SimpleGeneric [dispatch.on('ob')] def declarePredicate(ob,proto,factory): """Declare a SimpleGeneric dispatch predicate""" declarePredicate = _mkGeneric(declarePredicate,'ob') proto = declarePredicate.protocol def declareForType(typ,proto,factory): protocols.declareAdapter(factory,provides=[proto],forTypes=[typ]) def declareForProto(pro,proto,factory): protocols.declareAdapter(factory,provides=[proto],forProtocols=[pro]) def declareForSequence(seq,proto,factory): for item in seq: declarePredicate(item,proto,factory)
def compileIn(expr, criterion, truth): """Return a signature or predicate (or None) for 'expr in criterion'""" try: iter(criterion) except TypeError: return applyCriterion(expr, criterion, truth) if truth: return or_criteria(expr, [Inequality('==', v) for v in criterion]) else: return and_criteria(expr, [Inequality('<>', v) for v in criterion]) [dispatch.on('criterion')] def applyCriterion(expr, criterion, truth): """Apply 'criterion' to 'expr' (ala 'expr in criterion') -> sig or pred""" [applyCriterion.when(ICriterion)] def applyICriterion(expr, criterion, truth): if not truth: criterion = ~criterion return Signature([(expr, criterion)])
protocols.declareAdapter(protocols.NO_ADAPTER_NEEDED, [f.protocol], forProtocols=[protocol]) return f func.addMethod = addMethod func.when = when func.clone = clone func.protocol = protocol func.__doc__ = oldfunc.__doc__ protocols.adviseObject(func, provides=[IExtensibleFunction]) return func # Bootstrap SimpleGeneric declaration helper function -- itself a SimpleGeneric [dispatch.on('ob')] def declarePredicate(ob, proto, factory): """Declare a SimpleGeneric dispatch predicate""" declarePredicate = _mkGeneric(declarePredicate, 'ob') proto = declarePredicate.protocol def declareForType(typ, proto, factory): protocols.declareAdapter(factory, provides=[proto], forTypes=[typ]) def declareForProto(pro, proto, factory):
def compileIn(expr,criterion,truth): """Return a signature or predicate (or None) for 'expr in criterion'""" try: iter(criterion) except TypeError: return applyCriterion(expr,criterion,truth) if truth: return or_criteria(expr,[Inequality('==',v) for v in criterion]) else: return and_criteria(expr,[Inequality('<>',v) for v in criterion]) [dispatch.on('criterion')] def applyCriterion(expr,criterion,truth): """Apply 'criterion' to 'expr' (ala 'expr in criterion') -> sig or pred""" [applyCriterion.when(ICriterion)] def applyICriterion(expr,criterion,truth): if not truth: criterion = ~criterion return Signature([(expr,criterion)]) [applyCriterion.when(object)] def applyDefault(expr,criterion,truth): return None # no special application possible
an iterable of name/value pairs (such as a dictionary's 'items()' or 'iteritems()'). For each name, if it is a valid attribute of the object's class, then the attribute will be set with 'setattr(ob,name,value)'. If the name does not exist as an attribute of the object's class, a 'TypeError' will be raised, identifying the incorrect name/constructor keyword. """ klass = ob.__class__ for k, v in attrItems: if hasattr(klass, k): setattr(ob, k, v) else: raise TypeError("%s constructor has no keyword argument %s" % (klass, k)) [dispatch.on('metadata')] def declareClassMetadata(classobj, metadata): """Declare 'metadata' about 'classobj' This generic function is used to dispatch metadata declarations. You do not normally call it directly, unless implementing a metadata API or special class advisor. Instead, you add methods to it, in order to support a new metadata type you've defined. Note that it's up to your methods to define the semantics, such as where the metadata will be stored. The only predefined semantics are for metadata of 'None' (which is a no-op), and 'protocols.IBasicSequence' types (which recursively invokes 'declareClassMetadata()' on the sequence's contents).