rVM 0.0.10 → 0.0.11

data/spec/languages/ecma_spec.rb

@@ -0,0 +1,337 @@
+require File.dirname(__FILE__) +'/../../lib/rvm'
+require File.dirname(__FILE__) +'/../../lib/rvm/languages'
+require File.dirname(__FILE__) +'/../../lib/rvm/languages/ecma'
+
+describe RVM::Languages::ECMA do
+  def exec code
+    @compiler.compile(code).execute(@env)
+  end
+  
+  before(:each) do
+    @env = RVM::Interpreter.env
+    @compiler = RVM::Languages::ECMA.new
+  end
+  
+  describe "literals" do
+    describe "strings" do
+      it "should handle string literals" do
+        res = exec <<-EOC
+          "Hallo!"
+        EOC
+        res.should == "Hallo!"
+      end
+      
+      it "should handle newline replacements" do
+        res = exec <<-EOC
+          "\n"
+        EOC
+        res.should == "\n"
+      end
+      
+      it "should handle newline replacements" do
+        res = exec <<-EOC
+          "\t"
+        EOC
+        res.should == "\t"
+      end
+      it "should handle newline replacements" do
+        res = exec <<-EOC
+          "\n"
+        EOC
+        res.should == "\n"
+      end
+      
+      it "should handle double escapes" do
+        res = exec <<-EOC
+          "\\t"
+        EOC
+        res.should == "\\t"
+      end
+      
+      it "should handle double escapes followed by single escapes" do
+        res = exec <<-EOC
+          "\\\t"
+        EOC
+        res.should == "\\\t"
+      end
+    end
+    
+    it "should handle number literals" do
+      res = exec <<-EOC
+        42
+      EOC
+      res.should == 42
+    end
+    
+    it "should handle array literals" do
+      res = exec <<-EOC
+        [42, "Kekse!"]
+      EOC
+      res.should == [42, "Kekse!"]
+    end
+    
+    it "should handle true literals" do
+      res = exec <<-EOC
+        true
+      EOC
+      res.should be_is_true
+    end
+    
+    it "should handle false literals" do
+      res = exec <<-EOC
+        false
+      EOC
+      res.should_not be_is_true
+    end
+  end
+  
+  describe "array" do
+    
+    it "should allow accessing elements" do
+      @env['a'] = RVM::Classes::List.new([1,2,3])
+      res = exec <<-EOC
+        a[0]
+      EOC
+      res.should == 1   
+    end
+   
+    it "should allow accessing the length" do
+      @env['a'] = RVM::Classes::List.new([1,2,3])
+      res = exec <<-EOC
+        a.length()
+      EOC
+      res.should == 3
+    end    
+    
+  end
+  
+  describe "variables" do
+    it "should recognize simple assignments" do
+      res = exec <<-EOC
+        variable = 'value';
+      EOC
+      res.should == 'value'
+      @env['variable'].val.should == 'value'
+    end
+  
+    it "should recognize local assignments" do
+      res = exec <<-EOC
+        var variable = 'value';
+      EOC
+      res.should == 'value'
+      @env['variable'].val.should == 'value'
+    end
+  
+    it "should scope local assignments correctly" do
+      res = exec <<-EOC
+        variable = 'outer scope';
+        {
+          var variable = 'inner scope';
+        }
+      EOC
+      res.should == 'inner scope'
+      @env['variable'].val.should == 'outer scope'
+    end
+  end
+  
+  describe "conditions" do
+    describe "true condition" do
+      describe "without blocks" do
+        
+        it "should handle loops without else" do
+          res = exec <<-EOC
+            if (true)
+              42
+          EOC
+          res.should == 42
+        end
+        
+        it "should handle loops with else" do
+          res = exec <<-EOC
+            if (true)
+              42
+            else
+              23
+          EOC
+          res.should == 42
+        end
+        
+      end
+      
+      describe "with blocks" do
+        it "should handle loops without else" do
+          res = exec <<-EOC
+            if (true) {
+              42
+            }
+          EOC
+          res.should == 42
+        end
+        it "should handle loops with else" do
+          res = exec <<-EOC
+            if (true) {
+              42
+            } else {
+              23
+            }
+          EOC
+          res.should == 42
+        end
+      end
+    end
+    describe "false condition" do
+      describe "without blocks" do
+        it "should handle loops without else" do
+          res = exec <<-EOC
+            if (false)
+              42
+          EOC
+          res.should be_nil
+        end
+        it "should handle loops with else" do
+          res = exec <<-EOC
+            if (false)
+              42
+            else
+              23
+          EOC
+          res.should == 23
+        end
+      end
+      describe "with blocks" do
+        it "should handle loops without else" do
+          res = exec <<-EOC
+            if (false) {
+              42
+            }
+          EOC
+          res.should be_nil
+        end
+        it "should handle loops with else" do
+          res = exec <<-EOC
+            if (false) {
+              42
+            } else {
+              23
+            }
+          EOC
+          res.should == 23
+        end
+      end
+    end
+  end
+  
+  describe "loops" do
+    it "should handle for loops" do
+      res = exec <<-EOC
+        variable = "";
+        for (i = 0; i < 3; i = i + 1) {
+          variable = variable + i;
+        }
+      EOC
+      res.should == 3
+      @env['variable'].val.should == '012'    
+    end
+  
+    it "should handle while loops" do
+      res = exec <<-EOC
+        variable = "";
+        i = 0;
+        while (i < 3) {
+          i = i + 1;
+          variable = variable + i;
+        }
+      EOC
+      res.should == '123'
+      @env['variable'].val.should == '123'    
+    end
+    
+    it "should handle do while loops" do
+      res = exec <<-EOC
+        variable = "";
+        i = 0;
+        do {
+          i = i + 1;
+          variable = variable + i;
+        } while (i < 3)
+      EOC
+      res.should == '123'
+      @env['variable'].val.should == '123'    
+    end
+  end
+  it "should execute do while loops at least once" do
+    res = exec <<-EOC
+      variable = "";
+      i = 0;
+      do {
+        i = i + 1;
+        variable = variable + i;
+      } while (i < 0)
+    EOC
+    res.should be_nil
+    @env['variable'].val.should == '1'    
+  end
+  
+
+
+  describe "functions" do
+    it "should handle function definitions without variables" do
+      res = exec <<-EOC
+        function f() {
+          42;
+        }
+      EOC
+      res.class.should == RVM::Classes::Block
+      @env.function('f').should be
+    end
+  
+    it "should handle function definitions with variables" do
+      res = exec <<-EOC
+        function g(x) {
+          42 + x;
+        }
+      EOC
+      res.class.should == RVM::Classes::Block
+      @env.function('g').should be
+    end
+  end
+  
+  describe "objects" do
+    it "should handle object variables" do
+      obj = mock('object mock')
+      varialbes = mock('variables')
+      obj.should_receive(:variables).once.and_return(varialbes)
+      obj.should_receive(:functions).once.and_return({})
+      varialbes.should_receive(:each)
+      varialbes.should_receive(:[]=)
+      varialbes.should_receive(:[]).with('test').and_return(RVM::Interpreter::VariableStorage.new('ok'))
+      @env['obj'] = obj
+      res = exec <<-EOC
+        obj.test;
+      EOC
+      
+      res.should == 'ok'
+    end
+  
+    it "should handle object functions" do
+      obj = mock('object mock')
+      functions = mock('variables mock')
+      function = mock('function mock')
+      obj.should_receive(:variables).once.and_return({})
+      obj.should_receive(:functions).once.and_return(functions)
+      
+      functions.should_receive(:[]).with('test').and_return(function)
+      function.should_receive(:call).and_return 'ok'
+      
+      @env['obj'] = obj
+      res = exec <<-EOC
+        obj.test();
+      EOC
+      
+      res.should == 'ok'
+    end
+  end
+  
+  describe "condition"
+
+end

