odin-foundation 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 73fe064a2bdc58380f03167913ebea10dce6c722a8b0b2b30703134b28f4ce2e
-  data.tar.gz: c60ca22db57be40b617169266dbd97c0e3e181674eaf1e5ec57796fc24729635
+  metadata.gz: a42b39245e4ab2f8821e0e12100d16418316b22758071d7acf28db0b7a754f20
+  data.tar.gz: 99f7bc6624af35e90864f3ccc1239eb2c3c8ab1cd1a50bcd5daffdca36655e98
 SHA512:
-  metadata.gz: 3495932fb340947ca0bc35a381557d5b1bf55e18d50150b9117ae073965faeb2dac8f23eedbcc0fdf8058013288b819aa41da3cf1436418819bc941847018064
-  data.tar.gz: 2d01979d2e392f6ed40b84a2626b2056d9fda8b281f1cfe6978604f7ae0359b7882db6c2465555cc272337560b010fe1d018f2fcf773647ab0da126a296e0652
+  metadata.gz: 00027a7160bb7e6605bdbb3e77e2ea54232147902027cdc98d3dccc6b6ce06635563d4ca84698a12a3325d29b1310e88355911dcd0c75099ad13ba35eef84a64
+  data.tar.gz: 4ad5366860defb9e19affa8f666eccd4d3d6bd3a9cba539131bb189987c9b878a6217cb60260bb58ff03660e71d4bb3865eb77fed4bb4ff47a3e01124f4621fb

data/lib/odin/transform/transform_engine.rb

@@ -1105,9 +1105,10 @@ module Odin
       def process_mapping(mapping, source, context, output, modifier_prefix: "")
         target = mapping.target_field
 
-        # Handle _pass directive and other underscore-prefixed targets
-        # but still evaluate `_` (bare underscore) for side effects like accumulate
-        if target == "_"
+        # An unrecognized `_`-prefixed target is a computation-only sink: it runs
+        # for side effects (accumulators, counters) but is never emitted. This
+        # lets several %accumulate/%set advance in one loop pass.
+        if target.start_with?("_")
           begin
             evaluate(mapping.expression, context)
           rescue StandardError => e
@@ -1115,7 +1116,6 @@ module Odin
           end
           return
         end
-        return if target.start_with?("_")
 
         begin
           mods = mapping_mods(mapping)
@@ -1532,17 +1532,10 @@ module Odin
         verb_name = expr.verb_name
         args = expr.arguments
 
-        # Lazy evaluation for conditional verbs — apply extraction to result
-        case verb_name
-        when "ifElse"
-          val = evaluate_if_else(args, context)
-          return apply_extraction_directives(val, extraction_directives)
-        when "cond"
-          val = evaluate_cond(args, context)
-          return apply_extraction_directives(val, extraction_directives)
-        when "switch"
-          val = evaluate_switch(args, context)
-          return apply_extraction_directives(val, extraction_directives)
+        # Lazy evaluation for control-flow verbs — apply extraction to result.
+        if !context.strict_types && LAZY_VERBS.include?(verb_name) && !(expr.respond_to?(:custom) && expr.custom)
+          handled, val = evaluate_lazy_verb(verb_name, args, context)
+          return apply_extraction_directives(val, extraction_directives) if handled
         end
 
         # Eager evaluation: apply extraction directives to CopyExpr arguments
@@ -1579,18 +1572,19 @@ module Odin
         invoke_verb(verb_name, evaluated_args, context)
       end
 
+      # Control-flow verbs that evaluate the condition first and run only the
+      # selected branch; and/or/coalesce short-circuit. Strict-types mode
+      # evaluates eagerly so every argument is validated.
+      LAZY_VERBS = %w[ifElse ifNull ifEmpty coalesce and or cond switch].freeze
+
       def evaluate_verb(expr, context)
         verb_name = expr.verb_name
         args = expr.arguments
 
