kumi 0.0.18 → 0.0.20

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Dev
+    module Golden
+      class Suite
+        attr_reader :base_dir, :representations
+
+        def initialize(base_dir: "golden", representations: REPRESENTATIONS)
+          @base_dir = base_dir
+          @representations = representations
+        end
+
+        def list
+          schema_names.each { |name| puts name }
+        end
+
+        def update(name = nil)
+          names = name ? [name] : schema_names
+          results = update_schemas(names)
+          Reporter.new.report_update(results)
+        end
+
+        def verify(name = nil)
+          names = name ? [name] : schema_names
+          results = verify_schemas(names)
+          Reporter.new.report_verify(results)
+        end
+
+        def diff(name = nil)
+          names = name ? [name] : schema_names
+          results = diff_schemas(names)
+          Reporter.new.report_diff(results)
+        end
+
+        def test(name = nil)
+          names = name ? [name] : schema_names
+
+          update_schemas(names)
+
+          ruby_results = run_runtime_tests(names, :ruby)
+          js_results = run_runtime_tests(names, :javascript)
+
+          Reporter.new.report_runtime_tests(
+            ruby: ruby_results,
+            javascript: js_results
+          )
+        end
+
+        private
+
+        def schema_names
+          Dir.glob(File.join(base_dir, "*/schema.kumi"))
+             .map { |path| File.basename(File.dirname(path)) }
+             .sort
+        end
+
+        def schema_path(name)
+          File.join(base_dir, name, "schema.kumi")
+        end
+
+        def expected_dir(name)
+          File.join(base_dir, name, "expected")
+        end
+
+        def tmp_dir(name)
+          File.join(base_dir, name, "tmp")
+        end
+
+        def schema_dir(name)
+          File.join(base_dir, name)
+        end
+
+        def update_schemas(names)
+          names.each_with_object({}) do |name, results|
+            path = schema_path(name)
+            unless File.exist?(path)
+              puts "Warning: #{path} not found, skipping"
+              next
+            end
+
+            generator = Generator.new(name, path, expected_dir(name))
+            results[name] = generator.update_all(representations)
+          end
+        end
+
+        def verify_schemas(names)
+          names.each_with_object({}) do |name, results|
+            path = schema_path(name)
+            unless File.exist?(path)
+              puts "Warning: #{path} not found, skipping"
+              next
+            end
+
+            generator = Generator.new(name, path, tmp_dir(name))
+            generator.generate_all(representations, tmp_dir(name))
+
+            verifier = Verifier.new(name, expected_dir(name), tmp_dir(name))
+            results[name] = verifier.verify_all(representations)
+          end
+        end
+
+        def diff_schemas(names)
+          names.each_with_object({}) do |name, results|
+            verifier = Verifier.new(name, expected_dir(name), tmp_dir(name))
+            results[name] = verifier.verify_all(representations)
+          end
+        end
+
+        def run_runtime_tests(names, language)
+          testable_names = filter_testable_schemas(names, language)
+
+          testable_names.map do |name|
+            RuntimeTest.new(name, language).run(schema_dir(name))
+          end
+        end
+
+        def filter_testable_schemas(names, language)
+          extension = language == :ruby ? "rb" : "mjs"
+          code_filename = "expected/schema_#{language}.#{extension}"
+
+          names.select do |name|
+            File.exist?(File.join(schema_dir(name), code_filename)) &&
+              File.exist?(File.join(schema_dir(name), "input.json")) &&
+              File.exist?(File.join(schema_dir(name), "expected.json"))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Dev
+    module Golden
+      class Verifier
+        attr_reader :schema_name, :expected_dir, :actual_dir
+
+        def initialize(schema_name, expected_dir, actual_dir)
+          @schema_name = schema_name
+          @expected_dir = expected_dir
+          @actual_dir = actual_dir
+        end
+
+        def verify_all(representations)
+          representations.map do |repr|
+            verify_representation(repr)
+          end
+        end
+
+        private
+
+        def verify_representation(repr)
+          expected_file = File.join(expected_dir, repr.filename)
+          actual_file = File.join(actual_dir, repr.filename)
+
+          unless File.exist?(expected_file)
+            return VerificationResult.new(
+              schema_name: schema_name,
+              representation: repr.name,
+              status: :missing_expected
+            )
+          end
+
+          unless File.exist?(actual_file)
+            return VerificationResult.new(
+              schema_name: schema_name,
+              representation: repr.name,
+              status: :missing_actual
+            )
+          end
+
+          expected_content = File.read(expected_file)
+          actual_content = File.read(actual_file)
+
+          if expected_content.strip == actual_content.strip
+            VerificationResult.new(
+              schema_name: schema_name,
+              representation: repr.name,
+              status: :passed
+            )
+          else
+            VerificationResult.new(
+              schema_name: schema_name,
+              representation: repr.name,
+              status: :failed,
+              diff: compute_diff(expected_file, actual_file)
+            )
+          end
+        rescue StandardError => e
+          VerificationResult.new(
+            schema_name: schema_name,
+            representation: repr.name,
+            status: :error,
+            error: e.message
+          )
+        end
+
+        def compute_diff(expected_file, actual_file)
+          output, status = Open3.capture2("diff", "-u", expected_file, actual_file)
+          status.success? ? nil : output
+        end
+      end
+    end
+  end
+end

