kumi-parser 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb3ed4f3c5d534b41a856cb05ecacdafa233c66f97039af6c7f695d7b11e9638
-  data.tar.gz: dae5536d6035f67546136f12ffe1fc52d602bdffc8dd5eeba120fec2313c4cd7
+  metadata.gz: 14750f2db79c5e3125f477a55452f97c53a919dfd14f6731ebef89169b6a25a3
+  data.tar.gz: 2c617dd3c673d580c0ea4dcee97d0a82cc34d69e8d23aefd7e6cc53c9e288fcf
 SHA512:
-  metadata.gz: 1bc09e791d8557b52f2b4b6475ee368f6ac000c4cae9de0efb9e877e86eb7929f1933e6bb247aa6cfa4cdd5412d22217645ab4a873f9881935613cc02bc95dc2
-  data.tar.gz: 8cf8d948c812075b068479e25737a0d43999831f2dea87a018d6d62fe8c1049d96bb27076f88173ed91d4bd4ae1939669d768402ee9e8ce8e5c215c14014d909
+  metadata.gz: fe96cecd1682fde3006a890413e82aa2d8963400a160b5a808d4cb841bfe702c72624ab4b3abb9abc3829745e4355fcecb7f096300c5b1f13e2b8cdcd2475f34
+  data.tar.gz: ab9576fa7828bedcd731567a37e1b977691cc5aa4a87ba2b2c1faf3a83299eabe466c4a62165548cef4178dd3648f012167378581b70a58d0e2435206fce5d5f

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--format documentation
+--color

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kumi Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,76 @@
+# Kumi::Parser
+
+Text parser for [Kumi](https://github.com/amuta/kumi). Allows Kumi schemas to be written as plain text with syntax validation and editor integration.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'kumi-parser'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install kumi-parser
+
+## Usage
+
+### Basic Parsing
+
+```ruby
+require 'kumi/parser'
+
+schema_text = <<~SCHEMA
+  schema do
+    input do
+      integer :age, domain: 18..65
+      string :status, domain: %w[active inactive]
+    end
+    
+    trait :adult, input.age >= 18
+    value :bonus, 100
+  end
+SCHEMA
+
+# Parse and get AST
+ast = Kumi::Parser::TextParser.parse(schema_text)
+
+# Validate syntax
+diagnostics = Kumi::Parser::TextParser.validate(schema_text)
+puts "Valid!" if diagnostics.empty?
+```
+
+### Editor Integration
+
+```ruby
+# Get diagnostics for Monaco Editor
+monaco_diagnostics = Kumi::Parser::TextParser.diagnostics_for_monaco(schema_text)
+
+# Get diagnostics for CodeMirror
+codemirror_diagnostics = Kumi::Parser::TextParser.diagnostics_for_codemirror(schema_text)
+
+# Get diagnostics as JSON
+json_diagnostics = Kumi::Parser::TextParser.diagnostics_as_json(schema_text)
+```
+
+## API Reference
+
+- `parse(text)` - Parse schema text and return AST
+- `validate(text)` - Validate syntax and return diagnostics
+- `valid?(text)` - Quick validation check (returns boolean)
+- `diagnostics_for_monaco(text)` - Get Monaco Editor format diagnostics
+- `diagnostics_for_codemirror(text)` - Get CodeMirror format diagnostics  
+- `diagnostics_as_json(text)` - Get JSON format diagnostics
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## License
+
+MIT License

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/examples/debug_text_parser.rb

@@ -0,0 +1,41 @@
+# Debug the text parser transform
+
+require_relative 'lib/kumi/text_parser'
+
+schema_text = <<~SCHEMA
+  schema do
+    input do
+      integer :age
+    end
+  #{'  '}
+    trait :adult, input.age >= 18
+    value :bonus, 100
+  end
+SCHEMA
+
+puts 'Debugging text parser...'
+
+begin
+  # Test just the grammar parsing first
+  grammar = Kumi::TextParser::Grammar.new
+  parse_tree = grammar.parse(schema_text)
+
+  puts 'Raw parse tree:'
+  puts parse_tree.inspect
+  puts
+
+  # Now test the transform
+  transform = Kumi::TextParser::Transform.new
+  ast = transform.apply(parse_tree)
+
+  puts 'Transformed AST:'
+  puts ast.inspect
+  puts
+
+  puts 'AST structure:'
+  puts "- Values: #{ast.attributes.count} - #{ast.attributes.map(&:name)}"
+  puts "- Traits: #{ast.traits.count} - #{ast.traits.map(&:name)}"
+rescue StandardError => e
+  puts "Error: #{e.message}"
+  puts e.backtrace.first(5)
+end

data/examples/debug_transform_rule.rb

@@ -0,0 +1,26 @@
+# Debug specific transform rule
+
+require_relative 'lib/kumi/text_parser'
+
+# Test just the trait parsing
+trait_text = 'trait :adult, input.age >= 18'
+
+grammar = Kumi::TextParser::Grammar.new
+transform = Kumi::TextParser::Transform.new
+
+begin
+  # Parse just the trait declaration
+  parse_result = grammar.trait_declaration.parse(trait_text)
+  puts 'Trait parse result:'
+  puts parse_result.inspect
+  puts
+
+  # Try to transform it
+  transformed = transform.apply(parse_result)
+  puts 'Transformed result:'
+  puts transformed.inspect
+  puts "Class: #{transformed.class}"
+rescue StandardError => e
+  puts "Error: #{e.message}"
+  puts e.backtrace.first(5)
+end

data/examples/text_parser_comprehensive_test.rb

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+require_relative '../lib/kumi'
+
+# Comprehensive test of all text parser supported features
+# This example tests what the text parser ACTUALLY supports
+# (not what the Ruby DSL supports)
+
+module TextParserComprehensiveTest
+  extend Kumi::Schema
+
+  schema do
+    input do
+      # Basic type declarations
+      integer :age, domain: 18..65
+      float :score, domain: 0.0..100.0
+      string :status, domain: %w[active inactive suspended]
+      boolean :verified
+      any :metadata
+
+      # Nested array declarations
+      array :items do
+        string :name
+        float :price
+        integer :quantity
+      end
+    end
+
+    # ============================================================
+    # ARITHMETIC OPERATIONS - All supported operators
+    # ============================================================
+
+    # Addition and subtraction
+    value :total_price, input.items.price + input.items.quantity
+    value :price_diff, input.items.price - 10.0
+
+    # Multiplication and division
+    value :scaled_score, input.score * 1.5
+    value :average_score, input.score / 2
+
+    # Modulo
+    value :remainder, input.age % 10
+
+    # Complex arithmetic with parentheses
+    value :complex_calc, (input.score * 2.5) + (input.age / 2) - 10
+
+    # ============================================================
+    # COMPARISON OPERATIONS - All comparison operators
+    # ============================================================
+
+    trait :adult, input.age >= 18
+    trait :senior, input.age > 60
+    trait :young_adult, input.age <= 25
+    trait :is_teen, input.age < 20
+    trait :perfect_score, input.score == 100.0
+    trait :not_perfect, input.score != 100.0
+
+    # String comparisons
+    trait :is_active, input.status == 'active'
+    trait :not_suspended, input.status != 'suspended'
+
+    # Boolean comparisons
+    trait :is_verified, input.verified == true
+    trait :not_verified, input.verified == false
+
+    # ============================================================
+    # LOGICAL OPERATIONS - AND and OR
+    # ============================================================
+
+    # AND operations using &
+    trait :eligible, (input.age >= 18) & (input.verified == true) & (input.status == 'active')
+    trait :premium_user, is_verified & is_active & (input.score > 80.0)
+
+    # OR operations using |
+    trait :needs_attention, (input.status == 'suspended') | (input.verified == false)
+    trait :special_case, senior | (input.score >= 95.0)
+
+    # Complex logical expressions
+    trait :complex_logic, (adult & is_verified) | (senior & is_active)
+
+    # ============================================================
+    # FUNCTION CALLS - fn(:name, args) syntax
+    # ============================================================
+
+    # Math functions
+    value :absolute_diff, fn(:abs, fn(:subtract, input.score, 50.0))
+    value :rounded_score, fn(:round, input.score)
+    value :clamped_score, fn(:clamp, input.score, 20.0, 80.0)
+
+    # String functions (note: no method syntax like .length)
+    value :name_length, fn(:string_length, input.status)
+    value :uppercase_status, fn(:upcase, input.status)
+    value :lowercase_status, fn(:downcase, input.status)
+
+    # Collection/aggregation functions on arrays
+    value :total_items, fn(:sum, input.items.quantity)
+    value :item_count, fn(:size, input.items)
+    value :max_price, fn(:max, input.items.price)
+    value :min_price, fn(:min, input.items.price)
+
+    # ============================================================
+    # REFERENCES - Both bare identifiers and ref() NOT supported in text parser
+    # ============================================================
+
+    # Using previously defined values/traits (bare identifiers)
+    trait :super_eligible, eligible & premium_user
+    value :bonus_points, fn(:multiply, total_price, 0.1)
+
+    # ============================================================
+    # CASCADE EXPRESSIONS - on/base syntax
+    # ============================================================
+
+    value :user_tier do
+      on premium_user, 'premium'
+      on eligible, 'standard'
+      on is_verified, 'basic'
+      base 'guest'
+    end
+
+    value :discount_rate do
+      on senior, 0.25
+      on premium_user, 0.15
+      on is_active, 0.05
+      base 0.0
+    end
+
+    # Cascades using complex conditions
+    value :risk_level do
+      on complex_logic, 'low'
+      on needs_attention, 'high'
+      on is_active, 'medium'
+      base 'unknown'
+    end
+
+    # ============================================================
+    # NESTED INPUT REFERENCES - Deep field access
+    # ============================================================
+
+    # Direct nested field access (parsed as multi-part input reference)
+    value :first_item_name, input.items.name
+    value :all_prices, input.items.price
+
+    # Operations on nested fields (broadcasting)
+    value :discounted_prices, input.items.price * 0.9
+
+    # ============================================================
+    # LITERALS - All supported literal types
+    # ============================================================
+
+    # Number literals (integers and floats)
+    value :constant_int, 42
+    value :constant_float, 3.14159
+
+    # String literals (double quotes only)
+    value :greeting, 'Hello, World!'
+
+    # Boolean literals
+    value :always_true, true
+    value :always_false, false
+
+    # ============================================================
+    # EDGE CASES AND LIMITATIONS
+    # ============================================================
+
+    # Complex parenthesized expressions
+    value :nested_parens, ((input.age + 10) * 2) / (input.score - 20)
+
+    # Multiple operators in sequence
+    value :operator_chain, input.age + 10 - 5 + 20 - 3
+
+    # Nested function calls
+    value :nested_functions, fn(:round, fn(:multiply, fn(:add, input.score, 10), 1.5))
+
+    # ============================================================
+    # NOT SUPPORTED (would fail in text parser)
+    # ============================================================
+
+    # These are commented out as they would cause parse errors:
+
+    # Array literals in expressions
+    # value :array_literal, [1, 2, 3, 4, 5]
+    # value :max_of_array, fn(:max, [input.age, 30, 50])
+
+    # Method-style function calls
+    # value :method_style, fn.add(input.age, 10)
+
+    # Sugar method calls on fields
+    # trait :long_status, input.status.length > 5
+    # value :name_chars, input.status.size
+
+    # Ternary/conditional expressions
+    # value :conditional, eligible ? 100 : 0
+
+    # Hash literals
+    # value :options, { min: 0, max: 100 }
+
+    # ref() syntax
+    # trait :ref_example, ref(:eligible) & ref(:premium_user)
+
+    # Symbol literals (except in fn() calls)
+    # value :symbol_value, :active
+
+    # Power operator
+    # value :squared, input.age ** 2
+
+    # Comments within the DSL
+    # value :test, 42 # this would fail
+  end
+end
+
+# Test the schema with the text parser
+if __FILE__ == $0
+  require_relative '../lib/kumi/text_parser'
+
+  # Create a clean schema without comments for text parser testing
+  schema_text = <<~SCHEMA
+    schema do
+      input do
+        integer :age, domain: 18..65
+        float :score, domain: 0.0..100.0
+        string :status, domain: %w[active inactive suspended]
+        boolean :verified
+        any :metadata
+    #{'    '}
+        array :items do
+          string :name
+          float :price
+          integer :quantity
+        end
+      end
+
+      value :total_price, input.items.price + input.items.quantity
+      value :price_diff, input.items.price - 10.0
+      value :scaled_score, input.score * 1.5
+      value :average_score, input.score / 2
+      value :remainder, input.age % 10
+      value :complex_calc, (input.score * 2.5) + (input.age / 2) - 10
+    #{'  '}
+      trait :adult, input.age >= 18
+      trait :senior, input.age > 60
+      trait :young_adult, input.age <= 25
+      trait :is_teen, input.age < 20
+      trait :perfect_score, input.score == 100.0
+      trait :not_perfect, input.score != 100.0
+      trait :is_active, input.status == "active"
+      trait :not_suspended, input.status != "suspended"
+      trait :is_verified, input.verified == true
+      trait :not_verified, input.verified == false
+    #{'  '}
+      trait :eligible, (input.age >= 18) & (input.verified == true) & (input.status == "active")
+      trait :premium_user, is_verified & is_active & (input.score > 80.0)
+      trait :needs_attention, (input.status == "suspended") | (input.verified == false)
+      trait :special_case, senior | (input.score >= 95.0)
+      trait :complex_logic, (adult & is_verified) | (senior & is_active)
+    #{'  '}
+      value :absolute_diff, fn(:abs, fn(:subtract, input.score, 50.0))
+      value :rounded_score, fn(:round, input.score)
+      value :clamped_score, fn(:clamp, input.score, 20.0, 80.0)
+      value :name_length, fn(:string_length, input.status)
+      value :uppercase_status, fn(:upcase, input.status)
+      value :lowercase_status, fn(:downcase, input.status)
+      value :total_items, fn(:sum, input.items.quantity)
+      value :item_count, fn(:size, input.items)
+      value :max_price, fn(:max, input.items.price)
+      value :min_price, fn(:min, input.items.price)
+    #{'  '}
+      trait :super_eligible, eligible & premium_user
+      value :bonus_points, fn(:multiply, total_price, 0.1)
+    #{'  '}
+      value :user_tier do
+        on premium_user, "premium"
+        on eligible, "standard"
+        on is_verified, "basic"
+        base "guest"
+      end
+    #{'  '}
+      value :discount_rate do
+        on senior, 0.25
+        on premium_user, 0.15
+        on is_active, 0.05
+        base 0.0
+      end
+    #{'  '}
+      value :risk_level do
+        on complex_logic, "low"
+        on needs_attention, "high"
+        on is_active, "medium"
+        base "unknown"
+      end
+    #{'  '}
+      value :first_item_name, input.items.name
+      value :all_prices, input.items.price
+      value :discounted_prices, input.items.price * 0.9
+    #{'  '}
+      value :constant_int, 42
+      value :constant_float, 3.14159
+      value :greeting, "Hello, World!"
+      value :always_true, true
+      value :always_false, false
+    #{'  '}
+      value :nested_parens, ((input.age + 10) * 2) / (input.score - 20)
+      value :operator_chain, input.age + 10 - 5 + 20 - 3
+      value :nested_functions, fn(:round, fn(:multiply, fn(:add, input.score, 10), 1.5))
+    end
+  SCHEMA
+
+  puts 'Testing text parser with comprehensive DSL...'
+  puts '=' * 60
+
+  begin
+    # Validate the schema
+    diagnostics = Kumi::TextParser.validate(schema_text)
+
+    if diagnostics.empty?
+      puts '✅ Schema is valid!'
+
+      # Parse and show some info
+      ast = Kumi::TextParser.parse(schema_text)
+      puts "\nParsed successfully!"
+      puts "- Input fields: #{ast.inputs.map(&:name).join(', ')}"
+      puts "- Values: #{ast.attributes.count}"
+      puts "- Traits: #{ast.traits.count}"
+    else
+      puts '❌ Schema has errors:'
+      diagnostics.to_a.each do |diagnostic|
+        puts "  Line #{diagnostic.line}, Column #{diagnostic.column}: #{diagnostic.message}"
+      end
+    end
+  rescue StandardError => e
+    puts "❌ Parser error: #{e.message}"
+    puts e.backtrace.first(5)
+  end
+end

data/examples/text_parser_test_with_comments.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require_relative '../lib/kumi/text_parser'
+
+# Test schema with comments and verify AST structure
+schema_text = <<~SCHEMA
+  schema do
+    # Input section with type declarations
+    input do
+      integer :age, domain: 18..65     # User's age
+      float :score, domain: 0.0..100.0 # Test score
+      string :status, domain: %w[active inactive] # User status
+      boolean :verified                # Verification status
+  #{'    '}
+      # Nested array example
+      array :items do
+        string :name     # Item name
+        float :price     # Item price
+        integer :quantity # Item quantity
+      end
+    end
+
+    # Basic arithmetic operations
+    value :total_price, input.items.price + input.items.quantity
+    value :scaled_score, input.score * 1.5
+  #{'  '}
+    # Trait definitions with comparisons
+    trait :adult, input.age >= 18    # Is adult
+    trait :high_scorer, input.score > 80.0 # High score
+    trait :is_active, input.status == "active" # Active user
+  #{'  '}
+    # Complex logical operations
+    trait :eligible, adult & is_active & (input.verified == true)
+  #{'  '}
+    # Function calls
+    value :rounded_score, fn(:round, input.score)
+    value :item_count, fn(:size, input.items)
+  #{'  '}
+    # Cascade expressions
+    value :user_level do
+      on high_scorer, "premium"  # Premium users
+      on eligible, "standard"    # Standard users#{'  '}
+      base "basic"              # Default level
+    end
+  end
+SCHEMA
+
+puts 'Testing text parser with comments...'
+puts '=' * 50
+
+begin
+  # Test parsing
+  diagnostics = Kumi::TextParser.validate(schema_text)
+
+  if diagnostics.empty?
+    puts '✅ Schema parsed successfully!'
+
+    # Parse and examine AST structure
+    ast = Kumi::TextParser.parse(schema_text)
+
+    puts "\n📊 AST Structure:"
+    puts "- Root type: #{ast.class.name}"
+    puts "- Input fields: #{ast.inputs.count}"
+    ast.inputs.each_with_index do |input, i|
+      puts "  #{i + 1}. #{input.name} (#{input.type})"
+      next unless input.children && input.children.any?
+
+      input.children.each do |child|
+        puts "     - #{child.name} (#{child.type})"
+      end
+    end
+
+    puts "- Value declarations: #{ast.attributes.count}"
+    ast.attributes.each_with_index do |value, i|
+      puts "  #{i + 1}. #{value.name}"
+    end
+
+    puts "- Trait declarations: #{ast.traits.count}"
+    ast.traits.each_with_index do |trait, i|
+      puts "  #{i + 1}. #{trait.name}"
+    end
+
+    # Test with actual Ruby DSL to verify it works end-to-end
+    puts "\n🧪 Testing with full Kumi analysis..."
+    begin
+      analyzer = Kumi::Analyzer.new
+      analysis_result = analyzer.analyze(ast)
+
+      if analysis_result.errors.any?
+        puts '❌ Analysis errors:'
+        analysis_result.errors.each do |error|
+          if error.respond_to?(:message)
+            puts "  - #{error.message}"
+          elsif error.is_a?(Array)
+            puts "  - #{error[1]}"
+          else
+            puts "  - #{error}"
+          end
+        end
+      else
+        puts '✅ Schema analysis successful!'
+
+        # Try to create a compiled schema
+        compiler = Kumi::Compiler.new
+        compiled = compiler.compile(ast, analysis_result)
+        puts '✅ Schema compilation successful!'
+
+        # Test execution with sample data
+        test_data = {
+          age: 25,
+          score: 85.5,
+          status: 'active',
+          verified: true,
+          items: [
+            { name: 'Item 1', price: 10.0, quantity: 2 },
+            { name: 'Item 2', price: 15.0, quantity: 1 }
+          ]
+        }
+
+        runner = Kumi::Runner.new(compiled, test_data)
+
+        # Test a few key calculations
+        puts "\n🎯 Test Results:"
+        puts "- total_price: #{runner.fetch(:total_price)}"
+        puts "- scaled_score: #{runner.fetch(:scaled_score)}"
+        puts "- adult: #{runner.fetch(:adult)}"
+        puts "- eligible: #{runner.fetch(:eligible)}"
+        puts "- user_level: #{runner.fetch(:user_level)}"
+        puts "- item_count: #{runner.fetch(:item_count)}"
+
+      end
+    rescue StandardError => e
+      puts "❌ Analysis/compilation error: #{e.message}"
+      puts e.backtrace.first(3)
+    end
+
+  else
+    puts '❌ Schema has parse errors:'
+    diagnostics.to_a.each do |diagnostic|
+      puts "  Line #{diagnostic.line}, Column #{diagnostic.column}: #{diagnostic.message}"
+    end
+  end
+rescue StandardError => e
+  puts "❌ Unexpected error: #{e.message}"
+  puts e.backtrace.first(5)
+end