AmberVM 0.0.19

data/spec/classes/atom/list_spec.rb

@@ -0,0 +1,68 @@
+require "amber/classes/list"
+describe AmberVM::Classes::List do
+  
+  describe "(creation)" do
+    it "should create empty" do
+      l = AmberVM::Classes::List.new()
+      l.size.should be(0)
+    end
+    
+    it "should create simple lists with one element" do
+      l = AmberVM::Classes::List.new(true)
+      l.size.should be(1)
+    end
+    
+    
+    it "should create from an array" do
+      l = AmberVM::Classes::List.new(['1','2','3','4'])
+      l.size.should be(4)
+    end
+    
+    it "should split a list of string sepperated items" do
+      l = AmberVM::Classes::List.new("1 2 3 4")
+      l.should == ['1','2','3','4']
+      l.size.should be(4)
+    end
+    
+    it "should split a list of string sepperated items" do
+      l = AmberVM::Classes::List.new("1|2|3|4", '|')
+      l.should == ['1','2','3','4']
+      l.size.should be(4)
+    end
+    it "should have the data type :list" do
+      l = AmberVM::Classes::List.new("")
+      l.data_type.should == :list
+    end
+  end
+  
+  describe "(conversion)" do
+    it "should rejoin a list, by default with spaces" do
+      l = AmberVM::Classes::List.new([1,2,3])
+      l.to_s.should == "1 2 3"
+    end
+    
+    it "should rejoin a list by a other sepperator" do
+      l = AmberVM::Classes::List.new([1,2,3], ',')
+      l.to_s.should == "1,2,3"
+    end
+  end
+  
+  describe "(sepperator)" do
+    it "should let you switch the sepperator without affecting the elemetns" do
+      l = AmberVM::Classes::List.new("1|a 2|b 3|c 4|d")
+      l.size.should be(4)
+      l.sepperator = '|'
+      l.size.should be(4)
+      l.to_s.should == "1|a|2|b|3|c|4|d"
+    end
+    
+    it "should let you resplit the list changing it's content" do
+      l = AmberVM::Classes::List.new("1|a 2|b 3|c 4|d")
+      l.size.should be(4)
+      l.resplit('|')
+      l.size.should be(5)
+      l.to_s.should == "1|a 2|b 3|c 4|d"
+    end   
+  end
+  
+end

data/spec/classes/atom/number_spec.rb

