kumi 0.0.9 → 0.0.10

data/lib/kumi/syntax/input_element_reference.rb

@@ -2,11 +2,11 @@
 
 module Kumi
   module Syntax
-      # For field usage/reference in expressions (input.field_name)
-      InputElementReference = Struct.new(:path) do
-        include Node
+    # For field usage/reference in expressions (input.field_name)
+    InputElementReference = Struct.new(:path) do
+      include Node
 
-        def children = []
-      end
+      def children = []
+    end
   end
 end

data/lib/kumi/syntax/input_reference.rb

@@ -2,11 +2,11 @@
 
 module Kumi
   module Syntax
-      # For field usage/reference in expressions (input.field_name)
-      InputReference = Struct.new(:name) do
-        include Node
+    # For field usage/reference in expressions (input.field_name)
+    InputReference = Struct.new(:name) do
+      include Node
 
-        def children = []
-      end
+      def children = []
+    end
   end
 end

data/lib/kumi/syntax/literal.rb

@@ -2,10 +2,10 @@
 
 module Kumi
   module Syntax
-      Literal = Struct.new(:value) do
-        include Node
+    Literal = Struct.new(:value) do
+      include Node
 
-        def children = []
-      end
+      def children = []
+    end
   end
 end

data/lib/kumi/syntax/node.rb

@@ -2,45 +2,45 @@
 
 module Kumi
   module Syntax
-      # A struct to hold standardized source location information.
-      Location = Struct.new(:file, :line, :column, keyword_init: true)
+    # A struct to hold standardized source location information.
+    Location = Struct.new(:file, :line, :column, keyword_init: true)
 
-      # Base module included by all AST nodes to provide a standard
-      # interface for accessing source location information..
-      module Node
-        attr_accessor :loc
+    # Base module included by all AST nodes to provide a standard
+    # interface for accessing source location information..
+    module Node
+      attr_accessor :loc
 
-        def initialize(*args, loc: nil, **kwargs)
-          @loc = loc
-          super(*args, **kwargs)
-          freeze
-        end
+      def initialize(*args, loc: nil, **kwargs)
+        @loc = loc
+        super(*args, **kwargs)
+        freeze
+      end
 
-        def ==(other)
-          other.is_a?(self.class) &&
-            # for Struct-based nodes
-            (if respond_to?(:members)
-               members.all? { |m| self[m] == other[m] }
-             else
-               instance_variables.reject { |iv| iv == :@loc }
-                                          .all? do |iv|
-                 instance_variable_get(iv) ==
-                                              other.instance_variable_get(iv)
-               end
+      def ==(other)
+        other.is_a?(self.class) &&
+          # for Struct-based nodes
+          (if respond_to?(:members)
+             members.all? { |m| self[m] == other[m] }
+           else
+             instance_variables.reject { |iv| iv == :@loc }
+                                        .all? do |iv|
+               instance_variable_get(iv) ==
+                                            other.instance_variable_get(iv)
              end
-            )
-        end
-        alias eql? ==
+           end
+          )
+      end
+      alias eql? ==
 
-        def hash
-          values = if respond_to?(:members)
-                     members.map { |m| self[m] }
-                   else
-                     instance_variables.reject { |iv| iv == :@loc }
-                                       .map { |iv| instance_variable_get(iv) }
-                   end
-          [self.class, *values].hash
-        end
+      def hash
+        values = if respond_to?(:members)
+                   members.map { |m| self[m] }
+                 else
+                   instance_variables.reject { |iv| iv == :@loc }
+                                     .map { |iv| instance_variable_get(iv) }
+                 end
+        [self.class, *values].hash
       end
+    end
   end
 end

data/lib/kumi/syntax/root.rb

@@ -2,12 +2,12 @@
 
 module Kumi
   module Syntax
-      # Represents the root of the Abstract Syntax Tree.
-      # It holds all the top-level declarations parsed from the source.
-      Root = Struct.new(:inputs, :attributes, :traits) do
-        include Node
+    # Represents the root of the Abstract Syntax Tree.
+    # It holds all the top-level declarations parsed from the source.
+    Root = Struct.new(:inputs, :attributes, :traits) do
+      include Node
 
-        def children = [inputs, attributes, traits]
-      end
+      def children = [inputs, attributes, traits]
+    end
   end
 end

data/lib/kumi/syntax/trait_declaration.rb

@@ -2,10 +2,10 @@
 
 module Kumi
   module Syntax
-      TraitDeclaration = Struct.new(:name, :expression) do
-        include Node
+    TraitDeclaration = Struct.new(:name, :expression) do
+      include Node
 
-        def children = [expression]
-      end
+      def children = [expression]
+    end
   end
 end

data/lib/kumi/syntax/value_declaration.rb

@@ -2,10 +2,10 @@
 
 module Kumi
   module Syntax
-      ValueDeclaration = Struct.new(:name, :expression) do
-        include Node
+    ValueDeclaration = Struct.new(:name, :expression) do
+      include Node
 
