parser_combinator_dsl 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8ebac413cd45e47ff7de3b0b5d4aeb6c98dd265434620206e2ffd5c2d9f910ea
+  data.tar.gz: 9ef20b739416d15763b8a1c9451245a54a509ebd9e0436046a735d3db0200575
+SHA512:
+  metadata.gz: c357783a6d1dd1009f7f3a329f7647764de90378e8ddc671f01d644080336886e950a009388c822772fd8fb05366a1025241966be7930e508dca6dd06878fcac
+  data.tar.gz: 6073c6130917b7eeeb21d597224f4349732e4075454d6634cafcb2248bed3a95c627d687fa4638604158ce3dc62a07ed730e616a799f2c5530609919a358e84c

data/lib/base_parsers.rb

@@ -0,0 +1,203 @@
+require_relative "parser_result"
+
+module BaseParsers
+  def eof
+    Parser.new do |input|
+      if input == "" || input.nil?
+        ParserResult.ok(matched: "", remaining: input)
+      else
+        ParserResult.fail(input)
+      end
+    end
+  end
+
+  def empty
+    Parser.new do |input|
+      ParserResult.ok(matched: "", remaining: input)
+    end
+  end
+
+  def whitespace
+    many0 { anyChar([' '] + %w[\b \f \n \r \t]) }
+  end
+
+  def one(char)
+    Parser.new do |input|
+      if input[0] == char
+        ParserResult.ok(matched: char, remaining: input[1..-1])
+      else
+        ParserResult.fail(input)
+      end
+    end
+  end
+
+  def str(string)
+    Parser.new do |input|
+      if input.start_with?(string)
+        ParserResult.ok(matched: string, remaining: input[string.length..-1])
+      else
+        ParserResult.fail(input)
+      end
+    end
+  end
+
+  def anyLetter
+    anyChar(('a'..'z').to_a + ('A'..'Z').to_a)
+  end
+
+  def anyNumber
+    anyChar ('0'..'9').to_a
+  end
+
+  def many1(&wrapper)
+    Parser.new do |input|
+      matched   = ""
+      remaining = input
+      parser    = wrapper.call
+
+      loop do
+        result = parser.run(remaining)
+        break if remaining.nil? || result.fail?
+        matched   = matched + result.matched
+        remaining = result.remaining
+      end
+
+      ParserResult.new(!matched.empty?, remaining, matched)
+    end
+  end
+
+  def many0(&wrapper)
+    Parser.new do |input|
+      if input.nil? || input == ""
+        ParserResult.ok(matched: "", remaining: input)
+      else
+        many1(&wrapper).run(input)
+      end
+    end
+  end
+
+  def seq(*args)
+    callback = args[-1]
+    parsers  = args[0..(args.length - 2)]
+
+    raise "Seq expects at least a parser and a callback." if callback.nil? || parsers.empty?
+
+    Parser.new do |input|
+      remaining = input
+      matched   = ""
+
+      new_args = parsers.map do |parser|
+        result = parser.run(remaining)
+        return ParserResult.fail(input) unless result.ok?
+        remaining = result.remaining
+        result.matched
+      end
+
+      callback.call(*new_args)
+    end
+  end
+
+  # This is just an alias of lambda in the DSL. See specs for more on this.
+  #
+  def satisfy(&wrapper)
+    Parser.new do |input|
+      wrapper.call(input)
+    end
+  end
+
+  def regex(re)
+    Parser.new do |input|
+      test regex: re, with: input
+    end
+  end
+
+  def match(rule, between:)
+    first, last = between
+    Parser.new do |input|
+      lhs = first.run(input)
+      if lhs.ok?
+        middle = rule.run(lhs.remaining)
+        if middle.ok?
+          rhs = last.run(middle.remaining)
+          if rhs.ok?
+            rhs
+          else
+            ParserResult.fail(input)
+          end
+        else
+          ParserResult.fail(input)
+        end
+      else
+        ParserResult.fail(input)
+      end
+    end
+  end
+
+  def anyChar(chars)
+    Parser.new do |input|
+      first_char = input[0]
+      result     = ParserResult.fail(input)
+
+      chars.each do |char|
+        if first_char == char
+          result = ParserResult.ok(matched: char, remaining: input[1..-1])
+          break
+        end
+      end
+
+      result
+    end
+  end
+
+  def anyCharBut(chars)
+    Parser.new do |input|
+      first_char = input[0]
+      result     = ParserResult.ok(matched: first_char, remaining: input[1..-1])
+
+      chars.each do |char|
+        if first_char == char
+          result = ParserResult.fail(input)
+          break
+        end
+      end
+
+      result
+    end
+  end
+
+  def exactly(n, &wrapper)
+    parser = wrapper.call
+    Parser.new do |input|
+      matched   = ""
+      remaining = input
+      success   = true
+
+      n.to_i.times do
+        result = parser.run(remaining)
+        if result.fail?
+          success = false
+          break
+        end
+        matched   = matched + result.matched
+        remaining = result.remaining
+      end
+
+      if success
+        ParserResult.ok(matched: matched, remaining: remaining)
+      else
+        ParserResult.fail(input)
+      end
+    end
+  end
+
+  private
+
+  # Test against a simple regex, no groups. It would be possible to pass a callback
+  # to the regex, in order to work with groups. #MAYBE #TODO
+  def test(regex:, with:)
+    match = regex.match(with)
+    return ParserResult.fail(with) if match.nil?
+    matched = match[0]
+    ParserResult.ok(matched: matched, remaining: with[matched.length..-1])
+  end
+end

