kumi 0.0.10 → 0.0.12

data/lib/kumi/core/compiler/path_traversal_compiler.rb

@@ -1,158 +0,0 @@
-module Kumi
-  module Core
-    module Compiler
-      module PathTraversalCompiler
-        private
-
-        def compile_element_field_reference(expr)
-          path = expr.path
-
-          # Check if we have nested paths metadata for this path
-          nested_paths = @analysis.state[:broadcasts]&.dig(:nested_paths)
-          unless nested_paths && nested_paths[path]
-            raise Errors::CompilationError, "Missing nested path metadata for #{path.inspect}. This indicates an analyzer bug."
-          end
-
-          # Determine operation mode based on context
-          operation_mode = determine_operation_mode_for_path(path)
-          path_metadata = nested_paths[path]
-          lambda do |ctx|
-            traverse_nested_path(ctx, path, operation_mode, path_metadata)
-          end
-
-          # ERROR: All nested paths should have metadata from the analyzer
-          # If we reach here, it means the BroadcastDetector didn't process this path
-        end
-
-        # Metadata-driven nested array traversal using the traversal algorithm from our design
-        def traverse_nested_path(data, path, operation_mode, path_metadata = nil)
-          access_mode = path_metadata&.dig(:access_mode) || :object
-
-          # Use specialized traversal for element access mode
-          result = if access_mode == :element
-                     traverse_element_path(data, path, operation_mode)
-                   else
-                     traverse_path_recursive(data, path, operation_mode, access_mode)
-                   end
-
-          # Post-process result based on operation mode
-          case operation_mode
-          when :flatten
-            # Completely flatten nested arrays for aggregation
-            flatten_completely(result)
-          else
-            result
-          end
-        end
-
-        # Specialized traversal for element access mode
-        # In element access, we need to extract the specific field from EvaluationWrapper
-        # then apply progressive traversal based on path depth
-        def traverse_element_path(data, path, _operation_mode)
-          # Handle EvaluationWrapper by extracting the specific field
-          if data.is_a?(Core::EvaluationWrapper)
-            field_name = path.first
-            array_data = data[field_name]
-
-            # Always apply progressive traversal based on path depth
-            # This gives us the structure at the correct nesting level for both
-            # broadcast operations and structure operations
-            if array_data.is_a?(Array) && path.length > 1
-              # Flatten exactly (path_depth - 1) levels to get the desired nesting level
-              array_data.flatten(path.length - 1)
-            else
-              array_data
-            end
-          else
-            data
-          end
-        end
-
-        def traverse_path_recursive(data, path, operation_mode, access_mode = :object, original_path_length = nil)
-          # Track original path length to determine traversal depth
-          original_path_length ||= path.length
-          current_depth = original_path_length - path.length
-
-          return data if path.empty?
-
-          field = path.first
-          remaining_path = path[1..]
-
-          if remaining_path.empty?
-            # Final field - extract based on operation mode
-            case operation_mode
-            when :broadcast, :flatten
-              # Extract field preserving array structure
-              extract_field_preserving_structure(data, field, access_mode, current_depth)
-            else
-              # Simple field access
-              if data.is_a?(Array)
-                data.map do |item|
-                  access_field(item, field, access_mode, current_depth)
-                end
-              else
-                access_field(data, field, access_mode, current_depth)
-              end
-            end
-          elsif data.is_a?(Array)
-            # Intermediate step - traverse deeper
-            # Array of items - traverse each item
-            data.map do |item|
-              traverse_path_recursive(access_field(item, field, access_mode, current_depth), remaining_path, operation_mode, access_mode,
-                                      original_path_length)
-            end
-          else
-            # Single item - traverse directly
-            traverse_path_recursive(access_field(data, field, access_mode, current_depth), remaining_path, operation_mode, access_mode,
-                                    original_path_length)
-          end
-        end
-
-        def extract_field_preserving_structure(data, field, access_mode = :object, depth = 0)
-          if data.is_a?(Array)
-            data.map { |item| extract_field_preserving_structure(item, field, access_mode, depth) }
-          else
-            access_field(data, field, access_mode, depth)
-          end
-        end
-
-        def access_field(data, field, access_mode, _depth = 0)
-          case access_mode
-          when :element
-            # Element access mode - for nested arrays, we need to traverse one level deeper
-            # This enables progressive path traversal like input.cube.layer.row.value
-            if data.is_a?(Core::EvaluationWrapper)
-              data[field]
-            elsif data.is_a?(Array)
-              # For element access, flatten one level to traverse deeper into nested structure
-              data.flatten(1)
-            else
-              # If not an array, return as-is (leaf level)
-              data
-            end
-          when :object
-            # Object access mode - normal hash/object field access
-            data[field]
-          else
-            # Default to object access
-            data[field]
-          end
-        end
-
-        def flatten_completely(data)
-          result = []
-          flatten_recursive(data, result)
-          result
-        end
-
-        def flatten_recursive(data, result)
-          if data.is_a?(Array)
-            data.each { |item| flatten_recursive(item, result) }
-          else
-            result << data
-          end
-        end
-      end
-    end
-  end
-end