-        def children = [expression]
-      end
+      def children = [expression]
+    end
   end
 end

data/lib/kumi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kumi
-  VERSION = "0.0.9"
+  VERSION = "0.0.10"
 end

data/lib/kumi.rb

@@ -11,7 +11,7 @@ module Kumi
   extend Schema
 
   def self.inspector_from_schema
-    Inspector.new(@__syntax_tree__, @__analyzer_result__, @__compiled_schema__)
+    Schema::Inspector.new(@__syntax_tree__, @__analyzer_result__, @__compiled_schema__)
   end
 
   def self.reset!

data/scripts/analyze_broadcast_methods.rb

@@ -0,0 +1,68 @@
+#!/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

@@ -0,0 +1,74 @@
+#!/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

@@ -0,0 +1,51 @@
+#!/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

data/scripts/find_dead_code.rb

@@ -0,0 +1,114 @@
+#!/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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kumi
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - André Muta
@@ -39,14 +39,16 @@ files:
 - docs/DSL.md
 - docs/FUNCTIONS.md
 - docs/SYNTAX.md
+- docs/compiler_design_principles.md
 - docs/development/README.md
 - docs/development/error-reporting.md
 - docs/features/README.md
 - docs/features/analysis-cascade-mutual-exclusion.md
 - docs/features/analysis-type-inference.md
 - docs/features/analysis-unsat-detection.md
-- docs/features/array-broadcasting.md
+- docs/features/hierarchical-broadcasting.md
 - docs/features/input-declaration-system.md
+- docs/features/javascript-transpiler.md
 - docs/features/performance.md
 - docs/features/s-expression-printer.md
 - docs/schema_metadata.md
@@ -66,7 +68,6 @@ files:
 - examples/wide_schema_compilation_and_evaluation_benchmark.rb
 - lib/kumi.rb
 - lib/kumi/analyzer.rb
-- lib/kumi/cli.rb
 - lib/kumi/compiler.rb
 - lib/kumi/core/analyzer/analysis_state.rb
 - lib/kumi/core/analyzer/constant_evaluator.rb
@@ -84,7 +85,13 @@ files:
 - lib/kumi/core/analyzer/passes/unsat_detector.rb
 - lib/kumi/core/analyzer/passes/visitor_pass.rb
 - lib/kumi/core/atom_unsat_solver.rb
+- lib/kumi/core/cascade_executor_builder.rb
 - lib/kumi/core/compiled_schema.rb
+- lib/kumi/core/compiler/expression_compiler.rb
+- lib/kumi/core/compiler/function_invoker.rb
+- lib/kumi/core/compiler/path_traversal_compiler.rb
+- lib/kumi/core/compiler/reference_compiler.rb
+- lib/kumi/core/compiler_base.rb
 - lib/kumi/core/constraint_relationship_solver.rb
 - lib/kumi/core/domain/enum_analyzer.rb
 - lib/kumi/core/domain/range_analyzer.rb
@@ -109,6 +116,7 @@ files:
 - lib/kumi/core/function_registry/function_builder.rb
 - lib/kumi/core/function_registry/logical_functions.rb
 - lib/kumi/core/function_registry/math_functions.rb
+- lib/kumi/core/function_registry/stat_functions.rb
 - lib/kumi/core/function_registry/string_functions.rb
 - lib/kumi/core/function_registry/type_functions.rb
 - lib/kumi/core/input/type_matcher.rb
@@ -117,6 +125,7 @@ files:
 - lib/kumi/core/json_schema.rb
 - lib/kumi/core/json_schema/generator.rb
 - lib/kumi/core/json_schema/validator.rb
+- lib/kumi/core/nested_structure_utils.rb
 - lib/kumi/core/ruby_parser.rb
 - lib/kumi/core/ruby_parser/build_context.rb
 - lib/kumi/core/ruby_parser/declaration_reference_proxy.rb
@@ -139,8 +148,11 @@ files:
 - lib/kumi/core/types/inference.rb
 - lib/kumi/core/types/normalizer.rb
 - lib/kumi/core/types/validator.rb
-- lib/kumi/core/vectorization_metadata.rb
+- lib/kumi/core/vectorized_function_builder.rb
 - lib/kumi/errors.rb
+- lib/kumi/js.rb
+- lib/kumi/js/compiler.rb
+- lib/kumi/js/function_registry.rb
 - lib/kumi/registry.rb
 - lib/kumi/schema.rb
 - lib/kumi/schema_metadata.rb
@@ -161,6 +173,10 @@ files:
 - lib/kumi/syntax/value_declaration.rb
 - lib/kumi/version.rb
 - migrate_to_core_iterative.rb
+- scripts/analyze_broadcast_methods.rb
+- scripts/analyze_cascade_methods.rb
+- scripts/check_broadcasting_coverage.rb
+- scripts/find_dead_code.rb
 - scripts/generate_function_docs.rb
 homepage: https://github.com/amuta/kumi
 licenses: