llip 0.1.0

data/spec/llip/abstract_scanner_spec.rb

@@ -0,0 +1,152 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'abstract_scanner'
+require 'stringio'
+
+describe "An AbstractScanner" do
+
+  before(:each) do
+    @instance = AbstractScanner.new
+  end
+
+  it "should be able to scan a string" do
+    @instance.should respond_to(:scan)
+    @instance.should_receive(:read_next).once
+    lambda { @instance.scan("this is a string") }.should_not raise_error
+    @instance.source.should be_kind_of(StringIO)	
+    @instance.source.string.should == "this is a string"
+  end
+
+  it "should be able to scan an IO" do
+    @instance.should respond_to(:scan)
+    @instance.should_receive(:read_next).once
+    io = StringIO.new("this is a string")
+    lambda { @instance.scan(io) }.should_not raise_error
+    @instance.source.should == io	
+  end
+
+  it "should have a source attribute" do
+    @instance.should respond_to(:source)
+    @instance.source.should be_nil
+  end
+
+  it "should call scan when initialized with an argument" do
+    lambda { @instance = AbstractScanner.new("this is a string") }.should_not raise_error
+    @instance.source.string.should == "this is a string"
+    io = StringIO.new("this is another string")
+    lambda { @instance = AbstractScanner.new(io) }.should_not raise_error
+    @instance.source.should == io
+  end
+
+  it "should increments :current_line and reset :current_char when called :scan" do
+    @instance.should_receive(:read_next).once
+    @instance.instance_variable_set(:@current_char,5)
+    @instance.scan("b")
+    @instance.current_line.should == 0
+    @instance.current_char.should == -1
+  end
+
+  it "should initialize current to a Token" do
+    @instance.should respond_to(:current)
+    @instance.current.should be_kind_of(Token)	
+  end
+
+  it "should have a current_line attribute which is initialized at -1" do
+    @instance.should respond_to(:current_line)
+    @instance.current_line.should == -1
+  end
+
+  it "should have a current_char attribute which is initialized at -1" do
+    @instance.should respond_to(:current_char)
+    @instance.current_char.should == -1
+  end
+
+  it "should have a next method which raises a NotImplementedError" do
+    lambda { @instance.next }.should raise_error(NotImplementedError)
+  end
+end
+
+describe "An AbstractScanner with all its protected methods exposed should have a read_next method" do
+	
+  before(:each) do
+    @protected_methods = AbstractScanner.protected_instance_methods(false)
+    @protected_methods.each { |m| AbstractScanner.send(:public,m) }
+    @instance = AbstractScanner.new
+    @instance.should respond_to(:read_next)	
+  end
+
+  after(:each) do
+    @protected_methods.each { |m| AbstractScanner.send(:protected,m) }
+  end
+
+  it "which reads a char from the source" do
+    @instance.scan("This is a string") # scan automatically calls read_next. See the previous context.
+    @instance.source.readchar.chr.should == "h"
+    @instance.read_next.should == "i"
+    @instance.source.readchar.chr.should == "s"
+  end
+
+  it "which handles correctly eof" do
+    @instance.scan("a")
+    lambda { @instance.read_next }.should_not raise_error
+    @instance.source.should be_eof	
+    @instance.instance_variable_get("@next_char").should be_nil
+  end
+
+  it "which store the read char into @next_char" do
+    @instance.scan("ab")
+    @instance.instance_variable_get("@next_char").should == "a"
+    @instance.read_next
+    @instance.instance_variable_get("@next_char").should == "b"
+  end
+
+  it "which reads correctly multibyte chars" do
+    @instance.scan("éòù")
+    @instance.read_next.should == "ò"
+    @instance.read_next.should == "ù"
+    @instance.read_next.should be_nil
+  end
+
+  it "which increments :current_line for every line read" do
+    @instance.scan("cc\nb\ng")
+    @instance.read_next.should == "c"
+    @instance.current_line == 0
+    @instance.read_next.should == "\n"
+    @instance.current_line == 1
+    @instance.read_next.should == "b"
+    @instance.read_next.should == "\n"
+    @instance.current_line == 2
+    @instance.read_next.should == "g"
+  end
+
+  it "which increments :current_char for every char read" do
+    @instance.scan("abcde")
+    @instance.current_char.should == 0
+		
+    @instance.read_next.should == "b"
+    @instance.current_char.should == 1
+
+    @instance.read_next.should == "c"
+    @instance.current_char.should == 2
+
+    @instance.read_next.should == "d"
+    @instance.current_char.should == 3
+
+    @instance.read_next.should == "e"
+    @instance.current_char.should == 4
+  end
+
+  it "which reset :current_char for every line read" do
+    @instance.scan("cc\nb\ng")
+    @instance.read_next.should == "c"
+			
+    @instance.read_next.should == "\n"
+    @instance.current_char.should == -1
+    @instance.current_line == 1
+    @instance.read_next.should == "b"
+    @instance.read_next.should == "\n"
+    @instance.current_char.should == -1
+    @instance.current_line == 2
+    @instance.read_next.should == "g"
+
+  end
+end

