kumi 0.0.6 → 0.0.7

data/lib/kumi/export/node_registry.rb

@@ -7,7 +7,7 @@ module Kumi
       SERIALIZATION_MAP = {
         "Kumi::Syntax::Root" => "root",
         "Kumi::Syntax::InputDeclaration" => "field_declaration",
-        "Kumi::Syntax::ValueDeclaration" => "attribute_declaration", 
+        "Kumi::Syntax::ValueDeclaration" => "attribute_declaration",
         "Kumi::Syntax::TraitDeclaration" => "trait_declaration",
         "Kumi::Syntax::CallExpression" => "call_expression",
         "Kumi::Syntax::ArrayExpression" => "list_expression",
@@ -23,7 +23,7 @@ module Kumi
       DESERIALIZATION_MAP = {
         "root" => "Kumi::Syntax::Root",
         "field_declaration" => "Kumi::Syntax::InputDeclaration",
-        "attribute_declaration" => "Kumi::Syntax::ValueDeclaration", 
+        "attribute_declaration" => "Kumi::Syntax::ValueDeclaration",
         "trait_declaration" => "Kumi::Syntax::TraitDeclaration",
         "call_expression" => "Kumi::Syntax::CallExpression",
         "list_expression" => "Kumi::Syntax::ArrayExpression",

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/{parser → ruby_parser}/declaration_reference_proxy.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 module Kumi
-  module Parser
+  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
 
@@ -33,4 +33,4 @@ module Kumi
       end
     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
 
@@ -89,7 +89,7 @@ module Kumi
           when Symbol
             create_binding(name, location)
           when DeclarationReference
-            name  # Already a binding from method_missing
+            name # Already a binding from method_missing
           else
             raise_error("trait reference must be a symbol or bare identifier, got #{name.class}", location)
           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
@@ -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

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

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
 module Kumi
-  module Parser
+  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
+        @path = Array(path) # Ensure it's always an array
         @context = context
       end
 
@@ -43,4 +43,4 @@ module Kumi
       end
     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

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Kumi
-  module Parser
+  module RubyParser
     # Simple context struct for nested input collection
     class NestedInput
       attr_reader :inputs, :current_location

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

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
 

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