dotted-notation 0.51.0__tar.gz → 0.51.1__tar.gz

{dotted_notation-0.51.0 → dotted_notation-0.51.1}/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to `dotted` are recorded here. Versions prior to
 the ones listed are omitted — browse git history for earlier entries.
 
+## [0.51.1]
+
+### Added
+- `ReferenceResolver.lex` is offered a bare transform argument too,
+  `|sub:taken`, in the position `'transforms'`. Answering `None` leaves
+  it the plain string it was.
+
 ## [0.51.0]
 
 ### Added

{dotted_notation-0.51.0/dotted_notation.egg-info → dotted_notation-0.51.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotted_notation
-Version: 0.51.0
+Version: 0.51.1
 Summary: Dotted notation for safe nested data traversal with optional chaining, pattern matching, and transforms
 Author-email: Frey Waid <logophage1@gmail.com>
 License-Expression: MIT
@@ -1771,12 +1771,14 @@ path's segment values, and a slice of a parsed path, `ops[1:]`, is a path.
 
 A host's own names may stand where dotted has no reading for a bare token:
 a slot, `merged[k]`, a slice bound, `items[:n]`, a filter value,
-`[*&cur=want]`, or a guard value, `a=k`. The parse-time hook
-`lex(text, position)` is offered each such token as written, a dotted name
-whole, with its position, one of `'slots'`, `'slices'`, `'filters'` or
-`'guards'`. It answers with dotted text to read in the token's place, `None`
-to leave the `ParseError`, or raises to fail the parse at the token. The
-answer must be one token dotted reads there, and is not offered again.
+`[*&cur=want]`, a guard value, `a=k`, or a transform argument,
+`|sub:taken`. The parse-time hook `lex(text, position)` is offered each such
+token as written, a dotted name whole, with its position, one of `'slots'`,
+`'slices'`, `'filters'`, `'guards'` or `'transforms'`. It answers with dotted
+text to read in the token's place, `None` to leave the `ParseError` (a
+transform argument stays the plain string it was), or raises to fail the
+parse at the token. The answer must be one token dotted reads there, and is
+not offered again.
 
     >>> class Names(dotted.ReferenceResolver):
     ...     def lex(self, text, position):
@@ -1787,7 +1789,7 @@ answer must be one token dotted reads there, and is not offered again.
     >>> dotted.get(d, 'merged[c.account]', resolver=Names())
     2
 
-A token dotted reads, `m[$x]` or `|sub:taken`, is never offered to `lex()`;
+A token dotted reads, `m[$x]` or `|sub:$taken`, is never offered to `lex()`;
 a host that means something else by one remaps it at run time, through
 `literals`. `parse` takes `resolver=` too, and a path is cached per resolver
 that lexes.

{dotted_notation-0.51.0 → dotted_notation-0.51.1}/README.md

@@ -1723,12 +1723,14 @@ path's segment values, and a slice of a parsed path, `ops[1:]`, is a path.
 
 A host's own names may stand where dotted has no reading for a bare token:
 a slot, `merged[k]`, a slice bound, `items[:n]`, a filter value,
-`[*&cur=want]`, or a guard value, `a=k`. The parse-time hook
-`lex(text, position)` is offered each such token as written, a dotted name
-whole, with its position, one of `'slots'`, `'slices'`, `'filters'` or
-`'guards'`. It answers with dotted text to read in the token's place, `None`
-to leave the `ParseError`, or raises to fail the parse at the token. The
-answer must be one token dotted reads there, and is not offered again.
+`[*&cur=want]`, a guard value, `a=k`, or a transform argument,
+`|sub:taken`. The parse-time hook `lex(text, position)` is offered each such
+token as written, a dotted name whole, with its position, one of `'slots'`,
+`'slices'`, `'filters'`, `'guards'` or `'transforms'`. It answers with dotted
+text to read in the token's place, `None` to leave the `ParseError` (a
+transform argument stays the plain string it was), or raises to fail the
+parse at the token. The answer must be one token dotted reads there, and is
+not offered again.
 
     >>> class Names(dotted.ReferenceResolver):
     ...     def lex(self, text, position):
@@ -1739,7 +1741,7 @@ answer must be one token dotted reads there, and is not offered again.
     >>> dotted.get(d, 'merged[c.account]', resolver=Names())
     2
 
-A token dotted reads, `m[$x]` or `|sub:taken`, is never offered to `lex()`;
+A token dotted reads, `m[$x]` or `|sub:$taken`, is never offered to `lex()`;
 a host that means something else by one remaps it at run time, through
 `literals`. `parse` takes `resolver=` too, and a path is cached per resolver
 that lexes.

{dotted_notation-0.51.0 → dotted_notation-0.51.1}/dotted/base.py

