aridity 74__tar.gz → 76__tar.gz

{aridity-74 → aridity-76}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aridity
-Version: 74
+Version: 76
 Summary: DRY config and template system, easily extensible with Python
 Home-page: https://pypi.org/project/aridity/
 Author: foyono

{aridity-74 → aridity-76}/aridity/config.py

@@ -3,7 +3,7 @@ from .model import Entry, Function, Locator, Number, Resource, Scalar, Stream, T
 from .repl import Repl
 from .scope import Scope
 from .search import resolvedscopeornone
-from .util import CycleException, dotpy, NoSuchPathException, qualname, selectentrypoints, solo
+from .util import dotpy, NoSuchPathException, qualname, selectentrypoints, solo
 from functools import partial
 from itertools import chain
 from parabject import Parabject, register
@@ -172,7 +172,7 @@ class Config(Parabject):
         path = ctrl.prefix + [name]
         try:
             obj = ctrl.basescope.resolved(*path) # TODO LATER: Guidance for how lazy non-scalars should be in this situation.
-        except (CycleException, NoSuchPathException): # XXX: Should this really translate CycleException?
+        except NoSuchPathException:
             raise AttributeError(' '.join(path))
         try:
             return obj.scalar

{aridity-74 → aridity-76}/aridity/functions.py

@@ -2,10 +2,11 @@ from __future__ import division
 from .model import Boolean, Number, Resource, Text, wrap
 from .util import allfunctions, dotpy, NoSuchPathException, realname
 from importlib import import_module
-import itertools, json, re, shlex
+from itertools import chain
+import json, re, shlex
 
 xmlentities = dict([c, "&%s;" % w] for c, w in [['"', 'quot'], ["'", 'apos']])
-tomlbasicbadchars = re.compile('[%s]+' % re.escape(r'\"' + ''.join(chr(x) for x in itertools.chain(range(0x08 + 1), range(0x0A, 0x1F + 1), [0x7F]))))
+tomlbasicbadchars = re.compile('[%s]+' % re.escape(r'\"' + ''.join(chr(x) for x in chain(range(0x08 + 1), range(0x0A, 0x1F + 1), [0x7F]))))
 zeroormoredots = re.compile('[.]*')
 
 def _tomlquote(text):
@@ -136,11 +137,6 @@ class Functions:
         s = resolvables.resolve(scope)
         return Text(separator.join(o.cat() for _, o in s.resolveditems()))
 
-    def get(*args): return getimpl(*args)
-
-    @realname('')
-    def get_(*args): return getimpl(*args)
-
     @realname(',') # XXX: Oh yeah?
     def aslist(scope, *resolvables):
         return scope.resolved(*(r.resolve(scope).cat() for r in resolvables), **{'aslist': True})
@@ -246,8 +242,13 @@ class Functions:
             raise NoSuchPathException('No line terminator to remove.')
         return Text(text[:-n])
 
-def getimpl(scope, *resolvables):
-    return scope.resolved(*(r.resolve(scope).cat() for r in resolvables))
+    def indentmorelines(scope, resolvable):
+        indent = scope.resolved('indent').cat()
+        lines = resolvable.resolve(scope).cat().splitlines(True)
+        return Text(''.join(chain(lines[:1], (indent + line for line in lines[1:]))))
+
+def getimpl(scope, *resolvables, **kwargs):
+    return scope.resolved(*(r.resolve(scope).cat() for r in resolvables), **kwargs)
 
 def getfunctions():
     return allfunctions(Functions)

{aridity-74 → aridity-76}/aridity/model.py

@@ -302,11 +302,11 @@ class Call(Resolvable):
                 yield a
 
     def resolve(self, scope, aslist = False):
-        result = self._functionvalue(scope)(scope, *self._resolvables())
+        result = self._functionvalue(scope)(scope.getresolvecontext(), *self._resolvables())
         return List([result]) if aslist else result
 
     def resolvemulti(self, j, scope):
