odin-foundation 1.0.4 → 1.2.0

data/lib/odin/transform/transform_types.rb

@@ -58,15 +58,16 @@ module Odin
 
     # Transform definition — top-level AST node
     class TransformDef
-      attr_reader :header, :segments, :constants, :tables, :accumulators, :passes
+      attr_reader :header, :segments, :constants, :tables, :accumulators, :passes, :imports
 
-      def initialize(header:, segments: [], constants: {}, tables: {}, accumulators: {}, passes: [])
+      def initialize(header:, segments: [], constants: {}, tables: {}, accumulators: {}, passes: [], imports: [])
         @header = header
         @segments = segments
         @constants = constants
         @tables = tables
         @accumulators = accumulators
         @passes = passes
+        @imports = imports
       end
 
       def direction
@@ -92,7 +93,7 @@ module Odin
     class TransformHeader
       attr_reader :odin_version, :transform_version, :direction,
                   :target_format, :enforce_confidential,
-                  :source_options, :target_options,
+                  :source_options, :target_options, :target_namespaces,
                   :strict_types, :id, :name
 
       def initialize(
@@ -103,6 +104,7 @@ module Odin
         enforce_confidential: ConfidentialMode::NONE,
         source_options: {},
         target_options: {},
+        target_namespaces: {},
         strict_types: false,
         id: nil,
         name: nil
@@ -114,6 +116,7 @@ module Odin
         @enforce_confidential = enforce_confidential
         @source_options = source_options
         @target_options = target_options
+        @target_namespaces = target_namespaces
         @strict_types = strict_types
         @id = id
         @name = name
@@ -125,7 +128,9 @@ module Odin
       attr_reader :name, :path, :array_index,
                   :field_mappings, :discriminator, :discriminator_value,
                   :when_condition, :each_source, :if_condition,
-                  :children, :pass, :counter_name, :is_array
+                  :elif_condition, :is_else,
+                  :children, :pass, :counter_name, :is_array,
+                  :loops, :is_literal, :literal_body
 
       def initialize(
         name:,
@@ -137,10 +142,15 @@ module Odin
         when_condition: nil,
         each_source: nil,
         if_condition: nil,
+        elif_condition: nil,
+        is_else: false,
         children: [],
         pass: nil,
         counter_name: nil,
-        is_array: false
+        is_array: false,
+        loops: [],
+        is_literal: false,
+        literal_body: nil
       )
         @name = name
         @path = path
@@ -151,10 +161,15 @@ module Odin
         @when_condition = when_condition
         @each_source = each_source
         @if_condition = if_condition
+        @elif_condition = elif_condition
+        @is_else = is_else
         @children = children
         @pass = pass
         @counter_name = counter_name
         @is_array = is_array
+        @loops = loops
+        @is_literal = is_literal
+        @literal_body = literal_body
       end
     end
 
@@ -261,12 +276,13 @@ module Odin
 
     # Transform result
     class TransformResult
-      attr_reader :output, :formatted, :errors, :output_dv
+      attr_reader :output, :formatted, :errors, :warnings, :output_dv
 
-      def initialize(output:, formatted: nil, errors: [], output_dv: nil)
+      def initialize(output:, formatted: nil, errors: [], warnings: [], output_dv: nil)
         @output = output
         @formatted = formatted
         @errors = errors
+        @warnings = warnings
         @output_dv = output_dv
       end
 

data/lib/odin/transform/verb_context.rb

@@ -8,6 +8,7 @@ module Odin
                     :loop_index,      # Integer — current loop iteration (0-based)
                     :loop_length,     # Integer — total loop length
                     :loop_vars,       # Hash<String, DynValue> — named loop variables
+                    :aliases,         # Hash<String, DynValue> — :loop :as alias bindings
                     :accumulators,    # Hash<String, DynValue> — accumulator state
                     :tables,          # Hash<String, LookupTable> — lookup tables
                     :constants,       # Hash<String, DynValue> — constant values
@@ -16,7 +17,12 @@ module Odin
                     :loop_depth,      # Integer — nesting depth for security
                     :field_modifiers, # Hash<String, Array<Symbol>> — tracked field modifiers
                     :errors,          # Array<TransformEngine::TransformError> — collected errors
-                    :source_format    # String — source format for directive handling
+                    :warnings,        # Array<String> — collected warnings
+                    :source_format,   # String — source format for directive handling
+                    :on_validation,   # String — validation policy (fail / warn / skip)
+                    :on_missing,      # String — missing-data policy (fail / warn / skip / default)
+                    :on_error,        # String — error policy (fail / warn / skip)
+                    :strict_types     # Boolean — enforce verb argument type signatures
 
       MAX_LOOP_DEPTH = 10
 
@@ -26,6 +32,7 @@ module Odin
         @loop_index = 0
         @loop_length = 0
         @loop_vars = {}
+        @aliases = {}
         @accumulators = {}
         @tables = {}
         @constants = {}
@@ -34,7 +41,12 @@ module Odin
         @loop_depth = 0
         @field_modifiers = {}
         @errors = []
+        @warnings = []
         @source_format = ""
+        @on_validation = nil
+        @on_missing = nil
+        @on_error = nil
+        @strict_types = false
       end
 
       def next_sequence(name)
@@ -72,6 +84,7 @@ module Odin
         ctx = VerbContext.new
         ctx.source = @source
         ctx.loop_vars = @loop_vars.dup
+        ctx.aliases = @aliases.dup
         ctx.accumulators = @accumulators # shared reference
         ctx.tables = @tables
         ctx.constants = @constants
@@ -80,6 +93,11 @@ module Odin
         ctx.loop_depth = @loop_depth + 1
         ctx.field_modifiers = @field_modifiers # shared reference
         ctx.errors = @errors # shared reference
+        ctx.warnings = @warnings # shared reference
+        ctx.source_format = @source_format
+        ctx.on_validation = @on_validation
+        ctx.on_missing = @on_missing
+        ctx.on_error = @on_error
         ctx
       end
     end

data/lib/odin/transform/verbs/aggregation_verbs.rb

@@ -52,7 +52,8 @@ module Odin
             items = CollectionVerbs.extract_items(args[0])
             nums = items.filter_map { |item| NumericVerbs.to_double(item) }
             return dv.of_null if nums.empty?
-            dv.of_float(nums.sum / nums.length.to_f)
+            total = nums.inject(0.0) { |s, v| s + v }
+            NumericVerbs.numeric_result(total / nums.length.to_f)
           }
 
           registry["first"] = ->(args, _ctx) {

data/lib/odin/transform/verbs/collection_verbs.rb

@@ -7,17 +7,22 @@ module Odin
         module_function
 
         def extract_items(v)
-          return [] if v.nil? || v.null?
+          as_items(v) || []
+        end
+
+        # Returns the underlying array items, or nil when v is not array-like.
+        def as_items(v)
+          return nil if v.nil? || v.null?
           return v.value if v.array?
           if v.string?
             begin
               parsed = Types::DynValue.extract_array(v.value)
-              return parsed.value
+              return parsed.value if parsed.array?
             rescue
-              return []
+              return nil
             end
           end
-          []
+          nil
         end
 
         def compare_dyn_values(a, b)
@@ -37,6 +42,24 @@ module Odin
           a.to_string == b.to_string
         end
 
+        # Field/operator/value condition matching used by find, findIndex, partition.
+        def matches_condition?(item, field, op, compare)
+          val = item.object? ? item.get(field) : item
+          val ||= Types::DynValue.of_null
+          case op
+          when "=", "==" then val.to_string == compare.to_string
+          when "!=", "<>" then val.to_string != compare.to_string
+          when "<" then (NumericVerbs.to_double(val) || 0) < (NumericVerbs.to_double(compare) || 0)
+          when "<=" then (NumericVerbs.to_double(val) || 0) <= (NumericVerbs.to_double(compare) || 0)
+          when ">" then (NumericVerbs.to_double(val) || 0) > (NumericVerbs.to_double(compare) || 0)
+          when ">=" then (NumericVerbs.to_double(val) || 0) >= (NumericVerbs.to_double(compare) || 0)
+          when "contains" then val.to_string.include?(compare.to_string)
+          when "startsWith" then val.to_string.start_with?(compare.to_string)
+          when "endsWith" then val.to_string.end_with?(compare.to_string)
+          else false
+          end
+        end
+
         def register(registry)
           dv = Types::DynValue
 
@@ -204,9 +227,15 @@ module Odin
           }
 
           registry["every"] = ->(args, _ctx) {
-            items = CollectionVerbs.extract_items(args[0])
+            items = CollectionVerbs.as_items(args[0])
+            return dv.of_null if items.nil?
             return dv.of_bool(true) if items.empty?
-            if args.length >= 2
+            if args.length >= 4
+              field = args[1]&.to_string || ""
+              op = args[2]&.to_string || "="
+              compare = args[3]
+              dv.of_bool(items.all? { |item| CollectionVerbs.matches_condition?(item, field, op, compare) })
+            elsif args.length >= 2
               field = args[1]&.to_string || ""
               dv.of_bool(items.all? { |item| (item.object? ? item.get(field) : item)&.truthy? || false })
             else
@@ -215,9 +244,15 @@ module Odin
           }
 
           registry["some"] = ->(args, _ctx) {
-            items = CollectionVerbs.extract_items(args[0])
+            items = CollectionVerbs.as_items(args[0])
+            return dv.of_null if items.nil?
             return dv.of_bool(false) if items.empty?
-            if args.length >= 2
+            if args.length >= 4
+              field = args[1]&.to_string || ""
+              op = args[2]&.to_string || "="
+              compare = args[3]
+              dv.of_bool(items.any? { |item| CollectionVerbs.matches_condition?(item, field, op, compare) })
+            elsif args.length >= 2
               field = args[1]&.to_string || ""
               dv.of_bool(items.any? { |item| (item.object? ? item.get(field) : item)&.truthy? || false })
             else
@@ -226,24 +261,24 @@ module Odin
           }
 
           registry["find"] = ->(args, _ctx) {
+            return dv.of_null if args.length < 4
+
             items = CollectionVerbs.extract_items(args[0])
-            if args.length >= 2
-              field = args[1]&.to_string || ""
-              found = items.find { |item| (item.object? ? item.get(field) : item)&.truthy? || false }
-            else
-              found = items.find(&:truthy?)
-            end
+            field = args[1]&.to_string || ""
+            op = args[2]&.to_string || "="
+            compare = args[3]
+            found = items.find { |item| CollectionVerbs.matches_condition?(item, field, op, compare) }
             found || dv.of_null
           }
 
           registry["findIndex"] = ->(args, _ctx) {
+            return dv.of_integer(-1) if args.length < 4
+
             items = CollectionVerbs.extract_items(args[0])
-            if args.length >= 2
-              field = args[1]&.to_string || ""
-              idx = items.index { |item| (item.object? ? item.get(field) : item)&.truthy? || false }
-            else
-              idx = items.index(&:truthy?)
-            end
+            field = args[1]&.to_string || ""
+            op = args[2]&.to_string || "="
+            compare = args[3]
+            idx = items.index { |item| CollectionVerbs.matches_condition?(item, field, op, compare) }
             dv.of_integer(idx || -1)
           }
 
