kumi 0.0.18 → 0.0.19

data/lib/kumi/dev/codegen.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module Kumi
+  module Dev
+    module Codegen
+      module_function
+
+      def list
+        available_schemas.each do |name|
+          puts name
+        end
+      end
+
+      def build!(schema_name, targets: %w[ruby], output_dir: nil)
+        schema_path = find_schema_path(schema_name)
+        raise "Schema '#{schema_name}' not found" unless schema_path
+
+        output_dir ||= "codegen/#{schema_name}"
+        FileUtils.mkdir_p(output_dir)
+
+        targets.each do |target|
+          case target
+          when "ruby"
+            build_ruby!(schema_path, output_dir)
+          else
+            puts "Warning: Unknown target '#{target}'"
+          end
+        end
+
+        puts "Generated code in #{output_dir}"
+      end
+
+      def test!(*schema_names)
+        names = schema_names.empty? ? available_schemas : schema_names.flatten
+        success = true
+        total_tests = 0
+        passed_tests = 0
+
+        names.each do |name|
+          puts "Testing #{name}..."
+
+          begin
+            schema_success, schema_total, schema_passed = test_schema!(name)
+            success &&= schema_success
+            total_tests += schema_total
+            passed_tests += schema_passed
+          rescue StandardError => e
+            puts "  ✗ #{name}: ERROR - #{e.message}"
+            success = false
+          end
+        end
+
+        puts "=== Test Summary ==="
+        puts "Schemas: #{names.length}"
+        puts "Total: #{total_tests}"
+        puts "Passed: #{passed_tests}"
+        puts "Failed: #{total_tests - passed_tests}"
+        success_rate = total_tests > 0 ? (passed_tests.to_f / total_tests * 100).round(1) : 0
+        puts "Success rate: #{success_rate}%"
+
+        success
+      end
+
+      def verify!(schema_name)
+        schema_path = find_schema_path(schema_name)
+        raise "Schema '#{schema_name}' not found" unless schema_path
+
+        output_dir = "codegen/#{schema_name}"
+        expected_file = "#{output_dir}/expected.json"
+
+        unless File.exist?(expected_file)
+          puts "No expected outputs for #{schema_name}"
+          return false
+        end
+
+        build!(schema_name, output_dir: output_dir)
+        test_schema!(schema_name)
+      end
+
+      def schema_paths
+        Dir.glob("golden/*/schema.kumi") + Dir.glob("schemas/*.kumi")
+      end
+
+      def available_schemas
+        schema_paths.map do |path|
+          if path.start_with?("golden/")
+            # Extract schema name from golden/SCHEMA_NAME/schema.kumi
+            path.split("/")[1]
+          else
+            # For standalone schemas, use the filename without extension
+            File.basename(path, ".kumi")
+          end
+        end.uniq.sort
+      end
+
+      def find_schema_path(name)
+        candidates = [
+          "golden/#{name}/schema.kumi",
+          "schemas/#{name}.kumi",
+          name.end_with?(".kumi") ? name : "#{name}.kumi"
+        ]
+
+        candidates.find { |path| File.exist?(path) }
+      end
+
+      def build_ruby!(schema_path, output_dir)
+        schema, = Kumi::Frontends.load(path: schema_path)
+        result = Kumi::Analyzer.analyze!(schema)
+
+        code = result.state[:ruby_codegen_files]["codegen.rb"]
+
+        File.write("#{output_dir}/schema_ruby.rb", ruby_code)
+        puts "  ✓ Ruby code generated"
+
+        ruby_code
+      end
+
+      def test_schema!(schema_name)
+        output_dir = "codegen/#{schema_name}"
+        generated_file = "#{output_dir}/schema_ruby.rb"
+        input_file = find_test_input(schema_name)
+        expected_file = find_expected_output(schema_name)
+
+        unless File.exist?(generated_file)
+          puts "  ✗ No generated code found"
+          return [false, 0, 0]
+        end
+
+        unless input_file && File.exist?(input_file)
+          puts "  ✗ No test input found"
+          return [false, 0, 0]
+        end
+
+        unless expected_file && File.exist?(expected_file)
+          puts "  ✗ No expected output found"
+          return [false, 0, 0]
+        end
+
+        code = File.read(generated_file)
+        input_data = JSON.parse(File.read(input_file))
+        expected_outputs = JSON.parse(File.read(expected_file))
+
+        temp_file = "#{output_dir}/test_runner.rb"
+        File.write(temp_file, code)
+
+        begin
+          load temp_file
+
+          registry = Kumi::KernelRegistry.load_ruby
+          program = Generated::Program.new(registry: registry)
+          bound = program.from(input_data)
+
+          total = expected_outputs.size
+          passed = 0
+
+          expected_outputs.each do |decl_name, expected_value|
+            actual = bound[decl_name.to_sym]
+            if actual == expected_value
+              puts "  ✓ #{decl_name}: #{actual.inspect}"
+              passed += 1
+            else
+              puts "  ✗ #{decl_name}: got #{actual.inspect}, expected #{expected_value.inspect}"
+            end
+          end
+
+          [passed == total, total, passed]
+        ensure
+          FileUtils.rm_f(temp_file)
+        end
+      end
+
+      def find_test_input(schema_name)
+        candidates = [
+          "golden/#{schema_name}/input.json",
+          "codegen/#{schema_name}/input.json",
+          "test/inputs/#{schema_name}.json"
+        ]
+        candidates.find { |path| File.exist?(path) }
+      end
+
+      def find_expected_output(schema_name)
+        candidates = [
+          "golden/#{schema_name}/expected.json",
+          "codegen/#{schema_name}/expected.json",
+          "test/outputs/#{schema_name}.json"
+        ]
+        candidates.find { |path| File.exist?(path) }
+      end
+    end
+  end
+end

