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).
