kumi 0.0.5 → 0.0.7

data/lib/kumi/json_schema/generator.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Kumi
+  module JsonSchema
+    # Converts Kumi schema metadata to JSON Schema format
+    class Generator
+      def initialize(schema_metadata)
+        @metadata = schema_metadata
+      end
+
+      def generate
+        {
+          type: "object",
+          properties: build_properties,
+          required: extract_required_fields,
+          "x-kumi-values": @metadata.values,
+          "x-kumi-traits": @metadata.traits
+        }
+      end
+
+      private
+
+      def build_properties
+        @metadata.inputs.transform_values { |spec| convert_input_to_json_schema(spec) }
+      end
+
+      def extract_required_fields
+        @metadata.inputs.select { |_k, v| v[:required] }.keys
+      end
+
+      def convert_input_to_json_schema(input_spec)
+        base = { type: map_kumi_type_to_json_schema(input_spec[:type]) }
+
+        domain = input_spec[:domain]
+        return base unless domain
+
+        case domain[:type]
+        when :range
+          base[:minimum] = domain[:min]
+          base[:maximum] = domain[:max]
+        when :enum
+          base[:enum] = domain[:values]
+        end
+
+        base
+      end
+
+      def map_kumi_type_to_json_schema(kumi_type)
+        case kumi_type
+        when :string then "string"
+        when :integer then "integer"
+        when :float then "number"
+        when :boolean then "boolean"
+        when :array then "array"
+        when :hash then "object"
+        else "string"
+        end
+      end
+    end
+  end
+end

data/lib/kumi/json_schema/validator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Kumi
+  module JsonSchema
+    # Validates data against JSON Schema (placeholder for future implementation)
+    class Validator
+      def initialize(json_schema)
+        @schema = json_schema
+      end
+
+      def validate(_data)
+        # Placeholder implementation
+        # In a real implementation, this would validate data against the JSON Schema
+        {
+          valid: true,
+          errors: []
+        }
+      end
+
+      def self.validate(json_schema, data)
+        new(json_schema).validate(data)
+      end
+    end
+  end
+end

data/lib/kumi/json_schema.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "json_schema/generator"
+require_relative "json_schema/validator"
+
+module Kumi
+  module JsonSchema
+    # Entry point for the JsonSchema functionality
+    #
+    # Available components:
+    # - Generator: Converts Kumi metadata to JSON Schema
+    # - Validator: Validates data against JSON Schema (placeholder)
+  end
+end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Kumi
-  module Parser
+  module RubyParser
     class BuildContext
       attr_reader :inputs, :attributes, :traits
       attr_accessor :current_location

data/lib/kumi/ruby_parser/declaration_reference_proxy.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Kumi
+  module RubyParser
+    # 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 → ruby_parser}/dsl.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Kumi
-  module Parser
+  module RubyParser
     module Dsl
       def self.build_syntax_tree(&rule_block)
         parser = Parser.new

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Kumi
-  module Parser
+  module RubyParser
     class DslCascadeBuilder
       include Syntax
 
@@ -88,8 +88,8 @@ module Kumi
           case name
           when Symbol
             create_binding(name, location)
-          when Binding
-            name  # Already a binding from method_missing
+          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
@@ -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 → ruby_parser}/expression_converter.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Kumi
-  module Parser
+  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
@@ -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)
@@ -89,21 +89,21 @@ module Kumi
       end
 
       def validate_reference_name(name)
-        unless name.is_a?(Symbol)
-          raise_syntax_error(
-            "Reference name must be a symbol, got #{name.class}",
-            location: current_location
-          )
-        end
+        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)
-        unless fn_name.is_a?(Symbol)
-          raise_syntax_error(
-            "Function name must be a symbol, got #{fn_name.class}",
-            location: current_location
-          )
-        end
+        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)
@@ -123,4 +123,4 @@ module Kumi
       end
     end
   end
-end
+end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Kumi
-  module Parser
+  module RubyParser
     module GuardRails
       RESERVED = %i[input trait value fn lit ref].freeze
 

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

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

@@ -0,0 +1,46 @@
+# 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/{parser → ruby_parser}/input_proxy.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Kumi
-  module Parser
+  module RubyParser
     # Proxy object for input field references (input.field_name)
     class InputProxy
       include Syntax
@@ -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/ruby_parser/nested_input.rb

@@ -0,0 +1,15 @@
+# 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/{parser → ruby_parser}/parser.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 module Kumi
-  module Parser
+  module RubyParser
+    # Main parser class for Ruby DSL
     class Parser
       include Syntax
       include ErrorReporting
@@ -33,15 +34,19 @@ module Kumi
       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")
+        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)
 
@@ -59,10 +64,6 @@ module Kumi
       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 → ruby_parser}/schema_builder.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Kumi
-  module Parser
+  module RubyParser
     class SchemaBuilder
       include GuardRails
       include Syntax
@@ -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)