raabro 0.9.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+
+Copyright (c) 2015-2015, John Mettraux, jmettraux@gmail.com
+
+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,11 @@
+
+# raabro
+
+A very dumb PEG parser library.
+
+Son to [aabro](https://github.com/flon-io/aabro), grandson to [neg](https://github.com/jmettraux/neg).
+
+## LICENSE
+
+MIT, see [LICENSE.txt](LICENSE.txt)
+

data/Rakefile

@@ -0,0 +1,68 @@
+
+require 'rubygems'
+
+require 'rake'
+require 'rake/clean'
+require 'rdoc/task'
+
+
+#
+# clean
+
+CLEAN.include('pkg', 'rdoc')
+
+
+#
+# test / spec
+
+#task :spec => :check_dependencies do
+task :spec do
+  exec 'rspec spec/'
+end
+task :test => :spec
+
+task :default => :spec
+
+
+#
+# gem
+
+GEMSPEC_FILE = Dir['*.gemspec'].first
+GEMSPEC = eval(File.read(GEMSPEC_FILE))
+GEMSPEC.validate
+
+
+desc %{
+  builds the gem and places it in pkg/
+}
+task :build do
+
+  sh "gem build #{GEMSPEC_FILE}"
+  sh "mkdir -p pkg"
+  sh "mv #{GEMSPEC.name}-#{GEMSPEC.version}.gem pkg/"
+end
+
+desc %{
+  builds the gem and pushes it to rubygems.org
+}
+task :push => :build do
+
+  sh "gem push pkg/#{GEMSPEC.name}-#{GEMSPEC.version}.gem"
+end
+
+
+#
+# rdoc
+#
+# make sure to have rdoc 2.5.x to run that
+
+Rake::RDocTask.new do |rd|
+
+  rd.main = 'README.txt'
+  rd.rdoc_dir = "rdoc/#{GEMSPEC.name}"
+
+  rd.rdoc_files.include('README.rdoc', 'CHANGELOG.txt', 'lib/**/*.rb')
+
+  rd.title = "#{GEMSPEC.name} #{GEMSPEC.version}"
+end
+

data/lib/raabro.rb

@@ -0,0 +1,194 @@
+
+#--
+# Copyright (c) 2015-2015, John Mettraux, jmettraux@gmail.com
+#
+# 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.
+#
+# Made in Japan.
+#++
+
+
+module Raabro
+
+  VERSION = '0.9.0'
+
+  class Input
+
+    attr_accessor :string, :offset
+    attr_reader :options
+
+    def initialize(string, options={})
+
+      @string = string
+      @offset = 0
+      @options = options
+    end
+
+    def match(str_or_regex)
+
+      if str_or_regex.is_a?(Regexp)
+        m = @string[@offset..-1].match(str_or_regex)
+        m ? m[0].length : false
+      else # String or whatever responds to #to_s
+        s = str_or_regex.to_s
+        l = s.length
+        @string[@offset, l] == s ? l : false
+      end
+    end
+  end
+
+  class Tree
+
+    attr_accessor :name, :input
+    attr_accessor :result # ((-1 error,)) 0 nomatch, 1 success
+    attr_accessor :offset, :length
+    attr_accessor :parter, :children
+
+    def initialize(name, parter, input)
+
+      @result = 0
+      @name = name
+      @parter = parter
+      @input = input
+      @offset = input.offset
+      @length = 0
+      @children = []
+    end
+
+    def to_a(opts={})
+
+      cn =
+        opts[:leaves] && (@result == 1) && @children.empty? ?
+        @input.string[@offset, @length] :
+        @children.collect { |e| e.to_a(opts) }
+
+      [ @name, @result, @offset, @length, @note, @parter, cn ]
+    end
+  end
+
+  def self.match(name, input, parter, regex_or_string)
+
+    r = Tree.new(name, parter, input)
+
+    if l = input.match(regex_or_string)
+      r.result = 1
+      r.length = l
+      input.offset += l
+    end
+
+    r
+  end
+
+  def self.str(name, input, string)
+
+    match(name, input, :str, string)
+  end
+
+  def self.rex(name, input, regex_or_string)
+
+    match(name, input, :rex, Regexp.new(regex_or_string))
+  end
+
+  def self.narrow(parser)
+
+    return parser if parser.is_a?(Method)
+    return method(parser) if parser.is_a?(Symbol)
+
+    k, m = parser.to_s.split('.')
+    k, m = [ Object, k ] unless m
+
+    Kernel.const_get(k).method(m)
+  end
+
+  def self.parse(parser, input)
+
+    narrow(parser).call(input)
+  end
+
+  def self.seq(name, input, *parsers)
+
+    r = Tree.new(name, :seq, input)
+
+    start = input.offset
+    c = nil
+
+    parsers.each do |pa|
+      c = parse(pa, input)
+      r.children << c
+      break if c.result != 1
+    end
+
+    if c && c.result == 1
+      r.result = 1
+      r.length = input.offset - start
+    else
+      input.offset = start
+    end
+
+    r
+  end
+
+  def self.alt(name, input, *parsers)
+
+    r = Tree.new(name, :alt, input)
+
+    c = nil
+
+    parsers.each do |pa|
+      c = parse(pa, input)
+      r.children << c
+      break if c.result == 1
+    end
+
+    if c && c.result == 1
+      r.result = 1
+      r.length = c.length
+    end
+
+    r
+  end
+
+  def self.rep(name, input, parser, min, max=0)
+
+    min = 0 if min == nil || min < 0
+    max = nil if max.nil? || max < 1
+
+    r = Tree.new(name, :rep, input)
+    start = input.offset
+    count = 0
+
+    loop do
+      c = parse(parser, input)
+      r.children << c
+      break if c.result != 1
+      count += 1
+      break if max && count == max
+    end
+
+    if count >= min && (max == nil || count <= max)
+      r.result = 1
+      r.length = input.offset - start
+    else
+      input.offset = start
+    end
+
+    r
+  end
+end
+

data/raabro.gemspec

@@ -0,0 +1,36 @@
+
+Gem::Specification.new do |s|
+
+  s.name = 'raabro'
+
+  s.version = File.read(
+    File.expand_path('../lib/raabro.rb', __FILE__)
+  ).match(/ VERSION *= *['"]([^'"]+)/)[1]
+
+  s.platform = Gem::Platform::RUBY
+  s.authors = [ 'John Mettraux' ]
+  s.email = [ 'jmettraux@gmail.com' ]
+  s.homepage = 'http://github.com/jmettraux/rufus-scheduler'
+  s.rubyforge_project = 'rufus'
+  s.license = 'MIT'
+  s.summary = 'a very dumb PEG parser library'
+
+  s.description = %{
+a very dumb PEG parser library
+  }.strip
+
+  #s.files = `git ls-files`.split("\n")
+  s.files = Dir[
+    'Rakefile',
+    'lib/**/*.rb', 'spec/**/*.rb', 'test/**/*.rb',
+    '*.gemspec', '*.txt', '*.rdoc', '*.md'
+  ]
+
+  #s.add_runtime_dependency 'tzinfo'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec', '>= 2.13.0'
+
+  s.require_path = 'lib'
+end
+

data/spec/alt_spec.rb

@@ -0,0 +1,61 @@
+
+#
+# specifying raabro
+#
+# Sun Sep 20 07:31:53 JST 2015
+#
+
+require 'spec_helper'
+
+
+describe Raabro do
+
+  describe '.alt' do
+
+    before :each do
+
+      @input = Raabro::Input.new('tato')
+    end
+
+    it "returns a tree with result == 0 in case of failure" do
+
+      @input.string = 'tutu'
+
+      t = Raabro.alt(nil, @input, :ta, :to)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ nil, 0, 0, 0, nil, :alt, [
+          [ nil, 0, 0, 0, nil, :str, [] ],
+          [ nil, 0, 0, 0, nil, :str, [] ]
+        ] ]
+      )
+      expect(@input.offset).to eq(0)
+    end
+
+    it "succeeds (1st alternative)" do
+
+      t = Raabro.alt(nil, @input, :ta, :to)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ nil, 1, 0, 2, nil, :alt, [
+          [ nil, 1, 0, 2, nil, :str, 'ta' ]
+        ] ]
+      )
+      expect(@input.offset).to eq(2)
+    end
+
+    it "succeeds (2nd alternative)" do
+
+      t = Raabro.alt(nil, @input, :to, :ta)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ nil, 1, 0, 2, nil, :alt, [
+          [ nil, 0, 0, 0, nil, :str, [] ],
+          [ nil, 1, 0, 2, nil, :str, 'ta' ]
+        ] ]
+      )
+      expect(@input.offset).to eq(2)
+    end
+  end
+end
+

