raabro 0.9.0 → 1.0.0

data/spec/all_spec.rb

@@ -0,0 +1,54 @@
+
+#
+# specifying raabro
+#
+# Mon Sep 21 05:56:18 JST 2015
+#
+
+require 'spec_helper'
+
+
+describe Raabro do
+
+  describe '.all' do
+
+    it 'fails when not all the input is consumed' do
+
+      i = Raabro::Input.new('tototota')
+
+      t = Raabro.all(nil, i, :to_plus)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ nil, 0, 0, 0, nil, :all, [
+          [ :tos, 1, 0, 6, nil, :rep, [
+            [ nil, 1, 0, 2, nil, :str, 'to' ],
+            [ nil, 1, 2, 2, nil, :str, 'to' ],
+            [ nil, 1, 4, 2, nil, :str, 'to' ],
+            [ nil, 0, 6, 0, nil, :str, [] ]
+          ] ]
+        ] ]
+      )
+      expect(i.offset).to eq(0)
+    end
+
+    it 'succeeds when all the input is consumed' do
+
+      i = Raabro::Input.new('tototo')
+
+      t = Raabro.all(nil, i, :to_plus)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ nil, 1, 0, 6, nil, :all, [
+          [ :tos, 1, 0, 6, nil, :rep, [
+            [ nil, 1, 0, 2, nil, :str, 'to' ],
+            [ nil, 1, 2, 2, nil, :str, 'to' ],
+            [ nil, 1, 4, 2, nil, :str, 'to' ],
+            [ nil, 0, 6, 0, nil, :str, [] ]
+          ] ]
+        ] ]
+      )
+      expect(i.offset).to eq(6)
+    end
+  end
+end
+

data/spec/alt_spec.rb

@@ -12,16 +12,11 @@ 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'
+      i = Raabro::Input.new('tutu')
 
-      t = Raabro.alt(nil, @input, :ta, :to)
+      t = Raabro.alt(nil, i, :ta, :to)
 
       expect(t.to_a(:leaves => true)).to eq(
         [ nil, 0, 0, 0, nil, :alt, [
@@ -29,24 +24,28 @@ describe Raabro do
           [ nil, 0, 0, 0, nil, :str, [] ]
         ] ]
       )
-      expect(@input.offset).to eq(0)
+      expect(i.offset).to eq(0)
     end
 
     it "succeeds (1st alternative)" do
 
-      t = Raabro.alt(nil, @input, :ta, :to)
+      i = Raabro::Input.new('tato')
+
+      t = Raabro.alt(nil, i, :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)
+      expect(i.offset).to eq(2)
     end
 
     it "succeeds (2nd alternative)" do
 
-      t = Raabro.alt(nil, @input, :to, :ta)
+      i = Raabro::Input.new('tato')
+
+      t = Raabro.alt(nil, i, :to, :ta)
 
       expect(t.to_a(:leaves => true)).to eq(
         [ nil, 1, 0, 2, nil, :alt, [
@@ -54,7 +53,88 @@ describe Raabro do
           [ nil, 1, 0, 2, nil, :str, 'ta' ]
         ] ]
       )
-      expect(@input.offset).to eq(2)
+      expect(i.offset).to eq(2)
+    end
+
+    it 'prunes' do
+
+      i = Raabro::Input.new('tato', :prune => true)
+
+      t = Raabro.alt(nil, i, :to, :ta)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ nil, 1, 0, 2, nil, :alt, [
+          [ nil, 1, 0, 2, nil, :str, 'ta' ]
+        ] ]
+      )
+      expect(i.offset).to eq(2)
+    end
+
+    context 'when not greedy (default)' do
+
+      it 'goes with the first successful result' do
+
+        i = Raabro::Input.new('xx')
+
+        t = Raabro.alt(nil, i, :onex, :twox)
+
+        expect(t.to_a(:leaves => true)).to eq(
+          [ nil, 1, 0, 1, nil, :alt, [
+            [ :onex, 1, 0, 1, nil, :str, 'x' ]
+          ] ]
+        )
+        expect(i.offset).to eq(1)
+      end
+    end
+
+    context 'when greedy (last argument set to true)' do
+
+      it 'takes the longest successful result' do
+
+        i = Raabro::Input.new('xx')
+
+        t = Raabro.alt(nil, i, :onex, :twox, true)
+
+        expect(t.to_a(:leaves => true)).to eq(
+          [ nil, 1, 0, 2, nil, :altg, [
+            [ :onex, 0, 0, 1, nil, :str, [] ],
+            [ :twox, 1, 0, 2, nil, :str, 'xx' ]
+          ] ]
+        )
+        expect(i.offset).to eq(2)
+      end
+    end
+  end
+
+  describe '.altg' do
+
+    it 'is greedy, always' do
+
+      i = Raabro::Input.new('xx')
+
+      t = Raabro.altg(nil, i, :onex, :twox)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ nil, 1, 0, 2, nil, :altg, [
+          [ :onex, 0, 0, 1, nil, :str, [] ],
+          [ :twox, 1, 0, 2, nil, :str, 'xx' ]
+        ] ]
+      )
+      expect(i.offset).to eq(2)
+    end
+
+    it 'prunes' do
+
+      i = Raabro::Input.new('xx', :prune => true)
+
+      t = Raabro.altg(nil, i, :onex, :twox)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ nil, 1, 0, 2, nil, :altg, [
+          [ :twox, 1, 0, 2, nil, :str, 'xx' ]
+        ] ]
+      )
+      expect(i.offset).to eq(2)
     end
   end
 end

