sexp_grammar 0.1.0

data/spec/many/test_eat.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+module SexpGrammar
+  describe Many, "eat" do
+
+    let(:term){ Terminal.new(/^[a-z]+$/)   }
+    let(:rule){ Many.new term, min, max    }
+
+    context "when set for *" do
+      let(:min){ 0   }
+      let(:max){ nil }
+
+      it 'returns the subarray when zero match' do
+        rule.eat([nil, "world", "then"]).should eq([nil, "world", "then"])
+      end
+
+      it 'returns the subarray when one match' do
+        rule.eat(["world", nil, "then"]).should eq([nil, "then"])
+      end
+
+      it 'returns the subarray when multiple matches' do
+        rule.eat(["world", "then"]).should eq([])
+      end
+
+    end # *
+
+    context "when set for +" do
+      let(:min){ 1   }
+      let(:max){ nil }
+
+      it 'returns nil zero match' do
+        rule.eat([nil, "world", "then"]).should be_nil
+      end
+
+      it 'returns the subarray when one match' do
+        rule.eat(["world", nil, "then"]).should eq([nil, "then"])
+      end
+
+      it 'returns the subarray when multiple matches' do
+        rule.eat(["world", "then"]).should eq([])
+      end
+
+    end # +
+
+    context "when set for ?" do
+      let(:min){ 0 }
+      let(:max){ 1 }
+
+      it 'returns the subarray when zero match' do
+        rule.eat([nil, "world", "then"]).should eq([nil, "world", "then"])
+      end
+
+      it 'returns the subarray when one match' do
+        rule.eat(["world", "then"]).should eq(["then"])
+      end
+
+    end # ?
+
+  end
+end

data/spec/many/test_initialize.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module SexpGrammar
+  describe Many, "initialize" do
+
+    it 'understands a single min' do
+      many = Many.new(nil, 2)
+      many.min.should eq(2)
+      many.max.should be_nil
+    end
+
+    it 'understands a min and a max' do
+      many = Many.new(nil, 2, 10)
+      many.min.should eq(2)
+      many.max.should eq(10)
+    end
+
+    it 'understands ?' do
+      many = Many.new(nil, '?')
+      many.min.should eq(0)
+      many.max.should eq(1)
+    end
+
+    it 'understands *' do
+      many = Many.new(nil, '*')
+      many.min.should eq(0)
+      many.max.should be_nil
+    end
+
+    it 'understands +' do
+      many = Many.new(nil, '+')
+      many.min.should eq(1)
+      many.max.should be_nil
+    end
+
+  end
+end

data/spec/many/test_match_q.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module SexpGrammar
+  describe Many do
+
+    let(:term){ Terminal.new(/^[a-z]+$/) }
+    let(:rule){ Many.new term, '+'       }
+
+    it 'returns true on match' do
+      rule.should be_match(["hello"])
+      rule.should be_match(["hello", "world"])
+    end
+
+    it 'returns false on partial match' do
+      rule.should_not be_match(["hello", "world", "12"])
+    end
+
+    it 'returns false on no match' do
+      rule.should_not be_match(["12"])
+      rule.should_not be_match([])
+      rule.should_not be_match(nil)
+    end
+
+  end
+end

data/spec/reference/test_eat.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+module SexpGrammar
+  describe Reference, "eat" do
+
+    let(:grammar){ {:hello => Terminal.new(/^[a-z]+$/)} }
+    let(:rule)   { Reference.new :hello, grammar        }
+
+    it 'delegates the call' do
+      rule.eat(["hello", "world"]).should eq(["world"])
+    end
+
+  end
+end

data/spec/reference/test_match_q.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module SexpGrammar
+  describe Reference, "match?" do
+
+    let(:grammar){ {:hello => Terminal.new(/^[a-z]+$/)} }
+    let(:rule)   { Reference.new :hello, grammar        }
+
+    it 'returns true on match' do
+      rule.should be_match("hello")
+      (rule === "hello").should be_true
+    end
+
+    it 'returns false on no match' do
+      rule.should_not be_match("12")
+      rule.should_not be_match(nil)
+      rule.should_not be_match([])
+    end
+
+  end
+end

