aridity 92__tar.gz → 94__tar.gz

{aridity-92 → aridity-94}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aridity
-Version: 92
+Version: 94
 Summary: DRY config and template system, easily extensible with Python
 Home-page: https://pypi.org/project/aridity/
 Author: foyono
@@ -35,7 +35,7 @@ Process the given template to stdout using config from stdin.
 #### ConfigCtrl Objects
 
 ```python
-class ConfigCtrl()
+class ConfigCtrl(Forkable)
 ```
 
 High level scope API.
@@ -191,6 +191,17 @@ def plusequals(prefix, suffix, scope)
 
 Assign expression to prefix plus an opaque key, i.e. add to list.
 
+<a id="aridity.directives.commaequals"></a>
+
+###### commaequals
+
+```python
+@prime
+def commaequals(prefix, suffix, scope)
+```
+
+Split expression on whitespace and make a list out of the parts.
+
 <a id="aridity.functions"></a>
 
 ### aridity.functions
@@ -461,20 +472,20 @@ Attempt to wrap the given value in a model object of the most specific type.
 
 ### aridity.scope
 
-<a id="aridity.scope.AbstractScope"></a>
+<a id="aridity.scope.Scope"></a>
 
-#### AbstractScope Objects
+#### Scope Objects
 
 ```python
-class AbstractScope(Resolvable)
+class Scope(Resolvable)
 ```
 
-<a id="aridity.scope.AbstractScope.resolved"></a>
+<a id="aridity.scope.Scope.resolved"></a>
 
 ###### resolved
 
 ```python
-def resolved(*path, **kwargs)
+def resolved(*path)
 ```
 
 Follow the given path to get an expression, evaluate it (resolving any paths it requires, recursively), and return the resulting model object.

{aridity-92 → aridity-94}/README.md

@@ -25,7 +25,7 @@ Process the given template to stdout using config from stdin.
 #### ConfigCtrl Objects
 
 ```python
-class ConfigCtrl()
+class ConfigCtrl(Forkable)
 ```
 
 High level scope API.
@@ -181,6 +181,17 @@ def plusequals(prefix, suffix, scope)
 
 Assign expression to prefix plus an opaque key, i.e. add to list.
 
+<a id="aridity.directives.commaequals"></a>
+
+###### commaequals
+
+```python
+@prime
+def commaequals(prefix, suffix, scope)
+```
+
+Split expression on whitespace and make a list out of the parts.
+
 <a id="aridity.functions"></a>
 
 ### aridity.functions
@@ -451,20 +462,20 @@ Attempt to wrap the given value in a model object of the most specific type.
 
 ### aridity.scope
 
-<a id="aridity.scope.AbstractScope"></a>
+<a id="aridity.scope.Scope"></a>
 
-#### AbstractScope Objects
+#### Scope Objects
 
 ```python
-class AbstractScope(Resolvable)
+class Scope(Resolvable)
 ```
 
-<a id="aridity.scope.AbstractScope.resolved"></a>
+<a id="aridity.scope.Scope.resolved"></a>
 
 ###### resolved
 
 ```python
-def resolved(*path, **kwargs)
+def resolved(*path)
 ```
 
 Follow the given path to get an expression, evaluate it (resolving any paths it requires, recursively), and return the resulting model object.

{aridity-92 → aridity-94}/aridity/__init__.py

@@ -1,6 +1,6 @@
 'Interactive REPL.'
 from .repl import CommandReader
-from .scope import Scope
+from .scope import StaticScope
 from .util import NoSuchPathException
 from traceback import print_exc
 import sys
@@ -8,7 +8,7 @@ import sys
 assert NoSuchPathException
 
 def main():
-    scope = Scope()
+    scope = StaticScope.createchild()
     for command in CommandReader(sys.stdin):
         try:
             scope.execute(command)

{aridity-92 → aridity-94}/aridity/arid_config.py

@@ -1,7 +1,8 @@
 'Print given config (with optional path in config) as shell snippet.'
+from .functions import OpaqueKey
 from .model import Boolean, Entry, Locator, Number, Text
-from .scope import Scope
-import os, sys
+from .scope import Scope, StaticScope
+import os, shlex, sys
 
 def _configpath(configname):
     if os.sep in configname:
@@ -12,20 +13,24 @@ def _configpath(configname):
             return path
     raise Exception(f"Not found: {configname}")
 