data/spec/eseq_spec.rb

@@ -0,0 +1,112 @@
+
+#
+# specifying raabro
+#
+# Mon Sep 21 10:15:35 JST 2015
+#
+
+require 'spec_helper'
+
+
+describe Raabro do
+
+  describe '.eseq' do
+
+    it 'parses successfully' do
+
+      i = Raabro::Input.new('<a,b>')
+
+      t = Raabro.eseq(:list, i, :lt, :cha, :com, :gt)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ :list, 1, 0, 5, nil, :eseq, [
+          [ nil, 1, 0, 1, nil, :str, '<' ],
+          [ nil, 1, 1, 1, nil, :rex, 'a' ],
+          [ nil, 1, 2, 1, nil, :str, ',' ],
+          [ nil, 1, 3, 1, nil, :rex, 'b' ],
+          [ nil, 0, 4, 0, nil, :str, [] ],
+          [ nil, 1, 4, 1, nil, :str, '>' ]
+        ] ]
+      )
+      expect(i.offset).to eq(5)
+    end
+
+    it 'prunes' do
+
+      i = Raabro::Input.new('<a,b>', :prune => true)
+
+      t = Raabro.eseq(:list, i, :lt, :cha, :com, :gt)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ :list, 1, 0, 5, nil, :eseq, [
+          [ nil, 1, 0, 1, nil, :str, '<' ],
+          [ nil, 1, 1, 1, nil, :rex, 'a' ],
+          [ nil, 1, 2, 1, nil, :str, ',' ],
+          [ nil, 1, 3, 1, nil, :rex, 'b' ],
+          [ nil, 1, 4, 1, nil, :str, '>' ]
+        ] ]
+      )
+      expect(i.offset).to eq(5)
+    end
+
+    context 'no start parser' do
+
+      it 'parses successfully' do
+
+        i = Raabro::Input.new('a,b>')
+
+        t = Raabro.eseq(:list, i, nil, :cha, :com, :gt)
+
+        expect(t.to_a(:leaves => true)).to eq(
+          [ :list, 1, 0, 4, nil, :eseq, [
+            [ nil, 1, 0, 1, nil, :rex, 'a' ],
+            [ nil, 1, 1, 1, nil, :str, ',' ],
+            [ nil, 1, 2, 1, nil, :rex, 'b' ],
+            [ nil, 0, 3, 0, nil, :str, [] ],
+            [ nil, 1, 3, 1, nil, :str, '>' ]
+          ] ]
+        )
+        expect(i.offset).to eq(4)
+      end
+    end
+
+    context 'no end parser' do
+
+      it 'parses successfully' do
+
+        i = Raabro::Input.new('<a,b')
+
+        t = Raabro.eseq(:list, i, :lt, :cha, :com, nil)
+
+        expect(t.to_a(:leaves => true)).to eq(
+          [ :list, 1, 0, 4, nil, :eseq, [
+            [ nil, 1, 0, 1, nil, :str, '<' ],
+            [ nil, 1, 1, 1, nil, :rex, 'a' ],
+            [ nil, 1, 2, 1, nil, :str, ',' ],
+            [ nil, 1, 3, 1, nil, :rex, 'b' ],
+            [ nil, 0, 4, 0, nil, :str, [] ],
+          ] ]
+        )
+        expect(i.offset).to eq(4)
+      end
+
+      it 'prunes' do
+
+        i = Raabro::Input.new('<a,b', :prune => true)
+
+        t = Raabro.eseq(:list, i, :lt, :cha, :com, nil)
+
+        expect(t.to_a(:leaves => true)).to eq(
+          [ :list, 1, 0, 4, nil, :eseq, [
+            [ nil, 1, 0, 1, nil, :str, '<' ],
+            [ nil, 1, 1, 1, nil, :rex, 'a' ],
+            [ nil, 1, 2, 1, nil, :str, ',' ],
+            [ nil, 1, 3, 1, nil, :rex, 'b' ]
+          ] ]
+        )
+        expect(i.offset).to eq(4)
+      end
+    end
+  end
+end
+

data/spec/jseq_spec.rb

