sexpr 0.2.0

data/spec/grammar/test_fetch.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Sexpr
+  describe Grammar, "fetch" do
+
+    let(:grammar){
+      Sexpr.load(:terminal => /[a-z]+/)
+    }
+
+    it 'returns the rule when it exists' do
+      grammar[:terminal].should be_a(Terminal)
+    end
+
+    it 'returns nil otherwise' do
+      grammar[:nosuchone].should be_nil
+    end
+
+  end
+end # module Sexpr

data/spec/grammar/test_parse.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Sexpr
+  describe Grammar, "parse" do
+
+    def parser
+      Object.new.tap{|x|
+        def x.parse(s)
+          Struct.new(:value).new([:parsed, s])
+        end
+      }
+    end
+
+    def grammar(options = {})
+      Sexpr.load({}, {:parser => parser})
+    end
+
+    it 'it accepts a string' do
+      grammar.parse("Hello world").should eq([:parsed, "Hello world"])
+    end
+
+    it 'it accepts a path' do
+      grammar.parse(Path.here).should eq([:parsed, File.read(__FILE__)])
+    end
+
+    it 'it accepts an IO' do
+      File.open(__FILE__, 'r') do |io|
+        grammar.parse(io).should eq([:parsed, File.read(__FILE__)])
+      end
+    end
+
+  end
+end

data/spec/grammar/test_root.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Sexpr
+  describe Grammar, "root" do
+
+    let(:rules){ {:t => /[a-z]+/, :nt => true} }
+
+    def grammar(options = {})
+      Sexpr.load(rules, options)
+    end
+
+    it 'is the first key by default' do
+      grammar.root.value.should eq(/[a-z]+/)
+    end
+
+    it 'is the specified rule when specified' do
+      grammar(:root => :nt).root.value.should eq(true)
+    end
+
+  end
+end

data/spec/many/test_eat.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+module Sexpr
+  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 Sexpr
+  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 Sexpr
+  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 Sexpr
+  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 Sexpr
+  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 Sexpr
+  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 Sexpr
+  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 Sexpr
+  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 Sexpr
+  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 'sexpr'

data/spec/terminal/test_eat.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Sexpr
+  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 Sexpr
+  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 Sexpr
+  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