kumi-parser 0.0.2 → 0.0.3

data/lib/kumi/parser/text_parser/parser.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative 'grammar'
+require_relative 'transform'
+require 'kumi/core/error_reporting'
+
+module Kumi
+  module Parser
+    module TextParser
+      # Parslet-based parser with proper arithmetic operator precedence
+      class Parser
+        include Kumi::Core::ErrorReporting
+
+        def initialize
+          @grammar = Grammar.new
+          @transform = Transform.new
+        end
+
+        def parse(text_dsl, source_file: '<parslet_parser>')
+          # Parse with Parslet grammar
+          parse_tree = @grammar.parse(text_dsl)
+
+          # Transform to AST
+          ast = @transform.apply(parse_tree)
+
+          # Post-process to create final Root node if needed
+          post_process(ast)
+        rescue Parslet::ParseFailed => e
+          raise_syntax_error(
+            "Parse error: #{e.parse_failure_cause.ascii_tree}",
+            location: create_location(source_file, 1, 1)
+          )
+        end
+
+        private
+
+        def post_process(ast)
+          # If it's already a Root node, return it
+          return ast if ast.is_a?(Syntax::Root)
+
+          # If it's a hash with input and declarations, convert it
+          if ast.is_a?(Hash) && ast[:input] && ast[:declarations]
+            input_decls = ast[:input][:declarations] || []
+            input_decls = [input_decls] unless input_decls.is_a?(Array)
+
+            # Process input declarations
+            processed_input_decls = input_decls.map do |input_decl|
+              process_input_declaration(input_decl)
+            end
+
+            other_decls = ast[:declarations] || []
+            other_decls = [other_decls] unless other_decls.is_a?(Array)
+
+            # Convert remaining hash values to proper nodes
+            values = []
+            traits = []
+
+            other_decls.each do |decl|
+              if decl.is_a?(Hash) && decl[:name] && decl[:expr]
+                expr = process_expression(decl[:expr])
+                values << Syntax::ValueDeclaration.new(decl[:name], expr, loc: create_location('<parslet>', 1, 1))
+              elsif decl.is_a?(Syntax::ValueDeclaration)
+                # Need to process the expression if it's still a hash
+                if decl.expression.is_a?(Hash)
+                  processed_expr = process_expression(decl.expression)
+                  values << Syntax::ValueDeclaration.new(decl.name, processed_expr, loc: decl.loc)
+                else
+                  values << decl
+                end
+              elsif decl.is_a?(Syntax::TraitDeclaration)
+                traits << decl
+              end
+            end
+
+            Syntax::Root.new(processed_input_decls, values, traits, loc: create_location('<parslet>', 1, 1))
+          else
+            ast
+          end
+        end
+
+        def process_expression(expr)
+          # If it's already a proper AST node, return it
+          return expr unless expr.is_a?(Hash)
+
+          # Handle nested expression structures
+          if expr[:left] && expr[:ops]
+            left_expr = process_expression(expr[:left])
+            ops = expr[:ops] || []
+            ops = [ops] unless ops.is_a?(Array)
+
+            result = ops.inject(left_expr) do |left, op|
+              if op.is_a?(Hash) && op[:op] && op[:right]
+                op_name = op[:op].keys.first
+                right_expr = process_expression(op[:right])
+                Syntax::CallExpression.new(op_name, [left, right_expr], loc: create_location('<parslet>', 1, 1))
+              else
+                left
+              end
+            end
+
+            # Handle comparison
+            if expr[:comp] && expr[:comp][:op] && expr[:comp][:right]
+              comp = expr[:comp]
+              op_name = comp[:op].keys.first
+              right_expr = process_expression(comp[:right])
+              Syntax::CallExpression.new(op_name, [result, right_expr], loc: create_location('<parslet>', 1, 1))
+            else
+              result
+            end
+          else
+            expr
+          end
+        end
+
+        def process_input_declaration(input_decl)
+          return input_decl if input_decl.is_a?(Syntax::InputDeclaration)
+
+          if input_decl.is_a?(Hash)
+            if input_decl[:nested_fields]
+              # Array input declaration
+              nested_fields = input_decl[:nested_fields] || []
+              nested_fields = [nested_fields] unless nested_fields.is_a?(Array)
+
+              processed_fields = nested_fields.map do |field|
+                if field.is_a?(Hash) && field[:type] && field[:name]
+                  Syntax::InputDeclaration.new(
+                    field[:name],
+                    field[:domain],
+                    field[:type].to_sym,
+                    [],
+                    loc: create_location('<parslet>', 1, 1)
+                  )
+                else
+                  field
+                end
+              end
+
+              Syntax::InputDeclaration.new(
+                input_decl[:name],
+                nil,
+                :array,
+                processed_fields,
+                loc: create_location('<parslet>', 1, 1)
+              )
+            elsif input_decl[:type] && input_decl[:name]
+              # Simple input declaration
+              Syntax::InputDeclaration.new(
+                input_decl[:name],
+                input_decl[:domain],
+                input_decl[:type].to_sym,
+                [],
+                loc: create_location('<parslet>', 1, 1)
+              )
+            else
+              input_decl
+            end
+          else
+            input_decl
+          end
+        end
+
+        def create_location(file, line, column)
+          Syntax::Location.new(file: file, line: line, column: column)
+        end
+      end
+    end
+  end
+end