data/lib/kumi/dev/golden/generator.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Kumi
+  module Dev
+    module Golden
+      class Generator
+        attr_reader :schema_name, :schema_path, :expected_dir
+
+        def initialize(schema_name, schema_path, expected_dir)
+          @schema_name = schema_name
+          @schema_path = schema_path
+          @expected_dir = expected_dir
+        end
+
+        def update_all(representations)
+          FileUtils.mkdir_p(expected_dir)
+
+          representations.map do |repr|
+            update_representation(repr)
+          end
+        end
+
+        def generate_all(representations, output_dir)
+          FileUtils.mkdir_p(output_dir)
+
+          representations.map do |repr|
+            generate_representation(repr, output_dir)
+          end
+        end
+
+        private
+
+        def update_representation(repr)
+          output = generate_output(repr)
+          return GenerationResult.new(
+            schema_name: schema_name,
+            representation: repr.name,
+            status: :skipped
+          ) unless output
+
+          expected_file = File.join(expected_dir, repr.filename)
+
+          if File.exist?(expected_file)
+            expected_content = File.read(expected_file)
+            if output.strip == expected_content.strip
+              return GenerationResult.new(
+                schema_name: schema_name,
+                representation: repr.name,
+                status: :unchanged
+              )
+            end
+          end
+
+          File.write(expected_file, output)
+          status = File.exist?(expected_file) && File.read(expected_file).strip != output.strip ? :created : :updated
+
+          GenerationResult.new(
+            schema_name: schema_name,
+            representation: repr.name,
+            status: status,
+            changed: true
+          )
+        rescue StandardError => e
+          GenerationResult.new(
+            schema_name: schema_name,
+            representation: repr.name,
+            status: :error,
+            error: e.message
+          )
+        end
+
+        def generate_representation(repr, output_dir)
+          output = generate_output(repr)
+          return GenerationResult.new(
+            schema_name: schema_name,
+            representation: repr.name,
+            status: :skipped
+          ) unless output
+
+          output_file = File.join(output_dir, repr.filename)
+          File.write(output_file, output)
+
+          GenerationResult.new(
+            schema_name: schema_name,
+            representation: repr.name,
+            status: :generated
+          )
+        rescue StandardError => e
+          GenerationResult.new(
+            schema_name: schema_name,
+            representation: repr.name,
+            status: :error,
+            error: e.message
+          )
+        end
+
+        def generate_output(repr)
+          repr.generate(schema_path)
+        end
+      end
+    end
+  end
+end