data/lib/kumi/core/compiler/reference_compiler.rb

@@ -1,46 +0,0 @@
-module Kumi
-  module Core
-    module Compiler
-      module ReferenceCompiler
-        private
-
-        def compile_literal(expr)
-          v = expr.value
-          ->(_ctx) { v }
-        end
-
-        def compile_field_node(expr)
-          compile_field(expr)
-        end
-
-        def compile_binding_node(expr)
-          name = expr.name
-          # Handle forward references in cycles by deferring binding lookup to runtime
-          lambda do |ctx|
-            fn = @bindings[name].last
-            fn.call(ctx)
-          end
-        end
-
-        def compile_field(node)
-          name = node.name
-          loc  = node.loc
-          lambda do |ctx|
-            return ctx[name] if ctx.respond_to?(:key?) && ctx.key?(name)
-
-            raise Errors::RuntimeError,
-                  "Key '#{name}' not found at #{loc}. Available: #{ctx.respond_to?(:keys) ? ctx.keys.join(', ') : 'N/A'}"
-          end
-        end
-
-        def compile_declaration(decl)
-          @current_declaration = decl.name
-          kind = decl.is_a?(Kumi::Syntax::TraitDeclaration) ? :trait : :attr
-          fn = compile_expr(decl.expression)
-          @bindings[decl.name] = [kind, fn]
-          @current_declaration = nil
-        end
-      end
-    end
-  end
-end

data/lib/kumi/core/evaluation_wrapper.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Core
-    EvaluationWrapper = Struct.new(:ctx) do
-      def initialize(ctx)
-        super
-        @__schema_cache__ = {} # memoization cache for bindings
-      end
-
-      def [](key)
-        ctx[key]
-      end
-
-      def []=(key, value)
-        ctx[key] = value
-      end
-
-      def keys
-        ctx.keys
-      end
-
-      def key?(key)
-        ctx.key?(key)
-      end
-
-      def clear
-        @__schema_cache__.clear
-      end
-
-      def clear_cache(*keys)
-        if keys.empty?
-          @__schema_cache__.clear
-        else
-          keys.each { |key| @__schema_cache__.delete(key) }
-        end
-      end
-    end
-  end
-end