data/spec/languages/math/compiler_spec.rb

@@ -0,0 +1,49 @@
+require  File.join(File.dirname(__FILE__), '/../../../lib/rvm/interpreter')
+require  File.join(File.dirname(__FILE__), '/../../../lib/rvm/classes/number')
+require  File.join(File.dirname(__FILE__), '/../../../lib/rvm/languages/math/compiler')
+describe RVM::Languages::Math::Compiler do
+  before do
+    @c = RVM::Languages::Math::Compiler
+  end
+  
+  it "should compile numbers to constants" do
+    @c.compile({:type=>:number, :number=>"5"}).should be_instance_of(RVM::Interpreter::Constant);
+  end
+  
+  it "should ignore arrays" do
+    @c.compile([{:type=>:number, :number=>"5"}]).should be_instance_of(RVM::Interpreter::Constant);
+  end
+  
+  it "should compile it ident to variables" do
+    @c.compile({:type => :ident, :ident => "x"}).should be_instance_of(RVM::Interpreter::Variable);
+  end
+  
+  it "should compile functions" do
+    @c.compile({:type => :function, :op => "x", :params => []}).should be_instance_of(RVM::Interpreter::FunctionCall);
+    @c.compile({:type => :function, :op => "-", :params => []}).should be_instance_of(RVM::Interpreter::FunctionCall);
+  end
+  
+  it "should compile mathematical ooperators to function calls" do
+    @c.compile({:type => :op, :op => "+", :left => {:type=>:number, :number=>"5"}, :right => {:type=>:number, :number=>"5"}}).should be_instance_of(RVM::Interpreter::FunctionCall);
+  end
+  
+  it "should compile = operators to assignments if left side is a ident" do
+    @c.compile({:type => :op, :op => "=", :left => {:type => :ident, :ident=>"x"}, :right => {:type=>:number, :number=>"5"}}).should be_instance_of(RVM::Interpreter::Assignment);
+  end
+  
+  it "should compile = operators to function declaratins if left side is a function" do
+    @c.compile({:type => :op, :op => "=", :left => {:type => :function, :op => "x", :params => []}, :right => {:type=>:number, :number=>"5"}}).should be_instance_of(RVM::Interpreter::FunctionDefinition);
+    @c.compile({:type => :op, :op => "=", :left => {:type => :function, :op => "x", :params => [{:type => :ident, :ident=>"x"}]}, :right => {:type=>:number, :number=>"5"}}).should be_instance_of(RVM::Interpreter::FunctionDefinition);
+  end
+  
+  it "should raise an error of the  = operators is used with a number on the left" do
+    lambda {
+      @c.compile({:type => :op, :op => "=", :left => {:type => :number, :ident=>"5"}, :right => {:type=>:number, :number=>"5"}})
+    }.should raise_error
+  end
+  
+  it "should compile ; to sepperators of sequences" do
+    @c.compile({:type => :op, :op => ";", :left => {:type => :ident, :ident=>"x"}, :right => {:type=>:number, :number=>"5"}}).should be_instance_of(RVM::Interpreter::Sequence);
+    @c.compile({:type => :op, :op => ";", :left => {:type => :op, :op => ";", :left => {:type => :ident, :ident=>"x"}, :right => {:type=>:number, :number=>"5"}}, :right => {:type => :op, :op => ";", :left => {:type => :ident, :ident=>"x"}, :right => {:type=>:number, :number=>"5"}}}).should be_instance_of(RVM::Interpreter::Sequence);
+  end
+end

