paco 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 874b690b05bae4b9627aab0da0d248b020de705fbbbc88be1dc6e08afdeb8bc5
+  data.tar.gz: 4d69df9a10c651470acc62b297c0c628ab80afa2f508c3f0588c24e811b14000
+SHA512:
+  metadata.gz: 6c5ed079f9a70a4eb11dc754ed24b59d1b50ee9e5a29baf36ab9f61cb040c6609284f8d4b9d6f3044d1ab26e8617a349b4b3811026c97b87c731d423422576d5
+  data.tar.gz: b1afa018f1646c3421e21d01be36cd052468cb824843dc66dd38cabd92a92aee734470a08fd5b169c5bbdadab196440543e1e14419322079e50cb0b31b82fd49

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog],
+and this project adheres to [Semantic Versioning].
+
+## [Unreleased]
+
+## [0.1.0]
+
+### Added
+
+- Initial implementation. ([@skryukov])
+
+[@skryukov]: https://github.com/skryukov
+
+[Unreleased]: https://github.com/skryukov/paco/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/skryukov/paco/commits/v0.1.0
+
+[Keep a Changelog]: https://keepachangelog.com/en/1.0.0/
+[Semantic Versioning]: https://semver.org/spec/v2.0.0.html

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Svyatoslav Kryukov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,42 @@
+# Paco
+
+Paco is a parser combinator library inspired by Haskell's [Parsec] and [Parsimmon].
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "paco"
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install paco
+
+## Usage
+
+See [API documentation](docs/paco.md), [examples](examples) and [specs](spec).
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/skryukov/paco.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License].
+
+[MIT License]: https://opensource.org/licenses/MIT
+[Parsec]: https://github.com/haskell/parsec
+[Parsimmon]: https://github.com/jneen/parsimmon
+[parsby]: https://github.com/jolmg/parsby

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "paco"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/paco/combinators/char.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Paco
+  module Combinators
+    module Char
+      # Returns a parser that returns a single character if passed block result is truthy:
+      #
+      # @example
+      # lower = Combinators.satisfy do |char|
+      #   char == char.downcase
+      # end
+      #
+      # lower.parse("a") #=> "a"
+      # lower.parse("P") #=> ParseError
+      #
+      # @param [String] desc optional description for the parser
+      # @param [Proc] block proc with one argument – a next char of the input
+      # @return [Paco::Parser]
+      def satisfy(desc = "", &block)
+        Parser.new(desc) do |ctx, parser|
+          parser.failure(ctx) if ctx.eof?
+
+          char = ctx.read(1)
+          parser.failure(ctx) unless block.call(char)
+
+          ctx.pos += 1
+          char
+        end
+      end
+
+      # Returns a parser that looks for a passed `matcher` string and returns its value on success.
+      # @param [String] matcher
+      # @return [Paco::Parser]
+      def string(matcher)
+        Parser.new(matcher) do |ctx, parser|
+          src = ctx.read(matcher.length)
+          parser.failure(ctx) if src != matcher
+
+          ctx.pos += matcher.length
+          src
+        end
+      end
+
+      # Returns a parser that looks for a match to the regexp and returns the entire text matched.
+      # The regexp will always match starting at the current parse location.
+      # When `group` is specified, it returns only the text in the specific regexp match group.
+      # @param [Regexp] regexp
+      # @return [Paco::Parser]
+      def regexp(regexp, group: 0)
+        anchored_regexp = Regexp.new("^(?:#{regexp.source})", regexp.options)
+        Parser.new(regexp.inspect) do |ctx, parser|
+          match = anchored_regexp.match(ctx.read_all)
+          parser.failure(ctx) if match.nil?
+
+          ctx.pos += match[0].length
+          match[group]
+        end
+      end
+
+      # Returns a parser that checks current character against the passed `regexp`
+      # @param [Regexp] regexp
+      # @return [Paco::Parser]
+      def regexp_char(regexp)
+        satisfy(regexp.inspect) { |char| regexp.match?(char) }
+      end
+
+      # Returns a parser that looks for exactly one character from passed
+      # `matcher`, and returns its value on success.
+      # @param [String, Array<String>] matcher
+      # @return [Paco::Parser]
+      def one_of(matcher)
+        satisfy(matcher.to_s) { |char| matcher.include?(char) }
+      end
+
+      # Returns a parser that looks for exactly one character _NOT_ from passed
+      # `matcher`, and returns its value on success.
+      # @param [String, Array<String>] matcher
+      # @return [Paco::Parser]
+      def none_of(matcher)
+        satisfy("not #{matcher}") { |char| !matcher.include?(char) }
+      end
+
+      # Returns a parser that consumes and returns the next character of the input.
+      # @return [Paco::Parser]
+      def any_char
+        memoize { satisfy("any_char") { |ch| ch.length > 0 } }
+      end
+
+      # Returns a parser that consumes and returns the entire remainder of the input.
+      # @return [Paco::Parser]
+      def remainder
+        memoize do
+          Parser.new("remainder of the input") do |ctx, parser|
+            result = ctx.read_all
+            ctx.pos += result.length
+            result
+          end
+        end
+      end
+
+      # Returns a parser that returns a string containing all the next
+      # characters that are truthy for the passed block.
+      # @param [Proc] block proc with one argument – a next char of the input
+      # @return [Paco::Parser]
+      def take_while(&block)
+        satisfy(&block).many.join
+      end
+
+      # Returns a parser that matches end of file and returns nil.
+      # @return [Paco::Parser]
+      def eof
+        memoize do
+          Parser.new("end of file") do |ctx, parser|
+            parser.failure(ctx) unless ctx.eof?
+            nil
+          end
+        end
+      end
+
+      # Returns a parser that checks for the "carriage return" (`\r`) character.
+      # @return [Paco::Parser]
+      def cr
+        memoize { string("\r") }
+      end
+
+      # Returns a parser that checks for the "line feed" (`\n`) character.
+      # @return [Paco::Parser]
+      def lf
+        memoize { string("\n") }
+      end
+
+      # Returns a parser that checks for the "carriage return" character followed by the "line feed" character (`\r\n`).
+      # @return [Paco::Parser]
+      def crlf
+        memoize { string("\r\n") }
+      end
+
+      # Returns a parser that will match any kind of line ending.
+      # @return [Paco::Parser]
+      def newline
+        memoize { alt(crlf, lf, cr) }
+      end
+
+      # Returns a parser that will match any kind of line ending *including* end of file.
+      # @return [Paco::Parser]
+      def end_of_line
+        memoize { alt(newline, eof) }
+      end
+
+      # Alias for `Paco::Combinators.regexp(/[a-z]/i)`.
+      # @return [Paco::Parser]
+      def letter
+        memoize { regexp_char(/[a-z]/i) }
+      end
+
+      # Alias for `Paco::Combinators.regexp(/[a-z]+/i)`.
+      # @return [Paco::Parser]
+      def letters
+        memoize { seq(letter, letter.many).fmap { |x| x.flatten.join } }
+      end
+
+      # Alias for `Paco::Combinators.regexp(/[a-z]*/i)`.
+      # @return [Paco::Parser]
+      def opt_letters
+        memoize { letters | succeed("") }
+      end
+
+      # Alias for `Paco::Combinators.regexp(/[0-9]/)`.
+      # @return [Paco::Parser]
+      def digit
+        memoize { regexp_char(/[0-9]/) }
+      end
+
+      # Alias for `Paco::Combinators.regexp(/[0-9]+/)`.
+      # @return [Paco::Parser]
+      def digits
+        memoize { seq(digit, digit.many).fmap { |x| x.flatten.join } }
+      end
+
+      # Alias for `Paco::Combinators.regexp(/[0-9]*/)`.
+      # @return [Paco::Parser]
+      def opt_digits
+        memoize { digits | succeed("") }
+      end
+
+      # Alias for `Paco::Combinators.regexp(/\s+/)`.
+      # @return [Paco::Parser]
+      def ws
+        memoize { regexp(/\s+/) }
+      end
+
+      # Alias for `Paco::Combinators.regexp(/\s*/)`.
+      # @return [Paco::Parser]
+      def opt_ws
+        memoize { regexp(/\s*/) }
+      end
+
+      # Alias for `parser.trim(Paco::Combinators.opt_ws)`.
+      # @param [Paco::Parser] parser
+      # @return [Paco::Parser]
+      def spaced(parser)
+        parser.trim(opt_ws)
+      end
+    end
+  end
+end

