kumi 0.0.7 → 0.0.8

data/lib/kumi/core/function_registry/math_functions.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module FunctionRegistry
+      # Mathematical operations
+      module MathFunctions
+        def self.definitions
+          {
+            # Basic arithmetic
+            add: FunctionBuilder.math_binary(:add, "Add two numbers", :+),
+            subtract: FunctionBuilder.math_binary(:subtract, "Subtract second number from first", :-),
+            multiply: FunctionBuilder.math_binary(:multiply, "Multiply two numbers", :*),
+            divide: FunctionBuilder.math_binary(:divide, "Divide first number by second", :/),
+            modulo: FunctionBuilder.math_binary(:modulo, "Modulo operation", :%),
+            power: FunctionBuilder.math_binary(:power, "Raise first number to power of second", :**),
+
+            # Unary operations
+            abs: FunctionBuilder.math_unary(:abs, "Absolute value", :abs),
+            floor: FunctionBuilder.math_unary(:floor, "Floor of number", :floor, return_type: :integer),
+            ceil: FunctionBuilder.math_unary(:ceil, "Ceiling of number", :ceil, return_type: :integer),
+
+            # Special operations
+            round: FunctionBuilder::Entry.new(
+              fn: ->(a, precision = 0) { a.round(precision) },
+              arity: -1,
+              param_types: [:float],
+              return_type: :float,
+              description: "Round number to specified precision"
+            ),
+
+            clamp: FunctionBuilder::Entry.new(
+              fn: ->(value, min, max) { value.clamp(min, max) },
+              arity: 3,
+              param_types: %i[float float float],
+              return_type: :float,
+              description: "Clamp value between min and max"
+            ),
+            piecewise_sum: FunctionBuilder::Entry.new(
+              # Tiered / piece‑wise accumulator ­­­­­­­­­­­­­­­­­­­­­­­­­
+              fn: lambda do |value, breaks, rates|
+                raise ArgumentError, "breaks & rates size mismatch" unless breaks.size == rates.size
+
+                acc      = 0.0
+                previous = 0.0
+                marginal = rates.last
+
+                breaks.zip(rates).each do |upper, rate|
+                  if value <= upper
+                    marginal = rate
+                    acc += (value - previous) * rate
+                    break
+                  else
+                    acc += (upper - previous) * rate
+                    previous = upper
+                  end
+                end
+                [acc, marginal] # => [sum, marginal_rate]
+              end,
+              arity: 3,
+              param_types: [
+                :float,
+                Kumi::Core::Types.array(:float),                   # breaks
+                Kumi::Core::Types.array(:float)                    # rates
+              ],
+              return_type: Kumi::Core::Types.array(:float),        # 2‑element [sum, marginal]
+              description: "Accumulate over tiered ranges; returns [sum, marginal_rate]"
+            )
+          }
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/function_registry/string_functions.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module FunctionRegistry
+      # String manipulation functions
+      module StringFunctions
+        def self.definitions
+          {
+            # String transformations
+            upcase: FunctionBuilder.string_unary(:upcase, "Convert string to uppercase", :upcase),
+            downcase: FunctionBuilder.string_unary(:downcase, "Convert string to lowercase", :downcase),
+            capitalize: FunctionBuilder.string_unary(:capitalize, "Capitalize first letter of string", :capitalize),
+            strip: FunctionBuilder.string_unary(:strip, "Remove leading and trailing whitespace", :strip),
+
+            # String queries
+            string_length: FunctionBuilder::Entry.new(
+              fn: ->(str) { str.to_s.length },
+              arity: 1,
+              param_types: [:string],
+              return_type: :integer,
+              description: "Get string length"
+            ),
+
+            # Keep the original length for backward compatibility, but it will be overridden
+            length: FunctionBuilder::Entry.new(
+              fn: ->(str) { str.to_s.length },
+              arity: 1,
+              param_types: [:string],
+              return_type: :integer,
+              description: "Get string length"
+            ),
+
+            # String inclusion using different name to avoid conflict with collection include?
+            string_include?: FunctionBuilder.string_binary(:include?, "Check if string contains substring", :include?,
+                                                           return_type: :boolean),
+            includes?: FunctionBuilder.string_binary(:include?, "Check if string contains substring", :include?, return_type: :boolean),
+            contains?: FunctionBuilder.string_binary(:include?, "Check if string contains substring", :include?, return_type: :boolean),
+
+            start_with?: FunctionBuilder.string_binary(:start_with?, "Check if string starts with prefix", :start_with?,
+                                                       return_type: :boolean),
+            end_with?: FunctionBuilder.string_binary(:end_with?, "Check if string ends with suffix", :end_with?, return_type: :boolean),
+
+            # String building
+            concat: FunctionBuilder::Entry.new(
+              fn: ->(*strings) { strings.join },
+              arity: -1,
+              param_types: [:string],
+              return_type: :string,
+              description: "Concatenate multiple strings"
+            )
+          }
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/function_registry/type_functions.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module FunctionRegistry
+      # Type checking and conversion functions
+      module TypeFunctions
+        def self.definitions
+          {
+            fetch: FunctionBuilder::Entry.new(
+              fn: ->(hash, key, default = nil) { hash.fetch(key, default) },
+              arity: -1, # Variable arity (2 or 3)
+              param_types: [Kumi::Core::Types.hash(:any, :any), :any, :any],
+              return_type: :any,
+              description: "Fetch value from hash with optional default"
+            ),
+
+            has_key?: FunctionBuilder::Entry.new(
+              fn: ->(hash, key) { hash.key?(key) },
+              arity: 2,
+              param_types: [Kumi::Core::Types.hash(:any, :any), :any],
+              return_type: :boolean,
+              description: "Check if hash has the given key"
+            ),
+
+            keys: FunctionBuilder::Entry.new(
+              fn: lambda(&:keys),
+              arity: 1,
+              param_types: [Kumi::Core::Types.hash(:any, :any)],
+              return_type: Kumi::Core::Types.array(:any),
+              description: "Get all keys from hash"
+            ),
+
+            values: FunctionBuilder::Entry.new(
+              fn: lambda(&:values),
+              arity: 1,
+              param_types: [Kumi::Core::Types.hash(:any, :any)],
+              return_type: Kumi::Core::Types.array(:any),
+              description: "Get all values from hash"
+            ),
+            at: FunctionBuilder::Entry.new(
+              fn: ->(array, index) { array[index] },
+              arity: 2,
+              param_types: [Kumi::Core::Types.array(:any), :integer],
+              return_type: :any,
+              description: "Get element at index from array"
+            )
+          }
+        end
+      end
+    end
+  end
+end