+def _bashforeval(scope):
+    return ''.join(f"{name}={obj.tobash()}\n" for name, obj in scope.resolveditems())
+
 def _scopetobash(self, toplevel = False):
     if toplevel:
-        return ''.join(f"{name}={obj.resolve(self).tobash()}\n" for name, obj in self.resolvables.items())
-    if self.islist:
-        return f"({' '.join(x.resolve(self).tobash() for _, x in self.resolvables.items())})"
-    return Text(self.tobash(True)).tobash()
+        return _bashforeval(self)
+    d = dict(self.resolveditems())
+    if all(map(OpaqueKey.isopaque, d)):
+        return f"({' '.join(x.tobash() for x in d.values())})"
+    return shlex.quote(_bashforeval(self))
 
 Scope.tobash = _scopetobash
 Boolean.tobash = lambda self, toplevel: 'true' if self.booleanvalue else 'false'
 Number.tobash = lambda self: str(self.numbervalue)
-Text.tobash = lambda self: "'{}'".format(self.textvalue.replace("'", r"'\''"))
+Text.tobash = lambda self: shlex.quote(self.textvalue)
 
 def main():
-    scope = Scope()
+    scope = StaticScope.createchild()
     Locator(_configpath(sys.argv[1])).source(scope, Entry([]))
     sys.stdout.write(scope.resolved(*sys.argv[2:]).tobash(True))
 

{aridity-92 → aridity-94}/aridity/config.py

@@ -1,8 +1,8 @@
 from .functions import OpaqueKey
 from .model import Entry, Locator, Resource, Stream, Text, wrap
-from .scope import Scope
+from .scope import StaticScope
 from .search import resolvedscopeornone
-from .util import dotpy, NoSuchPathException, qualname, selectentrypoints, solo
+from .util import dotpy, Forkable, NoSuchPathException, qualname, selectentrypoints, solo
 from io import StringIO
 from parabject import Parabject, register
 from pathlib import Path
@@ -31,16 +31,12 @@ def _processmainfunction(mainfunction):
 def _wrappathorstream(pathorstream):
     return (Stream if getattr(pathorstream, 'readable', lambda: False)() else Locator)(pathorstream)
 
-class ConfigCtrl:
+class ConfigCtrl(Forkable):
     'High level scope API.'
 
     if 'HOME' in os.environ:
         settingsopenable = Locator(Path.home() / '.settings.arid')
 
-    @classmethod
-    def _of(cls, *args, **kwargs):
-        return cls(*args, **kwargs)
-
     @property
     def node(self):
         return register(self, Config)
@@ -56,7 +52,7 @@ class ConfigCtrl:
         return register(self, WConfig)
 
     def __init__(self, basescope = None, prefix = None):
-        self.basescope = Scope() if basescope is None else basescope
+        self.basescope = StaticScope.createchild() if basescope is None else basescope
         self.prefix = [] if prefix is None else prefix
 
     def loadappconfig(self, mainfunction, moduleresource, encoding = 'ascii', settingsoptional = False):

{aridity-92 → aridity-94}/aridity/directives.py

@@ -30,7 +30,7 @@ def source(prefix, suffix, scope):
     # XXX: Use full algo to get phrasescope?
     def rootscopes():
         for s in chain.from_iterable(phrasescope.scopedepths()):
-            if [staticscope] == s.parents:
+            if [staticscope] == s.parents: # XXX: Slow?
                 yield s
     staticscope = scope.staticscope()
     phrasescope = scope
@@ -74,8 +74,16 @@ def colonequals(prefix, suffix, scope):
 def plusequals(prefix, suffix, scope):
     'Assign expression to prefix plus an opaque key, i.e. add to list.'
     from .functions import OpaqueKey
-    phrase = suffix.tophrase()
-    scope[prefix.topath(scope) + (OpaqueKey(),)] = phrase
+    scope[prefix.topath(scope) + (OpaqueKey(),)] = suffix.tophrase()
+
+@prime
+def commaequals(prefix, suffix, scope):
+    'Split expression on whitespace and make a list out of the parts.'
+    from .functions import OpaqueKey
+    basepath = prefix.topath(scope)
+    scope.getorcreatesubscope(basepath)
+    for r in suffix.words():
+        scope[basepath + (OpaqueKey(),)] = r
 
 @prime
 def _cat(prefix, suffix, scope):