data/spec/llip/buffer_spec.rb

@@ -0,0 +1,60 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'buffer'
+
+describe "A Buffer" do
+	
+  before(:each) do
+    @scanner = mock 'Scanner'
+    @buf = Buffer.new(@scanner)
+  end
+
+  it "should wrap a scanner" do
+    @buf.should respond_to(:scanner)
+    @buf.should respond_to(:scanner=)
+
+    @buf.scanner.should == @scanner
+
+    @buf.scanner = nil
+    @buf.scanner.should be_nil
+  end
+
+  it "should have a next method, which calls the scanner's next method" do
+    @buf.should respond_to(:next)
+    @scanner.should_receive(:next).and_return(:token)
+    @buf.next.should == :token
+  end
+
+  it "should have a scan method, which calls the scanner's scan method" do
+    @buf.should respond_to(:scan)
+    @scanner.should_receive(:scan).with("a string")
+    @buf.scan("a string").should == @buf
+  end
+
+  it "should have a current method, which returns the last token read" do
+    @buf.should respond_to(:current)
+    @scanner.should_receive(:next).and_return(:token)
+    @buf.next
+    @buf.current.should == :token
+  end
+
+  it "should allow lookahead" do
+    @buf.should respond_to(:lookahead)
+    @scanner.should_receive(:next).and_return(:first,:second,:third,nil)
+    @buf.next
+    @buf.current.should == :first
+
+    @buf.lookahead(1).should == :second
+    @buf.current.should == :first
+
+    @buf.lookahead(2).should == :third
+    @buf.lookahead(1).should == :second
+    @buf.current.should == :first
+	
+    @buf.next
+
+    @buf.lookahead(2).should be_nil
+    @buf.lookahead(1).should == :third
+    @buf.current.should == :second
+  end	
+end
+

data/spec/llip/llip_error_spec.rb

@@ -0,0 +1,77 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'llip_error'
+
+describe "An LLIPError" do
+
+  before(:each) do
+    @instance = LLIPError.new(:a_token)
+  end
+
+  it "should have a Token and a optional message as initialization arguments" do
+    lambda { @instance = LLIPError.new }.should raise_error(ArgumentError)	
+    lambda { @instance = LLIPError.new(:a_token,"a message") }.should_not raise_error
+  end
+
+  it "should have a :token attribute" do
+    @instance.should respond_to(:token)
+    @instance.token.should == :a_token
+  end
+
+  it "should add information about the line and the char from the token to the message" do
+    token = mock("Token")
+    @instance = LLIPError.new(token,"this is a fake error message.")
+    token.should_receive(:line).and_return(1)
+    token.should_receive(:char).and_return(5)
+
+    @instance.to_s.should == "At line 1 char 5 a LLIP::LLIPError occurred: this is a fake error message."
+  end
+end
+
+describe "An instance of a class descending from LLIPError" do
+
+  before(:each) do
+    @class = Class.new(LLIPError)
+  end
+
+  it "should have the right to_s method" do
+    @class.should_receive(:name).and_return("FakeLLIPError")
+		
+    token = mock("Token")
+    @instance = @class.new(token,"this is a fake error message.")
+    token.should_receive(:line).and_return(1)
+    token.should_receive(:char).and_return(5)
+
+		
+    @instance.to_s.should == "At line 1 char 5 a FakeLLIPError occurred: this is a fake error message."
+  end
+end
+
+describe "A UnvalidTokenError" do
+	
+  it "should have a correct to_s method " do
+    token = mock("Token")
+    token.should_receive(:line).and_return(1)
+    token.should_receive(:char).and_return(5)
+    token.should_receive(:value).and_return("a")
+    token.should_receive(:name).and_return(:a_regexp)
+
+    @instance = UnvalidTokenError.new(token)
+    @instance.to_s.should == "At line 1 char 5 a LLIP::UnvalidTokenError occurred: the current token 'a' doesn't match with the regular expression a_regexp."
+  end
+
+end
+
+describe "A NotAllowedTokenError" do
+	
+  it "should have a correct to_s method " do
+    token = mock("Token")
+    token.should_receive(:line).and_return(1)
+    token.should_receive(:char).and_return(5)
+    token.should_receive(:value).and_return("a")
+    token.should_receive(:name).and_return(:a_regexp)
+
+    lambda { @instance = NotAllowedTokenError.new(token,:a_production) }.should_not raise_error
+    @instance.to_s.should == "At line 1 char 5 a LLIP::NotAllowedTokenError occurred: the token 'a' matched by the regexp 'a_regexp' isn't allowed in production a_production."
+  end
+
+end

data/spec/llip/parser_spec.rb

