kumi 0.0.6 → 0.0.8

data/lib/kumi/input/type_matcher.rb

@@ -1,95 +0,0 @@
-# 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 :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

data/lib/kumi/input/validator.rb

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

@@ -1,50 +0,0 @@
-# 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/parser/build_context.rb

@@ -1,25 +0,0 @@
-# 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/declaration_reference_proxy.rb

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

data/lib/kumi/parser/dsl.rb

@@ -1,12 +0,0 @@
-# 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

@@ -1,136 +0,0 @@
-# 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
-
-        trait_bindings = convert_trait_names_to_bindings(trait_names, on_loc)
-        condition = create_fn(:all?, trait_bindings)
-        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
-
-        trait_bindings = convert_trait_names_to_bindings(trait_names, on_loc)
-        condition = create_fn(:any?, trait_bindings)
-        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
-
-        trait_bindings = convert_trait_names_to_bindings(trait_names, on_loc)
-        condition = create_fn(:none?, trait_bindings)
-        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 convert_trait_names_to_bindings(trait_names, location)
-        trait_names.map do |name|
-          case name
-          when Symbol
-            create_binding(name, location)
-          when DeclarationReference
-            name  # Already a binding from method_missing
-          else
-            raise_error("trait reference must be a symbol or bare identifier, got #{name.class}", location)
-          end
-        end
-      end
-
-      def add_case(condition, result)
-        @cases << Kumi::Syntax::CaseExpression.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)
-        Kumi::Syntax::DeclarationReference.new(name, loc: location)
-      end
-    end
-  end
-end

data/lib/kumi/parser/expression_converter.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Parser
-    # Converts Ruby objects and DSL expressions into AST nodes
-    # This is the bridge between Ruby's native types and Kumi's syntax tree
-    class ExpressionConverter
-      include Syntax
-      include ErrorReporting
-
-      # Use the same literal types as Sugar module to avoid duplication
-      LITERAL_TYPES = Sugar::LITERAL_TYPES
-
-      def initialize(context)
-        @context = context
-      end
-
-      # Convert any Ruby object into a syntax node
-      # @param obj [Object] The object to convert
-      # @return [Syntax::Node] The corresponding AST node
-      def ensure_syntax(obj)
-        case obj
-        when *LITERAL_TYPES
-          create_literal(obj)
-        when Array
-          create_list(obj)
-        when Syntax::Node
-          obj
-        else
-          handle_custom_object(obj)
-        end
-      end
-
-      # Create a reference to another declaration
-      # @param name [Symbol] The name to reference
-      # @return [Syntax::DeclarationReference] Reference node
-      def ref(name)
-        validate_reference_name(name)
-        Kumi::Syntax::DeclarationReference.new(name, loc: current_location)
-      end
-
-      # Create a literal value node
-      # @param value [Object] The literal value
-      # @return [Syntax::Literal] Literal node
-      def literal(value)
-        Kumi::Syntax::Literal.new(value, loc: current_location)
-      end
-
-      # Create a function call expression
-      # @param fn_name [Symbol] The function name
-      # @param args [Array] The function arguments
-      # @return [Syntax::CallExpression] Function call node
-      def fn(fn_name, *args)
-        validate_function_name(fn_name)
-        expr_args = convert_arguments(args)
-        Kumi::Syntax::CallExpression.new(fn_name, expr_args, loc: current_location)
-      end
-
-      # Access the input proxy for field references
-      # @return [InputProxy] Proxy for input field access
-      def input
-        InputProxy.new(@context)
-      end
-
-      # Raise a syntax error with location information
-      # @param message [String] Error message
-      # @param location [Location] Error location
-      def raise_error(message, location)
-        raise_syntax_error(message, location: location)
-      end
-
-      private
-
-      def create_literal(value)
-        Kumi::Syntax::Literal.new(value, loc: current_location)
-      end
-
-      def create_list(array)
-        elements = array.map { |element| ensure_syntax(element) }
-        Kumi::Syntax::ArrayExpression.new(elements, loc: current_location)
-      end
-
-      def handle_custom_object(obj)
-        if obj.respond_to?(:to_ast_node)
-          obj.to_ast_node
-        else
-          raise_invalid_expression_error(obj)
-        end
-      end
-
-      def validate_reference_name(name)
-        unless name.is_a?(Symbol)
-          raise_syntax_error(
-            "Reference name must be a symbol, got #{name.class}",
-            location: current_location
-          )
-        end
-      end
-
-      def validate_function_name(fn_name)
-        unless fn_name.is_a?(Symbol)
-          raise_syntax_error(
-            "Function name must be a symbol, got #{fn_name.class}",
-            location: current_location
-          )
-        end
-      end
-
-      def convert_arguments(args)
-        args.map { |arg| ensure_syntax(arg) }
-      end
-
-      def raise_invalid_expression_error(obj)
-        raise_syntax_error(
-          "Cannot convert #{obj.class} to AST node. " \
-          "Value: #{obj.inspect}",
-          location: current_location
-        )
-      end
-
-      def current_location
-        @context.current_location
-      end
-    end
-  end
-end

data/lib/kumi/parser/guard_rails.rb

@@ -1,43 +0,0 @@
-# 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

@@ -1,125 +0,0 @@
-# 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 << Kumi::Syntax::InputDeclaration.new(name, domain, normalized_type, [], loc: @context.current_location)
-      end
-
-      %i[integer float string boolean any scalar].each do |type_name|
-        define_method(type_name) do |name, type: nil, domain: nil|
-          actual_type = type || (type_name == :scalar ? :any : type_name)
-          @context.inputs << Kumi::Syntax::InputDeclaration.new(name, domain, actual_type, [], loc: @context.current_location)
-        end
-      end
-
-      def array(name_or_elem_type, **kwargs, &block)
-        if block_given?
-          create_array_field_with_block(name_or_elem_type, kwargs, &block)
-        elsif 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', 'scalar', '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 << Kumi::Syntax::InputDeclaration.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 << Kumi::Syntax::InputDeclaration.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
-
-      def create_array_field_with_block(field_name, options, &block)
-        domain = options[:domain]
-
-        # Collect children by creating a nested context
-        children = collect_array_children(&block)
-
-        # Create the InputDeclaration with children
-        @context.inputs << Kumi::Syntax::InputDeclaration.new(
-          field_name,
-          domain,
-          :array,
-          children,
-          loc: @context.current_location
-        )
-      end
-
-      def collect_array_children(&block)
-        # Create a temporary nested context to collect children
-        nested_inputs = []
-        nested_context = NestedInput.new(nested_inputs, @context.current_location)
-        nested_builder = InputBuilder.new(nested_context)
-
-        # Execute the block in the nested context
-        nested_builder.instance_eval(&block)
-
-        nested_inputs
-      end
-    end
-  end
-end