raabro 1.0.5 → 1.1.0

data/CHANGELOG.txt

@@ -2,6 +2,12 @@
 = raabro CHANGELOG.txt
 
 
+== raabro 1.1.0  released 2016-02-09
+
+- many improvements
+- unlock custom `rewrite(t)`
+
+
 == raabro 1.0.5  released 2015-09-25
 
 - allow for .parse(s, debug: 1 to 3)

data/LICENSE.txt

@@ -1,5 +1,5 @@
 
-Copyright (c) 2015-2015, John Mettraux, jmettraux@gmail.com
+Copyright (c) 2015-2016, 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

data/README.md

@@ -33,23 +33,25 @@ module Fun include Raabro
 
   def num(i); rex(:num, i, /-?[0-9]+\s*/); 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 args(i); eseq(nil, i, :pa, :exp, :com, :pz); end
+  def funame(i); rex(nil, 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
+  def exp(i); alt(nil, i, :fun, :num); end
 
   # rewrite
   #
   # Names above (:num, :fun, ...) get a rewrite_xxx function.
   # "t" stands for "tree".
+  #
+  # The trees with a nil name are handled by rewrite_(tree) a default
+  # rewrite function
 
-  def rewrite_exp(t); rewrite(t.children[0]); end
   def rewrite_num(t); t.string.to_i; end
 
   def rewrite_fun(t)
     [ t.children[0].string ] +
-    t.children[1].children.inject([]) { |a, e| a << rewrite(e) if e.name; a }
+    t.children[1].odd_children.collect { |a| rewrite(a) }
   end
 end
 
@@ -66,10 +68,37 @@ p Fun.parse('mul (1, 2)')
 
 This sample is available at: [doc/readme0.rb](doc/readme0.rb).
 
+## custom rewrite()
+
+By default, a parser gets a `rewrite(t)` that looks at the parse tree node names and calls the corresponding `rewrite_{node_name}()`.
+
+It's OK to provide a custom `rewrite(t)` function.
+
+```ruby
+module Hello include Raabro
+
+  def hello(i); str(:hello, i, 'hello'); end
+
+  def rewrite(t)
+    [ :ok, t.string ]
+  end
+end
+```
+
 
 ## basic parsers
 
-The first parameter is the name used by rewrite rules.
+One makes a parser by composing basic parsers, for example:
+```ruby
+  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
+```
+where the `fun` parser is a sequence combining the `funame` parser then the `args` one. `:fun` (the first argument to the basic parser `seq`) will be the name of the resulting (local) parse tree.
+
+Below is a list of the basic parsers provided by Raabro.
+
+The first parameter to the basic parser is the name used by rewrite rules.
 The second parameter is a `Raabro::Input` instance, mostly a wrapped string.
 
 ```ruby

data/lib/raabro.rb

@@ -1,6 +1,6 @@
 
 #--
-# Copyright (c) 2015-2015, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2015-2016, 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
@@ -26,7 +26,7 @@
 
 module Raabro
 
-  VERSION = '1.0.5'
+  VERSION = '1.1.0'
 
   class Input
 
@@ -51,6 +51,11 @@ module Raabro
         @string[@offset, l] == s ? l : false
       end
     end
+
+    def tring(l=-1)
+
+      l < 0 ? @string[@offset..l] : @string[@offset, l]
+    end
   end
 
   class Tree
@@ -71,6 +76,17 @@ module Raabro
       @children = []
     end
 
+    def c0; @children[0]; end
+    def c1; @children[1]; end
+    def c2; @children[2]; end
+    def c3; @children[3]; end
+    def c4; @children[4]; end
+
+    def empty?
+
+      @result == 1 && @length == 0
+    end
+
     def successful_children
 
       @children.select { |c| c.result == 1 }
@@ -88,35 +104,53 @@ module Raabro
 
     def lookup(name)
 
-      name = name.to_s
+      name = name ? name.to_s : nil
 
+      return self if @name && name == nil
       return self if @name.to_s == name
+      sublookup(name)
+    end
+
+    def sublookup(name)
+
       @children.each { |c| if n = c.lookup(name); return n; end }
+
       nil
     end
 
     def gather(name, acc=[])
 
-      name = name.to_s
+      name = name ? name.to_s : nil
 
-      if @name.to_s == name
+      if (@name && name == nil) || (@name.to_s == name)
         acc << self
       else
-        @children.each { |c| c.gather(name, acc) }
+        subgather(name, acc)
       end
 
       acc
     end
 
+    def subgather(name, acc=[])
+
+      @children.each { |c| c.gather(name, acc) }
+
+      acc
+    end
+
     def to_a(opts={})
 
       opts = Array(opts).inject({}) { |h, e| h[e] = true; h } \
         unless opts.is_a?(Hash)
 
       cn =
-        opts[:leaves] && (@result == 1) && @children.empty? ?
-        string :
-        @children.collect { |e| e.to_a(opts) }
+        if opts[:leaves] && (@result == 1) && @children.empty?
+          string
+        elsif opts[:children] != false
+          @children.collect { |e| e.to_a(opts) }
+        else
+          @children.length
+        end
 
       [ @name, @result, @offset, @length, @note, @parter, cn ]
     end
@@ -132,6 +166,16 @@ module Raabro
 
       depth == 0 ? io.string : nil
     end
+
+    def odd_children
+
+      cs = []; @children.each_with_index { |c, i| cs << c if i.odd? }; cs
+    end
+
+    def even_children
+
+      cs = []; @children.each_with_index { |c, i| cs << c if i.even? }; cs
+    end
   end
 
   module ModuleMethods
@@ -181,6 +225,10 @@ module Raabro
 
     def _parse(parser, input)
 
+      #p [ caller.length, parser, input.tring ]
+      #r = _narrow(parser).call(input)
+      #p [ caller.length, parser, input.tring, r.to_a(children: false) ]
+      #r
       _narrow(parser).call(input)
     end
 
@@ -240,9 +288,11 @@ module Raabro
         input.offset = start
 
         if greedy
-          if cc.result == 1 && cc.length > (c ? c.length : -1)
+          if cc.result == 1 && cc.length >= (c ? c.length : -1)
             c.result = 0 if c
             c = cc
+          else
+            cc.result = 0
           end
         else
           c = cc
@@ -280,6 +330,7 @@ module Raabro
         r.children << c
         break if c.result != 1
         count += 1
+        break if c.length < 1
         break if max && count == max
       end
 
@@ -345,23 +396,28 @@ module Raabro
 
       if r.result == 1
 
-        i = 1
-        count = 0
+        i = 0
 
         loop do
 
-          i = (i + 1) % 2
-          pa = i == 0 ? eltpa : seppa
+          add = true
 
-          c = _parse(pa, input)
-          r.children << c
+          st = i > 0 ? _parse(seppa, input) : nil
+          et = st == nil || st.result == 1 ? _parse(eltpa, input) : nil
+
+          break if st && et && st.empty? && et.result == 0
+          break if st && et && st.empty? && et.empty?
+
+          r.children << st if st
+          r.children << et if et
 
-          break if c.result != 1
+          break if et == nil
+          break if et.result != 1
 
-          count += 1
+          i = i + 1
         end
 
-        r.result = 0 if jseq && count < 1
+        r.result = 0 if jseq && i == 0
       end
 
       if r.result == 1 && endpa
@@ -415,11 +471,18 @@ module Raabro
 
       t = t.children.first if t.parter == :all
 
-      return rewrite(t) if opts[:rewrite] != false && rewrite(0) == true
+      return rewrite(t) if opts[:rewrite] != false
 
       t
     end
 
+    def rewrite_(tree)
+
+      t = tree.lookup(nil)
+
+      t ? rewrite(t) : nil
+    end
+
     def rewrite(tree)
 
       return !! methods.find { |m| m.to_s.match(/^rewrite_/) } if tree == 0
@@ -427,15 +490,20 @@ module Raabro
 
       send("rewrite_#{tree.name}", tree)
     end
-  end
-  extend ModuleMethods
 
-  def self.included(target)
+    def make_includable
+
+      def self.included(target)
 
-    target.instance_eval do
-      extend ::Raabro::ModuleMethods
-      extend self
+        target.instance_eval do
+          extend ::Raabro::ModuleMethods
+          extend self
+        end
+      end
     end
   end
+  extend ModuleMethods
+
+  make_includable
 end
 

data/spec/alt_spec.rb

@@ -136,6 +136,34 @@ describe Raabro do
       )
       expect(i.offset).to eq(2)
     end
+
+    it 'declares a single winner' do
+
+      i = Raabro::Input.new('xx', :prune => true)
+
+      t = Raabro.altg(nil, i, :twox, :onex)
+
+      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
+
+    it 'takes the longest and latest winner' do
+
+      i = Raabro::Input.new('xx', :prune => true)
+
+      t = Raabro.altg(nil, i, :twox, :onex, :deux)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ nil, 1, 0, 2, nil, :altg, [
+          [ :deux, 1, 0, 2, nil, :str, 'xx' ]
+        ] ]
+      )
+      expect(i.offset).to eq(2)
+    end
   end
 end
 

data/spec/eseq_spec.rb

@@ -49,11 +49,26 @@ describe Raabro do
       expect(i.offset).to eq(5)
     end
 
+    it 'parses <>' do
+
+      i = Raabro::Input.new('<>', :prune => true)
+
+      t = Raabro.eseq(:list, i, :lt, :cha, :com, :gt)
+
+      expect(t.to_a(:leaves => true)).to eq(
+        [ :list, 1, 0, 2, nil, :eseq, [
+          [ nil, 1, 0, 1, nil, :str, '<' ],
+          [ nil, 1, 1, 1, nil, :str, '>' ]
+        ] ]
+      )
+      expect(i.offset).to eq(2)
+    end
+
     context 'no start parser' do
 
       it 'parses successfully' do
 
-        i = Raabro::Input.new('a,b>')
+        i = Raabro::Input.new('a,b>', prune: false)
 
         t = Raabro.eseq(:list, i, nil, :cha, :com, :gt)
 
@@ -84,7 +99,7 @@ describe Raabro do
             [ 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, 0, 4, 0, nil, :str, [] ]
           ] ]
         )
         expect(i.offset).to eq(4)
@@ -107,6 +122,45 @@ describe Raabro do
         expect(i.offset).to eq(4)
       end
     end
+
+    context 'no progress' do
+
+      it 'parses <>' do
+
+        i = Raabro::Input.new('<>', :prune => true)
+
+        t = arr(i)
+
+        expect(t.to_a(:leaves => true)).to eq(
+          [ nil, 1, 0, 2, nil, :eseq, [
+            [ nil, 1, 0, 1, nil, :str, '<' ],
+            [ nil, 1, 1, 0, nil, :rex, '' ],
+            [ nil, 1, 1, 1, nil, :str, '>' ]
+          ] ]
+        )
+        expect(i.offset).to eq(2)
+      end
+
+      it 'parses <a,,a>' do
+
+        i = Raabro::Input.new('<a,,a>', :prune => true)
+
+        t = arr(i)
+
+        expect(t.to_a(:leaves => true)).to eq(
+          [ nil, 1, 0, 6, nil, :eseq, [
+            [ nil, 1, 0, 1, nil, :str, '<' ],
+            [ nil, 1, 1, 1, nil, :rex, 'a' ],
+            [ nil, 1, 2, 1, nil, :rex, ',' ],
+            [ nil, 1, 3, 0, nil, :rex, '' ],
+            [ nil, 1, 3, 1, nil, :rex, ',' ],
+            [ nil, 1, 4, 1, nil, :rex, 'a' ],
+            [ nil, 1, 5, 1, nil, :str, '>' ]
+          ] ]
+        )
+        expect(i.offset).to eq(6)
+      end
+    end
   end
 end
 

data/spec/sample_spec.rb

@@ -0,0 +1,43 @@
+
+#
+# specifying raabro
+#
+# Sun Oct 11 04:24:32 SGT 2015
+#
+
+require 'spec_helper'
+
+
+module Sample::OwnRewrite include Raabro
+
+  # parse
+
+  def hello(i); str(:hello, i, 'hello'); end
+
+  #alias root exp
+    # not necessary since Raabro takes the last defined parser as the root
+
+  # rewrite
+
+  def rewrite(t)
+
+    [ :ok, t.string ]
+  end
+end
+
+
+describe Raabro do
+
+  describe Sample::OwnRewrite do
+
+    it 'uses its own rewrite' do
+
+      expect(
+        Sample::OwnRewrite.parse('hello')
+      ).to eq(
+        [ :ok, 'hello' ]
+      )
+    end
+  end
+end
+

data/spec/sample_xel_spec.rb

@@ -33,8 +33,10 @@ module Sample::Xel include Raabro
   def rewrite_num(t); t.string.to_i; end
 
   def rewrite_fun(t)
-    [ t.children[0].string ] +
-    t.children[1].children.inject([]) { |a, e| a << rewrite(e) if e.name; a }
+
+    #[ t.children[0].string ] +
+    #t.children[1].children.inject([]) { |a, e| a << rewrite(e) if e.name; a }
+    [ t.children[0].string ] + t.children[1].odd_children.map { |c| rewrite(c) }
   end
 end
 

data/spec/sample_xell_spec.rb

@@ -0,0 +1,92 @@
+
+#
+# specifying raabro
+#
+# Sun Dec 13 06:10:00 JST 2015
+#
+
+require 'spec_helper'
+
+
+module Sample::Xell include Raabro
+
+  # parse
+
+  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(nil, i, :pa, :exp, :com, :pz); end
+  def funame(i); rex(nil, i, /[A-Z][A-Z0-9]*/); end
+  def fun(i); seq(:fun, i, :funame, :args); end
+
+  def exp(i); alt(nil, i, :fun, :num); end
+
+  # rewrite
+
+  #def rewrite_(t)
+  #
+  #  c = t.children.find { |c| c.length > 0 || c.name }
+  #  c ? rewrite(c) : nil
+  #end
+    #
+    # part of aabro now
+
+  def rewrite_num(t); t.string.to_i; end
+
+  def rewrite_fun(t)
+
+    #as = []
+    #t.children[1].children.each_with_index { |e, i| as << e if i.odd? }
+    #[ t.children[0].string ] + as.collect { |a| rewrite(a) }
+    [ t.children[0].string ] +
+    t.children[1].odd_children.collect { |a| rewrite(a) }
+  end
+end
+
+
+describe Raabro do
+
+  describe Sample::Xell do
+
+    describe '.parse' do
+
+      it 'parses (success)' do
+
+        expect(
+          Sample::Xell.parse('MUL(7,-3)')
+        ).to eq(
+          [ 'MUL', 7, -3 ]
+        )
+      end
+
+      it 'parses (rewrite: false, success)' do
+
+        expect(
+          Sample::Xell.parse('MUL(7,-3)', rewrite: false).to_s
+        ).to eq(%{
+1 nil 0,9
+  1 :fun 0,9
+    1 nil 0,3 "MUL"
+    1 nil 3,6
+      1 nil 3,1 "("
+      1 nil 4,1
+        1 :num 4,1 "7"
+      1 nil 5,1 ","
+      1 nil 6,2
+        1 :num 6,2 "-3"
+      1 nil 8,1 ")"
+        }.strip)
+      end
+
+      it 'parses (miss)' do
+
+        expect(Sample::Xell.parse('MUL(7,3) ')).to eq(nil)
+        expect(Sample::Xell.parse('MUL(7,3')).to eq(nil)
+      end
+    end
+  end
+end
+

data/spec/seq_spec.rb

@@ -226,6 +226,21 @@ describe Raabro do
         )
         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
@@ -262,31 +277,22 @@ describe Raabro do
         )
         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
 
-#describe "fabr_seq()"
-#
-#  context "quantifiers"
-#  {
-#    describe "fabr_qmark"
-#    {
-#      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"
-#          "] ]");
-#      }
-#    }
-#  }
-#}
-

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 
 #
-# Specifying rufus-scheduler
+# Specifying raabro
 #
 # Sat Sep 19 21:12:35 JST 2015
 #
@@ -17,6 +17,8 @@ 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
 
@@ -28,6 +30,12 @@ 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
 
 
 #

data/spec/tree_spec.rb

@@ -14,7 +14,7 @@ describe Raabro::Tree do
 
     it 'returns the first node with the given name' do
 
-      t = Sample::Cal.parse('4 5 6 + 1 2 3 * +')
+      t = Sample::Cal.parse('4 5 6 + 1 2 3 * +', rewrite: false)
 
       expect(
         t.lookup('item').to_a(:leaves)
@@ -24,13 +24,41 @@ describe Raabro::Tree do
         ] ]
       )
     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 * +')
+      t = Sample::Cal.parse('4 5 6 + 1 2 3 * +', rewrite: false)
 
       expect(
         t.gather('op').collect { |n| n.to_a(:leaves) }
@@ -42,6 +70,57 @@ describe Raabro::Tree do
         ]
       )
     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
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: raabro
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-25 00:00:00.000000000 Z
+date: 2016-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -50,7 +50,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- Rakefile
 - lib/raabro.rb
 - spec/all_spec.rb
 - spec/alt_spec.rb
@@ -59,7 +58,9 @@ files:
 - spec/ren_spec.rb
 - spec/rep_spec.rb
 - spec/rex_spec.rb
+- spec/sample_spec.rb
 - spec/sample_xel_spec.rb
+- spec/sample_xell_spec.rb
 - spec/seq_spec.rb
 - spec/spec_helper.rb
 - spec/str_spec.rb

data/Rakefile

@@ -1,68 +0,0 @@
-
-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
-