kumi 0.0.4 → 0.0.6

data/lib/kumi/parser/expression_converter.rb

@@ -2,57 +2,125 @@
 
 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 Integer, String, TrueClass, FalseClass, Float, Regexp, Symbol
-          Literal.new(obj)
+        when *LITERAL_TYPES
+          create_literal(obj)
         when Array
-          ListExpression.new(obj.map { |e| ensure_syntax(e) })
+          create_list(obj)
         when Syntax::Node
           obj
         else
-          handle_complex_object(obj)
+          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)
-        Binding.new(name, loc: @context.current_location)
+        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)
-        Literal.new(value, loc: @context.current_location)
+        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)
-        expr_args = args.map { |a| ensure_syntax(a) }
-        CallExpression.new(fn_name, expr_args, loc: @context.current_location)
+        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 handle_complex_object(obj)
-        if obj.class.instance_methods.include?(:to_ast_node)
+      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_syntax_error("Invalid expression: #{obj.inspect}", location: @context.current_location)
+          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
+end

data/lib/kumi/parser/input_builder.rb

@@ -12,17 +12,20 @@ module Kumi
 
       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)
+        @context.inputs << Kumi::Syntax::InputDeclaration.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)
+      %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)
-        if kwargs.any?
+      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)
@@ -36,7 +39,7 @@ module Kumi
       end
 
       def method_missing(method_name, *_args)
-        allowed_methods = "'key', 'integer', 'float', 'string', 'boolean', 'any', 'array', and 'hash'"
+        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
@@ -59,7 +62,7 @@ module Kumi
         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)
+        @context.inputs << Kumi::Syntax::InputDeclaration.new(field_name, domain, array_type, [], loc: @context.current_location)
       end
 
       def create_array_type(field_name, elem_type)
@@ -77,7 +80,7 @@ module Kumi
         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)
+        @context.inputs << Kumi::Syntax::InputDeclaration.new(field_name, domain, hash_type, [], loc: @context.current_location)
       end
 
       def extract_type(spec)
@@ -89,6 +92,34 @@ module Kumi
       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

data/lib/kumi/parser/input_field_proxy.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Parser
+    # Proxy for input field access that can handle arbitrary depth nesting
+    # Handles input.field.subfield.subsubfield... syntax by building up path arrays
+    class InputFieldProxy
+      include Syntax
+      
+      # Use shared operator methods instead of refinements
+      extend Sugar::ProxyRefinement
+
+      def initialize(path, context)
+        @path = Array(path)  # Ensure it's always an array
+        @context = context
+      end
+
+      # Convert to appropriate AST node based on path length
+      def to_ast_node
+        if @path.length == 1
+          # Single field: input.field -> InputReference
+          Kumi::Syntax::InputReference.new(@path.first, loc: @context.current_location)
+        else
+          # Nested fields: input.field.subfield... -> InputElementReference
+          Kumi::Syntax::InputElementReference.new(@path, loc: @context.current_location)
+        end
+      end
+
+      private
+
+      def method_missing(method_name, *args, &block)
+        if args.empty? && block.nil?
+          # Extend the path: input.user.details -> InputFieldProxy([user, details])
+          InputFieldProxy.new(@path + [method_name], @context)
+        else
+          # Operators are now handled by ProxyRefinement methods
+          super
+        end
+      end
+
+      def respond_to_missing?(_method_name, _include_private = false)
+        true
+      end
+    end
+  end
+end

data/lib/kumi/parser/input_proxy.rb

@@ -13,13 +13,13 @@ module Kumi
       private
 
       def method_missing(method_name, *_args)
-        # Create a FieldRef node for the given method name
-        FieldRef.new(method_name, loc: @context.current_location)
+        # Create InputFieldProxy that can handle further field access
+        InputFieldProxy.new(method_name, @context)
       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.
+      # It is used to create an InputReference node in the AST.
 
       def respond_to_missing?(_method_name, _include_private = false)
         true # Allow any field name

data/lib/kumi/parser/nested_input.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Parser
+    # Simple context struct for nested input collection
+    class NestedInput
+      attr_reader :inputs, :current_location
+
+      def initialize(inputs_array, location)
+        @inputs = inputs_array
+        @current_location = location
+      end
+    end
+  end
+end

data/lib/kumi/parser/parser.rb

@@ -36,6 +36,8 @@ module Kumi
         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")
+        rule_block.binding.eval("using Kumi::Parser::Sugar::ArrayRefinement")
+        rule_block.binding.eval("using Kumi::Parser::Sugar::ModuleRefinement")
       rescue RuntimeError, NoMethodError
         # Refinements disabled in method scope - continue without them
       end