data/spec/rep_spec.rb

@@ -0,0 +1,82 @@
+
+#
+# specifying raabro
+#
+# Sun Sep 20 09:36:16 JST 2015
+#
+
+require 'spec_helper'
+
+
+describe Raabro do
+
+  before :each do
+
+    @input = Raabro::Input.new('toto')
+  end
+
+  describe '.rep' do
+
+    it 'returns a tree with result == 0 in case of failure' do
+
+      t = Raabro.rep(:x, @input, :to, 3, 4)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ :x, 0, 0, 0, nil, :rep, [
+          [ nil, 1, 0, 2, nil, :str, 'to' ],
+          [ nil, 1, 2, 2, nil, :str, 'to' ],
+          [ nil, 0, 4, 0, nil, :str, [] ]
+        ] ]
+      )
+      expect(@input.offset).to eq(0)
+    end
+
+    it "fails (min not reached)" do
+
+      @input.string = 'toto'
+
+      t = Raabro.rep(:x, @input, :to, 3)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ :x, 0, 0, 0, nil, :rep, [
+          [ nil, 1, 0, 2, nil, :str, 'to' ],
+          [ nil, 1, 2, 2, nil, :str, 'to' ],
+          [ nil, 0, 4, 0, nil, :str, [] ]
+        ] ]
+      )
+      expect(@input.offset).to eq(0)
+    end
+
+    it "succeeds (max set)" do
+
+      @input.string = 'tototo'
+
+      t = Raabro.rep(:x, @input, :to, 1, 2)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ :x, 1, 0, 4, nil, :rep, [
+          [ nil, 1, 0, 2, nil, :str, 'to' ],
+          [ nil, 1, 2, 2, nil, :str, 'to' ]
+        ] ]
+      )
+      expect(@input.offset).to eq(4)
+    end
+
+    it "succeeds (max not set)" do
+
+      @input.string = 'toto'
+
+      t = Raabro.rep(:x, @input, :to, 1)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ :x, 1, 0, 4, nil, :rep, [
+          [ nil, 1, 0, 2, nil, :str, 'to' ],
+          [ nil, 1, 2, 2, nil, :str, 'to' ],
+          [ nil, 0, 4, 0, nil, :str, [] ]
+        ] ]
+      )
+      expect(@input.offset).to eq(4)
+    end
+  end
+end
+

