parsanol 1.3.13-arm-linux

data/Rakefile

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+
+begin
+  require "rspec/core/rake_task"
+rescue LoadError
+  # RSpec not available in this environment
+end
+
+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
+
+GEMSPEC = Gem::Specification.load("parsanol.gemspec")
+
+# Load rake tasks from rakelib/
+Dir.glob("rakelib/*.rake").each { |r| load r }
+
+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 =====
+namespace :gem do
+  desc "Build source gem (compile on install)"
+  task "native:any" do
+    sh "rake gem: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.gemspec").dup
+    task = Gem::PackageTask.new(spec)
+    task.define
+  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/lib/parsanol/ast_visitor.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+# Base class for AST visitors following the Visitor pattern
+# This separates tree traversal logic from transformation logic
+# making the code more maintainable and extensible.
+module Parsanol
+  # Base visitor class that traverses the Parslet AST
+  # Subclasses override visit_* methods to perform transformations
+  class ASTVisitor
+    # Visit a parslet and its children
+    # Subclasses should override specific visit_* methods
+    # @param parslet [Parsanol::Atoms::Base] parslet to visit
+    # @return [Parsanol::Atoms::Base] transformed parslet
+    def visit(parslet)
+      case parslet
+      when Parsanol::Atoms::Sequence
+        visit_sequence(parslet)
+      when Parsanol::Atoms::Alternative
+        visit_alternative(parslet)
+      when Parsanol::Atoms::Repetition
+        visit_repetition(parslet)
+      when Parsanol::Atoms::Lookahead
+        visit_lookahead(parslet)
+      when Parsanol::Atoms::Named
+        visit_named(parslet)
+      when Parsanol::Atoms::Str
+        visit_str(parslet)
+      when Parsanol::Atoms::Re
+        visit_re(parslet)
+      else
+        # Leaf nodes or unknown types - return as-is
+        parslet
+      end
+    end
+
+    # Visit a sequence node
+    # Default implementation visits children and reconstructs if changed
+    # @param parslet [Parsanol::Atoms::Sequence] sequence to visit
+    # @return [Parsanol::Atoms::Base] transformed sequence
+    def visit_sequence(parslet)
+      new_parslets = parslet.parslets.map { |p| visit(p) }
+      if new_parslets == parslet.parslets
+        parslet
+      else
+        Parsanol::Atoms::Sequence.new(*new_parslets)
+      end
+    end
+
+    # Visit an alternative node
+    # Default implementation visits children and reconstructs if changed
+    # @param parslet [Parsanol::Atoms::Alternative] alternative to visit
+    # @return [Parsanol::Atoms::Base] transformed alternative
+    def visit_alternative(parslet)
+      new_alternatives = parslet.alternatives.map { |p| visit(p) }
+      if new_alternatives == parslet.alternatives
+        parslet
+      else
+        Parsanol::Atoms::Alternative.new(*new_alternatives)
+      end
+    end
+
+    # Visit a repetition node
+    # Default implementation visits child and reconstructs if changed
+    # @param parslet [Parsanol::Atoms::Repetition] repetition to visit
+    # @return [Parsanol::Atoms::Base] transformed repetition
+    def visit_repetition(parslet)
+      new_parslet = visit(parslet.parslet)
+      if new_parslet.equal?(parslet.parslet)
+        parslet
+      else
+        Parsanol::Atoms::Repetition.new(
+          new_parslet,
+          parslet.min,
+          parslet.max,
+          parslet.instance_variable_get(:@tag),
+        )
+      end
+    end
+
+    # Visit a lookahead node
+    # Default implementation visits child and reconstructs if changed
+    # @param parslet [Parsanol::Atoms::Lookahead] lookahead to visit
+    # @return [Parsanol::Atoms::Base] transformed lookahead
+    def visit_lookahead(parslet)
+      new_bound = visit(parslet.bound_parslet)
+      if new_bound.equal?(parslet.bound_parslet)
+        parslet
+      else
+        Parsanol::Atoms::Lookahead.new(new_bound, parslet.positive)
+      end
+    end
+
+    # Visit a named node
+    # Default implementation visits child and reconstructs if changed
+    # @param parslet [Parsanol::Atoms::Named] named to visit
+    # @return [Parsanol::Atoms::Base] transformed named
+    def visit_named(parslet)
+      new_parslet = visit(parslet.parslet)
+      if new_parslet.equal?(parslet.parslet)
+        parslet
+      else
+        Parsanol::Atoms::Named.new(new_parslet, parslet.name)
+      end
+    end
+
+    # Visit a string literal node
+    # Default implementation returns as-is (leaf node)
+    # @param parslet [Parsanol::Atoms::Str] string to visit
+    # @return [Parsanol::Atoms::Base] transformed string
+    def visit_str(parslet)
+      parslet
+    end
+
+    # Visit a regex node
+    # Default implementation returns as-is (leaf node)
+    # @param parslet [Parsanol::Atoms::Re] regex to visit
+    # @return [Parsanol::Atoms::Base] transformed regex
+    def visit_re(parslet)
+      parslet
+    end
+  end
+end

