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

raabro 1.1.1 → 1.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

data/spec/seq_spec.rb DELETED

@@ -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