kumi 0.0.0 → 0.0.4

data/lib/kumi/input/type_matcher.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Kumi
+  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 :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

data/lib/kumi/input/validator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "type_matcher"
+require_relative "violation_creator"
+
+module Kumi
+  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

data/lib/kumi/input/violation_creator.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Kumi
+  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::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

data/lib/kumi/input.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Input
+  end
+end
+
+require_relative "input/validator"

data/lib/kumi/parser/build_context.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Parser
+    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

data/lib/kumi/parser/dsl.rb

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

data/lib/kumi/parser/dsl_cascade_builder.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Parser
+    class DslCascadeBuilder
+      include Syntax
+
+      attr_reader :cases
+
+      def initialize(context, loc)
+        @context = context
+        @cases   = []
+        @loc = loc
+      end
+
+      def on(*args)
+        on_loc = current_location
+        validate_on_args(args, "on", on_loc)
+
+        trait_names = args[0..-2]
+        expr = args.last
+
+        condition = create_function_call(:all?, trait_names, on_loc)
+        result = ensure_syntax(expr)
+        add_case(condition, result)
+      end
+
+      def on_any(*args)
+        on_loc = current_location
+        validate_on_args(args, "on_any", on_loc)
+
+        trait_names = args[0..-2]
+        expr = args.last
+
+        condition = create_function_call(:any?, trait_names, on_loc)
+        result = ensure_syntax(expr)
+        add_case(condition, result)
+      end
+
+      def on_none(*args)
+        on_loc = current_location
+        validate_on_args(args, "on_none", on_loc)
+
+        trait_names = args[0..-2]
+        expr = args.last
+
+        condition = create_function_call(:none?, trait_names, on_loc)
+        result = ensure_syntax(expr)
+        add_case(condition, result)
+      end
+
+      def base(expr)
+        result = ensure_syntax(expr)
+        add_case(create_literal(true), result)
+      end
+
+      def method_missing(method_name, *args, &block)
+        return super if !args.empty? || block_given?
+
+        # Allow direct trait references in cascade conditions
+        create_binding(method_name, @loc)
+      end
+
+      def respond_to_missing?(_method_name, _include_private = false)
+        true
+      end
+
+      private
+
+      def current_location
+        caller_info = caller_locations(1, 1).first
+        Location.new(file: caller_info.path, line: caller_info.lineno, column: 0)
+      end
+
+      def validate_on_args(args, method_name, location)
+        raise_error("cascade '#{method_name}' requires at least one trait name", location) if args.empty?
+
+        return unless args.size == 1
+
+        raise_error("cascade '#{method_name}' requires an expression as the last argument", location)
+      end
+
+      def create_function_call(function_name, trait_names, location)
+        trait_bindings = trait_names.map { |name| create_binding(name, location) }
+        create_fn(function_name, trait_bindings)
+      end
+
+      def add_case(condition, result)
+        @cases << WhenCaseExpression.new(condition, result)
+      end
+
+      def ref(name)
+        @context.ref(name)
+      end
+
+      def fn(name, *args)
+        @context.fn(name, *args)
+      end
+
+      def create_literal(value)
+        @context.literal(value)
+      end
+
+      def create_fn(name, args)
+        @context.fn(name, args)
+      end
+
+      def input
+        @context.input
+      end
+
+      def ensure_syntax(expr)
+        @context.ensure_syntax(expr)
+      end
+
+      def raise_error(message, location)
+        @context.raise_error(message, location)
+      end
+
+      def create_binding(name, location)
+        Binding.new(name, loc: location)
+      end
+    end
+  end
+end