-        # Lazy evaluation for conditional verbs
-        case verb_name
-        when "ifElse"
-          return evaluate_if_else(args, context)
-        when "cond"
-          return evaluate_cond(args, context)
-        when "switch"
-          return evaluate_switch(args, context)
+        # Lazy evaluation for control-flow verbs (skipped under strict types).
+        if !context.strict_types && LAZY_VERBS.include?(verb_name) && !(expr.respond_to?(:custom) && expr.custom)
+          handled, value = evaluate_lazy_verb(verb_name, args, context)
+          return value if handled
         end
 
         # Eager evaluation for all other verbs
@@ -1618,6 +1612,49 @@ module Odin
         invoke_verb(verb_name, evaluated_args, context)
       end
 
+      # Dispatch a lazy control-flow verb. Returns [handled, value]; handled is
+      # false when arity is too low, so the caller falls back to eager paths.
+      def evaluate_lazy_verb(verb_name, args, context)
+        ev = ->(i) { evaluate(args[i], context) }
+        case verb_name
+        when "ifElse"
+          return [false, Types::DynValue.of_null] if args.length < 3
+          [true, ev.call(0).truthy? ? ev.call(1) : ev.call(2)]
+        when "ifNull"
+          return [false, Types::DynValue.of_null] if args.length < 2
+          v0 = ev.call(0)
+          [true, v0.null? ? ev.call(1) : v0]
+        when "ifEmpty"
+          return [false, Types::DynValue.of_null] if args.length < 2
+          v0 = ev.call(0)
+          [true, lazy_empty?(v0) ? ev.call(1) : v0]
+        when "coalesce"
+          args.each_index do |i|
+            v = ev.call(i)
+            return [true, v] unless v.null?
+          end
+          [true, Types::DynValue.of_null]
+        when "and"
+          return [false, Types::DynValue.of_null] if args.length < 2
+          return [true, Types::DynValue.of_bool(false)] unless ev.call(0).truthy?
+          [true, Types::DynValue.of_bool(ev.call(1).truthy?)]
+        when "or"
+          return [false, Types::DynValue.of_null] if args.length < 2
+          return [true, Types::DynValue.of_bool(true)] if ev.call(0).truthy?
+          [true, Types::DynValue.of_bool(ev.call(1).truthy?)]
+        when "cond"
+          [true, evaluate_cond(args, context)]
+        when "switch"
+          [true, evaluate_switch(args, context)]
+        else
+          [false, Types::DynValue.of_null]
+        end
+      end
+
+      def lazy_empty?(v)
+        v.nil? || v.null? || (v.string? && v.value.empty?)
+      end
+
       def evaluate_if_else(args, context)
         return Types::DynValue.of_null if args.length < 3
 
@@ -2735,6 +2772,31 @@ module Odin
          .gsub("'", "&apos;")
       end
 
+      # True when every backslash escape in a JSON string body is well-formed.
+      def valid_json_escapes?(s)
+        i = 0
+        len = s.length
+        while i < len
+          if s[i] == "\\"
+            i += 1
+            return false if i >= len
+            case s[i]
+            when "\"", "\\", "/", "b", "f", "n", "r", "t"
+              i += 1
+            when "u"
+              hex = s[(i + 1), 4]
+              return false if hex.nil? || hex.length < 4 || hex !~ /\A[0-9a-fA-F]{4}\z/
+              i += 5
+            else
+              return false
+            end
+          else
+            i += 1
+          end
+        end
+        true
+      end
+
       # ── Verb Registry ──
 
       def build_verb_registry
@@ -2751,6 +2813,7 @@ module Odin
         Verbs::AggregationVerbs.register(registry)
         Verbs::ObjectVerbs.register(registry)
         Verbs::GeoVerbs.register(registry)
+        Verbs::ExtraVerbs.register(registry)
 
         registry
       end
