rVM 0.0.10 → 0.0.11

data/spec/classes/atom/boolean_spec.rb

@@ -0,0 +1,67 @@
+require "lib/rvm/classes/boolean"
+describe RVM::Classes::Boolean do
+  
+  
+  it "shoulds creat with a bool value" do
+    b = RVM::Classes::Boolean.new(true)
+    b.is_true?.should be_true
+    b = RVM::Classes::Boolean.new(false)
+    b.is_true?.should be_false
+  end
+  
+  it "should create with nil" do
+    b = RVM::Classes::Boolean.new(nil)
+    b.is_true?.should be_false
+  end
+  
+  it "should use is_true? if existing" do
+    val = mock('value mock')
+    val.should_receive(:respond_to?).once.with(:is_true?).and_return(true)
+    val.should_receive(:is_true?).once.with(no_args).and_return(false)
+    b = RVM::Classes::Boolean.new(val)
+    b.is_true?.should be_false 
+  end
+  
+  it "should have the data type :boolean" do
+    b = RVM::Classes::Boolean.new(true)
+    b.data_type.should == :boolean
+  end
+  
+  def setup
+    super
+    @Boolean = RVM::Classes::Boolean
+  end
+  
+  def test_class
+    assert(@Boolean)
+  end
+  
+  def test_creation
+    assert(@Boolean.new(@Boolean), "Create not nil object bool")
+  end
+  
+  def test_compare
+    assert_equal(@Boolean.new(true),@Boolean.new(true))
+    assert_equal(@Boolean.new(false),@Boolean.new(false))
+    assert_equal(@Boolean.new(false),@Boolean.new(nil))
+    assert_equal(@Boolean.new(true),@Boolean.new(self))
+  end
+  
+  def test_creation_is_true
+    assert(@Boolean)
+    assert(b1 = @Boolean.new(true), "Create true bool.")
+    assert(b2 = @Boolean.new(false), "Create false bool.")
+    assert(b3 = @Boolean.new(nil), "Create nil bool.")
+    assert(b4 = @Boolean.new(b1), "Create is_true? object bool.")
+    assert(b5 = @Boolean.new(b2), "Create not is_true? object bool.")
+    assert(b6 = @Boolean.new(@Boolean), "Create not nil object bool.")
+    
+    assert(b1.is_true?, "Test if true is true.")
+    assert(!b2.is_true?, "Test if false is false.")
+    assert(!b3.is_true?, "Test if nis is false.")
+    assert(b4.is_true?, "Test if a is_true? object is true.")
+    assert(!b5.is_true?, "Test if a not is_true? object is false.")
+    assert(b6.is_true?, "Test if not null object is true.")
+  end
+  
+end

data/spec/classes/atom/error_spec.rb

@@ -0,0 +1,43 @@
+require "lib/rvm/classes/error"
+describe RVM::Classes::Error do
+  
+  describe "(creation)" do
+    
+    it "should create with an integer" do
+      e = RVM::Classes::Error.new(1,"Test error")
+      e.should be
+    end
+    
+    it "should create with an integer" do
+      e = RVM::Classes::Error.new(1.2,"Test error")
+      e.should be
+    end
+    
+    it "should create with with odd stuff" do
+      e = RVM::Classes::Error.new(nil,"Test error")
+      e.should be
+      e = RVM::Classes::Error.new("muhaha","Test error")
+      e.should be
+    end
+    
+  end
+  
+  describe "(usage)" do
+    it "shuld convert to a error string" do
+      e = RVM::Classes::Error.new(1,"Test error.")
+      e.to_s.should == "#1 Test error."
+    end
+    
+    it "should prevent double positive error numbers" do
+      e = RVM::Classes::Error.new(-3,"Test error.")
+      e.to_s.should == "#-3 Test error."
+    end
+    
+    it "should return false for is_true?." do
+      e = RVM::Classes::Error.new(1,"Test error.")
+      e.is_true?.should be_false
+    end
+    
+  end
+  
+end

data/spec/classes/atom/list_spec.rb

