kumi 0.0.7 → 0.0.9

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Types
+      # Formats types for display and debugging
+      class Formatter
+        # Convert types to string representation
+        def self.type_to_s(type)
+          case type
+          when Hash
+            if type[:array]
+              "array(#{type_to_s(type[:array])})"
+            elsif type[:hash]
+              "hash(#{type_to_s(type[:hash][0])}, #{type_to_s(type[:hash][1])})"
+            else
+              type.to_s
+            end
+          else
+            type.to_s
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Kumi
+  module Core
+    module Types
+      # Infers types from Ruby values
+      class Inference
+        def self.infer_from_value(value)
+          case value
+          when String then :string
+          when Integer then :integer
+          when Float then :float
+          when TrueClass, FalseClass then :boolean
+          when Symbol then :symbol
+          when Regexp then :regexp
+          when Time then :time
+          when DateTime then :datetime
+          when Date then :date
+          when Array
+            return Kumi::Core::Types.array(:any) if value.empty?
+
+            # Infer element type from first element (simple heuristic)
+            first_elem_type = infer_from_value(value.first)
+            Kumi::Core::Types.array(first_elem_type)
+          when Hash
+            return Kumi::Core::Types.hash(:any, :any) if value.empty?
+
+            # Infer key/value types from first pair (simple heuristic)
+            first_key, first_value = value.first
+            key_type = infer_from_value(first_key)
+            value_type = infer_from_value(first_value)
+            Kumi::Core::Types.hash(key_type, value_type)
+          else
+            :any
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Kumi
+  module Core
+    module Types
+      # Normalizes different type inputs to canonical forms
+      class Normalizer
+        # Type normalization - convert various inputs to canonical type symbols
+        def self.normalize(type_input)
+          case type_input
+          when Symbol
+            return type_input if Validator.valid_type?(type_input)
+
+            raise ArgumentError, "Invalid type symbol: #{type_input}"
+          when String
+            symbol_type = type_input.to_sym
+            return symbol_type if Validator.valid_type?(symbol_type)
+
+            raise ArgumentError, "Invalid type string: #{type_input}"
+          when Hash
+            return type_input if Validator.valid_type?(type_input)
+
+            raise ArgumentError, "Invalid type hash: #{type_input}"
+          when Class
+            # Handle Ruby class inputs
+            case type_input.name
+            when "Integer" then :integer
+            when "String" then :string
+            when "Float" then :float
+            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
+          else
+            case type_input
+            when Integer, Float, Numeric
+              raise ArgumentError, "Type must be a symbol, got #{type_input} (#{type_input.class})"
+            else
+              raise ArgumentError, "Invalid type input: #{type_input} (#{type_input.class})"
+            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
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Types
+      # Validates type definitions and structures
+      class Validator
+        VALID_TYPES = %i[string integer float boolean any symbol regexp time date datetime array].freeze
+
+        def self.valid_type?(type)
+          return true if VALID_TYPES.include?(type)
+          return true if array_type?(type)
+          return true if hash_type?(type)
+
+          false
+        end
+
+        def self.array_type?(type)
+          type.is_a?(Hash) && type.keys == [:array] && valid_type?(type[:array])
+        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)
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/types.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Types
+      # Re-export constants for compatibility
+      VALID_TYPES = Validator::VALID_TYPES
+
+      # Validation methods
+      def self.valid_type?(type)
+        Validator.valid_type?(type)
+      end
+
+      # Type builders
+      def self.array(elem_type)
+        Builder.array(elem_type)
+      end
+
+      def self.hash(key_type, val_type)
+        Builder.hash(key_type, val_type)
+      end
+
+      # Normalization
+      def self.normalize(type_input)
+        Normalizer.normalize(type_input)
+      end
+
+      def self.coerce(type_input)
+        Normalizer.coerce(type_input)
+      end
+
+      # Compatibility and unification
+      def self.compatible?(type1, type2)
+        Compatibility.compatible?(type1, type2)
+      end
+
+      def self.unify(type1, type2)
+        Compatibility.unify(type1, type2)
+      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/core/vectorization_metadata.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    # Metadata system for vectorization detection and handling
+    module VectorizationMetadata
+      # Tracks which declarations are arrays with children (vectorizable)
+      class ArrayDeclarationTracker
+        def initialize
+          @array_declarations = {}
+        end
+
+        def register_array(name, children)
+          @array_declarations[name] = children.map(&:name)
+        end
+
+        def array_declaration?(name)
+          @array_declarations.key?(name)
+        end
+
+        def array_children(name)
+          @array_declarations[name] || []
+        end
+
+        def all_arrays
+          @array_declarations.keys
+        end
+      end
+
+      # Detects vectorized operations in expressions
+      class VectorizationDetector
+        def initialize(array_tracker)
+          @array_tracker = array_tracker
+        end
+
+        # Check if an expression should be vectorized
+        def vectorized_expression?(expression)
+          case expression
+          when Kumi::Syntax::CallExpression
+            vectorized_call?(expression)
+          when Kumi::Syntax::InputElementReference
+            vectorized_element_reference?(expression)
+          else
+            false
+          end
+        end
+
+        # Check if a function call should be treated as a reducer
+        def reducer_function?(fn_name, args)
+          REDUCER_FUNCTIONS.include?(fn_name) &&
+            args.any? { |arg| vectorized_expression?(arg) }
+        end
+
+        private
+
+        REDUCER_FUNCTIONS = %i[sum min max size length first last].freeze
+
+        def vectorized_call?(call_expr)
+          # Arithmetic operations between array elements are vectorized
+          ARITHMETIC_OPERATIONS.include?(call_expr.fn_name) &&
+            call_expr.args.any? { |arg| vectorized_expression?(arg) }
+        end
+
+        def vectorized_element_reference?(elem_ref)
+          return false unless elem_ref.path.size >= 2
+
+          array_name, _field_name = elem_ref.path
+          @array_tracker.array_declaration?(array_name)
+        end
+
+        ARITHMETIC_OPERATIONS = %i[add subtract multiply divide modulo power].freeze
+      end
+
+      # Metadata about how values should be computed
+      class ComputationMetadata
+        attr_reader :vectorized_values, :reducer_values, :scalar_values
+
+        def initialize
+          @vectorized_values = Set.new
+          @reducer_values = Set.new
+          @scalar_values = Set.new
+        end
+
+        def mark_vectorized(name)
+          @vectorized_values.add(name)
+        end
+
+        def mark_reducer(name)
+          @reducer_values.add(name)
+        end
+
+        def mark_scalar(name)
+          @scalar_values.add(name)
+        end
+
+        def vectorized?(name)
+          @vectorized_values.include?(name)
+        end
+
+        def reducer?(name)
+          @reducer_values.include?(name)
+        end
+
+        def scalar?(name)
+          @scalar_values.include?(name)
+        end
+      end
+    end
+  end
+end