data/spec/languages/math/tokenizer_spec.rb

@@ -0,0 +1,73 @@
+require  File.join(File.dirname(__FILE__), '/../../../lib/rvm/languages/math/tokenizer')
+describe RVM::Languages::Math::Tokenizer do
+  before do
+    @t = RVM::Languages::Math::Tokenizer
+  end
+  
+  it "should tokenize numbers in it's forms" do
+    @t.tokenize("5").should == [['5', :number]]
+    @t.tokenize("42").should == [['42', :number]]
+    @t.tokenize("4.2").should == [['4.2', :number]]
+    @t.tokenize(".2").should == [['.2', :number]]
+    @t.tokenize("4.2e10").should == [['4.2e10', :number]]
+    @t.tokenize("4.2e-10").should == [['4.2e-10', :number]]
+  end
+  
+  it "should tokenize idents" do
+    @t.tokenize("x").should == [['x', :ident]]
+    @t.tokenize("xy").should == [['xy', :ident]]
+    @t.tokenize("x42").should == [['x42', :ident]]
+    @t.tokenize("_x").should == [['_x', :ident]]
+    @t.tokenize("_x_").should == [['_x_', :ident]]
+    @t.tokenize("really_freaking_long_IdentWithA11KindOfOddStuff").should == [['really_freaking_long_IdentWithA11KindOfOddStuff', :ident]]
+  end
+  
+  it "should ignore spaces between tokens" do
+    @t.tokenize("23 +    19").should == [['23', :number],['+', :opperator],['19', :number]]
+  end
+  
+  it "should recognize mathematical opperators (+,-,*,/,^)" do
+    @t.tokenize("23+19").should == [['23', :number], ['+', :opperator], ['19', :number]]
+    @t.tokenize("43-1").should == [['43', :number], ['-', :opperator], ['1', :number]]
+    @t.tokenize("21*2").should == [['21', :number], ['*', :opperator], ['2', :number]]
+    @t.tokenize("84/2").should == [['84', :number], ['/', :opperator], ['2', :number]]
+  end
+  
+  it "recognizes unary - and  ü" do
+    @t.tokenize("+5").should == [['5', :number]]
+    @t.tokenize("++5").should == [['5', :number]]
+    @t.tokenize("-5").should == [['-', :function], ['5', :number]]
+    @t.tokenize("- 5").should == [['-', :function], ['5', :number]]
+    @t.tokenize("- - 5").should == [['-', :function], ['-', :function], ['5', :number]]
+    @t.tokenize("3 + - - 5").should == [['3', :number], ['+', :opperator], ['-', :function], ['-', :function], ['5', :number]]
+  end
+  
+  it "should recognize functions" do
+    @t.tokenize("f(x)").should == [['f', :function], ['x', :ident], [')', :paren_close]]
+    @t.tokenize("f(x, y)").should == [['f', :function], ['x', :ident], [',', :function_sep], ['y', :ident], [')', :paren_close]]
+    @t.tokenize("f()").should == [['f', :function], [")", :paren_close]]
+  end
+  
+  it "should recognize parentheethes" do
+    @t.tokenize("(42)").should == [["(", :paren_open], ["42", :number], [")", :paren_close]]
+    @t.tokenize("(f(x))").should == [["(", :paren_open], ['f', :function], ['x', :ident], [')', :paren_close], [")", :paren_close]]
+    @t.tokenize("(19+23)").should == [["(", :paren_open], ['19', :number], ['+', :opperator], ['23', :number], [")", :paren_close]]
+  end
+  
+  it "should recognize semicolons" do
+    @t.tokenize("42;42").should == [["42", :number], [";", :opperator], ["42", :number]]
+  end
+  
+  it "should not alow semicolons within brackets" do
+    lambda{@t.tokenize("(42;42)")}.should raise_error
+  end
+  
+  it "should throw exeptions on unknown literals where numbers are expected" do
+    lambda{@t.tokenize("42that_is_not_valid!")}.should raise_error
+  end
+  
+  it "should throw exeptions on unknown literals" do
+    lambda{@t.tokenize("42that_is_not_valid!")}.should raise_error
+    lambda{@t.tokenize("?")}.should raise_error
+  end
+end