kumi 0.0.17 → 0.0.19

data/scripts/find_dead_code.rb

@@ -1,114 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "json"
-
-class SimpleDeadCodeFinder
-  COVERAGE_JSON = "coverage/.resultset.json"
-
-  def run
-    unless File.exist?(COVERAGE_JSON)
-      puts "❌ No coverage data found. Run tests first:"
-      puts "   COVERAGE=true bundle exec rspec"
-      exit 1
-    end
-
-    puts "🔍 Analyzing SimpleCov data for dead code..."
-
-    coverage_data = JSON.parse(File.read(COVERAGE_JSON))
-    coverage = coverage_data.values.first["coverage"]
-
-    find_dead_files(coverage)
-    find_low_coverage_files(coverage)
-
-    puts "\n💡 Next steps:"
-    puts "   1. Open coverage/index.html to see detailed line-by-line coverage"
-    puts "   2. Review uncovered files to see if they can be removed"
-    puts "   3. Look at uncovered methods in low-coverage files"
-  end
-
-  private
-
-  def find_dead_files(coverage)
-    puts "\n🚨 COMPLETELY UNCOVERED FILES (potential dead code):"
-    puts "=" * 60
-
-    dead_files = []
-
-    coverage.each do |file, line_data|
-      next unless file.include?("/lib/")
-
-      # Extract lines array from SimpleCov format
-      lines = line_data["lines"]
-      next unless lines
-
-      total_lines = lines.count { |hits| !hits.nil? }
-      covered_lines = lines.count { |hits| hits && hits > 0 }
-
-      if total_lines > 0 && covered_lines == 0
-        relative_path = file.sub("#{Dir.pwd}/", "")
-        dead_files << relative_path
-      end
-    end
-
-    if dead_files.empty?
-      puts "✅ No completely uncovered files found!"
-    else
-      puts "Found #{dead_files.length} completely uncovered files:"
-      dead_files.sort.each { |f| puts "  📄 #{f}" }
-
-      puts "\n⚠️  These files are candidates for removal, but verify:"
-      puts "   • Check if they're loaded via autoloading/zeitwerk"
-      puts "   • Look for usage in examples/ or external code"
-      puts "   • Consider if they're part of public API"
-    end
-  end
-
-  def find_low_coverage_files(coverage)
-    puts "\n🔍 LOW COVERAGE FILES (<20% - check for dead methods):"
-    puts "=" * 20
-
-    low_coverage = []
-
-    coverage.each do |file, line_data|
-      next unless file.include?("/lib/")
-
-      # Extract lines array from SimpleCov format
-      lines = line_data["lines"]
-      next unless lines
-
-      total_lines = lines.count { |hits| !hits.nil? }
-      covered_lines = lines.count { |hits| hits && hits > 0 }
-
-      next if total_lines == 0
-
-      coverage_percent = (covered_lines.to_f / total_lines * 100)
-
-      next unless coverage_percent > 0 && coverage_percent < 20
-
-      relative_path = file.sub("#{Dir.pwd}/", "")
-      low_coverage << {
-        file: relative_path,
-        percent: coverage_percent,
-        covered: covered_lines,
-        total: total_lines
-      }
-    end
-
-    if low_coverage.empty?
-      puts "✅ No files with very low coverage found!"
-    else
-      low_coverage.sort_by { |f| f[:percent] }.each do |info|
-        printf "  📄 %-50s %5.1f%% (%d/%d lines)\n",
-               info[:file], info[:percent], info[:covered], info[:total]
-      end
-
-      puts "\n💡 These files likely contain dead methods:"
-      puts "   • Open coverage/index.html and click on these files"
-      puts "   • Red lines are uncovered - potential dead code"
-      puts "   • Look for entire uncovered methods/classes"
-    end
-  end
-end
-
-SimpleDeadCodeFinder.new.run if __FILE__ == $0

data/scripts/generate_function_docs.rb