data/lib/paco/combinators.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+require "paco/combinators/char"
+
+module Paco
+  module Combinators
+    def self.extended(base)
+      base.extend MonitorMixin
+      base.extend Char
+    end
+
+    def self.included(base)
+      base.include MonitorMixin
+      base.include Char
+    end
+
+    extend self
+
+    # 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
+          ctx.pos = start_pos
+          nil
+        else
+          pars.failure(ctx)
+        end
+      end
+    end
+
+    # Returns a parser that doesn't consume any input and always returns `result`.
+    # @return [Paco::Parser]
+    def succeed(result)
+      Parser.new { 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 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 do |ctx|
+        result = nil
+        last_error = nil
+        start_pos = ctx.pos
+        parsers.each do |pars|
+          break result = {value: pars._parse(ctx)}
+        rescue ParseError => e
+          last_error = e
+          ctx.pos = start_pos
+          next
+        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.
+    # @param [Array<Paco::Parser>] parsers
+    # @return [Paco::Parser]
+    def seq(*parsers)
+      raise ArgumentError, "no parsers specified" if parsers.empty?
+
+      Parser.new do |ctx|
+        parsers.map { |parser| parser._parse(ctx) }
+      end
+    end
+
+    # Returns a parser that matches all `parsers` sequentially, and passes
+    # their results as an arguments to a `block`, and at the end returns its result.
+    # @param [Array<Paco::Parser>] parsers
+    # @return [Paco::Parser]
+    def seq_map(*parsers, &block)
+      raise ArgumentError, "no parsers specified" if parsers.empty?
+
+      seq(*parsers).fmap do |results|
+        block.call(*results)
+      end
+    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_1(parser, separator), succeed([]))
+    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_1(parser, separator)
+      seq_map(parser, many(separator.next(parser))) do |first, arr|
+        [first] + arr
+      end
+    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
+    # @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 do |ctx|
+        results = []
+        # last_pos = ctx.pos
+        loop do
+          results << parser._parse(ctx)
+          # raise ArgumentError, "smth wrong" if last_pos == ctx.pos
+          # last_pos = ctx.pos
+        rescue ParseError
+          break
+        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
+
+    # Helper used for memoization
+    def memoize(&block)
+      key = block.source_location
+      synchronize do
+        @_paco_memoized ||= {}
+        return @_paco_memoized[key] if @_paco_memoized.key?(key)
+
+        @_paco_memoized[key] = block.call
+      end
+    end
+  end
+end