@@ -0,0 +1,67 @@
+
+#
+# specifying raabro
+#
+# Mon Sep 21 06:55:35 JST 2015
+#
+
+require 'spec_helper'
+
+
+describe Raabro do
+
+  describe '.jseq' do
+
+    it 'parses elts joined by a separator' do
+
+      i = Raabro::Input.new('a,b,c')
+
+      t = Raabro.jseq(:j, i, :cha, :com)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ :j, 1, 0, 5, nil, :jseq, [
+          [ nil, 1, 0, 1, nil, :rex, 'a' ],
+          [ nil, 1, 1, 1, nil, :str, ',' ],
+          [ nil, 1, 2, 1, nil, :rex, 'b' ],
+          [ nil, 1, 3, 1, nil, :str, ',' ],
+          [ nil, 1, 4, 1, nil, :rex, 'c' ],
+          [ nil, 0, 5, 0, nil, :str, [] ]
+        ] ]
+      )
+      expect(i.offset).to eq(5)
+    end
+
+    it 'prunes' do
+
+      i = Raabro::Input.new('a,b,c', :prune => true)
+
+      t = Raabro.jseq(:j, i, :cha, :com)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ :j, 1, 0, 5, nil, :jseq, [
+          [ nil, 1, 0, 1, nil, :rex, 'a' ],
+          [ nil, 1, 1, 1, nil, :str, ',' ],
+          [ nil, 1, 2, 1, nil, :rex, 'b' ],
+          [ nil, 1, 3, 1, nil, :str, ',' ],
+          [ nil, 1, 4, 1, nil, :rex, 'c' ]
+        ] ]
+      )
+      expect(i.offset).to eq(5)
+    end
+
+    it 'fails when zero elements' do
+
+      i = Raabro::Input.new('')
+
+      t = Raabro.jseq(:j, i, :cha, :com)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ :j, 0, 0, 0, nil, :jseq, [
+          [ nil, 0, 0, 0, nil, :rex, [] ]
+        ] ]
+      )
+      expect(i.offset).to eq(0)
+    end
+  end
+end
+

data/spec/ren_spec.rb

@@ -0,0 +1,43 @@
+
+#
+# specifying raabro
+#
+# Mon Sep 21 05:46:00 JST 2015
+#
+
+require 'spec_helper'
+
+
+describe Raabro do
+
+  describe '.ren' do
+
+    it 'returns the tree coming from the wrapped parser' do
+
+      i = Raabro::Input.new('ta')
+
+      t = Raabro.ren('renamed', i, :nta)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ 'renamed', 1, 0, 2, nil, :str, 'ta' ]
+      )
+      expect(i.offset).to eq(2)
+    end
+  end
+
+  describe '.rename' do
+
+    it 'is an alias to .ren' do
+
+      i = Raabro::Input.new('ta')
+
+      t = Raabro.rename('autre', i, :nta)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ 'autre', 1, 0, 2, nil, :str, 'ta' ]
+      )
+      expect(i.offset).to eq(2)
+    end
+  end
+end
+

data/spec/rep_spec.rb

@@ -10,16 +10,13 @@ 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)
+      i = Raabro::Input.new('toto')
+
+      t = Raabro.rep(:x, i, :to, 3, 4)
 
       expect(t.to_a(:leaves => true)).to eq(
         [ :x, 0, 0, 0, nil, :rep, [
@@ -28,14 +25,29 @@ describe Raabro do
           [ nil, 0, 4, 0, nil, :str, [] ]
         ] ]
       )
-      expect(@input.offset).to eq(0)
+      expect(i.offset).to eq(0)
+    end
+
+    it 'prunes' do
+
+      i = Raabro::Input.new('toto', :prune => true)
+
+      t = Raabro.rep(:x, i, :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' ]
+        ] ]
+      )
+      expect(i.offset).to eq(0)
     end
 
     it "fails (min not reached)" do
 
-      @input.string = 'toto'
+      i = Raabro::Input.new('toto')
 
-      t = Raabro.rep(:x, @input, :to, 3)
+      t = Raabro.rep(:x, i, :to, 3)
 
       expect(t.to_a(:leaves => true)).to eq(
         [ :x, 0, 0, 0, nil, :rep, [
@@ -44,14 +56,14 @@ describe Raabro do
           [ nil, 0, 4, 0, nil, :str, [] ]
         ] ]
       )
-      expect(@input.offset).to eq(0)
+      expect(i.offset).to eq(0)
     end
 
     it "succeeds (max set)" do
 
-      @input.string = 'tototo'
+      i = Raabro::Input.new('tototo')
 
-      t = Raabro.rep(:x, @input, :to, 1, 2)
+      t = Raabro.rep(:x, i, :to, 1, 2)
 
       expect(t.to_a(:leaves => true)).to eq(
         [ :x, 1, 0, 4, nil, :rep, [
@@ -59,14 +71,14 @@ describe Raabro do
           [ nil, 1, 2, 2, nil, :str, 'to' ]
         ] ]
       )
-      expect(@input.offset).to eq(4)
+      expect(i.offset).to eq(4)
     end
 
     it "succeeds (max not set)" do
 
-      @input.string = 'toto'
+      i = Raabro::Input.new('toto')
 
-      t = Raabro.rep(:x, @input, :to, 1)
+      t = Raabro.rep(:x, i, :to, 1)
 
       expect(t.to_a(:leaves => true)).to eq(
         [ :x, 1, 0, 4, nil, :rep, [
@@ -75,7 +87,7 @@ describe Raabro do
           [ nil, 0, 4, 0, nil, :str, [] ]
         ] ]
       )
-      expect(@input.offset).to eq(4)
+      expect(i.offset).to eq(4)
     end
   end
 end