data/spec/rule/test_eat.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+module SexpGrammar
+  describe Rule, "eat" do
+
+    let(:defn){ Sequence.new [Terminal.new(/^[a-z]+$/)] }
+    let(:rule){ Rule.new :hello, defn }
+
+    it 'returns the trailing array when match' do
+      rule.eat([[:hello, "world"], "!"]).should eq(["!"])
+    end
+
+    it 'returns nil when not match' do
+      rule.eat([:hello, "world"]).should be_nil
+      rule.eat([:hello]).should be_nil
+      rule.eat([]).should be_nil
+      rule.eat([[]]).should be_nil
+      rule.eat([nil]).should be_nil
+    end
+
+  end
+end

data/spec/rule/test_match_q.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module SexpGrammar
+  describe Rule, 'match?' do
+
+    let(:defn){ Sequence.new [Terminal.new(/^[a-z]+$/)] }
+    let(:rule){ Rule.new :hello, defn }
+
+    it 'returns true on match' do
+      rule.should be_match([:hello, "hello"])
+    end
+
+    it 'returns false on partial match' do
+      rule.should_not be_match([:hello, "hello", "world"])
+    end
+
+    it 'returns false on no match' do
+      rule.should_not be_match(["hello"])
+      rule.should_not be_match([:hello, 12])
+      rule.should_not be_match([])
+      rule.should_not be_match(nil)
+    end
+
+  end
+end

data/spec/sequence/test_eat.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module SexpGrammar
+  describe Sequence, "eat" do
+
+    let(:alt1){ Terminal.new(nil)          }
+    let(:alt2){ Terminal.new(/^[a-z]+$/)   }
+    let(:rule){ Sequence.new [alt1, alt2]  }
+
+    it 'returns the subarray when match' do
+      rule.eat([nil, "world", "then"]).should eq(["then"])
+    end
+
+    it 'returns nil when no match' do
+      rule.eat([]).should be_nil
+      rule.eat(["12"]).should be_nil
+      rule.eat([nil]).should be_nil
+    end
+
+  end
+end

data/spec/sequence/test_match_q.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+module SexpGrammar
+  describe Sequence, 'match?' do
+
+    let(:alt1){ Terminal.new(nil)          }
+    let(:alt2){ Terminal.new(/^[a-z]+$/)   }
+    let(:rule){ Sequence.new [alt1, alt2]  }
+
+    it 'returns true on match' do
+      rule.should be_match([nil, "hello"])
+    end
+
+    it 'returns false on partial match' do
+      rule.should_not be_match([nil, "hello", "world"])
+    end
+
+    it 'returns false on no match' do
+      rule.should_not be_match([:hello, 12])
+      rule.should_not be_match([])
+      rule.should_not be_match(nil)
+      rule.should_not be_match([nil])
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'epath'
+require 'sexp_grammar'

data/spec/terminal/test_eat.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module SexpGrammar
+  describe Terminal, "eat" do
+
+    let(:rule){ Terminal.new(/^[a-z]+$/) }
+
+    context "with a regexp" do
+
+      it 'returns subarray when match' do
+        rule.eat(["hello", "world"]).should eq(["world"])
+      end
+
+      it 'returns nil when no match' do
+        rule.eat([]).should be_nil
+        rule.eat(["12"]).should be_nil
+      end
+    end
+
+  end
+end