@@ -0,0 +1,68 @@
+require "lib/rvm/classes/list"
+describe RVM::Classes::List do
+  
+  describe "(creation)" do
+    it "should create empty" do
+      l = RVM::Classes::List.new()
+      l.size.should be(0)
+    end
+    
+    it "should create simple lists with one element" do
+      l = RVM::Classes::List.new(true)
+      l.size.should be(1)
+    end
+    
+    
+    it "should create from an array" do
+      l = RVM::Classes::List.new(['1','2','3','4'])
+      l.size.should be(4)
+    end
+    
+    it "should split a list of string sepperated items" do
+      l = RVM::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 = RVM::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 = RVM::Classes::List.new("")
+      l.data_type.should == :list
+    end
+  end
+  
+  describe "(conversion)" do
+    it "should rejoin a list, by default with spaces" do
+      l = RVM::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 = RVM::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 = RVM::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 = RVM::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 "lib/rvm/classes"
+require "lib/rvm/classes/number"
+
+describe RVM::Classes::Number do
+  
+  describe "(creation)" do
+    
+    it "should create from fixnums" do
+      n = RVM::Classes::Number.new(1)
+      n.should be_instance_of(RVM::Classes::Number)
+      n.should == 1
+    end
+    
+    it "should create from floats" do
+      n = RVM::Classes::Number.new(1.1)
+      n.should be_instance_of(RVM::Classes::Number)
+      n.should == 1.1
+    end
+    
+    it "should create from bignum" do
+      n = RVM::Classes::Number.new(10**100)
+      n.should be_instance_of(RVM::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 = RVM::Classes::Number.new(value)
+        n.should be_instance_of(RVM::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 = RVM::Classes::Number.new(value)
+        n.should be_instance_of(RVM::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 = RVM::Classes::Number.new(value)
+        n.should be_instance_of(RVM::Classes::Number)
+        n.should == 4.2
+      end
+    end
+  end
+  describe "(runtime)" do
+    before do
+      @object  = RVM::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 =RVM::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 =  RVM::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(RVM::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 = RVM::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(RVM::Classes::Number)
+        res.should == 42
+      end
+      
+      it "should raise a method missing otherwise" do
+        @object  = RVM::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 "lib/rvm/classes/string"
+
+describe RVM::Classes::String do
+  
+  describe "(creation)" do
+    it "should create as an empty string without arguments" do
+      str = RVM::Classes::String.new
+      str.should be_instance_of(RVM::Classes::String)
+      str.empty?.should be_true
+    end
+    
+    it "should create with a string parameter" do
+      str = RVM::Classes::String.new 'example'
+      str.should be_instance_of(RVM::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 = RVM::Classes::String.new value
+      str.should be_instance_of(RVM::Classes::String)
+      str.should == 'example2'
+    end
+  end
+  
+  describe "(runtime)" do
+    before do
+      @object  = RVM::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  = RVM::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 RVM::Classes::String when adding it" do
+      str =  @object + '!'
+      str.should be_instance_of(RVM::Classes::String)
+      str.should == 'String!'
+    end
+    
+    describe "(center)" do
+      it "should center evenly" do
+        str =   @object.center(8)
+        str.should be_instance_of(RVM::Classes::String)
+        str.should == ' String '
+      end
+      it "should align left when uneven" do
+        str =   @object.center(9)
+        str.should be_instance_of(RVM::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(RVM::Classes::String)
+        str.should == 'String'       
+      end
+      
+      it "should allow to alter spacing chars" do
+        str =   @object.center(8,'.')
+        str.should be_instance_of(RVM::Classes::String)
+        str.should == '.String.'
+      end
+      
+      it "should take the first spacing chars" do
+        str =   @object.center(8,'-.')
+        str.should be_instance_of(RVM::Classes::String)
+        str.should == '-String-'
+      end      
+      it "should default the spacing char to space" do
+        str =   @object.center(8,'')
+        str.should be_instance_of(RVM::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(RVM::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(RVM::Classes::String)
+        str.should == 'String'       
+      end
+      
+      it "should allow to alter spacing chars" do
+        str =   @object.ljust(8,'.')
+        str.should be_instance_of(RVM::Classes::String)
+        str.should == 'String..'
+      end
+      
+      it "should take the first spacing chars" do
+        str =   @object.ljust(8,'-.')
+        str.should be_instance_of(RVM::Classes::String)
+        str.should == 'String--'
+      end
+      
+      it "should default the spacing char to space" do
+        str =   @object.ljust(8,'')
+        str.should be_instance_of(RVM::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(RVM::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(RVM::Classes::String)
+        str.should == 'String'       
+      end
+      
+      it "should allow to alter spacing chars" do
+        str = @object.rjust(8,'.')
+        str.should be_instance_of(RVM::Classes::String)
+        str.should == '..String'
+      end
+      
+      it "should take the first spacing chars" do
+        str = @object.rjust(8,'-.')
+        str.should be_instance_of(RVM::Classes::String)
+        str.should == '--String'
+      end
+      
+      it "should default the spacing char to space" do
+        str = @object.rjust(8,'')
+        str.should be_instance_of(RVM::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 = RVM::Classes::String.new("<")
+        str_right = RVM::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