kumi 0.0.25 → 0.0.27

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

@@ -5,38 +5,45 @@ require "date"
 module Kumi
   module Core
     module Types
-      # Normalizes different type inputs to canonical forms
+      # Normalizes different type inputs to canonical Type objects
       class Normalizer
-        # Type normalization - convert various inputs to canonical type symbols
+        # Type normalization - convert various inputs to Type objects
         def self.normalize(type_input)
           case type_input
+          when Type
+            # Already a Type object, return as-is
+            type_input
           when Symbol
-            return type_input if Validator.valid_type?(type_input)
-
-            raise ArgumentError, "Invalid type symbol: #{type_input}"
+            if Validator.valid_kind?(type_input)
+              Kumi::Core::Types.scalar(type_input)
+            else
+              raise ArgumentError, "Invalid type symbol: #{type_input}"
+            end
           when String
             symbol_type = type_input.to_sym
-            return symbol_type if Validator.valid_type?(symbol_type)
-
-            raise ArgumentError, "Invalid type string: #{type_input}"
+            if Validator.valid_kind?(symbol_type)
+              Kumi::Core::Types.scalar(symbol_type)
+            else
+              raise ArgumentError, "Invalid type string: #{type_input}"
+            end
           when Hash
-            return type_input if Validator.valid_type?(type_input)
-
-            raise ArgumentError, "Invalid type hash: #{type_input}"
+            raise ArgumentError, "Hash-based types no longer supported, use Type objects instead"
           when Class
             # Handle Ruby class inputs
-            case type_input.name
-            when "NilClass" then :null
-            when "Integer" then :integer
-            when "String" then :string
-            when "Float" then :float
-            when "Symbol" then :symbol
-            when "TrueClass", "FalseClass" then :boolean
-            when "Array" then raise ArgumentError, "Use array(:type) helper for array types"
-            when "Hash" then raise ArgumentError, "Use hash(:key_type, :value_type) helper for hash types"
-            else
-              raise ArgumentError, "Unsupported class type: #{type_input}"
-            end
+            kind = case type_input.name
+                   when "NilClass" then :null
+                   when "Integer" then :integer
+                   when "String" then :string
+                   when "Float" then :float
+                   when "Decimal", "BigDecimal" then :decimal
+                   when "Symbol" then :symbol
+                   when "TrueClass", "FalseClass" then :boolean
+                   when "Array" then raise ArgumentError, "Use array(:type) helper for array types"
+                   when "Hash" then raise ArgumentError, "Use scalar(:hash) for hash type"
+                   else
+                     raise ArgumentError, "Unsupported class type: #{type_input}"
+                   end
+            Kumi::Core::Types.scalar(kind)
           else
             case type_input
             when Integer, Float, Numeric
@@ -46,28 +53,6 @@ module Kumi
             end
           end
         end
-
-        # Legacy compatibility - coerce old constants to symbols
-        def self.coerce(type_input)
-          # Handle legacy constant usage
-          return type_input if type_input.is_a?(Symbol) && Validator.valid_type?(type_input)
-
-          # Handle legacy constant objects
-          case type_input
-          when STRING then :string
-          when INT then :integer
-          when FLOAT, NUMERIC then :float # Both FLOAT and NUMERIC map to :float
-          when BOOL then :boolean
-          when ANY then :any
-          when SYMBOL then :symbol
-          when REGEXP then :regexp
-          when TIME then :time
-          when DATE then :date
-          when DATETIME then :datetime
-          else
-            normalize(type_input)
-          end
-        end
       end
     end
   end

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

@@ -5,38 +5,27 @@ module Kumi
     module Types
       # Validates type definitions and structures
       class Validator
-        VALID_TYPES = %i[string integer float boolean any symbol regexp time date datetime array hash null].freeze
+        VALID_TYPES = %i[string integer float decimal boolean any symbol regexp time date datetime array hash null].freeze
 
-        def self.valid_type?(type)
-          return true if !type.is_a?(Hash) && VALID_TYPES.include?(type.to_s.to_sym)
-
-          return true if array_type?(type)
-          return true if hash_type?(type)
-
-          false
-        end
-
-        def self.array_type?(type)
-          return true if type.is_a?(Hash) && type.keys == [:array] && valid_type?(type[:array])
+        # Validate scalar kinds (no :array or :hash)
+        VALID_KINDS = %i[string integer float decimal boolean any symbol regexp time date datetime null].freeze
 