data/lib/kumi/dev/golden/reporter.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Dev
+    module Golden
+      class Reporter
+        def report_update(results_by_schema)
+          changed_any = false
+          changed_schemas = []
+          errors = []
+
+          results_by_schema.each do |schema_name, results|
+            schema_changed = false
+
+            results.each do |result|
+              if result.changed?
+                puts "  #{schema_name}/#{result.representation}.* (#{result.status})"
+                schema_changed = true
+                changed_any = true
+              elsif result.error?
+                errors << "  ✗ #{schema_name}/#{result.representation} (error: #{result.error})"
+              end
+            end
+
+            changed_schemas << schema_name if schema_changed
+          end
+
+          if errors.any?
+            puts
+            errors.each { |e| puts e }
+          end
+
+          if changed_any
+            puts
+            puts "Updated #{changed_schemas.size} schema(s)"
+          else
+            puts "All schemas up to date"
+          end
+        end
+
+        def report_verify(results_by_schema)
+          success = true
+
+          results_by_schema.each do |schema_name, results|
+            failed_reprs = results.select { |r| !r.passed? }
+
+            if failed_reprs.empty?
+              puts "✓ #{schema_name}"
+            else
+              success = false
+              failed_msgs = failed_reprs.map do |r|
+                case r.status
+                when :missing_expected
+                  "#{r.representation}.* (no expected file)"
+                when :missing_actual
+                  "#{r.representation}.* (no actual file)"
+                when :error
+                  "#{r.representation}.* (error: #{r.error})"
+                else
+                  "#{r.representation}.*"
+                end
+              end
+              puts "✗ #{schema_name} (#{failed_msgs.join(', ')})"
+            end
+          end
+
+          success
+        end
+
+        def report_diff(results_by_schema)
+          results_by_schema.each do |schema_name, results|
+            results.each do |result|
+              if result.failed? && result.diff
+                puts "=== #{schema_name}/#{result.representation}.* ==="
+                puts result.diff
+                puts
+              end
+            end
+          end
+        end
+
+        def report_runtime_tests(results_by_language)
+          success = true
+
+          # Organize results by schema
+          results_by_schema = {}
+          results_by_language.each do |language, schema_results|
+            schema_results.each do |result|
+              results_by_schema[result.schema_name] ||= {}
+              results_by_schema[result.schema_name][language] = result
+            end
+          end
+
+          # Report failures first
+          failed_schemas = results_by_schema.select do |_, lang_results|
+            lang_results.values.any? { |r| r.error || !r.passed? }
+          end
+
+          if failed_schemas.any?
+            puts "Failures:"
+            failed_schemas.each do |schema_name, lang_results|
+              lang_results.each do |language, result|
+                if result.error
+                  puts "  ✗ #{schema_name} [#{language}]: #{result.error}"
+                  success = false
+                elsif !result.passed?
+                  puts "  ✗ #{schema_name} [#{language}]: #{result.passed_count}/#{result.total_count} passed"
+                  success = false
+
+                  result.test_results.select(&:failed?).each do |test|
+                    puts "      #{test.decl_name}: got #{test.actual.inspect}, expected #{test.expected.inspect}"
+                  end
+                end
+              end
+            end
+            puts
+          end
+
+          # Print summary
+          print_combined_summary(results_by_language)
+
+          success
+        end
+
+        private
+
+        def print_combined_summary(results_by_language)
+          stats = {}
+
+          results_by_language.each do |language, schema_results|
+            total_tests = 0
+            passed_tests = 0
+            schema_count = schema_results.size
+
+            schema_results.each do |result|
+              total_tests += result.total_count
+              passed_tests += result.passed_count
+            end
+
+            stats[language] = {
+              schemas: schema_count,
+              total: total_tests,
+              passed: passed_tests,
+              failed: total_tests - passed_tests
+            }
+          end
+
+          # Print combined summary
+          languages = stats.keys.sort
+          puts "Summary:"
+          languages.each do |language|
+            s = stats[language]
+            status = s[:failed] == 0 ? "✓" : "✗"
+            puts "  #{status} #{language}: #{s[:passed]}/#{s[:total]} passed across #{s[:schemas]} schemas"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kumi/dev/golden/representation.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Dev
+    module Golden
+      class Representation
+        attr_reader :name, :extension, :generator_method
+
+        def initialize(name, extension:, generator: nil)
+          @name = name
+          @extension = extension
+          @generator_method = generator || "generate_#{name}"
+        end
+
+        def filename
+          "#{name}.#{extension}"
+        end
+
+        def generate(schema_path)
+          unless PrettyPrinter.respond_to?(generator_method)
+            raise "Unknown generator method: #{generator_method}"
+          end
+
+          PrettyPrinter.send(generator_method, schema_path)
+        end
+      end
+
+      REPRESENTATIONS = [
+        Representation.new("ast", extension: "txt"),
+        Representation.new("input_plan", extension: "txt"),
+        Representation.new("nast", extension: "txt"),
+        Representation.new("snast", extension: "txt"),
+        Representation.new("lir_00_unoptimized", extension: "txt"),
+        Representation.new("lir_01_hoist_scalar_references", extension: "txt"),
+        Representation.new("lir_02_inlined", extension: "txt"),
+        Representation.new("lir_04_1_loop_fusion", extension: "txt"),
+        Representation.new("lir_03_cse", extension: "txt"),
+        Representation.new("lir_04_loop_invcm", extension: "txt"),
+        Representation.new("lir_06_const_prop", extension: "txt"),
+        Representation.new("schema_ruby", extension: "rb"),
+        Representation.new("schema_javascript", extension: "mjs")
+      ].freeze
+    end
+  end
+end

