kumi-parser 0.0.2 → 0.0.4

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

data/kumi-parser.gemspec

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'lib/kumi/parser/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'kumi-parser'
+  spec.version = Kumi::Parser::VERSION
+  spec.authors = ['Kumi Team']
+  spec.email = ['dev@kumi.ai']
+
+  spec.summary = 'Text parser for Kumi'
+  spec.description = 'Allows Kumi schemas to be written as plain text with syntax validation and editor integration.'
+  spec.homepage = 'https://github.com/amuta/kumi-parser'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 3.0.0'
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/amuta/kumi-parser'
+  spec.metadata['changelog_uri'] = 'https://github.com/amuta/kumi-parser/blob/main/CHANGELOG.md'
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile]) ||
+        f.end_with?('.gem')
+    end
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # Dependencies
+  spec.add_dependency 'kumi', '~> 0.0.7'
+  spec.add_dependency 'parslet', '~> 2.0'
+  spec.add_dependency 'zeitwerk', '~> 2.6'
+
+  # Development dependencies
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 1.21'
+  spec.add_development_dependency 'simplecov', '~> 0.22'
+end

data/lib/kumi/parser/base.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'smart_tokenizer'
+require_relative 'direct_parser'
+require_relative 'errors'
+
+module Kumi
+  module Parser
+    # Text parser using tokenizer + direct AST construction
+    class Base
+      def self.parse(source, source_file: '<input>')
+        tokens = SmartTokenizer.new(source, source_file: source_file).tokenize
+        Kumi::Parser::DirectParser.new(tokens).parse
+      end
+
+      def self.valid?(source, source_file: '<input>')
+        parse(source, source_file: source_file)
+        true
+      rescue Errors::TokenizerError, Errors::ParseError
+        false
+      end
+
+      def self.validate(source, source_file: '<input>')
+        parse(source, source_file: source_file)
+        []
+      rescue Errors::TokenizerError, Errors::ParseError => e
+        [create_diagnostic(e, source_file)]
+      end
+
+      private
+
+      def self.create_diagnostic(error, source_file)
+        location = if error.is_a?(Errors::ParseError) && error.token
+                     error.token.location
+                   elsif error.respond_to?(:location)
+                     error.location
+                   else
+                     nil
+                   end
+
+        {
+          line: location&.line || 1,
+          column: location&.column || 1,
+          message: error.message,
+          severity: :error,
+          type: :syntax
+        }
+      end
+    end
+  end
+end