@@ -92,4 +100,5 @@ def coredirectives():
     yield '=', equals
     yield ':=', colonequals
     yield '+=', plusequals
+    yield ',=', commaequals
     yield '<', _cat

{aridity-92 → aridity-94}/aridity/functions.py

@@ -103,7 +103,7 @@ def map_(scope, objsresolvable, *args):
         kname, vname, resolvable = args
         kname = kname.resolve(scope).textvalue
         vname = vname.resolve(scope).textvalue
-    result = Scope(islist = True) # XXX: Really no parent?
+    result = Scope([])
     for k, v in objs.resolveditems():
         result.resolvables.put(k, resolvable.resolve(context(k, v)))
     return result
@@ -116,9 +116,9 @@ def map1(scope, contextresolvable, resultresolvable):
 
 def _flat(scope, listsresolvable):
     from .scope import Scope
-    s = Scope(islist = True) # XXX: Really no parent?
-    for lk, l in listsresolvable.resolve(scope).resolvables.items():
-        for ok, obj in l.resolvables.items():
+    s = Scope([])
+    for lk, l in listsresolvable.resolve(scope).resolveditems():
+        for ok, obj in l.resolveditems():
             s.resolvables.put((lk, ok), obj)
     return s
 
@@ -129,16 +129,13 @@ def join(scope, partsresolvable, sepresolvable = None):
     'Concatenate the given list, using optional separator. Frequently used with `map`.'
     return Join(scope, partsresolvable).execute(sepresolvable)
 
-def _aslist(scope, *resolvables):
-    return scope.resolved(*(r.resolve(scope).textvalue for r in resolvables), **{'aslist': True})
-
 def str_(scope, resolvable):
     'Coerce to string.'
     return resolvable.resolve(scope).totext()
 
 def list_(scope, *resolvables):
     'Create a list.'
-    v = scope.createchild(islist = True)
+    v = scope.createchild()
     for r in resolvables:
         v[OpaqueKey(),] = r
     return v
@@ -250,8 +247,8 @@ class Join:
                         break
         return resobj
 
-def getimpl(scope, *resolvables, **kwargs):
-    return scope.resolved(*(r.resolve(scope).textvalue for r in resolvables), **kwargs)
+def getimpl(scope, *resolvables):
+    return scope.resolved(*(r.resolve(scope).textvalue for r in resolvables))
 
 def corefunctions():
     yield 'gpg', gpg
@@ -272,7 +269,6 @@ def corefunctions():
     yield 'flat', _flat
     yield 'label', _label
     yield 'join', join
-    yield ',', _aslist # XXX: Really comma?
     yield 'str', str_
     yield 'list', list_
     yield 'fork', _fork

{aridity-92 → aridity-94}/aridity/model.py

@@ -1,4 +1,4 @@
-from .util import dotpy
+from .util import dotpy, Forkable
 from contextlib import contextmanager
 from importlib import import_module
 from importlib.resources import files
@@ -37,8 +37,8 @@ class Resolvable(Struct):
 
 class Resolved(Resolvable):
 
-    def resolve(self, scope, aslist = False):
-        return List([self]) if aslist else self
+    def resolve(self, scope):
+        return self
 
 nullmonitor = lambda text: None
 
@@ -80,9 +80,7 @@ class Concat(Resolvable): # TODO: Ban in path components.
         self.parts = parts
         self.monitor = monitor
 
-    def resolve(self, scope, aslist = False):
-        if aslist:
-            return List([part.resolve(scope) for part in self.parts if not part.ignorable])
+    def resolve(self, scope):
         result = Indeterminate
         negbuffer = NegBuffer()
         for part in self.parts:
@@ -111,7 +109,7 @@ class BaseSimpleValue(Resolved):
         value, = t
         return cls(value)
 
-    def unravel(self):
+    def unravel(self, listmode = None):
         return self.scalar
 
 class Blank(BaseSimpleValue):
@@ -156,16 +154,12 @@ class Scalar(BaseScalar):
     def __init__(self, scalar):
         self.scalar = scalar
 
-class Text(BaseScalar):
+class Text(BaseScalar, Forkable):
 
     @classmethod
     def joinpa(cls, s, l, t):
         return cls(''.join(t))
 