data/lib/kumi/errors.rb

@@ -1,116 +1,5 @@
-# frozen_string_literal: true
-
 module Kumi
   module Errors
-    class Error < StandardError; end
-
-    class LocatedError < Error
-      attr_reader :location
-
-      def initialize(message, location = nil)
-        super(message)
-        @location = location
-      end
-
-      def to_s
-        if @location
-          "#{super} at #{@location.file}:#{@location.line}:#{@location.column}"
-        else
-          super
-        end
-      end
-    end
-
-    class SemanticError < LocatedError; end
-
-    class TypeError < SemanticError; end
-
-    class FieldMetadataError < SemanticError; end
-
-    class SyntaxError < LocatedError; end
-
-    class RuntimeError < Error; end
-
-    class DomainViolationError < Error
-      attr_reader :violations
-
-      def initialize(violations)
-        @violations = violations
-        super(format_message)
-      end
-
-      def single_violation?
-        violations.size == 1
-      end
-
-      def multiple_violations?
-        violations.size > 1
-      end
-
-      private
-
-      def format_message
-        if single_violation?
-          violations.first[:message]
-        else
-          "Multiple domain violations:\n#{violations.map { |v| "  - #{v[:message]}" }.join("\n")}"
-        end
-      end
-    end
-
-    class InputValidationError < Error
-      attr_reader :violations
-
-      def initialize(violations)
-        @violations = violations
-        super(format_message)
-      end
-
-      def single_violation?
-        violations.size == 1
-      end
-
-      def multiple_violations?
-        violations.size > 1
-      end
-
-      def type_violations
-        violations.select { |v| v[:type] == :type_violation }
-      end
-
-      def domain_violations
-        violations.select { |v| v[:type] == :domain_violation }
-      end
-
-      def type_violations?
-        type_violations.any?
-      end
-
-      def domain_violations?
-        domain_violations.any?
-      end
-
-      private
-
-      def format_message
-        if single_violation?
-          violations.first[:message]
-        else
-          message_parts = []
-
-          if type_violations?
-            message_parts << "Type violations:"
-            type_violations.each { |v| message_parts << "  - #{v[:message]}" }
-          end
-
-          if domain_violations?
-            message_parts << "Domain violations:"
-            domain_violations.each { |v| message_parts << "  - #{v[:message]}" }
-          end
-
-          message_parts.join("\n")
-        end
-      end
-    end
+    include Core::Errors
   end
 end

