kumi 0.0.29 → 0.0.30

data/lib/kumi/core/analyzer/passes/input_form_schema_pass.rb

@@ -5,7 +5,7 @@ module Kumi
     module Analyzer
       module Passes
         class InputFormSchemaPass < PassBase
-          def run(errors)
+          def run(_errors)
             input_metadata = get_state(:input_metadata)
             return state unless input_metadata
 

data/lib/kumi/core/analyzer/passes/lir/loop_invariant_code_motion_pass.rb

@@ -97,7 +97,7 @@ module Kumi
               new_ops
             end
 
-            def is_invariant(ins, defs_in_loop, prefix, depth)
+            def is_invariant(ins, defs_in_loop, prefix, _depth)
               prefix_inner = "#{prefix}      "
               debug "#{prefix_inner}- Checking: #{ins.result_register || '(no result)'} = #{ins.opcode}(#{ins.inputs.join(', ')})"
 

data/lib/kumi/core/analyzer/passes/lir/stencil_emitter.rb

@@ -231,8 +231,6 @@ module Kumi
               when NAST::Ref
                 decl = @snast.decls.fetch(node.name) { return nil }
                 resolve_call(decl.body)
-              else
-                nil
               end
             end
           end

data/lib/kumi/core/analyzer/passes/normalize_to_nast_pass.rb

@@ -80,7 +80,11 @@ module Kumi
               # Try to get the function to check if it's expandable
               # For expandable functions, we need to resolve now
               # For regular functions, we defer resolution to NASTDimensionalAnalyzerPass
-              func = @registry.function(fn_alias) rescue nil
+              func = begin
+                @registry.function(fn_alias)
+              rescue StandardError
+                nil
+              end
             rescue StandardError
               # puts "MISSING_FUNCTION: #{node.fn_name.inspect}"
               raise

data/lib/kumi/core/analyzer/passes/output_schema_pass.rb

@@ -5,7 +5,7 @@ module Kumi
     module Analyzer
       module Passes
         class OutputSchemaPass < PassBase
-          def run(errors)
+          def run(_errors)
             snast_module = get_state(:snast_module)
             return state unless snast_module
 
@@ -19,6 +19,7 @@ module Kumi
           def build_output_schema(snast_module, hints)
             snast_module.decls.each_with_object({}) do |(name, decl), acc|
               next if hints[name][:inline]
+
               acc[name] = build_output_field(decl)
             end
           end

data/lib/kumi/core/analyzer/passes/snast_pass.rb

@@ -176,7 +176,7 @@ module Kumi
             m    = meta_for(n)
             # Use the function ID from metadata (already resolved with type awareness in NASTDimensionalAnalyzerPass)
             fn_id = m[:function] || @registry.resolve_function(n.fn)
-            out  = n.class.new(id: n.id, fn: fn_id.to_sym, args:, opts: n.opts, loc: n.loc)
+            out = n.class.new(id: n.id, fn: fn_id.to_sym, args:, opts: n.opts, loc: n.loc)
             stamp!(out, m[:result_scope], m[:result_type])
           end
 

data/lib/kumi/core/analyzer/passes/unsat_detector.rb

@@ -32,14 +32,14 @@ module Kumi
               next if atoms.empty?
 
               # Check for formal, obvious contradictions
-              if contradicting_equalities?(atoms) || domain_violations?(atoms, input_meta) ||
-                 propagated_violations?(atoms, definitions, input_meta, registry)
-                report_error(
-                  errors,
-                  "conjunction `#{decl.name}` is impossible",
-                  location: decl.loc
-                )
-              end
+              next unless contradicting_equalities?(atoms) || domain_violations?(atoms, input_meta) ||
+                          propagated_violations?(atoms, definitions, input_meta, registry)
+
+              report_error(
+                errors,
+                "conjunction `#{decl.name}` is impossible",
+                location: decl.loc
+              )
             end
 
             state
@@ -90,8 +90,6 @@ module Kumi
               val == :unknown ? node.name : val
             when InputReference
               node.name
-            else
-              nil
             end
           end
 

data/lib/kumi/core/compiler/access_planner_v2.rb

@@ -29,8 +29,7 @@ module Kumi
               axes  << root_name.to_sym
             end
 
