kumi 0.0.6 → 0.0.8

data/lib/kumi/parser/input_field_proxy.rb

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Parser
-    # Proxy object for input field references (input.field_name)
-    class InputProxy
-      include Syntax
-
-      def initialize(context)
-        @context = context
-      end
-
-      private
-
-      def method_missing(method_name, *_args)
-        # 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 an InputReference node in the AST.
-
-      def respond_to_missing?(_method_name, _include_private = false)
-        true # Allow any field name
-      end
-    end
-  end
-end

data/lib/kumi/parser/nested_input.rb

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

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Parser
-    class Parser
-      include Syntax
-      include ErrorReporting
-
-      def initialize
-        @context = BuildContext.new
-        @interface = SchemaBuilder.new(@context)
-      end
-
-      def parse(&rule_block)
-        enable_refinements(rule_block)
-
-        before_consts = ::Object.constants
-        @interface.freeze # stop singleton hacks
-        @interface.instance_eval(&rule_block)
-        added = ::Object.constants - before_consts
-
-        unless added.empty?
-          raise Kumi::Errors::SemanticError,
-                "DSL cannot define global constants: #{added.join(', ')}"
-        end
-
-        build_syntax_tree
-      rescue ArgumentError => e
-        handle_parse_error(e)
-        raise
-      end
-
-      private
-
-      def enable_refinements(rule_block)
-        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
-
-      def handle_parse_error(error)
-        return unless literal_comparison_error?(error)
-
-        warn <<~HINT
-          #{error.backtrace.first.split(':', 2).join(':')}: \
-          Literal‑left comparison failed because the schema block is \
-          defined inside a method (Ruby disallows refinements there).
-
-          • Move the `schema do … end` block to the top level of a class or module, OR
-          • Write the comparison as `input.age >= 80` (preferred), OR
-          • Wrap the literal: `lit(80) <= input.age`.
-        HINT
-      end
-
-      def literal_comparison_error?(error)
-        error.message =~ /comparison of Integer with Kumi::Syntax::/i
-      end
-
-      def build_syntax_tree
-        Root.new(@context.inputs, @context.attributes, @context.traits)
-      end
-    end
-  end
-end

data/lib/kumi/parser/schema_builder.rb

