llip 0.1.0

data/spec/ariteval/exp_spec.rb

@@ -0,0 +1,232 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'exp'
+
+describe "A NumExp" do
+  before(:each) do 
+    @num = NumExp.new(5)
+  end
+
+  it "should return its value" do
+    @num.should respond_to(:value)
+
+    @num.value.should be_equal(5)
+  end
+
+  it "should return its value as a String" do
+    @num.to_s.should == "5"
+  end
+	
+  it "should call visitor.visit_num_exp in 'accept'" do
+    visitor = mock("Visitor")
+    visitor.should_receive(:visit_num_exp).with(@num)
+    @num.accept(visitor)
+  end
+end
+
+describe "A IdentExp" do
+	
+  before(:each) do
+    @ident = IdentExp.new("a")
+  end
+
+  it "should return its value" do
+    @ident.should respond_to(:value)
+
+    @ident.value.should == "a"
+  end
+
+  it "should be coerced to a String" do
+    @ident.to_s.should == @ident.value
+  end
+
+  it "should call visitor.visit_ident_exp in 'accept'" do
+    visitor = mock("Visitor")
+    visitor.should_receive(:visit_ident_exp).with(@ident)
+    @ident.accept(visitor)
+  end
+
+end
+
+describe "An AssignIdentExp" do
+	
+  before(:each) do
+    @assign = AssignIdentExp.new("a",5)
+  end
+
+  it "should return its name" do
+    @assign.should respond_to(:name)
+    @assign.name.should == "a"
+  end
+
+  it "should be coerced to a String" do
+    @assign.to_s.should == "( a = 5 )"
+  end
+
+  it "should call visitor.visit_assign_ident_exp in 'accept'" do
+    visitor = mock("Visitor")
+    visitor.should_receive(:visit_assign_ident_exp).with(@assign)
+    @assign.accept(visitor)
+  end
+end
+
+describe "OpExp", :shared => true do
+
+  it "should have a left and a right child" do
+    @exp.should respond_to(:left)
+    @exp.should respond_to(:right)
+	
+    @exp.left.should be_equal(:left)
+    @exp.right.should be_equal(:right)
+  end
+
+  it "should respond to 'op'" do
+    @exp.should respond_to(:op)
+  end
+
+  it "should be represented by a String" do
+    @exp.should_receive(:op).and_return("op")
+
+    @exp.to_s.should == "( left op right )"
+  end
+end
+
+describe "An OpExp" do
+  it_should_behave_like "OpExp"
+  
+  before(:each) do
+    @exp = OpExp.new(:left,:right)
+  end
+  
+  it "should not be equal to another one with different values" do
+    @exp.should_not == "ciao"
+
+    new_exp = OpExp.new(:different_left,:different_right)
+    @exp.should_not == new_exp
+  end
+
+  it "should be equal to another one with the same values" do
+    new_exp = OpExp.new(:left,:right)
+    @exp.should == new_exp
+  end
+end
+
+describe "A PlusExp" do
+  
+  it_should_behave_like "OpExp"
+  
+  before(:each) do
+    @exp = PlusExp.new(:left,:right)
+  end
+
+  it "should have op = '+'" do
+    @exp.op.should == "+"
+  end
+
+  it "should call visitor.visit_plus_exp in 'accept'" do
+    visitor = mock("Visitor")
+    visitor.should_receive(:visit_plus_exp).with(@exp)
+    @exp.accept(visitor)
+  end
+end
+
+describe "A MinusExp" do 
+  
+  it_should_behave_like "OpExp"
+  
+  before(:each) do
+    @exp = MinusExp.new(:left,:right)
+  end
+	
+  it "should have op = '-'" do
+    @exp.op.should == "-"
+  end
+	
+  it "should call visitor.visit_minus_exp in 'accept'" do
+    visitor = mock("Visitor")
+    visitor.should_receive(:visit_minus_exp).with(@exp)
+    @exp.accept(visitor)
+  end
+end
+
+describe "A MulExp" do
+  
+  it_should_behave_like "OpExp"
+  
+  before(:each) do
+    @exp = MulExp.new(:left,:right)
+  end
+	
+  it "should have op = '*'" do
+    @exp.op.should == "*"
+  end
+	
+  it "should call visitor.visit_mul_exp in 'accept'" do
+    visitor = mock("Visitor")
+    visitor.should_receive(:visit_mul_exp).with(@exp)
+    @exp.accept(visitor)
+  end
+end
+
+describe "A DivExp" do
+  
+  it_should_behave_like "OpExp"
+  
+  before(:each) do
+    @exp = DivExp.new(:left,:right)
+  end
+	
+  it "should have op = '/'" do
+    @exp.op.should == "/"
+  end
+	
+  it "should call visitor.visit_div_exp in 'accept'" do
+    visitor = mock("Visitor")
+    visitor.should_receive(:visit_div_exp).with(@exp)
+    @exp.accept(visitor)
+  end
+end
+
+describe "Using all the exp you should be able to represent" do
+  it "'3-5'" do
+    exp = MinusExp.new(NumExp.new(3),NumExp.new(5))
+		
+    exp.to_s.should == "( 3 - 5 )"
+  end
+
+  it "'2+5*4-1'" do
+    exp = MinusExp.new(
+      PlusExp.new(
+        NumExp.new(2),
+        MulExp.new(NumExp.new(5),NumExp.new(4))
+      ),
+      NumExp.new(1)
+    )
+		
+    exp.to_s.should == "( ( 2 + ( 5 * 4 ) ) - 1 )"
+  end
+
+  it "'3-5-1*5'" do
+    exp = MinusExp.new(
+        NumExp.new(3),
+        MinusExp.new(
+          NumExp.new(5),
+          MulExp.new(NumExp.new(1),NumExp.new(5))
+        )
+    )
+
+    exp.to_s.should == "( 3 - ( 5 - ( 1 * 5 ) ) )"
+  end
+
+  it "'a = 5'" do
+    exp = AssignIdentExp.new('a',NumExp.new(5))
+    exp.to_s.should == "( a = 5 )"
+  end
+
+  it "'( a = 3 * 2 ) - ( 24 + a )'" do
+    exp = MinusExp.new(
+      AssignIdentExp.new("a", MulExp.new(NumExp.new(3),NumExp.new(2))),
+      PlusExp.new(NumExp.new(24),IdentExp.new("a"))
+    )
+    exp.to_s.should == "( ( a = ( 3 * 2 ) ) - ( 24 + a ) )"
+  end
+end