-            # Emit normal plan for the root node
-            node_axes = [] # The root axes are always [], e.g. array :x (the container :x opens [:x], but is not inside that dim)
+            # Emit normal plan for the root node # The root axes are always [], e.g. array :x (the container :x opens [:x], but is not inside that dim)
             walk([root_name.to_s], node, steps, axes, steps, [])
 
             # If the root array defines an index, emit a *synthetic* index plan now

data/lib/kumi/core/functions/overload_resolver.rb

@@ -31,13 +31,12 @@ module Kumi
             validate_arity!(s, arg_types)
             fn = @functions[s]
             score = match_score(fn.params, arg_types)
-            if score > 0
-              return s
-            else
-              # Type constraints failed
-              raise ResolutionError,
-                    "#{alias_or_id}(#{format_types(arg_types)}) - type mismatch"
-            end
+            return s if score > 0
+
+            # Type constraints failed
+            raise ResolutionError,
+                  "#{alias_or_id}(#{format_types(arg_types)}) - type mismatch"
+
           end
 
           # Get all candidate overloads for this alias
@@ -50,13 +49,12 @@ module Kumi
             validate_arity!(fn_id, arg_types)
             fn = @functions[fn_id]
             score = match_score(fn.params, arg_types)
-            if score > 0
-              return fn_id
-            else
-              # Type constraints failed for the only overload
-              raise ResolutionError,
-                    "#{alias_or_id}(#{format_types(arg_types)}) - type mismatch"
-            end
+            return fn_id if score > 0
+
+            # Type constraints failed for the only overload
+            raise ResolutionError,
+                  "#{alias_or_id}(#{format_types(arg_types)}) - type mismatch"
+
           end
 
           # Multiple overloads - find best match by type constraints (prefer exact matches)
@@ -68,9 +66,7 @@ module Kumi
 
           best_match, score = candidates_with_scores.max_by { |_, s| s }
 
-          if score > 0
-            return best_match
-          end
+          return best_match if score > 0
 
           # No match found - provide helpful error
           raise ResolutionError,
@@ -134,6 +130,7 @@ module Kumi
           # Check if it's a type category
           if TypeCategories.category?(constraint)
             return false unless type_obj.is_a?(Kumi::Core::Types::ScalarType)
+
             return TypeCategories.includes?(constraint, type_obj.kind)
           end
 
@@ -160,6 +157,7 @@ module Kumi
           # Check if it's a type category
           if TypeCategories.category?(param_dtype_str)
             return false unless arg_type.is_a?(Kumi::Core::Types::ScalarType)
+
             return TypeCategories.includes?(param_dtype_str, arg_type.kind)
           end
 
@@ -189,8 +187,6 @@ module Kumi
                 "function #{fn_id} expects #{fn.params.size} arguments, got #{arg_types.size}"
         end
 
-        private
-
         def format_types(arg_types)
           arg_types.map(&:to_s).join(", ")
         end

data/lib/kumi/core/functions/type_categories.rb

@@ -9,11 +9,11 @@ module Kumi
       class TypeCategories
         # Define type categories as unions of scalar kinds
         CATEGORIES = {
-          numeric: [:integer, :float, :decimal],
-          comparable: [:integer, :float, :decimal, :string],
+          numeric: %i[integer float decimal],
+          comparable: %i[integer float decimal string],
           boolean: [:boolean],
           stringable: [:string],
-          orderable: [:integer, :float, :decimal, :string]
+          orderable: %i[integer float decimal string]
         }.freeze
 
         def self.expand(dtype_constraint)

data/lib/kumi/core/functions/type_error_reporter.rb

@@ -103,14 +103,12 @@ module Kumi
           error
         end
 
-        private
-
         def self.format_overload_error(alias_or_id, arg_types, available_overloads)
           arg_types_str = arg_types.map(&:inspect).join(", ")
           available_str = available_overloads.map { |id| "'#{id}'" }.join(", ")
 
           "no overload of '#{alias_or_id}' matches argument types (#{arg_types_str}). " \
-          "Available overloads: #{available_str}"
+            "Available overloads: #{available_str}"
         end
       end
     end

data/lib/kumi/core/input/type_matcher.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'bigdecimal'
+require "bigdecimal"
 
 module Kumi
   module Core