data/lib/combinators.rb

@@ -0,0 +1,112 @@
+# Combinators allow us to "combine" parsers together.
+# For example: run this parser first, if it fails, run this other one
+#              run this parser first, and then run this other parser
+module Combinators
+  # Logical OR.
+  # Usage:
+  #   myParser | otherParser
+  #
+  def |(other)
+    Parser.new do |input|
+      first = run(input)
+      if first.ok?
+        first
+      else
+        other.run(input)
+      end
+    end
+  end
+
+  # Logical AND.
+  # Usage:
+  #   myParser >> otherParser
+  #
+  def >>(other)
+    Parser.new do |input|
+      first = run(input)
+      matched = ""
+      if first.ok?
+        matched = matched + first.matched
+        second = other.run(first.remaining)
+        if second.ok?
+          matched = matched + second.matched
+          ParserResult.ok(matched: matched, remaining: second.remaining)
+        else
+          ParserResult.fail(input)
+        end
+      else
+        first
+      end
+    end
+  end
+
+  # Match this, other is optional
+  def >(other)
+    Parser.new do |input|
+      first = run(input)
+      matched = ""
+      if first.ok?
+        matched = first.matched
+        second  = other.run(first.remaining)
+        if second.ok?
+          matched = matched + second.matched
+          ParserResult.ok(matched: matched, remaining: second.remaining)
+        else
+          first
+        end
+      else
+        ParserResult.fail(input)
+      end
+    end
+  end
+
+  # Match other, this is optional
+  def <(other)
+    Parser.new do |input|
+      first     = run(input)
+      matched   = ""
+      remaining = input
+
+      if first.ok?
+        matched   = first.matched
+        remaining = first.remaining
+      end
+
+      second = other.run(remaining)
+      if second.ok?
+        matched = matched + second.matched
+        ParserResult.ok(matched: matched, remaining: second.remaining)
+      else
+        ParserResult.fail(input)
+      end
+    end
+  end
+
+  # Match this, other is ignored but consumed
+  def >=(other)
+    Parser.new do |input|
+      first = run(input)
+      if first.ok?
+        second  = other.run(first.remaining)
+        if second.ok?
+          ParserResult.ok(matched: first.matched, remaining: second.remaining)
+        else
+          first
+        end
+      else
+        ParserResult.fail(input)
+      end
+    end
+  end
+
+  # Match other, this is ignored but consumed
+  def <=(other)
+    Parser.new do |input|
+      first     = run(input)
+      remaining = input
+      remaining = first.remaining if first.ok?
+      second    = other.run(remaining)
+      second.ok? ? second : ParserResult.fail(input)
+    end
+  end
+end