-    @classmethod
-    def _of(cls, textvalue):
-        return cls(textvalue)
-
     @property
     def scalar(self):
         return self.textvalue
@@ -245,11 +239,7 @@ class Openable:
         with self.pushopen(scope) as f:
             return Stream(f).processtemplate(scope)
 
-class Locator(Resolved, Openable):
-
-    @classmethod
-    def _of(cls, pathvalue):
-        return cls(pathvalue)
+class Locator(Resolved, Openable, Forkable):
 
     @property
     def scalar(self):
@@ -267,11 +257,7 @@ class Locator(Resolved, Openable):
     def modulenameornone(self):
         pass
 
-class Resource(Resolved, Openable):
-
-    @classmethod
-    def _of(cls, *args):
-        return cls(*args)
+class Resource(Resolved, Openable, Forkable):
 
     def __init__(self, package_or_requirement, resource_name, encoding = 'ascii'):
         self.package_or_requirement = package_or_requirement
@@ -304,11 +290,7 @@ class Resource(Resolved, Openable):
         if self.resource_name.endswith(dotpy):
             return f"{self._packagename()}.{self.resource_name[:-len(dotpy)].replace('/', '.')}"
 
-class Binary(BaseScalar):
-
-    @classmethod
-    def _of(cls, *args):
-        return cls(*args)
+class Binary(BaseScalar, Forkable):
 
     @property
     def scalar(self):
@@ -375,9 +357,8 @@ class Call(Resolvable):
             if not a.ignorable:
                 yield a
 
-    def resolve(self, scope, aslist = False):
-        result = self._functionvalue(scope)(scope.getresolvecontext(), *self._resolvables())
-        return List([result]) if aslist else result
+    def resolve(self, scope):
+        return self._functionvalue(scope)(scope.getresolvecontext(), *self._resolvables())
 
     def resolvemulti(self, j, scope):
         f = self._functionvalue(scope.getresolvecontext())
@@ -388,13 +369,6 @@ class Call(Resolvable):
             for k, o in resolvable.resolve(scope).resolveditems():
                 yield (j, k), o
 
-def List(objs):
-    from .scope import Scope
-    s = Scope(islist = True)
-    for obj in objs:
-        s.resolvables.put(object(), obj) # XXX: Not OpaqueKey?
-    return s
-
 class Directive(Resolved):
 
     @property
@@ -438,25 +412,18 @@ class Stream(Resolved):
         with scope.staticscope().indent.push() as monitor:
             return templateparser(monitor)(self.streamvalue.read()).resolve(scope)
 
-class Entry(Struct):
+class Entry(Struct, Forkable):
 
     @classmethod
     def pa(cls, s, l, t):
         return cls(t.asList())
 
-    @classmethod
-    def _of(cls, *args):
-        return cls(*args)
-
     def __init__(self, resolvables):
         self.resolvables = resolvables
 
     def size(self):
         return sum(1 for r in self.resolvables if not r.ignorable)
 
-    def resolve(self):
-        return List([r.resolve(None) for r in self.resolvables])
-
     def word(self, i):
         word, = islice((r for r in self.resolvables if not r.ignorable), i, i + 1)
         return word

{aridity-92 → aridity-94}/aridity/resolve.py

@@ -1,6 +1,5 @@
 from .search import Query
-from .util import CycleException, NoSuchPathException, TreeNoSuchPathException
-from itertools import chain
+from .util import CycleException, Forkable, NoSuchPathException, TreeNoSuchPathException
 
 class BaseResolveContext:
 
@@ -16,8 +15,8 @@ class BaseResolveContext:
     def resolvables(self):
         return self.leafscope().resolvables
 
-    def createchild(self, **kwargs):
-        return self.leafscope().createchild(**kwargs)
+    def createchild(self):
+        return self.leafscope().createchild()
 
     def getresolvecontext(self):
         return self
@@ -25,8 +24,8 @@ class BaseResolveContext:
     def resolvableornone(self, key):
         return self.leafscope().resolvableornone(key)
 
-    def resolved(self, *path, **kwargs):
-        return self.resolvedimpl(path, kwargs) if path else self.leafscope()
+    def resolved(self, *path):
+        return self.resolvedimpl(path) if path else self.leafscope()
 
     def staticscope(self):
         return self.leafscope().staticscope()