@@ -254,73 +289,78 @@ module Odin
           }
 
           registry["concatArrays"] = ->(args, _ctx) {
+            extracted = args.map { |a| CollectionVerbs.as_items(a) }
+            return dv.of_null if extracted.all?(&:nil?)
             result = []
-            args.each do |a|
-              if a&.array?
-                result.concat(a.value)
-              elsif !a.nil? && !a.null?
-                result << a
-              end
-            end
+            extracted.each { |items| result.concat(items) if items }
             dv.of_array(result)
           }
 
           registry["zip"] = ->(args, _ctx) {
-            arrays = args.map { |a| CollectionVerbs.extract_items(a) }
-            return dv.of_array([]) if arrays.empty?
-            max_len = arrays.map(&:length).max || 0
-            result = (0...max_len).map do |i|
-              pair = arrays.map { |arr| i < arr.length ? arr[i] : dv.of_null }
-              dv.of_array(pair)
+            extracted = args.map { |a| CollectionVerbs.as_items(a) }
+            return dv.of_null if extracted.any?(&:nil?) || extracted.empty?
+            min_len = extracted.map(&:length).min || 0
+            result = (0...min_len).map do |i|
+              dv.of_array(extracted.map { |arr| arr[i] })
             end
             dv.of_array(result)
           }
 
           registry["groupBy"] = ->(args, _ctx) {
+            return dv.of_null if args.length < 2
+
             items = CollectionVerbs.extract_items(args[0])
             field = args[1]&.to_string || ""
             groups = {}
+            order = []
             items.each do |item|
               key = if item.object?
-                       (item.get(field) || dv.of_null).to_string
-                     else
-                       item.to_string
-                     end
-              groups[key] ||= []
+                      (item.get(field) || dv.of_null).to_string
+                    else
+                      item.to_string
+                    end
+              unless groups.key?(key)
+                groups[key] = []
+                order << key
+              end
               groups[key] << item
             end
-            obj = groups.transform_values { |v| dv.of_array(v) }
-            dv.of_object(obj)
+            result = order.map do |key|
+              dv.of_object({ "key" => dv.of_string(key), "items" => dv.of_array(groups[key]) })
+            end
+            dv.of_array(result)
           }
 
           registry["partition"] = ->(args, _ctx) {
+            return dv.of_null if args.length < 4
+
             items = CollectionVerbs.extract_items(args[0])
-            if args.length >= 2
-              field = args[1]&.to_string || ""
-              pass_items, fail_items = items.partition { |item| (item.object? ? item.get(field) : item)&.truthy? || false }
-            else
-              pass_items, fail_items = items.partition(&:truthy?)
-            end
+            field = args[1]&.to_string || ""
+            op = args[2]&.to_string || "="
+            compare = args[3]
+            pass_items, fail_items = items.partition { |item| CollectionVerbs.matches_condition?(item, field, op, compare) }
             dv.of_array([dv.of_array(pass_items), dv.of_array(fail_items)])
           }
 
           registry["take"] = ->(args, _ctx) {
-            items = CollectionVerbs.extract_items(args[0])
+            items = CollectionVerbs.as_items(args[0])
             n = NumericVerbs.to_double(args[1])&.to_i || 0
-            dv.of_array(items.first([n, 0].max))
+            return dv.of_null if items.nil? || n < 0
+            dv.of_array(items.first(n))
           }
           registry["limit"] = registry["take"]
 
           registry["drop"] = ->(args, _ctx) {
-            items = CollectionVerbs.extract_items(args[0])
+            items = CollectionVerbs.as_items(args[0])
             n = NumericVerbs.to_double(args[1])&.to_i || 0
-            dv.of_array(items.drop([n, 0].max))
+            return dv.of_null if items.nil? || n < 0
+            dv.of_array(items.drop(n))
           }
 
           registry["chunk"] = ->(args, _ctx) {
-            items = CollectionVerbs.extract_items(args[0])
+            items = CollectionVerbs.as_items(args[0])
             size = NumericVerbs.to_double(args[1])&.to_i || 1
-            size = 1 if size < 1
+            return dv.of_null if items.nil? || size < 1
             chunks = items.each_slice(size).map { |c| dv.of_array(c) }
             dv.of_array(chunks)
           }