-          type = type.to_s
-          type.is_a?(String) && type.match?(/^array<(.+)>$/) && type.scan(/(\w+)/)[1..-1].flatten.all? { |t| valid_type?(t) }
+        def self.valid_kind?(kind)
+          VALID_KINDS.include?(kind)
         end
 
-        def item_types(type)
-        end
-
-        def self.hash_type?(type)
-          type.is_a?(Hash) &&
-            type.keys.sort == [:hash] &&
-            type[:hash].is_a?(Array) &&
-            type[:hash].size == 2 &&
-            valid_type?(type[:hash][0]) &&
-            valid_type?(type[:hash][1])
-        end
-
-        def self.primitive_type?(type)
-          VALID_TYPES.include?(type)
+        def self.valid_type?(type)
+          # Support Type objects
+          case type
+          when ScalarType
+            valid_kind?(type.kind)
+          when ArrayType, TupleType
+            true  # If constructed, it's valid
+          when Symbol
+            valid_kind?(type)
+          else
+            false
+          end
         end
       end
     end

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Types
+      # Base class for all type objects
+      class Type
+        def scalar?
+          is_a?(ScalarType)
+        end
+
+        def array?
+          is_a?(ArrayType)
+        end
+
+        def tuple?
+          is_a?(TupleType)
+        end
+      end
+
+      # Represents scalar types: string, integer, float, boolean, hash
+      class ScalarType < Type
+        attr_reader :kind
+
+        def initialize(kind)
+          @kind = kind
+        end
+
+        def to_s
+          @kind.to_s
+        end
+
+        def inspect
+          "#<ScalarType:#{@kind}>"
+        end
+
+        def ==(other)
+          return false unless other.is_a?(ScalarType)
+          @kind == other.kind
+        end
+
+        def eql?(other)
+          self == other
+        end
+
+        def hash
+          [@kind].hash
+        end
+      end
+
+      # Represents array types with an element type
+      class ArrayType < Type
+        attr_reader :element_type
+
+        def initialize(element_type)
+          @element_type = element_type
+        end
+
+        def to_s
+          "array<#{@element_type}>"
+        end
+
+        def inspect
+          "#<ArrayType:#{to_s}>"
+        end
+
+        def ==(other)
+          return false unless other.is_a?(ArrayType)
+          @element_type == other.element_type
+        end
+
+        def eql?(other)
+          self == other
+        end
+
+        def hash
+          [@element_type].hash
+        end
+      end
+
+      # Represents tuple types with a list of element types
+      class TupleType < Type
+        attr_reader :element_types
+
+        def initialize(element_types)
+          @element_types = element_types
+        end
+
+        def to_s
+          "tuple<#{@element_types.join(', ')}>"
+        end
+
+        def inspect
+          "#<TupleType:#{to_s}>"
+        end
+
+        def ==(other)
+          return false unless other.is_a?(TupleType)
+          @element_types == other.element_types
+        end
+
+        def eql?(other)
+          self == other
+        end
+
+        def hash
+          @element_types.hash
+        end
+      end
+
+      # Namespace module for consistency with autoloader
+      module ValueObjects
+      end
+    end
+  end
+end

data/lib/kumi/core/types.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'types/value_objects'
+
 module Kumi
   module Core
     module Types
@@ -10,64 +12,70 @@ module Kumi
         tuple?(dtype) || array?(dtype)
       end
 
-      def self.tuple?(dtype) = dtype == :tuple || dtype.match?(/^tuple</)
-      def self.array?(dtype) = dtype == :array || dtype.match?(/^array</)
+      def self.tuple?(dtype)
+        dtype.is_a?(TupleType)
+      end
+
+      def self.array?(dtype)
+        dtype.is_a?(ArrayType)
+      end
 
       # Validation methods
       def self.valid_type?(type)
         Validator.valid_type?(type)
       end
 
-      # Type builders
-      def self.array(elem_type)
-        Builder.array(elem_type)
+      # Type value object constructors
+      def self.scalar(kind)
+        ScalarType.new(kind)
       end
 