@@ -0,0 +1,132 @@
+require "amber/classes"
+require "amber/classes/number"
+
+describe AmberVM::Classes::Number do
+  
+  describe "(creation)" do
+    
+    it "should create from fixnums" do
+      n = AmberVM::Classes::Number.new(1)
+      n.should be_instance_of(AmberVM::Classes::Number)
+      n.should == 1
+    end
+    
+    it "should create from floats" do
+      n = AmberVM::Classes::Number.new(1.1)
+      n.should be_instance_of(AmberVM::Classes::Number)
+      n.should == 1.1
+    end
+    
+    it "should create from bignum" do
+      n = AmberVM::Classes::Number.new(10**100)
+      n.should be_instance_of(AmberVM::Classes::Number)
+      n.should == 10**100
+    end
+    
+    describe "(conversion)" do
+      it "should try to call to_f if to_f and to_i is different" do
+        value = mock('value mock')
+        value.should_receive(:respond_to?).ordered.once.with(:to_f).and_return(true)
+        value.should_receive(:to_f).ordered.once.with(no_args).and_return(42)
+        value.should_receive(:to_i).ordered.once.with(no_args).and_return(2)
+        n = AmberVM::Classes::Number.new(value)
+        n.should be_instance_of(AmberVM::Classes::Number)
+        n.should == 42
+      end
+      
+      it "should use to_i if to_f and to_i are the same" do
+        value = mock('value mock')
+        value.should_receive(:respond_to?).ordered.once.with(:to_f).and_return(true)
+        value.should_receive(:to_f).ordered.once.with(no_args).and_return(2)
+        value.should_receive(:to_i).ordered.twice.with(no_args).and_return(2)
+        value.should_receive(:respond_to?).ordered.once.with(:to_i).and_return(true)
+        n = AmberVM::Classes::Number.new(value)
+        n.should be_instance_of(AmberVM::Classes::Number)
+        n.should == 2
+      end
+      
+      it "should stuff it in a string if nothing else" do
+        value = mock('value mock')
+        value.should_receive(:respond_to?).ordered.once.with(:to_f).and_return(false)
+        value.should_receive(:respond_to?).ordered.once.with(:to_i).and_return(false)
+        value.should_receive(:to_s).ordered.once.and_return('4.2')
+        n = AmberVM::Classes::Number.new(value)
+        n.should be_instance_of(AmberVM::Classes::Number)
+        n.should == 4.2
+      end
+    end
+  end
+  describe "(runtime)" do
+    before do
+      @object  = AmberVM::Classes::Number.new 42
+    end
+    
+    describe "(convertion)" do
+      it "should convert the value to a string" do
+        @object.to_s.should == '42'
+      end
+      
+      it "should convert the value to integer" do
+        @object.to_i.should be_instance_of(Fixnum)
+      end
+      
+      it "should convert the value to fliat" do
+        @object.to_f.should be_instance_of(Float)
+      end
+    end
+    describe "(compairsont)" do
+      it "should be is_true? when not zero" do
+        @object.is_true?.should be_true
+      end
+      
+      it "should not be is_true? when  zero" do
+        @object =AmberVM::Classes::Number.new 0
+        @object.is_true?.should_not be_true
+      end
+      
+      it "should compare with other Numbers" do
+        @object.==(@object).should be_true
+      end
+      
+      it "should compare normal ruby number classes" do
+        @object.==(42).should be_true
+        @object.==(42.0).should be_true
+      end
+    end
+    
+    describe "(delegation)" do
+      before do
+        @value = mock('value mock')
+        @value.should_receive(:is_a?).once.with(Numeric).and_return(true)
+        @value
+        @object =  AmberVM::Classes::Number.new @value
+      end
+      
+      #it "should delege respond_to to it's value" do
+      #  @value.should_receive(:respond_to?).once.with(:woggle).and_return('yes god damn it!')
+      #  @object.respond_to?(:woggle).should == 'yes god damn it!'
+      #end
+      
+      it "should delege unknwon methods to it's value and return a Number" do
+        @value.should_receive(:woggle).once.with(1).and_return(42)
+        res = @object.woggle(1)
+        res.should be_instance_of(AmberVM::Classes::Number)
+        res.should == 42
+      end
+      
+      it "should delege unknwon methods to it's value and return a Number also work with number arguments" do
+        n = AmberVM::Classes::Number.new(1)
+        @value.should_receive(:respond_to?).once.with(:woggle).and_return(true)
+        @value.should_receive(:woggle).once.with(n).and_return(42)
+        res = @object.woggle(n)
+        res.should be_instance_of(AmberVM::Classes::Number)
+        res.should == 42
+      end
+      
+      it "should raise a method missing otherwise" do
+        @object  = AmberVM::Classes::Number.new 42
+        lambda {@object.woggle}.should raise_error
+      end
+    end
+  end
+end

data/spec/classes/atom/string_spec.rb