@@ -39,15 +38,11 @@ class AnchorResolveContext(BaseResolveContext):
     def leafscope(self):
         return self.anchorscope
 
-    def resolvedimpl(self, path, kwargs):
+    def resolvedimpl(self, path):
         hit = Query([], path).search(self.anchorscope)
-        return hit.resolvable.resolve(ResolveContext(self.anchorscope, path, [hit.address]), **kwargs)
+        return hit.resolvable.resolve(ResolveContext(self.anchorscope, path, [hit.address]))
 
-class ResolveContext(BaseResolveContext):
-
-    @classmethod
-    def _of(cls, *args):
-        return cls(*args)
+class ResolveContext(BaseResolveContext, Forkable):
 
     def __init__(self, anchorscope, exprpath, addresses):
         self.anchorscope = anchorscope
@@ -58,11 +53,11 @@ class ResolveContext(BaseResolveContext):
     def leafscope(self):
         return Query([], self.scopepath).search(self.anchorscope).naiveresolve() if self.scopepath else self.anchorscope # XXX: Is naiveresolve correct here?
 
-    def resolvedimpl(self, path, kwargs):
+    def resolvedimpl(self, path):
         try:
             hit = Query(self.scopepath, path).search(self.anchorscope)
             if hit.address in self.addresses: # XXX: Could it be valid to resolve the same address recursively with 2 different contexts?
                 raise CycleException(path)
-            return hit.resolvable.resolve(self._of(self.anchorscope, list(chain(self.scopepath, path)), self.addresses + [hit.address]), **kwargs)
+            return hit.resolvable.resolve(self._of(self.anchorscope, [*self.scopepath, *path], [*self.addresses, hit.address]))
         except NoSuchPathException as e:
             raise TreeNoSuchPathException(self.exprpath, [e])

{aridity-92 → aridity-94}/aridity/scope.py

@@ -4,9 +4,9 @@ from .model import Directive, Function, Hole, Resolvable, Scalar, star, Stream,
 from .resolve import AnchorResolveContext
 from .search import Query
 from .stacks import IndentStack, SimpleStack, ThreadLocalResolvable
-from .util import NoSuchPathException, OrderedDict, solo, UnsupportedEntryException
+from .util import NoSuchPathException, solo, UnsupportedEntryException
 from itertools import chain
-import collections, os, sys, threading
+import os, sys, threading
 
 class NotAPathException(Exception): pass
 
@@ -45,7 +45,7 @@ class Resolvables:
         return {}
 
     def __init__(self, scope):
-        self.d = collections.OrderedDict()
+        self.d = {}
         self.scope = scope
 
     def put(self, key, resolvable):
@@ -69,7 +69,7 @@ class Resolvables:
                 yield k, v
 
 # XXX: Isn't this Resolved rather than Resolvable?
-class AbstractScope(Resolvable): # TODO LATER: Some methods should probably be moved to Scope.
+class Scope(Resolvable):
 
     nametypes = {str, type(None), OpaqueKey} # XXX: Is None still used by anything?
 
@@ -117,7 +117,7 @@ class AbstractScope(Resolvable): # TODO LATER: Some methods should probably be m
     def getresolvecontext(self):
         return AnchorResolveContext(self)
 
-    def resolved(self, *path, **kwargs):
+    def resolved(self, *path):
         'Follow the given path to get an expression, evaluate it (resolving any paths it requires, recursively), and return the resulting model object.'
         # TODO LATER: API to filter out results unsuitable for context.
         for s in chain.from_iterable(self.scopedepths()):
@@ -127,7 +127,7 @@ class AbstractScope(Resolvable): # TODO LATER: Some methods should probably be m
                 break
             except AttributeError:
                 pass
-        return g(self.getresolvecontext(), *map(Text, path), **kwargs)
+        return g(self.getresolvecontext(), *map(Text, path))
 
     def resolvableornone(self, key):
         return self.resolvables.getornone(key)
@@ -141,9 +141,12 @@ class AbstractScope(Resolvable): # TODO LATER: Some methods should probably be m
             yield scopes
             scopes = nextscopes
 