-      def self.hash(key_type, val_type)
-        Builder.hash(key_type, val_type)
+      def self.array(element_type)
+        elem_obj = case element_type
+                   when Type
+                     element_type
+                   when :string, :integer, :float, :decimal, :boolean, :hash, :any, :symbol, :regexp, :time, :date, :datetime, :null
+                     scalar(element_type)
+                   else
+                     raise ArgumentError,
+                           "array element must be Type object or scalar kind, got #{element_type.inspect}"
+                   end
+        ArrayType.new(elem_obj)
       end
 
-      # Normalization
-      def self.normalize(type_input)
-        Normalizer.normalize(type_input)
-      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
 
-      def self.coerce(type_input)
-        Normalizer.coerce(type_input)
+        # Convert any non-Type elements to Type objects
+        converted = element_types.map do |t|
+          case t
+          when Type
+            t
+          when :string, :integer, :float, :decimal, :boolean, :hash, :any, :symbol, :regexp, :time, :date, :datetime, :null
+            scalar(t)
+          else
+            raise ArgumentError, "tuple element must be Type or scalar kind, got #{t.inspect}"
+          end
+        end
+
+        TupleType.new(converted)
       end
 
-      # Compatibility and unification
-      def self.compatible?(type1, type2)
-        Compatibility.compatible?(type1, type2)
+      def self.hash(key_type, val_type)
+        raise NotImplementedError, "Use scalar(:hash) instead - Kumi treats hash as scalar, not key/value pair"
       end
 
-      def self.unify(type1, type2)
-        Compatibility.unify(type1, type2)
+      # Normalization
+      def self.normalize(type_input)
+        Normalizer.normalize(type_input)
       end
 
       # Type inference
       def self.infer_from_value(value)
         Inference.infer_from_value(value)
       end
-
-      # Formatting
-      def self.type_to_s(type)
-        Formatter.type_to_s(type)
-      end
-
-      # Legacy compatibility constants (will be phased out)
-      # These should be replaced with symbols in user code over time
-      STRING = :string
-      INT = :integer # NOTE: using :integer instead of :int for clarity
-      FLOAT = :float
-      BOOL = :boolean
-      ANY = :any
-      SYMBOL = :symbol
-      REGEXP = :regexp
-      TIME = :time
-      DATE = :date
-      DATETIME = :datetime
-      NUMERIC = :float # Legacy: represents numeric compatibility
     end
   end
 end

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

@@ -40,12 +40,14 @@ module Kumi
 
         def report_verify(results_by_schema)
           success = true
+          results_presented = false
 
           results_by_schema.each do |schema_name, results|
             failed_reprs = results.select { |r| !r.passed? }
 
             if failed_reprs.empty?
               puts "✓ #{schema_name}"
+              results_presented = true
             else
               success = false
               failed_msgs = failed_reprs.map do |r|
@@ -61,9 +63,16 @@ module Kumi
                 end
               end
               puts "✗ #{schema_name} (#{failed_msgs.join(', ')})"
+              results_presented = true
             end
           end
 
+          # If nothing was shown, report that results were empty
+          unless results_presented
+            puts "⚠ No test results to report - check that schema files exist"
+            success = false
+          end
+
           success
         end
 

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'value_normalizer'
+
 module Kumi
   module Dev
     module Golden
@@ -60,7 +62,7 @@ module Kumi
         end
 
         def passed?
-          actual == expected
+          ValueNormalizer.values_equal?(actual, expected, language: language)
         end
 
         def failed?

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

@@ -2,6 +2,8 @@
 
 require "json"
 require "open3"
+require "bigdecimal"
+require_relative "value_normalizer"
 
 module Kumi
   module Dev
@@ -64,6 +66,9 @@ module Kumi
           code = File.read(code_file)
           input_data = JSON.parse(File.read(input_file))
 
+          # Convert decimal string inputs to BigDecimal
+          input_data = convert_decimal_strings(input_data)
+
           module_name = code.match(/module (Kumi::Compiled::\S+)/)[1]
           eval(code)
           module_const = Object.const_get(module_name)
@@ -72,6 +77,26 @@ module Kumi
           decl_names.to_h { |name| [name, instance[name.to_sym]] }
         end
 