data/lib/kumi/dev/golden/result.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Dev
+    module Golden
+      class Result
+        attr_reader :schema_name, :representation, :status, :error
+
+        def initialize(schema_name:, representation:, status:, error: nil)
+          @schema_name = schema_name
+          @representation = representation
+          @status = status
+          @error = error
+        end
+
+        def passed?
+          status == :passed
+        end
+
+        def failed?
+          status == :failed
+        end
+
+        def error?
+          status == :error
+        end
+      end
+
+      class GenerationResult < Result
+        attr_reader :changed
+
+        def initialize(schema_name:, representation:, status:, changed: false, error: nil)
+          super(schema_name: schema_name, representation: representation, status: status, error: error)
+          @changed = changed
+        end
+
+        def changed?
+          @changed
+        end
+      end
+
+      class VerificationResult < Result
+        attr_reader :diff
+
+        def initialize(schema_name:, representation:, status:, diff: nil, error: nil)
+          super(schema_name: schema_name, representation: representation, status: status, error: error)
+          @diff = diff
+        end
+      end
+
+      class RuntimeTestResult
+        attr_reader :schema_name, :decl_name, :expected, :actual, :language
+
+        def initialize(schema_name:, decl_name:, expected:, actual:, language:)
+          @schema_name = schema_name
+          @decl_name = decl_name
+          @expected = expected
+          @actual = actual
+          @language = language
+        end
+
+        def passed?
+          actual == expected
+        end
+
+        def failed?
+          !passed?
+        end
+      end
+
+      class SchemaTestResult
+        attr_reader :schema_name, :test_results, :error
+
+        def initialize(schema_name:, test_results: [], error: nil)
+          @schema_name = schema_name
+          @test_results = test_results
+          @error = error
+        end
+
+        def passed?
+          error.nil? && test_results.all?(&:passed?)
+        end
+
+        def failed?
+          !passed?
+        end
+
+        def passed_count
+          test_results.count(&:passed?)
+        end
+
+        def total_count
+          test_results.size
+        end
+      end
+    end
+  end
+end

data/lib/kumi/dev/golden/runtime_test.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+
+module Kumi
+  module Dev
+    module Golden
+      class RuntimeTest
+        attr_reader :schema_name, :language
+
+        def initialize(schema_name, language)
+          @schema_name = schema_name
+          @language = language
+        end
+
+        def run(base_dir)
+          expected_outputs = load_expected_outputs(base_dir)
+          actual_outputs = execute_schema(base_dir, expected_outputs.keys)
+
+          test_results = expected_outputs.map do |decl_name, expected_value|
+            RuntimeTestResult.new(
+              schema_name: schema_name,
+              decl_name: decl_name,
+              expected: expected_value,
+              actual: actual_outputs[decl_name],
+              language: language
+            )
+          end
+
+          SchemaTestResult.new(
+            schema_name: schema_name,
+            test_results: test_results
+          )
+        rescue StandardError => e
+          SchemaTestResult.new(
+            schema_name: schema_name,
+            error: e.message
+          )
+        end
+
+        private
+
+        def load_expected_outputs(base_dir)
+          expected_file = File.join(base_dir, "expected.json")
+          JSON.parse(File.read(expected_file))
+        end
+
+        def execute_schema(base_dir, decl_names)
+          case language
+          when :ruby
+            execute_ruby(base_dir, decl_names)
+          when :javascript
+            execute_javascript(base_dir, decl_names)
+          else
+            raise "Unsupported language: #{language}"
+          end
+        end
+
+        def execute_ruby(base_dir, decl_names)
+          code_file = File.join(base_dir, "expected/schema_ruby.rb")
+          input_file = File.join(base_dir, "input.json")
+
+          code = File.read(code_file)
+          input_data = JSON.parse(File.read(input_file))
+
+          module_name = code.match(/module (Kumi::Compiled::\S+)/)[1]
+          eval(code)
+          module_const = Object.const_get(module_name)
+          instance = module_const.from(input_data)
+
+          decl_names.to_h { |name| [name, instance[name.to_sym]] }
+        end
+
+        def execute_javascript(base_dir, decl_names)
+          runner_path = File.expand_path("../support/kumi_runner.mjs", __dir__)
+          raise "JS test runner not found at #{runner_path}" unless File.exist?(runner_path)
+
+          module_path = File.absolute_path(File.join(base_dir, "expected/schema_javascript.mjs"))
+          input_path = File.absolute_path(File.join(base_dir, "input.json"))
+          decl_str = decl_names.join(",")
+
+          command = "node #{runner_path} #{module_path} #{input_path} #{decl_str}"
+          stdout, stderr, status = Open3.capture3(command)
+
+          raise "JS runner failed for '#{schema_name}':\n#{stderr}" unless status.success?
+
+          JSON.parse(stdout)
+        end
+      end
+    end
+  end
+end