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)