aridity 83__tar.gz → 85__tar.gz

{aridity-83 → aridity-85}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aridity
-Version: 83
+Version: 85
 Summary: DRY config and template system, easily extensible with Python
 Home-page: https://pypi.org/project/aridity/
 Author: foyono
@@ -247,16 +247,6 @@ Process the given template to stdout using config from stdin.
 
 ### aridity.config
 
-<a id="aridity.config.ForeignScopeException"></a>
-
-#### ForeignScopeException Objects
-
-```python
-class ForeignScopeException(Exception)
-```
-
-The operation required a scope at precisely the given path.
-
 <a id="aridity.config.ConfigCtrl"></a>
 
 #### ConfigCtrl Objects
@@ -558,7 +548,7 @@ If given 3 args, the first two are variable names for scope key and scope respec
 ###### join
 
 ```python
-def join(scope, resolvables, *args)
+def join(scope, partsresolvable, sepresolvable=None)
 ```
 
 Concatenate the given list, using optional separator. Frequently used with `map`.
@@ -780,7 +770,7 @@ Get the regular object associated with `parabject` or raise UnknownParabjectExce
 #### Parabject Objects
 
 ```python
-class Parabject(object)
+class Parabject()
 ```
 
 Subclasses typically implement `__getattr__` for dynamic behaviour on attribute access.

{aridity-83 → aridity-85}/README.md

@@ -237,16 +237,6 @@ Process the given template to stdout using config from stdin.
 
 ### aridity.config
 
-<a id="aridity.config.ForeignScopeException"></a>
-
-#### ForeignScopeException Objects
-
-```python
-class ForeignScopeException(Exception)
-```
-
-The operation required a scope at precisely the given path.
-
 <a id="aridity.config.ConfigCtrl"></a>
 
 #### ConfigCtrl Objects
@@ -548,7 +538,7 @@ If given 3 args, the first two are variable names for scope key and scope respec
 ###### join
 
 ```python
-def join(scope, resolvables, *args)
+def join(scope, partsresolvable, sepresolvable=None)
 ```
 
 Concatenate the given list, using optional separator. Frequently used with `map`.
@@ -770,7 +760,7 @@ Get the regular object associated with `parabject` or raise UnknownParabjectExce
 #### Parabject Objects
 
 ```python
-class Parabject(object)
+class Parabject()
 ```
 
 Subclasses typically implement `__getattr__` for dynamic behaviour on attribute access.

{aridity-83 → aridity-85}/aridity/config.py

@@ -1,12 +1,11 @@
 from .functions import OpaqueKey
-from .model import Entry, Function, Locator, Number, Resource, Scalar, Stream, Text, wrap
+from .model import Entry, Locator, Resource, Stream, Text, wrap
 from .repl import Repl
 from .scope import Scope
 from .search import resolvedscopeornone
 from .util import dotpy, NoSuchPathException, qualname, selectentrypoints, solo
-from functools import partial
-from itertools import chain
 from parabject import Parabject, register
+from pathlib import Path
 import errno, logging, os, sys
 
 log = logging.getLogger(__name__)
@@ -29,19 +28,22 @@ def _processmainfunction(mainfunction):
         appname, = (ep.name for ep in selectentrypoints('console_scripts') if ep.module == module and ep.attr == attr)
     return module, appname
 
-class ForeignScopeException(Exception):
-    'The operation required a scope at precisely the given path.'
-
 def _wrappathorstream(pathorstream):
     return (Stream if getattr(pathorstream, 'readable', lambda: False)() else Locator)(pathorstream)
 
 class ConfigCtrl:
     'High level scope API.'
 
+    settingsopenable = Locator(Path.home() / '.settings.arid')
+
     @classmethod
     def _of(cls, *args, **kwargs):
         return cls(*args, **kwargs)
 
+    @property
+    def node(self):
+        return register(self, Config)
+
     @property
     def r(self):
         'Get config object for reading, i.e. missing scopes will error.'
@@ -53,7 +55,6 @@ class ConfigCtrl:
         return register(self, WConfig)
 
     def __init__(self, basescope = None, prefix = None):