data/lib/kumi/core/nested_structure_utils.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Core
-    # Shared utilities for working with nested array structures
-    module NestedStructureUtils
-      def calculate_array_depth(arr)
-        return 0 unless arr.is_a?(Array)
-        return 1 if arr.empty? || !arr.first.is_a?(Array)
-
-        1 + calculate_array_depth(arr.first)
-      end
-
-      def map_nested_structure(structure, indices = [], &block)
-        if structure.is_a?(Array) && structure.first.is_a?(Array)
-          # Still nested - recurse deeper
-          structure.map.with_index do |sub_structure, i|
-            map_nested_structure(sub_structure, indices + [i], &block)
-          end
-        elsif structure.is_a?(Array)
-          # Leaf array level - apply function to elements
-          structure.map.with_index do |_element, i|
-            yield(*(indices + [i]))
-          end
-        else
-          # Single element - apply function
-          yield(*indices)
-        end
-      end
-
-      def navigate_nested_indices(structure, indices)
-        indices.reduce(structure) do |current, index|
-          if current.is_a?(Array)
-            current[index]
-          else
-            # If we hit a non-array during navigation, it means we're dealing with
-            # mixed nesting levels - return the current value
-            current
-          end
-        end
-      end
-
-      def navigate_with_hierarchical_broadcasting(value, indices, template)
-        # Navigate through value with hierarchical broadcasting to match template structure
-        value_depth = calculate_array_depth(value)
-        template_depth = calculate_array_depth(template)
-
-        if value_depth < template_depth
-          # Value is at parent level - broadcast to child level by using fewer indices
-          parent_indices = indices[0, value_depth]
-          navigate_nested_indices(value, parent_indices)
-        else
-          # Same or deeper level - navigate normally
-          navigate_nested_indices(value, indices)
-        end
-      end
-
-      def find_structure_template(all_results)
-        # Find the first array to use as structure template
-        all_results.find { |v| v.is_a?(Array) }
-      end
-
-      def determine_array_length(arrays)
-        # Find the first array and use its length
-        first_array = arrays.find { |v| v.is_a?(Array) }
-        first_array ? first_array.length : 1
-      end
-
-      def extract_element_at_index(value, index)
-        if value.is_a?(Array)
-          index < value.length ? value[index] : nil
-        else
-          value # Scalar value - same for all indices
-        end
-      end
-    end
-  end
-end

data/lib/kumi/core/schema_instance.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Core
-    # A bound pair of <compiled schema + context>.  Immutable.
-    #
-    # Public API ----------------------------------------------------------
-    #   instance.evaluate                # => full Hash of all bindings
-    #   instance.evaluate(:tax_due, :rate)
-    #   instance.slice(:tax_due)         # alias for evaluate(*keys)
-    #   instance.explain(:tax_due)       # pretty trace string
-    #   instance.input                   # original context (read‑only)
-
-    class SchemaInstance
-      attr_reader :compiled_schema, :metadata, :context
-
-      def initialize(compiled_schema, metadata, context)
-        @compiled_schema = compiled_schema # Kumi::Core::CompiledSchema
-        @metadata = metadata # Frozen state hash
-        @context  = context.is_a?(EvaluationWrapper) ? context : EvaluationWrapper.new(context)
-      end
-
-      # Hash‑like read of one or many bindings
-      def evaluate(*key_names)
-        if key_names.empty?
-          @compiled_schema.evaluate(@context)
-        else
-          @compiled_schema.evaluate(@context, *key_names)
-        end
-      end
-
-      def slice(*key_names)
-        return {} if key_names.empty?
-
-        evaluate(*key_names)
-      end
-
-      def [](key_name)
-        evaluate(key_name)[key_name]
-      end
-
-      def functions_used
-        @metadata[:functions_required].to_a
-      end
-
-      # Update input values and clear affected cached computations
-      def update(**changes)
-        changes.each do |field, value|
-          # Validate field exists
-          raise ArgumentError, "unknown input field: #{field}" unless input_field_exists?(field)
-
-          # Validate domain constraints
-          validate_domain_constraint(field, value)
-
-          # Update the input data
-          @context[field] = value
-
-          # Clear affected cached values using transitive closure by default
-          if ENV["KUMI_SIMPLE_CACHE"] == "true"
-            # Simple fallback: clear all cached values
-            @context.clear_cache
-          else
-            # Default: selective cache clearing using precomputed transitive closure
-            affected_keys = find_dependent_declarations_optimized(field)
-            affected_keys.each { |key| @context.clear_cache(key) }
-          end
-        end
-
-        self # Return self for chaining
-      end
-
-      private
-
-      def input_field_exists?(field)
-        # Check if field is declared in input block
-        input_meta = @metadata[:inputs] || {}
-        input_meta.key?(field) || @context.key?(field)
-      end
-
-      def validate_domain_constraint(field, value)
-        input_meta = @metadata[:inputs] || {}
-        field_meta = input_meta[field]
-        return unless field_meta&.dig(:domain)
-
-        domain = field_meta[:domain]
-        return unless violates_domain?(value, domain)
-
-        raise ArgumentError, "value #{value} is not in domain #{domain}"
-      end
-
-      def violates_domain?(value, domain)
-        case domain
-        when Range
-          !domain.include?(value)
-        when Array
-          !domain.include?(value)
-        when Proc
-          # For Proc domains, we can't statically analyze
-          false
-        else
-          false
-        end
-      end
-
-      def find_dependent_declarations_optimized(field)
-        # Use precomputed transitive closure for true O(1) lookup!
-        transitive_dependents = @metadata[:dependents]
-        return [] unless transitive_dependents
-
-        # This is truly O(1) - just array lookup, no traversal needed
-        transitive_dependents[field] || []
-      end
-    end
-  end
-end