@@ -1,173 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Parser
-    class SchemaBuilder
-      include GuardRails
-      include Syntax
-      include ErrorReporting
-
-      DSL_METHODS = %i[value trait input ref literal fn].freeze
-
-      def initialize(context)
-        @context = context
-      end
-
-      def value(name = nil, expr = nil, &blk)
-        update_location
-        validate_value_args(name, expr, blk)
-
-        expression = blk ? build_cascade(&blk) : ensure_syntax(expr)
-        @context.attributes << Kumi::Syntax::ValueDeclaration.new(name, expression, loc: @context.current_location)
-      end
-
-      def trait(*args, **kwargs)
-        update_location
-        raise_syntax_error("keyword trait syntax not supported", location: @context.current_location) unless kwargs.empty?
-        build_positional_trait(args)
-      end
-
-      def input(&blk)
-        return InputProxy.new(@context) unless block_given?
-
-        raise_syntax_error("input block already defined", location: @context.current_location) if @context.input_block_defined?
-        @context.mark_input_block_defined!
-
-        update_location
-        input_builder = InputBuilder.new(@context)
-        input_builder.instance_eval(&blk)
-      end
-
-      def ref(name)
-        update_location
-        Kumi::Syntax::DeclarationReference.new(name, loc: @context.current_location)
-      end
-
-      def literal(value)
-        update_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) }
-        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
-          # Create proxy for declaration references (traits/values)
-          DeclarationReferenceProxy.new(method_name, @context)
-        else
-          super
-        end
-      end
-
-      def respond_to_missing?(_method_name, _include_private = false)
-        true
-      end
-
-      private
-
-      def update_location
-        # Use caller_locations(2, 1) to skip the DSL method and get the actual user code location
-        # Stack: [0] update_location, [1] DSL method (value/trait/etc), [2] user's DSL code
-        caller_location = caller_locations(2, 1).first
-
-        @context.current_location = Location.new(
-          file: caller_location.path,
-          line: caller_location.lineno,
-          column: 0
-        )
-      end
-
-      def validate_value_args(name, expr, blk)
-        raise_syntax_error("value requires a name as first argument", location: @context.current_location) if name.nil?
-        unless name.is_a?(Symbol)
-          raise_syntax_error("The name for 'value' must be a Symbol, got #{name.class}",
-                             location: @context.current_location)
-        end
-
-        has_expr = !expr.nil?
-        has_block = blk
-
-        if has_expr && has_block
-          raise_syntax_error("value '#{name}' cannot be called with both an expression and a block", location: @context.current_location)
-        elsif !has_expr && !has_block
-          raise_syntax_error("value '#{name}' requires an expression or a block", location: @context.current_location)
-        end
-      end
-
-      def build_positional_trait(args)
-        case args.size
-        when 0
-          raise_syntax_error("trait requires a name and expression", location: @context.current_location)
-        when 1
-          name = args.first
-          raise_syntax_error("trait '#{name}' requires an expression", location: @context.current_location)
-        when 2
-          name, expression = args
-          validate_trait_name(name)
-          expr = ensure_syntax(expression)
-          @context.traits << Kumi::Syntax::TraitDeclaration.new(name, expr, loc: @context.current_location)
-        else
-          handle_deprecated_trait_syntax(args)
-        end
-      end
-
-      def handle_deprecated_trait_syntax(args)
-        if args.size == 3
-          name, = args
-          raise_syntax_error("trait '#{name}' requires exactly 3 arguments: lhs, operator, and rhs", location: @context.current_location)
-        end
-
-        # warn "DEPRECATION: trait(:name, lhs, operator, rhs) syntax is deprecated. Use: trait :name, (lhs operator rhs)"
-
-        if args.size == 4
-          name, lhs, operator, rhs = args
-          build_deprecated_trait(name, lhs, operator, [rhs])
-        else
-          name, lhs, operator, *rhs = args
-          build_deprecated_trait(name, lhs, operator, rhs)
-        end
-      end
-
-      def build_deprecated_trait(name, lhs, operator, rhs)
-        validate_trait_name(name)
-        validate_operator(operator)
-
-        rhs_exprs = rhs.map { |r| ensure_syntax(r) }
-        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)
-        return if name.is_a?(Symbol)
-
-        raise_syntax_error("The name for 'trait' must be a Symbol, got #{name.class}", location: @context.current_location)
-      end
-
-      def validate_operator(operator)
-        unless operator.is_a?(Symbol)
-          raise_syntax_error("expects a symbol for an operator, got #{operator.class}", location: @context.current_location)
-        end
-
-        return if FunctionRegistry.operator?(operator)
-
-        raise_syntax_error("unsupported operator `#{operator}`", location: @context.current_location)
-      end
-
-      def build_cascade(&blk)
-        expression_converter = ExpressionConverter.new(@context)
-        cascade_builder = DslCascadeBuilder.new(expression_converter, @context.current_location)
-        cascade_builder.instance_eval(&blk)
-        Kumi::Syntax::CascadeExpression.new(cascade_builder.cases, loc: @context.current_location)
-      end
-
-      def ensure_syntax(obj)
-        ExpressionConverter.new(@context).ensure_syntax(obj)
-      end
-    end
-  end
-end

data/lib/kumi/parser/sugar.rb

