AmberVM 0.0.19

data/spec/languages/ecma_fuku/ecma_old_spec.rb

@@ -0,0 +1,415 @@
+$: << 'lib'
+require 'amber'
+require 'amber/languages'
+require 'amber/languages/ecma_fuku'
+
+describe AmberVM::Languages::ECMA_Fuku do
+  before(:each) do
+    @compiler = AmberVM::Languages::ECMA_Fuku.new
+    @env = {}
+  end
+  
+  def run code
+    @compiler.compile(code).execute(@env)
+  end
+  
+  describe "literals" do
+    describe "strings" do
+      it "should handle string literals" do
+        res = run <<-EOC
+          "Hallo!"
+        EOC
+        res.should == "Hallo!"
+      end
+      
+      it "should handle newline replacements" do
+        res = run '"\n"'
+        res.should == "\n"
+      end
+      
+      it "should handle newline replacements" do
+        res = run <<-'EOC'
+          "\t"
+        EOC
+        res.should == "\t"
+      end
+      it "should handle newline replacements" do
+        res = run <<-'EOC'
+          "\n"
+        EOC
+        res.should == "\n"
+      end
+      
+      it "should handle double escapes" do
+        res = run <<-'EOC'
+          "\\t"
+        EOC
+        res.should == "\\t"
+      end
+      
+      it "should handle double escapes followed by single escapes" do
+        res = run <<-'EOF'
+          "\\\t"
+        EOF
+        res.should == "\\\t"
+      end
+    end
+    
+    it "should handle number literals" do
+      res = run <<-EOC
+        42
+      EOC
+      res.should == 42
+    end
+    
+    describe "array" do
+      it "should handle array literals with no elements" do
+        res = run <<-EOC
+          []
+        EOC
+        res.should == []
+      end
+      
+      it "should handle array literals with one element" do
+        res = run <<-EOC
+          ["Kekse!"]
+        EOC
+        res.should == ["Kekse!"]
+      end
+
+      it "should handle array literals with arrays in it" do
+        res = run <<-EOC
+          [["Kekse!",2],1]
+        EOC
+        res.should == [["Kekse!",2],1]
+      end      
+      
+      it "should handle array literals with multiple elements" do
+        res = run <<-EOC
+          [42, "Kekse!"]
+        EOC
+        res.should == [42, "Kekse!"]
+      end
+      
+      it "should allow to set array elements" do
+        res = run <<-EOC
+          array = [];
+          array[0] = 42;
+          array;
+        EOC
+        res.should == [42]
+      end
+    end
+    
+    describe "Objects array" do
+      it "should handle an empty object" do
+        res = run <<-EOC
+          a = {}
+        EOC
+        @env['a'].should be_instance_of(OpenStruct)
+      end
+      
+      it "should handle an object with variables" do
+        res = run <<-EOC
+          {a: 1}
+        EOC
+        res.should be_instance_of(OpenStruct)
+        res.a.should == 1
+      end
+      it "should handle an object with functions" do
+        res = run <<-EOC
+          {f: function(){1;}}
+        EOC
+        res.should be_instance_of(OpenStruct)
+        res.f.should be
+        res.f.call.should == :undefined
+      end
+    end
+    
+    it "should handle true literals" do
+      res = run <<-EOC
+        true
+      EOC
+      res.should be_true
+    end
+    
+    it "should handle false literals" do
+      res = run <<-EOC
+        false
+      EOC
+      res.should_not be_true
+    end
+  end
+  
+  describe "array" do
+    it "should allow accessing elements" do
+      @env['a'] = [1,2,3]
+      res = run <<-EOC
+        a[0]
+      EOC
+      res.should == 1
+    end
+    
+    it "should allow setting elements" do
+      @env['a'] = [1,2,3]
+      res = run <<-EOC
+        a[0] = 42;
+      EOC
+      res.should == 42
+      @env['a'][0].should == 42
+    end
+    it "should allow accessing the length" do
+      @env['a'] = [1,2,3]
+      res = run <<-EOC
+        a.length
+      EOC
+      res.should == 3
+    end
+  end
+  
+  describe "variables" do
+    it "should recognize simple assignments" do
+      res = run <<-EOC
+        variable = 'value';
+      EOC
+      res.should == 'value'
+      @env['variable'].should == 'value'
+    end
+  
+    it "should recognize local assignments" do
+      res = run <<-EOC
+        var variable = 'value';
+      EOC
+      res.should == 'value'
+      @env['variable'].should == 'value'
+    end
+  
+    it "should recognize multiple local assignments" do
+      res = run <<-EOC
+        var i = 'a', j = 'b';
+      EOC
+      res.should == 'b'
+      @env['i'].should == 'a'
+      @env['j'].should == 'b'
+    end
+    
+    it "should scope global assignments correctly" do
+      res = run <<-EOC
+        variable = 'outer scope';
+        {
+          var variable = 'inner scope';
+        }
+      EOC
+      res.should == 'inner scope'
+      @env['variable'].should == 'inner scope'
+    end
+  end
+  
+  describe "conditions" do
+    describe "true condition" do
+      describe "without blocks" do
+        
+        it "should handle loops without else" do
+          res = run <<-EOC
+            if (true)
+              42
+          EOC
+          res.should == 42
+        end
+        
+        it "should handle loops with else" do
+          res = run <<-EOC
+            if (true)
+              42;
+            else
+              23
+          EOC
+          res.should == 42
+        end
+        
+        it "should handle loops with else and ugly ';'" do
+          res = run <<-EOC
+            if (true)
+              42;
+            else
+              23
+          EOC
+          res.should == 42
+        end
+      end
+      
+      describe "with blocks" do
+        it "should handle condition without else" do
+          res = run <<-EOC
+            if (true) {
+              42;
+            }
+          EOC
+          res.should == 42
+        end
+        it "should handle condition with else" do
+          res = run <<-EOC
+            if (true) {
+              42;
+            } else {
+              23;
+            }
+          EOC
+          res.should == 42
+        end
+      end
+    end
+    describe "false condition" do
+      describe "without blocks" do
+        it "should handle condition without else" do
+          res = run <<-EOC
+            if (false)
+              42;
+          EOC
+          res.should == nil
+        end
+        it "should handle condition with else" do
+          res = run <<-EOC
+            if (false)
+              42;
+            else
+              23;
+          EOC
+          res.should == 23
+        end
+      end
+      describe "with blocks" do
+        it "should handle condition without else" do
+          res = run <<-EOC
+            if (false) {
+              42;
+            }
+          EOC
+          res.should be_nil
+        end
+        it "should handle condition with else" do
+          res = run <<-EOC
+            if (false) {
+              42;
+            } else {
+              23;
+            }
+          EOC
+          res.should == 23
+        end
+      end
+    end
+  end
+  
+  describe "loops" do
+    it "should handle for loops" do
+      res = run <<-EOC
+        variable = "";
+        for (i = 0; i <= 3; i = i + 1) {
+          variable = variable + i;
+        }
+      EOC
+      @env['variable'].should == '0123'
+    end
+    
+    it "should handle for loops (bug prevention)" do
+      code = <<-EOC
+        function test() {for (var i = 1; i <= 2; i+=1) {};};
+        test();
+      EOC
+      proc { run(code) }.should_not raise_error
+    end  
+    
+    it "should handle while loops" do
+      res = run <<-EOC
+        variable = "";
+        i = 0;
+        while (i < 3) {
+          i = i + 1;
+          variable = variable + i;
+        }
+      EOC
+      @env['variable'].should == '123'
+    end
+    
+    it "should handle do while loops" do
+      res = run <<-EOC
+        variable = "";
+        i = 0;
+        do {
+          i = i + 1;
+          variable = variable + i;
+        } while (i < 3)
+      EOC
+      @env['variable'].should == '123'    
+    end
+  end
+  it "should execute do while loops at least once" do
+    res = run <<-EOC
+      variable = "";
+      i = 0;
+      do {
+        i = i + 1;
+        variable = variable + i;
+      } while (i < 0)
+    EOC
+    res.should be_nil
+    @env['variable'].should == '1'
+  end
+  
+  describe "objects" do
+    it "should handle object variables" do
+      obj = mock('object mock')
+      obj.should_receive(:test).with(no_args).and_return('ok')
+      @env['obj'] = obj
+      res = run <<-EOC
+        obj.test;
+      EOC
+      res.should == 'ok'
+    end
+  
+    it "should handle object functions" do
+      obj = mock('object mock')
+      function = mock('function mock')
+      obj.should_receive(:test).with(no_args).and_return(function)
+      function.should_receive(:call).once.with(no_args).and_return('ok')
+      @env['obj'] = obj
+      res = run <<-EOC
+        obj.test();
+      EOC
+      res.should == 'ok'
+    end
+  end
+  
+  
+  describe "opperators" do
+    it "should recognize ++" do
+      @env['i'] = 41
+      res = run <<-EOC
+        i++;
+      EOC
+      res.should == 41
+    end
+    it "should recognize --" do
+      @env['i'] = 43
+      res = run <<-EOC
+        i--;
+      EOC
+      res.should == 43
+    end
+    it "should recognize +=" do
+      @env['i'] = 40
+      res = run <<-EOC
+        i += 2;
+      EOC
+      res.should == 42
+    end
+    it "should recognize -=" do
+      @env['i'] = 44
+      res = run <<-EOC
+        i -= 2;
+      EOC
+      res.should == 42
+    end
+  end
+end

