kumi 0.0.5 → 0.0.6

data/lib/kumi/parser/declaration_reference_proxy.rb

@@ -0,0 +1,36 @@
+# 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_cascade_builder.rb

@@ -88,7 +88,7 @@ module Kumi
           case name
           when Symbol
             create_binding(name, location)
-          when Binding
+          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)
@@ -97,7 +97,7 @@ module Kumi
       end
 
       def add_case(condition, result)
-        @cases << WhenCaseExpression.new(condition, result)
+        @cases << Kumi::Syntax::CaseExpression.new(condition, result)
       end
 
       def ref(name)
@@ -129,7 +129,7 @@ module Kumi
       end
 
       def create_binding(name, location)
-        Binding.new(name, loc: location)
+        Kumi::Syntax::DeclarationReference.new(name, loc: location)
       end
     end
   end

data/lib/kumi/parser/expression_converter.rb

@@ -33,17 +33,17 @@ module Kumi
 
       # Create a reference to another declaration
       # @param name [Symbol] The name to reference
-      # @return [Syntax::Binding] Reference node
+      # @return [Syntax::DeclarationReference] Reference node
       def ref(name)
         validate_reference_name(name)
-        Binding.new(name, loc: current_location)
+        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: current_location)
+        Kumi::Syntax::Literal.new(value, loc: current_location)
       end
 
       # Create a function call expression
@@ -53,7 +53,7 @@ module Kumi
       def fn(fn_name, *args)
         validate_function_name(fn_name)
         expr_args = convert_arguments(args)
-        CallExpression.new(fn_name, expr_args, loc: current_location)
+        Kumi::Syntax::CallExpression.new(fn_name, expr_args, loc: current_location)
       end
 
       # Access the input proxy for field references
@@ -72,12 +72,12 @@ module Kumi
       private
 
       def create_literal(value)
-        Literal.new(value, loc: current_location)
+        Kumi::Syntax::Literal.new(value, loc: current_location)
       end
 
       def create_list(array)
         elements = array.map { |element| ensure_syntax(element) }
-        ListExpression.new(elements, loc: current_location)
+        Kumi::Syntax::ArrayExpression.new(elements, loc: current_location)
       end
 
       def handle_custom_object(obj)

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/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

@@ -13,7 +13,7 @@ module Kumi
       COMPARISON_OPS = %i[< <= > >= == !=].freeze
 
       LITERAL_TYPES = [
-        Integer, String, Symbol, TrueClass, FalseClass, Float, Regexp
+        Integer, String, Symbol, TrueClass, FalseClass, Float, Regexp, NilClass
       ].freeze
 
       # Collection methods that can be applied to arrays/syntax nodes
@@ -23,11 +23,11 @@ module Kumi
       ].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)
@@ -36,7 +36,7 @@ module Kumi
 
       # Create a call expression with consistent error handling
       def self.create_call_expression(fn_name, args)
-        Syntax::CallExpression.new(fn_name, args)
+        Kumi::Syntax::CallExpression.new(fn_name, args)
       end
 
       module ExpressionRefinement
@@ -100,7 +100,7 @@ module Kumi
               define_method(op) do |other|
                 if Sugar.syntax_expression?(other)
                   other_node = Sugar.ensure_literal(other)
-                  Sugar.create_call_expression(op_name, [Syntax::Literal.new(self), other_node])
+                  Sugar.create_call_expression(op_name, [Kumi::Syntax::Literal.new(self), other_node])
                 else
                   super(other)
                 end
@@ -112,7 +112,7 @@ module Kumi
               define_method(op) do |other|
                 if Sugar.syntax_expression?(other)
                   other_node = Sugar.ensure_literal(other)
-                  Sugar.create_call_expression(op, [Syntax::Literal.new(self), other_node])
+                  Sugar.create_call_expression(op, [Kumi::Syntax::Literal.new(self), other_node])
                 else
                   super(other)
                 end
@@ -127,7 +127,7 @@ module Kumi
           def +(other)
             if Sugar.syntax_expression?(other)
               other_node = Sugar.ensure_literal(other)
-              Sugar.create_call_expression(:concat, [Syntax::Literal.new(self), other_node])
+              Sugar.create_call_expression(:concat, [Kumi::Syntax::Literal.new(self), other_node])
             else
               super
             end
@@ -137,7 +137,7 @@ module Kumi
             define_method(op) do |other|
               if Sugar.syntax_expression?(other)
                 other_node = Sugar.ensure_literal(other)
-                Sugar.create_call_expression(op, [Syntax::Literal.new(self), other_node])
+                Sugar.create_call_expression(op, [Kumi::Syntax::Literal.new(self), other_node])
               else
                 super(other)
               end
@@ -156,7 +156,7 @@ module Kumi
           # Convert array to syntax list expression with all elements as syntax nodes
           def to_syntax_list
             syntax_elements = map { |item| Sugar.ensure_literal(item) }
-            Syntax::ListExpression.new(syntax_elements)
+            Kumi::Syntax::ArrayExpression.new(syntax_elements)
           end
 
           # Create array method that works with syntax expressions
@@ -204,6 +204,58 @@ module Kumi
           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/syntax/array_expression.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Syntax
+    ArrayExpression = Struct.new(:elements) do
+      include Node
+
+      def children = elements
+
+      def size
+        elements.size
+      end
+    end
+  end
+end

data/lib/kumi/syntax/call_expression.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Syntax
+    CallExpression = Struct.new(:fn_name, :args) do
+      include Node
+
+      def children = args
+    end
+  end
+end

data/lib/kumi/syntax/cascade_expression.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Syntax
+    CascadeExpression = Struct.new(:cases) do
+      include Node
+
+      def children = cases
+    end
+  end
+end

data/lib/kumi/syntax/case_expression.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Syntax
+    CaseExpression = Struct.new(:condition, :result) do
+      include Node
+
+      def children = [condition, result]
+    end
+  end
+end

data/lib/kumi/syntax/declaration_reference.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Syntax
+    DeclarationReference = Struct.new(:name) do
+      include Node
+
+      def children = []
+    end
+  end
+end

data/lib/kumi/syntax/hash_expression.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Syntax
+    HashExpression = Struct.new(:pairs) do
+      include Node
+
+      def children = pairs.flatten
+    end
+  end
+end

data/lib/kumi/syntax/input_declaration.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Syntax
+    # For field metadata declarations inside input blocks
+    InputDeclaration = Struct.new(:name, :domain, :type, :children) do
+      include Node
+
+      def children = self[:children] || []
+    end
+  end
+end

data/lib/kumi/syntax/input_element_reference.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Syntax
+    # For field usage/reference in expressions (input.field_name)
+    InputElementReference = Struct.new(:path) do
+      include Node
+
+      def children = []
+    end
+  end
+end

data/lib/kumi/syntax/input_reference.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Syntax
+    # For field usage/reference in expressions (input.field_name)
+    InputReference = Struct.new(:name) do
+      include Node
+
+      def children = []
+    end
+  end
+end

data/lib/kumi/syntax/literal.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Syntax
+    Literal = Struct.new(:value) do
+      include Node
+
+      def children = []
+    end
+  end
+end

data/lib/kumi/syntax/trait_declaration.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Syntax
+    TraitDeclaration = Struct.new(:name, :expression) do
+      include Node
+
+      def children = [expression]
+    end
+  end
+end

data/lib/kumi/syntax/value_declaration.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Syntax
+    ValueDeclaration = Struct.new(:name, :expression) do
+      include Node
+
+      def children = [expression]
+    end
+  end
+end