data/lib/kumi/parser/text_parser/transform.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'parslet'
+require 'kumi/syntax/node'
+require 'kumi/syntax/root'
+require 'kumi/syntax/input_declaration'
+require 'kumi/syntax/value_declaration'
+require 'kumi/syntax/trait_declaration'
+require 'kumi/syntax/call_expression'
+require 'kumi/syntax/input_reference'
+require 'kumi/syntax/input_element_reference'
+require 'kumi/syntax/declaration_reference'
+require 'kumi/syntax/literal'
+
+module Kumi
+  module Parser
+    module TextParser
+      class Transform < Parslet::Transform
+        LOC = Kumi::Syntax::Location.new(file: '<parslet_parser>', line: 1, column: 1)
+
+        # Literals
+        rule(integer: simple(:x)) { Kumi::Syntax::Literal.new(x.to_i, loc: LOC) }
+        rule(float: simple(:x)) { Kumi::Syntax::Literal.new(x.to_f, loc: LOC) }
+        rule(string: simple(:x)) { Kumi::Syntax::Literal.new(x.to_s, loc: LOC) }
+        rule(true: simple(:_)) { Kumi::Syntax::Literal.new(true, loc: LOC) }
+        rule(false: simple(:_)) { Kumi::Syntax::Literal.new(false, loc: LOC) }
+
+        # Symbols
+        rule(symbol: simple(:name)) { name.to_sym }
+
+        # Input and declaration references
+        rule(input_ref: simple(:path)) do
+          # Handle multi-level paths like "items.price"
+          path_parts = path.to_s.split('.')
+          if path_parts.length == 1
+            Kumi::Syntax::InputReference.new(path_parts[0].to_sym, loc: LOC)
+          else
+            Kumi::Syntax::InputElementReference.new(path_parts.map(&:to_sym), loc: LOC)
+          end
+        end
+
+        rule(decl_ref: simple(:name)) { Kumi::Syntax::DeclarationReference.new(name.to_sym, loc: LOC) }
+
+        # Function calls
+        rule(fn_name: simple(:name), args: sequence(:args)) do
+          Kumi::Syntax::CallExpression.new(name, args, loc: LOC)
+        end
+
+        rule(fn_name: simple(:name), args: []) do
+          Kumi::Syntax::CallExpression.new(name, [], loc: LOC)
+        end
+
+        # Arithmetic expressions with left-associativity
+        rule(left: simple(:l), ops: sequence(:operations)) do
+          operations.inject(l) do |left_expr, op|
+            op_name = op[:op].keys.first
+            Kumi::Syntax::CallExpression.new(op_name, [left_expr, op[:right]], loc: LOC)
+          end
+        end
+
+        rule(left: simple(:l), ops: []) { l }
+
+        # Comparison expressions
+        rule(left: simple(:l), comp: simple(:comparison)) do
+          if comparison && comparison[:op] && comparison[:right]
+            op_name = comparison[:op].keys.first
+            Kumi::Syntax::CallExpression.new(op_name, [l, comparison[:right]], loc: LOC)
+          else
+            l
+          end
+        end
+
+        rule(left: simple(:l), comp: nil) { l }
+
+        # Simple input declarations
+        rule(type: simple(:type), name: simple(:name)) do
+          Kumi::Syntax::InputDeclaration.new(name, nil, type.to_sym, [], loc: LOC)
+        end
+
+        # Nested array declarations
+        rule(name: simple(:name), nested_fields: sequence(:fields)) do
+          # Transform nested field hashes to InputDeclaration objects
+          transformed_fields = fields.map do |field|
+            if field.is_a?(Hash) && field[:type] && field[:name]
+              Kumi::Syntax::InputDeclaration.new(
+                field[:name],
+                field[:domain],
+                field[:type].to_sym,
+                [],
+                loc: LOC
+              )
+            else
+              field
+            end
+          end
+
+          # Create an array input declaration with nested fields
+          Kumi::Syntax::InputDeclaration.new(
+            name,
+            nil,
+            :array,
+            transformed_fields,
+            loc: LOC
+          )
+        end
+
+        rule(name: simple(:name), nested_fields: simple(:field)) do
+          # Single nested field case
+          transformed_field = if field.is_a?(Hash) && field[:type] && field[:name]
+                                Kumi::Syntax::InputDeclaration.new(
+                                  field[:name],
+                                  field[:domain],
+                                  field[:type].to_sym,
+                                  [],
+                                  loc: LOC
+                                )
+                              else
+                                field
+                              end
+
+          Kumi::Syntax::InputDeclaration.new(
+            name,
+            nil,
+            :array,
+            [transformed_field],
+            loc: LOC
+          )
+        end
+
+        rule(type: simple(:type), name: simple(:name), expr: simple(:expr)) do
+          # Differentiate between value and trait declarations based on type
+          if type.to_s == 'value'
+            Kumi::Syntax::ValueDeclaration.new(name, expr, loc: LOC)
+          elsif type.to_s == 'trait'
+            Kumi::Syntax::TraitDeclaration.new(name, expr, loc: LOC)
+          else
+            # Fallback - shouldn't happen
+            Kumi::Syntax::ValueDeclaration.new(name, expr, loc: LOC)
+          end
+        end
+
+        # Handle the intermediate case before the expression gets fully transformed
+        rule(type: simple(:type), name: { symbol: simple(:name) }, expr: simple(:expr)) do
+          # Differentiate between value and trait declarations based on type
+          if type.to_s == 'value'
+            Kumi::Syntax::ValueDeclaration.new(name.to_sym, expr, loc: LOC)
+          elsif type.to_s == 'trait'
+            Kumi::Syntax::TraitDeclaration.new(name.to_sym, expr, loc: LOC)
+          else
+            # Fallback - shouldn't happen
+            Kumi::Syntax::ValueDeclaration.new(name.to_sym, expr, loc: LOC)
+          end
+        end
+
+        # Schema structure - convert the hash to Root node
+        rule(input: { declarations: sequence(:input_decls) }, declarations: sequence(:other_decls)) do
+          values = other_decls.select { |d| d.is_a?(Kumi::Syntax::ValueDeclaration) }
+          traits = other_decls.select { |d| d.is_a?(Kumi::Syntax::TraitDeclaration) }
+          Kumi::Syntax::Root.new(input_decls, values, traits, loc: LOC)
+        end
+
+        rule(input: { declarations: simple(:input_decl) }, declarations: sequence(:other_decls)) do
+          values = other_decls.select { |d| d.is_a?(Kumi::Syntax::ValueDeclaration) }
+          traits = other_decls.select { |d| d.is_a?(Kumi::Syntax::TraitDeclaration) }
+          Kumi::Syntax::Root.new([input_decl], values, traits, loc: LOC)
+        end
+      end
+    end
+  end
+end