@@ -1,71 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# This script loads the Kumi library and introspects the FunctionRegistry
-# to generate a Markdown reference for the standard function library.
-
-require "bundler/setup"
-require "kumi"
-
-# Helper to format the type information for display.
-def format_type(type)
-  Kumi::Core::Types.type_to_s(type)
-end
-
-# Helper to generate a signature string for a function.
-def generate_signature(name, signature)
-  params = if signature[:arity].negative?
-             # Variadic function (e.g., add, concat)
-             param_type = format_type(signature[:param_types].first || :any)
-             "#{param_type}1, #{param_type}2, ..."
-           else
-             # Fixed arity function
-             signature[:param_types].map.with_index { |type, i| "#{format_type(type)} arg#{i + 1}" }.join(", ")
-           end
-
-  return_type = format_type(signature[:return_type])
-  "`fn(:#{name}, #{params})` → `#{return_type}`"
-end
-
-# Main documentation generation logic.
-def generate_docs
-  output = []
-  add_header(output)
-  add_function_categories(output)
-  output.join("\n")
-end
-
-def add_header(output)
-  output << "# Kumi Standard Function Library Reference"
-  output << "\nKumi provides a rich library of built-in functions for use within `value` and `trait` expressions via `fn(...)`."
-end
-
-def add_function_categories(output)
-  function_categories.each do |title, functions|
-    output << "\n## #{title}\n"
-    add_functions_for_category(output, functions)
-  end
-end
-
-def function_categories
-  {
-    "Logical Functions" => Kumi::Registry.logical_operations,
-    "Comparison Functions" => Kumi::Registry.comparison_operators,
-    "Math Functions" => Kumi::Registry.math_operations,
-    "String Functions" => Kumi::Registry.string_operations,
-    "Collection Functions" => Kumi::Registry.collection_operations,
-    "Conditional Functions" => Kumi::Registry.conditional_operations,
-    "Type & Hash Functions" => Kumi::Registry.type_operations
-  }
-end
-
-def add_functions_for_category(output, functions)
-  functions.sort.each do |name|
-    signature = Kumi::Registry.signature(name)
-    output << "* **`#{name}`**: #{signature[:description]}"
-    output << "  * **Usage**: #{generate_signature(name, signature)}"
-  end
-end
-
-# Execute the script and print the documentation.
-puts generate_docs

data/scripts/test_mixed_nesting_performance.rb