data/lib/kumi/dev/golden.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "open3"
+
+require_relative "golden/representation"
+require_relative "golden/result"
+require_relative "golden/generator"
+require_relative "golden/verifier"
+require_relative "golden/runtime_test"
+require_relative "golden/reporter"
+require_relative "golden/suite"
+
+module Kumi
+  module Dev
+    module Golden
+      module_function
+
+      def list
+        suite.list
+      end
+
+      def update!(name = nil)
+        suite.update(name)
+      end
+
+      def verify!(name = nil)
+        suite.verify(name)
+      end
+
+      def diff!(name = nil)
+        suite.diff(name)
+      end
+
+      def test_all_codegen!(name = nil)
+        names = name ? [name] : suite.send(:schema_names)
+
+        ruby_names = suite.send(:filter_testable_schemas, names, :ruby)
+        ruby_results = ruby_names.map do |schema_name|
+          RuntimeTest.new(schema_name, :ruby).run(suite.send(:schema_dir, schema_name))
+        end
+
+        js_names = suite.send(:filter_testable_schemas, names, :javascript)
+        js_results = js_names.map do |schema_name|
+          RuntimeTest.new(schema_name, :javascript).run(suite.send(:schema_dir, schema_name))
+        end
+
+        Reporter.new.report_runtime_tests(ruby: ruby_results, javascript: js_results)
+      end
+
+      def test_codegen!(name = nil)
+        names = name ? [name] : suite.send(:schema_names)
+        testable_names = suite.send(:filter_testable_schemas, names, :ruby)
+        results = testable_names.map do |schema_name|
+          RuntimeTest.new(schema_name, :ruby).run(suite.send(:schema_dir, schema_name))
+        end
+        Reporter.new.report_runtime_tests(ruby: results)
+      end
+
+      def test_js_codegen!(name = nil)
+        names = name ? [name] : suite.send(:schema_names)
+        testable_names = suite.send(:filter_testable_schemas, names, :javascript)
+        results = testable_names.map do |schema_name|
+          RuntimeTest.new(schema_name, :javascript).run(suite.send(:schema_dir, schema_name))
+        end
+        Reporter.new.report_runtime_tests(javascript: results)
+      end
+
+      def suite
+        @suite ||= Suite.new
+      end
+    end
+  end
+end

data/lib/kumi/dev/ir.rb

@@ -13,10 +13,10 @@ module Kumi
         lines = []
         lines << "IR Module"
         lines << "decls: #{ir_module.decls.size}"
-        
+
         ir_module.decls.each_with_index do |decl, i|
           lines << "decl[#{i}] #{decl.kind}:#{decl.name} shape=#{decl.shape} ops=#{decl.ops.size}"
-          
+
           decl.ops.each_with_index do |op, j|
             # Sort attribute keys for deterministic output
             sorted_attrs = op.attrs.keys.sort.map { |k| "#{k}=#{format_value(op.attrs[k])}" }.join(" ")
@@ -24,7 +24,7 @@ module Kumi
             lines << "  #{j}: #{op.tag} #{sorted_attrs} #{args_str}".rstrip
           end
         end
-        
+
         lines.join("\n") + "\n"
       end
 
@@ -72,4 +72,4 @@ module Kumi
       end
     end
   end
-end
+end

data/lib/kumi/dev/parse.rb

@@ -11,7 +11,7 @@ module Kumi
         # Load schema via text frontend
         begin
           schema, _inputs = Kumi::Frontends::Text.load(path: schema_path)
-        rescue LoadError => e
+        rescue LoadError
           puts "Error: kumi-parser gem not available. Install: gem install kumi-parser"
           return false
         rescue StandardError => e

