llip 0.1.0

data/spec/llip/production_compiler_spec.rb

@@ -0,0 +1,271 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'production_compiler'
+
+describe "A ProductionCompiler" do
+	
+  before(:each) do
+    @compiler = ProductionCompiler.new
+  end
+
+  it "should have a code method which returns a String" do
+    @compiler.should respond_to(:code)
+    @compiler.code.should == ""
+  end
+
+  it "should have a start method which accept a name and build the definition of a method" do
+    @compiler.should respond_to(:start)
+    @compiler.start(:new_production)
+    @compiler.code.strip.should =~ /^def parse_new_production$/
+    @compiler.code.should =~ /^( |\t|\n)*result = productions\[:"new_production"\].default.call\(@scanner,self\)\n*$/
+  end
+
+  it "should have an end method which close the definition of a method" do
+    @compiler.should respond_to(:end)
+    @compiler.start(:new_production)
+    @compiler.end
+    @compiler.code.strip.should =~ /^def parse_new_production$/
+    @compiler.code.should =~ /^( |\t|\n)*result = productions\[:"new_production"\].default.call\(@scanner,self\)\n*$/
+    @compiler.code.should =~ /^( |\t|\n)*return result\n*$/
+    @compiler.code.strip.should =~ /^( |\t|\n)*end$/
+  end
+
+  it "should build an 'if'..'elsif' block for a sequence of tokens" do
+		
+    @compiler.start(:new_production)
+    @compiler.token(:first_token)
+    @compiler.token(:second_token)
+    @compiler.code.strip.should =~ /^( |\t|\n)*if @scanner.current == :"first_token"$/
+    @compiler.code.strip.should =~ /^( |\t|\n)*result = productions\[:"new_production"\].tokens\[:"first_token"\].call\(result,@scanner,self\)$/
+    @compiler.code.strip.should =~ /^( |\t|\n)*elsif @scanner.current == :"second_token"$/
+    @compiler.code.strip.should =~ /^( |\t|\n)*result = productions\[:"new_production"\].tokens\[:"second_token"\].call\(result,@scanner,self\)$/
+  end
+	
+  it "should build an 'if'..'elsif' block for a sequence of tokens" do
+    @compiler.start(:new_production)
+    @compiler.token("token")
+    @compiler.code.strip.should =~ /^( |\t|\n)*if @scanner.current == 'token'$/
+    @compiler.code.strip.should =~ /^( |\t|\n)*result = productions\[:"new_production"\].tokens\['token'\].call\(result,@scanner,self\)$/
+  end
+	
+  it "should close the 'if' block with an appropriate raising 'else' clause as a default" do
+    @compiler.start(:new_production)
+    @compiler.token(:first_token)
+
+    lambda { @compiler.end }.should_not raise_error
+		
+    @compiler.code.strip.should =~ /^( |\t|\n)*if @scanner.current == :"first_token"$/
+    @compiler.code.strip.should =~ /^( |\t|\n)*result = productions\[:"new_production"\].tokens\[:"first_token"\].call\(result,@scanner,self\)$/
+    @compiler.code.strip.should =~ /^( |\t|\n)*else$/
+    @compiler.code.strip.should =~ /^( |\t|\n)*raise NotAllowedTokenError.new\(@scanner.current,:"new_production"\)( |\t|\n)*end$/
+  end
+
+  it "should close the 'if' block without an 'else' clause if it's specified so" do
+    @compiler.start(:new_production)
+    @compiler.token(:first_token)
+
+    lambda { @compiler.end(false) }.should_not raise_error
+		
+    @compiler.code.strip.should =~ /^( |\t|\n)*if @scanner.current == :"first_token"$/
+    @compiler.code.strip.should =~ /^( |\t|\n)*result = productions\[:"new_production"\].tokens\[:"first_token"\].call\(result,@scanner,self\)( |\t|\n)*end$/
+  end
+
+  it "should produce an 'if'..'elsif' block containing lookaheads" do
+    @compiler.start(:new_production)
+    @compiler.token(["token","first","second"])
+    @compiler.token(["token","first"])
+    @compiler.token(["token","second"])
+    @compiler.code.strip.should =~ /^( |\t|\n)*if @scanner.current == 'token' and @scanner.lookahead\(1\) == 'first' and @scanner.lookahead\(2\) == 'second'$/
+    @compiler.code.strip.should =~ /^( |\t|\n)*result = productions\[:"new_production"\].tokens\[\['token','first','second'\]\].call\(result,@scanner,self\)$/
+    @compiler.code.strip.should =~ /^( |\t|\n)*elsif @scanner.current == 'token' and @scanner.lookahead\(1\) == 'first'$/
+    @compiler.code.strip.should =~ /^( |\t|\n)*result = productions\[:"new_production"\].tokens\[\['token','first'\]\].call\(result,@scanner,self\)$/
+    @compiler.code.strip.should =~ /^( |\t|\n)*elsif @scanner.current == 'token' and @scanner.lookahead\(1\) == 'second'$/
+    @compiler.code.strip.should =~ /^( |\t|\n)*result = productions\[:"new_production"\].tokens\[\['token','second'\]\].call\(result,@scanner,self\)$/
+  end
+
+  it "should not modify the lookaheads tokens" do
+    @compiler.start(:new_production)
+    lookahead = ["token","first","second"]
+    @compiler.token(lookahead)
+    lookahead.should == ["token","first","second"]
+  end
+
+  it "should produce code that doesn't raise Exceptions if evaluated" do
+    @compiler.start(:fake)
+    @compiler.token(:first)
+    @compiler.token(:second)
+    @compiler.token(:third)
+    @compiler.token([:fourth,:lk])
+    @compiler.token(:fourth)
+    @compiler.end
+
+    @class = Class.new
+    lambda { @class.class_eval(@compiler.code) }.should_not raise_error
+  end
+
+  it "should have a reset method which clean the code" do
+    @compiler.should respond_to(:reset)
+    @compiler.code.should == ""
+    @compiler.start(:fake)
+    @compiler.token(:first)
+    @compiler.token(:second)
+    @compiler.token(:third)
+    @compiler.end
+    @compiler.code.should_not == ""
+    @compiler.reset
+    @compiler.code.should == ""
+  end
+
+  it "should have a compile method which accept a ProductionSpecification and create the code" do
+    @compiler.should respond_to(:compile)
+
+    @production = mock "ProductionSpecification"
+    @production.should_receive(:name).and_return(:fake)
+    @production.should_receive(:tokens).and_return({ :first => nil, :second => nil, :third => nil})
+    @production.should_receive(:raise_on_error).and_return(false)
+
+    @compiler.should_receive(:start).with(:fake)
+    @compiler.should_receive(:token).with(:first)	
+    @compiler.should_receive(:token).with(:second)	
+    @compiler.should_receive(:token).with(:third)
+    @compiler.should_receive(:end).with(false)
+
+    @compiler.compile(@production)	
+  end
+
+  it "should compile a lookahead production correctly" do
+    @compiler.should respond_to(:compile)
+
+    @production = mock "Production"
+    @production.should_receive(:name).and_return(:fake)
+    @production.should_receive(:tokens).and_return({ [:look,"3"] => nil, [:look,"1"] => nil, :look => nil})
+    @production.should_receive(:raise_on_error).and_return(true)
+
+    @compiler.should_receive(:start).with(:fake)
+    @compiler.should_receive(:token).with([:look,"3"])	
+    @compiler.should_receive(:token).with([:look,"1"])
+    @compiler.should_receive(:token).with(:look)	
+    @compiler.should_receive(:end).with(true)
+
+    @compiler.compile(@production)	
+  end
+
+  it "should have a method to sort the productions correctly" do
+    @compiler.should respond_to(:sort_production)
+		
+    @production = mock "Production"
+    @production.should_receive(:tokens).and_return({ [:look,"1"] => nil, [:look,"3","2"] => nil, :everything => nil, :look => nil})
+		
+    @compiler.sort_production(@production).should == [[:look,"3","2"],[:look,"1"], :look, :everything]
+  end
+end
+
+
+describe "The code produced by a ProductionCompiler without lookaheads" do
+	
+  before(:each) do
+    @compiler = ProductionCompiler.new
+    @compiler.start(:fake)
+    @compiler.token(:first)
+    @compiler.token(:second)
+    @compiler.token(:third)
+    @compiler.token("+")
+    @compiler.end
+
+    @class = Class.new
+    lambda { @class.class_eval(@compiler.code) }.should_not raise_error
+    @class.class_eval <<-CODE 
+			attr_accessor :productions
+			attr_accessor :scanner
+		CODE
+    @instance = @class.new
+    @instance.productions = {
+      :fake => mock("ProductionSpecification")
+    }
+    @tokens = {  
+      :first => mock('first'),
+      :second => mock('second'),
+      :third => mock('third'),
+      "+" => mock('+')
+    }
+    @instance.productions[:fake].should_receive(:tokens).any_number_of_times.and_return(@tokens)
+    @instance.scanner = mock 'scanner'
+    @instance.scanner.should_receive(:next).any_number_of_times
+
+    @default = mock "default"
+    @instance.productions[:fake].should_receive(:default).any_number_of_times.and_return(@default)
+    @default.should_receive(:call).and_return(nil)
+  end
+
+  it "should call the specified block when received the correct token" do
+    @instance.scanner.should_receive(:current).and_return(:first)
+    @tokens[:first].should_receive(:call).with(nil,@instance.scanner,@instance)
+    @instance.parse_fake
+  end
+	
+  it "should call the specified block even if the token is a string" do
+    @instance.scanner.should_receive(:current).exactly(4).and_return("+")
+    @tokens["+"].should_receive(:call).with(nil,@instance.scanner,@instance)
+    @instance.parse_fake
+  end
+	
+  it "should call the specified block and return the correct value" do
+    @tokens[:second] = lambda { |result,scanner,parser| :ok }
+    @instance.scanner.should_receive(:current).twice.and_return(:second)
+    @instance.parse_fake.should == :ok
+  end
+
+  it "should raise an exception if the token isn't recognized" do
+    token = mock "Token"
+    token.should_receive(:value).and_return("value")
+    token.should_receive(:name).and_return(:a_name)
+    @instance.scanner.should_receive(:current).exactly(@tokens.size + 1).times.and_return(token)
+    lambda { @instance.parse_fake }.should raise_error(NotAllowedTokenError)
+  end
+end
+
+describe "The code produced by a ProductionCompiler with lookaheads" do
+	
+  before(:each) do
+    @compiler = ProductionCompiler.new
+    @compiler.start(:fake)
+    @compiler.token([:token,:first,:third])
+    @compiler.token([:token,:second])
+    @compiler.token([:token,:third])
+    @compiler.token(:token)
+    @compiler.end
+
+    @class = Class.new
+    lambda { @class.class_eval(@compiler.code) }.should_not raise_error
+    @class.class_eval <<-CODE 
+			attr_accessor :productions
+			attr_accessor :scanner
+		CODE
+    @instance = @class.new
+    @instance.productions = {
+      :fake => mock("ProductionSpecification")
+    }
+    @tokens = {  
+      [:token,:first,:third] => mock('first'),
+      [:token,:second] => mock('second'),
+      [:token,:third] => mock('third'),
+      :token => mock('token')
+    }
+    @instance.productions[:fake].should_receive(:tokens).any_number_of_times.and_return(@tokens)
+    @instance.scanner = mock 'scanner'
+    @scanner = @instance.scanner
+
+    @default = mock "default"
+    @instance.productions[:fake].should_receive(:default).any_number_of_times.and_return(@default)
+    @default.should_receive(:call).and_return(nil)
+  end
+
+  it "should recognize the sequence [:token,:first,:third]" do
+    @scanner.should_receive(:current).once.and_return(:token)
+    @scanner.should_receive(:lookahead).with(1).once.and_return(:first)
+    @scanner.should_receive(:lookahead).with(2).once.and_return(:third)
+		
+    @tokens[[:token,:first,:third]].should_receive(:call).with(nil,@scanner,@instance)
+
+    @instance.parse_fake
+  end
+end

