1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
import unittest
import mop
from . import InMemoryDatabase
# in a real implementation, we'd add more functionality to the mop itself to
# allow for calling superclass methods, but that would be complicated enough to
# obscure the implementation and make it not as easy to follow (we would have
# to manage call stacks ourselves), and so we just do this instead for now
def call_method_at_class(c, method_name, invocant, *args, **kwargs):
method = c.all_methods()[method_name]
attr = method.metaclass.all_attributes()["body"]
return attr.value(method)(invocant, *args, **kwargs)
class OverridesTest(unittest.TestCase):
def test_accessor_generation(self):
AccessorsMetaclass = mop.Class(
name="AccessorsMetaclass",
superclass=mop.Class,
)
def add_attribute(self, attr):
name = attr.name()
call_method_at_class(mop.Class, "add_attribute", self, attr)
self.add_method(self.method_class()(
name=name,
body=lambda self: self.metaclass.all_attributes()[name].value(self),
))
AccessorsMetaclass.add_method(AccessorsMetaclass.metaclass.method_class()(
name="add_attribute",
body=add_attribute,
))
AccessorsMetaclass.finalize()
Point = AccessorsMetaclass(
name="Point",
superclass=AccessorsMetaclass.base_object_class(),
)
Point.add_attribute(Point.attribute_class()(name="x", default=0))
Point.add_attribute(Point.attribute_class()(name="y", default=0))
Point.finalize()
point = Point(x=1, y=2)
assert point.x() == 1
assert point.y() == 2
def test_trace_method_calls(self):
methods_called = []
TraceMethod = mop.Class(
name="TraceMethod",
superclass=mop.Method,
)
def execute(self, invocant, args, kwargs):
methods_called.append(self.name())
return call_method_at_class(mop.Method, "execute", self, invocant, args, kwargs)
TraceMethod.add_method(TraceMethod.metaclass.method_class()(
name="execute",
body=execute,
))
TraceMethod.finalize()
TraceClass = mop.Class(
name="TraceClass",
superclass=mop.Class,
)
TraceClass.add_method(TraceClass.metaclass.method_class()(
name="method_class",
body=lambda self: TraceMethod,
))
TraceClass.finalize()
Point = TraceClass(
name="Point",
superclass=TraceClass.base_object_class(),
)
Point.add_attribute(Point.attribute_class()(name="x", default=0))
Point.add_attribute(Point.attribute_class()(name="y", default=0))
Point.add_method(Point.method_class()(
name="x",
body=lambda self: self.metaclass.all_attributes()["x"].value(self)
))
Point.add_method(Point.method_class()(
name="y",
body=lambda self: self.metaclass.all_attributes()["y"].value(self)
))
Point.finalize()
point = Point(x=1, y=2)
assert methods_called == []
assert point.x() == 1
assert methods_called == ['x']
assert point.y() == 2
assert methods_called == ['x', 'y']
def test_db_backed_object(self):
DatabaseAttribute = mop.Class(
name="DatabaseAttribute",
superclass=mop.Attribute,
)
DatabaseAttribute.add_attribute(DatabaseAttribute.attribute_class()(
name="db",
))
DatabaseAttribute.add_method(DatabaseAttribute.method_class()(
name="db",
body=lambda self: self.metaclass.all_attributes()["db"].value(self)
))
def value(self, instance):
key = str(hash(instance)) + ":" + self.name()
return self.db().lookup(key)
DatabaseAttribute.add_method(DatabaseAttribute.method_class()(
name="value",
body=value,
))
def set_value(self, instance, new_value):
key = str(hash(instance)) + ":" + self.name()
self.db().insert(key, new_value)
DatabaseAttribute.add_method(DatabaseAttribute.method_class()(
name="set_value",
body=set_value,
))
DatabaseAttribute.finalize()
DatabaseBackedClass = mop.Class(
name="DatabaseBackedClass",
superclass=mop.Class,
)
DatabaseBackedClass.add_attribute(DatabaseBackedClass.attribute_class()(
name="db",
))
DatabaseBackedClass.add_method(DatabaseBackedClass.method_class()(
name="db",
body=lambda self: self.metaclass.all_attributes()["db"].value(self)
))
def add_attribute(self, attr):
attr.metaclass.all_attributes()["db"].set_value(attr, self.db())
call_method_at_class(mop.Class, "add_attribute", self, attr)
DatabaseBackedClass.add_method(DatabaseBackedClass.method_class()(
name="add_attribute",
body=add_attribute,
))
DatabaseBackedClass.add_method(DatabaseBackedClass.method_class()(
name="attribute_class",
body=lambda self: DatabaseAttribute,
))
DatabaseBackedClass.finalize()
Point = DatabaseBackedClass(
name="Point",
superclass=DatabaseBackedClass.base_object_class(),
db=InMemoryDatabase(),
)
Point.add_attribute(Point.attribute_class()(name="x", default=0))
Point.add_attribute(Point.attribute_class()(name="y", default=0))
Point.add_method(Point.method_class()(
name="x",
body=lambda self: self.metaclass.all_attributes()["x"].value(self)
))
Point.add_method(Point.method_class()(
name="y",
body=lambda self: self.metaclass.all_attributes()["y"].value(self)
))
Point.add_method(Point.method_class()(
name="set_x",
body=lambda self, new_value: self.metaclass.all_attributes()["x"].set_value(self, new_value)
))
Point.finalize()
point = Point(x=3, y=7)
assert point.x() == 3
assert point.y() == 7
assert point.slots == {}
point.set_x(12)
assert point.x() == 12
assert point.y() == 7
assert point.slots == {}
assert len(Point.db().store) == 2
point2 = Point(x=123, y=-5)
assert point.x() == 12
assert point.y() == 7
assert point.slots == {}
assert point2.x() == 123
assert point2.y() == -5
assert point2.slots == {}
assert len(Point.db().store) == 4
|