+        private
+
+        def convert_decimal_strings(value)
+          case value
+          when Hash
+            value.transform_values { |v| convert_decimal_strings(v) }
+          when Array
+            value.map { |v| convert_decimal_strings(v) }
+          when String
+            # Convert decimal-like strings to BigDecimal
+            if value.match?(/\A-?\d+(\.\d+)?\z/)
+              BigDecimal(value)
+            else
+              value
+            end
+          else
+            value
+          end
+        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)

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

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

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module Kumi
+  module Dev
+    module Golden
+      # Normalizes values for test comparisons, handling decimal precision
+      class ValueNormalizer
+        def self.normalize(value, language: :ruby)
+          case value
+          when Hash
+            value.transform_values { |v| normalize(v, language: language) }
+          when Array
+            value.map { |v| normalize(v, language: language) }
+          when String
+            # Try to parse as decimal if it looks like one
+            if decimal_string?(value)
+              language == :ruby ? BigDecimal(value) : value
+            else
+              value
+            end
+          else
+            value
+          end
+        end
+
+        def self.values_equal?(actual, expected, language: :ruby)
+          norm_actual = normalize(actual, language: language)
+          norm_expected = normalize(expected, language: language)
+
+          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/)
+        end
+
+        def self.compare_values(actual, expected, language:)
+          # Handle decimal comparisons with tolerance for floating-point errors
+          case [actual, expected]
+          in [Array, Array]
+            actual.length == expected.length &&
+              actual.zip(expected).all? { |a, e| compare_values(a, e, language: language) }
+          in [Hash, Hash]
+            actual.keys == expected.keys &&
+              actual.all? { |k, v| compare_values(v, expected[k], language: language) }
+          in [BigDecimal, BigDecimal]
+            actual == expected
+          in [BigDecimal, (Integer | Float)]
+            BigDecimal(actual.to_s) == BigDecimal(expected.to_s)
+          in [(Integer | Float), BigDecimal]
+            BigDecimal(actual.to_s) == BigDecimal(expected.to_s)
+          in [(Integer | Float), String] | [String, (Integer | Float)]
+            # Compare number with decimal string (e.g., JavaScript number vs expected string)
+            actual_bd = BigDecimal(actual.to_s)
+            expected_bd = BigDecimal(expected.to_s)
+            # Allow small floating-point differences (within 1e-10)
+            (actual_bd - expected_bd).abs < BigDecimal("1e-10")
+          in [String, String]
+            # Both strings - try to parse as decimals and compare
+            begin
+              actual_bd = BigDecimal(actual)
+              expected_bd = BigDecimal(expected)
+              (actual_bd - expected_bd).abs < BigDecimal("1e-10")
+            rescue ArgumentError
+              # If not valid decimals, compare as strings
+              actual == expected
+            end
+          else
+            actual == expected
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kumi/dev/golden.rb

@@ -21,20 +21,27 @@ module Kumi
         suite.list
       end
 
-      def update!(name = nil)
-        suite.update(name)
+      def update!(*names)
+        names = [names].flatten.compact
+        names = nil if names.empty?
+        suite.update(names)
       end
 
-      def verify!(name = nil)
-        suite.verify(name)
+      def verify!(*names)
+        names = [names].flatten.compact
+        names = nil if names.empty?
+        suite.verify(names)
       end
 
-      def diff!(name = nil)
-        suite.diff(name)
+      def diff!(*names)
+        names = [names].flatten.compact
+        names = nil if names.empty?
+        suite.diff(names)
       end
 
-      def test_all_codegen!(name = nil)
-        names = name ? [name] : suite.send(:schema_names)
+      def test_all_codegen!(*names_arg)
+        names_arg = [names_arg].flatten.compact
+        names = names_arg.any? ? names_arg : suite.send(:schema_names)
 
         ruby_names = suite.send(:filter_testable_schemas, names, :ruby)
         ruby_results = ruby_names.map do |schema_name|
@@ -49,8 +56,9 @@ module Kumi
         Reporter.new.report_runtime_tests(ruby: ruby_results, javascript: js_results)
       end
 
-      def test_codegen!(name = nil)
-        names = name ? [name] : suite.send(:schema_names)
+      def test_codegen!(*names_arg)
+        names_arg = [names_arg].flatten.compact
+        names = names_arg.any? ? names_arg : 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))
@@ -58,8 +66,9 @@ module Kumi
         Reporter.new.report_runtime_tests(ruby: results)
       end
 
-      def test_js_codegen!(name = nil)
-        names = name ? [name] : suite.send(:schema_names)
+      def test_js_codegen!(*names_arg)
+        names_arg = [names_arg].flatten.compact
+        names = names_arg.any? ? names_arg : 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))