@@ -2824,7 +2887,19 @@ module Odin
         # Type checks
         registry["typeOf"] = ->(args, _ctx) {
           v = args[0]
-          type_str = v.nil? ? "null" : v.type.to_s
+          type_str =
+            if v.nil?
+              "null"
+            else
+              {
+                null: "null", bool: "boolean", integer: "integer",
+                float: "number", float_raw: "number", string: "string",
+                array: "array", object: "object", date: "date",
+                timestamp: "timestamp", time: "time", duration: "duration",
+                currency: "currency", currency_raw: "currency", percent: "percent",
+                reference: "reference", binary: "binary"
+              }.fetch(v.type, "unknown")
+            end
           Types::DynValue.of_string(type_str)
         }
         registry["isString"] = ->(args, _ctx) { Types::DynValue.of_bool(args[0]&.string? || false) }
@@ -2836,9 +2911,9 @@ module Odin
 
         # Coercion
         registry["coerceString"] = ->(args, _ctx) { Types::DynValue.of_string(args[0]&.to_string || "") }
-        registry["coerceNumber"] = ->(args, _ctx) { Types::DynValue.of_float(args[0]&.to_number&.to_f || 0.0) }
-        registry["coerceInteger"] = ->(args, _ctx) { Types::DynValue.of_integer(args[0]&.to_number&.to_i || 0) }
-        registry["coerceBoolean"] = ->(args, _ctx) { Types::DynValue.of_bool(args[0]&.truthy? || false) }
+        registry["coerceNumber"] = ->(args, _ctx) { Verbs::NumericVerbs.numeric_result(Verbs::NumericVerbs.to_number(args[0])) }
+        registry["coerceInteger"] = ->(args, _ctx) { Types::DynValue.of_integer(Verbs::NumericVerbs.to_number(args[0]).floor) }
+        registry["coerceBoolean"] = ->(args, _ctx) { Types::DynValue.of_bool(Verbs::NumericVerbs.coerce_boolean(args[0])) }
 
         # Arithmetic
         registry["add"] = ->(args, _ctx) {
@@ -3126,19 +3201,20 @@ module Odin
           Types::DynValue.of_bool(args[0]&.truthy? || args[1]&.truthy?)
         }
 
-        # Comparison
-        registry["lt"] = ->(args, _ctx) {
-          Types::DynValue.of_bool((args[0]&.to_number || 0) < (args[1]&.to_number || 0))
-        }
-        registry["lte"] = ->(args, _ctx) {
-          Types::DynValue.of_bool((args[0]&.to_number || 0) <= (args[1]&.to_number || 0))
-        }
-        registry["gt"] = ->(args, _ctx) {
-          Types::DynValue.of_bool((args[0]&.to_number || 0) > (args[1]&.to_number || 0))
-        }
-        registry["gte"] = ->(args, _ctx) {
-          Types::DynValue.of_bool((args[0]&.to_number || 0) >= (args[1]&.to_number || 0))
-        }
+        # Comparison: numeric when both coerce to numbers, else lexical.
+        compare = lambda do |a, b|
+          an = Verbs::NumericVerbs.to_double(a)
+          bn = Verbs::NumericVerbs.to_double(b)
+          if !an.nil? && !bn.nil?
+            an <=> bn
+          else
+            (a&.to_string || "") <=> (b&.to_string || "")
+          end
+        end
+        registry["lt"] = ->(args, _ctx) { Types::DynValue.of_bool(compare.call(args[0], args[1]) < 0) }
+        registry["lte"] = ->(args, _ctx) { Types::DynValue.of_bool(compare.call(args[0], args[1]) <= 0) }
+        registry["gt"] = ->(args, _ctx) { Types::DynValue.of_bool(compare.call(args[0], args[1]) > 0) }
+        registry["gte"] = ->(args, _ctx) { Types::DynValue.of_bool(compare.call(args[0], args[1]) >= 0) }
 
         # String operations
         registry["contains"] = ->(args, _ctx) {
@@ -3212,13 +3288,10 @@ module Odin
           end
         }
 
-        # Assertions
+        # Assertions: pass the value through when truthy, else null.
         registry["assert"] = ->(args, _ctx) {
           condition = args[0]
-          msg = args[1]&.to_string || "Assertion failed"
-          raise TransformError.new(msg) unless condition&.truthy?
-
-          Types::DynValue.of_bool(true)
+          condition&.truthy? ? condition : Types::DynValue.of_null
         }
 
         # Switch/cond handled via lazy evaluation in evaluate_verb