@@ -1,261 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Parser
-    module Sugar
-      include Syntax
-
-      ARITHMETIC_OPS = {
-        :+ => :add, :- => :subtract, :* => :multiply,
-        :/ => :divide, :% => :modulo, :** => :power
-      }.freeze
-
-      COMPARISON_OPS = %i[< <= > >= == !=].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 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)
-
-        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)
-              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)
-              Sugar.create_call_expression(op, [self, other_node])
-            end
-          end
-
-          # Array access
-          def [](index)
-            Sugar.create_call_expression(:at, [self, Sugar.ensure_literal(index)])
-          end
-
-          # Unary minus
-          def -@
-            Sugar.create_call_expression(:subtract, [Sugar.ensure_literal(0), self])
-          end
-
-          # Logical operations
-          def &(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
-
-      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 = 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 = Sugar.ensure_literal(other)
-                  Sugar.create_call_expression(op, [Kumi::Syntax::Literal.new(self), other_node])
-                else
-                  super(other)
-                end
-              end
-            end
-          end
-        end
-      end
-
-      module StringRefinement
-        refine String do
-          def +(other)
-            if Sugar.syntax_expression?(other)
-              other_node = Sugar.ensure_literal(other)
-              Sugar.create_call_expression(:concat, [Kumi::Syntax::Literal.new(self), other_node])
-            else
-              super
-            end
-          end
-
-          %i[== !=].each do |op|
-            define_method(op) do |other|
-              if Sugar.syntax_expression?(other)
-                other_node = Sugar.ensure_literal(other)
-                Sugar.create_call_expression(op, [Kumi::Syntax::Literal.new(self), other_node])
-              else
-                super(other)
-              end
-            end
-          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_instance.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  # A bound pair of <compiled schema + context>.  Immutable.
-  #
-  # Public API ----------------------------------------------------------
-  #   instance.evaluate                # => full Hash of all bindings
-  #   instance.evaluate(:tax_due, :rate)
-  #   instance.slice(:tax_due)         # alias for evaluate(*keys)
-  #   instance.explain(:tax_due)       # pretty trace string
-  #   instance.input                   # original context (read‑only)
-
-  class SchemaInstance
-    attr_reader :compiled_schema, :analysis, :context
-
-    def initialize(compiled_schema, analysis, context)
-      @compiled_schema = compiled_schema # Kumi::CompiledSchema
-      @analysis = analysis # Analyzer result (for deps)
-      @context  = context.is_a?(EvaluationWrapper) ? context : EvaluationWrapper.new(context)
-    end
-
-    # Hash‑like read of one or many bindings
-    def evaluate(*key_names)
-      if key_names.empty?
-        @compiled_schema.evaluate(@context)
-      else
-        @compiled_schema.evaluate(@context, *key_names)
-      end
-    end
-
-    def slice(*key_names)
-      return {} if key_names.empty?
-
-      evaluate(*key_names)
-    end
-
-    def [](key_name)
-      evaluate(key_name)[key_name]
-    end
-
-    # Update input values and clear affected cached computations
-    def update(**changes)
-      changes.each do |field, value|
-        # Validate field exists
-        raise ArgumentError, "unknown input field: #{field}" unless input_field_exists?(field)
-
-        # Validate domain constraints
-        validate_domain_constraint(field, value)
-
-        # Update the input data
-        @context[field] = value
-
-        # Clear affected cached values using transitive closure by default
-        if ENV["KUMI_SIMPLE_CACHE"] == "true"
-          # Simple fallback: clear all cached values
-          @context.clear_cache
-        else
-          # Default: selective cache clearing using precomputed transitive closure
-          affected_keys = find_dependent_declarations_optimized(field)
-          affected_keys.each { |key| @context.clear_cache(key) }
-        end
-      end
-
-      self # Return self for chaining
-    end
-
-    private
-
-    def input_field_exists?(field)
-      # Check if field is declared in input block
-      input_meta = @analysis&.state&.dig(:input_meta) || {}
-      input_meta.key?(field) || @context.key?(field)
-    end
-
-    def validate_domain_constraint(field, value)
-      input_meta = @analysis&.state&.dig(:input_meta) || {}
-      field_meta = input_meta[field]
-      return unless field_meta&.dig(:domain)
-
-      domain = field_meta[:domain]
-      return unless violates_domain?(value, domain)
-
-      raise ArgumentError, "value #{value} is not in domain #{domain}"
-    end
-
-    def violates_domain?(value, domain)
-      case domain
-      when Range
-        !domain.include?(value)
-      when Array
-        !domain.include?(value)
-      when Proc
-        # For Proc domains, we can't statically analyze
-        false
-      else
-        false
-      end
-    end
-
-    def find_dependent_declarations_optimized(field)
-      # Use precomputed transitive closure for true O(1) lookup!
-      transitive_dependents = @analysis&.state&.dig(:transitive_dependents)
-      return [] unless transitive_dependents
-
-      # This is truly O(1) - just array lookup, no traversal needed
-      transitive_dependents[field] || []
-    end
-  end
-end