paco 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 422192f0a277e1d7c6361db58ce97310db6e5fadfe06fed8e76a3978c1f65492
-  data.tar.gz: ed3e9e6c0ad0e4d11d7cf18afffcebcea83ba4b47928c98d72714eae0b3031af
+  metadata.gz: 8d72f440d9727dc302366b842d7a7bf3d3d2ac84f4e13b41ce8954dad4b971f0
+  data.tar.gz: 81b0e2b377c35060db0416472115754cd62d45efda5f302265003b1340e639b4
 SHA512:
-  metadata.gz: b96441b63edaf507c709c3f39db7a1a69c9805ef514eb8057d2ff04b1c63a97f8bac43d3a66221d3d86fb073c0337912b8ea85d95b4b81f8fd7ebf553e482b95
-  data.tar.gz: 7aba8df2a852b468e09c4b70478336eb74f667c189505ba8ef1985d7370c9c5c9df7c18f409d311f0f0ac521721ddacf04841eff22815a44cff1c928f27eed93
+  metadata.gz: 3aaa2ce601f6da71e1d24a0a13bee121abc3c6d52b9120e6795b57e5880cefbb2fae9c24b69f7e6284a54913b293e25c6d3fcbe7e503105e782fd84817e13413
+  data.tar.gz: fed4af90111069f4c39f4ce6ed85b72480aaf6bf10bcf4f06e8701a60f037095638647b423282a7dfe00ae0f1e8c17e94b907368879394b0f664ae06a812a47e

data/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning].
 
 ## [Unreleased]
 
+## [0.2.2] - 2023-08-23
+
+### Fixed
+
+- Ship gem with pre-transpiled files (`lib/.rbnext`). ([@palkan][])
+
 ## [0.2.1] - 2022-05-17
 
 ### Added