data/lib/kumi/core/types/normalizer.rb

@@ -14,18 +14,16 @@ module Kumi
             # Already a Type object, return as-is
             type_input
           when Symbol
-            if Validator.valid_kind?(type_input)
-              Kumi::Core::Types.scalar(type_input)
-            else
-              raise ArgumentError, "Invalid type symbol: #{type_input}"
-            end
+            raise ArgumentError, "Invalid type symbol: #{type_input}" unless Validator.valid_kind?(type_input)
+
+            Kumi::Core::Types.scalar(type_input)
+
           when String
             symbol_type = type_input.to_sym
-            if Validator.valid_kind?(symbol_type)
-              Kumi::Core::Types.scalar(symbol_type)
-            else
-              raise ArgumentError, "Invalid type string: #{type_input}"
-            end
+            raise ArgumentError, "Invalid type string: #{type_input}" unless Validator.valid_kind?(symbol_type)
+
+            Kumi::Core::Types.scalar(symbol_type)
+
           when Hash
             raise ArgumentError, "Hash-based types no longer supported, use Type objects instead"
           when Class

data/lib/kumi/core/types/validator.rb

@@ -20,7 +20,7 @@ module Kumi
           when ScalarType
             valid_kind?(type.kind)
           when ArrayType, TupleType
-            true  # If constructed, it's valid
+            true # If constructed, it's valid
           when Symbol
             valid_kind?(type)
           else

data/lib/kumi/core/types/value_objects.rb

@@ -36,6 +36,7 @@ module Kumi
 
         def ==(other)
           return false unless other.is_a?(ScalarType)
+
           @kind == other.kind
         end
 
@@ -61,11 +62,12 @@ module Kumi
         end
 
         def inspect
-          "#<ArrayType:#{to_s}>"
+          "#<ArrayType:#{self}>"
         end
 
         def ==(other)
           return false unless other.is_a?(ArrayType)
+
           @element_type == other.element_type
         end
 
@@ -91,11 +93,12 @@ module Kumi
         end
 
         def inspect
-          "#<TupleType:#{to_s}>"
+          "#<TupleType:#{self}>"
         end
 
         def ==(other)
           return false unless other.is_a?(TupleType)
+
           @element_types == other.element_types
         end
 

data/lib/kumi/core/types.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'types/value_objects'
+require_relative "types/value_objects"
 
 module Kumi
   module Core
@@ -44,9 +44,7 @@ module Kumi
       end
 
       def self.tuple(element_types)
-        unless element_types.is_a?(Array)
-          raise ArgumentError, "tuple expects array of Type objects, got #{element_types.class}"
-        end
+        raise ArgumentError, "tuple expects array of Type objects, got #{element_types.class}" unless element_types.is_a?(Array)
 
         # Convert any non-Type elements to Type objects
         converted = element_types.map do |t|

data/lib/kumi/dev/codegen.rb

@@ -110,7 +110,7 @@ module Kumi
         schema, = Kumi::Frontends.load(path: schema_path)
         result = Kumi::Analyzer.analyze!(schema)
 
-        code = result.state[:ruby_codegen_files]["codegen.rb"]
+        result.state[:ruby_codegen_files]["codegen.rb"]
 
         File.write("#{output_dir}/schema_ruby.rb", ruby_code)
         puts "  ✓ Ruby code generated"

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

@@ -34,11 +34,13 @@ module Kumi
 
         def update_representation(repr)
           output = generate_output(repr)
-          return GenerationResult.new(
-            schema_name: schema_name,
-            representation: repr.name,
-            status: :skipped
-          ) unless output
+          unless output
+            return GenerationResult.new(
+              schema_name: schema_name,
+              representation: repr.name,
+              status: :skipped
+            )
+          end
 
           expected_file = File.join(expected_dir, repr.filename)
 
@@ -73,11 +75,13 @@ module Kumi
 
         def generate_representation(repr, output_dir)
           output = generate_output(repr)
-          return GenerationResult.new(
-            schema_name: schema_name,
-            representation: repr.name,
-            status: :skipped
-          ) unless output
+          unless output
+            return GenerationResult.new(
+              schema_name: schema_name,
+              representation: repr.name,
+              status: :skipped
+            )
+          end
 
           output_file = File.join(output_dir, repr.filename)
           File.write(output_file, output)

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