data/spec/languages/ecma_fuku/ecma_operator_spec.rb

@@ -0,0 +1,33 @@
+$: << 'lib'
+require 'amber'
+require 'amber/languages'
+require 'amber/languages/ecma_fuku'
+
+describe AmberVM::Languages::ECMA_Fuku do
+  before(:each) do
+    @env = {}
+    @compiler = AmberVM::Languages::ECMA_Fuku.new
+  end
+  
+  def run code
+    @compiler.compile(code).execute(@env)
+  end
+  
+  describe "arithmetic" do
+    it "should handle >>>" do
+      result = run <<-CODE
+        -1766 >>> 12
+      CODE
+      result.should == 1048575
+    end
+    it "should handle >>>=" do
+      result = run <<-CODE
+        a = -8345;
+        a >>>= 4;
+        a
+      CODE
+      result.should == 268434934
+    end
+  end
+  
+end

data/spec/languages/ecma_fuku/ecma_spec.rb

@@ -0,0 +1,52 @@
+$: << 'lib'
+require 'amber'
+require 'amber/languages'
+require 'amber/languages/ecma_fuku'
+
+describe AmberVM::Languages::ECMA_Fuku do
+  before(:each) do
+    @env = {}
+    @compiler = AmberVM::Languages::ECMA_Fuku.new
+  end
+  
+  def run code
+    @compiler.compile(code).execute(@env)
+  end
+  
+  describe "variables" do
+    it "should get variables" do
+      @env['test'] = 42
+      result = run <<-CODE
+        test
+      CODE
+      result.should == 42
+    end
+    
+    it "should allow to assign literals to variables" do
+      result = run <<-CODE
+        test = 23
+      CODE
+      result.should == 23
+      @env['test'].should == 23
+    end
+    
+    it "should autocast strings when using <var>++" do
+      result = run <<-CODE
+        test = '1.2';
+        test++
+      CODE
+      result.should == 1.2
+      @env['test'].should == 2.2
+    end
+  end
+  
+  describe '+ operator' do
+    it 'should behave like ECMA' do
+      result = run <<-CODE
+        1 + "3"
+      CODE
+      result.should == "13"
+    end
+  end
+  
+end