data/lib/grammar.rb

@@ -0,0 +1,35 @@
+require_relative "base_parsers"
+require_relative "parser"
+
+# This is the main DSL interface. It builds up grammar rules and sets up the
+# DSL.
+#
+class Grammar
+  class << self
+    include BaseParsers
+
+    def build(&block)
+      raise "Must provide a block" unless block_given?
+      @rules = {}
+      instance_eval &block
+    end
+
+    def rule(name, &wrapper)
+      return @rules.fetch(name.to_sym) { raise "Could not find rule: #{name}"} if wrapper.nil?
+      @rules[name.to_sym] = Parser.new { |input| wrapper.call.run(input) }
+    end
+
+    def start(name)
+      @rules[name]
+    end
+
+    # Aliases for DSL
+    def ok(*args)
+      ParserResult.ok(*args)
+    end
+
+    def fail(*args)
+      ParserResult.fail(*args)
+    end
+  end
+end

data/lib/parser.rb

@@ -0,0 +1,15 @@
+require_relative "combinators"
+
+class Parser
+  include Combinators
+  
+  attr_reader :parser
+  def initialize(&block)
+    raise "Invalid argument, must provide a block" unless block_given?
+    @parser = block
+  end
+
+  def run(input)
+    parser.call(input)
+  end
+end

data/lib/parser_combinator_dsl.rb

@@ -0,0 +1 @@
+require 'grammar'

data/lib/parser_result.rb

@@ -0,0 +1,28 @@
+class ParserResult
+  attr_reader :success, :remaining, :matched
+  def initialize(success, remaining, matched)
+    @success   = success
+    @remaining = remaining
+    @matched   = matched
+  end
+
+  def self.ok(matched:, remaining:)
+    ParserResult.new(true, remaining, matched)
+  end
+
+  def self.fail(remaining)
+    ParserResult.new(false, remaining, "")
+  end
+
+  def ok?
+    success
+  end
+
+  def fail?
+    success == false
+  end
+
+  def ==(other)
+    return other.instance_of?(self.class) && other.success == success && other.remaining == remaining && other.matched == matched
+  end
+end

data/test/spec_helpers.rb

@@ -0,0 +1,13 @@
+def assert_parses(parser, with:, remaining:, matched: nil, should_fail: false)
+  result = parser.run(with)
+  assert_equal !should_fail,      result.success
+  assert_equal remaining, result.remaining
+  assert_equal matched,   result.matched unless matched.nil?
+end
+
+def test_parser(parser, with:, should_fail: false)
+  assert_equal !should_fail, parser.run(with).success
+end
+
+# Require everything in `/lib`
+Dir[File.join(File.dirname(__FILE__), '../lib/**/*.rb')].each { |f| require f }

data/test/test_base_parsers.rb

