jsonata-python 0.6.0__tar.gz → 0.6.2__tar.gz

{jsonata_python-0.6.0 → jsonata_python-0.6.2}/.github/workflows/test.yml

@@ -9,16 +9,16 @@ jobs:
   test:
     strategy:
       matrix:
-        python: ['3.9', '3.10', '3.11', '3.12', '3.13']
+        python: ['3.10', '3.11', '3.12', '3.13', '3.14']
         platform: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{ matrix.platform }}
     steps:
     - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v6
       with:
         submodules: recursive
     - name: Set up Python ${{ matrix.python }}
-      uses: actions/setup-python@v3
+      uses: actions/setup-python@v6
       with:
         python-version: ${{ matrix.python }}
     - name: Install test dependencies

{jsonata_python-0.6.0 → jsonata_python-0.6.2}/.gitignore

@@ -17,3 +17,5 @@ venv/
 .idea
 .venv
 tests/gen
+
+.claude

{jsonata_python-0.6.0 → jsonata_python-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jsonata-python
-Version: 0.6.0
+Version: 0.6.2
 Summary: Pure Python implementation of JSONata
 Project-URL: Homepage, https://github.com/rayokota/jsonata-python
 Project-URL: Bug Reports, https://github.com/rayokota/jsonata-python/issues
@@ -212,7 +212,7 @@ Keywords: json,jsonata
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 
 # jsonata-python
@@ -235,7 +235,7 @@ The JSONata documentation can be found [here](https://jsonata.org).
 ## Installation
 
 ```
-pip install jsonata-python
+pipx install jsonata-python
 ```
 
 ## Getting Started
@@ -256,8 +256,8 @@ A very simple start:
 The CLI provides the same functionality as the [Dashjoin JSONata CLI](https://github.com/dashjoin/jsonata-cli).
 
 ```
-% python3 -m jsonata.cli
-usage: jsonata.cli [-h] [-v] [-e <file>] [-i <arg>] [-ic <arg>] [-f {auto,json,string}] [-o <arg>] [-oc <arg>] [-time] [-c] [-b <json-string>]
+% jsonata -h
+usage: jsonata [-h] [-v] [-e <file>] [-i <arg>] [-ic <arg>] [-f {auto,json,string}] [-o <arg>] [-oc <arg>] [-time] [-c] [-b <json-string>]
                    [-bf <file>] [-it]
                    [expr]
 
@@ -293,19 +293,19 @@ options:
 ### Examples
 
 ```
-% echo '{"a":"hello", "b":" world"}' | python3 -m jsonata.cli '(a & b)'
+% echo '{"a":"hello", "b":" world"}' | jsonata '(a & b)'
 hello world
 
-% echo '{"a":"hello", "b":" world"}' | python3 -m jsonata.cli -o helloworld.json $
+% echo '{"a":"hello", "b":" world"}' | jsonata -o helloworld.json $
 # helloworld.json written
 
-% ls | python3 -m jsonata.cli $
+% ls | jsonata $
 helloworld.json
 
-% ps -o pid="",%cpu="",%mem="" | python3 -m jsonata.cli '$.$split(/\n/).$trim().[ $split(/\s+/)[$length()>0].$number() ]' -c
+% ps -o pid="",%cpu="",%mem="" | jsonata '$.$split(/\n/).$trim().[ $split(/\s+/)[$length()>0].$number() ]' -c
 [[4105,0,0],[4646,0,0],[4666,0,0],[33696,0,0]...]
 
-% curl -s https://raw.githubusercontent.com/jsonata-js/jsonata/master/test/test-suite/datasets/dataset1.json | python3 -m jsonata.cli '{"Name": FirstName & " " & Surname, "Cities": **.City, "Emails": Email[type="home"].address}'
+% curl -s https://raw.githubusercontent.com/jsonata-js/jsonata/master/test/test-suite/datasets/dataset1.json | jsonata '{"Name": FirstName & " " & Surname, "Cities": **.City, "Emails": Email[type="home"].address}'
 {
   "Name": "Fred Smith",
   "Cities": [
@@ -318,7 +318,7 @@ helloworld.json
   ]
 }
 
-% python3 -m jsonata.cli -i helloworld.json -it
+% jsonata -i helloworld.json -it
 Enter an expression to have it evaluated.
 JSONata> (a & b)
 hello world

{jsonata_python-0.6.0 → jsonata_python-0.6.2}/README.md

@@ -18,7 +18,7 @@ The JSONata documentation can be found [here](https://jsonata.org).
 ## Installation
 
 ```
-pip install jsonata-python
+pipx install jsonata-python
 ```
 
 ## Getting Started
@@ -39,8 +39,8 @@ A very simple start:
 The CLI provides the same functionality as the [Dashjoin JSONata CLI](https://github.com/dashjoin/jsonata-cli).
 
 ```
-% python3 -m jsonata.cli
-usage: jsonata.cli [-h] [-v] [-e <file>] [-i <arg>] [-ic <arg>] [-f {auto,json,string}] [-o <arg>] [-oc <arg>] [-time] [-c] [-b <json-string>]
+% jsonata -h
+usage: jsonata [-h] [-v] [-e <file>] [-i <arg>] [-ic <arg>] [-f {auto,json,string}] [-o <arg>] [-oc <arg>] [-time] [-c] [-b <json-string>]
                    [-bf <file>] [-it]
                    [expr]
 
@@ -76,19 +76,19 @@ options:
 ### Examples
 
 ```
-% echo '{"a":"hello", "b":" world"}' | python3 -m jsonata.cli '(a & b)'
+% echo '{"a":"hello", "b":" world"}' | jsonata '(a & b)'
 hello world
 
-% echo '{"a":"hello", "b":" world"}' | python3 -m jsonata.cli -o helloworld.json $
+% echo '{"a":"hello", "b":" world"}' | jsonata -o helloworld.json $
 # helloworld.json written
 
-% ls | python3 -m jsonata.cli $
+% ls | jsonata $
 helloworld.json
 
-% ps -o pid="",%cpu="",%mem="" | python3 -m jsonata.cli '$.$split(/\n/).$trim().[ $split(/\s+/)[$length()>0].$number() ]' -c
+% ps -o pid="",%cpu="",%mem="" | jsonata '$.$split(/\n/).$trim().[ $split(/\s+/)[$length()>0].$number() ]' -c
 [[4105,0,0],[4646,0,0],[4666,0,0],[33696,0,0]...]
 
-% curl -s https://raw.githubusercontent.com/jsonata-js/jsonata/master/test/test-suite/datasets/dataset1.json | python3 -m jsonata.cli '{"Name": FirstName & " " & Surname, "Cities": **.City, "Emails": Email[type="home"].address}'
+% curl -s https://raw.githubusercontent.com/jsonata-js/jsonata/master/test/test-suite/datasets/dataset1.json | jsonata '{"Name": FirstName & " " & Surname, "Cities": **.City, "Emails": Email[type="home"].address}'
 {
   "Name": "Fred Smith",
   "Cities": [
@@ -101,7 +101,7 @@ helloworld.json
   ]
 }
 
-% python3 -m jsonata.cli -i helloworld.json -it
+% jsonata -i helloworld.json -it
 Enter an expression to have it evaluated.
 JSONata> (a & b)
 hello world

{jsonata_python-0.6.0 → jsonata_python-0.6.2}/noxfile.py

@@ -37,7 +37,7 @@ def build_and_check_dists(session):
     session.run("python", "-m", "twine", "check", "dist/*")
 
 
-@nox.session(python=["3.9", "3.10", "3.11", "3.12", "3.13"])
+@nox.session(python=["3.10", "3.11", "3.12", "3.13", "3.14"])
 def tests(session):
     session.install("pytest")
     session.install("pytest-asyncio")

{jsonata_python-0.6.0 → jsonata_python-0.6.2}/pyproject.toml

@@ -2,13 +2,15 @@
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
+[project.scripts]
+jsonata = "jsonata.cli.__main__:main"
 
 [project]
 name = "jsonata-python"
-version = "0.6.0"
+version = "0.6.2"
 description = "Pure Python implementation of JSONata"
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 license = {file = "LICENSE"}
 keywords = ["jsonata", "json"]
 authors = [

{jsonata_python-0.6.0 → jsonata_python-0.6.2}/src/jsonata/cli/__main__.py

@@ -32,9 +32,9 @@ from jsonata import functions, jexception, jsonata, timebox
 def get_options(argv: Optional[list[str]] = None) -> argparse.ArgumentParser:
     """Parses command-line arguments.
     """
-    parser = argparse.ArgumentParser(prog="jsonata.cli", description="Pure Python JSONata CLI")
+    parser = argparse.ArgumentParser(prog="jsonata", description="Pure Python JSONata CLI")
     parser.add_argument(
-        "-v", "--version", action='version', version='%(prog)s 0.6.0')
+        "-v", "--version", action='version', version='%(prog)s 0.6.2')
 
     parser.add_argument(
         "-e", "--expression", metavar="<file>",

{jsonata_python-0.6.0 → jsonata_python-0.6.2}/src/jsonata/datetimeutils.py

@@ -524,7 +524,7 @@ class DateTimeUtils:
         while pos < len(picture):
             if picture[pos] == '[':
                 # check it's not a doubled [[
-                if picture[pos + 1] == '[':
+                if pos + 1 < len(picture) and picture[pos + 1] == '[':
                     # literal [
                     format.add_literal(picture, start, pos)
                     format.parts.append(DateTimeUtils.SpecPart("literal", value="["))
@@ -637,14 +637,14 @@ class DateTimeUtils:
 
         offset_millis = (60 * offset_hours + offset_minutes) * 60 * 1000
         date_time = datetime.datetime.fromtimestamp((millis + offset_millis) / 1000.0, datetime.timezone.utc)
-        result = ""
+        parts = []
         for part in format_spec.parts:
             if part.type == "literal":
-                result += part.value
+                parts.append(part.value)
             else:
-                result += DateTimeUtils._format_component(date_time, part, offset_hours, offset_minutes)
+                parts.append(DateTimeUtils._format_component(date_time, part, offset_hours, offset_minutes))
 
-        return result
+        return ''.join(parts)
 
     @staticmethod
     def _format_component(date: datetime.datetime, marker_spec: SpecPart, offset_hours: int,

{jsonata_python-0.6.0 → jsonata_python-0.6.2}/src/jsonata/functions.py

@@ -474,11 +474,7 @@ class Functions:
         pads = size - str_len
         if pads <= 0:
             return string
-        padding = ""
-        i = 0
-        while i < pads + 1:
-            padding += pad_str
-            i += 1
+        padding = pad_str * (pads // len(pad_str) + 1)
         return Functions.substr(padding, 0, pads) + string
 
     # Source: Jsonata4Java PadFunction
@@ -501,11 +497,7 @@ class Functions:
         pads = size - str_len
         if pads <= 0:
             return string
-        padding = ""
-        i = 0
-        while i < pads + 1:
-            padding += pad_str
-            i += 1
+        padding = pad_str * (pads // len(pad_str) + 1)
         return string + Functions.substr(padding, 0, pads)
 
     @dataclass
@@ -767,23 +759,23 @@ class Functions:
             raise jexception.JException("Fourth argument of replace function must evaluate to a positive number", 0)
 
         def string_replacer(match):
-            result = ''
+            parts = []
             position = 0
             repl = str(replacement)
             while position < len(repl):
                 index = repl.find('$', position)
                 if index == -1:
-                    result += repl[position:]
+                    parts.append(repl[position:])
                     break
-                result += repl[position:index]
+                parts.append(repl[position:index])
                 position = index + 1
                 if position < len(repl):
                     dollar_val = repl[position]
                     if dollar_val == '$':
-                        result += '$'
+                        parts.append('$')
                         position += 1
                     elif dollar_val == '0':
-                        result += match.group(0)
+                        parts.append(match.group(0))
                         position += 1
                     else:
                         max_digits = len(str(len(match.groups())))
@@ -791,15 +783,15 @@ class Functions:
                         if group_num.isdigit():
                             group_index = int(group_num)
                             if 0 < group_index <= len(match.groups()):
-                                result += match.group(group_index) or ''
+                                parts.append(match.group(group_index) or '')
                                 position += len(group_num)
                             else:
-                                result += '$'
+                                parts.append('$')
                         else:
-                            result += '$'
+                            parts.append('$')
                 else:
-                    result += '$'
-            return result
+                    parts.append('$')
+            return ''.join(parts)
 
         if callable(replacement):
             replacer = lambda m: replacement(m.groupdict())
@@ -810,23 +802,23 @@ class Functions:
 
         if isinstance(pattern, str):
             # Use string methods for literal string patterns
-            result = ''
+            parts = []
             position = 0
             count = 0
             while True:
                 if limit is not None and count >= limit:
-                    result += string[position:]
+                    parts.append(string[position:])
                     break
                 index = string.find(pattern, position)
                 if index == -1:
-                    result += string[position:]
+                    parts.append(string[position:])
                     break
-                result += string[position:index]
+                parts.append(string[position:index])
                 match = re.match(re.escape(pattern), string[index:])
-                result += replacer(match)
+                parts.append(replacer(match))
                 position = index + len(pattern)
                 count += 1
-            return result
+            return ''.join(parts)
         else:
             # Use regex for pattern objects
             if limit is None:
@@ -1844,7 +1836,8 @@ class Functions:
     #     
     @staticmethod
     def error(message: Optional[str]) -> NoReturn:
-        raise jexception.JException("D3137", -1, message if message is not None else "$error() function evaluated")
+        raise jexception.JException("D3137", -1,
+                                    message if message is not None else "$error() function evaluated")
 
     #
     #
@@ -1859,8 +1852,8 @@ class Functions:
             raise jexception.JException("T0410", -1)
 
         if not condition:
-            raise jexception.JException("D3141", -1, "$assert() statement failed")
-            #                message: message || "$assert() statement failed"
+            raise jexception.JException("D3141", -1,
+                                        message if message is not None else "$assert() statement failed")
 
     #
     #
@@ -2105,7 +2098,8 @@ class Functions:
                 dt = datetime.datetime.strptime(timestamp, "%Y")
             else:
                 dt = datetime.datetime.fromisoformat(timestamp)
-            dt = dt.replace(tzinfo=datetime.timezone.utc)
+            if dt.tzinfo is None:
+                dt = dt.replace(tzinfo=datetime.timezone.utc)
             return int(dt.timestamp() * 1000)
             # try:
             #     size = len(timestamp)

{jsonata_python-0.6.0 → jsonata_python-0.6.2}/src/jsonata/jexception.py

@@ -105,6 +105,9 @@ class JException(RuntimeError):
 
         formatted = message
 
+        if formatted == "{{{message}}}":
+            return str(arg1)
+
         # Replace any {{var}} with format "{}"
         formatted = re.sub("\\{\\{\\w+\\}\\}", "{}", formatted)
 

{jsonata_python-0.6.0 → jsonata_python-0.6.2}/src/jsonata/jsonata.py

@@ -469,7 +469,7 @@ class Jsonata:
         result.tuple_stream = True
         step_env = environment
         if tuple_bindings is None:
-            tuple_bindings = [{"@": item} for item in input if item is not None]
+            tuple_bindings = [{"@": item} for item in input]
 
         for tuple_binding in tuple_bindings:
             step_env = self.create_frame_from_tuple(environment, tuple_binding)
@@ -519,7 +519,7 @@ class Jsonata:
             if index < 0:
                 # count in from end of array
                 index = len(input) + index
-            item = input[index] if index < len(input) else None
+            item = input[index] if 0 <= index < len(input) else None
             if item is not None:
                 if isinstance(item, list):
                     results = item
@@ -684,9 +684,6 @@ class Jsonata:
                 if isinstance(value, list):
                     value = self.flatten(value, None)
                     results = functions.Functions.append(results, value)
-                elif isinstance(value, dict):
-                    # Call recursively do decompose the map
-                    results.extend(self.evaluate_wildcard(expr, value))
                 else:
                     results.append(value)
 
@@ -800,9 +797,9 @@ class Jsonata:
 
         result = None
         if op == "=":
-            result = lhs == rhs  # isDeepEqual(lhs, rhs);
+            result = utils.Utils.is_deep_equal(lhs, rhs)
         elif op == "!=":
-            result = lhs != rhs  # !isDeepEqual(lhs, rhs);
+            result = not utils.Utils.is_deep_equal(lhs, rhs)
         return result
 
     #
@@ -1475,7 +1472,14 @@ class Jsonata:
             elif isinstance(proc, Jsonata.JLambda):
                 result = proc.call(input, validated_args)
             elif isinstance(proc, re.Pattern):
-                result = [s for s in validated_args if proc.search(s) is not None]
+                _res = []
+                for s in validated_args:
+                    if isinstance(s, str):
+                        _res.append(Jsonata._regex_closure(proc.finditer(s)))
+                if len(_res) == 1:
+                    result = _res[0]
+                else:
+                    result = _res
             else:
                 print("Proc not found " + str(proc))
                 raise jexception.JException("T1006", 0)
@@ -1489,6 +1493,19 @@ class Jsonata:
             raise err
         return result
 
+    @staticmethod
+    def _regex_closure(iterator):
+        m = next(iterator, None)
+        if m is None:
+            return None
+        return {
+            "match": m.group(),
+            "start": m.start(),
+            "end": m.end(),
+            "groups": [m.group()],
+            "next": Jsonata.JLambda(lambda: Jsonata._regex_closure(iterator))
+        }
+
     #
     # Evaluate lambda against input data
     # @param {Object} expr - JSONata expression

{jsonata_python-0.6.0 → jsonata_python-0.6.2}/src/jsonata/parser.py

@@ -1047,7 +1047,8 @@ class Parser:
                 rest = self.process_ast(expr.rhs)
                 if (rest.type == "function" and rest.procedure.type == "path" and len(
                         rest.procedure.steps) == 1 and rest.procedure.steps[0].type == "name" and
-                        result.steps[-1].type == "function"):
+                        result.steps[-1].type == "function" and
+                        isinstance(rest.procedure.steps[0].value, Parser.Symbol)):
                     # next function in chain of functions - will override a thenable
                     result.steps[-1].next_function = rest.procedure.steps[0].value
                 if rest.type == "path":

{jsonata_python-0.6.0 → jsonata_python-0.6.2}/src/jsonata/signature.py

@@ -308,6 +308,7 @@ class Signature:
                             arg = args[arg_index] if arg_index < len(args) else None
                             validated_args.append(arg)
                             arg_index += 1
+                index += 1
             return validated_args
         self.throw_validation_error(args, supplied_sig, self.function_name)
 

{jsonata_python-0.6.0 → jsonata_python-0.6.2}/src/jsonata/tokenizer.py

@@ -32,6 +32,8 @@ from typing import Any, Optional
 
 from jsonata import jexception, utils
 
+_NUMBER_PATTERN = re.compile(r"^-?(0|([1-9][0-9]*))(\.[0-9]+)?([Ee][-+]?[0-9]+)?")
+
 
 class Tokenizer:
     operators = {
@@ -135,7 +137,10 @@ class Tokenizer:
                 if pattern == "":
                     raise jexception.JException("S0301", self.position)
                 self.position += 1
-                current_char = self.path[self.position]
+                if self.position < self.length:
+                    current_char = self.path[self.position]
+                else:
+                    current_char = None
                 # flags
                 start = self.position
                 while current_char == 'i' or current_char == 'm':
@@ -264,8 +269,7 @@ class Tokenizer:
                 self.position += 1
             raise jexception.JException("S0101", self.position)
         # test for numbers
-        numregex = re.compile("^-?(0|([1-9][0-9]*))(\\.[0-9]+)?([Ee][-+]?[0-9]+)?")
-        match_ = numregex.search(self.path[self.position:])
+        match_ = _NUMBER_PATTERN.search(self.path[self.position:])
         if match_ is not None:
             num = float(match_.group(0))
             if not math.isnan(num) and math.isfinite(num):

{jsonata_python-0.6.0 → jsonata_python-0.6.2}/src/jsonata/utils.py

@@ -74,11 +74,7 @@ class Utils:
     @staticmethod
     def create_sequence(el: Optional[Any] = NONE) -> list:
         if el is not Utils.NONE:
-            if isinstance(el, list) and len(el) == 1:
-                sequence = Utils.JList(el)
-            else:
-                # This case does NOT exist in Javascript! Why?
-                sequence = Utils.JList([el])
+            sequence = Utils.JList([el])
         else:
             sequence = Utils.JList()
         sequence.sequence = True
@@ -90,6 +86,28 @@ class Utils:
         sequence.sequence = True
         return sequence
 
+    @staticmethod
+    def is_deep_equal(lhs: Optional[Any], rhs: Optional[Any]) -> bool:
+        if isinstance(lhs, list) and isinstance(rhs, list):
+            if len(lhs) != len(rhs):
+                return False
+            for ii, _ in enumerate(lhs):
+                if not Utils.is_deep_equal(lhs[ii], rhs[ii]):
+                    return False
+            return True
+        elif isinstance(lhs, dict) and isinstance(rhs, dict):
+            if lhs.keys() != rhs.keys():
+                return False
+            for key in lhs.keys():
+                if not Utils.is_deep_equal(lhs[key], rhs[key]):
+                    return False
+            return True
+        if lhs == rhs:
+            if isinstance(lhs, bool) != isinstance(rhs, bool):
+                return False
+            return True
+        return False
+
     class JList(list):
         sequence: bool
         outer_wrapper: bool

jsonata_python-0.6.2/tests/array_test.py

@@ -0,0 +1,40 @@
+import jsonata
+import pytest
+
+
+class TestArray:
+
+    def test_negative_index(self):
+        expr = jsonata.Jsonata("item[-1]")
+        assert expr.evaluate({"item": []}) is None
+        expr = jsonata.Jsonata("$[-1]")
+        assert expr.evaluate([]) is None
+
+    def test_array(self):
+        assert jsonata.Jsonata("$.[{ }] ~> $reduce($append)").evaluate([True, True]) == [{}, {}]
+
+    def test_wildcard(self):
+        expr = jsonata.Jsonata("*")
+        assert expr.evaluate([{"x": 1}]) == {"x": 1}
+
+    def test_index(self):
+        expr = jsonata.Jsonata("($x:=['a','b']; $x#$i.$i)")
+        assert expr.evaluate(1) == [0, 1]
+        assert expr.evaluate(None) == [0, 1]
+
+    def test_wildcard_filter(self):
+        value1 = {"value": {"Name": "Cell1", "Product": "Product1"}}
+        value2 = {"value": {"Name": "Cell2", "Product": "Product2"}}
+        data = [value1, value2]
+
+        expression = jsonata.Jsonata("*[value.Product = 'Product1']")
+        assert expression.evaluate(data) == value1
+
+        expression2 = jsonata.Jsonata("**[value.Product = 'Product1']")
+        assert expression2.evaluate(data) == value1
+
+    def test_assert_custom_message(self):
+        expr = jsonata.Jsonata("$assert(false, 'custom error')")
+        with pytest.raises(jsonata.JException) as exc_info:
+            expr.evaluate(None)
+        assert "custom error" in str(exc_info.value)

{jsonata_python-0.6.0 → jsonata_python-0.6.2}/tests/signature_test.py

@@ -7,7 +7,7 @@ class TestSignature:
     def test_parameters_are_converted_to_arrays(self):
         expr = jsonata.Jsonata("$greet(1,null,3)")
         expr.register_function("greet", jsonata.Jsonata.JFunction(TestSignature.JFunctionCallable1(), "<a?a?a?a?:s>"))
-        assert expr.evaluate(None) == "[[1], [null], [3], [None]]"
+        assert expr.evaluate(None) == "[[1], None, [3], None]"
 
     class JFunctionCallable1(jsonata.Jsonata.JFunctionCallable):
 
@@ -30,3 +30,13 @@ class TestSignature:
 
         def call(self, input, args):
             return None
+
+    def test_var_arg_many(self):
+        expr = jsonata.Jsonata("$customArgs('test',[1,2,3,4],3)")
+        expr.register_function("customArgs", jsonata.Jsonata.JFunction(TestSignature.JFunctionCallable3(), "<sa<n>n:s>"))
+        assert expr.evaluate(None) == "['test', [1, 2, 3, 4], 3]"
+
+    class JFunctionCallable3(jsonata.Jsonata.JFunctionCallable):
+
+        def call(self, input, args):
+            return str(args)

{jsonata_python-0.6.0 → jsonata_python-0.6.2}/tests/string_test.py

@@ -42,6 +42,33 @@ class TestString:
         assert (jsonata.Jsonata("($matcher := $eval('/^' & 'foo' & '/i'); $.$spread()[$.$keys() ~> $matcher])")
                 .evaluate({"foo": 1, "bar": 2}) == {"foo": 1})
 
+    def test_regex_literal(self):
+        expr = jsonata.Jsonata("/^test.*$/")
+        result = expr.evaluate(None)
+        assert result.pattern == "^test.*$"
+
+    def test_eval_regex(self):
+        expr = jsonata.Jsonata("$eval('/^test.*$/')")
+        result = expr.evaluate(None)
+        assert result.pattern == "^test.*$"
+
+    def test_eval_regex_check_answer_data(self):
+        expr = jsonata.Jsonata("(\n    $matcher := $eval('/l/');\n    ('Hello World' ~> $matcher);\n)")
+        result = expr.evaluate(None)
+        assert result["match"] == "l"
+        assert result["start"] == 2
+        assert result["end"] == 3
+        assert result["groups"] == ["l"]
+        assert callable(result["next"].function)
+
+    def test_eval_regex_call_next_and_check_result(self):
+        expr = jsonata.Jsonata("(\n    $matcher := $eval('/l/');\n    ('Hello World' ~> $matcher).next();\n)")
+        result = expr.evaluate(None)
+        assert result["match"] == "l"
+        assert result["start"] == 3
+        assert result["end"] == 4
+        assert result["groups"] == ["l"]
+
     #
     # Additional $split tests
     #   
@@ -84,6 +111,11 @@ class TestString:
         res = jsonata.Jsonata("$split('this.*.*is.*a.*test.*.*.*.*.*.*', /\\.\\*/, 8)").evaluate(None)
         assert res == ["this", "", "is", "a", "test", "", "", ""]
 
+    def test_fieldname_with_special_char(self):
+        expr = jsonata.Jsonata("$ ~> |$|{}|")
+        o = {"a\nb": "c\nd"}
+        assert expr.evaluate(o) == o
+
     def test_trim(self):
         assert jsonata.Jsonata("$trim(\"\n\")").evaluate(None) == ""
         assert jsonata.Jsonata("$trim(\" \")").evaluate(None) == ""