@@ -0,0 +1,163 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'parser'
+require 'stringio'
+
+describe "A class that descend from Parser" do
+  before(:each) do
+    @class = Class.new(Parser)
+  end
+
+  it "should have an attribute parser which descends from AbstractParser"  do
+    @class.should respond_to(:parser)
+    @class.parser.should be_kind_of(Class)
+    @class.parser.ancestors[1].should == AbstractParser
+  end
+
+  it "should have an attribute scanner which descends from RegexpAbstractScanner"  do
+    @class.should respond_to(:scanner)
+    @class.scanner.should be_kind_of(Class)
+    @class.scanner.ancestors[1].should == RegexpAbstractScanner
+  end
+
+  it "should redirect :production, :scope to the parser" do
+    @class.should respond_to(:production)
+    @class.should respond_to(:scope)
+		
+    m = mock("parser")
+    m.should_receive(:production).and_return(:prod)
+    m.should_receive(:scope).and_return(:scop)
+
+    @class.instance_variable_set(:@parser,m)
+		
+    @class.production
+    @class.scope
+  end
+
+  it "should have a :regexp_parser and :regexp_scanner attributes" do
+    @class.should respond_to(:regexp_parser)
+    @class.should respond_to(:regexp_scanner)
+
+    @class.regexp_parser.should be_kind_of(RegexpParser)
+    @class.regexp_scanner.should be_kind_of(RegexpScanner)
+  end
+
+  it "should have a token method which parse a regexp and calls :add_regexp to the scanner" do
+
+    @class.should respond_to(:token)
+
+    rs = mock("regexp_scanner")
+    rs.should_receive(:scan).with("a regexp").and_return(rs)
+
+    regexp = mock("regexp")
+    regexp.should_receive(:name=).with(:a_name)
+
+    rp = mock("regexp_parser")
+    rp.should_receive(:parse).with(rs).and_return(regexp)
+
+    m = mock("scanner")
+    m.should_receive(:add_regexp).with(regexp)
+
+    @class.instance_variable_set(:@regexp_scanner,rs)
+    @class.instance_variable_set(:@regexp_parser,rp)
+		
+    @class.instance_variable_set(:@scanner,m)
+    @class.token(:a_name,"a regexp")
+  end
+
+  it "should have a lookahead method which allow to set the lookahead behaviour" do
+    @class.should respond_to(:lookahead)
+    @class.lookahead.should == false
+    @class.lookahead(true)
+    @class.lookahead.should == true
+  end
+
+end
+
+describe "The instance of a class desceding from Parser" do
+
+  before(:each) do
+    @class = Class.new(Parser)
+    @instance = @class.new
+  end
+
+  it "should have a parser which must be kind of its class parser" do
+    @instance.should respond_to(:parser)
+    @instance.parser.should be_kind_of(@class.parser)
+  end
+
+  it "should have a scanner which must be kind of its class scanner" do
+    @instance.should respond_to(:scanner)
+    @instance.scanner.should be_kind_of(@class.scanner)
+  end
+
+  it "with lookahead(true) should have a buffer encapsuling the scanner instead of the scanner" do
+    @class.lookahead(true)
+    @instance = @class.new
+		
+    @instance.scanner.should be_kind_of(Buffer)
+    s = mock("scanner")
+    s.should_receive(:scan).with("a string").and_return(s)
+
+    @instance.scanner.scanner= s
+
+    result = mock("result")
+		
+    p = mock("parser")
+    p.should_receive(:parse).with(@instance.scanner).and_return(result)
+	
+    @instance.instance_variable_set(:@parser,p)
+
+    @instance.parse("a string")
+  end
+
+  it "should have a :parse method which accept a source and parse thrugh the parser and the scanner" do
+    @instance.should respond_to(:parse)
+
+    s = mock("scanner")
+    s.should_receive(:scan).with("a string").and_return(s)
+
+    result = mock("result")
+
+    p = mock("parser")
+    p.should_receive(:parse).with(s).and_return(result)
+
+    @instance.instance_variable_set(:@scanner,s)
+    @instance.instance_variable_set(:@parser,p)
+
+    @instance.parse("a string").should == result
+  end
+end
+
+describe "The instance of a class descending from Parser with a simple grammar should be able to parse" do
+	
+  before(:each) do
+    @class = Class.new(Parser)
+    @instance = @class.new
+
+    @class.token(:plus,"\\+")
+    @class.token(:number,("0".."9").to_a.join("|"))
+	
+    @class.scope(:exp)
+
+    @class.production(:exp,:recursive) do |p|
+      p.default { |scanner,parser| parser.parse_num }
+		
+      p.token(:plus) do |result,scanner,parser| 
+        scanner.next
+        result + parser.parse_num
+      end
+    end
+
+    @class.production(:num,:single) do |p| 
+      p.token(:number) do |result,scanner,parser|
+        result = scanner.current.value.to_i
+        scanner.next
+        result
+      end
+    end
+  end
+
+  it "'1+1'" do
+    @instance.parse("1+1").should == 2
+  end
+end