-        self.node = register(self, Config)
         self.basescope = Scope() if basescope is None else basescope
         self.prefix = [] if prefix is None else prefix
 
@@ -73,7 +74,7 @@ class ConfigCtrl:
         return appconfig
 
     def _loadappconfig(self, appname, resource):
-        resource.source(self.basescope.getorcreatesubscope(self.prefix + [appname]), Entry([]))
+        resource.source(self.basescope.getorcreatesubscope([*self.prefix, appname]), Entry([]))
         return getattr(self.node, appname)
 
     def reapplysettings(self, mainfunction):
@@ -81,7 +82,7 @@ class ConfigCtrl:
             appname = mainfunction
         else:
             _, appname = _processmainfunction(mainfunction)
-        s = self.scope(True).duplicate()
+        s = self.scope.duplicate()
         s.label = Text(appname)
         p = solo(s.parents)
         p[appname,] = s
@@ -89,101 +90,72 @@ class ConfigCtrl:
         parent.loadsettings()
         return getattr(parent.node, appname)
 
-    def printf(self, template, *args):
-        with Repl(self.basescope) as repl:
-            repl.printf(''.join(chain(("%s " for _ in self.prefix), [template])), *chain(self.prefix, args))
-
     def load(self, pathorstream):
         'Execute config from the given path or stream.'
-        s = self.scope(True)
-        _wrappathorstream(pathorstream).source(s, Entry([]))
+        _wrappathorstream(pathorstream).source(self.scope, Entry([]))
 
     def loadsettings(self):
-        self.load(os.path.join(os.path.expanduser('~'), '.settings.arid'))
-
-    def repl(self):
-        assert not self.prefix # XXX: Support prefix?
-        return Repl(self.basescope)
+        self.settingsopenable.source(self.scope, Entry([]))
 
     def execute(self, text):
         'Execute given config text.'
-        with self.repl() as repl:
+        with Repl(self.scope) as repl:
             for line in text.splitlines(True):
                 repl(line)
 
-    def put(self, *path, **kwargs):
-        def pairs():
-            for t, k in [
-                    [Function, 'function'],
-                    [Number, 'number'],
-                    [Scalar, 'scalar'],
-                    [Text, 'text'],
-                    [lambda x: x, 'resolvable']]:
-                try:
-                    yield t, kwargs[k]
-                except KeyError:
-                    pass
-        # XXX: Support combination of types e.g. slash is both function and text?
-        factory, = (partial(t, v) for t, v in pairs())
-        self.basescope[tuple(self.prefix) + path] = factory()
-
-    def scope(self, strict = False):
-        if strict:
-            s = resolvedscopeornone(self.basescope, self.prefix)
-            if s is None:
-                raise ForeignScopeException
-            return s
-        return self.basescope.resolved(*self.prefix) # TODO: Test what happens if it changes.
+    @property
+    def scope(self):
+        s = resolvedscopeornone(self.basescope, self.prefix)
+        assert s is not None
+        return s
 
     def __iter__(self): # TODO: Add API to get keys without resolving values.
         'Yield keys and values.'
-        for k, o in self.scope().resolveditems():
+        for k, o in self.resolve().resolveditems():
             try:
                 yield k, o.scalar
             except AttributeError:
-                yield k, self._of(self.basescope, self.prefix + [k]).node
+                yield k, self.addname(k).node
 
     def processtemplate(self, frompathorstream, topathorstream):
         'Evaluate expression from path/stream and write result to path/stream.'
-        s = self.scope()
-        obj = _wrappathorstream(frompathorstream).processtemplate(s)
+        obj = _wrappathorstream(frompathorstream).processtemplate(self.resolve())
         if getattr(topathorstream, 'writable', lambda: False)():
-            topathorstream.write(obj.cat() if hasattr(topathorstream, 'encoding') else obj.binaryvalue)
+            topathorstream.write(obj.textvalue if hasattr(topathorstream, 'encoding') else obj.binaryvalue)
         else:
             obj.writeout(topathorstream)
 
