parsanol 3.0.0

data/Rakefile

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rdoc/task'
+require 'rubygems/package_task'
+
+begin
+  require 'opal/rspec/rake_task'
+rescue LoadError, NoMethodError
+  # Opal not available or incompatible with current Ruby version
+end
+
+# Native extension compilation using rake-compiler
+begin
+  require 'rake/extensiontask'
+  Rake::ExtensionTask.new('parsanol_native') do |ext|
+    ext.lib_dir = 'lib/parsanol'
+  end
+rescue LoadError
+  # rake-compiler not available
+end
+
+desc 'Run all tests'
+RSpec::Core::RakeTask.new(:spec)
+
+namespace :spec do
+  desc 'Run unit tests only'
+  RSpec::Core::RakeTask.new(:unit) do |task|
+    task.pattern = 'spec/parsanol/**/*_spec.rb'
+  end
+
+  if defined?(Opal::RSpec::RakeTask)
+    desc 'Run Opal (JavaScript) tests'
+    Opal::RSpec::RakeTask.new(:opal) do |task|
+      task.append_path 'lib'
+    end
+  end
+end
+
+RDoc::Task.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'Parsanol'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.adoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Print LOC statistics'
+task :stat do
+  %w[lib spec example].each do |dir|
+    next unless Dir.exist?(dir)
+
+    loc = `find #{dir} -name "*.rb" | xargs wc -l | grep 'total'`.split.first.to_i
+    printf("%20s %d\n", dir, loc)
+  end
+end
+
+# ===== Native Gem Building =====
+# Platform definitions for precompiled gems
+PLATFORMS = [
+  ['x64-mingw32', 'x86_64-w64-mingw32'],
+  ['x64-mingw-ucrt', 'x86_64-w64-mingw32'],
+  ['arm64-mingw-ucrt', 'aarch64-w64-mingw32'],
+  ['x86_64-linux', 'x86_64-linux-gnu'],
+  ['x86_64-linux-gnu', 'x86_64-linux-gnu'],
+  ['x86_64-linux-musl', 'x86_64-linux-musl'],
+  ['aarch64-linux', 'aarch64-linux-gnu'],
+  ['aarch64-linux-gnu', 'aarch64-linux-gnu'],
+  ['aarch64-linux-musl', 'aarch64-linux-musl'],
+  ['x86_64-darwin', 'x86_64-apple-darwin'],
+  ['arm64-darwin', 'arm64-apple-darwin'],
+]
+
+namespace :gem do
+  desc 'Build install-compilation gem (platform: any)'
+  task 'native:any' do
+    sh 'rake platform:any gem'
+  end
+
+  desc 'Define the gem task to build on any platform (compile on install)'
+  task 'platform:any' do
+    spec = Gem::Specification.load('parsanol-ruby.gemspec').dup
+    task = Gem::PackageTask.new(spec)
+    task.define
+  end
+
+  # Generate tasks for each platform
+  PLATFORMS.each do |platform, _host|
+    desc "Build pre-compiled gem for the #{platform} platform"
+    task "native:#{platform}" do
+      sh "rake compile platform:#{platform} gem"
+    end
+
+    desc "Define the gem task to build on the #{platform} platform (binary gem)"
+    task "platform:#{platform}" do
+      spec = Gem::Specification.load('parsanol-ruby.gemspec').dup
+      spec.platform = Gem::Platform.new(platform)
+
+      # Include pre-compiled native extension
+      spec.files += Dir.glob('lib/parsanol/*.{so,dylib,dll,bundle}')
+
+      # Remove extension build for binary gems (already compiled)
+      spec.extensions = []
+
+      # Remove build-time dependencies
+      spec.dependencies.reject! { |d| d.name == 'rb_sys' }
+      spec.dependencies.reject! { |d| d.name == 'rake-compiler' }
+
+      task = Gem::PackageTask.new(spec)
+      task.define
+    end
+  end
+
+  desc 'Build all platform gems (requires cross-compilation setup)'
+  task :native do
+    puts 'Building all platform gems...'
+    puts 'Run individual tasks like: rake gem:native:x86_64-linux'
+    puts 'Or use the CI workflow for cross-compilation.'
+  end
+end
+
+namespace :benchmark do
+  desc 'Run comprehensive benchmark suite'
+  task :all do
+    ruby 'benchmark/benchmark_suite.rb'
+  end
+
+  desc 'Run example-focused benchmarks'
+  task :examples do
+    ruby 'benchmark/example_benchmarks.rb'
+  end
+
+  desc 'Run benchmarks and export results to JSON/YAML'
+  task :export do
+    ruby 'benchmark/benchmark_runner.rb'
+  end
+
+  desc 'Run quick benchmark (examples only)'
+  task quick: :examples
+end
+
+# Load comparative benchmark tasks
+Dir.glob('benchmark/tasks/*.rake').each { |r| load r }
+
+desc 'Run quick benchmarks'
+task benchmark: 'benchmark:quick'
+
+# ===== Parslet Compatibility Tests =====
+namespace :compat do
+  desc 'Run imported Parslet tests with original Parslet (baseline)'
+  task :parslet do
+    ENV['PARSANOL_BACKEND'] = 'parslet'
+    sh 'bundle exec rspec spec/parslet_imported/ --format documentation'
+  end
+
+  desc 'Run imported Parslet tests with Parsanol compatibility layer'
+  task :parsanol do
+    ENV['PARSANOL_BACKEND'] = 'parsanol'
+    sh 'bundle exec rspec spec/parslet_imported/ --format documentation'
+  end
+
+  desc 'Run both and save results for comparison'
+  task :compare do
+    require 'fileutils'
+
+    results_dir = 'tmp/compat_results'
+    FileUtils.mkdir_p(results_dir)
+
+    puts '=== Running with original Parslet ==='
+    ENV['PARSANOL_BACKEND'] = 'parslet'
+    sh "bundle exec rspec spec/parslet_imported/ --format documentation > #{results_dir}/parslet.txt 2>&1"
+
+    puts "\n=== Running with Parsanol::Parslet ==="
+    ENV['PARSANOL_BACKEND'] = 'parsanol'
+    sh "bundle exec rspec spec/parslet_imported/ --format documentation > #{results_dir}/parsanol.txt 2>&1"
+
+    puts "\n=== Comparing results ==="
+    puts "Results saved to:"
+    puts "  - #{results_dir}/parslet.txt"
+    puts "  - #{results_dir}/parsanol.txt"
+    puts "\nTo compare: diff #{results_dir}/parslet.txt #{results_dir}/parsanol.txt"
+  end
+
+  desc 'Run imported Parslet tests (default: with Parsanol)'
+  task run: :parsanol
+end
+
+task default: :spec

