kumi 0.0.18 → 0.0.20

data/lib/kumi/core/function_registry.rb

@@ -1,176 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Core
-    # Internal function registry (single source of truth).
-    module FunctionRegistry
-      Entry = FunctionBuilder::Entry
-
-      CORE_OPERATORS = %i[== > < >= <= != between?].freeze
-
-      # Build core functions once
-      CORE_FUNCTIONS = {}.tap do |registry|
-        [
-          ComparisonFunctions.definitions,
-          MathFunctions.definitions,
-          StringFunctions.definitions,
-          LogicalFunctions.definitions,
-          CollectionFunctions.definitions,
-          ConditionalFunctions.definitions,
-          TypeFunctions.definitions,
-          StatFunctions.definitions
-        ].each do |defs|
-          defs.each do |name, entry|
-            raise ArgumentError, "Duplicate core function: #{name}" if registry.key?(name)
-
-            registry[name] = entry
-          end
-        end
-      end.freeze
-
-      @lock      = Mutex.new
-      @functions = CORE_FUNCTIONS.transform_values(&:dup)
-      @frozen    = false
-
-      class FrozenError < RuntimeError; end
-
-      class << self
-        def auto_register(*mods)
-          mods.each do |mod|
-            mod.public_instance_methods(false).each do |m|
-              next if function?(m)
-
-              register(m) { |*args| mod.new.public_send(m, *args) }
-            end
-            mod.singleton_methods(false).each do |m|
-              next if function?(m)
-
-              fn = mod.method(m)
-              register(m) { |*args| fn.call(*args) }
-            end
-          end
-        end
-
-        #
-        # Lifecycle
-        #
-        def reset!
-          @lock.synchronize do
-            @functions = CORE_FUNCTIONS.transform_values(&:dup)
-            @frozen    = false
-          end
-        end
-
-        def freeze!
-          @lock.synchronize do
-            @functions.each_value(&:freeze)
-            @functions.freeze
-            @frozen = true
-          end
-        end
-
-        def frozen?
-          @frozen
-        end
-
-        #
-        # Registration
-        #
-        # Unified entry point; used by both public and internal callers.
-        def register(name, fn_or = nil, **meta, &block)
-          fn = fn_or || block
-          raise ArgumentError, "block or Proc required" unless fn.is_a?(Proc)
-
-          defaults = {
-            arity: fn.arity,
-            param_types: [:any],
-            return_type: :any,
-            description: nil,
-            param_modes: nil,
-            reducer: false,
-            structure_function: false
-          }
-          register_with_metadata(name, fn, **defaults, **meta)
-        end
-
-        # Back-compat explicit API
-        def register_with_metadata(name, fn, arity:, param_types: [:any], return_type: :any,
-                                   description: nil, param_modes: nil, reducer: false,
-                                   structure_function: false)
-          @lock.synchronize do
-            raise FrozenError, "registry is frozen" if @frozen
-            raise ArgumentError, "Function #{name.inspect} already registered" if @functions.key?(name)
-
-            @functions[name] = Entry.new(
-              fn: fn,
-              arity: arity,
-              param_types: param_types,
-              return_type: return_type,
-              description: description,
-              param_modes: param_modes,
-              reducer: reducer,
-              structure_function: structure_function
-            )
-          end
-        end
-
-        #
-        # Queries
-        #
-        def function?(name)
-          @functions.key?(name)
-        end
-        alias supported? function?
-
-        def operator?(name)
-          name.is_a?(Symbol) && function?(name) && CORE_OPERATORS.include?(name)
-        end
-
-        def entry(name)
-          @functions[name]
-        end
-
-        def fetch(name)
-          ent = entry(name)
-          raise Kumi::Errors::UnknownFunction, "Unknown function: #{name}" unless ent
-
-          ent.fn
-        end
-
-        def signature(name)
-          ent = entry(name) or raise Kumi::Errors::UnknownFunction, "Unknown function: #{name}"
-          { arity: ent.arity, param_types: ent.param_types, return_type: ent.return_type, description: ent.description }
-        end
-
-        def reducer?(name)
-          ent = entry(name)
-          ent ? !!ent.reducer : false
-        end
-
-        def structure_function?(name)
-          ent = entry(name)
-          ent ? !!ent.structure_function : false
-        end
-
-        def all_functions
-          @functions.keys
-        end
-        alias all all_functions
-
-        def functions
-          @functions.dup
-        end
-
-        # Introspection helpers
-        def comparison_operators   = ComparisonFunctions.definitions.keys
-        def math_operations        = MathFunctions.definitions.keys
-        def string_operations      = StringFunctions.definitions.keys
-        def logical_operations     = LogicalFunctions.definitions.keys
-        def collection_operations  = CollectionFunctions.definitions.keys
-        def conditional_operations = ConditionalFunctions.definitions.keys
-        def type_operations        = TypeFunctions.definitions.keys
-        def stat_operations        = StatFunctions.definitions.keys
-      end
-    end
-  end
-end