data/spec/llip/abstract_parser_spec.rb

@@ -0,0 +1,273 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'abstract_parser'
+
+describe "A class descending from AbstractParser" do
+
+  before(:each) do
+    @class = Class.new(AbstractParser)
+    if @class.respond_to? :autocompile
+      @class.autocompile(false)
+    end
+    @parser = @class.new
+  end
+
+  it "should raise an exception if it hasn't been compiled" do
+    lambda { @parser.parse(:mock) }.should raise_error(RuntimeError)
+  end
+
+  it "should have hash-like capabilities" do
+    @parser.should respond_to(:[])
+    @parser.should respond_to(:[]=)
+
+    @parser[:var]= :foo
+    @parser[:var].should == :foo
+  end
+
+  it "should be able to specify a production with a name (and in case the mode), some tokens and blocks" do
+    @class.should respond_to(:production)
+
+    lambda do
+      @class.production(:name) do |prod| 
+        prod.token(:first_token) { "first" }
+        prod.token(:second_token) { "second" }
+      end
+    end.should_not raise_error
+
+
+    l = lambda do 
+      @class.production(:name,:mode) do |prod| 
+        prod.mode.should == :mode
+        prod.token(:first_token) { "first" }
+        prod.token(:second_token) { "second" }
+      end
+    end
+    l.should_not raise_error
+  end
+	
+  it "should memorize its productions in a hash of ProductionSpecification" do
+    @class.should respond_to(:productions)
+    @class.productions.should == {}
+		
+    @class.production(:name) do |prod| 
+      prod.token(:first_token) { "first" }
+      prod.token(:second_token) { "second" }
+    end	
+	
+    @class.productions[:name].should be_kind_of(ProductionSpecification)
+    @class.productions[:name].tokens[:first_token].should_not be_nil
+    @class.productions[:name].tokens[:second_token].should_not be_nil
+  end
+
+  it "should memorize the scope" do
+    @class.should respond_to(:scope)
+    @class.scope.should be_nil
+
+    @class.scope(:a_new_scope)
+    @class.scope.should == :a_new_scope
+  end
+	
+  it "should have an 'autocompile' attribute" do
+    @class.should respond_to(:autocompile)
+    @class.autocompile.should == false
+    lambda { @class.autocompile(true) }.should_not raise_error
+    @class.autocompile.should == true
+    lambda { @class.autocompile(false) }.should_not raise_error
+    @class.autocompile.should == false
+  end
+
+  it "should have a code attribute" do
+    @class.should respond_to(:code)
+    @class.code.should be_nil
+    @class.scope(:a_scope)
+    @class.production(:a_scope) {}
+    @class.compile
+    @class.code.should_not == ""
+  end
+
+  it "should initialize and fill 'code' when 'autocompile' is true" do
+    @class.autocompile false
+    @class.code.should be_nil
+    @class.autocompile true
+    @class.code.should == ""
+    @class.scope(:a_scope)
+    @class.code.should_not == ""
+    @class.production(:a_scope) {}
+    @class.code.should_not == ""
+  end
+
+  it "should raise if a production has an unknown mode" do
+    l = lambda {
+      @class.scope :first	
+      @class.production(:first) { |p| p.mode = :error_mode }
+      @class.compile	
+    }
+    l.should raise_error(RuntimeError)
+  end
+end
+
+describe "A class descending from AbstractParser with some productions specified" do
+	
+  before(:each) do
+    @class = Class.new(AbstractParser)
+    if @class.respond_to? :autocompile
+      @class.autocompile(false)
+    end
+    @parser = @class.new
+
+    @mock_single = mock "Single"
+    @mock_single.should_receive(:respond_to?).with(:to_ary).and_return(false)
+    @mock_single.should_receive(:respond_to?).with(:call).and_return(true)
+    @class.production(:single) do |prod|
+      prod.token(:single_token,@mock_single) 
+    end
+		
+    @mock_recursive = mock "Recursive"
+    @mock_recursive.should_receive(:respond_to?).with(:to_ary).and_return(false)
+    @mock_recursive.should_receive(:respond_to?).with(:call).and_return(true)
+    @class.production(:recursive) do |prod|
+      prod.mode=:recursive
+      prod.token(:recursive_token,@mock_recursive) 
+    end
+		
+    @class.should respond_to(:compile)
+    @class.should respond_to(:compiled)
+  end
+
+  it "should be compiled with a scope specified" do
+    @class.scope(:single)
+	
+    @class.compiled.should == false
+    lambda { @class.compile }.should_not raise_error
+    @class.compiled.should == true
+  end
+
+  it "shouldn't be compiled without a correct scope" do
+	
+    @class.compiled.should == false
+    lambda { @class.compile }.should raise_error(RuntimeError)
+    @class.compiled.should == false
+		
+    @class.scope(:fake_scope)
+    @class.compiled.should == false
+    lambda { @class.compile }.should raise_error(RuntimeError)
+    @class.compiled.should == false
+
+  end
+
+  it "shouldn't be compiled if a production has an invalid mode" do
+    @class.production(:error) { |prod| prod.mode = :this_is_an_invalid_mode }
+    lambda { @class.compile }.should raise_error(RuntimeError)
+  end
+
+  it "should mantain an attribute 'code' which mantains the built code" do
+    @class.scope(:single)
+		
+    @class.should respond_to(:code)
+    @class.code.should be_nil
+    lambda { @class.compile }.should_not raise_error
+    @class.code.should_not be_nil
+    @class.code.should be_kind_of(String)
+  end
+
+end
+
+describe "An instance of a class descending from AbstractParser with some productions specified after being compiled" do
+
+  before(:each) do
+    @class = Class.new(AbstractParser)
+    if @class.respond_to? :autocompile
+      @class.autocompile(false)
+    end
+    @parser = @class.new
+		
+    @class.scope :single
+
+    @mock_single = mock "Single"
+    @mock_single.should_receive(:respond_to?).with(:to_ary).and_return(false)
+    @mock_single.should_receive(:respond_to?).with(:call).and_return(true)
+    @class.production(:single) do |prod|
+      prod.token(:single_token,@mock_single) 
+    end
+		
+    @mock_recursive = mock "Recursive"
+    @mock_recursive.should_receive(:respond_to?).with(:to_ary).and_return(false)
+    @mock_recursive.should_receive(:respond_to?).with(:call).and_return(true)
+    @class.production(:recursive) do |prod|
+      prod.mode = :recursive
+      prod.token(:recursive_token,@mock_recursive) 
+    end
+		
+    lambda { @class.compile }.should_not raise_error
+  end
+
+  it "should expose parse_NAME methods" do
+    @parser.should respond_to("parse_single")
+    @parser.should respond_to("parse_recursive")
+  end
+
+  it "should have a productions method which alias the class one" do
+    @parser.should respond_to(:productions)
+    @parser.productions.should == @class.productions
+  end
+
+  it "should have a parse method which accept a scanner" do
+    @parser.should respond_to(:parse)
+
+    scanner = mock "Scanner"
+    scanner.should_receive(:next).any_number_of_times
+    scanner.should_receive(:current).twice.and_return(:single_token,nil)
+
+    @mock_single.should_receive(:call).with(nil,scanner,@parser).and_return(:good_result)
+
+    lambda { @parser.parse(scanner).should == :good_result }.should_not raise_error
+		
+    scanner = mock "Scanner2"
+    scanner.should_receive(:next).any_number_of_times
+    scanner.should_receive(:current).exactly(5).and_return(:single_token)
+		
+    @mock_single.should_receive(:call).with(nil,scanner,@parser).and_return(:good_result)
+		
+    lambda { @parser.parse(scanner) }.should raise_error(ParserError)
+  end
+
+end
+
+describe "A class descending from AbstractParser should autocompile" do
+	
+  before(:each) do
+    @class = Class.new(AbstractParser)
+    @parser = @class.new
+    #@class.autocompile true
+  end
+
+  it "the scope" do
+    @class.scope :scope
+    @parser.should respond_to(:parse)
+    @parser.should_receive(:parse_scope).once
+    scanner = mock "Scanner"
+    scanner.should_receive(:next).once
+    scanner.should_receive(:current).once
+    @parser.parse(scanner)
+  end
+
+  it "a 'single' production" do
+    @mock_single = mock "Single"
+    @mock_single.should_receive(:respond_to?).with(:to_ary).and_return(false)
+    @mock_single.should_receive(:respond_to?).with(:call).and_return(true)
+    @class.production(:single) do |prod|
+      prod.token(:single_token,@mock_single) 
+    end
+    @parser.should respond_to(:parse_single)
+  end
+	
+  it "a 'recursive' production" do
+    @mock_recursive = mock "Recursive"
+    @mock_recursive.should_receive(:respond_to?).with(:to_ary).and_return(false)
+    @mock_recursive.should_receive(:respond_to?).with(:call).and_return(true)
+    @class.production(:recursive) do |prod|
+      prod.mode = :recursive
+      prod.token(:recursive_token,@mock_recursive) 
+    end
+    @parser.should respond_to(:parse_recursive)
+  end
+end