def __init__(self, identifier, template, args, body, location=None):
super().__init__(location)
self.template = template
self.identifier = Self() if identifier is None else identifier
self.args = []
for n in range(0, len(args)):
arg = args[n]
if isinstance(arg, Argument):
self.args.append(Argument(arg.value, n, location))
else:
self.args.append(Argument(arg, n, location))
self.args.insert(0, Argument(self.identifier, -1))
self.extensions = []
self.body = []
for statement in body:
if isinstance(statement, ExtensionPragma):
for arg in self.args:
ext_args = [
arg.marshal(ext_arg) for ext_arg in statement.args
]
self.extensions.append(
ExtensionPragma(statement.name, ext_args))
else:
self.body.append(statement)
def test_as_triples_simple_triple_with_self(self):
'''
Tests if triples list is not empty when parser call with self.
'''
template = self.parser.parse('t()(x = self)')[0]
expect = [(Identifier(Self()), Identifier(Name('x')), Identifier(Self()))]
self.assertCountEqual(template.as_triples(self.env), expect)
def test_as_triples_multiple_properties(self):
'''
Tests if triples list is not empty when parser call with multiple properties.
'''
template = self.parser.parse('t()(x = y z = 12345)')[0]
expect = [(Identifier(Self()), Identifier(Name('x')), Identifier(Name('y'))),
(Identifier(Self()), Identifier(Name('z')), Value(12345))]
self.assertCountEqual(template.as_triples(self.env), expect)
def test_evaluate_extension_self_name(self):
forms = self.parser.parse('t()(@extension E(self.argument))')
t = forms[0]
self.env.current_self = Name(Self())
t.evaluate(self.env)
found = self.env.lookup_extensions(t.identifier.evaluate(self.env))
expect = [ExtensionPragma('E', [Identifier(Self(), Name('argument'))])]
self.assertCountEqual(found, expect)
def test_as_triples_with_expansion_in_property_with_self_as_name(self):
forms = self.parser.parse('a()(x = 1) b()(y = self.e is a a())')
a = forms[0]
b = forms[1]
a.evaluate(self.env)
expect = [(Identifier(Self(), Name('e')), Identifier(Name('x')).evaluate(self.env), Value(1)),
(Identifier(Self()), Identifier(Name('y')), Identifier(Self(), Name('e')))]
self.assertCountEqual(expect, b.as_triples(self.env))
def test_evaluate_stores_triples(self):
forms = self.parser.parse('t()(x=1 y=2)')
t = forms[0]
with self.assertRaises(KeyError):
self.env.lookup_template(t.identifier.evaluate(self.env))
t.evaluate(self.env)
found = self.env.lookup_template(t.identifier.evaluate(self.env))
expect = [(Identifier(Self()), Identifier(Name('x')).evaluate(self.env), Value(1)),
(Identifier(Self()), Identifier(Name('y')).evaluate(self.env), Value(2))]
self.assertCountEqual(found, expect)
def test_as_triples_with_base(self):
'''
Test for correctness when a base and specialised template are defined
'''
forms = self.parser.parse('a()(x = 1) b()(a() y = 2)')
base = forms[0]
specialised = forms[1]
base.evaluate(self.env)
expect = [(Identifier(Self()), Identifier(Name('x')).evaluate(self.env), Value(1)),
(Identifier(Self()), Identifier(Name('y')), Value(2))]
self.assertCountEqual(specialised.as_triples(self.env), expect)
def test_as_triples_with_base_with_self_named_expansion(self):
forms = self.parser.parse('s()(z=self) t()(x=self.e is a s())')
s = forms[0]
t = forms[1]
s.evaluate(self.env)
e = Identifier(Self(), Name('e'))
expect_s = [(Identifier(Self()), Identifier(Name('z')), Identifier(Self()))]
self.assertCountEqual(expect_s, s.as_triples(self.env))
expect_t = [(e, Identifier(Name('z')).evaluate(self.env), e),
(Identifier(Self()), Identifier(Name('x')), e)]
self.assertCountEqual(expect_t, t.as_triples(self.env))
def test_assignment_self_name(self):
name = Identifier(Self(), Name('v'))
value = Identifier(Name('Name'))
self.assertEqual(Assignment(name, value).evaluate(
self.env), value.evaluate(self.env))
self.assertEqual(name.evaluate(self.env), value.evaluate(self.env))
def test_evaluate_stores_triples_with_expansions(self):
forms = self.parser.parse('a(x)(e=x)' +
'b(y)(p=y)' +
'c()(a(f is a b(1))' +
' q = g is a b(2)' +
' h is a b(3))')
a = forms[0]
b = forms[1]
c = forms[2]
a.evaluate(self.env)
b.evaluate(self.env)
c.evaluate(self.env)
me = Identifier(Self())
env = self.env
f = Identifier(Name('f')).evaluate(env)
g = Identifier(Name('g')).evaluate(env)
h = Identifier(Name('h')).evaluate(env)
found = env.lookup_template(c.identifier.evaluate(env))
expect = [(me, Identifier(Name('e')).evaluate(env), f),
(g, Identifier(Name('p')).evaluate(env), Value(2)),
(me, Identifier(Name('q')).evaluate(env), g),
(h, Identifier(Name('p')).evaluate(env), Value(3))]
self.assertCountEqual(found, expect)
expect = [(f, Identifier(Name('p')).evaluate(env), Value(1))]
self.assertCountEqual(self.env._rdf.triples, expect)
def test_assignment_self_name(self):
script = 'self.v = Name'
expected = [
Assignment(Identifier(Self(), Name('v')), Identifier(Name('Name')))
]
actually = self.parser.parse(script)
self.assertEqual(expected, actually)
def test_bodied_expansion_in_template(self):
forms = self.parser.parse('s()(a = 1)' +
't()(self.e is a s()(b = 2))')
s = forms[0]
t = forms[1]
s.evaluate(self.env)
expect = [(Identifier(Self(), Name('e')),
Identifier(Name('a')).evaluate(self.env),
Value(1)),
(Identifier(Self(), Name('e')),
Identifier(Name('b')),
Value(2))]
self.assertCountEqual(expect, t.as_triples(self.env))
def test_as_triples_multiple_base_args_and_parameters(self):
forms = self.parser.parse('a(x, y)(x = y)' +
'b(x, y)(a(x, "string") z=y)' +
'c(x, y)(b(1, 2) x=y)')
a = forms[0]
b = forms[1]
c = forms[2]
a.evaluate(self.env)
b.evaluate(self.env)
expect = [(Identifier(Self()), Value(1), Value("string")),
(Identifier(Self()), Identifier(Name('z')).evaluate(self.env), Value(2)),
(Identifier(Self()), Identifier(Parameter('x', 0)), Identifier(Parameter('y', 0)))]
self.assertCountEqual(expect, c.as_triples(self.env))
def test_evaluate_stores_triples_of_chained_bases(self):
forms = self.parser.parse('q()(a=4) s()(z=3 q())t()(x=1 y=2 s())')
q = forms[0]
s = forms[1]
t = forms[2]
with self.assertRaises(KeyError):
self.env.lookup_template(t.identifier.evaluate(self.env))
q.evaluate(self.env)
s.evaluate(self.env)
t.evaluate(self.env)
found = self.env.lookup_template(t.identifier.evaluate(self.env))
expect = [(Identifier(Self()), Identifier(Name('x')).evaluate(self.env), Value(1)),
(Identifier(Self()), Identifier(Name('y')).evaluate(self.env), Value(2)),
(Identifier(Self()), Identifier(Name('z')).evaluate(self.env), Value(3)),
(Identifier(Self()), Identifier(Name('a')).evaluate(self.env), Value(4))]
self.assertCountEqual(found, expect)
def test_as_triples_multiple_inheritance(self):
forms = self.parser.parse('s()(a=123)' +
't()(b=456)' +
'u()(s() t())')
s = forms[0]
t = forms[1]
u = forms[2]
s.evaluate(self.env)
t.evaluate(self.env)
expect = [(Identifier(Self()),
Identifier(Name('a')).evaluate(self.env),
Value(123)),
(Identifier(Self()),
Identifier(Name('b')).evaluate(self.env),
Value(456))]
self.assertEqual(expect, u.as_triples(self.env))
def test_as_triples_params(self):
'''
Test for correctness when a template is defined with param and set to property
'''
forms = self.parser.parse('a(x)(property = x)')
a = forms[0]
expect = [(Identifier(Self()), Identifier(Name('property')), Identifier(Parameter('x',0)))]
for index,triple in enumerate(a.as_triples(self.env)):
for tuple_index,element in enumerate(triple):
self.assertEqual(element,expect[index][tuple_index])
self.assertCountEqual(a.as_triples(self.env), expect)
def test_evaluate_stores_triples_with_forward_parameterised_bases(self):
forms = self.parser.parse('q(p)(a=p)' +
's(t)(z=t q(t))' +
't()(x=1 y=2 s("t"))')
q = forms[0]
s = forms[1]
t = forms[2]
with self.assertRaises(KeyError):
self.env.lookup_template(t.identifier.evaluate(self.env))
q.evaluate(self.env)
s.evaluate(self.env)
t.evaluate(self.env)
found = self.env.lookup_template(t.identifier.evaluate(self.env))
expect = [(Identifier(Self()), Identifier(Name('x')).evaluate(self.env), Value(1)),
(Identifier(Self()), Identifier(Name('y')).evaluate(self.env), Value(2)),
(Identifier(Self()), Identifier(Name('z')).evaluate(self.env), Value("t")),
(Identifier(Self()), Identifier(Name('a')).evaluate(self.env), Value("t"))]
self.assertCountEqual(found, expect)
def test_as_triples_with_base_chain(self):
'''
Test for correctness when a base and multiple/chained specialised templates are defined
# Calls Expansion() ??
'''
forms = self.parser.parse('a()(x = 1)' +
'b()(a() y = 2)' +
'c()(b() z = 3)')
a = forms[0]
b = forms[1]
c = forms[2]
a.evaluate(self.env)
b.evaluate(self.env)
expect = [(Identifier(Self()), Identifier(Name('x')).evaluate(self.env), Value(1)),
(Identifier(Self()), Identifier(Name('y')).evaluate(self.env), Value(2)),
(Identifier(Self()), Identifier(Name('z')), Value(3))]
self.assertCountEqual(c.as_triples(self.env), expect)
def test_as_triples_nested_multiple_inheritance(self):
forms = self.parser.parse('s()(a=123)' +
't()(s() b=456)' +
'u()(s() t() c=789)' +
'v()(s() t() u())')
s = forms[0]
t = forms[1]
u = forms[2]
v = forms[3]
s.evaluate(self.env)
t.evaluate(self.env)
u.evaluate(self.env)
a = (Identifier(Self()), Identifier(Name('a')).evaluate(self.env), Value(123))
b = (Identifier(Self()), Identifier(Name('b')).evaluate(self.env), Value(456))
c = (Identifier(Self()), Identifier(Name('c')).evaluate(self.env), Value(789))
expect = [a, a, b, a, a, b, c]
self.assertEqual(expect, v.as_triples(self.env))
def test_as_triples_with_base_with_params(self):
'''
Test for correctness when a template is defined and property is set to value.
'''
forms = self.parser.parse('a(x)(x = 12345) b(y)(a(y))')
a = forms[0]
b = forms[1]
template_name = a.identifier.evaluate(self.env)
self.env.assign_template(template_name, a.as_triples(self.env))
expect = [(Identifier(Self()), Identifier(Parameter('y', 0)), Value(12345))]
self.assertCountEqual(expect, b.as_triples(self.env))
def test_as_triples_with_base_with_args(self):
'''
Test for correctness when a template is defined and property is set to value.
And specialised template contains arg
'''
forms = self.parser.parse('a(x)(x = 12345) b()(a(12345))')
a = forms[0]
b = forms[1]
a.evaluate(self.env)
expect = [(Identifier(Self()), Value(12345), Value(12345))]
self.assertCountEqual(expect, b.as_triples(self.env))
def test_as_triples_expansion(self):
forms = self.parser.parse('t()(x=1) e is a t()')
t = forms[0]
e = forms[1]
p = Property(Identifier(Name('y')), e)
t.evaluate(self.env)
expected = [(Identifier(Name('e')),
Identifier(Name('x')).evaluate(self.env), Value(1)),
(Identifier(Self()), Identifier(Name('y')),
Identifier(Name('e')))]
actually = p.as_triples(self.env)
self.assertEqual(expected, actually)
def test_evaluate_stores_triples_with_unevaluated_parameters(self):
forms = self.parser.parse('q(p)(a=p)' +
's(u,v)(z=u q(v))' +
't(a,b)(x=1 y=2 s(a,b))')
q = forms[0]
s = forms[1]
t = forms[2]
with self.assertRaises(KeyError):
self.env.lookup_template(t.identifier.evaluate(self.env))
q.evaluate(self.env)
s.evaluate(self.env)
t.evaluate(self.env)
a = Identifier(Parameter('a', 0))
b = Identifier(Parameter('b', 1))
found = self.env.lookup_template(t.identifier.evaluate(self.env))
expect = [(Identifier(Self()), Identifier(Name('x')).evaluate(self.env), Value(1)),
(Identifier(Self()), Identifier(Name('y')).evaluate(self.env), Value(2)),
(Identifier(Self()), Identifier(Name('z')).evaluate(self.env), a),
(Identifier(Self()), Identifier(Name('a')).evaluate(self.env), b)]
self.assertCountEqual(found, expect)
def test_as_triples_with_expansion_as_argument(self):
forms = self.parser.parse('r()(y=1) s(exp)(x=exp)' +
't()(s(e is a r()))')
r = forms[0]
s = forms[1]
t = forms[2]
r.evaluate(self.env)
s.evaluate(self.env)
e = self.parser.parse('e is a r()')[0]
expect = [(Identifier(Self()), Identifier(Name('x')).evaluate(self.env), e)]
self.assertCountEqual(expect, t.as_triples(self.env))
def test_evaluate_stores_triples_with_expansion_as_property(self):
forms = self.parser.parse('a(x)(p=x)' +
'b()(q = e is a a(2))')
a = forms[0]
b = forms[1]
a.evaluate(self.env)
b.evaluate(self.env)
env = self.env
me = Identifier(Self())
found = env.lookup_template(b.identifier.evaluate(env))
expect = [(Identifier(Name('e')).evaluate(env), Identifier(Name('p')).evaluate(env), Value(2)),
(me, Identifier(Name('q')).evaluate(env), Identifier(Name('e')).evaluate(env))]
self.assertCountEqual(found, expect)
def test_evaluate_stores_triples_with_expansion_in_argument(self):
forms = self.parser.parse('a(x)(p=x)' +
'b(x)(e=x)' +
'c()(b(f is a a(2)))')
a = forms[0]
b = forms[1]
c = forms[2]
a.evaluate(self.env)
b.evaluate(self.env)
c.evaluate(self.env)
env = self.env
me = Identifier(Self())
found = env.lookup_template(c.identifier.evaluate(env))
expect = [(me, Identifier(Name('e')).evaluate(env), Identifier(Name('f')).evaluate(env))]
self.assertCountEqual(found, expect)
expect = [(Identifier(Name('f')).evaluate(env), Identifier(Name('p')).evaluate(env), Value(2))]
self.assertCountEqual(self.env._rdf.triples, expect)
class Expansion(Node):
def __init__(self, identifier, template, args, body, location=None):
super().__init__(location)
self.template = template
self.identifier = Self() if identifier is None else identifier
self.args = []
for n in range(0, len(args)):
arg = args[n]
if isinstance(arg, Argument):
self.args.append(Argument(arg.value, n, location))
else:
self.args.append(Argument(arg, n, location))
self.args.insert(0, Argument(self.identifier, -1))
self.extensions = []
self.body = []
for statement in body:
if isinstance(statement, ExtensionPragma):
for arg in self.args:
ext_args = [
arg.marshal(ext_arg) for ext_arg in statement.args
]
self.extensions.append(
ExtensionPragma(statement.name, ext_args))
else:
self.body.append(statement)
def __eq__(self, other):
return (isinstance(other, Expansion)
and self.template == other.template
and self.identifier == other.identifier
and self.args == other.args and self.body == other.body)
def __repr__(self):
return format("%s is a %s(%s)\n (%s)\n" %
(self.identifier, self.template, self.args, self.body))
def get_extensions(self, context):
template_uri = self.template.evaluate(context)
raw_extensions = context.lookup_extensions(template_uri)
processed_extensions = []
for ext in raw_extensions:
ext_args = ext.args
for arg in self.args:
ext_args = [arg.marshal(ext_arg) for ext_arg in ext_args]
processed_extensions += [ExtensionPragma(ext.name, ext_args)]
return processed_extensions + self.extensions
def as_triples(self, context):
triples = []
template_uri = self.template.evaluate(context)
try:
triples = context.lookup_template(template_uri)
except KeyError:
raise TemplateNotFound(template_uri, self.template.location)
for statement in self.body:
triples += statement.as_triples(context)
def argument_marshal(triple):
result = triple
for argument in self.args:
result = tuple([argument.marshal(x) for x in result])
return result
triples = [argument_marshal(triple) for triple in triples]
return triples
def evaluate(self, context):
identifier = self.identifier.evaluate(context)
evaluated_args = []
for arg in self.args:
evaluated_arg = Argument(arg.value.evaluate(context), arg.position)
evaluated_args.append(evaluated_arg)
triples = self.as_triples(context)
def evaluate_triple(triple):
return tuple([x.evaluate(context) for x in triple])
triples = [evaluate_triple(triple) for triple in triples]
for ext in self.get_extensions(context):
triples = ext.run(context, triples)
context.add_triples(triples)
return identifier
def num_expected_arguments(self, context):
template_uri = self.template.evaluate(context)
try:
triples = context.lookup_template(template_uri)
except KeyError:
raise TemplateNotFound(template_uri, self.template.location)
def get_top_parameter_in_identifier(identifier):
top_index = 0
for part in identifier.parts:
print(part)
if isinstance(part, Parameter) and part.position > top_index:
top_index = part.position
return top_index
num = 0
for triple in triples:
try:
num = max(
num, *[get_top_parameter_in_identifier(x) for x in triple])
except AttributeError:
pass
return num
def test_as_triples_self_in_name(self):
p = Property(Identifier(Self()), Value(1))
expected = [(Identifier(Self()), Identifier(Self()), Value(1))]
actually = p.as_triples(self.env)
self.assertEqual(expected, actually)
def test_as_triples_simple(self):
p = Property(Identifier(Name('x')), Identifier(Name('y')))
expected = [(Identifier(Self()), Identifier(Name('x')),
Identifier(Name('y')))]
actually = p.as_triples(self.env)
self.assertEqual(expected, actually)
def test_name_self_as_suffix(self):
script = 'p.self'
expected = [Identifier(Name('p'), Self())]
actually = self.parser.parse(script)
self.assertCountEqual(expected, actually)