@@ -0,0 +1,175 @@
+require "amber/classes/string"
+
+describe AmberVM::Classes::String do
+  
+  describe "(creation)" do
+    it "should create as an empty string without arguments" do
+      str = AmberVM::Classes::String.new
+      str.should be_instance_of(AmberVM::Classes::String)
+      str.empty?.should be_true
+    end
+    
+    it "should create with a string parameter" do
+      str = AmberVM::Classes::String.new 'example'
+      str.should be_instance_of(AmberVM::Classes::String)
+      str.should == 'example'
+    end   
+    
+    it "should create with a string .to_s otherwise" do
+      value = mock('value mock')
+      value.should_receive(:to_s).once.with(no_args).and_return('example2')
+      str = AmberVM::Classes::String.new value
+      str.should be_instance_of(AmberVM::Classes::String)
+      str.should == 'example2'
+    end
+  end
+  
+  describe "(runtime)" do
+    before do
+      @object  = AmberVM::Classes::String.new "String"
+    end
+    
+    it "should be is_true? when non empty" do
+      @object.is_true?.should be_true
+    end
+    
+    it "should not be is_true? when  empty" do
+      @object  = AmberVM::Classes::String.new ""
+      @object.is_true?.should_not be_true
+    end
+    
+    it "should have the data_type :string" do
+      @object.data_type.should == :string
+    end
+    
+    it "should return a AmberVM::Classes::String when adding it" do
+      str =  @object + '!'
+      str.should be_instance_of(AmberVM::Classes::String)
+      str.should == 'String!'
+    end
+    
+    describe "(center)" do
+      it "should center evenly" do
+        str =   @object.center(8)
+        str.should be_instance_of(AmberVM::Classes::String)
+        str.should == ' String '
+      end
+      it "should align left when uneven" do
+        str =   @object.center(9)
+        str.should be_instance_of(AmberVM::Classes::String)
+        str.should == ' String  '
+      end
+      
+      it "should not crop the string when too long" do
+        str =   @object.center(1)
+        str.should be_instance_of(AmberVM::Classes::String)
+        str.should == 'String'       
+      end
+      
+      it "should allow to alter spacing chars" do
+        str =   @object.center(8,'.')
+        str.should be_instance_of(AmberVM::Classes::String)
+        str.should == '.String.'
+      end
+      
+      it "should take the first spacing chars" do
+        str =   @object.center(8,'-.')
+        str.should be_instance_of(AmberVM::Classes::String)
+        str.should == '-String-'
+      end      
+      it "should default the spacing char to space" do
+        str =   @object.center(8,'')
+        str.should be_instance_of(AmberVM::Classes::String)
+        str.should == ' String '
+      end  
+    end
+    
+    describe "(ljust)" do
+      it "should adjust to the left" do
+        str =   @object.ljust(7)
+        str.should be_instance_of(AmberVM::Classes::String)
+        str.should == 'String '
+      end
+      
+      it "should not crop the string when too long" do
+        str =   @object.ljust(1)
+        str.should be_instance_of(AmberVM::Classes::String)
+        str.should == 'String'       
+      end
+      
+      it "should allow to alter spacing chars" do
+        str =   @object.ljust(8,'.')
+        str.should be_instance_of(AmberVM::Classes::String)
+        str.should == 'String..'
+      end
+      
+      it "should take the first spacing chars" do
+        str =   @object.ljust(8,'-.')
+        str.should be_instance_of(AmberVM::Classes::String)
+        str.should == 'String--'
+      end
+      
+      it "should default the spacing char to space" do
+        str =   @object.ljust(8,'')
+        str.should be_instance_of(AmberVM::Classes::String)
+        str.should == 'String  '
+      end  
+    end
+    describe "(rjust)" do
+      it "should adjust to the right" do
+        str =   @object.rjust(7)
+        str.should be_instance_of(AmberVM::Classes::String)
+        str.should == ' String'
+      end
+      
+      it "should not crop the string when too long" do
+        str = @object.rjust(1)
+        str.should be_instance_of(AmberVM::Classes::String)
+        str.should == 'String'       
+      end
+      
+      it "should allow to alter spacing chars" do
+        str = @object.rjust(8,'.')
+        str.should be_instance_of(AmberVM::Classes::String)
+        str.should == '..String'
+      end
+      
+      it "should take the first spacing chars" do
+        str = @object.rjust(8,'-.')
+        str.should be_instance_of(AmberVM::Classes::String)
+        str.should == '--String'
+      end
+      
+      it "should default the spacing char to space" do
+        str = @object.rjust(8,'')
+        str.should be_instance_of(AmberVM::Classes::String)
+        str.should == '  String'
+      end  
+    end
+    describe "(ansi)" do
+      
+      it "should allow you to colorize strings" do
+        @object = @object.ansi('hr')
+        @object.should == "\e[1;31mString\e[0m"
+      end
+      
+      it "should handle embedding of ansi in other ansi" do
+        str_left = AmberVM::Classes::String.new("<")
+        str_right = AmberVM::Classes::String.new(">")
+        @object = @object.ansi('hr')
+        @object = str_left + @object + str_right
+        @object.should == "<\e[1;31mString\e[0m>"
+        @object = @object.ansi('g')
+        @object.should == "\e[32m<\e[1;31mString\e[32m>\e[0m"        
+      end
+      
+      it "should handle positioning ansi aware" do
+        pending("ANSI Awarenes isn't implemented yet")
+      end
+      
+      it "should split ansi aware" do
+        pending("ANSI Awarenes isn't implemented yet")
+      end
+    end
+  end
+end

data/spec/languages/ecma/ecma_array_spec.rb