data/lib/kumi/parser/expression_converter.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Parser
+    class ExpressionConverter
+      include Syntax
+      include ErrorReporting
+
+      def initialize(context)
+        @context = context
+      end
+
+      def ensure_syntax(obj)
+        case obj
+        when Integer, String, TrueClass, FalseClass, Float, Regexp, Symbol
+          Literal.new(obj)
+        when Array
+          ListExpression.new(obj.map { |e| ensure_syntax(e) })
+        when Syntax::Node
+          obj
+        else
+          handle_complex_object(obj)
+        end
+      end
+
+      def ref(name)
+        Binding.new(name, loc: @context.current_location)
+      end
+
+      def literal(value)
+        Literal.new(value, loc: @context.current_location)
+      end
+
+      def fn(fn_name, *args)
+        expr_args = args.map { |a| ensure_syntax(a) }
+        CallExpression.new(fn_name, expr_args, loc: @context.current_location)
+      end
+
+      def input
+        InputProxy.new(@context)
+      end
+
+      def raise_error(message, location)
+        raise_syntax_error(message, location: location)
+      end
+
+      private
+
+      def handle_complex_object(obj)
+        if obj.class.instance_methods.include?(:to_ast_node)
+          obj.to_ast_node
+        else
+          raise_syntax_error("Invalid expression: #{obj.inspect}", location: @context.current_location)
+        end
+      end
+    end
+  end
+end

data/lib/kumi/parser/guard_rails.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Parser
+    module GuardRails
+      RESERVED = %i[input trait value fn lit ref].freeze
+
+      def self.included(base)
+        base.singleton_class.prepend(ClassMethods)
+      end
+
+      module ClassMethods
+        # prevent accidental addition of new DSL keywords
+        def method_added(name)
+          if GuardRails::RESERVED.include?(name)
+            # Check if this is a redefinition by looking at the call stack
+            # We want to allow the original definition but prevent redefinition
+            calling_location = caller_locations(1, 1).first
+
+            # Allow the original definition from schema_builder.rb
+            if calling_location&.path&.include?("schema_builder.rb")
+              super
+              return
+            end
+
+            # This is a redefinition attempt, prevent it
+            raise Kumi::Errors::SemanticError,
+                  "DSL keyword `#{name}` is reserved; " \
+                  "do not redefine it inside SchemaBuilder"
+          end
+          super
+        end
+      end
+
+      # catch any stray method call inside DSL block
+      def method_missing(name, *_args)
+        raise NoMethodError, "unknown DSL keyword `#{name}`"
+      end
+
+      def respond_to_missing?(*) = false
+    end
+  end
+end

data/lib/kumi/parser/input_builder.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Parser
+    class InputBuilder
+      include Syntax
+      include ErrorReporting
+
+      def initialize(context)
+        @context = context
+      end
+
+      def key(name, type: :any, domain: nil)
+        normalized_type = normalize_type(type, name)
+        @context.inputs << FieldDecl.new(name, domain, normalized_type, loc: @context.current_location)
+      end
+
+      %i[integer float string boolean any].each do |type_name|
+        define_method(type_name) do |name, domain: nil|
+          @context.inputs << FieldDecl.new(name, domain, type_name, loc: @context.current_location)
+        end
+      end
+
+      def array(name_or_elem_type, **kwargs)
+        if kwargs.any?
+          create_array_field(name_or_elem_type, kwargs)
+        else
+          Kumi::Types.array(name_or_elem_type)
+        end
+      end
+
+      def hash(name_or_key_type, val_type = nil, **kwargs)
+        return Kumi::Types.hash(name_or_key_type, val_type) unless val_type.nil?
+
+        create_hash_field(name_or_key_type, kwargs)
+      end
+
+      def method_missing(method_name, *_args)
+        allowed_methods = "'key', 'integer', 'float', 'string', 'boolean', 'any', 'array', and 'hash'"
+        raise_syntax_error("Unknown method '#{method_name}' in input block. Only #{allowed_methods} are allowed.",
+                           location: @context.current_location)
+      end
+
+      def respond_to_missing?(_method_name, _include_private = false)
+        false
+      end
+
+      private
+
+      def normalize_type(type, name)
+        Kumi::Types.normalize(type)
+      rescue ArgumentError => e
+        raise_syntax_error("Invalid type for input `#{name}`: #{e.message}", location: @context.current_location)
+      end
+
+      def create_array_field(field_name, options)
+        elem_spec = options[:elem]
+        domain = options[:domain]
+        elem_type = elem_spec.is_a?(Hash) && elem_spec[:type] ? elem_spec[:type] : :any
+
+        array_type = create_array_type(field_name, elem_type)
+        @context.inputs << FieldDecl.new(field_name, domain, array_type, loc: @context.current_location)
+      end
+
+      def create_array_type(field_name, elem_type)
+        Kumi::Types.array(elem_type)
+      rescue ArgumentError => e
+        raise_syntax_error("Invalid element type for array `#{field_name}`: #{e.message}", location: @context.current_location)
+      end
+
+      def create_hash_field(field_name, options)
+        key_spec = options[:key]
+        val_spec = options[:val] || options[:value]
+        domain = options[:domain]
+
+        key_type = extract_type(key_spec)
+        val_type = extract_type(val_spec)
+
+        hash_type = create_hash_type(field_name, key_type, val_type)
+        @context.inputs << FieldDecl.new(field_name, domain, hash_type, loc: @context.current_location)
+      end
+
+      def extract_type(spec)
+        spec.is_a?(Hash) && spec[:type] ? spec[:type] : :any
+      end
+
+      def create_hash_type(field_name, key_type, val_type)
+        Kumi::Types.hash(key_type, val_type)
+      rescue ArgumentError => e
+        raise_syntax_error("Invalid types for hash `#{field_name}`: #{e.message}", location: @context.current_location)
+      end
+    end
+  end
+end