data/spec/llip/production_specification_spec.rb

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'production_specification'
+
+describe "A ProductionSpecification" do
+  
+  before(:each) do 
+    @production = ProductionSpecification.new(:test_production)
+  end
+
+  it "should have a name" do
+    @production.should respond_to(:name)
+    @production.name.should == :test_production
+  end
+
+  it "should allow to specify a recognized token with a block parameter" do
+    @production.should respond_to(:token)
+    lambda { @production.token(:token_name) { "hello" } }.should_not raise_error
+  end
+
+  it "should have some tokens" do
+    @production.should respond_to(:tokens)
+    @production.tokens.should == {}
+  
+    first_block = lambda { :first_block }
+    second_block = lambda { :second_block }
+    @production.token(:first_token,&first_block)
+    @production.token(:second_token,second_block)
+
+    @production.tokens[:first_token].should == first_block
+    @production.tokens[:second_token].should == second_block
+  end
+
+  it "should have a 'mode' attribute with a default (:single)" do
+    @production.should respond_to(:mode)
+    @production.mode.should == :single
+    
+    @production.should respond_to(:mode=)
+    @production.mode= :recursive
+    @production.mode.should == :recursive
+  end
+
+  it "should have a default result" do
+    @production.should respond_to(:default)
+    @production.default.should respond_to(:call)
+    @production.default.call.should be_nil
+
+    called = false
+    @production.default { called = true }
+    @production.default.call
+    called.should == true
+
+    block = mock "block"
+    block.should_receive(:call)
+    @production.default(block)
+    @production.default.call
+  end
+
+  it "should accept as a token an array" do
+    @production.token([:first,:second])
+    @production.tokens.has_key?([:first,:second]).should be_true
+  end
+
+  it "should assume that a lot of symbols as arguments are an array" do
+    @production.token :first, :second
+    @production.tokens.has_key?([:first,:second]).should be_true
+  end
+
+  it "should have a :raise_on_error attribute with true as a default" do
+    @production.should respond_to(:raise_on_error)
+    @production.should respond_to(:raise_on_error=)
+    @production.raise_on_error.should == true
+    @production.raise_on_error=false
+    @production.raise_on_error.should == false
+  end
+end

