raabro 0.9.0 → 1.0.0

data/spec/rex_spec.rb

@@ -10,31 +10,42 @@ 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
+    it 'hits' do
 
-      t = Raabro.rex(nil, @input, /t[ua]/)
+      i = Raabro::Input.new('toto')
+
+      t = Raabro.rex(nil, i, /t[ua]/)
 
       expect(t.to_a).to eq(
         [ nil, 0, 0, 0, nil, :rex, [] ]
       )
-      expect(@input.offset).to eq(0)
+      expect(i.offset).to eq(0)
     end
 
-    it "returns a tree with result == 1 in case of success" do
+    it 'misses' do
+
+      i = Raabro::Input.new('toto')
 
-      t = Raabro.rex(nil, @input, /(to)+/)
+      t = Raabro.rex(nil, i, /(to)+/)
 
       expect(t.to_a(:leaves => true)).to eq(
         [ nil, 1, 0, 4, nil, :rex, 'toto' ]
       )
-      expect(@input.offset).to eq(4)
+      expect(i.offset).to eq(4)
+    end
+
+    it 'misses if the match is not at the current input offset' do
+
+      i = Raabro::Input.new('tato')
+
+      t = Raabro.rex(:biga, i, /(to)+/)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ :biga, 0, 0, 0, nil, :rex, [] ]
+      )
+      expect(i.offset).to eq(0)
     end
   end
 end

data/spec/sample_xel_spec.rb

@@ -0,0 +1,110 @@
+
+#
+# specifying raabro
+#
+# Mon Sep 21 16:58:01 JST 2015
+#
+
+require 'spec_helper'
+
+
+module Sample::Xel include Raabro
+
+  # parser
+
+  def pa(i); str(nil, i, '('); end
+  def pz(i); str(nil, i, ')'); end
+  def com(i); str(nil, i, ','); end
+
+  def num(i); rex(:num, i, /-?[0-9]+/); end
+
+  def args(i); eseq(:args, i, :pa, :exp, :com, :pz); end
+  def funame(i); rex(:funame, i, /[A-Z][A-Z0-9]*/); end
+  def fun(i); seq(:fun, i, :funame, :args); end
+
+  def exp(i); alt(:exp, i, :fun, :num); end
+
+  # entry point .parse
+
+  def rewrite(tree)
+
+    case tree.name
+      when :exp
+        rewrite tree.children.first
+      when :num
+        tree.string.to_i
+      when :fun
+        [ tree.children[0].string ] +
+        tree.children[1].children.collect { |e| rewrite(e) }
+      else
+        fail ArgumentError.new("cannot rewrite #{tree.to_a.inspect}")
+    end
+  end
+
+  def parse(input)
+
+    t = all(nil, Raabro::Input.new(input, :prune => true), :exp)
+
+    return nil if t.result != 1
+
+    rewrite(t.children.first.shrink!)
+  end
+end
+
+
+describe Raabro do
+
+  describe Sample::Xel do
+
+    describe '.funame' do
+
+      it 'hits' do
+
+        i = Raabro::Input.new('NADA')
+
+        t = Sample::Xel.funame(i)
+
+        expect(t.to_a(:leaves => true)).to eq(
+          [ :funame, 1, 0, 4, nil, :rex, 'NADA' ]
+        )
+      end
+    end
+
+    describe '.fun' do
+
+      it 'parses a function call' do
+
+        i = Raabro::Input.new('SUM(1,MUL(4,5))', :prune => true)
+
+        t = Sample::Xel.fun(i)
+
+        expect(t.result).to eq(1)
+
+        expect(
+          Sample::Xel.rewrite(t.shrink!)
+        ).to eq(
+          [ 'SUM', 1, [ 'MUL', 4, 5 ] ]
+        )
+      end
+    end
+
+    describe '.parse' do
+
+      it 'parses (success)' do
+
+        expect(
+          Sample::Xel.parse('MUL(7,-3)')
+        ).to eq(
+          [ 'MUL', 7, -3 ]
+        )
+      end
+
+      it 'parses (miss)' do
+
+        expect(Sample::Xel.parse('MUL(7,3) ')).to eq(nil)
+        expect(Sample::Xel.parse('MUL(7,3')).to eq(nil)
+      end
+    end
+  end
+end
+

data/spec/seq_spec.rb

@@ -12,26 +12,25 @@ 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)
+      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(@input.offset).to eq(0)
+      expect(i.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)
+      i = Raabro::Input.new('tato')
+
+      t = Raabro.seq(nil, i, :ta, :ta)
 
       expect(
         t.to_a(:leaves => true)
@@ -41,12 +40,14 @@ describe Raabro do
           [ nil, 0, 2, 0, nil, :str, [] ]
         ] ]
       )
-      expect(@input.offset).to eq(0)
+      expect(i.offset).to eq(0)
     end
 
     it "returns a tree with result == 1 in case of success" do
 
-      t = Raabro.seq(nil, @input, :ta, :to)
+      i = Raabro::Input.new('tato')
+
+      t = Raabro.seq(nil, i, :ta, :to)
 
       expect(
         t.to_a(:leaves => true)
@@ -56,12 +57,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 "names the result if there is a name" do
 
-      t = Raabro.seq(:x, @input, :ta, :to)
+      i = Raabro::Input.new('tato')
+
+      t = Raabro.seq(:x, i, :ta, :to)
 
       expect(
         t.to_a(:leaves => true)
@@ -71,12 +74,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 "names in case of failure as well" do
 
-      t = Raabro.seq(:y, @input, :ta, :ta)
+      i = Raabro::Input.new('tato')
+
+      t = Raabro.seq(:y, i, :ta, :ta)
 
       expect(
         t.to_a(:leaves => true)
@@ -86,14 +91,14 @@ describe Raabro do
           [ nil, 0, 2, 0, nil, :str, [] ]
         ] ]
       )
-      expect(@input.offset).to eq(0)
+      expect(i.offset).to eq(0)
     end
 
     it "fails when the input string ends" do
 
-      @input.string = 'to'
+      i = Raabro::Input.new('to')
 
-      t = Raabro.seq(:z, @input, :to, :ta)
+      t = Raabro.seq(:z, i, :to, :ta)
 
       expect(
         t.to_a(:leaves => true)
@@ -103,104 +108,170 @@ describe Raabro do
           [ nil, 0, 2, 0, nil, :str, [] ]
         ] ]
       )
-      expect(@input.offset).to eq(0)
+      expect(i.offset).to eq(0)
     end
 
     it "accepts an empty input" do
 
-      @input.offset = 4
+      i = Raabro::Input.new('tato', 4)
 
-      t = Raabro.seq(nil, @input, :to, :ta)
+      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(@input.offset).to eq(4)
+      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
+    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
     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";
@@ -216,99 +287,6 @@ end
 #          "] ]");
 #      }
 #    }
-#
-#    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"
-#          "] ]");
-#      }
-#    }
 #  }
 #}