kumi 0.0.7 → 0.0.8

data/lib/kumi/ruby_parser/input_builder.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  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::Types.array(name_or_elem_type)
-        end
-      end
-
-      def hash(name_or_key_type, val_type = nil, **kwargs)
-        return Kumi::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::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::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::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

data/lib/kumi/ruby_parser/input_field_proxy.rb

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

data/lib/kumi/ruby_parser/input_proxy.rb

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

data/lib/kumi/ruby_parser/nested_input.rb

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

data/lib/kumi/ruby_parser/parser.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  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::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::RubyParser::Sugar::ExpressionRefinement")
-        rule_block.binding.eval("using Kumi::RubyParser::Sugar::NumericRefinement")
-        rule_block.binding.eval("using Kumi::RubyParser::Sugar::StringRefinement")
-        rule_block.binding.eval("using Kumi::RubyParser::Sugar::ArrayRefinement")
-        rule_block.binding.eval("using Kumi::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

data/lib/kumi/ruby_parser/schema_builder.rb

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