copilot feedback

Author: rayokota

src/jsonata/functions.py

@@ -474,7 +474,11 @@ def left_pad(string: Optional[str], size: Optional[int], pad_str: Optional[str])
         pads = size - str_len
         if pads <= 0:
             return string
-        padding = pad_str * (pads // len(pad_str) + 1)
+        padding = ""
+        i = 0
+        while i < pads + 1:
+            padding += pad_str
+            i += 1
         return Functions.substr(padding, 0, pads) + string
 
     # Source: Jsonata4Java PadFunction
@@ -497,7 +501,11 @@ def right_pad(string: Optional[str], size: Optional[int], pad_str: Optional[str]
         pads = size - str_len
         if pads <= 0:
             return string
-        padding = pad_str * (pads // len(pad_str) + 1)
+        padding = ""
+        i = 0
+        while i < pads + 1:
+            padding += pad_str
+            i += 1
         return string + Functions.substr(padding, 0, pads)
 
     @dataclass
@@ -549,7 +557,7 @@ def contains(string: Optional[str], token: Union[None, str, re.Pattern]) -> Opti
 
         if isinstance(token, str):
             result = (string.find(str(token)) != - 1)
-        elif Functions.is_regex(token):
+        elif isinstance(token, re.Pattern):
             matches = Functions.evaluate_matcher(token, string)
             # if (dbg) System.out.println("match = "+matches)
             # result = (typeof matches !== 'undefined')
@@ -647,7 +655,7 @@ def safe_replace_all(s: str, pattern: re.Pattern, replacement: Optional[Any]) ->
         r = None
         for i in range(0, 10):
             try:
-                r = pattern.sub(replacement, s)
+                r = re.sub(pattern, replacement, s)
                 break
             except Exception as e:
                 msg = str(e)
@@ -704,7 +712,7 @@ def replace_fn(t):
             else:
                 raise jexception.JException("D3012", -1)
 
-        r = pattern.sub(replace_fn, s)
+        r = re.sub(pattern, replace_fn, s)
         return r
 
     #
@@ -721,7 +729,7 @@ def safe_replace_first(s: str, pattern: re.Pattern, replacement: str) -> Optiona
         r = None
         for i in range(0, 10):
             try:
-                r = pattern.sub(replacement, s, count=1)
+                r = re.sub(pattern, replacement, s, count=1)
                 break
             except Exception as e:
                 msg = str(e)
@@ -759,39 +767,39 @@ def replace(string: Optional[str], pattern: Union[str, re.Pattern], replacement:
             raise jexception.JException("Fourth argument of replace function must evaluate to a positive number", 0)
 
         def string_replacer(match):
-            parts = []
+            result = ''
             position = 0
             repl = str(replacement)
             while position < len(repl):
                 index = repl.find('$', position)
                 if index == -1:
-                    parts.append(repl[position:])
+                    result += repl[position:]
                     break
-                parts.append(repl[position:index])
+                result += repl[position:index]
                 position = index + 1
                 if position < len(repl):
                     dollar_val = repl[position]
                     if dollar_val == '$':
-                        parts.append('$')
+                        result += '$'
                         position += 1
                     elif dollar_val == '0':
-                        parts.append(match.group(0))
+                        result += match.group(0)
                         position += 1
                     else:
                         max_digits = len(str(len(match.groups())))
                         group_num = repl[position:position+max_digits]
                         if group_num.isdigit():
                             group_index = int(group_num)
                             if 0 < group_index <= len(match.groups()):
-                                parts.append(match.group(group_index) or '')
+                                result += match.group(group_index) or ''
                                 position += len(group_num)
                             else:
-                                parts.append('$')
+                                result += '$'
                         else:
-                            parts.append('$')
+                            result += '$'
                 else:
-                    parts.append('$')
-            return ''.join(parts)
+                    result += '$'
+            return result
 
         if callable(replacement):
             replacer = lambda m: replacement(m.groupdict())
@@ -802,23 +810,23 @@ def string_replacer(match):
 
         if isinstance(pattern, str):
             # Use string methods for literal string patterns
-            parts = []
+            result = ''
             position = 0
             count = 0
             while True:
                 if limit is not None and count >= limit:
-                    parts.append(string[position:])
+                    result += string[position:]
                     break
                 index = string.find(pattern, position)
                 if index == -1:
-                    parts.append(string[position:])
+                    result += string[position:]
                     break
-                parts.append(string[position:index])
+                result += string[position:index]
                 match = re.match(re.escape(pattern), string[index:])
-                parts.append(replacer(match))
+                result += replacer(match)
                 position = index + len(pattern)
                 count += 1
-            return ''.join(parts)
+            return result
         else:
             # Use regex for pattern objects
             if limit is None:
@@ -1836,8 +1844,7 @@ def each(obj: Optional[Mapping], func: Any) -> Optional[list]:
     #     
     @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")
 
     #
     #
@@ -1852,8 +1859,8 @@ def assert_fn(condition: Optional[bool], message: Optional[str]) -> None:
             raise jexception.JException("T0410", -1)
 
         if not condition:
-            raise jexception.JException("D3141", -1,
-                                        message if message is not None else "$assert() statement failed")
+            raise jexception.JException("D3141", -1, "$assert() statement failed")
+            #                message: message || "$assert() statement failed"
 
     #
     #
@@ -2019,22 +2026,6 @@ def append(arg1: Optional[Any], arg2: Optional[Any]) -> Optional[Any]:
     def is_lambda(result: Optional[Any]) -> bool:
         return isinstance(result, parser.Parser.Symbol) and result._jsonata_lambda
 
-    #
-    # Tests whether a value is a compiled regex, from the stdlib re module
-    # or from a pluggable regex_engine (e.g. re2) with a compatible interface.
-    #
-    @staticmethod
-    def is_regex(value: Optional[Any]) -> bool:
-        if isinstance(value, re.Pattern):
-            return True
-        if value is None or inspect.ismodule(value) or inspect.isclass(value):
-            return False
-        return (
-            callable(getattr(value, "search", None))
-            and callable(getattr(value, "finditer", None))
-            and callable(getattr(value, "sub", None))
-        )
-
     #
     # Return value from an object for a given key
     # @param {Object} input - Object/Array
@@ -2116,6 +2107,8 @@ def datetime_to_millis(timestamp: Optional[str], picture: Optional[str]) -> Opti
                 dt = datetime.datetime.fromisoformat(timestamp)
             if dt.tzinfo is None:
                 dt = dt.replace(tzinfo=datetime.timezone.utc)
+            else:
+                dt = dt.astimezone(datetime.timezone.utc)
             return int(dt.timestamp() * 1000)
             # try:
             #     size = len(timestamp)
@@ -2217,7 +2210,7 @@ def function_eval(expr: Optional[str], focus: Optional[Any]) -> Optional[Any]:
 
         ast = None
         try:
-            ast = jsonata.Jsonata(expr, jsonata.Jsonata.CURRENT.jsonata.regex_engine)
+            ast = jsonata.Jsonata(expr)
         except Exception as err:
             # error parsing the expression passed to $eval
             # populateMessage(err)