kumi 0.0.7 → 0.0.8

data/lib/kumi/core/ruby_parser/dsl_cascade_builder.rb

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

data/lib/kumi/core/ruby_parser/expression_converter.rb

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

data/lib/kumi/core/ruby_parser/guard_rails.rb

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

data/lib/kumi/core/ruby_parser/input_builder.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module RubyParser
+      class InputBuilder
+        include Syntax
+        include ErrorReporting
+
+        def initialize(context)
+          @context = context
+        end
+
+        def key(name, type: :any, domain: nil)
+          normalized_type = normalize_type(type, name)
+          @context.inputs << Kumi::Syntax::InputDeclaration.new(name, domain, normalized_type, [], loc: @context.current_location)
+        end
+
+        %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, &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::Core::Types.array(name_or_elem_type)
+          end
+        end
+
+        def hash(name_or_key_type, val_type = nil, **kwargs)
+          return Kumi::Core::Types.hash(name_or_key_type, val_type) unless val_type.nil?
+
+          create_hash_field(name_or_key_type, kwargs)
+        end
+
+        def method_missing(method_name, *_args)
+          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
+
+        def respond_to_missing?(_method_name, _include_private = false)
+          false
+        end
+
+        private
+
+        def normalize_type(type, name)
+          Kumi::Core::Types.normalize(type)
+        rescue ArgumentError => e
+          raise_syntax_error("Invalid type for input `#{name}`: #{e.message}", location: @context.current_location)
+        end
+
+        def create_array_field(field_name, options)
+          elem_spec = options[:elem]
+          domain = options[:domain]
+          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 << Kumi::Syntax::InputDeclaration.new(field_name, domain, array_type, [], loc: @context.current_location)
+        end
+
+        def create_array_type(field_name, elem_type)
+          Kumi::Core::Types.array(elem_type)
+        rescue ArgumentError => e
+          raise_syntax_error("Invalid element type for array `#{field_name}`: #{e.message}", location: @context.current_location)
+        end
+
+        def create_hash_field(field_name, options)
+          key_spec = options[:key]
+          val_spec = options[:val] || options[:value]
+          domain = options[:domain]
+
+          key_type = extract_type(key_spec)
+          val_type = extract_type(val_spec)
+
+          hash_type = create_hash_type(field_name, key_type, val_type)
+          @context.inputs << Kumi::Syntax::InputDeclaration.new(field_name, domain, hash_type, [], loc: @context.current_location)
+        end
+
+        def extract_type(spec)
+          spec.is_a?(Hash) && spec[:type] ? spec[:type] : :any
+        end
+
+        def create_hash_type(field_name, key_type, val_type)
+          Kumi::Core::Types.hash(key_type, val_type)
+        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
+end

data/lib/kumi/core/ruby_parser/input_field_proxy.rb

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

data/lib/kumi/core/ruby_parser/input_proxy.rb

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

data/lib/kumi/core/ruby_parser/nested_input.rb

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

data/lib/kumi/core/ruby_parser/parser.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module RubyParser
+      # Main parser class for Ruby DSL
+      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::Core::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::Core::RubyParser::Sugar::ExpressionRefinement")
+          rule_block.binding.eval("using Kumi::Core::RubyParser::Sugar::NumericRefinement")
+          rule_block.binding.eval("using Kumi::Core::RubyParser::Sugar::StringRefinement")
+          rule_block.binding.eval("using Kumi::Core::RubyParser::Sugar::ArrayRefinement")
+          rule_block.binding.eval("using Kumi::Core::RubyParser::Sugar::ModuleRefinement")
+        rescue RuntimeError, NoMethodError
+          # Refinements disabled in method scope - continue without them
+        end
+
+        def build_syntax_tree
+          Root.new(@context.inputs, @context.attributes, @context.traits)
+        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
+      end
+    end
+  end
+end