RubyGems - raabro - Versions diffs - 1.1.1 → 1.1.2 - Mend

raabro 1.1.1 → 1.1.2

Files changed (18) hide show

@@ -1,298 +0,0 @@
-#
-# specifying raabro
-#
-# Sun Sep 20 06:11:54 JST 2015
-#
-require 'spec_helper'
-describe Raabro do
-  describe '.seq' do
-    it "returns a tree with result == 0 in case of failure" do
-      i = Raabro::Input.new('tato')
-      t = Raabro.seq(nil, i, :to, :ta)
-      expect(t.to_a).to eq(
-        [ nil, 0, 0, 0, nil, :seq, [
-          [ nil, 0, 0, 0, nil, :str, [] ]
-        ] ]
-      )
-      expect(i.offset).to eq(0)
-    end
-    it "returns a tree with result == 0 in case of failure (at 2nd step)" do
-      i = Raabro::Input.new('tato')
-      t = Raabro.seq(nil, i, :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(i.offset).to eq(0)
-    end
-    it "returns a tree with result == 1 in case of success" do
-      i = Raabro::Input.new('tato')
-      t = Raabro.seq(nil, i, :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(i.offset).to eq(4)
-    end
-    it "names the result if there is a name" do
-      i = Raabro::Input.new('tato')
-      t = Raabro.seq(:x, i, :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(i.offset).to eq(4)
-    end
-    it "names in case of failure as well" do
-      i = Raabro::Input.new('tato')
-      t = Raabro.seq(:y, i, :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(i.offset).to eq(0)
-    end
-    it "fails when the input string ends" do
-      i = Raabro::Input.new('to')
-      t = Raabro.seq(:z, i, :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(i.offset).to eq(0)
-    end
-    it "accepts an empty input" do
-      i = Raabro::Input.new('tato', 4)
-      t = Raabro.seq(nil, i, :to, :ta)
-      expect(t.to_a).to eq(
-        [ nil, 0, 4, 0, nil, :seq, [
-          [ nil, 0, 4, 0, nil, :str, [] ]
-        ] ]
-      )
-      expect(i.offset).to eq(4)
-    end
-  end
-  describe 'seq and quantifiers' do
-    describe 'a lonely quantifier' do
-      it 'raises an ArgumentError' do
-        i = Raabro::Input.new('tato')
-        expect {
-          t = Raabro.seq(nil, i, '?')
-        }.to raise_error(ArgumentError, 'lone quantifier ?')
-      end
-    end
-    describe 'the question mark quantifier' do
-      it 'lets optional elements appear in sequences (miss)' do
-        i = Raabro::Input.new('tato')
-        t = Raabro.seq(nil, i, :ta, :tu, '?', :to)
-        expect(t.to_a(:leaves => true)).to eq(
-          [ nil, 1, 0, 4, nil, :seq, [
-            [ nil, 1, 0, 2, nil, :str, 'ta' ],
-            [ nil, 0, 2, 0, nil, :str, [] ],
-            [ nil, 1, 2, 2, nil, :str, 'to' ]
-          ] ]
-        )
-        expect(i.offset).to eq(4)
-      end
-      it 'lets optional elements appear in sequences (hit)' do
-        i = Raabro::Input.new('tatuto')
-        t = Raabro.seq(nil, i, :ta, :tu, '?', :to)
-        expect(t.to_a(:leaves => true)).to eq(
-          [ nil, 1, 0, 6, nil, :seq, [
-            [ nil, 1, 0, 2, nil, :str, 'ta' ],
-            [ nil, 1, 2, 2, nil, :str, 'tu' ],
-            [ nil, 1, 4, 2, nil, :str, 'to' ]
-          ] ]
-        )
-        expect(i.offset).to eq(6)
-      end
-      it 'lets optional elements appear in sequences (fail)' do
-        i = Raabro::Input.new('tatututo')
-        t = Raabro.seq(nil, i, :ta, :tu, '?', :to)
-        expect(t.to_a(:leaves => true)).to eq(
-          [ nil, 0, 0, 0, nil, :seq, [
-            [ nil, 1, 0, 2, nil, :str, 'ta' ],
-            [ nil, 1, 2, 2, nil, :str, 'tu' ],
-            [ nil, 0, 4, 0, nil, :str, [] ]
-          ] ]
-        )
-        expect(i.offset).to eq(0)
-      end
-    end
-    describe 'the star quantifier' do
-      it 'lets optional elements recur in sequences (hit zero)' do
-        i = Raabro::Input.new('tato')
-        t = Raabro.seq(nil, i, :ta, :tu, '*', :to)
-        expect(t.to_a(:leaves => true)).to eq(
-          [ nil, 1, 0, 4, nil, :seq, [
-            [ nil, 1, 0, 2, nil, :str, 'ta' ],
-            [ nil, 0, 2, 0, nil, :str, [] ],
-            [ nil, 1, 2, 2, nil, :str, 'to' ]
-          ] ]
-        )
-        expect(i.offset).to eq(4)
-      end
-      it 'lets optional elements recur in sequences (hit)' do
-        i = Raabro::Input.new('tatututo')
-        t = Raabro.seq(nil, i, :ta, :tu, '*', :to)
-        expect(t.to_a(:leaves => true)).to eq(
-          [ nil, 1, 0, 8, nil, :seq, [
-            [ nil, 1, 0, 2, nil, :str, 'ta' ],
-            [ nil, 1, 2, 2, nil, :str, 'tu' ],
-            [ nil, 1, 4, 2, nil, :str, 'tu' ],
-            [ nil, 0, 6, 0, nil, :str, [] ],
-            [ nil, 1, 6, 2, nil, :str, 'to' ]
-          ] ]
-        )
-        expect(i.offset).to eq(8)
-      end
-      it 'stops when there is no progress' do
-        i = Raabro::Input.new('abc')
-        t = Raabro.seq(nil, i, :to_star, '*');
-        expect(t.to_a(:leaves => true)).to eq(
-          [ nil, 1, 0, 0, nil, :seq, [
-            [ nil, 1, 0, 0, nil, :rep, [
-              [ nil, 0, 0, 0, nil, :str, [] ]
-            ] ]
-          ] ]
-        )
-      end
-    end
-    describe 'the plus quantifier' do
-      it 'lets elements recur in sequences (hit)' do
-        i = Raabro::Input.new('tatututo')
-        t = Raabro.seq(nil, i, :ta, :tu, '+', :to)
-        expect(t.to_a(:leaves => true)).to eq(
-          [ nil, 1, 0, 8, nil, :seq, [
-            [ nil, 1, 0, 2, nil, :str, 'ta' ],
-            [ nil, 1, 2, 2, nil, :str, 'tu' ],
-            [ nil, 1, 4, 2, nil, :str, 'tu' ],
-            [ nil, 0, 6, 0, nil, :str, [] ],
-            [ nil, 1, 6, 2, nil, :str, 'to' ]
-          ] ]
-        )
-        expect(i.offset).to eq(8)
-      end
-      it 'lets elements recur in sequences (fail)' do
-        i = Raabro::Input.new('tato')
-        t = Raabro.seq(nil, i, :ta, :tu, '+', :to)
-        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(i.offset).to eq(0)
-      end
-      it 'stops when there is no progress' do
-        i = Raabro::Input.new('abc')
-        t = Raabro.seq(nil, i, :to_star, '+');
-        expect(t.to_a(:leaves => true)).to eq(
-          [ nil, 1, 0, 0, nil, :seq, [
-            [ nil, 1, 0, 0, nil, :rep, [
-              [ nil, 0, 0, 0, nil, :str, [] ]
-            ] ]
-          ] ]
-        )
-      end
-    end
-  end
-end

data/spec/spec_helper.rb DELETED

@@ -1,68 +0,0 @@
-#
-# Specifying raabro
-#
-# Sat Sep 19 21:12:35 JST 2015
-#
-require 'pp'
-require 'raabro'
-#
-# parsers
-def ta(i); Raabro.str(nil, i, 'ta'); end
-def to(i); Raabro.str(nil, i, 'to'); end
-def tu(i); Raabro.str(nil, i, 'tu'); end
-def to_plus(input); Raabro.rep(:tos, input, :to, 1); end
-def to_star(input); Raabro.rep(nil, input, :to, 0); end
-def to_qmark(input); Raabro.rep(nil, input, :to, 0, 1); end
-def nta(i); Raabro.str('the-ta', i, 'ta'); end
-def cha(i); Raabro.rex(nil, i, /\A[a-z]/); end
-def com(i); Raabro.str(nil, i, ','); end
-def lt(i); Raabro.str(nil, i, '<'); end
-def gt(i); Raabro.str(nil, i, '>'); end
-def onex(i); Raabro.str(:onex, i, 'x'); end
-def twox(i); Raabro.str(:twox, i, 'xx'); end
-def deux(i); Raabro.str(:deux, i, 'xx'); end
-# testing eseq...
-def acom(i); Raabro.rex(nil, i, /,?/); end
-def aval(i); Raabro.rex(nil, i, /[a-z]?/); end
-def arr(i); Raabro.eseq(nil, i, :lt, :aval, :acom, :gt); end
-#
-# test modules
-module Sample; end
-module Sample::Cal include Raabro
-  def sp(i); rex(nil, i, /\s+/); end
-  def num(i); rex(:num, i, /-?[0-9]+/); end
-  def op(i); rex(:op, i, /[+\-*\/]/); end
-  def item(i); alt(:item, i, :num, :op); end
-  def suite(i); jseq(nil, i, :item, :sp); end
-end
-module Sample::Arith include Raabro
-  def number(i); rex(:number, i, /-?[0-9]+\s*/); end
-  def plus(i); rex(:plus, i, /\+\s*/); end
-  def minus(i); rex(:minus, i, /-\s*/); end
-  def addition(i); seq(:addition, i, :number, :plus, :op_or_num); end
-  def substraction(i); seq(:substraction, i, :number, :minus, :op_or_num); end
-  def op_or_num(i); alt(nil, i, :addition, :substraction, :number); end
-end

data/spec/str_spec.rb DELETED

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

data/spec/tree_spec.rb DELETED

@@ -1,126 +0,0 @@
-#
-# specifying raabro
-#
-# Tue Sep 22 07:55:52 JST 2015
-#
-require 'spec_helper'
-describe Raabro::Tree do
-  describe '.lookup' do
-    it 'returns the first node with the given name' do
-      t = Sample::Cal.parse('4 5 6 + 1 2 3 * +', rewrite: false)
-      expect(
-        t.lookup('item').to_a(:leaves)
-      ).to eq(
-        [ :item, 1, 0, 1, nil, :alt, [
-          [ :num, 1, 0, 1, nil, :rex, '4' ]
-        ] ]
-      )
-    end
-    it 'returns the first named node if the given name is nil' do
-      t = Sample::Cal.parse('4 5 6 + 1 2 3 * +', rewrite: false)
-      expect(
-        t.lookup(nil).to_a(:leaves)
-      ).to eq(
-        [ :item, 1, 0, 1, nil, :alt, [
-          [ :num, 1, 0, 1, nil, :rex, '4' ]
-        ] ]
-      )
-    end
-  end
-  describe '.sublookup' do
-    it 'skips the callee node' do
-      t = Sample::Cal.parse('4 5 6 + 1 2 3 * +', rewrite: false)
-      t = t.children[0]
-      expect(
-        t.sublookup(nil).to_a(:leaves)
-      ).to eq(
-        [ :num, 1, 0, 1, nil, :rex, '4' ]
-      )
-    end
-  end
-  describe '.gather' do
-    it 'returns all the nodes with a given name' do
-      t = Sample::Cal.parse('4 5 6 + 1 2 3 * +', rewrite: false)
-      expect(
-        t.gather('op').collect { |n| n.to_a(:leaves) }
-      ).to eq(
-        [
-          [ :op, 1, 6, 1, nil, :rex, '+' ],
-          [ :op, 1, 14, 1, nil, :rex, '*' ],
-          [ :op, 1, 16, 1, nil, :rex, '+' ]
-        ]
-      )
-    end
-    it 'returns all the nodes with a name if the given name is nil' do
-      t = Sample::Cal.parse('4 5 6 + 1 2 3 * +', rewrite: false)
-      expect(
-        t.gather(nil).collect { |n| n.to_a(:leaves) }
-      ).to eq([
-        [ :item, 1, 0, 1, nil, :alt, [
-          [ :num, 1, 0, 1, nil, :rex, '4' ]
-        ] ],
-        [ :item, 1, 2, 1, nil, :alt, [
-          [ :num, 1, 2, 1, nil, :rex, '5' ]
-        ] ],
-        [ :item, 1, 4, 1, nil, :alt, [
-          [ :num, 1, 4, 1, nil, :rex, '6' ]
-        ] ],
-        [ :item, 1, 6, 1, nil, :alt, [
-          [ :op, 1, 6, 1, nil, :rex, '+' ]
-        ] ],
-        [ :item, 1, 8, 1, nil, :alt, [
-          [ :num, 1, 8, 1, nil, :rex, '1' ]
-        ] ],
-        [ :item, 1, 10, 1, nil, :alt, [
-          [ :num, 1, 10, 1, nil, :rex, '2' ]
-        ] ],
-        [ :item, 1, 12, 1, nil, :alt, [
-          [ :num, 1, 12, 1, nil, :rex, '3' ]
-        ] ],
-        [ :item, 1, 14, 1, nil, :alt, [
-          [ :op, 1, 14, 1, nil, :rex, '*' ]
-        ] ],
-        [ :item, 1, 16, 1, nil, :alt, [
-          [ :op, 1, 16, 1, nil, :rex, '+' ]
-        ] ]
-      ])
-    end
-  end
-  describe '.subgather' do
-    it 'skips the callee node' do
-      t = Sample::Cal.parse('4 5 6 + 1 2 3 * +', rewrite: false)
-      expect(
-        t.children[0].subgather(nil).collect { |n| n.to_a(:leaves) }
-      ).to eq([
-        [ :num, 1, 0, 1, nil, :rex, '4' ]
-      ])
-    end
-  end
-end