@@ -0,0 +1,186 @@
+require "minitest/autorun"
+require "pry"
+require_relative "spec_helpers"
+
+describe Grammar do
+  describe "Built-in combinators" do
+    it "matches eof" do
+      parser = Grammar.build do
+        rule(:foo) { eof }
+        start(:foo)
+      end
+
+      assert_parses parser, with: "",    remaining: ""
+      assert_parses parser, with: "asd", remaining: "asd", should_fail: true
+    end
+
+    it "matches empty" do
+      parser = Grammar.build do
+        rule(:foo) { empty }
+        start(:foo)
+      end
+
+      assert_parses parser, with: "asd", remaining: "asd"
+      assert_parses parser, with: "",    remaining: ""
+    end
+
+    it "matches whitespace" do
+      parser = Grammar.build do
+        rule(:foo) { whitespace }
+        start(:foo)
+      end
+
+      assert_parses parser, with: "  asd", remaining: "asd"
+      assert_parses parser, with: "",      remaining: ""
+    end
+
+    it "must parse one" do
+      parser = Grammar.build do
+        rule(:one) { one "a" }
+        start(:one)
+      end
+
+      assert_parses parser, with: "abc", remaining: "bc"
+    end
+
+    it "must parse str" do
+      parser = Grammar.build do
+        rule(:foo) { str "foo" }
+        start(:foo)
+      end
+
+      assert_parses parser, with: "foo",    remaining: ""
+      assert_parses parser, with: "foobar", remaining: "bar"
+      assert_parses parser, with: "fobar",  remaining: "fobar", should_fail: true
+    end
+  end
+
+  it "can make rules by hand" do
+    parser = Grammar.build do
+      rule(:foo) { Parser.new { |input| input == "foo" ? ok(matched: "foo", remaining: "") : fail(input) } }
+      start(:foo)
+    end
+
+    assert_parses parser, with: "foo", remaining: ""
+  end
+
+  it "matching rules by hand is the same as satisfy" do
+    parser = Grammar.build do
+      rule(:foo) { satisfy { |input| input == "foo" ? ok(matched: "foo", remaining: "") : fail(input) } }
+      start(:foo)
+    end
+
+    assert_parses parser, with: "foo", remaining: ""
+  end
+
+  it "matches anyLetter" do
+    parser = Grammar.build do
+      rule(:any) { anyLetter }
+      start(:any)
+    end
+
+    assert_parses parser, with: "abzx",  remaining: "bzx"
+    assert_parses parser, with: "Znasd", remaining: "nasd"
+  end
+
+  it "matches anyNumber" do
+    parser = Grammar.build do
+      rule(:any) { anyNumber }
+      start(:any)
+    end
+
+    assert_parses parser, with: "12asd3", remaining: "2asd3"
+    assert_parses parser, with: "32asd",  remaining: "2asd"
+  end
+
+  it "matches many1" do
+    parser = Grammar.build do
+      rule(:word) { many1 { anyLetter } }
+      start(:word)
+    end
+
+    assert_parses parser, with: "asd123", remaining: "123"
+  end
+
+  it "matches many0" do
+    parser = Grammar.build do
+      rule(:word) { many0 { anyLetter } }
+      start(:word)
+    end
+
+    assert_parses parser, with: "",      remaining: ""
+    assert_parses parser, with: "abcde", remaining: ""
+  end
+
+  it "matches using seq" do
+    parser = Grammar.build do
+      rule(:letter)         { many1 { anyLetter } }
+      rule(:number)         { many0 { anyNumber } }
+      rule(:letterOrNumber) { seq rule(:letter), rule(:number), lambda { |letter, number| [letter, number] } }
+      start(:letterOrNumber)
+    end
+
+    assert_equal ["w", "8"], parser.run("w8")
+
+    parser = Grammar.build do
+      rule(:letter)         { many1 { anyLetter } }
+      rule(:letterOrNumber) { seq rule(:letter), anyNumber, lambda { |letter, number| [letter, number] } }
+      start(:letterOrNumber)
+    end
+
+    assert_equal ["w", "8"], parser.run("w8")
+  end
+
+  it "uses regex" do
+    parser = Grammar.build do
+      rule(:foo) { regex /foo/ }
+      start(:foo)
+    end
+
+    assert_parses parser, with: "foo", remaining: ""
+  end
+
+  it "matches between" do
+    parser = Grammar.build do
+      rule(:quote) { one '"' }
+      rule(:foo)   { match (many1 { anyLetter }), between: [rule(:quote), rule(:quote)] }
+    end
+
+    assert_parses parser, with: '"hi"', remaining: ''
+  end
+
+  it "matches anyChar" do
+    parser = Grammar.build do
+      rule(:foo) { anyChar ['a', 'b'] }
+      start(:foo)
+    end
+
+    assert_parses parser, with: "asd", remaining: "sd"
+    assert_parses parser, with: "bsd", remaining: "sd"
+    assert_parses parser, with: "c",   remaining: "c", should_fail: true
+  end
+
+  it "matches anyCharBut" do
+    parser = Grammar.build do
+      rule(:foo) { anyCharBut ['a', 'b'] }
+      start(:foo)
+    end
+
+    assert_parses parser, with: "c", remaining: ""
+    assert_parses parser, with: "d", remaining: ""
+    assert_parses parser, with: "a", remaining: "a", should_fail: true
+    assert_parses parser, with: "b", remaining: "b", should_fail: true
+  end
+
+  it "matches exactly n times" do
+    parser = Grammar.build do
+      rule(:foo) { exactly(4) { anyLetter } }
+      start(:foo)
+    end
+
+    assert_parses parser, with: "abcde", remaining: "e"
+    assert_parses parser, with: "abcd",  remaining: ""
+    assert_parses parser, with: "a",     remaining: "a",  should_fail: true
+    assert_parses parser, with: "abc",   remaining: "abc", should_fail: true
+  end
+end