data/lib/kumi/parser/schema_builder.rb

@@ -18,7 +18,7 @@ module Kumi
         validate_value_args(name, expr, blk)
 
         expression = blk ? build_cascade(&blk) : ensure_syntax(expr)
-        @context.attributes << Attribute.new(name, expression, loc: @context.current_location)
+        @context.attributes << Kumi::Syntax::ValueDeclaration.new(name, expression, loc: @context.current_location)
       end
 
       def trait(*args, **kwargs)
@@ -40,24 +40,25 @@ module Kumi
 
       def ref(name)
         update_location
-        Binding.new(name, loc: @context.current_location)
+        Kumi::Syntax::DeclarationReference.new(name, loc: @context.current_location)
       end
 
       def literal(value)
         update_location
-        Literal.new(value, loc: @context.current_location)
+        Kumi::Syntax::Literal.new(value, loc: @context.current_location)
       end
 
       def fn(fn_name, *args)
         update_location
         expr_args = args.map { |a| ensure_syntax(a) }
-        CallExpression.new(fn_name, expr_args, loc: @context.current_location)
+        Kumi::Syntax::CallExpression.new(fn_name, expr_args, loc: @context.current_location)
       end
 
       def method_missing(method_name, *args, &block)
         if args.empty? && !block_given?
           update_location
-          Binding.new(method_name, loc: @context.current_location)
+          # Create proxy for declaration references (traits/values)
+          DeclarationReferenceProxy.new(method_name, @context)
         else
           super
         end
@@ -109,7 +110,7 @@ module Kumi
           name, expression = args
           validate_trait_name(name)
           expr = ensure_syntax(expression)
-          @context.traits << Trait.new(name, expr, loc: @context.current_location)
+          @context.traits << Kumi::Syntax::TraitDeclaration.new(name, expr, loc: @context.current_location)
         else
           handle_deprecated_trait_syntax(args)
         end
@@ -137,8 +138,8 @@ module Kumi
         validate_operator(operator)
 
         rhs_exprs = rhs.map { |r| ensure_syntax(r) }
-        expr = CallExpression.new(operator, [ensure_syntax(lhs)] + rhs_exprs, loc: @context.current_location)
-        @context.traits << Trait.new(name, expr, loc: @context.current_location)
+        expr = Kumi::Syntax::CallExpression.new(operator, [ensure_syntax(lhs)] + rhs_exprs, loc: @context.current_location)
+        @context.traits << Kumi::Syntax::TraitDeclaration.new(name, expr, loc: @context.current_location)
       end
 
       def validate_trait_name(name)
@@ -161,7 +162,7 @@ module Kumi
         expression_converter = ExpressionConverter.new(@context)
         cascade_builder = DslCascadeBuilder.new(expression_converter, @context.current_location)
         cascade_builder.instance_eval(&blk)
-        CascadeExpression.new(cascade_builder.cases, loc: @context.current_location)
+        Kumi::Syntax::CascadeExpression.new(cascade_builder.cases, loc: @context.current_location)
       end
 
       def ensure_syntax(obj)

data/lib/kumi/parser/sugar.rb

@@ -5,49 +5,89 @@ module Kumi
     module Sugar
       include Syntax
 
-      ARITHMETIC_OPS = { :+ => :add, :- => :subtract, :* => :multiply,
-                         :/ => :divide, :% => :modulo, :** => :power }.freeze
+      ARITHMETIC_OPS = {
+        :+ => :add, :- => :subtract, :* => :multiply,
+        :/ => :divide, :% => :modulo, :** => :power
+      }.freeze
+
       COMPARISON_OPS = %i[< <= > >= == !=].freeze
-      LITERAL_TYPES = [Integer, String, Symbol, TrueClass, FalseClass, Float, Regexp].freeze
+
+      LITERAL_TYPES = [
+        Integer, String, Symbol, TrueClass, FalseClass, Float, Regexp, NilClass
+      ].freeze
+
+      # Collection methods that can be applied to arrays/syntax nodes
+      COLLECTION_METHODS = %i[
+        sum size length first last sort reverse unique min max empty? flatten
+        map_with_index indices
+      ].freeze
 
       def self.ensure_literal(obj)
-        return Literal.new(obj) if LITERAL_TYPES.any? { |type| obj.is_a?(type) }
+        return Kumi::Syntax::Literal.new(obj) if LITERAL_TYPES.any? { |type| obj.is_a?(type) }
         return obj if obj.is_a?(Syntax::Node)
         return obj.to_ast_node if obj.respond_to?(:to_ast_node)
 
