kumi 0.0.5 → 0.0.7

data/lib/kumi/{parser → ruby_parser}/sugar.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Kumi
-  module Parser
+  module RubyParser
     module Sugar
       include Syntax
 
@@ -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/ruby_parser.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Kumi
+  # Ruby DSL parser for Kumi schemas
+  # Converts Ruby block syntax into AST nodes
+  module RubyParser
+    # This module contains all Ruby DSL parsing functionality
+    # The main entry point is through Dsl.build_syntax_tree
+  end
+end

data/lib/kumi/schema.rb

@@ -16,19 +16,19 @@ module Kumi
       raise("No schema defined") unless @__compiled_schema__
 
       # Validate input types and domain constraints
-      input_meta = @__analyzer_result__.state[:input_meta] || {}
+      input_meta = @__analyzer_result__.state[:inputs] || {}
       violations = Input::Validator.validate_context(context, input_meta)
 
       raise Errors::InputValidationError, violations unless violations.empty?
 
-      SchemaInstance.new(@__compiled_schema__, @__analyzer_result__, context)
+      SchemaInstance.new(@__compiled_schema__, @__analyzer_result__.state, context)
     end
 
     def explain(context, *keys)
       raise("No schema defined") unless @__compiled_schema__
 
       # Validate input types and domain constraints
-      input_meta = @__analyzer_result__.state[:input_meta] || {}
+      input_meta = @__analyzer_result__.state[:inputs] || {}
       violations = Input::Validator.validate_context(context, input_meta)
 
       raise Errors::InputValidationError, violations unless violations.empty?
@@ -41,11 +41,17 @@ module Kumi
     end
 
     def schema(&block)
-      @__syntax_tree__ = Kumi::Parser::Dsl.build_syntax_tree(&block).freeze
+      @__syntax_tree__ = Kumi::RubyParser::Dsl.build_syntax_tree(&block).freeze
       @__analyzer_result__ = Analyzer.analyze!(@__syntax_tree__).freeze
       @__compiled_schema__ = Compiler.compile(@__syntax_tree__, analyzer: @__analyzer_result__).freeze
 
       Inspector.new(@__syntax_tree__, @__analyzer_result__, @__compiled_schema__)
     end
+
+    def schema_metadata
+      raise("No schema defined") unless @__analyzer_result__
+
+      @schema_metadata ||= SchemaMetadata.new(@__analyzer_result__.state, @__syntax_tree__)
+    end
   end
 end

data/lib/kumi/schema_instance.rb

@@ -11,11 +11,11 @@ module Kumi
   #   instance.input                   # original context (read‑only)
 
   class SchemaInstance
-    attr_reader :compiled_schema, :analysis, :context
+    attr_reader :compiled_schema, :metadata, :context
 
-    def initialize(compiled_schema, analysis, context)
+    def initialize(compiled_schema, metadata, context)
       @compiled_schema = compiled_schema # Kumi::CompiledSchema
-      @analysis = analysis # Analyzer result (for deps)
+      @metadata = metadata # Frozen state hash
       @context  = context.is_a?(EvaluationWrapper) ? context : EvaluationWrapper.new(context)
     end
 
@@ -68,12 +68,12 @@ module Kumi
 
     def input_field_exists?(field)
       # Check if field is declared in input block
-      input_meta = @analysis&.state&.dig(:input_meta) || {}
+      input_meta = @metadata[:inputs] || {}
       input_meta.key?(field) || @context.key?(field)
     end
 
     def validate_domain_constraint(field, value)
-      input_meta = @analysis&.state&.dig(:input_meta) || {}
+      input_meta = @metadata[:inputs] || {}
       field_meta = input_meta[field]
       return unless field_meta&.dig(:domain)
 
@@ -99,7 +99,7 @@ module Kumi
 
     def find_dependent_declarations_optimized(field)
       # Use precomputed transitive closure for true O(1) lookup!
-      transitive_dependents = @analysis&.state&.dig(:transitive_dependents)
+      transitive_dependents = @metadata[:dependents]
       return [] unless transitive_dependents
 
       # This is truly O(1) - just array lookup, no traversal needed