data/lib/kumi/dev/pretty_printer.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "printer/irv2_formatter"
+
+module Kumi
+  module Dev
+    module PrettyPrinter
+      module_function
+
+      def run(kind, path)
+        method_name = "generate_#{kind}"
+        raise "Unknown pretty print kind: #{kind}" unless respond_to?(method_name)
+
+        output = send(method_name, path)
+        puts output if output
+      end
+
+      def with_stop_after(pass_name)
+        saved = {
+          "KUMI_STOP_AFTER" => ENV.fetch("KUMI_STOP_AFTER", nil),
+          "KUMI_CHECKPOINT" => ENV.fetch("KUMI_CHECKPOINT", nil),
+          "KUMI_RESUME_FROM" => ENV.fetch("KUMI_RESUME_FROM", nil),
+          "KUMI_RESUME_AT" => ENV.fetch("KUMI_RESUME_AT", nil)
+        }
+
+        ENV["KUMI_STOP_AFTER"] = pass_name
+        ENV["KUMI_CHECKPOINT"] = "0"
+        ENV.delete("KUMI_RESUME_FROM")
+        ENV.delete("KUMI_RESUME_AT")
+
+        yield
+      ensure
+        saved.each { |k, v| v ? ENV[k] = v : ENV.delete(k) }
+      end
+
+      def generate_ast(path)
+        schema, = Kumi::Frontends.load(path: path)
+        Kumi::Support::SExpressionPrinter.print(schema)
+      end
+
+      def generate_input_plan(path)
+        schema, = Kumi::Frontends.load(path: path)
+        res = Kumi::Analyzer.analyze!(schema, return_with_state: :input_metadata)
+        return nil unless res.state[:input_metadata]
+
+        print_input_plan(res.state[:input_metadata])
+      end
+
+      def print_input_plan(metadata, indent = 0)
+        lines = []
+        metadata.each do |name, node|
+          lines << format_node(name, node, indent)
+        end
+        lines.join("\n")
+      end
+
+      def format_node(name, node, indent)
+        prefix = "  " * indent
+        result = []
+
+        # Node header with type and container
+        header = "#{prefix}#{name}: #{node.type}"
+        header += " (#{node.container})" if node.container != :scalar
+        header += " access_mode=#{node.access_mode}" if node.access_mode
+        result << header
+
+        # Child steps if any
+        if node.child_steps && !node.child_steps.empty?
+          node.child_steps.each do |child_name, steps|
+            steps_str = steps.map { |s| s[:kind] }.join(" → ")
+            result << "#{prefix}  └─> #{child_name}: #{steps_str}"
+          end
+        end
+
+        # Recursively print children
+        if node.children && !node.children.empty?
+          node.children.each do |child_name, child_node|
+            result << format_node(child_name, child_node, indent + 1)
+          end
+        end
+
+        result.join("\n")
+      end
+
+      def generate_ir(path)
+        schema, = Kumi::Frontends.load(path: path)
+        res = Kumi::Analyzer.analyze!(schema)
+        return nil unless res.state[:ir_module]
+
+        Kumi::Support::IRRender.to_text(res.state[:ir_module], analysis_state: res.state)
+      end
+
+      def generate_nast(path)
+        schema, = Kumi::Frontends.load(path: path)
+        with_stop_after("NormalizeToNASTPass") do
+          res = Kumi::Analyzer.analyze!(schema)
+          return nil unless res.state[:nast_module]
+
+          Kumi::Support::NASTPrinter.print(res.state[:nast_module])
+        end
+      end
+
+      def generate_lir_00_unoptimized(path)
+        schema, = Kumi::Frontends.load(path: path)
+        res = Kumi::Analyzer.analyze!(schema, side_tables: true)
+        raise "Error Generating #{path}" unless res.state[:lir_00_unoptimized]
+
+        Kumi::Support::LIRPrinter.print(res.state[:lir_00_unoptimized])
+      end
+
+      def generate_lir_01_hoist_scalar_references(path)
+        schema, = Kumi::Frontends.load(path: path)
+        res = Kumi::Analyzer.analyze!(schema, side_tables: true)
+        raise "Error Generating #{path}" unless res.state[:lir_01_hoist_scalar_references]
+
+        Kumi::Support::LIRPrinter.print(res.state[:lir_01_hoist_scalar_references])
+      end
+
+      def generate_lir_02_inlined(path)
+        schema, = Kumi::Frontends.load(path: path)
+        res = Kumi::Analyzer.analyze!(schema, side_tables: true)
+        raise "Error Generating #{path}" unless res.state[:lir_02_inlined_ops_by_decl]
+
+        Kumi::Support::LIRPrinter.print(res.state[:lir_02_inlined_ops_by_decl])
+      end
+
+      def generate_lir_04_1_loop_fusion(path)
+        schema, = Kumi::Frontends.load(path: path)
+        res = Kumi::Analyzer.analyze!(schema, side_tables: true)
+        raise "Error Generating #{path}" unless res.state[:lir_04_1_loop_fusion]
+
+        Kumi::Support::LIRPrinter.print(res.state[:lir_04_1_loop_fusion])
+      end
+
+      def generate_lir_03_cse(path)
+        schema, = Kumi::Frontends.load(path: path)
+        res = Kumi::Analyzer.analyze!(schema, side_tables: true)
+        raise "Error Generating #{path}" unless res.state[:lir_03_cse]
+
+        Kumi::Support::LIRPrinter.print(res.state[:lir_03_cse])
+      end
+
+      def generate_lir_04_loop_invcm(path)
+        schema, = Kumi::Frontends.load(path: path)
+        res = Kumi::Analyzer.analyze!(schema, side_tables: true)
+        raise "Error Generating #{path}" unless res.state[:lir_04_loop_invcm]
+
+        Kumi::Support::LIRPrinter.print(res.state[:lir_04_loop_invcm])
+      end
+
+      def generate_lir_05_global_cse(path)
+        schema, = Kumi::Frontends.load(path: path)
+        res = Kumi::Analyzer.analyze!(schema, side_tables: true)
+        raise "Error Generating #{path}" unless res.state[:lir_05_global_cse]
+
+        Kumi::Support::LIRPrinter.print(res.state[:lir_05_global_cse])
+      end
+
+      def generate_lir_06_const_prop(path)
+        schema, = Kumi::Frontends.load(path: path)
+        res = Kumi::Analyzer.analyze!(schema, side_tables: true)
+        raise "Error Generating #{path}" unless res.state[:lir_06_const_prop]
+
+        Kumi::Support::LIRPrinter.print(res.state[:lir_06_const_prop])
+      end
+
+      def generate_snast(path)
+        schema, = Kumi::Frontends.load(path: path)
+        with_stop_after("SNASTPass") do
+          res = Kumi::Analyzer.analyze!(schema)
+          raise "Error Generating #{path}" unless res.state[:snast_module]
+
+          Kumi::Support::SNASTPrinter.print(res.state[:snast_module])
+        end
+      end
+
+      def generate_irv2(path)
+        schema, = Kumi::Frontends.load(path: path)
+        res = Kumi::Analyzer.analyze!(schema, side_tables: true)
+        return nil unless res.state[:irv2]
+
+        Printer::WidthAwareJson.dump(res.state[:irv2])
+      end
+
+      def generate_binding_manifest(path)
+        schema, = Kumi::Frontends.load(path: path)
+        res = Kumi::Analyzer.analyze!(schema, side_tables: true)
+        return nil unless res.state[:binding_manifest]
+
+        Printer::WidthAwareJson.dump(res.state[:binding_manifest])
+      end
+
+      def generate_schema_ruby(path)
+        schema, = Kumi::Frontends.load(path: path)
+        res = Kumi::Analyzer.analyze!(schema, side_tables: true)
+        return nil unless res.state[:ruby_codegen_files]
+
+        res.state[:ruby_codegen_files]["codegen.rb"]
+      end
+
+      def generate_schema_javascript(path)
+        schema, = Kumi::Frontends.load(path: path)
+        res = Kumi::Analyzer.analyze!(schema, side_tables: true)
+        return nil unless res.state[:javascript_codegen_files]
+
+        res.state[:javascript_codegen_files]["codegen.mjs"]
+      end
+
+      def generate_planning(path)
+        require_relative "../codegen/planning"
+
+        schema, = Kumi::Frontends.load(path: path)
+        res = Kumi::Analyzer.analyze!(schema, side_tables: true)
+        return nil unless res.state[:irv2]
+
+        bundle = Kumi::Codegen::Planning.from_ir(res.state[:irv2])
+        planning_data = Kumi::Codegen::Planning.to_json(bundle)
+        Printer::WidthAwareJson.dump(planning_data)
+      end
+
+      def generate_pack(path)
+        require_relative "../pack"
+
+        Kumi::Pack.print(schema: path, targets: %w[ruby])
+      end
+    end
+  end
+end