@@ -0,0 +1,79 @@
+$: << 'lib'
+
+require 'amber'
+require 'amber/languages'
+require 'amber/languages/ecma'
+
+describe AmberVM::Languages::ECMA do
+  before(:each) do
+    @env = AmberVM::Interpreter.env
+    @compiler = AmberVM::Languages::ECMA.new
+  end
+  
+  def run code, &tests 
+    env = @env.dup
+    yield(@compiler.compile(code).execute(@env), @env)
+    yield(@compiler.compile(code).optimize.execute(env), env)
+  end
+  
+  describe "arrays" do
+    it "should allow accessing data on an array" do
+      @env['test'] = AmberVM::Classes::List.new([42])
+      code = <<-CODE
+        test[0]
+      CODE
+      run code do |result, env|
+        result.should == 42
+      end
+    end
+    
+    it "should allow set data on an array" do
+      @env['test'] = AmberVM::Classes::List.new([42])
+      code = <<-CODE
+        test[0] = 23
+      CODE
+      run code do |result, env|
+        result.should == 23
+        env['test'].val[0].val.should == 23
+      end
+    end
+    
+    it "should allow set data on an array from functions" do
+      @env['test'] = AmberVM::Classes::List.new([42])
+      code = <<-CODE
+        function f(x) {
+          return  x + 1;
+        };
+        a = 23;
+        test[0] = f(a);
+      CODE
+      run code do |result, env|
+        result.should == 24
+        env['test'].val[0].val.should == 24
+      end
+    end
+    
+    it "should allow to concat arrays" do
+      a1 = AmberVM::Classes::List.new([42])
+      @env['test'] = AmberVM::Classes::List.new([a1])
+      code = <<-CODE
+        test[0][0]
+      CODE
+      run code do |result, env|
+        result.should == 42
+      end
+    end
+    
+    it "should allow to concat arrays when setting values" do
+      a1 = AmberVM::Classes::List.new([42])
+      @env['test'] = AmberVM::Classes::List.new([a1])
+      code = <<-CODE
+        test[0][0] = 23
+      CODE
+      run code do |result, env|
+        result.should == 23
+        a1[0].val.should == 23
+      end
+    end
+  end
+end

data/spec/languages/ecma/ecma_closure_spec.rb

@@ -0,0 +1,38 @@
+$: << 'lib'
+require 'amber'
+require 'amber/languages'
+require 'amber/languages/ecma'
+
+describe AmberVM::Languages::ECMA do
+  before(:each) do
+    @env = AmberVM::Interpreter.env
+    @compiler = AmberVM::Languages::ECMA.new
+  end
+  
+  def run code, &tests 
+    env = @env.dup
+    yield(@compiler.compile(code).execute(@env), @env)
+    yield(@compiler.compile(code).optimize.execute(env), env)
+  end
+  
+  describe "closure" do
+    it "should be created" do
+      #pending 'No closures implemented yet.'
+      
+      code = <<-CODE
+        function createClosure(x) {
+          return function() {
+            return x;
+          };
+        };
+        closure = createClosure(42);
+        createClosure("wrong!");
+        closure();
+      CODE
+      run code do |result, env|
+          result.should == 42
+        end
+    end
+  end
+  
+end

data/spec/languages/ecma/ecma_literals_spec.rb

@@ -0,0 +1,71 @@
+$: << 'lib'
+
+require 'amber'
+require 'amber/languages'
+require 'amber/languages/ecma'
+
+describe AmberVM::Languages::ECMA do
+  before(:each) do
+    @compiler = AmberVM::Languages::ECMA.new
+    @env = @compiler.env
+  end
+  
+  def run code, &tests 
+    env = @env.dup
+    yield(@compiler.compile(code).execute(@env), @env)
+    yield(@compiler.compile(code).optimize.execute(env), env)
+  end
+  
+  describe "literals" do
+    it "should know String literals" do
+      code = <<-CODE
+        "test"
+      CODE
+      run code do |result, env|
+        result.should == "test"
+      end
+    end
+    it "should know Integer literals" do
+      code = <<-CODE
+        42
+      CODE
+      run code do |result, env|
+        result.should == 42
+      end
+    end
+    it "should know Float literals" do
+      code = <<-CODE
+        4.2
+      CODE
+      run code do |result, env|
+        result.should == 4.2
+      end
+    end
+    
+    it "should know complex Float literals" do
+      code = <<-CODE
+        .2e-10
+      CODE
+      run code do |result, env|
+        result.should == 0.2e-10
+      end
+    end
+    it "should know the false literals" do
+      code = <<-CODE
+        false
+      CODE
+      run code do |result, env|
+        result.should_not be_is_true
+      end
+    end
+    it "should know the true literals" do
+      code = <<-CODE
+        true
+      CODE
+      run code do |result, env|
+        result.should be_is_true
+      end
+    end
+  end
+  
+end