-    def freectrl(self):
-        return self._of(self.scope()) # XXX: Strict?
-
     def childctrl(self):
-        return self._of(self.scope(True).createchild())
+        return self._of(self.scope.createchild())
 
     def addname(self, name):
-        return self._of(self.basescope, self.prefix + [name])
+        return self._of(self.basescope, [*self.prefix, name])
 
     def resolve(self):
         return self.basescope.resolved(*self.prefix)
 
+    def prefixrepr(self):
+        return '.'.join(w if w.isidentifier() else repr(w) for w in self.prefix)
+
 class Config(Parabject):
 
     def __getattr__(self, name):
-        ctrl = -self
-        path = ctrl.prefix + [name]
+        query = (-self).addname(name)
         try:
-            obj = ctrl.basescope.resolved(*path) # TODO LATER: Guidance for how lazy non-scalars should be in this situation.
+            obj = query.resolve() # TODO LATER: Guidance for how lazy non-scalars should be in this situation.
         except NoSuchPathException:
-            raise AttributeError(' '.join(path))
+            raise AttributeError(query.prefixrepr())
         try:
             return obj.scalar
         except AttributeError:
-            return ctrl._of(ctrl.basescope, path).node
+            return query.node
 
     def __iter__(self):
         for _, o in -self:
             yield o
 
     def __setattr__(self, name, value):
-        (-self).scope(True)[name,] = wrap(value)
+        (-self).scope[name,] = wrap(value)
 
 class RConfig(Parabject):
 
@@ -192,7 +164,7 @@ class RConfig(Parabject):
         try:
             obj = query.resolve()
         except NoSuchPathException:
-            raise AttributeError
+            raise AttributeError(query.prefixrepr())
         try:
             return obj.scalar
         except AttributeError:
@@ -200,7 +172,7 @@ class RConfig(Parabject):
 
     def __iter__(self):
         'Yield values only. Iterate over `-self` for keys and values.'
-        for _, o in (-self).scope().resolveditems(): # TODO: Investigate how iteration should work.
+        for _, o in (-self).resolve().resolveditems(): # TODO: Investigate how iteration should work.
             yield o.scalar
 
 class WConfig(Parabject):

{aridity-83 → aridity-85}/aridity/directives.py

@@ -36,7 +36,7 @@ class Redirect:
 class Write:
     name = '!write'
     def __call__(self, prefix, suffix, scope):
-        scope.resolved('stdout').flush(suffix.tophrase().resolve(scope).cat())
+        scope.resolved('stdout').flush(suffix.tophrase().resolve(scope).textvalue)
 
 @_directive
 class Source:
@@ -94,4 +94,4 @@ class Cat:
     name = '<'
     def __call__(self, prefix, suffix, scope):
         scope = scope.getorcreatesubscope(prefix.topath(scope))
-        scope.resolved('stdout').flush(suffix.tophrase().resolve(scope).openable(scope).processtemplate(scope).cat())
+        scope.resolved('stdout').flush(suffix.tophrase().resolve(scope).openable(scope).processtemplate(scope).textvalue)

{aridity-83 → aridity-85}/aridity/functions.py

@@ -1,4 +1,4 @@
-from .model import Boolean, Hole, Number, Resource, Text, wrap
+from .model import Boolean, Hole, Indeterminate, Number, Resource, Text, wrap
 from .util import allfunctions, dotpy, NoSuchPathException, realname
 from importlib import import_module
 from itertools import chain
@@ -13,7 +13,7 @@ def _tomlquote(text):
         return ''.join(fr"\u{ord(c):04X}" for c in m.group())
     return f'"{tomlbasicbadchars.sub(repl, text)}"'
 
-class OpaqueKey(object):
+class OpaqueKey:
 
     @classmethod
     def isopaque(cls, key):
@@ -25,19 +25,19 @@ class Functions:
 
     def screenstr(scope, resolvable):
         'GNU Screen string literal.'