data/spec/rex_spec.rb

@@ -0,0 +1,41 @@
+
+#
+# specifying raabro
+#
+# Sun Sep 20 07:12:35 JST 2015
+#
+
+require 'spec_helper'
+
+
+describe Raabro do
+
+  before :each do
+
+    @input = Raabro::Input.new('toto')
+  end
+
+  describe '.rex' do
+
+    it 'returns a tree with result == 0 in case of failure' do
+
+      t = Raabro.rex(nil, @input, /t[ua]/)
+
+      expect(t.to_a).to eq(
+        [ nil, 0, 0, 0, nil, :rex, [] ]
+      )
+      expect(@input.offset).to eq(0)
+    end
+
+    it "returns a tree with result == 1 in case of success" do
+
+      t = Raabro.rex(nil, @input, /(to)+/)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ nil, 1, 0, 4, nil, :rex, 'toto' ]
+      )
+      expect(@input.offset).to eq(4)
+    end
+  end
+end
+

data/spec/seq_spec.rb

@@ -0,0 +1,314 @@
+
+#
+# specifying raabro
+#
+# Sun Sep 20 06:11:54 JST 2015
+#
+
+require 'spec_helper'
+
+
+describe Raabro do
+
+  describe '.seq' do
+
+    before :each do
+
+      @input = Raabro::Input.new('tato')
+    end
+
+    it "returns a tree with result == 0 in case of failure" do
+
+      t = Raabro.seq(nil, @input, :to, :ta)
+
+      expect(t.to_a).to eq(
+        [ nil, 0, 0, 0, nil, :seq, [
+          [ nil, 0, 0, 0, nil, :str, [] ]
+        ] ]
+      )
+      expect(@input.offset).to eq(0)
+    end
+
+    it "returns a tree with result == 0 in case of failure (at 2nd step)" do
+
+      t = Raabro.seq(nil, @input, :ta, :ta)
+
+      expect(
+        t.to_a(:leaves => true)
+      ).to eq(
+        [ nil, 0, 0, 0, nil, :seq, [
+          [ nil, 1, 0, 2, nil, :str, 'ta' ],
+          [ nil, 0, 2, 0, nil, :str, [] ]
+        ] ]
+      )
+      expect(@input.offset).to eq(0)
+    end
+
+    it "returns a tree with result == 1 in case of success" do
+
+      t = Raabro.seq(nil, @input, :ta, :to)
+
+      expect(
+        t.to_a(:leaves => true)
+      ).to eq(
+        [ nil, 1, 0, 4, nil, :seq, [
+          [ nil, 1, 0, 2, nil, :str, 'ta' ],
+          [ nil, 1, 2, 2, nil, :str, 'to' ]
+        ] ]
+      )
+      expect(@input.offset).to eq(4)
+    end
+
+    it "names the result if there is a name" do
+
+      t = Raabro.seq(:x, @input, :ta, :to)
+
+      expect(
+        t.to_a(:leaves => true)
+      ).to eq(
+        [ :x, 1, 0, 4, nil, :seq, [
+          [ nil, 1, 0, 2, nil, :str, 'ta' ],
+          [ nil, 1, 2, 2, nil, :str, 'to' ]
+        ] ]
+      )
+      expect(@input.offset).to eq(4)
+    end
+
+    it "names in case of failure as well" do
+
+      t = Raabro.seq(:y, @input, :ta, :ta)
+
+      expect(
+        t.to_a(:leaves => true)
+      ).to eq(
+        [ :y, 0, 0, 0, nil, :seq, [
+          [ nil, 1, 0, 2, nil, :str, 'ta' ],
+          [ nil, 0, 2, 0, nil, :str, [] ]
+        ] ]
+      )
+      expect(@input.offset).to eq(0)
+    end
+
+    it "fails when the input string ends" do
+
+      @input.string = 'to'
+
+      t = Raabro.seq(:z, @input, :to, :ta)
+
+      expect(
+        t.to_a(:leaves => true)
+      ).to eq(
+        [ :z, 0, 0, 0, nil, :seq, [
+          [ nil, 1, 0, 2, nil, :str, 'to' ],
+          [ nil, 0, 2, 0, nil, :str, [] ]
+        ] ]
+      )
+      expect(@input.offset).to eq(0)
+    end
+
+    it "accepts an empty input" do
+
+      @input.offset = 4
+
+      t = Raabro.seq(nil, @input, :to, :ta)
+
+      expect(t.to_a).to eq(
+        [ nil, 0, 4, 0, nil, :seq, [
+          [ nil, 0, 4, 0, nil, :str, [] ]
+        ] ]
+      )
+      expect(@input.offset).to eq(4)
+    end
+  end
+end
+
+#describe "fabr_seq()"
+#{
+#  before each
+#  {
+#    fabr_input i = { "tato", 0, 0 };
+#    fabr_tree *t = NULL;
+#  }
+#  after each
+#  {
+#    fabr_tree_free(t);
+#  }
+#
+#  fabr_tree *_ta(fabr_input *i) { return fabr_str(NULL, i, "ta"); }
+#  fabr_tree *_to(fabr_input *i) { return fabr_str(NULL, i, "to"); }
+#
+#  it "returns a tree with result == 0 in case of failure"
+#  it "returns a tree with result == 0 in case of failure (at 2nd step)"
+#  it "returns a tree with result == 1 in case of success"
+#  it "names the result if there is a name"
+#  it "names in case of failure as well"
+#  it "fails when the input string ends"
+#  it "resets the input offset in case of failure"
+#  it "accepts an empty input"
+#
+#  context "quantifiers"
+#  {
+#    describe "a lonely quantifier"
+#    {
+#      it "triggers an error"
+#      {
+#        i.string = "tatota";
+#        t = fabr_seq("y", &i, fabr_qmark, NULL);
+#
+#        expect(fabr_tree_to_string(t, i.string, 0) ===f ""
+#          "[ \"y\", -1, 0, 0, \"bad position for fabr_qmark, _star or _plus\", \"seq\", 0, [] ]");
+#      }
+#    }
+#
+#    describe "fabr_qmark"
+#    {
+#      it "fails"
+#      {
+#        i.string = "tatotota";
+#        t = fabr_seq("x", &i, _ta, _to, fabr_qmark, _ta, NULL);
+#
+#        expect(fabr_tree_to_string(t, i.string, 0) ===f ""
+#          "[ \"x\", 0, 0, 0, null, \"seq\", 0, [\n"
+#          "  [ null, 1, 0, 2, null, \"str\", 2, \"ta\" ],\n"
+#          "  [ null, 1, 2, 2, null, \"str\", 2, \"to\" ],\n"
+#          "  [ null, 0, 4, 0, null, \"str\", 2, [] ]\n"
+#          "] ]");
+#      }
+#
+#      it "succeeds"
+#      {
+#        i.string = "tata";
+#        t = fabr_seq("y", &i, _ta, _to, fabr_qmark, _ta, NULL);
+#
+#        expect(fabr_tree_to_string(t, i.string, 0) ===f ""
+#          "[ \"y\", 1, 0, 4, null, \"seq\", 0, [\n"
+#          "  [ null, 1, 0, 2, null, \"str\", 2, \"ta\" ],\n"
+#          "  [ null, 0, 2, 0, null, \"str\", 2, [] ],\n"
+#          "  [ null, 1, 2, 2, null, \"str\", 2, \"ta\" ]\n"
+#          "] ]");
+#      }
+#
+#      it "succeeds (2)"
+#      {
+#        i.string = "tatota";
+#        t = fabr_seq("z", &i, _ta, _to, fabr_qmark, _ta, NULL);
+#
+#        expect(fabr_tree_to_string(t, i.string, 0) ===f ""
+#          "[ \"z\", 1, 0, 6, null, \"seq\", 0, [\n"
+#          "  [ null, 1, 0, 2, null, \"str\", 2, \"ta\" ],\n"
+#          "  [ null, 1, 2, 2, null, \"str\", 2, \"to\" ],\n"
+#          "  [ null, 1, 4, 2, null, \"str\", 2, \"ta\" ]\n"
+#          "] ]");
+#      }
+#
+#      it "prunes when input->flags & FABR_F_PRUNE"
+#      {
+#        i.string = "tatota";
+#        i.flags = FABR_F_PRUNE;
+#
+#        t = fabr_seq("z", &i, _ta, _to, fabr_qmark, _ta, NULL);
+#
+#        expect(fabr_tree_to_string(t, i.string, 0) ===f ""
+#          "[ \"z\", 1, 0, 6, null, \"seq\", 0, [\n"
+#          "  [ null, 1, 0, 2, null, \"str\", 2, \"ta\" ],\n"
+#          "  [ null, 1, 2, 2, null, \"str\", 2, \"to\" ],\n"
+#          "  [ null, 1, 4, 2, null, \"str\", 2, \"ta\" ]\n"
+#          "] ]");
+#      }
+#    }
+#
+#    describe "fabr_star"
+#    {
+#      it "succeeds"
+#      {
+#        i.string = "tata";
+#        t = fabr_seq("x", &i, _ta, _to, fabr_star, _ta, NULL);
+#
+#        expect(fabr_tree_to_string(t, i.string, 0) ===f ""
+#          "[ \"x\", 1, 0, 4, null, \"seq\", 0, [\n"
+#          "  [ null, 1, 0, 2, null, \"str\", 2, \"ta\" ],\n"
+#          "  [ null, 0, 2, 0, null, \"str\", 2, [] ],\n"
+#          "  [ null, 1, 2, 2, null, \"str\", 2, \"ta\" ]\n"
+#          "] ]");
+#      }
+#
+#      it "succeeds (2)"
+#      {
+#        i.string = "tatotota";
+#        t = fabr_seq("x", &i, _ta, _to, fabr_star, _ta, NULL);
+#
+#        expect(fabr_tree_to_string(t, i.string, 0) ===f ""
+#          "[ \"x\", 1, 0, 8, null, \"seq\", 0, [\n"
+#          "  [ null, 1, 0, 2, null, \"str\", 2, \"ta\" ],\n"
+#          "  [ null, 1, 2, 2, null, \"str\", 2, \"to\" ],\n"
+#          "  [ null, 1, 4, 2, null, \"str\", 2, \"to\" ],\n"
+#          "  [ null, 0, 6, 0, null, \"str\", 2, [] ],\n"
+#          "  [ null, 1, 6, 2, null, \"str\", 2, \"ta\" ]\n"
+#          "] ]");
+#      }
+#
+#      it "prunes when input->flags & FABR_F_PRUNE"
+#      {
+#        i.string = "tatotota";
+#        i.flags = FABR_F_PRUNE;
+#
+#        t = fabr_seq("x", &i, _ta, _to, fabr_star, _ta, NULL);
+#
+#        expect(fabr_tree_to_string(t, i.string, 0) ===f ""
+#          "[ \"x\", 1, 0, 8, null, \"seq\", 0, [\n"
+#          "  [ null, 1, 0, 2, null, \"str\", 2, \"ta\" ],\n"
+#          "  [ null, 1, 2, 2, null, \"str\", 2, \"to\" ],\n"
+#          "  [ null, 1, 4, 2, null, \"str\", 2, \"to\" ],\n"
+#          "  [ null, 1, 6, 2, null, \"str\", 2, \"ta\" ]\n"
+#          "] ]");
+#      }
+#    }
+#
+#    describe "fabr_plus"
+#    {
+#      it "fails"
+#      {
+#        i.string = "tata";
+#        t = fabr_seq("x", &i, _ta, _to, fabr_plus, _ta, NULL);
+#
+#        expect(fabr_tree_to_string(t, i.string, 0) ===f ""
+#          "[ \"x\", 0, 0, 0, null, \"seq\", 0, [\n"
+#          "  [ null, 1, 0, 2, null, \"str\", 2, \"ta\" ],\n"
+#          "  [ null, 0, 2, 0, null, \"str\", 2, [] ]\n"
+#          "] ]");
+#      }
+#
+#      it "succeeds"
+#      {
+#        i.string = "tatotota";
+#        t = fabr_seq("x", &i, _ta, _to, fabr_plus, _ta, NULL);
+#
+#        expect(fabr_tree_to_string(t, i.string, 0) ===f ""
+#          "[ \"x\", 1, 0, 8, null, \"seq\", 0, [\n"
+#          "  [ null, 1, 0, 2, null, \"str\", 2, \"ta\" ],\n"
+#          "  [ null, 1, 2, 2, null, \"str\", 2, \"to\" ],\n"
+#          "  [ null, 1, 4, 2, null, \"str\", 2, \"to\" ],\n"
+#          "  [ null, 0, 6, 0, null, \"str\", 2, [] ],\n"
+#          "  [ null, 1, 6, 2, null, \"str\", 2, \"ta\" ]\n"
+#          "] ]");
+#      }
+#
+#      it "prunes when input->flags & FABR_F_PRUNE"
+#      {
+#        i.string = "tatotota";
+#        i.flags = FABR_F_PRUNE;
+#
+#        t = fabr_seq("x", &i, _ta, _to, fabr_plus, _ta, NULL);
+#
+#        expect(fabr_tree_to_string(t, i.string, 0) ===f ""
+#          "[ \"x\", 1, 0, 8, null, \"seq\", 0, [\n"
+#          "  [ null, 1, 0, 2, null, \"str\", 2, \"ta\" ],\n"
+#          "  [ null, 1, 2, 2, null, \"str\", 2, \"to\" ],\n"
+#          "  [ null, 1, 4, 2, null, \"str\", 2, \"to\" ],\n"
+#          "  [ null, 1, 6, 2, null, \"str\", 2, \"ta\" ]\n"
+#          "] ]");
+#      }
+#    }
+#  }
+#}
+

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+
+#
+# Specifying rufus-scheduler
+#
+# Sat Sep 19 21:12:35 JST 2015
+#
+
+require 'raabro'
+
+#
+# parsers
+
+def ta(i); Raabro.str(nil, i, 'ta'); end
+def to(i); Raabro.str(nil, i, 'to'); end
+