@@ -155,8 +155,8 @@ class NOP(metaclass=MetaNOP):
 LITERALS = ('segments', 'transforms', 'guards', 'filters')
 
 # The positions a resolver's lex() may be offered a token in: a slot, a
-# slice bound, a filter value and a guard value.
-LEXED = ('slots', 'slices', 'filters', 'guards')
+# slice bound, a filter value, a guard value and a transform argument.
+LEXED = ('slots', 'slices', 'filters', 'guards', 'transforms')
 
 
 class Resolver:
@@ -203,7 +203,8 @@ class Resolver:
         position it stands in, one of LEXED. A dotted name is one token,
         merged[a.b] offering 'a.b'. It answers with dotted text to read
         in the token's place, '$$(k)' making the path merged[$$(k)], or
-        None to leave the path unparsed; raising fails the parse at the
+        None to leave the path unparsed (a transform argument, |sub:k,
+        a plain string, as it was); raising fails the parse at the
         token. The text is read in that position as one token, and is
         not offered to lex() again. A token dotted reads is never
         offered: a host that means something else by one says so at run

{dotted_notation-0.51.0 → dotted_notation-0.51.1}/dotted/grammar.py

@@ -686,8 +686,11 @@ guard_value = (value + _ends) | Lexed('guards', value, _value_stops, end=True)
 _key_atom = _commons | numeric_extended | non_integer | numeric_key | word
 _slot_atom = _commons | numeric_extended | numeric_slot
 
-# Transform: |name or |name:param — defined early so filters and guards can reference it
-targ = concrete_value | _arg_sigil | var | quoted | ppc.number | none | true | false | pp.CharsNotIn('|:')
+# Transform: |name or |name:param — defined early so filters and guards can reference it.
+# A param dotted has no reading for is offered to the lexer before it is
+# taken as a plain string, so a lexer answering None leaves it one.
+_targ_read = concrete_value | _arg_sigil | var | quoted | ppc.number | none | true | false
+targ = (_targ_read + _ends) | Lexed('transforms', _targ_read, '|:', end=True) | pp.CharsNotIn('|:')
 param = (colon + targ) | colon.copy().set_parse_action(lambda: [None])
 transform = (transform_name.copy() + ZM(param)).set_parse_action(lambda s, loc, t: base.Transform(*t))
 transforms = ZM(pipe + transform)

{dotted_notation-0.51.0 → dotted_notation-0.51.1/dotted_notation.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotted_notation
-Version: 0.51.0
+Version: 0.51.1
 Summary: Dotted notation for safe nested data traversal with optional chaining, pattern matching, and transforms
 Author-email: Frey Waid <logophage1@gmail.com>
 License-Expression: MIT
@@ -1771,12 +1771,14 @@ path's segment values, and a slice of a parsed path, `ops[1:]`, is a path.
 
 A host's own names may stand where dotted has no reading for a bare token:
 a slot, `merged[k]`, a slice bound, `items[:n]`, a filter value,
-`[*&cur=want]`, or a guard value, `a=k`. The parse-time hook
-`lex(text, position)` is offered each such token as written, a dotted name
-whole, with its position, one of `'slots'`, `'slices'`, `'filters'` or
-`'guards'`. It answers with dotted text to read in the token's place, `None`
-to leave the `ParseError`, or raises to fail the parse at the token. The
-answer must be one token dotted reads there, and is not offered again.
+`[*&cur=want]`, a guard value, `a=k`, or a transform argument,
+`|sub:taken`. The parse-time hook `lex(text, position)` is offered each such
+token as written, a dotted name whole, with its position, one of `'slots'`,
+`'slices'`, `'filters'`, `'guards'` or `'transforms'`. It answers with dotted
+text to read in the token's place, `None` to leave the `ParseError` (a
+transform argument stays the plain string it was), or raises to fail the
+parse at the token. The answer must be one token dotted reads there, and is
+not offered again.
 
     >>> class Names(dotted.ReferenceResolver):
     ...     def lex(self, text, position):
@@ -1787,7 +1789,7 @@ answer must be one token dotted reads there, and is not offered again.
     >>> dotted.get(d, 'merged[c.account]', resolver=Names())
     2
 
-A token dotted reads, `m[$x]` or `|sub:taken`, is never offered to `lex()`;
+A token dotted reads, `m[$x]` or `|sub:$taken`, is never offered to `lex()`;
 a host that means something else by one remaps it at run time, through
 `literals`. `parse` takes `resolver=` too, and a path is cached per resolver
 that lexes.

{dotted_notation-0.51.0 → dotted_notation-0.51.1}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dotted_notation"
-version = "0.51.0"
+version = "0.51.1"
 description = "Dotted notation for safe nested data traversal with optional chaining, pattern matching, and transforms"
 readme = "README.md"
 requires-python = ">=3.6"