data/lib/kumi/parser/text_parser.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'syntax_validator'
+
+module Kumi
+  module Parser
+    module TextParser
+      # TextParser module - all classes are autoloaded by Zeitwerk
+
+      class << self
+        # Check if text is syntactically valid
+        def valid?(text, source_file: '<input>')
+          validator.valid?(text, source_file: source_file)
+        end
+
+        # Validate text and return diagnostic collection
+        def validate(text, source_file: '<input>')
+          validator.validate(text, source_file: source_file)
+        end
+
+        # Get Monaco Editor format diagnostics
+        def diagnostics_for_monaco(text, source_file: '<input>')
+          validate(text, source_file: source_file).to_monaco
+        end
+
+        # Get CodeMirror format diagnostics
+        def diagnostics_for_codemirror(text, source_file: '<input>')
+          validate(text, source_file: source_file).to_codemirror
+        end
+
+        # Get JSON format diagnostics
+        def diagnostics_as_json(text, source_file: '<input>')
+          validate(text, source_file: source_file).to_json
+        end
+
+        # Parse text (compatibility method)
+        def parse(text, source_file: '<input>')
+          parser.parse(text, source_file: source_file)
+        end
+
+        private
+
+        def validator
+          @validator ||= SyntaxValidator.new
+        end
+
+        def parser
+          @parser ||= TextParser::Parser.new
+        end
+      end
+    end
+  end
+end