@@ -3266,16 +3339,24 @@ module Odin
         }
 
         registry["titleCase"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
-          Types::DynValue.of_string(s.gsub(/\b\w/) { |m| m.upcase })
+          v = args[0]
+          next Types::DynValue.of_null if v.nil? || v.null?
+          s = v.to_string
+          next Types::DynValue.of_string("") if s.empty?
+          result = s.split(/\s+/).map { |w| w.empty? ? "" : w[0].upcase + w[1..].downcase }.join(" ")
+          Types::DynValue.of_string(result)
         }
 
         registry["slugify"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
+          v = args[0]
+          next Types::DynValue.of_null if v.nil? || v.null?
+          s = v.to_string
+          next Types::DynValue.of_string("") if s.empty?
           result = s.downcase
-                    .gsub(/[^a-z0-9\s-]/, "")
-                    .strip
-                    .gsub(/[\s-]+/, "-")
+                    .gsub(/[^a-z0-9_\s-]/, "")
+                    .gsub(/[\s_]+/, "-")
+                    .gsub(/-+/, "-")
+                    .gsub(/\A-+|-+\z/, "")
           Types::DynValue.of_string(result)
         }
 
@@ -3352,12 +3433,15 @@ module Odin
         }
 
         registry["split"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
-          delimiter = args[1]&.to_string || ","
-          parts = s.split(delimiter, -1)
-          # If a third argument (index) is provided, return that element
+          v = args[0]
+          next Types::DynValue.of_null if v.nil? || v.null?
+          s = v.to_string
+          delimiter = args[1]&.to_string || ""
+          parts = delimiter.empty? ? [s] : s.split(delimiter, -1)
+          # If a third argument (index) is provided, return that element.
           if args[2] && !args[2].null?
-            idx = args[2].to_number&.to_i || 0
+            idx = Verbs::NumericVerbs.to_double(args[2])&.to_i || 0
+            idx += parts.length if idx < 0
             if idx >= 0 && idx < parts.length
               Types::DynValue.of_string(parts[idx])
             else
@@ -3388,12 +3472,14 @@ module Odin
         }
 
         registry["match"] = ->(args, _ctx) {
+          next Types::DynValue.of_null if args.length < 2
           s = args[0]&.to_string || ""
           pattern = args[1]&.to_string || ""
           begin
+            next Types::DynValue.of_null if pattern.length > 256 || s.length > 100_000
             Types::DynValue.of_bool(!!(s =~ Regexp.new(pattern)))
           rescue RegexpError
-            Types::DynValue.of_bool(false)
+            Types::DynValue.of_null
           end
         }
         registry["matches"] = registry["match"]
@@ -3437,20 +3523,24 @@ module Odin
         }
 
         registry["repeat"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
-          count = args[1]&.to_number&.to_i || 0
-          count = 0 if count < 0
-          Types::DynValue.of_string(s * count)
+          v = args[0]
+          next Types::DynValue.of_null if v.nil? || v.null?
+          count = Verbs::NumericVerbs.to_double(args[1])&.to_i
+          next Types::DynValue.of_null if count.nil? || count < 0
+          count = 100_000 if count > 100_000
+          Types::DynValue.of_string(v.to_string * count)
         }
 
         registry["replaceRegex"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
+          next Types::DynValue.of_null if args.length < 3 || args[0].nil? || args[0].null?
+          s = args[0].to_string
           pattern = args[1]&.to_string || ""
           replacement = args[2]&.to_string || ""
           begin
+            next Types::DynValue.of_null if pattern.length > 256 || s.length > 100_000
             Types::DynValue.of_string(s.gsub(Regexp.new(pattern), replacement))
           rescue RegexpError
-            Types::DynValue.of_string(s)
+            Types::DynValue.of_null
           end
         }
 
