aridity 83__tar.gz → 84__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aridity
-Version: 83
+Version: 84
 Summary: DRY config and template system, easily extensible with Python
 Home-page: https://pypi.org/project/aridity/
 Author: foyono
@@ -558,7 +558,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`.

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

@@ -548,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`.

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

@@ -148,7 +148,7 @@ class ConfigCtrl:
         s = self.scope()
         obj = _wrappathorstream(frompathorstream).processtemplate(s)
         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)
 

{aridity-83 → aridity-84}/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-84}/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
@@ -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-84}/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-84}/aridity/model.py

@@ -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
@@ -159,7 +149,7 @@ class Scalar(BaseScalar):
     def __init__(self, scalar):
         self.scalar = scalar
 
-class Text(Cat, BaseScalar):
+class Text(BaseScalar):
 
     @classmethod
     def joinpa(cls, s, l, t):
@@ -203,12 +193,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 +208,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 +333,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):
 
@@ -472,7 +458,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 +487,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.'

{aridity-83 → aridity-84}/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-84}/aridity.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aridity
-Version: 83
+Version: 84
 Summary: DRY config and template system, easily extensible with Python
 Home-page: https://pypi.org/project/aridity/
 Author: foyono
@@ -558,7 +558,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`.

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

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