def test_ref_parsing():
for input in ['', None, type, 1, 3.0, 'hork bork']:
with pytest.raises(Ref.InvalidRefError):
ref(input)
ref('a').components() == [Ref.Dereference('a')]
ref('.a').components() == [Ref.Dereference('a')]
ref('a.b').components() == [Ref.Dereference('a'), Ref.Dereference('b')]
ref('[a]').components() == [Ref.Index('a')]
ref('[a-]').components() == [Ref.Index('a-')]
ref('[0].a').components() == [Ref.Index('0'), Ref.Dereference('a')]
ref('[0][a]').components() == [Ref.Index('0'), Ref.Index('a')]
for refstr in ('[a]b', '[]', '[[a]', 'b[[[', 'a.1', '1.a', '.[a]', '0'):
with pytest.raises(Ref.InvalidRefError):
ref(refstr)
for refstr in ('a-b', '-b', 'a-'):
with pytest.raises(Ref.InvalidRefError):
ref(refstr)
def provides(self, ref):
assert isinstance(ref, Ref)
if ref in self._table:
return True
targets = [key for key in self._table if Ref.subscope(key, ref)]
if not targets:
return False
else:
for key in sorted(targets, reverse=True):
scope = self._table[key]
if not isinstance(scope, Namable):
continue
subscope = Ref.subscope(key, ref)
# If subscope is empty, then we should've found it in the ref table.
assert not subscope.is_empty()
if scope.provides(subscope):
return True
return False
def _assimilate_dictionary(self, d):
for key, val in d.items():
val = Environment.wrap(val)
rkey = Ref.wrap(key)
if isinstance(val, Environment):
for vkey, vval in val._table.items():
self._table[rkey + vkey] = vval
else:
self._table[rkey] = val
def find(self, ref):
if ref in self._table:
return self._table[ref]
targets = [key for key in self._table if Ref.subscope(key, ref)]
if not targets:
raise Namable.NotFound(self, ref)
else:
for key in sorted(targets, reverse=True):
scope = self._table[key]
if not isinstance(scope, Namable):
continue
subscope = Ref.subscope(key, ref)
# If subscope is empty, then we should've found it in the ref table.
assert not subscope.is_empty()
try:
resolved = scope.find(subscope)
return resolved
except Namable.Error as e:
continue
raise Namable.NotFound(self, ref)
def covers(self, ref):
"""
Does this TypeEnvironment cover the ref?
"""
for binding in self._unbound_types:
if binding.provides(ref):
return True
for bound_name, binding in self._bound_types.items():
scoped_ref = Ref.from_address(bound_name).scoped_to(ref)
if scoped_ref is not None and binding.provides(scoped_ref):
return True
return False
def test_mustache_joining():
oe = Environment(foo="foo herp", bar="bar derp", baz="baz blerp")
joined, unbound = MustacheParser.join(MustacheParser.split("{{foo}}"), oe)
assert joined == "foo herp"
assert unbound == []
splits = MustacheParser.split('blech {{foo}} {{bar}} bonk {{&baz}} bling')
joined, unbound = MustacheParser.join(splits, oe)
assert joined == 'blech foo herp bar derp bonk {{baz}} bling'
assert unbound == []
splits = MustacheParser.split('{{foo}} {{bar}} {{unbound}}')
joined, unbound = MustacheParser.join(splits, oe)
assert joined == 'foo herp bar derp {{unbound}}'
assert unbound == [Ref.from_address('unbound')]
def test_mustache_joining():
oe = Environment(foo = "foo herp",
bar = "bar derp",
baz = "baz blerp")
joined, unbound = MustacheParser.join(MustacheParser.split("{{foo}}"), oe)
assert joined == "foo herp"
assert unbound == []
splits = MustacheParser.split('blech {{foo}} {{bar}} bonk {{&baz}} bling')
joined, unbound = MustacheParser.join(splits, oe)
assert joined == 'blech foo herp bar derp bonk {{baz}} bling'
assert unbound == []
splits = MustacheParser.split('{{foo}} {{bar}} {{unbound}}')
joined, unbound = MustacheParser.join(splits, oe)
assert joined == 'foo herp bar derp {{unbound}}'
assert unbound == [Ref.from_address('unbound')]
def split(string, keep_aliases=False):
splits = MustacheParser._MUSTACHE_RE.split(string)
first_split = splits.pop(0)
outsplits = [first_split] if first_split else []
assert len(splits) % 3 == 0
for k in range(0, len(splits), 3):
if splits[k] == MustacheParser._ADDRESS_DELIMITER:
outsplits.append('{{%s%s}}' % (
MustacheParser._ADDRESS_DELIMITER if keep_aliases else '',
splits[k+1]))
elif splits[k] == None:
outsplits.append(Ref.from_address(splits[k+1]))
else:
raise Exception("Unexpected parsing error in Mustache: splits[%s] = '%s'" % (
k, splits[k]))
if splits[k+2]:
outsplits.append(splits[k+2])
return outsplits
def dtd(d): return dict((Ref.from_address(key), str(val)) for key, val in d.items())
def ref(address): return Ref.from_address(address)
def test_ref_parsing():
for input in ['', None, type, 1, 3.0, 'hork bork']:
with pytest.raises(Ref.InvalidRefError):
ref(input)
ref('a').components() == [Ref.Dereference('a')]
ref('.a').components() == [Ref.Dereference('a')]
ref('a.b').components() == [Ref.Dereference('a'), Ref.Dereference('b')]
ref('[a]').components() == [Ref.Index('a')]
ref('[a-]').components() == [Ref.Index('a-')]
ref('[0].a').components() == [Ref.Index('0'), Ref.Dereference('a')]
ref('[0][a]').components() == [Ref.Index('0'), Ref.Index('a')]
ref('[.]').components() == [Ref.Index('.')]
ref('[/]').components() == [Ref.Index('/')]
ref('[_]').components() == [Ref.Index('_')]
ref('[-]').components() == [Ref.Index('-')]
ref('[a.b]').components() == [Ref.Index('a.b')]
ref('[a/b]').components() == [Ref.Index('a/b')]
ref('[a_b]').components() == [Ref.Index('a_b')]
ref('[a-b]').components() == [Ref.Index('a-b')]
ref('[a/b/c/d]').components() == [Ref.Index('a/b/c/d')]
ref('[2.0.a_c/d-e]').components() == [Ref.Index('2.0.a_c/d-e')]
for refstr in ('[a]b', '[]', '[[a]', 'b[[[', 'a.1', '1.a', '.[a]', '0'):
with pytest.raises(Ref.InvalidRefError):
ref(refstr)
for refstr in ('a-b', '-b', 'a-'):
with pytest.raises(Ref.InvalidRefError):
ref(refstr)