data/lib/kumi/{function_registry.rb → core/function_registry.rb}

@@ -1,31 +1,31 @@
 # frozen_string_literal: true
 
 module Kumi
-  # Registry for functions that can be used in Kumi schemas
-  # This is the public interface for registering custom functions
-  module FunctionRegistry
-    class UnknownFunction < StandardError; end
-
-    # Re-export the Entry struct from FunctionBuilder for compatibility
-    Entry = FunctionBuilder::Entry
-
-    # Core operators that are always available
-    CORE_OPERATORS = %i[== > < >= <= != between?].freeze
-
-    # Build the complete function registry by combining all categories
-    CORE_OPERATIONS = {}.tap do |registry|
-      registry.merge!(ComparisonFunctions.definitions)
-      registry.merge!(MathFunctions.definitions)
-      registry.merge!(StringFunctions.definitions)
-      registry.merge!(LogicalFunctions.definitions)
-      registry.merge!(CollectionFunctions.definitions)
-      registry.merge!(ConditionalFunctions.definitions)
-      registry.merge!(TypeFunctions.definitions)
-    end.freeze
-
-    @functions = CORE_OPERATIONS.dup
-
-    class << self
+  module Core
+    # Registry for functions that can be used in Kumi schemas
+    # This is the public interface for registering custom functions
+    module FunctionRegistry
+      # Re-export the Entry struct from FunctionBuilder for compatibility
+      Entry = FunctionBuilder::Entry
+
+      # Core operators that are always available
+      CORE_OPERATORS = %i[== > < >= <= != between?].freeze
+
+      # Build the complete function registry by combining all categories
+      CORE_FUNCTIONS = {}.tap do |registry|
+        registry.merge!(ComparisonFunctions.definitions)
+        registry.merge!(MathFunctions.definitions)
+        registry.merge!(StringFunctions.definitions)
+        registry.merge!(LogicalFunctions.definitions)
+        registry.merge!(CollectionFunctions.definitions)
+        registry.merge!(ConditionalFunctions.definitions)
+        registry.merge!(TypeFunctions.definitions)
+      end.freeze
+
+      @functions = CORE_FUNCTIONS.dup
+      @frozen = false
+
+      # class << self
       # Public interface for registering custom functions
       def register(name, &block)
         raise ArgumentError, "Function #{name.inspect} already registered" if @functions.key?(name)
@@ -75,11 +75,11 @@ module Kumi
       end
 
       def fetch(name)
-        @functions.fetch(name) { raise UnknownFunction, "Unknown function: #{name}" }.fn
+        @functions.fetch(name) { raise Kumi::Errors::UnknownFunction, "Unknown function: #{name}" }.fn
       end
 
       def signature(name)