@@ -1,206 +0,0 @@
-#!/usr/bin/env ruby
-# Performance test script for golden/mixed_nesting/schema.kumi
-# Saves results to performance_results.txt for tracking
-
-ENV['RUBYOPT'] = '-W0'
-require 'benchmark'
-require 'time'
-require_relative '../lib/kumi'
-
-# Output both to console and file
-class DualOutput
-  def initialize(file_path)
-    @file = File.open(file_path, 'w')
-    @start_time = Time.now
-  end
-
-  def puts(msg = "")
-    STDOUT.puts(msg)
-    @file.puts(msg)
-    @file.flush
-  end
-
-  def close
-    @file.puts
-    @file.puts("Test completed at: #{Time.now}")
-    @file.puts("Total runtime: #{(Time.now - @start_time).round(2)}s")
-    @file.close
-  end
-end
-
-output = DualOutput.new('performance_results.txt')
-
-output.puts "=== MIXED NESTING SCHEMA PERFORMANCE TEST ==="
-output.puts "Test run: #{Time.now}"
-output.puts "Ruby version: #{RUBY_VERSION}"
-output.puts
-
-# Load schema
-schema_path = File.join(__dir__, '../golden/mixed_nesting/schema.kumi')
-schema_content = File.read(schema_path)
-schema = eval("Module.new { extend Kumi::Schema; #{schema_content} }")
-
-output.puts "✅ Schema loaded successfully"
-output.puts
-
-# Generate test data
-def generate_test_data(num_regions = 2, num_buildings = 3)
-  {
-    organization: {
-      name: "Global Corp",
-      regions: (1..num_regions).map do |r|
-        {
-          region_name: "Region #{r}",
-          headquarters: {
-            city: "City #{r}",
-            buildings: (1..num_buildings).map do |b|
-              {
-                building_name: "Building #{r}-#{b}",
-                facilities: {
-                  facility_type: ["Office", "Warehouse", "Lab", "Datacenter"][b % 4],
-                  capacity: 50 + (r * 13) + (b * 7),
-                  utilization_rate: 0.4 + (0.3 * Math.sin(r + b))
-                }
-              }
-            end
-          }
-        }
-      end
-    }
-  }
-end
-
-# Test cases
-test_cases = [
-  { regions: 1, buildings: 1, name: "Tiny" },
-  { regions: 2, buildings: 2, name: "Small" },
-  { regions: 5, buildings: 5, name: "Medium" },
-  { regions: 10, buildings: 10, name: "Large" },
-  { regions: 20, buildings: 10, name: "XLarge" },
-  { regions: 50, buildings: 5, name: "Huge" }
-]
-
-output.puts "=== COMPILATION PERFORMANCE ==="
-output.puts
-
-test_cases.each do |test_case|
-  total_items = test_case[:regions] * test_case[:buildings]
-  
-  time = Benchmark.realtime do
-    test_schema = eval("Module.new { extend Kumi::Schema; #{schema_content} }")
-  end
-  
-  output.puts "#{test_case[:name].ljust(8)} (#{total_items.to_s.rjust(3)} items): #{(time * 1000).round(2).to_s.rjust(8)}ms"
-end
-
-output.puts
-output.puts "=== EXECUTION PERFORMANCE ==="
-output.puts
-
-test_cases.each do |test_case|
-  total_items = test_case[:regions] * test_case[:buildings]
-  data = generate_test_data(test_case[:regions], test_case[:buildings])
-  
-  # Warm up
-  schema.from(data)
-  
-  # Multiple runs for accuracy
-  times = []
-  5.times do
-    time = Benchmark.realtime do
-      runner = schema.from(data)
-      # Force evaluation of all values
-      runner[:org_name]
-      runner[:region_names]
-      runner[:hq_cities]
-      runner[:building_names]
-      runner[:facility_types]
-      runner[:capacities]
-      runner[:utilization_rates]
-      runner[:org_classification]
-      runner[:total_capacity]
-    end
-    times << time
-  end
-  
-  avg_time = times.sum / times.length
-  min_time = times.min
-  max_time = times.max
-  throughput = total_items / avg_time / 1000  # items per ms
-  
-  output.puts "#{test_case[:name].ljust(8)} (#{total_items.to_s.rjust(3)} items): avg=#{(avg_time * 1000).round(2).to_s.rjust(6)}ms, throughput=#{throughput.round(1).to_s.rjust(6)} items/ms"
-end
-
-output.puts
-output.puts "=== SCALING ANALYSIS ==="
-output.puts
-
-# Test linear scaling
-[50, 100, 200, 400, 800].each do |total_items|
-  regions = (total_items / 5).to_i
-  buildings = 5
-  
-  data = generate_test_data(regions, buildings)
-  
-  time = Benchmark.realtime do
-    runner = schema.from(data)
-    runner[:total_capacity]  # Most complex operation
-  end
-  
-  throughput = total_items / time / 1000
-  output.puts "#{total_items.to_s.rjust(3)} items: #{(time * 1000).round(2).to_s.rjust(6)}ms (#{throughput.round(1)} items/ms)"
-end
-
-output.puts
-output.puts "=== MEMORY ANALYSIS ==="
-output.puts
-
-large_data = generate_test_data(100, 5)  # 500 items
-before_memory = `ps -o rss -p #{Process.pid}`.split("\n").last.to_i
-
-10.times do |i|
-  runner = schema.from(large_data)
-  runner[:total_capacity]
-  
-  if i % 3 == 0
-    GC.start
-    current_memory = `ps -o rss -p #{Process.pid}`.split("\n").last.to_i
-    output.puts "Iteration #{i}: RSS=#{current_memory}KB (Δ#{current_memory - before_memory}KB)"
-  end
-end
-
-output.puts
-output.puts "=== SAMPLE OUTPUT VALIDATION ==="
-output.puts
-
-test_data = generate_test_data(2, 2)
-runner = schema.from(test_data)
-
-output.puts "org_name: #{runner[:org_name]}"
-output.puts "region_names: #{runner[:region_names]}"
-output.puts "total_capacity: #{runner[:total_capacity]}"
-output.puts "org_classification: #{runner[:org_classification]}"
-
-output.puts
-output.puts "=== PERFORMANCE BOTTLENECKS IDENTIFIED ==="
-output.puts
-
-output.puts "1. Deep nesting (5+ levels) creates complex IR with many lift operations"
-output.puts "2. Each nested access requires scope transitions"
-output.puts "3. Compilation cold start: ~80ms first time"
-output.puts "4. Linear scaling with data size is expected behavior"
-output.puts "5. Memory usage is stable (no leaks detected)"
-
-output.puts
-output.puts "=== RECOMMENDATIONS ==="
-output.puts
-
-output.puts "• For production: Cache compiled schemas to avoid cold start"
-output.puts "• For large datasets: Consider schema restructuring to reduce nesting"
-output.puts "• Current performance acceptable for <1000 items"
-output.puts "• Deep nesting workable but monitor performance with >10,000 items"
-
-output.close
-
-puts
-puts "📊 Performance test complete! Results saved to performance_results.txt"