-        return Text('"{}"'.format(re.sub(r'[\\\n"]', r'\\\g<0>', resolvable.resolve(scope).cat())))
+        return Text('"{}"'.format(re.sub(r'[\\\n"]', r'\\\g<0>', resolvable.resolve(scope).textvalue)))
 
     def scstr(scope, resolvable):
         'SuperCollider string literal.'
-        return Text('"{}"'.format(re.sub(r'[\\\n"]', r'\\\g<0>', resolvable.resolve(scope).cat())))
+        return Text('"{}"'.format(re.sub(r'[\\\n"]', r'\\\g<0>', resolvable.resolve(scope).textvalue)))
 
     def hclstr(scope, resolvable):
         'HashiCorp configuration language string literal.'
-        return Text('"{}"'.format(re.sub(r'[\\\n"]', r'\\\g<0>', resolvable.resolve(scope).cat())))
+        return Text('"{}"'.format(re.sub(r'[\\\n"]', r'\\\g<0>', resolvable.resolve(scope).textvalue)))
 
     def groovystr(scope, resolvable):
         'Groovy string literal.'
-        return Text("'{}'".format(re.sub(r"[\\\n']", r'\\\g<0>', resolvable.resolve(scope).cat())))
+        return Text("'{}'".format(re.sub(r"[\\\n']", r'\\\g<0>', resolvable.resolve(scope).textvalue)))
 
     def pystr(scope, resolvable):
         'Python literal.'
@@ -45,7 +45,7 @@ class Functions:
 
     def shstr(scope, resolvable):
         'Shell string literal.'
-        return Text(shlex.quote(resolvable.resolve(scope).cat()))
+        return Text(shlex.quote(resolvable.resolve(scope).textvalue))
 
     def jsonquote(scope, resolvable):
         'JSON literal, also suitable for YAML.'
@@ -54,21 +54,21 @@ class Functions:
     def xmlattr(scope, resolvable):
         'XML attribute literal (including quotes).'
         from xml.sax.saxutils import quoteattr
-        return Text(quoteattr(resolvable.resolve(scope).cat())) # TODO: Support booleans.
+        return Text(quoteattr(resolvable.resolve(scope).textvalue)) # TODO: Support booleans.
 
     def xmltext(scope, resolvable):
         'XML content, suggest assigning this to & with xmlattr assigned to " as is convention.'
         from xml.sax.saxutils import escape
-        return Text(escape(resolvable.resolve(scope).cat(), xmlentities))
+        return Text(escape(resolvable.resolve(scope).textvalue, xmlentities))
 
     def tomlquote(scope, resolvable):
         'TOML string literal.'
-        return Text(_tomlquote(resolvable.resolve(scope).cat()))
+        return Text(_tomlquote(resolvable.resolve(scope).textvalue))
 
     def urlquote(scope, resolvable):
         'Percent-encode all reserved characters.'
         from urllib.parse import quote