-    def unravel(self):
-        d = OrderedDict([k, o.unravel()] for k, o in self.resolveditems())
-        return list(d) if self.islist or (d and all(OpaqueKey.isopaque(k) for k in d.keys())) else d
+    def unravel(self, listmode = 0):
+        def g():
+            args = [2] if 2 == listmode else []
+            for k, o in self.resolveditems():
+                yield k, o.unravel(*args)
+        return [v for _, v in g()] if listmode else dict(g())
 
     def staticscope(self):
         for s in chain.from_iterable(self.scopedepths()):
@@ -197,10 +200,40 @@ class AbstractScope(Resolvable): # TODO LATER: Some methods should probably be m
             for t in r.resolvemulti(k, self):
                 yield t
 
-    def createchild(self, **kwargs):
-        return Scope([self], **kwargs)
+    def createchild(self):
+        return Scope([self])
+
+    def resolve(self, scope):
+        return self
+
+def _slashfunction(scope, *resolvables):
+    path = None
+    for r in reversed(resolvables):
+        component = r.resolve(scope).textvalue
+        path = component if path is None else os.path.join(component, path)
+        if os.path.isabs(path):
+            break
+    return Text(os.path.join() if path is None else path)
+
+class Slash(Text, Function):
+    'As text, the platform slash. As function, join args using that slash, starting with the last absolute path (or using all args if all relative).'
+
+    def __init__(self):
+        Text.__init__(self, os.sep)
+        Function.__init__(self, _slashfunction)
+
+class Star(Function, Directive):
 
-class StaticScope(AbstractScope):
+    protokey = object()
+
+    def __init__(self):
+        Function.__init__(self, star)
+        Directive.__init__(self, prime(self._star))
+
+    def _star(self, prefix, suffix, scope):
+        scope.getorcreatesubscope(prefix.topath(scope) + (self.protokey,)).execute(suffix)
+
+class StaticScope(Scope):
 
     rootscopekey = OpaqueKey()
     stacktypes = dict(here = SimpleStack, indent = IndentStack)
@@ -234,44 +267,8 @@ class StaticScope(AbstractScope):
             setattr(threadlocals, name, stack)
             return stack
 
-class Slash(Text, Function):
-    'As text, the platform slash. As function, join args using that slash, starting with the last absolute path (or using all args if all relative).'
-
-    def __init__(self):
-        Text.__init__(self, os.sep)
-        Function.__init__(self, slashfunction)
-
-def slashfunction(scope, *resolvables):
-    path = None
-    for r in reversed(resolvables):
-        component = r.resolve(scope).textvalue
-        path = component if path is None else os.path.join(component, path)
-        if os.path.isabs(path):
-            break
-    return Text(os.path.join() if path is None else path)
-
-class Star(Function, Directive):
-
-    protokey = object()
-
-    def __init__(self):
-        Function.__init__(self, star)
-        Directive.__init__(self, prime(self._star))
-
-    def _star(self, prefix, suffix, scope):
-        scope.getorcreatesubscope(prefix.topath(scope) + (self.protokey,)).execute(suffix)
-
 StaticScope = StaticScope()
 
-class Scope(AbstractScope):
-
-    def __init__(self, parents = None, islist = False):
-        super().__init__([StaticScope] if parents is None else parents)
-        self.islist = islist
-
-    def resolve(self, scope):
-        return self
-
 class ScalarScope(Scope):
 
     def __init__(self, parents, scalarobj):

{aridity-92 → aridity-94}/aridity/search.py

@@ -73,20 +73,17 @@ def _lt(*depthspair):
 class Query:
 
     def __init__(self, prefix, path):
-        assert path
         self.prefixlen = len(prefix)
         self.path = [*prefix, *path]
 
     def _search(self, scope):
-        merges = [Iterator([], scope, self.path[0], self.prefixlen)]
+        merges = [[Hit([], None, scope)], *(Merge() for _ in self.path)]
         size = len(self.path)
-        for _ in range(1, size):
-            merges.append(Merge())
         for cursor, merge in enumerate(merges):
-            zerocount = size - cursor - 1
+            zerocount = size - cursor
             yield None, zerocount
             for hit in merge:
-                for x in range(cursor + 1, size):
+                for x in range(cursor, size):
                     i = hit.iterornone(self.path[x], x < self.prefixlen)
                     if i is None:
                         break
@@ -94,7 +91,7 @@ class Query:
                         hit = i.next()
                     except StopIteration:
                         break
-                    merges[x].add(i)
+                    merges[1 + x].add(i)
                 else:
                     yield hit, zerocount
 