data/example/balanced-parens/basic.rb

@@ -0,0 +1,42 @@
+# A small example that demonstrates the power of tree pattern matching. Also
+# uses '.as(:name)' to construct a tree that can reliably be matched
+# afterwards. 
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'pp'
+require 'parsanol/parslet'
+
+module LISP # as in 'lots of insipid and stupid parenthesis'
+  class Parser < Parsanol::Parser
+    rule(:balanced) {
+      str('(').as(:l) >> balanced.maybe.as(:m) >> str(')').as(:r)
+    }
+  
+    root(:balanced)
+  end
+
+  class Transform < Parsanol::Transform
+    rule(:l => '(', :m => simple(:x), :r => ')') { 
+      # innermost :m will contain nil
+      x.nil? ? 1 : x+1
+    }
+  end
+end
+
+parser = LISP::Parser.new
+transform = LISP::Transform.new
+%w!
+  ()
+  (())
+  ((((()))))
+  ((())
+!.each do |pexp|
+  begin
+    result = parser.parse(pexp)
+    puts "#{"%20s"%pexp}: #{result.inspect} (#{transform.apply(result)} parens)"
+  rescue Parsanol::ParseFailed => m
+    puts "#{"%20s"%pexp}: #{m}"
+  end
+  puts
+end

data/example/balanced-parens/basic.rb.md

@@ -0,0 +1,86 @@
+# Balanced Parentheses - Ruby Implementation
+
+## How to Run
+
+```bash
+cd parsanol-ruby/example/balanced-parens
+ruby basic.rb
+```
+
+## Code Walkthrough
+
+### Recursive Balanced Rule
+
+Parentheses are defined recursively:
+
+```ruby
+rule(:balanced) {
+  str('(').as(:l) >> balanced.maybe.as(:m) >> str(')').as(:r)
+}
+```
+
+Each level contains opening paren, optional nested content, and closing paren.
+
+### Labeled Components
+
+Each part is labeled for pattern matching:
+
+```ruby
+str('(').as(:l)    # Opening paren labeled :l
+balanced.maybe.as(:m)  # Middle content labeled :m
+str(')').as(:r)    # Closing paren labeled :r
+```
+
+Labels enable precise pattern matching in transforms.
+
+### Transform for Counting
+
+The transform counts nesting depth:
+
+```ruby
+class Transform < Parsanol::Transform
+  rule(:l => '(', :m => simple(:x), :r => ')') {
+    x.nil? ? 1 : x+1
+  }
+end
+```
+
+Pattern matches the structure; nil indicates innermost level.
+
+### Recursive Tree Structure
+
+Deep nesting creates nested parse trees:
+
+```ruby
+# Input: ((()))
+# Tree: {:l=>"(", :m=>{:l=>"(", :m=>{:l=>"(", :m=>nil, :r=>")"}, :r=>")"}, :r=>")"}
+```
+
+The innermost `:m` is nil when nothing is inside.
+
+## Output Types
+
+```ruby
+# Parse tree for "(())":
+{:l=>"(", :m=>{:l=>"(", :m=>nil, :r=>")"}, :r=>")"}
+
+# After transform:
+2  # Depth of nesting
+
+# Invalid input:
+# Raises Parsanol::ParseFailed
+```
+
+## Design Decisions
+
+### Why Use Labels for Literals?
+
+Labeling constant values (`:l => '('`) allows pattern matching on structure, not just values.
+
+### Why Maybe for Middle Content?
+
+The innermost parentheses have nothing inside. `.maybe` handles this base case.
+
+### Why Count Depth in Transform?
+
+Counting demonstrates tree traversal. Real applications might validate matching pairs or build AST structures.

data/example/balanced-parens/parens.rb

@@ -0,0 +1,42 @@
+# A small example that demonstrates the power of tree pattern matching. Also
+# uses '.as(:name)' to construct a tree that can reliably be matched
+# afterwards. 
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'pp'
+require 'parsanol/parslet'
+
+module LISP # as in 'lots of insipid and stupid parenthesis'
+  class Parser < Parsanol::Parser
+    rule(:balanced) {
+      str('(').as(:l) >> balanced.maybe.as(:m) >> str(')').as(:r)
+    }
+  
+    root(:balanced)
+  end
+
+  class Transform < Parsanol::Transform
+    rule(:l => '(', :m => simple(:x), :r => ')') { 
+      # innermost :m will contain nil
+      x.nil? ? 1 : x+1
+    }
+  end
+end
+
+parser = LISP::Parser.new
+transform = LISP::Transform.new
+%w!
+  ()
+  (())
+  ((((()))))
+  ((())
+!.each do |pexp|
+  begin
+    result = parser.parse(pexp)
+    puts "#{"%20s"%pexp}: #{result.inspect} (#{transform.apply(result)} parens)"
+  rescue Parsanol::ParseFailed => m
+    puts "#{"%20s"%pexp}: #{m}"
+  end
+  puts
+end

data/example/balanced-parens/ruby_transform.rb

@@ -0,0 +1,162 @@
+# Balanced Parentheses Parser Example - RubyTransform
+#
+# This example demonstrates parsing balanced parentheses expressions.
+# Shows recursive grammar rules and validation.
+#
+# Run with: ruby -Ilib example/balanced_parens_ruby_transform.rb
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'parsanol'
+
+# Step 1: Define the balanced parentheses grammar
+# Using a PEG-friendly approach: parse multiple balanced groups
+class BalancedParensParser < Parsanol::Parser
+  root :content
+
+  # Content: zero or more balanced groups
+  rule(:content) {
+    balanced.repeat
+  }
+
+  # Balanced: a parenthesized group that may contain more groups
+  rule(:balanced) {
+    str('(') >> content >> str(')')
+  }
+end
+
+# Step 2: Node classes
+class ParenExpr
+  attr_reader :inner
+
+  def initialize(inner)
+    @inner = inner
+  end
+
+  def balanced?
+    true
+  end
+
+  def to_s
+    "(#{@inner})"
+  end
+
+  def depth
+    1 + (@inner.respond_to?(:depth) ? @inner.depth : 0)
+  end
+end
+
+class EmptyExpr
+  def balanced?
+    true
+  end
+
+  def to_s
+    ""
+  end
+
+  def depth
+    0
+  end
+end
+
+class SequenceExpr
+  attr_reader :exprs
+
+  def initialize(exprs)
+    @exprs = exprs
+  end
+
+  def balanced?
+    @exprs.all?(&:balanced?)
+  end
+
+  def to_s
+    @exprs.map(&:to_s).join
+  end
+
+  def depth
+    @exprs.map(&:depth).max || 0
+  end
+end
+
+# Step 3: Parse and build AST
+def parse_balanced(input)
+  parser = BalancedParensParser.new
+
+  tree = parser.parse(input)
+  puts "Parse tree: #{tree.inspect}"
+
+  # Build AST from tree
+  ast = build_ast(tree)
+  puts "AST: #{ast.to_s}"
+  puts "Balanced: #{ast.balanced?}"
+  puts "Max depth: #{ast.depth}"
+
+  ast
+rescue Parsanol::ParseFailed => e
+  puts "Parse failed: #{e.message}"
+  nil
+rescue SystemStackError => e
+  puts "Stack overflow - grammar too complex for input"
+  nil
+end
+
+def build_ast(tree)
+  # Handle nil and empty
+  return EmptyExpr.new if tree.nil?
+  return EmptyExpr.new if tree.to_s.empty?
+
+  if tree.is_a?(Array)
+    exprs = tree.map { |t| build_ast(t) }.reject { |e| e.is_a?(EmptyExpr) }
+    return EmptyExpr.new if exprs.empty?
+    return exprs.first if exprs.length == 1
+    SequenceExpr.new(exprs)
+  elsif tree.is_a?(Hash)
+    if tree[:balanced]
+      inner = build_ast(tree[:balanced])
+      ParenExpr.new(inner)
+    elsif tree[:content]
+      build_ast(tree[:content])
+    else
+      EmptyExpr.new
+    end
+  else
+    EmptyExpr.new
+  end
+end
+
+# Example usage
+if __FILE__ == $0
+  puts "=" * 60
+  puts "Balanced Parentheses Parser - RubyTransform"
+  puts "=" * 60
+  puts
+
+  test_cases = [
+    "",              # Empty - balanced
+    "()",            # Simple - balanced
+    "(())",          # Nested - balanced
+    "(()())",       # Multiple - balanced
+    "((()))",       # Deeply nested - balanced
+    "(()())()",     # Multiple groups - balanced
+    "(())(())",     # Two groups - balanced
+    "(",             # Unbalanced - should fail
+    ")",             # Unbalanced - should fail
+    "(()",           # Unbalanced - should fail
+    "())",           # Unbalanced - should fail
+    "((())",         # Unbalanced - should fail
+  ]
+
+  test_cases.each do |input|
+    puts "-" * 40
+    puts "Input: '#{input}'"
+    ast = parse_balanced(input)
+    if ast
+      puts "Result: #{ast.balanced? ? '✓ BALANCED' : '✗ UNBALANCED'}"
+    else
+      puts "Result: ✗ PARSE FAILED"
+    end
+    puts
+  end
+end

data/example/big.erb

@@ -0,0 +1,73 @@
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+proident, sunt in culpa qui officia deserunt mollit anim id est laborum.Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+
+<%= erb tag %>
+
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+proident, sunt in culpa qui officia deserunt mollit anim id est laborum.Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

data/example/boolean-algebra/basic.rb

@@ -0,0 +1,70 @@
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require "parsanol/parslet"
+require "pp"
+
+# Parses strings like "var1 and (var2 or var3)" respecting operator precedence
+# and parentheses. After that transforms the parse tree into an array of
+# arrays like this:
+#
+# [["1", "2"], ["1", "3"]]
+#
+# The array represents a DNF (disjunctive normal form). Elements of outer
+# array are connected with "or" operator, while elements of inner arrays are
+# joined with "and".
+#
+class MyParser < Parsanol::Parser
+  rule(:space)  { match[" "].repeat(1) }
+  rule(:space?) { space.maybe }
+
+  rule(:lparen) { str("(") >> space? }
+  rule(:rparen) { str(")") >> space? }
+
+  rule(:and_operator) { str("and") >> space? }
+  rule(:or_operator)  { str("or")  >> space? }
+
+  rule(:var) { str("var") >> match["0-9"].repeat(1).as(:var) >> space? }
+
+  # The primary rule deals with parentheses.
+  rule(:primary) { lparen >> or_operation >> rparen | var }
+
+  # Note that following rules are both right-recursive.
+  rule(:and_operation) { 
+    (primary.as(:left) >> and_operator >> 
+      and_operation.as(:right)).as(:and) | 
+    primary }
+    
+  rule(:or_operation)  { 
+    (and_operation.as(:left) >> or_operator >> 
+      or_operation.as(:right)).as(:or) | 
+    and_operation }
+
+  # We start at the lowest precedence rule.
+  root(:or_operation)
+end
+
+class Transformer < Parsanol::Transform
+  rule(:var => simple(:var)) { [[String(var)]] }
+
+  rule(:or => { :left => subtree(:left), :right => subtree(:right) }) do
+    (left + right)
+  end
+
+  rule(:and => { :left => subtree(:left), :right => subtree(:right) }) do
+     res = []
+     left.each do |l|
+       right.each do |r|
+         res << (l + r)
+       end
+     end
+     res
+  end
+end
+
+pp tree = MyParser.new.parse("var1 and (var2 or var3)")
+# {:and=>
+#   {:left=>{:var=>"1"@3},
+#    :right=>{:or=>{:left=>{:var=>"2"@13}, :right=>{:var=>"3"@21}}}}}
+pp Transformer.new.apply(tree)
+# [["1", "2"], ["1", "3"]]
+