data/lib/kumi/core/vectorized_function_builder.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Core
-    # Builds vectorized function execution lambdas from analysis metadata
-    class VectorizedFunctionBuilder
-      include NestedStructureUtils
-
-      def self.build_executor(fn_name, compilation_meta, analysis_state)
-        new(fn_name, compilation_meta, analysis_state).build
-      end
-
-      def initialize(fn_name, compilation_meta, analysis_state)
-        @fn_name = fn_name
-        @compilation_meta = compilation_meta
-        @analysis_state = analysis_state
-      end
-
-      def build
-        # Get the function from registry
-        fn = Kumi::Registry.fetch(@fn_name)
-
-        lambda do |arg_values, loc|
-          # Check if any argument is vectorized (array)
-          has_vectorized_args = arg_values.any?(Array)
-
-          if has_vectorized_args
-            # Apply function with broadcasting to all vectorized arguments
-            vectorized_function_call(fn, arg_values)
-          else
-            # All arguments are scalars - regular function call
-            fn.call(*arg_values)
-          end
-        rescue StandardError => e
-          enhanced_message = "Error calling fn(:#{@fn_name}) at #{loc}: #{e.message}"
-          runtime_error = Errors::RuntimeError.new(enhanced_message)
-          runtime_error.set_backtrace(e.backtrace)
-          runtime_error.define_singleton_method(:cause) { e }
-          raise runtime_error
-        end
-      end
-
-      private
-
-      def vectorized_function_call(fn, values)
-        # Find array dimensions for broadcasting
-        array_values = values.select { |v| v.is_a?(Array) }
-        return fn.call(*values) if array_values.empty?
-
-        # Check if we have deeply nested arrays (arrays containing arrays)
-        has_nested_arrays = array_values.any? { |arr| arr.is_a?(Array) && arr.first.is_a?(Array) }
-
-        if has_nested_arrays
-          # Use recursive element-wise operation for nested arrays
-          apply_function_to_nested_structure(fn, values)
-        else
-          # Original flat array logic
-          array_length = array_values.first.size
-          (0...array_length).map do |i|
-            element_args = values.map do |v|
-              v.is_a?(Array) ? v[i] : v # Broadcast scalars
-            end
-            fn.call(*element_args)
-          end
-        end
-      end
-
-      def apply_function_to_nested_structure(fn, values)
-        # Find the first array to determine structure
-        array_value = values.find { |v| v.is_a?(Array) }
-
-        # Apply function element-wise, preserving nested structure
-        map_nested_structure(array_value) do |*indices|
-          element_args = values.map do |value|
-            if value.is_a?(Array)
-              # Navigate to the corresponding element in nested structure
-              navigate_nested_indices(value, indices)
-            else
-              # Scalar - broadcast to all positions
-              value
-            end
-          end
-          fn.call(*element_args)
-        end
-      end
-    end
-  end
-end