data/test/test_combinators.rb

@@ -0,0 +1,129 @@
+require "minitest/autorun"
+require "pry"
+require_relative "spec_helpers"
+
+describe Grammar do
+  describe "|" do
+    it "works with a single branch" do
+      parser = Grammar.build do
+        rule(:letter)         { many1 { anyLetter } }
+        rule(:number)         { many0 { anyNumber } }
+        rule(:letterOrNumber) { rule(:letter) | rule(:number) }
+        start(:letterOrNumber)
+      end
+
+      assert_parses parser, with: "n", remaining: "", matched: "n"
+      assert_parses parser, with: "6", remaining: "", matched: "6"
+      assert_parses parser, with: "",  remaining: "", matched: ""
+    end
+
+    it "works with multiple branches" do
+      parser = Grammar.build do
+        rule(:letter)         { many1 { anyLetter } }
+        rule(:number)         { many1 { anyNumber } }
+        rule(:letterOrNumber) { rule(:letter) | rule(:number) | eof }
+        start(:letterOrNumber)
+      end
+
+      assert_parses parser, with: "n", remaining: "", matched: "n"
+      assert_parses parser, with: "6", remaining: "", matched: "6"
+      assert_parses parser, with: "",  remaining: "", matched: ""
+    end
+
+    it "works with satisfy" do
+      parser = Grammar.build do
+        rule(:letter)    { many1 { anyLetter } }
+        rule(:letterOr1) { rule(:letter) | (satisfy { |input| input == "1" ? ok(matched: "1", remaining: "") : fail(input) }) }
+        start(:letterOr1)
+      end
+
+      assert_parses parser, with: "n", remaining: ""
+      assert_parses parser, with: "1", remaining: ""
+    end
+  end
+
+  describe ">>" do
+    it "works with a single branch" do
+      parser = Grammar.build do
+        rule(:letter)          { many1 { anyLetter } }
+        rule(:number)          { many0 { anyNumber } }
+        rule(:letterAndNumber) { rule(:letter) >> rule(:number) }
+        start(:letterAndNumber)
+      end
+
+      assert_parses parser, with: "foo123", remaining: "", matched: "foo123"
+    end
+
+    it "works with multiple branches" do
+      parser = Grammar.build do
+        rule(:letter) { many1 { anyLetter } }
+        rule(:number) { many0 { anyNumber } }
+        rule(:foo)    { rule(:letter) >> rule(:number) >> rule(:letter) }
+        start(:foo)
+      end
+
+      assert_parses parser, with: "foo123asd", remaining: "", matched: "foo123asd"
+      assert_parses parser, with: "foo123",    remaining: "foo123", should_fail: true
+    end
+
+    it "works with rules and satisfies" do
+      parser = Grammar.build do
+        rule(:letter)          { many1 { anyLetter } }
+        rule(:letterAndNumber) { rule(:letter) >> many0 { anyNumber } }
+        start(:letterAndNumber)
+      end
+
+      assert_parses parser, with: "foo123", remaining: ""
+      assert_parses parser, with: "foo",    remaining: ""
+      assert_parses parser, with: "123a",   remaining: "123a", should_fail: true
+    end
+  end
+
+  describe ">" do
+    it "works with a single branch" do
+      parser = Grammar.build do
+        rule(:letter) { many1 { anyLetter } }
+        rule(:foo)    { (rule :letter) > whitespace }
+        start(:foo)
+      end
+
+      assert_parses parser, with: "foo   ", remaining: "", matched: "foo   "
+    end
+  end
+
+  describe "<" do
+    it "works with a single branch" do
+      parser = Grammar.build do
+        rule(:letter) { many1 { anyLetter } }
+        rule(:foo)    { whitespace < (rule :letter) }
+        start(:foo)
+      end
+
+      assert_parses parser, with: "   foo", remaining: "", matched: "   foo"
+    end
+  end
+
+  describe ">=" do
+    it "works with a single branch" do
+      parser = Grammar.build do
+        rule(:letter) { many1 { anyLetter } }
+        rule(:foo)    { (rule :letter) >= whitespace }
+        start(:foo)
+      end
+
+      assert_parses parser, with: "foo   ", remaining: "", matched: "foo"
+    end
+  end
+
+  describe "<=" do
+    it "matches second, first is ignored but consumed" do
+      parser = Grammar.build do
+        rule(:letter) { many1 { anyLetter } }
+        rule(:foo)    { whitespace <= (rule :letter) }
+        start(:foo)
+      end
+
+      assert_parses parser, with: "   foo", remaining: "", matched: "foo"
+    end
+  end
+end