data/lib/kumi/registry.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  # Public facade for the function registry.
-  # Delegates to Kumi::Core::FunctionRegistry.
-  module Registry
-    Entry       = Core::FunctionRegistry::FunctionBuilder::Entry
-    FrozenError = Core::FunctionRegistry::FrozenError
-
-    class << self
-      def auto_register(*mods)
-        Core::FunctionRegistry.auto_register(*mods)
-      end
-
-      def method_missing(name, ...)
-        if Core::FunctionRegistry.respond_to?(name)
-          Core::FunctionRegistry.public_send(name, ...)
-        else
-          super
-        end
-      end
-
-      def respond_to_missing?(name, include_private = false)
-        Core::FunctionRegistry.respond_to?(name, include_private) || super
-      end
-
-      def freeze!
-        Core::FunctionRegistry.freeze!
-      end
-    end
-  end
-end

data/lib/kumi/runtime/executable.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Runtime
-    # Executable / Reader: evaluation interface for compiled schemas
-    #
-    # BUILD:
-    # - Executable.from_analysis(state) consumes:
-    #   * :ir_module (lowered IR)
-    #   * :access_plans (for AccessBuilder)
-    #   * function registry
-    # - Builds accessor lambdas once per plan id.
-    #
-    # EVALUATION:
-    # - program.read(inputs, mode: :public|:wrapped, target: nil)
-    #   * mode=:public  → returns “user values” (scalars and plain Ruby arrays). Vec results are exposed as their lifted scalar.
-    #   * mode=:wrapped → returns internal VM structures for introspection:
-    #       - Scalars as {k: :scalar, v: ...}
-    #       - Vec twins available as :name__vec (and :name for lifted scalar)
-    #   * target: symbol → short-circuit after computing the requested declaration and its dependencies.
-    #
-    # NAMING & TWINS (TODO: we are not exposing for now):
-    # - Every vectorized declaration with indices has:
-    #   * :name__vec  → internal vec form (rows with idx)
-    #   * :name       → lifted scalar form (nested arrays shaped by scope)
-    # - only :name is visible (TODO: For now, we do not expose the twins)
-    #
-    # CACHING / MEMOIZATION:
-    # - Values are computed once per evaluation; dependent requests reuse cached slots.
-    #
-    # ERROR SURFACE:
-    # - VM errors are wrapped as Kumi::Core::Errors::RuntimeError with op context (decl/op index).
-    # - Accessors raise descriptive KeyError for missing fields/arrays (policy-aware).
-    #
-    # DEBUGGING:
-    # - DEBUG_LOWER=1 to print IR at build time
-    # - DEBUG_VM_ARGS=1 to trace VM execution
-    # - Accessors can be debugged independently with DEBUG_ACCESSOR_OPS=1
-    class Executable
-      def self.from_analysis(state, registry: nil, schema_name: nil)
-        ir = state.fetch(:ir_module)
-        access_plans = state.fetch(:access_plans)
-        input_metadata = state[:input_metadata] || {}
-        dependents = state[:dependents] || {}
-        schedules = state[:ir_execution_schedules] || {}
-
-        accessors = Dev::Profiler.phase("compiler.access_builder") do
-          Kumi::Core::Compiler::AccessBuilder.build(access_plans)
-        end
-
-        access_meta = {}
-
-        # access_plans.each_value do |plans|
-        #   plans.each do |p|
-        #     access_meta[p.accessor_key] = { mode: p.mode, scope: p.scope }
-
-        #     # Build precise field -> plan_ids mapping for invalidation
-        #     root_field = p.accessor_key.to_s.split(":").first.split(".").first.to_sym
-        #     field_to_plan_ids[root_field] << p.accessor_key
-        #   end
-        # end
-
-        # Use the internal functions hash that VM expects
-        registry ||= Kumi::Registry.functions
-        new(ir: ir, accessors: accessors, access_meta: access_meta, registry: registry,
-            input_metadata: input_metadata, dependents: dependents,
-            schema_name: schema_name, schedules: schedules)
-      end
-
-      def initialize(ir:, accessors:, access_meta:, registry:, input_metadata:, dependents: {}, schedules: {}, schema_name: nil)
-        @ir = ir.freeze
-        @acc = accessors.freeze
-        @meta = access_meta.freeze
-        @reg = registry
-        @input_metadata = input_metadata.freeze
-        @dependents = dependents.freeze
-        @schema_name = schema_name
-        @schedules = schedules
-        @decl = @ir.decls.map { |d| [d.name, d] }.to_h
-        @accessor_cache = {} # Persistent accessor cache across evaluations
-      end
-
-      def decl?(name) = @decl.key?(name)
-
-      def read(input, mode: :ruby)
-        Run.new(self, input, mode: mode, input_metadata: @input_metadata, dependents: @dependents, declarations: @decl.keys)
-      end
-
-      # API compatibility for backward compatibility
-      def evaluate(ctx, *key_names)
-        target_keys = key_names.empty? ? @decl.keys : validate_keys(key_names)
-
-        # Handle context wrapping for backward compatibility
-        input = ctx.respond_to?(:ctx) ? ctx.ctx : ctx
-
-        target_keys.each_with_object({}) do |key, result|
-          result[key] = eval_decl(key, input, mode: :ruby)
-        end
-      end
-
-      def eval_decl(name, input, mode: :ruby, declaration_cache: {})
-        raise Kumi::Core::Errors::RuntimeError, "unknown decl #{name}" unless decl?(name)
-
-        schedule = @schedules[name]
-        # If the caller asked for a specific binding, schedule deps once
-
-        runtime = {
-          accessor_cache: @accessor_cache,
-          declaration_cache: declaration_cache, # run-local cache
-          schema_name: @schema_name,
-          target: name
-        }
-
-        out = Dev::Profiler.phase("vm.run", target: name) do
-          Kumi::Core::IR::ExecutionEngine.run(schedule, input: input, runtime: runtime, accessors: @acc, registry: @reg).fetch(name)
-        end
-
-        mode == :ruby ? unwrap(@decl[name], out) : out
-      end
-
-      def unwrap(_decl, v)
-        v[:k] == :scalar ? v[:v] : v # no grouping needed
-      end
-
-      private
-
-      def validate_keys(keys)
-        unknown_keys = keys - @decl.keys
-        return keys if unknown_keys.empty?
-
-        raise Kumi::Errors::RuntimeError, "No binding named #{unknown_keys.first}"
-      end
-    end
-  end
-end