@@ -79,11 +79,11 @@ module Kumi
         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
+              next unless result.failed? && result.diff
+
+              puts "=== #{schema_name}/#{result.representation}.* ==="
+              puts result.diff
+              puts
             end
           end
         end

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

@@ -17,9 +17,7 @@ module Kumi
         end
 
         def generate(schema_path)
-          unless PrettyPrinter.respond_to?(generator_method)
-            raise "Unknown generator method: #{generator_method}"
-          end
+          raise "Unknown generator method: #{generator_method}" unless PrettyPrinter.respond_to?(generator_method)
 
           PrettyPrinter.send(generator_method, schema_path)
         end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'value_normalizer'
+require_relative "value_normalizer"
 
 module Kumi
   module Dev

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

@@ -77,8 +77,6 @@ module Kumi
           decl_names.to_h { |name| [name, instance[name.to_sym]] }
         end
 
-        private
-
         def convert_decimal_strings(value)
           case value
           when Hash

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

@@ -16,25 +16,41 @@ module Kumi
         end
 
         def update(name = nil)
-          names = name ? (name.is_a?(Array) ? name : [name]) : schema_names
+          names = if name
+                    name.is_a?(Array) ? name : [name]
+                  else
+                    schema_names
+                  end
           results = update_schemas(names)
           Reporter.new.report_update(results)
         end
 
         def verify(name = nil)
-          names = name ? (name.is_a?(Array) ? name : [name]) : schema_names
+          names = if name
+                    name.is_a?(Array) ? name : [name]
+                  else
+                    schema_names
+                  end
           results = verify_schemas(names)
           Reporter.new.report_verify(results)
         end
 
         def diff(name = nil)
-          names = name ? (name.is_a?(Array) ? name : [name]) : schema_names
+          names = if name
+                    name.is_a?(Array) ? name : [name]
+                  else
+                    schema_names
+                  end
           results = diff_schemas(names)
           Reporter.new.report_diff(results)
         end
 
         def test(name = nil)
-          names = name ? (name.is_a?(Array) ? name : [name]) : schema_names
+          names = if name
+                    name.is_a?(Array) ? name : [name]
+                  else
+                    schema_names
+                  end
 
           update_schemas(names)
 

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'bigdecimal'
+require "bigdecimal"
 
 module Kumi
   module Dev
@@ -32,8 +32,6 @@ module Kumi
           compare_values(norm_actual, norm_expected, language: language)
         end
 
-        private
-
         def self.decimal_string?(str)
           # Match decimal number strings like "10.50", "123", "-45.67"
           str.match?(/\A-?\d+(\.\d+)?\z/)

data/lib/kumi/doc_generator/formatters/json.rb

@@ -1,4 +1,4 @@
-require 'json'
+require "json"
 
 module Kumi
   module DocGenerator
@@ -10,16 +10,16 @@ module Kumi
 
         def format
           enriched = @docs.each_with_object({}) do |(alias_name, entry), acc|
-            kernel_ids = extract_kernel_ids(entry['kernels'])
+            kernel_ids = extract_kernel_ids(entry["kernels"])
             acc[alias_name] = {
-              'id' => entry['id'],
-              'kind' => entry['kind'],
-              'arity' => entry['arity'],
-              'params' => entry['params'],
-              'kernels' => kernel_ids,
-              'dtype' => entry['dtype'],
-              'aliases' => entry['aliases'],
-              'reduction_strategy' => entry['reduction_strategy']
+              "id" => entry["id"],
+              "kind" => entry["kind"],
+              "arity" => entry["arity"],
+              "params" => entry["params"],
+              "kernels" => kernel_ids,
+              "dtype" => entry["dtype"],
+              "aliases" => entry["aliases"],
+              "reduction_strategy" => entry["reduction_strategy"]
             }
           end
 
@@ -30,7 +30,7 @@ module Kumi
 
         def extract_kernel_ids(kernels)
           kernels.each_with_object({}) do |(target, kernel), acc|
-            acc[target] = kernel.is_a?(Hash) ? kernel['id'] : kernel
+            acc[target] = kernel.is_a?(Hash) ? kernel["id"] : kernel
           end
         end
       end