data/spec/str_spec.rb

@@ -0,0 +1,73 @@
+
+#
+# specifying raabro
+#
+# Sun Sep 20 06:11:54 JST 2015
+#
+
+require 'spec_helper'
+
+
+describe Raabro do
+
+  before :each do
+
+    @input = Raabro::Input.new('toto')
+  end
+
+  describe '.str' do
+
+    it 'returns a tree with result == 0 in case of failure' do
+
+      t = Raabro.str(nil, @input, 'nada')
+
+      expect(t.to_a).to eq(
+        [ nil, 0, 0, 0, nil, :str, [] ]
+      )
+      expect(@input.offset).to eq(0)
+    end
+
+    it "returns a tree with result == 1 in case of success" do
+
+      t = Raabro.str(nil, @input, 'toto')
+
+      expect(t.to_a).to eq(
+        [ nil, 1, 0, 4, nil, :str, [] ]
+      )
+      expect(@input.offset).to eq(4)
+    end
+
+    it "names the result if there is a name" do
+
+      t = Raabro.str(:x, @input, 'toto')
+
+      expect(t.to_a).to eq(
+        [ :x, 1, 0, 4, nil, :str, [] ]
+      )
+      expect(@input.offset).to eq(4)
+    end
+
+    it "names in case of failure as well" do
+
+      t = Raabro.str(:y, @input, 'nada')
+
+      expect(t.to_a).to eq(
+        [ :y, 0, 0, 0, nil, :str, [] ]
+      )
+      expect(@input.offset).to eq(0)
+    end
+
+    it "accepts an empty input" do
+
+      @input.offset = 4
+
+      t = Raabro.str(nil, @input, 'nada')
+
+      expect(t.to_a).to eq(
+        [ nil, 0, 4, 0, nil, :str, [] ]
+      )
+      expect(@input.offset).to eq(4)
+    end
+  end
+end
+

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: raabro
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+  prerelease: 
+platform: ruby
+authors:
+- John Mettraux
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+description: a very dumb PEG parser library
+email:
+- jmettraux@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- lib/raabro.rb
+- spec/alt_spec.rb
+- spec/rep_spec.rb
+- spec/rex_spec.rb
+- spec/seq_spec.rb
+- spec/spec_helper.rb
+- spec/str_spec.rb
+- raabro.gemspec
+- LICENSE.txt
+- README.md
+homepage: http://github.com/jmettraux/rufus-scheduler
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: rufus
+rubygems_version: 1.8.23.2
+signing_key: 
+specification_version: 3
+summary: a very dumb PEG parser library
+test_files: []