-        f = self._functionvalue(scope)
+        f = self._functionvalue(scope.getresolvecontext())
         if star != f:
             yield j, f(scope, *self._resolvables())
         else:

aridity-76/aridity/resolve.py

@@ -0,0 +1,83 @@
+from .search import Query
+from .util import CycleException, NoSuchPathException, TreeNoSuchPathException
+from itertools import chain
+
+def _slices(path):
+    yield path
+    limit = len(path) + 1
+    for k in range(1, limit):
+        for i in range(limit - k):
+            yield path[:i] + path[i + k:]
+
+class BaseResolveContext:
+
+    @property
+    def label(self):
+        return self.leafscope().label
+
+    @property
+    def parents(self):
+        return self.leafscope().parents
+
+    @property
+    def resolvables(self):
+        return self.leafscope().resolvables
+
+    def createchild(self, **kwargs):
+        return self.leafscope().createchild(**kwargs)
+
+    def getresolvecontext(self):
+        return self
+
+    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 staticscope(self):
+        return self.leafscope().staticscope()
+
+class AnchorResolveContext(BaseResolveContext):
+
+    def __init__(self, anchorscope):
+        self.anchorscope = anchorscope
+
+    def leafscope(self):
+        return self.anchorscope
+
+    def resolvedimpl(self, path, kwargs):
+        hit = Query(path).search(self.anchorscope)
+        return hit.resolvable.resolve(ResolveContext(self.anchorscope, path, [hit.address]), **kwargs)
+
+class ResolveContext(BaseResolveContext):
+
+    @classmethod
+    def _of(cls, *args):
+        return cls(*args)
+
+    def __init__(self, anchorscope, exprpath, addresses):
+        self.anchorscope = anchorscope
+        self.scopepath = exprpath[:-1]
+        self.exprpath = exprpath
+        self.addresses = addresses
+
+    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):
+        errors = []
+        for prefix in _slices(self.scopepath):
+            try:
+                hit = Query(list(chain(prefix, 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)
+            except NoSuchPathException as e:
+                errors.append(e)
+                continue
+            try:
+                return hit.resolvable.resolve(self._of(self.anchorscope, list(chain(self.scopepath, path)), self.addresses + [hit.address]), **kwargs)
+            except NoSuchPathException as e:
+                errors.append(e)
+                break # XXX: Or continue?
+        raise TreeNoSuchPathException(self.exprpath, errors)

{aridity-74 → aridity-76}/aridity/scope.py

@@ -1,10 +1,11 @@
 from . import directives
 from .directives import Precedence
-from .functions import getfunctions, OpaqueKey
+from .functions import getfunctions, getimpl, OpaqueKey
 from .model import CatNotSupportedException, Directive, Function, Resolvable, Scalar, star, Stream, Text
-from .search import Query, resolvedscopeornone, slices
+from .resolve import AnchorResolveContext
+from .search import Query
 from .stacks import IndentStack, SimpleStack, ThreadLocalResolvable
-from .util import CycleException, NoSuchPathException, OrderedDict, solo, TreeNoSuchPathException, UnsupportedEntryException
+from .util import NoSuchPathException, OrderedDict, solo, UnsupportedEntryException
 from itertools import chain
 import collections, os, sys, threading, unicodedata
 
@@ -118,31 +119,20 @@ class AbstractScope(Resolvable): # TODO LATER: Some methods should probably be m
             s.resolvables.put(k, v)
         return s
 
+    def getresolvecontext(self):
+        return AnchorResolveContext(self)
+
     def resolved(self, *path, **kwargs):
         'Follow the given path to get an expression, evaluate it (resolving any paths it requires, recursively), and return the resulting model object.'
-        try:
-            resolving = self.threadlocals.resolving
-        except AttributeError:
-            self.threadlocals.resolving = resolving = set()
-        if path in resolving:
-            raise CycleException(path)
-        resolving.add(path)
-        try:
-            if not path:
-                return self
-            hit = Query(path).search(self)
-            # TODO: Review this algo.
-            errors = []
-            for words in slices(path):
-                for s in (resolvedscopeornone(s, words) for s in chain.from_iterable(self.scopedepths())):
-                    if s is not None:
-                        try:
-                            return hit.resolvable.resolve(s, **kwargs)
-                        except NoSuchPathException as e:
-                            errors.append(e)
-            raise TreeNoSuchPathException(path, errors)
-        finally:
-            resolving.remove(path)
+        # TODO LATER: API to filter out results unsuitable for context.
+        for s in chain.from_iterable(self.scopedepths()):
+            obj = getimpl(s.getresolvecontext(), Text(''))
+            try:
+                g = obj.functionvalue
+                break
+            except AttributeError:
+                pass
+        return g(self.getresolvecontext(), *map(Text, path), **kwargs)
 
     def resolvableornone(self, key):
         return self.resolvables.getornone(key)
@@ -229,6 +219,8 @@ class StaticScope(AbstractScope):
             self[word.cat(),] = Directive(d)
         for name, f in getfunctions():
             self[name,] = Function(f)
+        self['',] = Function(getimpl) # TODO: Refer to the other one.
+        self['get',] = Function(getimpl)
         self['keyring_cron',] = Scalar(False)
         self['keyring_force',] = Scalar(False)
         self['~',] = Text(os.path.expanduser('~'))

{aridity-74 → aridity-76}/aridity/search.py

@@ -13,10 +13,15 @@ def resolvedscopeornone(s, path):
             return
     return s
 
-class Hit(namedtuple('BaseHit', 'depths scope resolvable')):
+class Address(namedtuple('BaseAddress', 'scope key')): pass
+
+class Hit(namedtuple('BaseHit', 'depths address resolvable')):
+
+    def naiveresolve(self):
+        return self.resolvable.resolve(self.address.scope) # XXX: Wise?
 
     def iterornone(self, word):
-        contextscope = self.resolvable.resolve(self.scope) # XXX: Wise?
+        contextscope = self.naiveresolve()
         if hasattr(contextscope, 'resolvableornone'):
             return Iterator(self.depths, contextscope, word)
 
@@ -36,7 +41,7 @@ class Iterator(Iterable):
                 for scope in scopes:
                     resolvable = scope.resolvableornone(word)
                     if resolvable is not None:
-                        yield Hit(depths + [depth], scope, resolvable)
+                        yield Hit(depths + [depth], Address(scope, word), resolvable)
         self.iterator = g()
 
     def next(self):
@@ -116,12 +121,3 @@ class Query:
                             return hit
                         sump.offer(hit)
         raise UnparseNoSuchPathException(self.path)
-
-def slices(path):
-    n = len(path)
-    for k in range(n)[::-1]:
-        for start in range(n - k):
-            v = path[start:start + k]
-            yield v
-            if not v:
-                return

{aridity-74 → aridity-76}/aridity/util.py

@@ -33,7 +33,7 @@ class TreeNoSuchPathException(NoSuchPathException):
                 lines.append("    %s" % l)
         return '\n'.join(lines)
 
-class CycleException(Exception): pass
+class CycleException(UnparseNoSuchPathException): pass
 
 class UnsupportedEntryException(Exception): pass
 

{aridity-74 → aridity-76}/aridity.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aridity
-Version: 74
+Version: 76
 Summary: DRY config and template system, easily extensible with Python
 Home-page: https://pypi.org/project/aridity/
 Author: foyono

{aridity-74 → aridity-76}/aridity.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ aridity/keyring.py
 aridity/model.py
 aridity/processtemplate.py
 aridity/repl.py
+aridity/resolve.py
 aridity/scope.py
 aridity/search.py
 aridity/stacks.py

{aridity-74 → aridity-76}/setup.py

@@ -6,7 +6,7 @@ def long_description():
 
 setup(
     name = 'aridity',
-    version = '74',
+    version = '76',
     description = 'DRY config and template system, easily extensible with Python',
     long_description = long_description(),
     long_description_content_type = 'text/markdown',