data/lib/parsanol/atoms/alternative.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+# Ordered choice - tries alternatives left-to-right, returning first success.
+# Fails only if all alternatives fail.
+#
+# @example Simple choice
+#   str('a') | str('b')  # matches 'a' or 'b'
+#
+# This is PEG ordered choice - no backtracking to later alternatives.
+#
+module Parsanol
+  module Atoms
+    class Alternative < Parsanol::Atoms::Base
+      # @return [Array<Parsanol::Atoms::Base>] alternative parsers
+      attr_reader :alternatives
+
+      # Creates a new choice.
+      #
+      # @param options [Array<Parsanol::Atoms::Base>] alternatives
+      def initialize(*options)
+        super()
+        @alternatives = options
+        @choice_error = "Expected one of #{options.inspect}"
+      end
+
+      # Adds an alternative with flattening.
+      #
+      # @param parser [Parsanol::Atoms::Base] new alternative
+      # @return [Parsanol::Atoms::Alternative] flattened choice
+      def |(other)
+        expanded = if other.is_a?(Parsanol::Atoms::Alternative)
+                     @alternatives + other.alternatives
+                   else
+                     @alternatives + [other]
+                   end
+        self.class.new(*expanded)
+      end
+
+      # Tries each alternative in order.
+      #
+      # @param source [Parsanol::Source] input
+      # @param context [Parsanol::Atoms::Context] context
+      # @param consume_all [Boolean] require full consumption
+      # @return [Array(Boolean, Object)] result
+      def try(source, context, consume_all)
+        options = @alternatives
+        count = options.size
+
+        # Optimized paths for common sizes
+        case count
+        when 2
+          try_two(options[0], options[1], source, context, consume_all)
+        when 3
+          try_three(options[0], options[1], options[2], source, context,
+                    consume_all)
+        else
+          try_many(options, source, context, consume_all)
+        end
+      end
+
+      precedence CHOICE
+
+      # String representation.
+      #
+      # @param prec [Integer] precedence
+      # @return [String]
+      def to_s_inner(prec)
+        @alternatives.map { |a| a.to_s(prec) }.join(" / ")
+      end
+
+      # FIRST set is union of all alternatives' FIRST sets.
+      #
+      # @return [Set]
+      def compute_first_set
+        return Set.new if @alternatives.empty?
+
+        @alternatives.map(&:first_set).reduce(&:union)
+      end
+
+      private
+
+      # Two-alternative fast path
+      def try_two(a1, a2, source, context, consume_all)
+        success, value1 = a1.apply(source, context, consume_all)
+        return [success, value1] if success
+
+        success, value2 = a2.apply(source, context, consume_all)
+        return [success, value2] if success
+
+        context.err(self, source, @choice_error, [value1, value2])
+      end
+
+      # Three-alternative fast path
+      def try_three(a1, a2, a3, source, context, consume_all)
+        success, value1 = a1.apply(source, context, consume_all)
+        return [success, value1] if success
+
+        success, value2 = a2.apply(source, context, consume_all)
+        return [success, value2] if success
+
+        success, value3 = a3.apply(source, context, consume_all)
+        return [success, value3] if success
+
+        context.err(self, source, @choice_error, [value1, value2, value3])
+      end
+
+      # General case for N alternatives
+      def try_many(options, source, context, consume_all)
+        errors = nil
+
+        options.each do |alt|
+          success, value = alt.apply(source, context, consume_all)
+          return [success, value] if success
+
+          errors ||= []
+          errors << value
+        end
+
+        context.err(self, source, @choice_error, errors)
+      end
+    end
+  end
+end

