kumi 0.0.7 → 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/json_schema/generator.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module Kumi
-  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

data/lib/kumi/json_schema/validator.rb

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

data/lib/kumi/json_schema.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "json_schema/generator"
-require_relative "json_schema/validator"
-
-module Kumi
-  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

data/lib/kumi/ruby_parser/build_context.rb

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

data/lib/kumi/ruby_parser/declaration_reference_proxy.rb

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

data/lib/kumi/ruby_parser/dsl.rb

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

data/lib/kumi/ruby_parser/dsl_cascade_builder.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module RubyParser
-    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/ruby_parser/expression_converter.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module RubyParser
-    # 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)
-        return if name.is_a?(Symbol)
-
-        raise_syntax_error(
-          "Reference name must be a symbol, got #{name.class}",
-          location: current_location
-        )
-      end
-
-      def validate_function_name(fn_name)
-        return if fn_name.is_a?(Symbol)
-
-        raise_syntax_error(
-          "Function name must be a symbol, got #{fn_name.class}",
-          location: current_location
-        )
-      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/ruby_parser/guard_rails.rb

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