kumi 0.0.10 → 0.0.11

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