data/lib/kumi/registry.rb

@@ -0,0 +1,37 @@
+module Kumi
+  module Registry
+    extend Core::FunctionRegistry
+    Entry = Core::FunctionRegistry::FunctionBuilder::Entry
+
+    @functions = Core::FunctionRegistry::CORE_FUNCTIONS.transform_values(&:dup)
+    @frozen    = false
+    @lock      = Mutex.new
+
+    class FrozenError < RuntimeError; end
+
+    class << self
+      def reset!
+        @lock.synchronize do
+          @functions = Core::FunctionRegistry::CORE_FUNCTIONS.transform_values(&:dup)
+          @frozen    = false
+        end
+      end
+
+      def register(name, &block)
+        @lock.synchronize do
+          raise FrozenError, "registry is frozen" if @frozen
+
+          super
+        end
+      end
+
+      def freeze!
+        @lock.synchronize do
+          @functions.each_value(&:freeze)
+          @functions.freeze
+          @frozen = true
+        end
+      end
+    end
+  end
+end

data/lib/kumi/schema.rb

@@ -17,11 +17,11 @@ module Kumi
 
       # Validate input types and domain constraints
       input_meta = @__analyzer_result__.state[:inputs] || {}
-      violations = Input::Validator.validate_context(context, input_meta)
+      violations = Core::Input::Validator.validate_context(context, input_meta)
 
       raise Errors::InputValidationError, violations unless violations.empty?
 
-      SchemaInstance.new(@__compiled_schema__, @__analyzer_result__.state, context)
+      Core::SchemaInstance.new(@__compiled_schema__, @__analyzer_result__.state, context)
     end
 
     def explain(context, *keys)
@@ -29,19 +29,19 @@ module Kumi
 
       # Validate input types and domain constraints
       input_meta = @__analyzer_result__.state[:inputs] || {}
-      violations = Input::Validator.validate_context(context, input_meta)
+      violations = Core::Input::Validator.validate_context(context, input_meta)
 
       raise Errors::InputValidationError, violations unless violations.empty?
 
       keys.each do |key|
-        puts Kumi::Explain.call(self, key, inputs: context)
+        puts Core::Explain.call(self, key, inputs: context)
       end
 
       nil
     end
 
     def schema(&block)
-      @__syntax_tree__ = Kumi::RubyParser::Dsl.build_syntax_tree(&block).freeze
+      @__syntax_tree__ = Core::RubyParser::Dsl.build_syntax_tree(&block).freeze
       @__analyzer_result__ = Analyzer.analyze!(@__syntax_tree__).freeze
       @__compiled_schema__ = Compiler.compile(@__syntax_tree__, analyzer: @__analyzer_result__).freeze
 

data/lib/kumi/schema_metadata.rb

@@ -210,7 +210,7 @@ module Kumi
     #   #   "x-kumi-traits": { ... }
     #   # }
     def to_json_schema
-      JsonSchema::Generator.new(self).generate
+      Core::JsonSchema::Generator.new(self).generate
     end
 
     # Returns processed declaration metadata.
@@ -412,9 +412,9 @@ module Kumi
       end
 
       function_calls.each_with_object({}) do |func_name, result|
-        next unless Kumi::FunctionRegistry.supported?(func_name)
+        next unless Kumi::Registry.supported?(func_name)
 
-        function_info = Kumi::FunctionRegistry.signature(func_name)
+        function_info = Kumi::Registry.signature(func_name)
         result[func_name] = {
           param_types: function_info[:param_types],
           return_type: function_info[:return_type],