data/lib/kumi/parser/input_proxy.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Parser
+    # Proxy object for input field references (input.field_name)
+    class InputProxy
+      include Syntax
+
+      def initialize(context)
+        @context = context
+      end
+
+      private
+
+      def method_missing(method_name, *_args)
+        # Create a FieldRef node for the given method name
+        FieldRef.new(method_name, loc: @context.current_location)
+      end
+
+      # This method is called when the user tries to access a field
+      # on the input object, e.g. `input.field_name`.
+      # It is used to create a FieldRef node in the AST.
+
+      def respond_to_missing?(_method_name, _include_private = false)
+        true # Allow any field name
+      end
+    end
+  end
+end

data/lib/kumi/parser/parser.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Parser
+    class Parser
+      include Syntax
+      include ErrorReporting
+
+      def initialize
+        @context = BuildContext.new
+        @interface = SchemaBuilder.new(@context)
+      end
+
+      def parse(&rule_block)
+        enable_refinements(rule_block)
+
+        before_consts = ::Object.constants
+        @interface.freeze # stop singleton hacks
+        @interface.instance_eval(&rule_block)
+        added = ::Object.constants - before_consts
+
+        unless added.empty?
+          raise Kumi::Errors::SemanticError,
+                "DSL cannot define global constants: #{added.join(', ')}"
+        end
+
+        build_syntax_tree
+      rescue ArgumentError => e
+        handle_parse_error(e)
+        raise
+      end
+
+      private
+
+      def enable_refinements(rule_block)
+        rule_block.binding.eval("using Kumi::Parser::Sugar::ExpressionRefinement")
+        rule_block.binding.eval("using Kumi::Parser::Sugar::NumericRefinement")
+        rule_block.binding.eval("using Kumi::Parser::Sugar::StringRefinement")
+      rescue RuntimeError, NoMethodError
+        # Refinements disabled in method scope - continue without them
+      end
+
+      def handle_parse_error(error)
+        return unless literal_comparison_error?(error)
+
+        warn <<~HINT
+          #{error.backtrace.first.split(':', 2).join(':')}: \
+          Literal‑left comparison failed because the schema block is \
+          defined inside a method (Ruby disallows refinements there).
+
+          • Move the `schema do … end` block to the top level of a class or module, OR
+          • Write the comparison as `input.age >= 80` (preferred), OR
+          • Wrap the literal: `lit(80) <= input.age`.
+        HINT
+      end
+
+      def literal_comparison_error?(error)
+        error.message =~ /comparison of Integer with Kumi::Syntax::/i
+      end
+
+      def build_syntax_tree
+        Root.new(@context.inputs, @context.attributes, @context.traits)
+      end
+    end
+  end
+end