data/spec/llip/recursive_production_compiler_spec.rb

@@ -0,0 +1,86 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'recursive_production_compiler'
+
+describe "A RecursiveProductionCompiler" do
+	
+  before(:each) do
+    @compiler = RecursiveProductionCompiler.new
+  end
+
+  it "should add to the 'start' and 'end' method a behaviour that add a while cycle to the code" do
+    @compiler.should respond_to(:start)
+    @compiler.start(:new_production)
+    @compiler.end
+
+    @compiler.code.strip.should =~ /^def parse_new_production$/
+    @compiler.code.should =~ /^( |\t|\n)*result = productions\[:"new_production"\].default.call\(@scanner,self\)\n*$/
+    @compiler.code.should =~ /^( |\t|\n)*while not @scanner\.current\.nil\?\n(.|\t|\n)*end$/
+    @compiler.code.should =~ /^( |\t|\n)*return result\n*$/
+    @compiler.code.strip.should =~ /^( |\t|\n)*end$/
+  end
+
+  it "should modify the 'else' behaviour to break, instead of raise" do
+    @compiler.start(:new_production)
+    @compiler.token(:first_token)
+
+    lambda { @compiler.send(:build_else) }.should_not raise_error
+		
+    @compiler.code.strip.should =~ /^( |\t|\n)*if @scanner.current == :"first_token"$/
+    @compiler.code.strip.should =~ /^( |\t|\n)*result = productions\[:"new_production"\].tokens\[:"first_token"\].call\(result,@scanner,self\)$/
+    @compiler.code.strip.should =~ /^( |\t|\n)*else$/
+    @compiler.code.strip.should =~ /^( |\t|\n)*break\n( |\t|\n)*end$/
+  end
+	
+  it "should produce code that doesn't raise Exceptions if evaluated" do
+    @compiler.start(:fake)
+    @compiler.token(:first)
+    @compiler.token(:second)
+    @compiler.token(:third)
+    @compiler.end
+		
+    @class = Class.new
+    lambda { @class.class_eval(@compiler.code) }.should_not raise_error
+  end
+end
+
+describe "The code produced by RecursiveProductionCompiler" do
+	
+  before(:each) do
+    @compiler = RecursiveProductionCompiler.new
+    @compiler.start(:fake)
+    @compiler.token(:first)
+    @compiler.token(:second)
+    @compiler.token(:third)
+    @compiler.end
+
+    @class = Class.new
+    lambda { @class.class_eval(@compiler.code) }.should_not raise_error
+    @class.class_eval <<-CODE 
+			attr_accessor :productions
+			attr_accessor :scanner
+		CODE
+    @instance = @class.new
+    @instance.productions = {
+      :fake => mock("ProductionSpecification")
+    }
+    @tokens = {  
+      :first => mock('first'),
+      :second => mock('second'),
+      :third => mock('third')
+    }
+    @instance.productions[:fake].should_receive(:tokens).any_number_of_times.and_return(@tokens)
+    @instance.scanner = mock 'scanner'
+    @instance.scanner.should_receive(:next).any_number_of_times
+	
+    @default = mock "default"
+    @instance.productions[:fake].should_receive(:default).any_number_of_times.and_return(@default)
+    @default.should_receive(:call).and_return(nil)
+  end
+
+  it "should call the specified block the number of times the token is given" do
+    @instance.scanner.should_receive(:current).exactly(7).times.and_return(*([:first]*6 + [nil]))
+    @tokens[:first].should_receive(:call).exactly(3).times.and_return("hello")
+    lambda { @instance.parse_fake.should == "hello" }.should_not raise_error
+  end
+end
+