data/spec/terminal/test_match_q.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+module SexpGrammar
+  describe Terminal, "match?" do
+
+    let(:rule){ Terminal.new(arg) }
+
+    describe "with true" do
+      let(:arg){ true }
+
+      it 'returns true on match' do
+        rule.should be_match(true)
+        (rule === true).should be_true
+      end
+
+      it 'returns false on no match' do
+        rule.should_not be_match([])
+        rule.should_not be_match(nil)
+        rule.should_not be_match(false)
+      end
+
+    end
+
+    describe "with false" do
+      let(:arg){ false }
+
+      it 'returns true on match' do
+        rule.should be_match(false)
+        (rule === false).should be_true
+      end
+
+      it 'returns false on no match' do
+        rule.should_not be_match([])
+        rule.should_not be_match(nil)
+        rule.should_not be_match(true)
+      end
+
+    end
+
+    describe "with nil" do
+      let(:arg){ nil }
+
+      it 'returns true on match' do
+        rule.should be_match(nil)
+        (rule === nil).should be_true
+      end
+
+      it 'returns false on no match' do
+        rule.should_not be_match([])
+        rule.should_not be_match(false)
+        rule.should_not be_match(true)
+      end
+
+    end
+
+  end
+end

data/spec/terminal/test_terminal_match.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+module SexpGrammar
+  describe Terminal, "terminal_match?" do
+
+    before do
+      class Terminal; public :terminal_match?; end
+    end
+
+    let(:terminal){ Terminal.new(arg) }
+
+    context "with a Regexp" do
+      let(:arg){ /^[a-z]+$/ }
+
+      it 'matches a matching string' do
+        terminal.terminal_match?("hello").should be_true
+      end
+
+      it 'matches a non matching string' do
+        terminal.terminal_match?("12").should be_false
+      end
+
+      it 'does not match a sexp' do
+        terminal.terminal_match?([:sexp, "Hello World"]).should be_false
+      end
+
+      it 'does not match nil' do
+        terminal.terminal_match?(nil).should be_false
+      end
+    end
+
+    context "with true" do
+      let(:arg){ true }
+
+      it 'matches true' do
+        terminal.terminal_match?(true).should be_true
+      end
+
+      it 'does not match false/nil' do
+        terminal.terminal_match?(false).should be_false
+        terminal.terminal_match?(nil).should be_false
+      end
+
+      it 'does not match anything else' do
+        terminal.terminal_match?([]).should be_false
+        terminal.terminal_match?([:sexp]).should be_false
+        terminal.terminal_match?("true").should be_false
+      end
+    end
+
+    context "with false" do
+      let(:arg){ false }
+
+      it 'matches false' do
+        terminal.terminal_match?(false).should be_true
+      end
+
+      it 'does not match true/nil' do
+        terminal.terminal_match?(true).should be_false
+        terminal.terminal_match?(nil).should be_false
+      end
+
+      it 'does not match anything else' do
+        terminal.terminal_match?([]).should be_false
+        terminal.terminal_match?([:sexp]).should be_false
+        terminal.terminal_match?("false").should be_false
+      end
+    end
+
+    context "with nil" do
+      let(:arg){ nil }
+
+      it 'matches nil' do
+        terminal.terminal_match?(nil).should be_true
+      end
+
+      it 'does not match true/false' do
+        terminal.terminal_match?(true).should be_false
+        terminal.terminal_match?(false).should be_false
+      end
+
+      it 'does not match anything else' do
+        terminal.terminal_match?([]).should be_false
+        terminal.terminal_match?([:sexp]).should be_false
+        terminal.terminal_match?("nil").should be_false
+      end
+    end
+
+  end
+end

data/spec/test_bool_expr.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+module SexpGrammar
+  describe "the bool_expr grammar" do
+
+    let(:g){ SexpGrammar.load(Path.dir/"bool_expr.yml") }
+
+    it "allows checking validy of specific nodes" do
+      (g[:bool_lit] === true).should be_true
+      (g[:var_ref]  === [:var_ref, "x"]).should be_true
+      (g[:bool_and] === [:bool_and, true, false]).should be_true
+      (g[:bool_and] === [:bool_or, true, false]).should be_false
+    end
+
+    it 'allows checking the validity against the root rule' do
+      (g === true).should be_true
+      (g === false).should be_true
+      (g === [:bool_not, true]).should be_true
+      (g === [:var_ref, "x"]).should be_true
+      (g === [:bool_not, [:var_ref, "x"]]).should be_true
+    end
+
+    it 'detects wrong matches' do
+      (g === [:bool_not, [:something_else, "x"]]).should be_false
+    end
+
+  end
+end