kumi-parser 0.0.3 → 0.0.4

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

@@ -1,214 +0,0 @@
-# frozen_string_literal: true
-
-require 'parslet'
-
-module Kumi
-  module Parser
-    module TextParser
-      # Parslet grammar with proper arithmetic operator precedence
-      class Grammar < Parslet::Parser
-        # Basic tokens
-        rule(:space) { match('\s').repeat(1) }
-        rule(:space?) { space.maybe }
-        rule(:newline?) { match('\n').maybe }
-
-        # Comments
-        rule(:comment) { str('#') >> match('[^\n]').repeat }
-        rule(:ws) { (space | comment).repeat }
-        rule(:ws?) { ws.maybe }
-
-        # Identifiers and symbols
-        rule(:identifier) { match('[a-zA-Z_]') >> match('[a-zA-Z0-9_]').repeat }
-        rule(:symbol) { str(':') >> identifier.as(:symbol) }
-
-        # Literals
-        rule(:integer) { match('[0-9]').repeat(1) }
-        rule(:float) { integer >> str('.') >> match('[0-9]').repeat(1) }
-        rule(:number) { float.as(:float) | integer.as(:integer) }
-        rule(:string_literal) do
-          str('"') >> (str('"').absent? >> any).repeat.as(:string) >> str('"')
-        end
-        rule(:boolean) { (str('true').as(:true) | str('false').as(:false)) }
-        rule(:literal) { number | string_literal | boolean }
-
-        # Keywords
-        rule(:schema_kw) { str('schema') }
-        rule(:input_kw) { str('input') }
-        rule(:value_kw) { str('value') }
-        rule(:trait_kw) { str('trait') }
-        rule(:do_kw) { str('do') }
-        rule(:end_kw) { str('end') }
-
-        # Type keywords
-        rule(:type_name) do
-          str('integer') | str('float') | str('string') | str('boolean') | str('any')
-        end
-
-        # Operators (ordered by precedence, highest to lowest)
-        rule(:mult_op) { str('*').as(:multiply) | str('/').as(:divide) | str('%').as(:modulo) }
-        rule(:add_op) { str('+').as(:add) | str('-').as(:subtract) }
-        rule(:comp_op) do
-          str('>=').as(:>=) | str('<=').as(:<=) | str('==').as(:==) |
-            str('!=').as(:!=) | str('>').as(:>) | str('<').as(:<)
-        end
-        rule(:logical_and_op) { str('&').as(:and) }
-        rule(:logical_or_op) { str('|').as(:or) }
-
-        # Expressions with proper precedence (using left recursion elimination)
-        rule(:primary_expr) do
-          str('(') >> ws? >> expression >> ws? >> str(')') |
-            function_call |
-            input_reference |
-            declaration_reference |
-            literal
-        end
-
-        # Function calls: fn(:name, arg1, arg2, ...)
-        rule(:function_call) do
-          str('fn(') >> ws? >>
-            symbol.as(:fn_name) >>
-            (str(',') >> ws? >> expression).repeat(0).as(:args) >>
-            ws? >> str(')')
-        end
-
-        # Multiplication/Division (left-associative)
-        rule(:mult_expr) do
-          primary_expr.as(:left) >>
-            (space? >> mult_op.as(:op) >> space? >> primary_expr.as(:right)).repeat.as(:ops)
-        end
-
-        # Addition/Subtraction (left-associative)
-        rule(:add_expr) do
-          mult_expr.as(:left) >>
-            (space? >> add_op.as(:op) >> space? >> mult_expr.as(:right)).repeat.as(:ops)
-        end
-
-        # Comparison operators
-        rule(:comp_expr) do
-          add_expr.as(:left) >>
-            (space? >> comp_op.as(:op) >> space? >> add_expr.as(:right)).maybe.as(:comp)
-        end
-
-        # Logical AND (higher precedence than OR)
-        rule(:logical_and_expr) do
-          comp_expr.as(:left) >>
-            (space? >> logical_and_op.as(:op) >> space? >> comp_expr.as(:right)).repeat.as(:ops)
-        end
-
-        # Logical OR (lowest precedence)
-        rule(:logical_or_expr) do
-          logical_and_expr.as(:left) >>
-            (space? >> logical_or_op.as(:op) >> space? >> logical_and_expr.as(:right)).repeat.as(:ops)
-        end
-
-        rule(:expression) { logical_or_expr }
-
-        # Input references: input.field or input.field.subfield
-        rule(:input_reference) do
-          str('input.') >> input_path.as(:input_ref)
-        end
-
-        rule(:input_path) do
-          identifier >> (str('.') >> identifier).repeat
-        end
-
-        # Declaration references: just identifier
-        rule(:declaration_reference) do
-          identifier.as(:decl_ref)
-        end
-
-        # Input declarations
-        rule(:input_declaration) do
-          nested_array_declaration | simple_input_declaration
-        end
-
-        rule(:simple_input_declaration) do
-          ws? >> type_name.as(:type) >> space >> symbol.as(:name) >>
-            (str(',') >> ws? >> domain_spec).maybe.as(:domain) >> ws? >> newline?
-        end
-
-        rule(:nested_array_declaration) do
-          ws? >> str('array') >> space >> symbol.as(:name) >> space >> do_kw >> ws? >> newline? >>
-            (ws? >> input_declaration >> ws?).repeat.as(:nested_fields) >>
-            ws? >> end_kw >> ws? >> newline?
-        end
-
-        rule(:domain_spec) do
-          str('domain:') >> ws? >> domain_value.as(:domain_value)
-        end
-
-        rule(:domain_value) do
-          # Ranges: 1..10, 1...10, 0.0..100.0
-          range_value |
-            # Word arrays: %w[active inactive]
-            word_array_value |
-            # String arrays: ["active", "inactive"]
-            string_array_value
-        end
-
-        rule(:range_value) do
-          (float | integer) >> str('..') >> (float | integer)
-        end
-
-        rule(:word_array_value) do
-          str('%w[') >> (identifier >> space?).repeat.as(:words) >> str(']')
-        end
-
-        rule(:string_array_value) do
-          str('[') >> space? >>
-            (string_literal >> (str(',') >> space? >> string_literal).repeat).maybe >>
-            space? >> str(']')
-        end
-
-        # Value declarations
-        rule(:value_declaration) do
-          cascade_value_declaration | simple_value_declaration
-        end
-
-        rule(:simple_value_declaration) do
-          ws? >> value_kw.as(:type) >> space >> symbol.as(:name) >> str(',') >> ws? >>
-            expression.as(:expr) >> ws? >> newline?
-        end
-
-        rule(:cascade_value_declaration) do
-          ws? >> value_kw.as(:type) >> space >> symbol.as(:name) >> space >> do_kw >> ws? >> newline? >>
-            (ws? >> cascade_case >> ws?).repeat.as(:cases) >>
-            ws? >> end_kw >> ws? >> newline?
-        end
-
-        rule(:cascade_case) do
-          (ws? >> str('on') >> space >> identifier.as(:condition) >> str(',') >> ws? >>
-           expression.as(:result) >> ws? >> newline?) |
-            (ws? >> str('base') >> space >> expression.as(:base_result) >> ws? >> newline?)
-        end
-
-        # Trait declarations
-        rule(:trait_declaration) do
-          ws? >> trait_kw.as(:type) >> space >> symbol.as(:name) >> str(',') >> ws? >>
-            expression.as(:expr) >> ws? >> newline?
-        end
-
-        # Input block
-        rule(:input_block) do
-          ws? >> input_kw >> space >> do_kw >> ws? >> newline? >>
-            (ws? >> input_declaration >> ws?).repeat.as(:declarations) >>
-            ws? >> end_kw >> ws? >> newline?
-        end
-
-        # Schema structure
-        rule(:schema_body) do
-          input_block.as(:input) >>
-            (ws? >> (value_declaration | trait_declaration) >> ws?).repeat.as(:declarations)
-        end
-
-        rule(:schema) do
-          ws? >> schema_kw >> space >> do_kw >> ws? >> newline? >>
-            schema_body >>
-            ws? >> end_kw >> ws?
-        end
-
-        root(:schema)
-      end
-    end
-  end
-end

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

@@ -1,168 +0,0 @@
-# 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

@@ -1,170 +0,0 @@
-# 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.rb

@@ -1,8 +0,0 @@
-# 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/test_basic.rb

@@ -1,44 +0,0 @@
-#!/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