data/test/test_json_demo.rb

@@ -0,0 +1,78 @@
+require "minitest/autorun"
+require "pry"
+require_relative "spec_helpers"
+
+# Build a grammar parsing JSON.
+describe Grammar do
+  it "parses JSON" do
+    parser = Grammar.build do
+      # =======================================================================
+      # Here `>` means right hand size is optional. `<` means left size is
+      # optional.
+      # You can think of `>` and `<` as an open duck mouth, the duck eats the
+      # mandatory part, ignores the other. #PrimarySchoolHacks
+      #
+      # `>>` means "and then" and `|` means "or else try this".
+      #
+      # Something similar happens with `>=` and `<=`, see `README.md` for more
+      # info on binary combinators.
+      # =======================================================================
+
+      # Simple stuff
+      rule(:bopen)       { (one "{") > whitespace }
+      rule(:bclose)      { whitespace < (one "}") }
+      rule(:semicolon)   { whitespace < (one ":") > whitespace }
+      rule(:comma)       { whitespace < (one ",") > whitespace }
+      rule(:quote)       { one '"' }
+      rule(:true)        { str "true" }
+      rule(:false)       { str "false" }
+      rule(:null)        { str "null" }
+
+      # string
+      rule(:hexdigit)           { anyChar %w[0 1 2 3 4 5 6 7 8 9 a b c d e f] }
+      rule(:hexdigits)          { (one "u") >> (exactly(4) { (rule :hexdigit) }) }
+      rule(:any_escaped_char)   { (one "\\") >> ((anyChar %w[" \\ / b f n r t]) | (rule :hexdigits)) }
+      rule(:any_unescaped_char) { (anyCharBut %w[" \\]) }
+      rule(:string_char)        { (rule :any_unescaped_char) | (rule :any_escaped_char) }
+      rule(:string)             { match (many0 { (rule :string_char) }), between: [(rule :quote), (rule :quote)] }
+
+      # number
+      rule(:decimal)              { (one '.') >> many1 { anyNumber } }
+      rule(:cientific)            { (anyChar %w[e E]) >> (anyChar %w[+ -]) >> many1 { anyNumber } }
+      rule(:decimal_or_cientific) { (rule :decimal) > (rule :cientific) }
+      rule(:positive_number)      { ((one "0") | many1 { anyNumber }) > (rule :decimal_or_cientific) }
+      rule(:number)               { (one "-") < (rule :positive_number) }
+
+      # array
+      rule(:array_body) { (rule :value_group) | empty }
+      rule(:array)      { match (rule :array_body), between: [(one "["), (one "]")] }
+
+      # other stuff
+      rule(:value_group) { ((rule :value) >> (rule :comma) >> (rule :value_group)) | (rule :value)  }
+      rule(:value)       { (rule :string) | (rule :number) | (rule :object) | (rule :array) | (rule :true) | (rule :false) | (rule :null) }
+
+      rule(:pair)        { (rule :string) >> (rule :semicolon) >> (rule :value) }
+      rule(:pair_group)  { ((rule :pair) >> (rule :comma) >> (rule :pair_group)) | (rule :pair) }
+      rule(:pair_body)   { (rule :pair_group) | empty }
+      rule(:object)      { match (rule :pair_body), between: [(rule :bopen), (rule :bclose)] }
+
+      # The last rule is always the starting rule, but let's make things clear
+      start(:object)
+    end
+
+    test_parser parser, with: '{}'
+    test_parser parser, with: '{ "foo": 123 }'
+    test_parser parser, with: '{ "foo": 0.321 }'
+    test_parser parser, with: '{ "foo": 1.5 }'
+    test_parser parser, with: '{ "foo": 1.5e-5 }'
+    test_parser parser, with: '{ "foo": false,"b\\nar" : true }'
+    test_parser parser, with: '{ "foo": { "bar": "baz\\u1235" } }'
+    test_parser parser, with: '{ "foo": [] }'
+    test_parser parser, with: '{ "foo": [1] }'
+    test_parser parser, with: '{ "foo": [1, 2, 3, 4] }'
+    # Some error cases
+    test_parser parser, with: '{ "foo": { "bar": "baz\\u125" } }', should_fail: true
+    test_parser parser, with: '{ "foo": [1, 2, 3, 4,] }',          should_fail: true
+    test_parser parser, with: '{ "foo": 123, }',                   should_fail: true
+  end
+end

data/test/test_tutorial.rb

@@ -0,0 +1,31 @@
+require "minitest/autorun"
+require "pry"
+require_relative "spec_helpers"
+
+# Build a grammar parsing JSON.
+describe Grammar do
+  it "step 1" do
+    parser = Grammar.build do
+      rule(:assign) { many1 { anyLetter } >> (str " = ") >> anyNumber }
+
+      start(:assign)
+    end
+
+    parser.run("foo = 1").ok?.must_equal true
+    parser.run("bar = 3").ok?.must_equal true
+    parser.run("baz = 9").ok?.must_equal true
+  end
+
+  it "step 2" do
+    parser = Grammar.build do
+      rule(:equals) { whitespace < (one "=") > whitespace }
+      rule(:assign) { many1 { anyLetter } >> (rule :equals) >> anyNumber }
+
+      start(:assign)
+    end
+
+    parser.run("foo = 1").ok?.must_equal true
+    parser.run("bar =3").ok?.must_equal  true
+    parser.run("baz= 9").ok?.must_equal  true
+  end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: parser_combinator_dsl
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Federico Ramirez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-20 00:00:00.000000000 Z
+dependencies: []
+description: "\n\tThis library provides a DSL which you can use to easily generate
+  parsers in Ruby.\n\n\tAt it's core, it's a parser combinator library, but you don't
+  need to worry about that. You build more complex expression based on simple ones,
+  and match any formal language you want.\n\t"
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/base_parsers.rb
+- lib/combinators.rb
+- lib/grammar.rb
+- lib/parser.rb
+- lib/parser_combinator_dsl.rb
+- lib/parser_result.rb
+- test/spec_helpers.rb
+- test/test_base_parsers.rb
+- test/test_combinators.rb
+- test/test_json_demo.rb
+- test/test_tutorial.rb
+homepage: https://github.com/moddx/parser-combinator
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: A parser combinator in Ruby, with a pretty DSL
+test_files: []