data/lib/paco/context.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+module Paco
+  class Context
+    attr_reader :input, :last_pos, :pos
+
+    def pos=(np)
+      # TODO: is that needed?
+      @last_pos = @pos
+      @pos = np
+    end
+
+    def initialize(input, pos = 0)
+      @input = input
+      @pos = pos
+    end
+
+    def read(n)
+      input[pos, n]
+    end
+
+    def read_all
+      input[pos..-1]
+    end
+
+    def eof?
+      pos >= input.length
+    end
+
+    def index(from = nil)
+      from ||= pos
+      lines = input[0..from].lines
+
+      {
+        line: lines.length,
+        column: lines[-1]&.length || 0,
+        pos: from
+      }
+    end
+  end
+end

data/lib/paco/parse_error.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module Paco
+  class Error < StandardError; end
+
+  class ParseError < Error
+    # @param [Paco::Context] ctx
+    def initialize(ctx, expected)
+      @ctx = ctx
+      @pos = ctx.pos
+      @expected = expected
+
+      # TODO: make this possible to show every parsing message? or last n?
+      # puts ""
+      # puts "#{ctx.pos}/#{ctx.input.length}: #{ctx.input[ctx.last_pos..ctx.pos]}"
+      # puts "expected: #{expected}"
+      # puts ""
+    end
+
+    def message
+      index = @ctx.index(@pos)
+      <<~MSG
+        Parsing error
+        line #{index[:line]}, column #{index[:column]}:
+        unexpected #{@ctx.input[@pos] || "end of file"}
+        expecting #{@expected}
+      MSG
+    end
+  end
+end