-        Literal.new(obj)
+        Kumi::Syntax::Literal.new(obj)
       end
 
       def self.syntax_expression?(obj)
         obj.is_a?(Syntax::Node) || obj.respond_to?(:to_ast_node)
       end
 
+      # Create a call expression with consistent error handling
+      def self.create_call_expression(fn_name, args)
+        Kumi::Syntax::CallExpression.new(fn_name, args)
+      end
+
       module ExpressionRefinement
         refine Syntax::Node do
+          # Arithmetic operations
           ARITHMETIC_OPS.each do |op, op_name|
             define_method(op) do |other|
               other_node = Sugar.ensure_literal(other)
-              Syntax::CallExpression.new(op_name, [self, other_node])
+              Sugar.create_call_expression(op_name, [self, other_node])
             end
           end
 
+          # Comparison operations
           COMPARISON_OPS.each do |op|
             define_method(op) do |other|
               other_node = Sugar.ensure_literal(other)
-              Syntax::CallExpression.new(op, [self, other_node])
+              Sugar.create_call_expression(op, [self, other_node])
             end
           end
 
+          # Array access
           def [](index)
-            Syntax::CallExpression.new(:at, [self, Sugar.ensure_literal(index)])
+            Sugar.create_call_expression(:at, [self, Sugar.ensure_literal(index)])
           end
 
+          # Unary minus
           def -@
-            Syntax::CallExpression.new(:subtract, [Sugar.ensure_literal(0), self])
+            Sugar.create_call_expression(:subtract, [Sugar.ensure_literal(0), self])
           end
 
+          # Logical operations
           def &(other)
-            Syntax::CallExpression.new(:and, [self, Sugar.ensure_literal(other)])
+            Sugar.create_call_expression(:and, [self, Sugar.ensure_literal(other)])
+          end
+
+          def |(other)
+            Sugar.create_call_expression(:or, [self, Sugar.ensure_literal(other)])
+          end
+
+          # Collection methods - single argument (self)
+          COLLECTION_METHODS.each do |method_name|
+            next if method_name == :include? # Special case with element argument
+
+            define_method(method_name) do
+              Sugar.create_call_expression(method_name, [self])
+            end
+          end
+
+          # Special case: include? takes an element argument
+          def include?(element)
+            Sugar.create_call_expression(:include?, [self, Sugar.ensure_literal(element)])
           end
         end
       end
@@ -55,22 +95,24 @@ module Kumi
       module NumericRefinement
         [Integer, Float].each do |klass|
           refine klass do
+            # Arithmetic operations with syntax expressions
             ARITHMETIC_OPS.each do |op, op_name|
               define_method(op) do |other|
                 if Sugar.syntax_expression?(other)
-                  other_node = other.respond_to?(:to_ast_node) ? other.to_ast_node : other
-                  Syntax::CallExpression.new(op_name, [Syntax::Literal.new(self), other_node])
+                  other_node = Sugar.ensure_literal(other)
+                  Sugar.create_call_expression(op_name, [Kumi::Syntax::Literal.new(self), other_node])
                 else
                   super(other)
                 end
               end
             end
 
+            # Comparison operations with syntax expressions
             COMPARISON_OPS.each do |op|
               define_method(op) do |other|
                 if Sugar.syntax_expression?(other)
-                  other_node = other.respond_to?(:to_ast_node) ? other.to_ast_node : other
-                  Syntax::CallExpression.new(op, [Syntax::Literal.new(self), other_node])
+                  other_node = Sugar.ensure_literal(other)
+                  Sugar.create_call_expression(op, [Kumi::Syntax::Literal.new(self), other_node])
                 else
                   super(other)
                 end
@@ -84,8 +126,8 @@ module Kumi
         refine String do
           def +(other)
             if Sugar.syntax_expression?(other)
-              other_node = other.respond_to?(:to_ast_node) ? other.to_ast_node : other
-              Syntax::CallExpression.new(:concat, [Syntax::Literal.new(self), other_node])
+              other_node = Sugar.ensure_literal(other)
+              Sugar.create_call_expression(:concat, [Kumi::Syntax::Literal.new(self), other_node])
             else
               super
             end
@@ -94,8 +136,8 @@ module Kumi
           %i[== !=].each do |op|
             define_method(op) do |other|
               if Sugar.syntax_expression?(other)
-                other_node = other.respond_to?(:to_ast_node) ? other.to_ast_node : other
-                Syntax::CallExpression.new(op, [Syntax::Literal.new(self), other_node])
+                other_node = Sugar.ensure_literal(other)
+                Sugar.create_call_expression(op, [Kumi::Syntax::Literal.new(self), other_node])
               else
                 super(other)
               end