data/lib/kumi/parser/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Parser
+    VERSION = '0.0.3'
+  end
+end

data/lib/kumi/parser.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Parser
+    # This namespace will contain TextParser and related classes
+    # All classes will be autoloaded by Zeitwerk
+  end
+end

data/lib/kumi-parser.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'kumi'
+require 'zeitwerk'
+require 'parslet'
+
+loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
+loader.ignore("#{__dir__}/kumi-parser.rb")
+loader.ignore("#{__dir__}/kumi/parser/version.rb")
+loader.setup
+
+require_relative 'kumi/parser/version'
+
+module Kumi
+  module Parser
+    # Parser extension for Kumi DSL
+  end
+end

data/test_basic.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+# Basic functionality test for kumi-parser
+
+require_relative 'lib/kumi/parser'
+
+schema_text = <<~SCHEMA
+  schema do
+    input do
+      integer :age
+    end
+  #{'  '}
+    trait :adult, input.age >= 18
+    value :bonus, 100
+  end
+SCHEMA
+
+puts 'Testing kumi-parser...'
+puts '=' * 40
+
+begin
+  # Test validation
+  puts '1. Testing validation...'
+  diagnostics = Kumi::Parser::TextParser.validate(schema_text)
+  puts "   ✅ Validation: #{diagnostics.empty? ? 'PASSED' : 'FAILED'}"
+
+  unless diagnostics.empty?
+    diagnostics.to_a.each do |d|
+      puts "   Error: Line #{d.line}, Column #{d.column}: #{d.message}"
+    end
+  end
+
+  # Test parsing if validation passed
+  if diagnostics.empty?
+    puts '2. Testing parsing...'
+    ast = Kumi::Parser::TextParser.parse(schema_text)
+    puts "   ✅ Parsing: #{ast ? 'PASSED' : 'FAILED'}"
+    puts "   AST type: #{ast.class}"
+  end
+
+  puts "\n🎉 Basic functionality test completed!"
+rescue StandardError => e
+  puts "❌ Error: #{e.message}"
+  puts e.backtrace.first(5)
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kumi-parser
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Kumi Team
@@ -128,7 +128,29 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- ".rspec"
+- LICENSE
+- README.md
+- Rakefile
+- examples/debug_text_parser.rb
+- examples/debug_transform_rule.rb
+- examples/text_parser_comprehensive_test.rb
+- examples/text_parser_test_with_comments.rb
+- kumi-parser.gemspec
+- lib/kumi-parser.rb
+- lib/kumi/parser.rb
+- lib/kumi/parser/analyzer_diagnostic_converter.rb
+- lib/kumi/parser/error_extractor.rb
+- lib/kumi/parser/syntax_validator.rb
+- lib/kumi/parser/text_parser.rb
+- lib/kumi/parser/text_parser/api.rb
+- lib/kumi/parser/text_parser/editor_diagnostic.rb
+- lib/kumi/parser/text_parser/grammar.rb
+- lib/kumi/parser/text_parser/parser.rb
+- lib/kumi/parser/text_parser/transform.rb
+- lib/kumi/parser/version.rb
+- test_basic.rb
 homepage: https://github.com/amuta/kumi-parser
 licenses:
 - MIT