data/lib/paco/parser.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "paco/combinators"
+
+module Paco
+  class Parser
+    attr_reader :desc
+
+    def initialize(desc = "", &block)
+      @desc = desc
+      @block = block
+    end
+
+    def parse(input)
+      ctx = input.is_a?(Context) ? input : Context.new(input)
+      skip(Paco::Combinators.eof)._parse(ctx)
+    end
+
+    def _parse(ctx)
+      @block.call(ctx, self)
+      # TODO: add ability for debugging
+      # puts ""
+      # puts "#{@block.source_location} succeed."
+      # puts "#{ctx.input.length}/#{ctx.pos}: " + ctx.input[ctx.last_pos..ctx.pos].inspect
+      # puts ""
+      # res
+    end
+
+    # Raises ParseError
+    # @param [Paco::Context] ctx
+    # @raise [Paco::ParseError]
+    def failure(ctx)
+      raise ParseError.new(ctx, desc), "", []
+    end
+
+    # Returns a new parser which tries `parser`, and if it fails uses `other`.
+    def or(other)
+      Parser.new do |ctx|
+        _parse(ctx)
+      rescue ParseError
+        other._parse(ctx)
+      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] }
+    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)
+      bind { other }
+    end
+    alias_method :>, :next
+
+    # Transforms the output of `parser` with the given block.
+    # @return [Paco::Parser]
+    def fmap(&block)
+      Parser.new 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 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 do |ctx|
+        results = min.times.map { _parse(ctx) }
+        (max - min).times.each do
+          results << _parse(ctx)
+        rescue ParseError
+          break
+        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_map(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/paco/version.rb

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

data/lib/paco.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "paco/version"
+require "paco/parse_error"
+require "paco/context"
+require "paco/parser"
+require "paco/combinators"
+
+module Paco
+  def self.extended(base)
+    base.extend Combinators
+  end
+
+  def self.included(base)
+    base.include Combinators
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: paco
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Svyatoslav Kryukov
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-12-12 00:00:00.000000000 Z
+dependencies: []
+description: Paco is a parser combinator library.
+email:
+- s.g.kryukov@yandex.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- bin/console
+- bin/setup
+- lib/paco.rb
+- lib/paco/combinators.rb
+- lib/paco/combinators/char.rb
+- lib/paco/context.rb
+- lib/paco/parse_error.rb
+- lib/paco/parser.rb
+- lib/paco/version.rb
+homepage: https://github.com/skryukov/paco
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/skryukov/paco/issues
+  changelog_uri: https://github.com/skryukov/paco/blob/master/CHANGELOG.md
+  documentation_uri: https://github.com/skryukov/paco/blob/master/README.md
+  homepage_uri: https://github.com/skryukov/paco
+  source_code_uri: https://github.com/skryukov/paco
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.15
+signing_key:
+specification_version: 4
+summary: Parser combinator library
+test_files: []