data/spec/llip/regexp_abstract_scanner_spec.rb

@@ -0,0 +1,320 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'regexp_abstract_scanner'
+
+describe "A class descending from RegexpAbstractScanner" do
+
+  before(:each) do
+    @class = Class.new(RegexpAbstractScanner)
+    @scanner = @class.new
+    @class.should_receive(:build).any_number_of_times
+  end
+
+  it "should respond to next and return Token.new if it isn't scanning a string" do
+    @scanner.should respond_to(:next)
+    @scanner.next.should be_kind_of(Token)
+    @scanner.next.should be_nil
+  end
+
+  it "should allow to add some regexp adding them to its scanning table" do
+    @class.should respond_to(:add_regexp)
+    r = mock "regexp"
+    r.should_receive(:starting_chars).and_return(["a","b"])
+    lambda { @class.add_regexp(r) }.should_not raise_error
+    @class.scanning_table['a'].should == r	
+    @class.scanning_table['b'].should == r
+
+    r2 = mock "regexp2"
+    r2.should_receive(:starting_chars).and_return(["c","d"])	
+    @class.add_regexp(r2)
+    @class.scanning_table['c'].should == r2	
+    @class.scanning_table['d'].should == r2
+  end
+
+  it "should handle correctly if two regexp ('ab', 'ac') have some starting chars in common" do
+    r1 = mock "regexp1"
+    s1 = mock "state1"
+    s2 = mock "state2"
+    s3 = mock "state3"
+    r1.should_receive(:starting_chars).any_number_of_times.and_return(["a"])
+    r1.should_receive(:name).any_number_of_times.and_return("r1")
+    r1.should_receive(:init).any_number_of_times.and_return(s1)
+    s1.should_receive(:keys).any_number_of_times.and_return(["a"])
+    s1.should_receive(:[]).any_number_of_times.with("a").and_return(s2)
+    s1.should_receive(:final?).any_number_of_times.and_return(false)
+    s2.should_receive(:keys).any_number_of_times.and_return(['b'])
+    s2.should_receive(:[]).with('b').and_return(s3)
+    s2.should_receive(:final?).any_number_of_times.and_return(false)
+    s3.should_receive(:keys).any_number_of_times.and_return([])
+    s3.should_receive(:final?).any_number_of_times.and_return(true)
+    s1.should_receive(:error).any_number_of_times.and_return(:error)
+    s2.should_receive(:error).any_number_of_times.and_return(:error)
+    s3.should_receive(:error).any_number_of_times.and_return(:error)
+    s1.should_receive(:regexp).any_number_of_times.and_return(r1)
+    s2.should_receive(:regexp).any_number_of_times.and_return(r1)
+    s3.should_receive(:regexp).any_number_of_times.and_return(r1)
+
+    r2 = mock "regexp2"
+    s4 = mock "state4"
+    s5 = mock "state5"
+    s6 = mock "state6"
+    r2.should_receive(:starting_chars).any_number_of_times.and_return(["a"])
+    r2.should_receive(:name).any_number_of_times.and_return("r2")
+    r2.should_receive(:init).any_number_of_times.and_return(s4)
+    s4.should_receive(:keys).any_number_of_times.and_return(["a"])
+    s4.should_receive(:[]).any_number_of_times.with("a").and_return(s5)
+    s4.should_receive(:final?).any_number_of_times.and_return(false)
+    s5.should_receive(:keys).any_number_of_times.and_return(['c'])
+    s5.should_receive(:[]).with('c').and_return(s6)
+    s5.should_receive(:final?).any_number_of_times.and_return(false)
+    s6.should_receive(:keys).any_number_of_times.and_return([])
+    s6.should_receive(:final?).any_number_of_times.and_return(true)
+    s4.should_receive(:error).any_number_of_times.and_return(:error)
+    s5.should_receive(:error).any_number_of_times.and_return(:error)
+    s6.should_receive(:error).any_number_of_times.and_return(:error)
+    s4.should_receive(:regexp).any_number_of_times.and_return(r2)
+    s5.should_receive(:regexp).any_number_of_times.and_return(r2)
+    s6.should_receive(:regexp).any_number_of_times.and_return(r2)
+		
+    @class.add_regexp(r1)
+    lambda { @class.add_regexp(r2) }.should_not raise_error
+    @class.scanning_table['a'].should be_kind_of(RegexpSpecification)
+    init = @class.scanning_table['a'].init
+    second = init['a']
+    second.keys.should == ['b','c']
+    second['b'].should == s3
+    second['c'].should == s6
+  end
+
+  it "should set the default value of the scanning table to the regexp that have starting_chars == :everything" do
+    r = mock "regexp"
+    r.should_receive(:starting_chars).and_return(:everything)
+    lambda { @class.add_regexp(r) }.should_not raise_error
+    lambda { @class.scanning_table['a'].should == r }.should_not raise_error
+  end
+
+  it "should expose its scanning table" do
+    @class.should respond_to(:scanning_table)
+    @class.scanning_table.should be_kind_of(Hash)
+    lambda { @class.scanning_table['a'] }.should_not raise_error
+  end
+
+  it "should be able to scan a simple regexp" do
+    r = mock "regexp"
+    s1 = mock "state1"
+    s2 = mock "state"
+    r.should_receive(:init).and_return(s1)
+    r.should_receive(:starting_chars).and_return(["a"])
+    r.should_receive(:name).and_return(:a_name)
+    s1.should_receive(:[]).twice.with('a').and_return(s2)
+    s2.should_receive(:[]).and_return(:error)
+    s2.should_receive(:final?).and_return(true)
+    s2.should_receive(:regexp).and_return(r)
+
+    @class.add_regexp(r)
+    @scanner.scan("a")
+    token = @scanner.next
+    token.should be_kind_of(Token)
+    token.should == "a"
+    token.should == :a_name
+    token.line.should == 0
+    token.char.should == 0
+		
+    @scanner.scan("b")
+    lambda { @scanner.next }.should raise_error(LLIPError)
+  end
+
+  it "should be able to scan '.*b' and 'eb' " do
+    r1 = mock "first"
+    s1 = mock "state1"
+    s2 = mock "state2"
+    r1.should_receive(:init).any_number_of_times.and_return(s1)
+    r1.should_receive(:starting_chars).and_return(:everything)
+    r1.should_receive(:name).any_number_of_times.and_return(:first_name)
+    s1.should_receive(:[]).any_number_of_times.with('b').and_return(s2)
+    s1.should_receive(:[]).any_number_of_times.and_return(s1)
+    s1.should_receive(:final?).and_return(false)
+    s2.should_receive(:[]).any_number_of_times.and_return(:error)
+    s2.should_receive(:final?).any_number_of_times.and_return(true)
+    s1.should_receive(:regexp).any_number_of_times.and_return(r1)
+    s2.should_receive(:regexp).any_number_of_times.and_return(r1)
+
+    r2 = mock "second"
+    s3 = mock "state3"
+    s4 = mock "state4"
+    s5 = mock "state5"
+    r2.should_receive(:init).any_number_of_times.and_return(s3)
+    r2.should_receive(:starting_chars).and_return(["e"])
+    r2.should_receive(:name).any_number_of_times.and_return(:second_name)
+    s3.should_receive(:[]).any_number_of_times.with('e').and_return(s4)
+    s3.should_receive(:final?).any_number_of_times.and_return(false)
+    s4.should_receive(:[]).any_number_of_times.with('b').and_return(s5)
+    s5.should_receive(:[]).any_number_of_times.and_return(:error)
+    s5.should_receive(:final?).any_number_of_times.and_return(true)
+    s3.should_receive(:regexp).any_number_of_times.and_return(r2)
+    s4.should_receive(:regexp).any_number_of_times.and_return(r2)
+    s5.should_receive(:regexp).any_number_of_times.and_return(r2)
+		
+    @class.add_regexp(r1)
+    @class.add_regexp(r2)
+
+    @scanner.scan("acdb \nb abd")
+    @scanner.next.should == "acdb"
+    @scanner.current.char == 0
+    @scanner.current.line == 0
+    @scanner.current.name == :first_name
+
+    @scanner.current.should == "acdb"	
+    @scanner.next.should == " \nb"
+    @scanner.current.char == 4
+    @scanner.current.line == 0
+    @scanner.next.should == " ab"
+    @scanner.current.line == 1
+    @scanner.current.char == 0
+    lambda { @scanner.next }.should raise_error(UnvalidTokenError)
+		
+    @scanner.scan("b")
+    @scanner.next
+    token = @scanner.next
+    token.should be_nil
+    token.line.should == 2
+
+    @scanner.scan("eb")
+    token = @scanner.next
+    token.should == "eb"
+    token.name.should == :second_name
+  end
+
+
+  it "should be able to scan '\+ *'" do
+    r = mock "regexp"
+    s1 = mock "state1"
+    s2 = mock "state"
+    r.should_receive(:init).any_number_of_times.and_return(s1)
+    r.should_receive(:starting_chars).and_return(['+'])
+    r.should_receive(:name).any_number_of_times.and_return(:a_name)
+    s1.should_receive(:[]).any_number_of_times.with('+').and_return(s2)
+    s2.should_receive(:[]).any_number_of_times.with(' ').and_return(s2)
+    s2.should_receive(:[]).any_number_of_times.and_return(:error)
+    s2.should_receive(:final?).any_number_of_times.and_return(true)
+    s1.should_receive(:regexp).any_number_of_times.and_return(r)
+    s2.should_receive(:regexp).any_number_of_times.and_return(r)
+
+    @class.add_regexp(r)
+    @scanner.scan("+")
+    @scanner.next.should == "+"
+    @scanner.current.should == "+"	
+    @scanner.next.should be_nil
+		
+    @scanner.scan("+ ")
+    @scanner.next.should == "+ "		
+    @scanner.current.should == "+ "	
+    @scanner.next.should be_nil
+	
+    @scanner.scan("+    ")
+    @scanner.next.should == "+    "		
+    @scanner.current.should == "+    "	
+    @scanner.next.should be_nil
+  end
+
+end
+
+describe "A class descending from RegexpAbstractScanner with the build method exposed" do
+	
+  before(:each) do
+    @class = Class.new(RegexpAbstractScanner)
+  end
+
+  it "should be able to scan '.+' and 'eb' " do
+    r1 = mock "first"
+    s1 = mock "state1"
+    r1.should_receive(:init).any_number_of_times.and_return(s1)
+    r1.should_receive(:starting_chars).and_return(:everything)
+    r1.should_receive(:name).any_number_of_times.and_return(:first_name)
+    r1.should_receive(:last).any_number_of_times.and_return([s1])
+    s1.should_receive(:[]=).with("e",:error)
+    s1.should_receive(:[]).with("e").and_return(:error)
+    s1.should_receive(:[]).any_number_of_times.and_return(s1)
+    s1.should_receive(:final?).any_number_of_times.and_return(true)
+    s1.should_receive(:error).any_number_of_times.and_return(s1)
+    s1.should_receive(:regexp).any_number_of_times.and_return(r1)
+
+    r2 = mock "second"
+    s3 = mock "state3"
+    s4 = mock "state4"
+    s5 = mock "state5"
+    r2.should_receive(:init).any_number_of_times.and_return(s3)
+    r2.should_receive(:starting_chars).and_return(["e"])
+    r2.should_receive(:name).any_number_of_times.and_return(:second_name)
+    r2.should_receive(:last).any_number_of_times.and_return([s5])
+    s3.should_receive(:[]).any_number_of_times.with('e').and_return(s4)
+    s3.should_receive(:final?).any_number_of_times.and_return(false)
+    s4.should_receive(:[]).any_number_of_times.with('b').and_return(s5)
+    s5.should_receive(:[]).any_number_of_times.and_return(:error)
+    s5.should_receive(:final?).any_number_of_times.and_return(true)
+    s5.should_receive(:error).any_number_of_times.and_return(nil)
+    s3.should_receive(:regexp).any_number_of_times.and_return(r2)
+    s4.should_receive(:regexp).any_number_of_times.and_return(r2)
+    s5.should_receive(:regexp).any_number_of_times.and_return(r2)
+
+    @class.add_regexp(r1)
+    @class.add_regexp(r2)
+		
+    @scanner = @class.new
+		
+    @scanner.scan("acdb \nb abd")
+    token = @scanner.next
+    token.should == "acdb \nb abd"
+
+    @scanner.scan("aeb")
+    token = @scanner.next
+    token.should == "a"
+    token.name.should == :first_name
+    token = @scanner.next
+    token.should == "eb"
+    token.name.should == :second_name
+
+    @scanner.scan("eb")
+    token = @scanner.next
+    token.should == "eb"
+    token.name.should == :second_name
+  end
+
+  it "should recall the build method if a new regexp is added and the scanner has already been built" do
+    @class.built?.should == false
+    @scanner = @class.new
+    @class.built?.should == true
+    @class.should_receive(:build)
+    r = mock "regexp"
+    r.should_receive(:starting_chars).and_return(["a"])
+    @class.add_regexp(r)
+  end
+
+  it "should have a build method which sets :error for every final state which ends with '.*' or '.+'" do
+    @class.should respond_to(:build)
+    @class.should respond_to(:built?)
+
+    r1 = mock "normal"
+    s1 = mock "state1"
+    s2 = mock "state2"
+    r1.should_receive(:init).any_number_of_times.and_return(s1)
+    r1.should_receive(:starting_chars).and_return(["a"])
+    r1.should_receive(:last).and_return([s2])
+    s2.should_receive(:error).any_number_of_times.and_return(:error)
+
+    r2 = mock "everything"
+    s3 = mock "state3"
+    r2.should_receive(:init).any_number_of_times.and_return(s3)
+    r2.should_receive(:starting_chars).and_return(:everything)
+    r2.should_receive(:last).and_return([s3])
+    s3.should_receive(:error).any_number_of_times.and_return(s3)
+    s3.should_receive(:[]=).with("a",:error)
+
+    @class.add_regexp(r1)
+    @class.add_regexp(r2)
+		
+    @class.built?.should == false
+		
+    @class.build.should == @class
+    @class.built?.should == true
+  end
+end