data/spec/languages/math/compiler_spec.rb

@@ -0,0 +1,49 @@
+require 'amber/interpreter'
+require 'amber/classes/number'
+require 'amber/languages/math/compiler'
+describe AmberVM::Languages::Math::Compiler do
+  before do
+    @c = AmberVM::Languages::Math::Compiler
+  end
+  
+  it "should compile numbers to constants" do
+    @c.compile({:type=>:number, :number=>"5"}).should be_instance_of(AmberVM::Interpreter::Constant);
+  end
+  
+  it "should ignore arrays" do
+    @c.compile([{:type=>:number, :number=>"5"}]).should be_instance_of(AmberVM::Interpreter::Constant);
+  end
+  
+  it "should compile it ident to variables" do
+    @c.compile({:type => :ident, :ident => "x"}).should be_instance_of(AmberVM::Interpreter::Variable);
+  end
+  
+  it "should compile functions" do
+    @c.compile({:type => :function, :op => "x", :params => []}).should be_instance_of(AmberVM::Interpreter::FunctionCall);
+    @c.compile({:type => :function, :op => "-", :params => []}).should be_instance_of(AmberVM::Interpreter::CoreCall);
+  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(AmberVM::Interpreter::CoreCall);
+  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(AmberVM::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(AmberVM::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(AmberVM::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(AmberVM::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(AmberVM::Interpreter::Sequence);
+  end
+end

data/spec/languages/math/tokenizer_spec.rb

@@ -0,0 +1,73 @@
+require 'amber/languages/math/tokenizer'
+describe AmberVM::Languages::Math::Tokenizer do
+  before do
+    @t = AmberVM::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