-        entry = @functions.fetch(name) { raise UnknownFunction, "Unknown function: #{name}" }
+        entry = @functions.fetch(name) { raise Kumi::Errors::UnknownFunction, "Unknown function: #{name}" }
         {
           arity: entry.arity,
           param_types: entry.param_types,
@@ -130,15 +130,7 @@ module Kumi
       def type_operations
         TypeFunctions.definitions.keys
       end
-
-      # Development helpers
-      def reset!
-        @functions = CORE_OPERATIONS.dup
-      end
-
-      def freeze!
-        @functions.freeze
-      end
     end
   end
 end
+# end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Input
+      class TypeMatcher
+        def self.matches?(value, declared_type)
+          case declared_type
+          when :integer
+            value.is_a?(Integer)
+          when :float
+            value.is_a?(Float) || value.is_a?(Integer) # Allow integer for float
+          when :string
+            value.is_a?(String)
+          when :boolean
+            value.is_a?(TrueClass) || value.is_a?(FalseClass)
+          when :symbol
+            value.is_a?(Symbol)
+          when :array
+            # Simple :array type - just check if it's an Array
+            value.is_a?(Array)
+          when :any
+            true
+          else
+            # Handle complex types (arrays, hashes)
+            handle_complex_type(value, declared_type)
+          end
+        end
+
+        def self.infer_type(value)
+          case value
+          when Integer then :integer
+          when Float then :float
+          when String then :string
+          when TrueClass, FalseClass then :boolean
+          when Symbol then :symbol
+          when Array then { array: :mixed }
+          when Hash then { hash: %i[mixed mixed] }
+          else :unknown
+          end
+        end
+
+        def self.format_type(type)
+          case type
+          when Symbol
+            type.to_s
+          when Hash
+            format_complex_type(type)
+          else
+            type.inspect
+          end
+        end
+
+        private_class_method def self.handle_complex_type(value, declared_type)
+          return false unless declared_type.is_a?(Hash)
+
+          if declared_type.key?(:array)
+            handle_array_type(value, declared_type[:array])
+          elsif declared_type.key?(:hash)
+            handle_hash_type(value, declared_type[:hash])
+          else
+            false
+          end
+        end
+
+        private_class_method def self.handle_array_type(value, element_type)
+          return false unless value.is_a?(Array)
+          return true if element_type == :any
+
+          value.all? { |elem| matches?(elem, element_type) }
+        end
+
+        private_class_method def self.handle_hash_type(value, hash_spec)
+          return false unless value.is_a?(Hash)
+
+          key_type, value_type = hash_spec
+          return true if key_type == :any && value_type == :any
+
+          value.all? do |k, v|
+            matches?(k, key_type) && matches?(v, value_type)
+          end
+        end
+
+        private_class_method def self.format_complex_type(type)
+          if type.key?(:array)
+            "array(#{format_type(type[:array])})"
+          elsif type.key?(:hash)
+            key_type, value_type = type[:hash]
+            "hash(#{format_type(key_type)}, #{format_type(value_type)})"
+          else
+            type.inspect
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Input
+      class Validator
+        def self.validate_context(context, input_meta)
+          violations = []
+
+          context.each do |field, value|
+            meta = input_meta[field]
+            next unless meta
+
+            # Type validation first
+            if should_validate_type?(meta) && !TypeMatcher.matches?(value, meta[:type])
+              violations << ViolationCreator.create_type_violation(field, value, meta[:type])
+              next # Skip domain validation if type is wrong
+            end
+
+            # Domain validation second (only if type is correct)
+            if should_validate_domain?(meta) && !Domain::Validator.validate_field(field, value, meta[:domain])
+              violations << ViolationCreator.create_domain_violation(field, value, meta[:domain])
+            end
+          end
+
+          violations
+        end
+
+        def self.type_matches?(value, declared_type)
+          TypeMatcher.matches?(value, declared_type)
+        end
+
+        def self.infer_type(value)
+          TypeMatcher.infer_type(value)
+        end
+
+        def self.format_type(type)
+          TypeMatcher.format_type(type)
+        end
+
+        private_class_method def self.should_validate_type?(meta)
+          meta[:type] && meta[:type] != :any
+        end
+
+        private_class_method def self.should_validate_domain?(meta)
+          meta[:domain]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Input
+      class ViolationCreator
+        def self.create_type_violation(field, value, expected_type)
+          {
+            type: :type_violation,
+            field: field,
+            value: value,
+            expected_type: expected_type,
+            actual_type: TypeMatcher.infer_type(value),
+            message: format_type_violation_message(field, value, expected_type)
+          }
+        end
+
+        def self.create_domain_violation(field, value, domain)
+          {
+            type: :domain_violation,
+            field: field,
+            value: value,
+            domain: domain,
+            message: Kumi::Core::Domain::ViolationFormatter.format_message(field, value, domain)
+          }
+        end
+
+        def self.create_missing_field_violation(field, expected_type)
+          {
+            type: :missing_field_violation,
+            field: field,
+            expected_type: expected_type,
+            message: format_missing_field_message(field, expected_type)
+          }
+        end
+
+        private_class_method def self.format_type_violation_message(field, value, expected_type)
+          actual_type = TypeMatcher.infer_type(value)
+          expected_formatted = TypeMatcher.format_type(expected_type)
+          actual_formatted = TypeMatcher.format_type(actual_type)
+
+          "Field :#{field} expected #{expected_formatted}, got #{value.inspect} of type #{actual_formatted}"
+        end
+
+        private_class_method def self.format_missing_field_message(field, expected_type)
+          expected_formatted = TypeMatcher.format_type(expected_type)
+          "Missing required field :#{field} of type #{expected_formatted}"
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/json_schema/generator.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Kumi
+  module Core
+    module JsonSchema
+      # Converts Kumi schema metadata to JSON Schema format
+      class Generator
+        def initialize(schema_metadata)
+          @metadata = schema_metadata
+        end
+
+        def generate
+          {
+            type: "object",
+            properties: build_properties,
+            required: extract_required_fields,
+            "x-kumi-values": @metadata.values,
+            "x-kumi-traits": @metadata.traits
+          }
+        end
+
+        private
+
+        def build_properties
+          @metadata.inputs.transform_values { |spec| convert_input_to_json_schema(spec) }
+        end
+
+        def extract_required_fields
+          @metadata.inputs.select { |_k, v| v[:required] }.keys
+        end
+
+        def convert_input_to_json_schema(input_spec)
+          base = { type: map_kumi_type_to_json_schema(input_spec[:type]) }
+
+          domain = input_spec[:domain]
+          return base unless domain
+
+          case domain[:type]
+          when :range
+            base[:minimum] = domain[:min]
+            base[:maximum] = domain[:max]
+          when :enum
+            base[:enum] = domain[:values]
+          end
+
+          base
+        end
+
+        def map_kumi_type_to_json_schema(kumi_type)
+          case kumi_type
+          when :string then "string"
+          when :integer then "integer"
+          when :float then "number"
+          when :boolean then "boolean"
+          when :array then "array"
+          when :hash then "object"
+          else "string"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module JsonSchema
+      # Validates data against JSON Schema (placeholder for future implementation)
+      class Validator
+        def initialize(json_schema)
+          @schema = json_schema
+        end
+
+        def validate(_data)
+          # Placeholder implementation
+          # In a real implementation, this would validate data against the JSON Schema
+          {
+            valid: true,
+            errors: []
+          }
+        end
+
+        def self.validate(json_schema, data)
+          new(json_schema).validate(data)
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/json_schema.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "json_schema/generator"
+require_relative "json_schema/validator"
+
+module Kumi
+  module Core
+    module JsonSchema
+      # Entry point for the JsonSchema functionality
+      #
+      # Available components:
+      # - Generator: Converts Kumi metadata to JSON Schema
+      # - Validator: Validates data against JSON Schema (placeholder)
+    end
+  end
+end

data/lib/kumi/core/ruby_parser/build_context.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module RubyParser
+      class BuildContext
+        attr_reader :inputs, :attributes, :traits
+        attr_accessor :current_location
+
+        def initialize
+          @inputs = []
+          @attributes = []
+          @traits = []
+          @input_block_defined = false
+        end
+
+        def input_block_defined?
+          @input_block_defined
+        end
+
+        def mark_input_block_defined!
+          @input_block_defined = true
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/ruby_parser/declaration_reference_proxy.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module RubyParser
+      # DSL proxy for declaration references (traits and values)
+      # Handles references to declared items and field access on them
+      class DeclarationReferenceProxy
+        include Syntax
+
+        # Use shared operator methods
+        extend Sugar::ProxyRefinement
+
+        def initialize(name, context)
+          @name = name
+          @context = context
+        end
+
+        # Convert to DeclarationReference AST node
+        def to_ast_node
+          Kumi::Syntax::DeclarationReference.new(@name, loc: @context.current_location)
+        end
+
+        private
+
+        def method_missing(method_name, *args, &block)
+          # All operators are handled by ProxyRefinement methods
+          # Field access should use input.field.subfield syntax, not bare identifiers
+          super
+        end
+
+        def respond_to_missing?(_method_name, _include_private = false)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/ruby_parser/dsl.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module RubyParser
+      module Dsl
+        def self.build_syntax_tree(&rule_block)
+          parser = Parser.new
+          parser.parse(&rule_block)
+        end
+      end
+    end
+  end
+end