data/lib/.rbnext/2.3/paco/context.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "paco/callstack"
+require "paco/index"
+
+module Paco
+  class Context
+    attr_reader :input, :last_pos, :callstack
+    attr_accessor :pos
+
+    def initialize(input, pos: 0, with_callstack: false)
+      @input = input
+      @pos = pos
+      @callstack = Callstack.new if with_callstack
+    end
+
+    def read(n)
+      input[pos, n]
+    end
+
+    def read_all
+      input[pos..-1]
+    end
+
+    def eof?
+      pos >= input.length
+    end
+
+    # @param [Integer] from
+    # @return [Paco::Index]
+    def index(from = nil)
+      Index.calculate(input: input, pos: from || pos)
+    end
+
+    # @param [Paco::Parser] parser
+    def failure_parse(parser)
+      ((((__safe_lvar__ = @callstack) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.failure(pos: pos, parser: parser.desc))
+    end
+
+    # @param [Paco::Parser] parser
+    def start_parse(parser)
+      ((((__safe_lvar__ = @callstack) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.start(pos: pos, parser: parser.desc))
+    end
+
+    # @param [Object] result
+    # @param [Paco::Parser] parser
+    def success_parse(result, parser)
+      ((((__safe_lvar__ = @callstack) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.success(pos: pos, result: result, parser: parser.desc))
+    end
+  end
+end

data/lib/.rbnext/2.3/paco/index.rb

@@ -0,0 +1,15 @@
+module Paco
+  Index = Struct.new(:pos, :line, :column) do
+    # @param [String] input
+    # @param [Integer] pos
+    def self.calculate(input:, pos:)
+      raise ArgumentError, "`pos` must be a non-negative integer" if pos < 0
+      raise ArgumentError, "`pos` is grater then input length" if pos > input.length
+
+      lines = input[0..pos].lines
+      line = lines.empty? ? 1 : lines.length
+      column = ((((__safe_lvar__ = lines.last) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.length) || 1
+      new(pos, line, column)
+    end
+  end
+end

data/lib/.rbnext/2.3/paco/parse_error.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Paco
+  class Error < StandardError; end
+
+  class ParseError < Error
+    attr_reader :ctx, :pos, :expected
+
+    # @param [Paco::Context] ctx
+    def initialize(ctx, expected)
+      @ctx = ctx
+      @pos = ctx.pos
+      @expected = expected
+    end
+
+    def callstack
+      ctx.callstack
+    end
+
+    def message
+      index = ctx.index(pos)
+      <<-MSG
+\nParsing error
+line #{index.line}, column #{index.column}:
+unexpected #{ctx.eof? ? "end of file" : ctx.input[pos].inspect}
+expecting #{expected}
+      MSG
+    end
+  end
+end

data/lib/.rbnext/2.5/paco/combinators.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "paco/combinators/char"
+require "paco/memoizer"
+
+module Paco
+  module Combinators
+    include Char
+    extend Char
+
+    module_function
+
+    # Returns a parser that runs the passed `parser` without consuming the input, and
+    # returns `null` if the passed `parser` _does not match_ the input. Fails otherwise.
+    # @param [Paco::Parser] parser
+    # @return [Paco::Parser]
+    def not_followed_by(parser)
+      Parser.new("not #{parser.desc}") do |ctx, pars|
+        start_pos = ctx.pos
+        begin
+          parser._parse(ctx)
+        rescue ParseError
+          nil
+        else
+          pars.failure(ctx)
+        ensure
+          ctx.pos = start_pos
+        end
+      end
+    end
+
+    # Returns a parser that doesn't consume any input and always returns `result`.
+    # @return [Paco::Parser]
+    def succeed(result)
+      Parser.new("succeed(#{result})") { result }
+    end
+
+    # Returns a parser that doesn't consume any input and always fails with passed `message`.
+    # @param [String] message
+    # @return [Paco::Parser]
+    def failed(message)
+      Parser.new(message) { |ctx, parser| parser.failure(ctx) }
+    end
+
+    # Returns a parser that runs the passed `parser` without consuming the input,
+    # and returns empty string.
+    # @param [Paco::Parser] parser
+    # @return [Paco::Parser]
+    def lookahead(parser)
+      Parser.new("lookahead(#{parser.desc})") do |ctx|
+        start_pos = ctx.pos
+        parser._parse(ctx)
+        ctx.pos = start_pos
+        ""
+      end
+    end
+
+    # Accepts any number of parsers, and returns a parser that returns the value of the first parser that succeeds, backtracking in between.
+    # @param [Array<Paco::Parser>] parsers
+    # @return [Paco::Parser]
+    def alt(*parsers)
+      raise ArgumentError, "no parsers specified" if parsers.empty?
+
+      Parser.new("alt(#{parsers.map(&:desc).join(", ")})") do |ctx|
+        result = nil
+        last_error = nil
+        start_pos = ctx.pos
+        parsers.each do |pars|
+          begin;break result = {value: pars._parse(ctx)}
+        rescue ParseError => e
+          last_error = e
+          ctx.pos = start_pos
+          next;end
+        end
+        raise last_error unless result
+        result[:value]
+      end
+    end
+
+    # Accepts one or more parsers, and returns a parser that expects them
+    # to match in order, returns an array of all their results.
+    # If `block` specified, passes results of the `parses` as an arguments
+    # to a `block`, and at the end returns its result.
+    # @param [Array<Paco::Parser>] parsers
+    # @return [Paco::Parser]
+    def seq(*parsers)
+      raise ArgumentError, "no parsers specified" if parsers.empty?
+
+      result = Parser.new("seq(#{parsers.map(&:desc).join(", ")})") do |ctx|
+        start_pos = ctx.pos
+        begin
+          parsers.map { |parser| parser._parse(ctx) }
+        rescue ParseError => e
+          ctx.pos = start_pos
+          raise e
+        end
+      end
+      return result unless block_given?
+
+      result.fmap { |results| yield(*results) }
+    end
+
+    # Accepts a block that returns a parser, which is evaluated the first time the parser is used.
+    # This is useful for referencing parsers that haven't yet been defined, and for implementing recursive parsers.
+    # @return [Paco::Parser]
+    def lazy(desc = "", &block)
+      Parser.new(desc) { |ctx| block.call._parse(ctx) }
+    end
+
+    # Returns a parser that expects zero or more matches for `parser`,
+    # separated by the parser `separator`. Returns an array of `parser` results.
+    # @param [Paco::Parser] parser
+    # @param [Paco::Parser] separator
+    # @return [Paco::Parser]
+    def sep_by(parser, separator)
+      alt(sep_by!(parser, separator), succeed([]))
+        .with_desc("sep_by(#{parser.desc}, #{separator.desc})")
+    end
+
+    # Returns a parser that expects one or more matches for `parser`,
+    # separated by the parser `separator`. Returns an array of `parser` results.
+    # @param [Paco::Parser] parser
+    # @param [Paco::Parser] separator
+    # @return [Paco::Parser]
+    def sep_by!(parser, separator)
+      seq(parser, many(separator.next(parser))) { |first, arr| [first] + arr }
+        .with_desc("sep_by!(#{parser.desc}, #{separator.desc})")
+    end
+    alias_method :sep_by_1, :sep_by!
+
+    # Expects the parser `before` before `parser` and `after` after `parser. Returns the result of the parser.
+    # @param [Paco::Parser] before
+    # @param [Paco::Parser] after
+    # @param [Paco::Parser] parser
+    # @return [Paco::Parser]
+    def wrap(before, after, parser)
+      before.next(parser).skip(after)
+    end
+
+    # Expects `parser` zero or more times, and returns an array of the results.
+    # @param [Paco::Parser] parser
+    # @return [Paco::Parser]
+    def many(parser)
+      Parser.new("many(#{parser.desc})") do |ctx|
+        results = []
+        loop do
+          begin;results << parser._parse(ctx)
+        rescue ParseError
+          break;end
+        end
+        results
+      end
+    end
+
+    # Returns parser that returns result of the passed `parser` or nil if `parser` fails.
+    # @param [Paco::Parser] parser
+    # @return [Paco::Parser]
+    def optional(parser)
+      alt(parser, succeed(nil))
+    end
+
+    # Returns parser that returns `Paco::Index` representing
+    # the current offset into the parse without consuming the input.
+    # @return [Paco::Parser]
+    def index
+      Parser.new { |ctx| ctx.index }
+    end
+
+    # Helper used for memoization
+    def memoize(&block)
+      Memoizer.memoize(block.source_location, &block)
+    end
+  end
+end

data/lib/.rbnext/2.5/paco/parser.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require "paco/combinators"
+
+module Paco
+  class Parser
+    attr_reader :desc
+
+    # @param [String] desc
+    def initialize(desc = "", &block)
+      @desc = desc
+      @block = block
+    end
+
+    # @param [String] desc
+    # @return [Paco::Parser]
+    def with_desc(desc)
+      @desc = desc
+      self
+    end
+
+    # @param [String, Paco::Context] input
+    # @param [true, false] with_callstack
+    def parse(input, with_callstack: false)
+      ctx = input.is_a?(Context) ? input : Context.new(input, with_callstack: with_callstack)
+      skip(Paco::Combinators.eof)._parse(ctx)
+    end
+
+    # @param [Paco::Context] ctx
+    def _parse(ctx)
+      ctx.start_parse(self)
+      res = @block.call(ctx, self)
+      ctx.success_parse(res, self)
+      res
+    end
+
+    # Raises ParseError
+    # @param [Paco::Context] ctx
+    # @raise [Paco::ParseError]
+    def failure(ctx)
+      ctx.failure_parse(self)
+      raise ParseError.new(ctx, desc), "", []
+    end
+
+    # Returns a new parser which tries `parser`, and if it fails uses `other`.
+    # @param [Paco::Parser] other
+    # @return [Paco::Parser]
+    def or(other)
+      Parser.new("or(#{desc}, #{other.desc})") do |ctx|
+        begin;_parse(ctx)
+      rescue ParseError
+        other._parse(ctx);end
+      end
+    end
+    alias_method :|, :or
+
+    # Expects `other` parser to follow `parser`, but returns only the value of `parser`.
+    # @param [Poco::Parser] other
+    # @return [Paco::Parser]
+    def skip(other)
+      Paco::Combinators.seq(self, other).fmap { |results| results[0] }.with_desc("#{desc}.skip(#{other.desc})")
+    end
+    alias_method :<, :skip
+
+    # Expects `other` parser to follow `parser`, but returns only the value of `other` parser.
+    # @param [Poco::Parser] other
+    # @return [Paco::Parser]
+    def next(other)
+      Paco::Combinators.seq(self, other).fmap { |results| results[1] }
+        .with_desc("#{desc}.next(#{other.desc})")
+    end
+    alias_method :>, :next
+
+    # Transforms the output of `parser` with the given block.
+    # @return [Paco::Parser]
+    def fmap(&block)
+      Parser.new("#{desc}.fmap") do |ctx|
+        block.call(_parse(ctx))
+      end
+    end
+
+    # Returns a new parser which tries `parser`, and on success
+    # calls the `block` with the result of the parse, which is expected
+    # to return another parser, which will be tried next. This allows you
+    # to dynamically decide how to continue the parse, which is impossible
+    # with the other Paco::Combinators.
+    # @return [Paco::Parser]
+    def bind(&block)
+      Parser.new("#{desc}.bind") do |ctx|
+        block.call(_parse(ctx))._parse(ctx)
+      end
+    end
+    alias_method :chain, :bind
+
+    # Expects `parser` zero or more times, and returns an array of the results.
+    # @return [Paco::Parser]
+    def many
+      Paco::Combinators.many(self)
+    end
+
+    # Returns a new parser with the same behavior, but which returns passed `value`.
+    # @return [Paco::Parser]
+    def result(value)
+      fmap { value }
+    end
+
+    # Returns a new parser which tries `parser` and, if it fails, returns `value` without consuming any input.
+    # @return [Paco::Parser]
+    def fallback(value)
+      self.or(Paco::Combinators.succeed(value))
+    end
+
+    # Expects `other` parser before and after `parser`, and returns the result of the parser.
+    # @param [Paco::Parser] other
+    # @return [Paco::Parser]
+    def trim(other)
+      other.next(self).skip(other)
+    end
+
+    # Expects the parser `before` before `parser` and `after` after `parser. Returns the result of the parser.
+    # @param [Paco::Parser] before
+    # @param [Paco::Parser] after
+    # @return [Paco::Parser]
+    def wrap(before, after)
+      Paco::Combinators.wrap(before, after, self)
+    end
+
+    # Returns a parser that runs passed `other` parser without consuming the input, and
+    # returns result of the `parser` if the passed one _does not match_ the input. Fails otherwise.
+    # @param [Paco::Parser] other
+    # @return [Paco::Parser]
+    def not_followed_by(other)
+      skip(Paco::Combinators.not_followed_by(other))
+    end
+
+    # Returns a parser that runs `parser` and concatenate it results with the `separator`.
+    # @param [String] separator
+    # @return [Paco::Parser]
+    def join(separator = "")
+      fmap { |result| result.join(separator) }
+    end
+
+    # Returns a parser that runs `parser` between `min` and `max` times,
+    # and returns an array of the results. When `max` is not specified, `max` = `min`.
+    # @param [Integer] min
+    # @param [Integer] max
+    # @return [Paco::Parser]
+    def times(min, max = nil)
+      max ||= min
+      if min < 0 || max < min
+        raise ArgumentError, "invalid attributes: min `#{min}`, max `#{max}`"
+      end
+
+      Parser.new("#{desc}.times(#{min}, #{max})") do |ctx|
+        results = min.times.map { _parse(ctx) }
+        (max - min).times.each do
+          begin;results << _parse(ctx)
+        rescue ParseError
+          break;end
+        end
+
+        results
+      end
+    end
+
+    # Returns a parser that runs `parser` at least `num` times,
+    # and returns an array of the results.
+    def at_least(num)
+      Paco::Combinators.seq(times(num), many) do |head, rest|
+        head + rest
+      end
+    end
+
+    # Returns a parser that runs `parser` at most `num` times,
+    # and returns an array of the results.
+    def at_most(num)
+      times(0, num)
+    end
+  end
+end

data/lib/.rbnext/2.5/paco/rspec/parse_matcher.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+RSpec::Matchers.define(:parse) do |input|
+  chain :as do |expected_output = nil, &block|
+    @expected = expected_output
+    @block = block
+  end
+
+  chain :fully do
+    @expected = input
+  end
+
+  match do |parser|
+    begin;@result = parser.parse(input)
+    return @block.call(@result) if @block
+    return @expected == @result if defined?(@expected)
+
+    true
+  rescue Paco::ParseError => e
+    @error_message = e.message
+    false;end
+  end
+
+  failure_message do |subject|
+    msg = "expected output of parsing #{input.inspect} with #{subject.inspect} to"
+    was = (@result ? "was #{@result.inspect}" : "raised an error #{@error_message}")
+    return "#{msg} meet block conditions, but it didn't. It #{was}" if @block
+    return "#{msg} equal #{@expected.inspect}, but it #{was}" if defined?(@expected)
+
+    "expected #{subject.inspect} to successfully parse #{input.inspect}, but it #{was}"
+  end
+
+  failure_message_when_negated do |subject|
+    msg = "expected output of parsing #{input.inspect} with #{subject.inspect} not to"
+    return "#{msg} meet block conditions, but it did" if @block
+    return "#{msg} equal #{@expected.inspect}" if defined?(@expected)
+
+    "expected #{subject.inspect} to not parse #{input.inspect}, but it did"
+  end
+
+  description do
+    return "parse #{input.inspect} with block conditions" if @block
+    return "parse #{input.inspect} as #{@expected.inspect}" if defined?(@expected)
+
+    "parse #{input.inspect}"
+  end
+end

data/lib/.rbnext/2.6/paco/context.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "paco/callstack"
+require "paco/index"
+
+module Paco
+  class Context
+    attr_reader :input, :last_pos, :callstack
+    attr_accessor :pos
+
+    def initialize(input, pos: 0, with_callstack: false)
+      @input = input
+      @pos = pos
+      @callstack = Callstack.new if with_callstack
+    end
+
+    def read(n)
+      input[pos, n]
+    end
+
+    def read_all
+      input[pos..-1]
+    end
+
+    def eof?
+      pos >= input.length
+    end
+
+    # @param [Integer] from
+    # @return [Paco::Index]
+    def index(from = nil)
+      Index.calculate(input: input, pos: from || pos)
+    end
+
+    # @param [Paco::Parser] parser
+    def failure_parse(parser)
+      @callstack&.failure(pos: pos, parser: parser.desc)
+    end
+
+    # @param [Paco::Parser] parser
+    def start_parse(parser)
+      @callstack&.start(pos: pos, parser: parser.desc)
+    end
+
+    # @param [Object] result
+    # @param [Paco::Parser] parser
+    def success_parse(result, parser)
+      @callstack&.success(pos: pos, result: result, parser: parser.desc)
+    end
+  end
+end

data/lib/paco/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Paco
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: paco
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Svyatoslav Kryukov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-17 00:00:00.000000000 Z
+date: 2023-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-next-core
@@ -34,6 +34,13 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- lib/.rbnext/2.3/paco/context.rb
+- lib/.rbnext/2.3/paco/index.rb
+- lib/.rbnext/2.3/paco/parse_error.rb
+- lib/.rbnext/2.5/paco/combinators.rb
+- lib/.rbnext/2.5/paco/parser.rb
+- lib/.rbnext/2.5/paco/rspec/parse_matcher.rb
+- lib/.rbnext/2.6/paco/context.rb
 - lib/paco.rb
 - lib/paco/callstack.rb
 - lib/paco/combinators.rb
@@ -70,7 +77,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.4.8
 signing_key:
 specification_version: 4
 summary: Parser combinator library