@@ -3531,10 +3621,17 @@ module Odin
         }
 
         registry["base64Decode"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
+          v = args[0]
+          next Types::DynValue.of_null if v.nil? || v.null?
+          s = v.to_string.tr("-_", "+/")
+          pad = (4 - s.length % 4) % 4
+          s += "=" * pad
           require "base64"
           begin
-            Types::DynValue.of_string(Base64.strict_decode64(s))
+            decoded = Base64.strict_decode64(s)
+            decoded.force_encoding("UTF-8")
+            next Types::DynValue.of_null unless decoded.valid_encoding?
+            Types::DynValue.of_string(decoded)
           rescue ArgumentError
             Types::DynValue.of_null
           end
@@ -3546,42 +3643,67 @@ module Odin
         }
 
         registry["hexDecode"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
-          begin
-            Types::DynValue.of_string([s].pack("H*"))
-          rescue ArgumentError
-            Types::DynValue.of_null
-          end
+          v = args[0]
+          next Types::DynValue.of_null if v.nil? || v.null?
+          s = v.to_string
+          next Types::DynValue.of_null if s.length.odd? || s.match?(/[^0-9a-fA-F]/)
+          decoded = [s].pack("H*")
+          decoded.force_encoding("UTF-8")
+          next Types::DynValue.of_null unless decoded.valid_encoding?
+          Types::DynValue.of_string(decoded)
         }
 
         registry["urlEncode"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
+          v = args[0]
+          next Types::DynValue.of_null if v.nil? || v.null?
           require "uri"
-          Types::DynValue.of_string(URI.encode_www_form_component(s).gsub("+", "%20"))
+          Types::DynValue.of_string(URI.encode_www_form_component(v.to_string, "UTF-8").gsub("+", "%20").gsub("%7E", "~"))
         }
 
         registry["urlDecode"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
+          v = args[0]
+          next Types::DynValue.of_null if v.nil? || v.null?
+          s = v.to_string
+          # Reject malformed percent-encoding (% not followed by two hex digits).
+          next Types::DynValue.of_null if s.scan(/%(..?|.?)/).any? { |seq| seq[0].length != 2 || seq[0].match?(/[^0-9a-fA-F]/) }
           require "uri"
           begin
-            Types::DynValue.of_string(URI.decode_www_form_component(s))
+            decoded = URI.decode_www_form_component(s, "UTF-8")
+            next Types::DynValue.of_null unless decoded.valid_encoding?
+            Types::DynValue.of_string(decoded)
           rescue ArgumentError
-            Types::DynValue.of_string(s)
+            Types::DynValue.of_null
           end
         }
 
         registry["jsonEncode"] = ->(args, _ctx) {
           v = args[0]
+          next Types::DynValue.of_null if v.nil? || v.null?
           require "json"
-          Types::DynValue.of_string(v.nil? || v.null? ? "null" : JSON.generate(v.to_ruby))
+          if v.object? || v.array?
+            next Types::DynValue.of_string(JSON.generate(v.to_ruby))
+          end
+          # Scalars: JSON-escape the string and drop the surrounding quotes.
+          encoded = JSON.generate(v.to_string)
+          Types::DynValue.of_string(encoded[1...-1])
         }
 
         registry["jsonDecode"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
+          v = args[0]
+          next Types::DynValue.of_null if v.nil? || v.null?
+          s = v.to_string
           require "json"
+          if s.start_with?("{", "[")
+            begin
+              parsed = JSON.parse(s)
+              next Types::DynValue.from_ruby(parsed) if parsed.is_a?(Hash) || parsed.is_a?(Array)
+            rescue JSON::ParserError
+            end
+          end
+          # Unescape as a JSON string; an invalid escape yields null.
+          next Types::DynValue.of_null unless valid_json_escapes?(s)
           begin
-            parsed = JSON.parse(s)
-            Types::DynValue.from_ruby(parsed)
+            Types::DynValue.of_string(JSON.parse("\"#{s}\""))
           rescue JSON::ParserError
             Types::DynValue.of_null
           end
@@ -3678,13 +3800,38 @@ module Odin
         registry["coerceDate"] = ->(args, _ctx) {
           v = args[0]
           return Types::DynValue.of_null if v.nil? || v.null?
+          return v if v.type == :date
+          if v.type == :timestamp
+            s = v.to_string
+            s = s[0...s.index("T")] if s.include?("T")
+            next Types::DynValue.of_date(s)
+          end
+
           s = v.to_string.strip
-          begin
-            d = Date.parse(s)
-            Types::DynValue.of_date(d.strftime("%Y-%m-%d"))
-          rescue ArgumentError, TypeError
-            Types::DynValue.of_null
+          next Types::DynValue.of_null if s.empty?
+
+          valid_ymd = ->(y, mo, d) { mo.between?(1, 12) && d >= 1 && Date.valid_date?(y, mo, d) }
+
+          # yyyy-MM-dd prefix
+          if s.length >= 10 && s[4] == "-" && s[7] == "-" &&
+             s[0, 4] =~ /\A\d{4}\z/ && s[5, 2] =~ /\A\d{2}\z/ && s[8, 2] =~ /\A\d{2}\z/
+            next Types::DynValue.of_date(s[0, 10])
           end
+
+          # Compact YYYYMMDD
+          if (m = s.match(/\A(\d{4})(\d{2})(\d{2})\z/))
+            y, mo, d = m[1].to_i, m[2].to_i, m[3].to_i
+            next valid_ymd.call(y, mo, d) ? Types::DynValue.of_date(format("%04d-%02d-%02d", y, mo, d)) : Types::DynValue.of_null
+          end
+
+          # Slash MM/DD/YYYY (US), or DD/MM/YYYY when first > 12
+          if (m = s.match(%r{\A(\d{1,2})/(\d{1,2})/(\d{4})\z}))
+            first, second, y = m[1].to_i, m[2].to_i, m[3].to_i
+            mo, d = first > 12 ? [second, first] : [first, second]
+            next valid_ymd.call(y, mo, d) ? Types::DynValue.of_date(format("%04d-%02d-%02d", y, mo, d)) : Types::DynValue.of_null
+          end
+
+          Types::DynValue.of_null
         }
 
         registry["coerceTimestamp"] = ->(args, _ctx) {
@@ -3715,23 +3862,19 @@ module Odin
         registry["toObject"] = ->(args, _ctx) {
           v = args[0]
           if v.nil? || v.null?
-            Types::DynValue.of_object({})
+            Types::DynValue.of_null
           elsif v.object?
             v
           elsif v.array?
             items = v.value || []
-            pairs = items.map { |item| to_object_pair(item) }
-            if !items.empty? && pairs.all?
-              obj = {}
-              pairs.each { |k, val| obj[k] = val }
-              Types::DynValue.of_object(obj)
-            else
-              obj = {}
-              items.each_with_index { |item, i| obj[i.to_s] = item }
-              Types::DynValue.of_object(obj)
+            obj = {}
+            items.each do |item|
+              pair = to_object_pair(item)
+              obj[pair[0]] = pair[1] if pair
             end
+            obj.empty? ? Types::DynValue.of_null : Types::DynValue.of_object(obj)
           else
-            Types::DynValue.of_object({ "value" => v })
+            Types::DynValue.of_null
           end
         }
 
@@ -3795,11 +3938,8 @@ module Odin
           digits = raw.gsub(/\D/, "")
           formatted = case country
           when "US", "CA"
-            if digits.length == 10
-              "(#{digits[0..2]}) #{digits[3..5]}-#{digits[6..9]}"
-            elsif digits.length == 11 && digits.start_with?("1")
-              "+1 (#{digits[1..3]}) #{digits[4..6]}-#{digits[7..10]}"
-            end
+            d = (digits.length == 11 && digits.start_with?("1")) ? digits[1..] : digits
+            "(#{d[0..2]}) #{d[3..5]}-#{d[6..9]}" if d.length == 10
           when "GB"
             if digits.length == 11 && digits.start_with?("0")
               "+44 #{digits[1..4]} #{digits[5..10]}"