data/lib/parsanol/atoms/base.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+# Base class for all parser atoms. Handles parsing orchestration,
+# memoization, error handling, and result processing.
+#
+# Concrete atoms must implement #try(source, context, consume_all).
+#
+# @abstract Implement #try to create custom parser atoms
+module Parsanol
+  module Atoms
+    class Base
+      include Parsanol::Atoms::Precedence
+      include Parsanol::Atoms::DSL
+      include Parsanol::Atoms::CanFlatten
+      include Parsanol::FirstSet
+
+      # Label used for error messages (optional)
+      attr_accessor :label
+
+      # Error message for unconsumed input
+      UNCONSUMED_INPUT_MSG = "Don't know what to do with "
+
+      # Primary parsing interface. Takes a string or Source and returns
+      # the parsed tree, or raises ParseFailed on error.
+      #
+      # @param source [String, Parsanol::Source] input to parse
+      # @param options [Hash] parsing options
+      # @option options [Parsanol::ErrorReporter] :reporter error collector
+      # @option options [Boolean] :prefix allow partial parse (default: false)
+      # @return [Object] the parsed result
+      # @raise [Parsanol::ParseFailed] on parse failure
+      def parse(source, options = {})
+        input = normalize_input(source)
+        must_consume_all = !options[:prefix]
+
+        # Initial parse attempt (no error collection)
+        success, value = run_with_context(input, nil, must_consume_all)
+        return finalize_result(value) if success
+
+        # Reparse with error reporting for diagnostics
+        report_detailed_error(input, must_consume_all, options[:reporter],
+                              value)
+      end
+
+      # Creates a new parsing context and executes the atom.
+      #
+      # @param input [Parsanol::Source] the source
+      # @param reporter [Object, nil] error reporter
+      # @param consume_all [Boolean] require complete consumption
+      # @return [Array(Boolean, Object)] outcome tuple
+      def run_with_context(input, reporter, consume_all)
+        parser_class = detect_parser_class
+        context = Parsanol::Atoms::Context.new(reporter,
+                                               parser_class: parser_class)
+        apply(input, context, consume_all)
+      end
+
+      # Core execution method. Manages position, caching, and error handling.
+      #
+      # @param input [Parsanol::Source] source to parse
+      # @param context [Parsanol::Atoms::Context] parsing state
+      # @param consume_all [Boolean] consume entire input
+      # @return [Array(Boolean, Object)] outcome pair
+      def apply(input, context, consume_all = false)
+        position_before = input.bytepos
+        outcome = context.try_with_cache(self, input, consume_all)
+        succeeded = outcome.first
+
+        return handle_failure(input, position_before, outcome) unless succeeded
+
+        context.succ(input)
+
+        # Verify full consumption when required
+        if consume_all && input.chars_left.positive?
+          return unconsumed_error(input, context,
+                                  position_before)
+        end
+
+        outcome
+      end
+
+      # Abstract matching method - override in subclasses.
+      #
+      # @param input [Parsanol::Source] source
+      # @param context [Parsanol::Atoms::Context] context
+      # @param consume_all [Boolean] consume all flag
+      # @return [Array(Boolean, Object)] parse result
+      # @raise [NotImplementedError] if not overridden
+      def try(input, context, consume_all)
+        raise NotImplementedError,
+              "Atom must implement #try(source, context, consume_all)"
+      end
+
+      # Whether packrat caching benefits this atom.
+      # Override to disable caching for simple atoms.
+      #
+      # @return [Boolean]
+      def cached?
+        true
+      end
+
+      # Whether this atom produces flat results.
+      # When true, flattening can be skipped.
+      #
+      # @return [Boolean]
+      def flat?
+        false
+      end
+
+      # DSL for setting precedence level (for pretty-printing).
+      #
+      # @param level [Integer] precedence value
+      def self.precedence(level)
+        define_method(:precedence) { level }
+      end
+      precedence ATOM
+
+      # String representation with precedence-aware parenthesization.
+      #
+      # @param outer [Integer] caller's precedence
+      # @return [String]
+      def to_s(outer = TOP)
+        text = label || to_s_inner(precedence)
+        outer < precedence ? "(#{text})" : text
+      end
+
+      def inspect
+        to_s(TOP)
+      end
+
+      protected
+
+      # Pre-allocated constant result tuples
+      NIL_OK = [true, nil].freeze
+      EMPTY_ARR = [].freeze
+      REP_TAG = [:repetition].freeze
+      REP_OK = [true, REP_TAG].freeze
+      SEQ_TAG = [:sequence].freeze
+      SEQ_OK = [true, SEQ_TAG].freeze
+      EMPTY_MAP = {}.freeze
+      MAP_OK = [true, EMPTY_MAP].freeze
+      CAP_TAG = [:capture].freeze
+      CAP_OK = [true, CAP_TAG].freeze
+
+      # Creates a success tuple.
+      #
+      # @param data [Object] the value
+      # @return [Array(true, Object)]
+      def ok(data)
+        return NIL_OK if data.nil?
+        return [true, EMPTY_ARR] if data.equal?(EMPTY_ARR)
+        return MAP_OK if data.equal?(EMPTY_MAP)
+        return REP_OK if data.equal?(REP_TAG)
+        return SEQ_OK if data.equal?(SEQ_TAG)
+        return CAP_OK if data.equal?(CAP_TAG)
+
+        [true, data]
+      end
+
+      # Alias for ok (legacy compatibility)
+      alias succ ok
+
+      private
+
+      # Converts raw input to Source if needed.
+      def normalize_input(source)
+        source.respond_to?(:line_and_column) ? source : Parsanol::Source.new(source)
+      end
+
+      # Detects if we're in a Parser context.
+      def detect_parser_class
+        is_a?(Parsanol::Parser) ? self.class : nil
+      end
+
+      # Handles parse failure by restoring position.
+      def handle_failure(input, saved_pos, outcome)
+        input.bytepos = saved_pos
+        outcome
+      end
+
+      # Creates error for unconsumed input.
+      def unconsumed_error(input, context, saved_pos)
+        excess_pos = input.bytepos
+        preview = input.consume(10)
+        input.bytepos = saved_pos
+        context.err_at(self, input,
+                       UNCONSUMED_INPUT_MSG + preview.to_s.inspect, excess_pos)
+      end
+
+      # Reports detailed error by reparsing with reporter.
+      def report_detailed_error(input, consume_all, reporter, _initial_error)
+        input.bytepos = 0
+        error_reporter = reporter || Parsanol::ErrorReporter::Tree.new
+        success, cause = run_with_context(input, error_reporter, consume_all)
+
+        # Second parse should also fail
+        raise "Invariant violation: parse succeeded during error reporting" if success
+
+        cause.raise
+      end
+
+      # Finalizes result by flattening.
+      def finalize_result(value)
+        flatten(value)
+      end
+    end
+  end
+end