data/lib/kumi/runtime/run.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Runtime
-    class Run
-      def initialize(program, input, mode:, input_metadata:, dependents:, declarations:)
-        @program = program
-        @input = input
-        @mode = mode
-        @input_metadata = input_metadata
-        @declarations = declarations
-        @dependents = dependents
-        @cache = {}
-      end
-
-      def key?(name)
-        @declarations.include? name
-      end
-
-      def get(name)
-        unless @cache.key?(name)
-          # Get the result in VM internal format
-          vm_result = @program.eval_decl(name, @input, mode: :wrapped, declaration_cache: @cache)
-          # Store VM format for cross-VM caching
-          @cache[name] = vm_result
-        end
-
-        # Convert to requested format when returning
-        vm_result = @cache[name]
-        @mode == :wrapped ? vm_result : @program.unwrap(nil, vm_result)
-      end
-
-      def to_h
-        slice(*@declarations)
-      end
-
-      def [](name)
-        get(name)
-      end
-
-      def slice(*keys)
-        return {} if keys.empty?
-
-        keys.each_with_object({}) { |key, result| result[key] = get(key) }
-      end
-
-      def compiled_schema
-        @program
-      end
-
-      def method_missing(sym, *args, **kwargs, &)
-        return super unless args.empty? && kwargs.empty? && key?(sym)
-
-        get(sym)
-      end
-
-      def respond_to_missing?(sym, priv = false)
-        key?(sym) || super
-      end
-
-      def update(**changes)
-        affected_declarations = Set.new
-
-        changes.each do |field, value|
-          raise ArgumentError, "unknown input field: #{field}" unless input_field_exists?(field)
-
-          validate_domain_constraint(field, value)
-
-          @input[field] = value
-          if (deps = @dependents[field])
-            deps.each { |d| @cache.delete(d) }
-          end
-        end
-
-        self
-      end
-
-      private
-
-      def input_field_exists?(field)
-        # Check if field is declared in input block
-        @input_metadata.key?(field)
-      end
-
-      def validate_domain_constraint(field, value)
-        field_meta = @input_metadata[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, Array
-          !domain.include?(value)
-        else
-          false
-        end
-      end
-    end
-  end
-end

data/performance_results.txt

@@ -1,63 +0,0 @@
-=== MIXED NESTING SCHEMA PERFORMANCE TEST ===
-Test run: 2025-08-21 01:31:06 -0300
-Ruby version: 3.3.8
-
-✅ Schema loaded successfully
-
-=== COMPILATION PERFORMANCE ===
-
-Tiny     (  1 items):     2.47ms
-Small    (  4 items):     3.67ms
-Medium   ( 25 items):     1.86ms
-Large    (100 items):     1.92ms
-XLarge   (200 items):     2.96ms
-Huge     (250 items):      2.0ms
-
-=== EXECUTION PERFORMANCE ===
-
-Tiny     (  1 items): avg=  0.54ms, throughput=   1.8 items/ms
-Small    (  4 items): avg=  0.64ms, throughput=   6.2 items/ms
-Medium   ( 25 items): avg=  1.15ms, throughput=  21.8 items/ms
-Large    (100 items): avg=  3.61ms, throughput=  27.7 items/ms
-XLarge   (200 items): avg=  7.25ms, throughput=  27.6 items/ms
-Huge     (250 items): avg=  11.8ms, throughput=  21.2 items/ms
-
-=== SCALING ANALYSIS ===
-
- 50 items:   0.87ms (57.2 items/ms)
-100 items:   1.45ms (68.9 items/ms)
-200 items:   2.85ms (70.3 items/ms)
-400 items:   5.75ms (69.6 items/ms)
-800 items:  15.16ms (52.8 items/ms)
-
-=== MEMORY ANALYSIS ===
-
-Iteration 0: RSS=35472KB (Δ256KB)
-Iteration 3: RSS=35472KB (Δ256KB)
-Iteration 6: RSS=35472KB (Δ256KB)
-Iteration 9: RSS=35472KB (Δ256KB)
-
-=== SAMPLE OUTPUT VALIDATION ===
-
-org_name: Global Corp
-region_names: ["Region 1", "Region 2"]
-total_capacity: [147, 173]
-org_classification: Enterprise
-
-=== PERFORMANCE BOTTLENECKS IDENTIFIED ===
-
-1. Deep nesting (5+ levels) creates complex IR with many lift operations
-2. Each nested access requires scope transitions
-3. Compilation cold start: ~80ms first time
-4. Linear scaling with data size is expected behavior
-5. Memory usage is stable (no leaks detected)
-
-=== RECOMMENDATIONS ===
-
-• For production: Cache compiled schemas to avoid cold start
-• For large datasets: Consider schema restructuring to reduce nesting
-• Current performance acceptable for <1000 items
-• Deep nesting workable but monitor performance with >10,000 items
-
-Test completed at: 2025-08-21 01:31:06 -0300
-Total runtime: 0.37s

data/scripts/analyze_broadcast_methods.rb

@@ -1,68 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "json"
-
-coverage_file = "coverage/.resultset.json"
-
-unless File.exist?(coverage_file)
-  puts "❌ No coverage data found. Run tests first:"
-  puts "   COVERAGE=true bundle exec rspec"
-  exit 1
-end
-
-data = JSON.parse(File.read(coverage_file))
-coverage = data.values.first["coverage"]
-
-broadcast_file = coverage.find { |file, _| file.include?("broadcast_detector.rb") }
-
-if broadcast_file
-  file_path, line_data = broadcast_file
-  lines = line_data["lines"]
-  
-  puts "🔍 BroadcastDetector Coverage Analysis:"
-  puts "File: #{File.basename(file_path)}"
-  
-  total_lines = lines.count { |hits| !hits.nil? }
-  covered_lines = lines.count { |hits| hits && hits > 0 }
-  coverage_percent = (covered_lines.to_f / total_lines * 100).round(1)
-  
-  puts "Coverage: #{coverage_percent}% (#{covered_lines}/#{total_lines} lines)"
-  
-  # Find uncovered method definitions
-  file_content = File.read(file_path)
-  uncovered_methods = []
-  covered_methods = []
-  
-  file_content.lines.each_with_index do |line, i|
-    if line.match?(/^\s*def\s+(\w+)/)
-      method_name = line.match(/^\s*def\s+(\w+)/)[1]
-      line_hits = lines[i]
-      
-      if line_hits.nil?
-        # Line not tracked
-      elsif line_hits == 0
-        uncovered_methods << "#{method_name} (line #{i+1})"
-      else
-        covered_methods << "#{method_name} (line #{i+1})"
-      end
-    end
-  end
-  
-  puts "\n📊 Method Coverage Summary:"
-  puts "  Total methods: #{covered_methods.length + uncovered_methods.length}"
-  puts "  Covered methods: #{covered_methods.length}"
-  puts "  Uncovered methods: #{uncovered_methods.length}"
-  
-  if uncovered_methods.any?
-    puts "\n🚨 Uncovered methods (potential dead code):"
-    uncovered_methods.each { |m| puts "    - #{m}" }
-  end
-  
-  if covered_methods.any?
-    puts "\n✅ Covered methods:"
-    covered_methods.each { |m| puts "    - #{m}" }
-  end
-else
-  puts "❌ BroadcastDetector file not found in coverage data"
-end

data/scripts/analyze_cascade_methods.rb

@@ -1,74 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "json"
-
-coverage_file = "coverage/.resultset.json"
-target_file = "cascade_executor_builder.rb"
-
-unless File.exist?(coverage_file)
-  puts "❌ No coverage data found. Run tests first"
-  exit 1
-end
-
-data = JSON.parse(File.read(coverage_file))
-coverage = data.values.first["coverage"]
-
-file_entry = coverage.find { |file, _| file.include?(target_file) }
-
-if file_entry
-  file_path, line_data = file_entry
-  lines = line_data["lines"]
-  
-  puts "🔍 CascadeExecutorBuilder Method Coverage:"
-  puts "=" * 50
-  
-  file_content = File.read(file_path)
-  methods = []
-  
-  file_content.lines.each_with_index do |line, i|
-    if line.match?(/^\s*def\s+/)
-      method_match = line.match(/^\s*def\s+(self\.)?(\w+)/)
-      if method_match
-        method_name = method_match[2]
-        is_class_method = !method_match[1].nil?
-        line_hits = lines[i]
-        
-        status = if line_hits.nil?
-                   "⚪ NOT TRACKED"
-                 elsif line_hits == 0
-                   "🚨 UNCOVERED"
-                 else
-                   "✅ COVERED (#{line_hits} hits)"
-                 end
-        
-        prefix = is_class_method ? "self." : ""
-        methods << {
-          name: "#{prefix}#{method_name}",
-          line: i + 1,
-          hits: line_hits,
-          status: status
-        }
-      end
-    end
-  end
-  
-  methods.each do |method|
-    printf "  %-25s (line %3d) %s\n", method[:name], method[:line], method[:status]
-  end
-  
-  uncovered = methods.select { |m| m[:hits] == 0 }
-  covered = methods.select { |m| m[:hits] && m[:hits] > 0 }
-  
-  puts "\n📊 Summary:"
-  puts "  Total methods: #{methods.length}"
-  puts "  Covered: #{covered.length}"
-  puts "  Uncovered: #{uncovered.length}"
-  
-  if uncovered.any?
-    puts "\n🚨 Uncovered methods (potential dead code):"
-    uncovered.each { |m| puts "    #{m[:name]} (line #{m[:line]})" }
-  end
-else
-  puts "❌ #{target_file} not found in coverage data"
-end

data/scripts/check_broadcasting_coverage.rb

@@ -1,51 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "json"
-
-coverage_file = "coverage/.resultset.json"
-
-unless File.exist?(coverage_file)
-  puts "❌ No coverage data found. Run tests first"
-  exit 1
-end
-
-data = JSON.parse(File.read(coverage_file))
-coverage = data.values.first["coverage"]
-
-broadcasting_files = [
-  "cascade_executor_builder.rb",
-  "vectorized_function_builder.rb", 
-  "nested_structure_utils.rb",
-  "broadcast_detector.rb"
-]
-
-puts "🔍 Broadcasting Files Coverage:"
-puts "=" * 60
-
-broadcasting_files.each do |filename|
-  file_entry = coverage.find { |file, _| file.include?(filename) }
-  
-  if file_entry
-    file_path, line_data = file_entry
-    lines = line_data["lines"]
-    
-    total_lines = lines.count { |hits| !hits.nil? }
-    covered_lines = lines.count { |hits| hits && hits > 0 }
-    coverage_percent = total_lines > 0 ? (covered_lines.to_f / total_lines * 100).round(1) : 0
-    
-    status = if coverage_percent == 0
-               "🚨 DEAD"
-             elsif coverage_percent < 20
-               "🔴 LOW"  
-             elsif coverage_percent < 50
-               "🟡 MEDIUM"
-             else
-               "✅ GOOD"
-             end
-    
-    printf "%-35s %s %6.1f%% (%d/%d lines)\n", filename, status, coverage_percent, covered_lines, total_lines
-  else
-    printf "%-35s ❌ NOT FOUND\n", filename
-  end
-end