parsanol 1.0.1-aarch64-linux

data/lib/parsanol/atoms/entity.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# Named rule wrapper that provides lazy evaluation and caching for grammar
+# rules. Rules are defined as Entity atoms and named, and they can be
+# referenced by other rules with automatic cycle detection.
+#
+# @example
+#   class MyParser < Parsanol::Parser
+#     rule(:expression) { str('a') >> str('b') }
+#     root(:expression)
+#   end
+#
+#   MyParser.new.parse('ab')  # => ["a", "b"]
+#
+module Parsanol
+  module Atoms
+    class Entity < Parsanol::Atoms::Base
+      attr_reader :rule_name, :block_definition
+
+      # Alias for backward compatibility
+      alias name rule_name
+
+      def initialize(name, label_or_opts = {}, &body)
+        super()
+        @rule_name = name
+        # Support both old API (label string) and new API (options hash)
+        @options = if label_or_opts.is_a?(Hash)
+                     label_or_opts
+                   else
+                     { label: label_or_opts }
+                   end
+        @body = body
+        @cached_atom = nil
+        # Set label on self for display purposes
+        self.label = @options[:label] if @options[:label]
+      end
+
+      # Evaluates the rule body, returns cached result.
+      def parslet
+        return @cached_atom unless @cached_atom.nil?
+
+        @cached_atom = @body.call
+
+        raise_not_implemented if @cached_atom.nil?
+
+        @cached_atom.label = @options[:label] if @options[:label]
+        @cached_atom
+      end
+
+      def try(source, context, consume_all)
+        atom = parslet
+        atom.apply(source, context, consume_all)
+      end
+
+      # Entities don't need caching since the underlying atom is already cached.
+      def cached?
+        false
+      end
+
+      def to_s_inner(_prec)
+        rule_name.to_s.upcase
+      end
+
+      private
+
+      def raise_not_implemented
+        trace_lines = caller.grep_v(/#{Regexp.escape(__FILE__)}/)
+        error_message = "rule '#{@rule_name}' has not been implemented, but already used?"
+        exception = NotImplementedError.new(error_message)
+        exception.set_backtrace(trace_lines)
+        raise exception
+      end
+    end
+  end
+end

data/lib/parsanol/atoms/ignored.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Ignores the result of a match, Useful for cases where you want to match
+# prefix or suffix without returning any.
+
+#
+# @example
+#   str('foo')            # will return 'foo',
+#   str('foo').ignore     # will return nil
+#
+# Inspired by Parslet (MIT License).
+
+module Parsanol
+  module Atoms
+    class Ignored < Parsanol::Atoms::Base
+      attr_reader :wrapped_atom
+
+      def initialize(atom)
+        super()
+        @wrapped_atom = atom
+      end
+
+      def apply(source, context, consume_all)
+        ok, result = @wrapped_atom.apply(source, context, consume_all)
+
+        return [false, result] unless ok
+
+        # Success - return nil instead of the matched value
+        [true, nil]
+      end
+
+      def to_s_inner(prec)
+        "ignored(#{@wrapped_atom.to_s(prec)})"
+      end
+    end
+  end
+end

data/lib/parsanol/atoms/infix.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+# Infix expression parser using precedence climbing algorithm.
+# Parses mathematical-style expressions with configurable operators.
+#
+# @example Basic usage
+#   element = match('[0-9]').repeat(1)
+#   operations = [
+#     [str('+'), 1, :left],
+#     [str('*'), 2, :left]
+#   ]
+#   infix = Parsanol::Atoms::Infix.new(element, *operations)
+#
+# Inspired by Parslet (MIT License).
+# Algorithm reference: http://eli.thegreenplace.net/2012/08/02/parsing-expressions-by-precedence-climbing/
+
+module Parsanol
+  module Atoms
+    class Infix < Parsanol::Atoms::Base
+      attr_reader :base_element, :operator_table, :result_combiner
+
+      # Creates a new infix expression parser.
+      #
+      # @param base_element [Parsanol::Atoms::Base] parser for atomic operands
+      # @param operations [Array<Array>] operator definitions [atom, precedence, associativity]
+      # @yield block to combine left, operator, right into result
+      def initialize(base_element, operations, &combiner)
+        super()
+        @base_element = base_element
+        @operator_table = operations
+        @result_combiner = combiner || default_combiner
+      end
+
+      # Attempts to parse an infix expression from the source.
+      #
+      # @param source [Parsanol::Source] input source
+      # @param context [Parsanol::Atoms::Context] parsing context
+      # @param consume_all [Boolean] whether to consume all input
+      # @return [Array] success/error tuple
+      def try(source, context, consume_all)
+        catch(:parse_error) do
+          raw_result = climb_precedence(source, context, consume_all)
+          structured_result = build_result_tree(raw_result)
+          return succ(structured_result)
+        end
+      end
+
+      private
+
+      # Default combiner creates nested hash structure
+      def default_combiner
+        lambda do |left_side, operator, right_side|
+          { left: left_side, op: operator, right: right_side }
+        end
+      end
+
+      # Converts flat array representation to nested structure.
+      # Input: ['1', '+', ['2', '*', '3']]
+      # Output: { left: '1', op: '+', right: { left: '2', op: '*', right: '3' } }
+      #
+      # @param expression [Object] array or leaf value
+      # @return [Object] structured result
+      def build_result_tree(expression)
+        return expression unless expression.is_a?(Array)
+
+        combiner = @result_combiner
+        accumulator = expression.shift
+
+        until expression.empty?
+          operator_token, right_operand = expression.shift(2)
+
+          if right_operand.is_a?(Array)
+            # Recursively process nested expressions
+            right_operand = build_result_tree(right_operand)
+          end
+
+          accumulator = combiner.call(accumulator, operator_token, right_operand)
+        end
+
+        accumulator
+      end
+
+      # Main precedence climbing loop.
+      # Parses operands and operators, respecting precedence and associativity.
+      #
+      # @param source [Parsanol::Source] input source
+      # @param context [Parsanol::Atoms::Context] parsing context
+      # @param consume_all [Boolean] consume all flag
+      # @param min_precedence [Integer] minimum precedence to continue (default: 1)
+      # @return [Object] parsed expression
+      def climb_precedence(source, context, consume_all, min_precedence = 1)
+        element_parser = @base_element
+        expression_parts = []
+
+        # Must match at least one element to start
+        ok, first_value = element_parser.apply(source, context, false)
+        unless ok
+          throw :parse_error,
+                context.err(self, source, "Expected #{element_parser.inspect}", [first_value])
+        end
+
+        expression_parts << flatten(first_value, true)
+
+        # Continue while operators match
+        loop do
+          saved_position = source.bytepos
+          operator_match, precedence, associativity = try_match_operator(source, context, false)
+
+          # No operator found - done with this level
+          break unless operator_match
+
+          if precedence >= min_precedence
+            # Calculate next minimum precedence based on associativity
+            next_min = associativity == :left ? precedence + 1 : precedence
+
+            expression_parts << operator_match
+            expression_parts << climb_precedence(source, context, consume_all, next_min)
+          else
+            # Operator has lower precedence - backtrack and return
+            source.bytepos = saved_position
+            return simplify_result(expression_parts)
+          end
+        end
+
+        simplify_result(expression_parts)
+      end
+
+      # Attempts to match any operator from the operator table.
+      #
+      # @param source [Parsanol::Source] input source
+      # @param context [Parsanol::Atoms::Context] parsing context
+      # @param consume_all [Boolean] consume all flag
+      # @return [Array, nil] [matched_value, precedence, associativity] or nil
+      def try_match_operator(source, context, consume_all)
+        operators = @operator_table
+
+        operators.each do |op_parser, prec, assoc|
+          ok, value = op_parser.apply(source, context, consume_all)
+          return [flatten(value, true), prec, assoc] if ok
+        end
+
+        nil
+      end
+
+      # Simplifies single-element results to avoid unnecessary nesting.
+      #
+      # @param result [Array] expression parts
+      # @return [Object] simplified result
+      def simplify_result(result)
+        result.length == 1 ? result.first : result
+      end
+
+      public
+
+      # Returns string representation for debugging
+      def to_s_inner(_precedence)
+        op_list = @operator_table.map { |op, _, _| op.inspect }.join(', ')
+        "infix_expression(#{@base_element.inspect}, [#{op_list}])"
+      end
+    end
+  end
+end

data/lib/parsanol/atoms/lookahead.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# Lookahead assertion - checks for pattern presence/absence without consuming.
+# Position is always restored after the check.
+#
+# @example Positive lookahead (must be present)
+#   str('foo').present?  # succeeds if 'foo' ahead
+#
+# @example Negative lookahead (must not be present)
+#   str('foo').absent?   # succeeds if 'foo' not ahead
+#
+module Parsanol
+  module Atoms
+    class Lookahead < Parsanol::Atoms::Base
+      # @return [Boolean] true for positive, false for negative
+      attr_reader :positive
+
+      # @return [Parsanol::Atoms::Base] parser to check
+      attr_reader :bound_parslet
+
+      # Creates a new lookahead.
+      #
+      # @param parser [Parsanol::Atoms::Base] parser to check
+      # @param is_positive [Boolean] positive vs negative
+      def initialize(parser, is_positive = true)
+        super()
+        @positive = is_positive
+        @bound_parslet = parser
+
+        # Pre-built error components
+        @should_start = ['Input should start with ', parser].freeze
+        @should_not_start = ['Input should not start with ', parser].freeze
+      end
+
+      # Tests lookahead without consuming input.
+      #
+      # @param source [Parsanol::Source] input
+      # @param context [Parsanol::Atoms::Context] context
+      # @param consume_all [Boolean] ignored
+      # @return [Array(Boolean, Object)] result
+      def try(source, context, consume_all)
+        # Save position - never consume
+        saved = source.bytepos
+
+        matched, = @bound_parslet.apply(source, context, consume_all)
+
+        # Always restore
+        source.bytepos = saved
+
+        if @positive
+          # Positive: succeed if matched
+          return ok(nil) if matched
+
+          context.err_at(self, source, @should_start, source.bytepos)
+        else
+          # Negative: succeed if not matched
+          return context.err_at(self, source, @should_not_start, source.bytepos) if matched
+
+          ok(nil)
+        end
+      end
+
+      precedence LOOKAHEAD
+
+      # String representation.
+      #
+      # @param prec [Integer] precedence
+      # @return [String]
+      def to_s_inner(prec)
+        symbol = @positive ? '&' : '!'
+        "#{symbol}#{@bound_parslet.to_s(prec)}"
+      end
+
+      # FIRST set is always EPSILON (zero-width).
+      #
+      # @return [Set]
+      def compute_first_set
+        Set.new([Parsanol::FirstSet::EPSILON])
+      end
+    end
+  end
+end

data/lib/parsanol/atoms/named.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# Named capture - assigns a label to matched content.
+# Results appear as { label: value } in the parse tree.
+#
+# @example Labeling matches
+#   str('foo').as(:name)  # returns { name: 'foo' }
+#
+module Parsanol
+  module Atoms
+    class Named < Parsanol::Atoms::Base
+      # @return [Parsanol::Atoms::Base] wrapped parser
+      attr_reader :parslet
+
+      # @return [Symbol] the capture label
+      attr_reader :name
+
+      # Creates a new named capture.
+      #
+      # @param parser [Parsanol::Atoms::Base] parser to wrap
+      # @param label [Symbol] name for captures
+      def initialize(parser, label)
+        super()
+        @parslet = parser
+        @name = label
+      end
+
+      # Applies parser and wraps result in hash.
+      #
+      # @param source [Parsanol::Source] input
+      # @param context [Parsanol::Atoms::Context] context
+      # @param consume_all [Boolean] require full consumption
+      # @return [Array(Boolean, Object)] result
+      def apply(source, context, consume_all)
+        success, value = @parslet.apply(source, context, consume_all)
+        return [false, value] unless success
+
+        ok(wrap_result(value))
+      end
+
+      # Named wrappers skip caching (inner parser handles it).
+      #
+      # @return [Boolean]
+      def cached?
+        false
+      end
+
+      # String representation.
+      #
+      # @param prec [Integer] precedence
+      # @return [String]
+      def to_s_inner(prec)
+        "#{@name}:#{@parslet.to_s(prec)}"
+      end
+
+      # FIRST set is wrapped parser's FIRST set.
+      #
+      # @return [Set]
+      def compute_first_set
+        @parslet.first_set
+      end
+
+      private
+
+      # Wraps matched value in labeled hash.
+      #
+      # @param matched [Object] matched value
+      # @return [Hash] labeled result
+      def wrap_result(matched)
+        { @name => flatten(matched, true) }
+      end
+    end
+  end
+end

data/lib/parsanol/atoms/re.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# Regular expression matcher for single characters.
+# Matches one character against a character class pattern.
+#
+# @example Character classes
+#   match('[a-z]')  # matches a-z
+#   match('\d')     # matches digits
+#   any             # matches any character
+#
+module Parsanol
+  module Atoms
+    class Re < Parsanol::Atoms::Base
+      # @return [String] the pattern string
+      attr_reader :match
+
+      # @return [Regexp] compiled pattern
+      attr_reader :re
+
+      # Creates a new regex matcher.
+      #
+      # @param pattern [String, Object] regex character class
+      def initialize(pattern)
+        super()
+        @match = pattern.to_s
+        @re = Regexp.new(@match, Regexp::MULTILINE)
+
+        # Extract pattern for display (strip delimiters)
+        @display = @match.inspect[1..-2] || @match
+
+        # Pre-built error messages
+        @eof_error = 'Unexpected end of input'
+        @no_match_error = "Failed to match #{@display}"
+      end
+
+      # Matches one character against the pattern.
+      #
+      # @param source [Parsanol::Source] input
+      # @param context [Parsanol::Atoms::Context] context
+      # @param _consume_all [Boolean] ignored
+      # @return [Array(Boolean, Object)] result
+      def try(source, context, _consume_all)
+        # Fast path: check if next char matches
+        return ok(source.consume(1)) if source.matches?(@re)
+
+        # No input left
+        return context.err(self, source, @eof_error) if source.chars_left < 1
+
+        # Character doesn't match
+        context.err(self, source, @no_match_error)
+      end
+
+      # String representation.
+      #
+      # @param _prec [Integer] unused
+      # @return [String]
+      def to_s_inner(_prec)
+        @display
+      end
+
+      # Simple atoms don't benefit from caching.
+      #
+      # @return [Boolean]
+      def cached?
+        false
+      end
+
+      # Produces flat results.
+      #
+      # @return [Boolean]
+      def flat?
+        true
+      end
+
+      # FIRST set is this atom.
+      #
+      # @return [Set]
+      def compute_first_set
+        Set.new([self])
+      end
+    end
+  end
+end