{aridity-92 → aridity-94}/aridity/util.py

@@ -1,5 +1,5 @@
 from importlib.metadata import entry_points
-import collections, sys
+import sys
 
 dotpy = '.py'
 inf = float('inf')
@@ -17,7 +17,7 @@ class TreeNoSuchPathException(NoSuchPathException):
 
     def __str__(self):
         path, causes = self.args # XXX: Also collect (and show) where in the tree the causes happened?
-        causestrtocount = collections.OrderedDict()
+        causestrtocount = {}
         for causestr in map(str, causes):
             try:
                 causestrtocount[causestr] += 1
@@ -35,52 +35,6 @@ class CycleException(UnparseNoSuchPathException): pass
 
 class UnsupportedEntryException(Exception): pass
 
-class OrderedDictWrapper:
-
-    def __init__(self, *args):
-        self.d = collections.OrderedDict(*args)
-
-    def __bool__(self):
-        return bool(self.d)
-
-    def __nonzero__(self):
-        return self.__bool__()
-
-class OrderedDict(OrderedDictWrapper):
-
-    def __setitem__(self, k, v):
-        self.d[k] = v
-
-    def __getitem__(self, k):
-        return self.d[k]
-
-    def __delitem__(self, k):
-        del self.d[k]
-
-    def get(self, k, default = None):
-        return self.d.get(k, default)
-
-    def keys(self):
-        return self.d.keys()
-
-    def values(self):
-        return self.d.values()
-
-    def items(self):
-        return self.d.items()
-
-    def __iter__(self):
-        return iter(self.d.values())
-
-    def __eq__(self, that):
-        return self.d == that
-
-    def __repr__(self):
-        return repr(self.d)
-
-    def update(self, other):
-        return self.d.update(other)
-
 def openresource(package_or_name, resource_name, encoding = 'ascii'):
     'Like `pkg_resources.resource_stream` but text mode.'
     from .model import Resource
@@ -112,3 +66,9 @@ def popattr(obj, name):
     val = getattr(obj, name)
     delattr(obj, name)
     return val
+
+class Forkable:
+
+    @classmethod
+    def _of(cls, *args, **kwargs):
+        return cls(*args, **kwargs)

{aridity-92 → aridity-94}/aridity.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aridity
-Version: 92
+Version: 94
 Summary: DRY config and template system, easily extensible with Python
 Home-page: https://pypi.org/project/aridity/
 Author: foyono
@@ -35,7 +35,7 @@ Process the given template to stdout using config from stdin.
 #### ConfigCtrl Objects
 
 ```python
-class ConfigCtrl()
+class ConfigCtrl(Forkable)
 ```
 
 High level scope API.
@@ -191,6 +191,17 @@ def plusequals(prefix, suffix, scope)
 
 Assign expression to prefix plus an opaque key, i.e. add to list.
 
+<a id="aridity.directives.commaequals"></a>
+
+###### commaequals
+
+```python
+@prime
+def commaequals(prefix, suffix, scope)
+```
+
+Split expression on whitespace and make a list out of the parts.
+
 <a id="aridity.functions"></a>
 
 ### aridity.functions
@@ -461,20 +472,20 @@ Attempt to wrap the given value in a model object of the most specific type.
 
 ### aridity.scope
 
-<a id="aridity.scope.AbstractScope"></a>
+<a id="aridity.scope.Scope"></a>
 
-#### AbstractScope Objects
+#### Scope Objects
 
 ```python
-class AbstractScope(Resolvable)
+class Scope(Resolvable)
 ```
 
-<a id="aridity.scope.AbstractScope.resolved"></a>
+<a id="aridity.scope.Scope.resolved"></a>
 
 ###### resolved
 
 ```python
-def resolved(*path, **kwargs)
+def resolved(*path)
 ```
 
 Follow the given path to get an expression, evaluate it (resolving any paths it requires, recursively), and return the resulting model object.

{aridity-92 → aridity-94}/setup.py

@@ -49,7 +49,7 @@ class SourceInfo:
 sourceinfo = SourceInfo('.')
 setup(
     name = 'aridity',
-    version = '92',
+    version = '94',
     description = 'DRY config and template system, easily extensible with Python',
     url = 'https://pypi.org/project/aridity/',
     author = 'foyono',