-        return Text(quote(resolvable.resolve(scope).cat(), safe = ''))
+        return Text(quote(resolvable.resolve(scope).textvalue, safe = ''))
 
     def map(scope, objsresolvable, *args):
         '''If given 1 arg, evaluate it against every scope in `objsresolvable` and return that list.
@@ -96,7 +96,7 @@ class Functions:
                 s[vname,] = v
                 return s
             vname, resolvable = args
-            vname = vname.resolve(scope).cat()
+            vname = vname.resolve(scope).textvalue
         else:
             def context(k, v):
                 s = Scope(parents)
@@ -104,8 +104,8 @@ class Functions:
                 s[vname,] = v
                 return s
             kname, vname, resolvable = args
-            kname = kname.resolve(scope).cat()
-            vname = vname.resolve(scope).cat()
+            kname = kname.resolve(scope).textvalue
+            vname = vname.resolve(scope).textvalue
         result = Scope(islist = True) # XXX: Really no parent?
         for k, v in objs.resolveditems():
             result.resolvables.put(k, resolvable.resolve(context(k, v)))
@@ -122,19 +122,13 @@ class Functions:
     def label(scope):
         return scope.label
 
-    def join(scope, resolvables, *args):
+    def join(scope, partsresolvable, sepresolvable = None):
         'Concatenate the given list, using optional separator. Frequently used with `map`.'
-        if args:
-            r, = args
-            separator = r.resolve(scope).cat()
-        else:
-            separator = ''
-        s = resolvables.resolve(scope)
-        return Text(separator.join(o.cat() for _, o in s.resolveditems()))
+        return Join(scope, partsresolvable).execute(sepresolvable)
 
     @realname(',') # XXX: Oh yeah?
     def aslist(scope, *resolvables):
-        return scope.resolved(*(r.resolve(scope).cat() for r in resolvables), **{'aslist': True})
+        return scope.resolved(*(r.resolve(scope).textvalue for r in resolvables), **{'aslist': True})
 
     def str(scope, resolvable):
         'Coerce to string.'
@@ -178,7 +172,7 @@ class Functions:
     @realname('./')
     def hereslash(scope, *resolvables):
         'Join the given path components with the directory of the current resource.'
-        return scope.resolved('here').slash((r.resolve(scope).cat() for r in resolvables), False)
+        return scope.resolved('here').slash((r.resolve(scope).textvalue for r in resolvables), False)
 
     def readfile(scope, resolvable):
         'Include the content of the given path.'
@@ -190,12 +184,12 @@ class Functions:
         return resolvable.resolve(scope).openable(scope).processtemplate(scope)
 
     def lower(scope, resolvable):
-        return Text(resolvable.resolve(scope).cat().lower())
+        return Text(resolvable.resolve(scope).textvalue.lower())
 
     def pyref(scope, moduleresolvable, qualnameresolvable):
         'Python object in given module with given qualified name. Module may be relative to current resource, in which case assignment with `:=` is normally necessary. Typically used to import functions.'
         def moduleobj():
-            moduleref = moduleresolvable.resolve(scope).cat()
+            moduleref = moduleresolvable.resolve(scope).textvalue
             leadingdots = len(zeroormoredots.match(moduleref).group())
             if not leadingdots:
                 return import_module(moduleref)
@@ -212,23 +206,23 @@ class Functions:
                 exec(f.read(), g)
             return M()
         pyobj = moduleobj()
-        for name in qualnameresolvable.resolve(scope).cat().split('.'):
+        for name in qualnameresolvable.resolve(scope).textvalue.split('.'):
             pyobj = getattr(pyobj, name)
         return wrap(pyobj)
 
     def pyres(scope, packageresolvable, nameresolvable, encoding = Text('ascii')):
         'Python resource for inclusion with `.` directive.'
-        return Resource(packageresolvable.resolve(scope).cat(), nameresolvable.resolve(scope).cat(), encoding.resolve(scope).cat())
+        return Resource(packageresolvable.resolve(scope).textvalue, nameresolvable.resolve(scope).textvalue, encoding.resolve(scope).textvalue)
 
     @realname('\N{NOT SIGN}')
     def not_(scope, resolvable):
         return Boolean(not resolvable.resolve(scope).truth())
 
     def getfrom(scope, scoperesolvable, *resolvables):
-        return scoperesolvable.resolve(scope).resolved(*(r.resolve(scope).cat() for r in resolvables))
+        return scoperesolvable.resolve(scope).resolved(*(r.resolve(scope).textvalue for r in resolvables))
 
     def rmeol(scope, resolvable):
-        text = resolvable.resolve(scope).cat()
+        text = resolvable.resolve(scope).textvalue
         if text.endswith('\r\n'):
             n = 2
         elif text.endswith(('\r', '\n')):
@@ -238,15 +232,40 @@ class Functions:
         return Text(text[:-n])
 
     def indentmorelines(scope, resolvable):
-        indent = scope.resolved('indent').cat()
-        lines = resolvable.resolve(scope).cat().splitlines(True)
+        indent = scope.resolved('indent').textvalue
+        lines = resolvable.resolve(scope).textvalue.splitlines(True)
         return Text(''.join(chain(lines[:1], (indent + line for line in lines[1:]))))
 
     def hole(scope, resolvable):
-        return Hole(Text(''), resolvable.resolve(scope).cat())
+        return Hole(Text(''), resolvable.resolve(scope).textvalue)
+
+class Join:
+
+    def __init__(self, scope, partsresolvable):
+        self.i = (o for _, o in partsresolvable.resolve(scope).resolveditems())
+        self.scope = scope
+
+    def _load(self):
+        try:
+            self.obj = next(self.i)
+            return True
+        except StopIteration:
+            pass
+
+    def execute(self, sepresolvable):
+        resobj = Indeterminate
+        if self._load():
+            resobj = resobj.plus(self.obj)
+            if self._load():
+                sepobj = Indeterminate if sepresolvable is None else sepresolvable.resolve(self.scope)
+                while True:
+                    resobj = resobj.plus(sepobj).plus(self.obj)
+                    if not self._load():
+                        break
+        return resobj
 
 def getimpl(scope, *resolvables, **kwargs):
-    return scope.resolved(*(r.resolve(scope).cat() for r in resolvables), **kwargs)
+    return scope.resolved(*(r.resolve(scope).textvalue for r in resolvables), **kwargs)
 
 def getfunctions():
     return allfunctions(Functions)

{aridity-83 → aridity-85}/aridity/keyring.py

@@ -33,8 +33,8 @@ def keyring(scope, serviceres, usernameres):
         log.debug("Set %s to: %s", key, value)
         os.environ[key] = value
     from keyring import get_password, set_password
-    service = serviceres.resolve(scope).cat()
-    username = usernameres.resolve(scope).cat()
+    service = serviceres.resolve(scope).textvalue
+    username = usernameres.resolve(scope).textvalue
     password = None if scope.resolved('keyring_force').scalar else get_password(service, username)
     return Scalar(Password(*[getpass(), partial(set_password, service, username)] if password is None else [password, None]))
 
@@ -43,7 +43,7 @@ class DecryptionFailedException(Exception): pass
 def gpg(scope, resolvable):
     'Use gpg to decrypt the given base64-encoded blob.'
     with NamedTemporaryFile() as f:
-        f.write(b64decode(resolvable.resolve(scope).cat()))
+        f.write(b64decode(resolvable.resolve(scope).textvalue))
         f.flush()
         try:
             return Scalar(Password(check_output(['gpg', '-d', f.name]).decode('ascii'), None))

{aridity-83 → aridity-85}/aridity/model.py

@@ -7,7 +7,7 @@ from itertools import chain, islice
 from parabject import dereference, UnknownParabjectException
 import numbers, os
 
-class Struct(object):
+class Struct:
 
     def __eq__(self, that):
         if type(self) != type(that):
@@ -52,7 +52,7 @@ class NegBuffer:
     def annihilate(self, obj):
         if not self.text:
             return obj
-        text = obj.cat()
+        text = obj.textvalue
         if not text:
             return obj
         k = min(len(self.text), len(text))
@@ -63,7 +63,7 @@ class NegBuffer:
     def propagate(self, obj):
         return Hole(obj, self.text) if self.text else obj
 
-class Concat(Resolvable):
+class Concat(Resolvable): # TODO: Ban in path components.
 
     ignorable = False
 
@@ -95,17 +95,14 @@ class Concat(Resolvable):
             obj = negbuffer.annihilate(obj)
             result = result.plus(obj)
             try:
-                text = obj.cat()
-            except CatNotSupportedException:
+                text = obj.textvalue
+            except AttributeError:
                 pass
             else:
                 self.monitor(text)
             negbuffer.insert(negtext)
         return negbuffer.propagate(result)
 
-# TODO: Always throw when concatenation within a path component is attempted.
-class CatNotSupportedException(Exception): pass
-
 class BaseSimpleValue(Resolved):
 
     @classmethod
@@ -113,35 +110,28 @@ class BaseSimpleValue(Resolved):
         value, = t
         return cls(value)
 
-    def cat(self):
-        raise CatNotSupportedException(self)
-
     def unravel(self):
         return self.scalar
 
-class SimpleValue(BaseSimpleValue):
-
-    def __init__(self, scalar):
-        self.scalar = scalar
-
-class Cat:
-
-    def cat(self):
-        return self.scalar
-
-class Blank(Cat, SimpleValue):
+class Blank(BaseSimpleValue):
 
     ignorable = True
     boundary = False
 
+    def __init__(self, textvalue):
+        self.textvalue = textvalue
+
     def plus(self, that):
-        return Text(self.scalar + that.cat())
+        return Text(self.textvalue + that.textvalue)
 
-class Boundary(SimpleValue):
+class Boundary(BaseSimpleValue):
 
     ignorable = True
     boundary = True
 
+    def __init__(self, scalar):
+        self.scalar = scalar
+
 class BaseScalar(BaseSimpleValue):
 
     ignorable = False
@@ -154,12 +144,18 @@ class BaseScalar(BaseSimpleValue):
             setattr(self, k, v)
         return self
 
+    def __getattr__(self, name):
+        raise self.attrerror(name)
+
+    def attrerror(self, name):
+        return AttributeError(f"{self} does not have: {name}")
+
 class Scalar(BaseScalar):
 
     def __init__(self, scalar):
         self.scalar = scalar
 
-class Text(Cat, BaseScalar):
+class Text(BaseScalar):
 
     @classmethod
     def joinpa(cls, s, l, t):
@@ -176,7 +172,7 @@ class Text(Cat, BaseScalar):
     @property
     def binaryvalue(self):
         if self.textvalue:
-            raise AttributeError('binaryvalue')
+            raise self.attrerror('binaryvalue')
         return b''
 
     def __init__(self, textvalue):
@@ -203,12 +199,12 @@ class Text(Cat, BaseScalar):
         return Locator(s)
 
     def plus(self, that):
-        return self._of(self.textvalue + that.cat())
+        return self._of(self.textvalue + that.textvalue)
 
-class Indeterminate:
+class Indeterminate(BaseSimpleValue): # XXX: Base class needed?
 
-    def cat(self):
-        return ''
+    binaryvalue = b''
+    textvalue = ''
 
     def plus(self, that):
         return that
@@ -218,11 +214,13 @@ class Indeterminate:
 
 Indeterminate = Indeterminate()
 
+class ResidualHoleException(Exception): pass
+
 class Hole(BaseScalar):
 
     @property
     def scalar(self):
-        raise CatNotSupportedException
+        raise ResidualHoleException
 
     def __init__(self, prefix, holevalue):
         self.prefix = prefix
@@ -341,14 +339,8 @@ class Number(BaseScalar):
             text = str(self.numbervalue) # TODO: Test this.
         return Text(text)
 
-    def cat(self):
-        try:
-            return self.textvalue
-        except AttributeError:
-            raise CatNotSupportedException
-
     def plus(self, that):
-        return Text(self.textvalue + that.cat())
+        return Text(self.textvalue + that.textvalue)
 
 class Boolean(BaseScalar):
 
@@ -399,7 +391,7 @@ def List(objs):
     from .scope import Scope
     s = Scope(islist = True)
     for obj in objs:
-        s.resolvables.put(object(), obj)
+        s.resolvables.put(object(), obj) # XXX: Not OpaqueKey?
     return s
 
 class Directive(Resolved):
@@ -472,7 +464,7 @@ class Entry(Struct):
         return [r for r in self.resolvables if not r.ignorable]
 
     def topath(self, scope):
-        return tuple((None if self.wildcard == r else r.resolve(scope).totext().cat()) for r in self.resolvables if not r.ignorable)
+        return tuple((None if self.wildcard == r else r.resolve(scope).totext().textvalue) for r in self.resolvables if not r.ignorable)
 
     def subentry(self, i, j):
         v = list(self.resolvables)
@@ -501,7 +493,7 @@ class Entry(Struct):
             if not r.ignorable or r.boundary:
                 break
             indent.append(r) # XXX: Can we simply grab its value?
-        return Concat.unlesssingleton(indent).resolve(None).cat()
+        return Concat.unlesssingleton(indent).resolve(None).textvalue
 
 def wrap(value):
     'Attempt to wrap the given value in a model object of the most specific type.'
@@ -510,7 +502,7 @@ def wrap(value):
     except UnknownParabjectException:
         pass
     else:
-        return ctrl.scope(True)
+        return ctrl.scope
     for b in map(bool, range(2)):
         if value is b:
             return Boolean(value)

{aridity-83 → aridity-85}/aridity/scope.py

@@ -1,7 +1,7 @@
 from . import directives
 from .directives import Precedence
 from .functions import getfunctions, getimpl, OpaqueKey
-from .model import CatNotSupportedException, Directive, Function, Hole, Resolvable, Scalar, star, Stream, Text
+from .model import Directive, Function, Hole, Resolvable, Scalar, star, Stream, Text
 from .resolve import AnchorResolveContext
 from .search import Query
 from .stacks import IndentStack, SimpleStack, ThreadLocalResolvable
@@ -160,7 +160,7 @@ class AbstractScope(Resolvable): # TODO LATER: Some methods should probably be m
         precedence = Precedence.void
         for i, wordobj in enumerate(entry.words()):
             try:
-                word = wordobj.cat()
+                word = wordobj.textvalue
                 if not word:
                     continue
                 initialcategory = _categoryornone(word[0])
@@ -172,7 +172,7 @@ class AbstractScope(Resolvable): # TODO LATER: Some methods should probably be m
                     del directives[:]
                     precedence = p
                 directives.append((d, i))
-            except (AttributeError, CatNotSupportedException, NoSuchPathException):
+            except (AttributeError, NoSuchPathException):
                 pass
         if directives:
             d, i = directives[0] # XXX: Always use first?
@@ -216,7 +216,7 @@ class StaticScope(AbstractScope):
     def __init__(self):
         super(StaticScope, self).__init__(())
         for word, d in directives.lookup.items():
-            self[word.cat(),] = Directive(d)
+            self[word.textvalue,] = Directive(d)
         for name, f in getfunctions():
             self[name,] = Function(f)
         self['',] = Function(getimpl) # TODO: Refer to the other one.
@@ -253,7 +253,7 @@ class Slash(Text, Function):
 def slashfunction(scope, *resolvables):
     path = None
     for r in reversed(resolvables):
-        component = r.resolve(scope).cat()
+        component = r.resolve(scope).textvalue
         path = component if path is None else os.path.join(component, path)
         if os.path.isabs(path):
             break

{aridity-83 → aridity-85}/aridity.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aridity
-Version: 83
+Version: 85
 Summary: DRY config and template system, easily extensible with Python
 Home-page: https://pypi.org/project/aridity/
 Author: foyono
@@ -247,16 +247,6 @@ Process the given template to stdout using config from stdin.
 
 ### aridity.config
 
-<a id="aridity.config.ForeignScopeException"></a>
-
-#### ForeignScopeException Objects
-
-```python
-class ForeignScopeException(Exception)
-```
-
-The operation required a scope at precisely the given path.
-
 <a id="aridity.config.ConfigCtrl"></a>
 
 #### ConfigCtrl Objects
@@ -558,7 +548,7 @@ If given 3 args, the first two are variable names for scope key and scope respec
 ###### join
 
 ```python
-def join(scope, resolvables, *args)
+def join(scope, partsresolvable, sepresolvable=None)
 ```
 
 Concatenate the given list, using optional separator. Frequently used with `map`.
@@ -780,7 +770,7 @@ Get the regular object associated with `parabject` or raise UnknownParabjectExce
 #### Parabject Objects
 
 ```python
-class Parabject(object)
+class Parabject()
 ```
 
 Subclasses typically implement `__getattr__` for dynamic behaviour on attribute access.

{aridity-83 → aridity-85}/parabject.py

@@ -17,7 +17,7 @@ def dereference(parabject):
     except (KeyError, TypeError):
         raise UnknownParabjectException
 
-class Parabject(object):
+class Parabject:
     'Subclasses typically implement `__getattr__` for dynamic behaviour on attribute access.'
 
     def __neg__(self):

{aridity-83 → aridity-85}/setup.py

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