@@ -360,21 +400,24 @@ module Odin
           }
 
           registry["compact"] = ->(args, _ctx) {
-            items = CollectionVerbs.extract_items(args[0])
+            items = CollectionVerbs.as_items(args[0])
+            return dv.of_null if items.nil?
             dv.of_array(items.reject { |item| item.null? || (item.string? && item.value.empty?) })
           }
 
-          registry["rowNumber"] = ->(args, ctx) {
-            name = "_rowNumber"
-            current = ctx.get_accumulator(name)
-            if current.null?
-              ctx.set_accumulator(name, dv.of_integer(1))
-              dv.of_integer(1)
-            else
-              next_val = current.to_number.to_i + 1
-              ctx.set_accumulator(name, dv.of_integer(next_val))
-              dv.of_integer(next_val)
+          registry["rowNumber"] = ->(args, _ctx) {
+            return dv.of_null if args.empty?
+
+            items = CollectionVerbs.extract_items(args[0])
+            result = items.each_with_index.map do |item, i|
+              num = dv.of_integer(i + 1)
+              if item.object?
+                dv.of_object({ "_rowNum" => num }.merge(item.value))
+              else
+                dv.of_object({ "_rowNum" => num, "value" => item })
+              end
             end
+            dv.of_array(result)
           }
 
           registry["sample"] = ->(args, _ctx) {
@@ -407,7 +450,8 @@ module Odin
           }
 
           registry["dedupe"] = ->(args, _ctx) {
-            items = CollectionVerbs.extract_items(args[0])
+            items = CollectionVerbs.as_items(args[0])
+            return dv.of_null if items.nil?
             field = args[1]&.to_string
             result = []
             last_key = nil
@@ -426,7 +470,8 @@ module Odin
           }
 
           registry["cumsum"] = ->(args, _ctx) {
-            items = CollectionVerbs.extract_items(args[0])
+            items = CollectionVerbs.as_items(args[0])
+            return dv.of_null if items.nil?
             sum = 0.0
             result = items.map do |item|
               n = NumericVerbs.to_double(item)
@@ -441,7 +486,8 @@ module Odin
           }
 
           registry["cumprod"] = ->(args, _ctx) {
-            items = CollectionVerbs.extract_items(args[0])
+            items = CollectionVerbs.as_items(args[0])
+            return dv.of_null if items.nil?
             prod = 1.0
             result = items.map do |item|
               n = NumericVerbs.to_double(item)
@@ -456,7 +502,8 @@ module Odin
           }
 
           registry["diff"] = ->(args, _ctx) {
-            items = CollectionVerbs.extract_items(args[0])
+            items = CollectionVerbs.as_items(args[0])
+            return dv.of_null if items.nil?
             lag = args[1] ? (NumericVerbs.to_double(args[1])&.to_i || 1) : 1
             result = items.each_with_index.map do |item, i|
               if i < lag
@@ -475,7 +522,8 @@ module Odin
           }
 
           registry["pctChange"] = ->(args, _ctx) {
-            items = CollectionVerbs.extract_items(args[0])
+            items = CollectionVerbs.as_items(args[0])
+            return dv.of_null if items.nil?
             lag = args[1] ? (NumericVerbs.to_double(args[1])&.to_i || 1) : 1
             result = items.each_with_index.map do |item, i|
               if i < lag
@@ -486,7 +534,7 @@ module Odin
                 if curr.nil? || prev.nil? || prev == 0.0
                   dv.of_null
                 else
-                  dv.of_float((curr - prev) / prev)
+                  NumericVerbs.numeric_result((curr - prev) / prev)
                 end
               end
             end
@@ -528,40 +576,62 @@ module Odin
           }
 
           registry["rank"] = ->(args, _ctx) {
+            return dv.of_null if args.empty?
+
             items = CollectionVerbs.extract_items(args[0])
-            field = args[1]&.to_string
-            direction = args[2]&.to_string || "desc"
+            field = args.length > 1 ? args[1]&.to_string : nil
+            field = nil if field&.empty?
+            direction = (args.length > 2 ? args[2]&.to_string : "desc").to_s.downcase
 
-            values = items.map do |item|
-              if field && item.object?
-                NumericVerbs.to_double(item.get(field))
+            comparable = ->(item) do
+              raw = field && item.object? ? item.get(field) : item
+              num = NumericVerbs.to_double(raw)
+              num.nil? ? (raw.nil? ? "" : raw.to_string) : num
+            end
+
+            indexed = items.each_index.map { |i| [i, comparable.call(items[i])] }
+            mult = direction == "asc" ? 1 : -1
+            sorted = indexed.sort do |a, b|
+              av = a[1]
+              bv = b[1]
+              if av.is_a?(Numeric) && bv.is_a?(Numeric)
+                (av <=> bv) * mult
               else
-                NumericVerbs.to_double(item)
+                (av.to_s <=> bv.to_s) * mult
               end
             end
 
-            sorted_unique = values.compact.uniq.sort
-            sorted_unique.reverse! if direction == "desc"
-
-            rank_map = {}
-            sorted_unique.each_with_index { |v, i| rank_map[v] = i + 1 }
+            ranks = {}
+            current_rank = 1
+            sorted.each_with_index do |(orig_idx, val), i|
+              current_rank = i + 1 if i.positive? && val != sorted[i - 1][1]
+              ranks[orig_idx] = current_rank
+            end
 
-            result = values.map do |v|
-              v.nil? ? dv.of_null : dv.of_integer(rank_map[v])
+            result = items.each_with_index.map do |item, i|
+              rank_val = dv.of_integer(ranks[i] || (i + 1))
+              if item.object?
+                dv.of_object({ "_rank" => rank_val }.merge(item.value))
+              else
+                dv.of_object({ "_rank" => rank_val, "value" => item })
+              end
             end
             dv.of_array(result)
           }
 
           registry["fillMissing"] = ->(args, _ctx) {
+            return dv.of_null if args.empty?
+
             items = CollectionVerbs.extract_items(args[0])
-            strategy = args[1]&.to_string || "value"
-            fill_val = args[2] || dv.of_null
+            fill_val = args.length >= 2 ? args[1] : dv.of_null
+            strategy = (args.length >= 3 ? args[2]&.to_string : "value").to_s.downcase
+            nullish = ->(item) { item.nil? || item.null? }
 
             case strategy
             when "forward"
-              last_val = dv.of_null
+              last_val = fill_val
               result = items.map do |item|
-                if item.null?
+                if nullish.call(item)
                   last_val
                 else
                   last_val = item
@@ -569,17 +639,22 @@ module Odin
                 end
               end
             when "backward"
-              last_val = dv.of_null
+              last_val = fill_val
               result = items.reverse.map do |item|
-                if item.null?
+                if nullish.call(item)
                   last_val
                 else
                   last_val = item
                   item
                 end
               end.reverse
+            when "mean"
+              nums = items.reject { |i| nullish.call(i) }.filter_map { |i| NumericVerbs.to_double(i) }
+              mean = nums.empty? ? 0.0 : nums.inject(0.0) { |s, v| s + v } / nums.length
+              mean_val = dv.of_float(mean)
+              result = items.map { |item| nullish.call(item) ? mean_val : item }
             else
-              result = items.map { |item| item.null? ? fill_val : item }
+              result = items.map { |item| nullish.call(item) ? fill_val : item }
             end
             dv.of_array(result)
           }