@@ -103,6 +145,117 @@ module Kumi
           end
         end
       end
+
+      module ArrayRefinement
+        refine Array do
+          # Helper method to check if array contains any syntax expressions
+          def any_syntax_expressions?
+            any? { |item| Sugar.syntax_expression?(item) }
+          end
+
+          # Convert array to syntax list expression with all elements as syntax nodes
+          def to_syntax_list
+            syntax_elements = map { |item| Sugar.ensure_literal(item) }
+            Kumi::Syntax::ArrayExpression.new(syntax_elements)
+          end
+
+          # Create array method that works with syntax expressions
+          def self.define_array_syntax_method(method_name, has_argument: false)
+            define_method(method_name) do |*args|
+              if any_syntax_expressions?
+                array_literal = to_syntax_list
+                call_args = [array_literal]
+                call_args.concat(args.map { |arg| Sugar.ensure_literal(arg) }) if has_argument
+                Sugar.create_call_expression(method_name, call_args)
+              else
+                super(*args)
+              end
+            end
+          end
+
+          # Define collection methods without arguments
+          %i[sum size length first last sort reverse unique min max empty? flatten].each do |method_name|
+            define_array_syntax_method(method_name)
+          end
+
+          # Define methods with arguments
+          define_array_syntax_method(:include?, has_argument: true)
+        end
+      end
+
+      module ModuleRefinement
+        refine Module do
+          # Allow modules to provide schema utilities and helpers
+          def with_schema_utilities
+            include Kumi::Schema if respond_to?(:include)
+            extend Kumi::Schema if respond_to?(:extend)
+          end
+
+          # Helper for defining schema constants that can be used in multiple schemas
+          def schema_const(name, value)
+            const_set(name, value.freeze)
+          end
+
+          # Enable easy schema composition
+          def compose_schema(*modules)
+            modules.each do |mod|
+              include mod if mod.is_a?(Module)
+            end
+          end
+        end
+      end
+
+      # Shared refinement for proxy objects that need to handle operators
+      # Both DeclarationReferenceProxy and InputFieldProxy can use this
+      module ProxyRefinement
+        def self.extended(proxy_class)
+          # Add operator methods directly to the proxy class
+          proxy_class.class_eval do
+            # Arithmetic operations
+            ARITHMETIC_OPS.each do |op, op_name|
+              define_method(op) do |other|
+                ast_node = to_ast_node
+                other_node = Sugar.ensure_literal(other)
+                Sugar.create_call_expression(op_name, [ast_node, other_node])
+              end
+            end
+
+            # Comparison operations (including == and != that don't work with refinements)
+            COMPARISON_OPS.each do |op|
+              define_method(op) do |other|
+                ast_node = to_ast_node
+                other_node = Sugar.ensure_literal(other)
+                Sugar.create_call_expression(op, [ast_node, other_node])
+              end
+            end
+
+            # Logical operations
+            define_method(:&) do |other|
+              ast_node = to_ast_node
+              other_node = Sugar.ensure_literal(other)
+              Sugar.create_call_expression(:and, [ast_node, other_node])
+            end
+
+            define_method(:|) do |other|
+              ast_node = to_ast_node
+              other_node = Sugar.ensure_literal(other)
+              Sugar.create_call_expression(:or, [ast_node, other_node])
+            end
+
+            # Array access
+            define_method(:[]) do |index|
+              ast_node = to_ast_node
+              Sugar.create_call_expression(:at, [ast_node, Sugar.ensure_literal(index)])
+            end
+
+            # Unary minus
+            define_method(:-@) do
+              ast_node = to_ast_node
+              Sugar.create_call_expression(:subtract, [Sugar.ensure_literal(0), ast_node])
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/kumi/schema.rb

@@ -4,6 +4,8 @@ require "ostruct"
 
 module Kumi
   module Schema
+    attr_reader :__syntax_tree__, :__analyzer_result__, :__compiled_schema__
+
     Inspector = Struct.new(:syntax_tree, :analyzer_result, :compiled_schema) do
       def inspect
         "#<#{self.class} syntax_tree: #{syntax_tree.inspect}, analyzer_result: #{analyzer_result.inspect}, schema: #{schema.inspect}>"
@@ -19,7 +21,7 @@ module Kumi
 
       raise Errors::InputValidationError, violations unless violations.empty?
 
-      SchemaInstance.new(@__compiled_schema__, @__analyzer_result__.definitions, context)
+      SchemaInstance.new(@__compiled_schema__, @__analyzer_result__, context)
     end
 
     def explain(context, *keys)