rubyvis 0.6.1 → 0.7.0

data/spec/dom_spec.rb

@@ -11,12 +11,12 @@ describe Rubyvis::Dom do
     dom_map=Rubyvis::Dom.new(map)       
     
     root=dom_map.root.sort {|a,b| a.node_name.to_s<=>b.node_name.to_s}
-    root.nodes.should be_instance_of Array
-    root.nodes.size.should eq 8
+    expect(root.nodes).to be_instance_of Array
+    expect(root.nodes.size).to eq 8
     ar=root.nodes.map do |n|
       [n.node_name, n.node_value]
     end
-    ar.should eq [[nil, nil], [:a, nil], [:aa, 1], [:ab, nil], [:aba, 2], [:b, 4], [:c, nil], [:ca, 5]]
+    expect(ar).to eq [[nil, nil], [:a, nil], [:aa, 1], [:ab, nil], [:aba, 2], [:b, 4], [:c, nil], [:ca, 5]]
   end
   it "should treemap example works right" do
     flare={:a=>{:aa=>1,:ab=>1,:ac=>1},:b=>{:ba=>1,:bb=>1},:c=>3}
@@ -42,7 +42,7 @@ describe Rubyvis::Dom do
     root.visit_before {|n,i|
       ar.push [n.node_name, n.size]
     }
-    ar.should eq [["flare", 8.0], [:b, 2.0], [:ba, 1.0], [:bb, 1.0], [:a, 3.0], [:aa, 1.0], [:ab, 1.0], [:ac, 1.0], [:c, 3.0]]
+    expect(ar).to eq [["flare", 8.0], [:b, 2.0], [:ba, 1.0], [:bb, 1.0], [:a, 3.0], [:aa, 1.0], [:ab, 1.0], [:ac, 1.0], [:c, 3.0]]
   end
   describe Rubyvis::Dom::Node do
     before do
@@ -55,44 +55,44 @@ describe Rubyvis::Dom do
     end
     subject {@n}
     it "should have node_value" do 
-      @n.node_value.should eq :a
+      expect(@n.node_value).to eq :a
     end
-    it  {should respond_to :parent_node}
-    it  {should respond_to :first_child}
-    it  {should respond_to :last_child}
-    it  {should respond_to :previous_sibling}
-    it  {should respond_to :next_sibling}
-    it  {should respond_to :node_name}
-    it  {should respond_to :child_nodes}
+    it  {is_expected.to respond_to :parent_node}
+    it  {is_expected.to respond_to :first_child}
+    it  {is_expected.to respond_to :last_child}
+    it  {is_expected.to respond_to :previous_sibling}
+    it  {is_expected.to respond_to :next_sibling}
+    it  {is_expected.to respond_to :node_name}
+    it  {is_expected.to respond_to :child_nodes}
     it "should child_nodes be empty" do
       @n.child_nodes.size==0
     end
     it "method append_child" do
-      @n.append_child(@n2).should eq @n2
-      @n.child_nodes.should eq [@n2]
-      @n2.parent_node.should eq @n
-      @n.first_child.should eq @n2
-      @n.last_child.should eq @n2
+      expect(@n.append_child(@n2)).to eq @n2
+      expect(@n.child_nodes).to eq [@n2]
+      expect(@n2.parent_node).to eq @n
+      expect(@n.first_child).to eq @n2
+      expect(@n.last_child).to eq @n2
       
       @n.append_child(@n3)
-      @n.child_nodes.should eq [@n2,@n3]
-      @n3.parent_node.should eq @n
-      @n.first_child.should eq @n2
-      @n.last_child.should eq @n3
-      @n2.previous_sibling.should be_nil
-      @n2.next_sibling.should eq @n3
-      @n3.previous_sibling.should eq @n2
-      @n3.next_sibling.should be_nil
+      expect(@n.child_nodes).to eq [@n2,@n3]
+      expect(@n3.parent_node).to eq @n
+      expect(@n.first_child).to eq @n2
+      expect(@n.last_child).to eq @n3
+      expect(@n2.previous_sibling).to be_nil
+      expect(@n2.next_sibling).to eq @n3
+      expect(@n3.previous_sibling).to eq @n2
+      expect(@n3.next_sibling).to be_nil
       
       @n.append_child(@n4)
-      @n.last_child.should eq @n4
-      @n2.next_sibling.should eq @n3
-      @n3.next_sibling.should eq @n4
-      @n4.next_sibling.should be_nil
+      expect(@n.last_child).to eq @n4
+      expect(@n2.next_sibling).to eq @n3
+      expect(@n3.next_sibling).to eq @n4
+      expect(@n4.next_sibling).to be_nil
 
-      @n4.previous_sibling.should eq @n3
-      @n3.previous_sibling.should eq @n2
-      @n2.previous_sibling.should be_nil
+      expect(@n4.previous_sibling).to eq @n3
+      expect(@n3.previous_sibling).to eq @n2
+      expect(@n2.previous_sibling).to be_nil
       
     end
     it "method remove_child" do
@@ -100,42 +100,42 @@ describe Rubyvis::Dom do
       @n.append_child(@n3)
       @n.append_child(@n4)
       
-      @n.remove_child(@n3).should eq @n3
+      expect(@n.remove_child(@n3)).to eq @n3
       
-      @n3.next_sibling.should be_nil
-      @n3.previous_sibling.should be_nil
-      @n3.parent_node.should be_nil
+      expect(@n3.next_sibling).to be_nil
+      expect(@n3.previous_sibling).to be_nil
+      expect(@n3.parent_node).to be_nil
       
-      @n2.next_sibling.should eq @n4
-      @n4.previous_sibling.should eq @n2
+      expect(@n2.next_sibling).to eq @n4
+      expect(@n4.previous_sibling).to eq @n2
       
       @n.remove_child(@n4)
-      @n2.next_sibling.should be_nil
-      @n.first_child.should eq @n2
-      @n.last_child.should eq @n2
+      expect(@n2.next_sibling).to be_nil
+      expect(@n.first_child).to eq @n2
+      expect(@n.last_child).to eq @n2
     end
     
     it "method insert_before" do
       @n.append_child(@n2)
       @n.append_child(@n4)
       @n.insert_before(@n3,@n4)
-      @n.child_nodes.size.should eq 3
+      expect(@n.child_nodes.size).to eq 3
       
-      @n.first_child.should eq @n2
-      @n.last_child.should eq @n4
-      @n2.next_sibling.should eq @n3
-      @n3.next_sibling.should eq @n4
-      @n4.next_sibling.should be_nil
+      expect(@n.first_child).to eq @n2
+      expect(@n.last_child).to eq @n4
+      expect(@n2.next_sibling).to eq @n3
+      expect(@n3.next_sibling).to eq @n4
+      expect(@n4.next_sibling).to be_nil
      
-      @n2.previous_sibling.should be_nil
-      @n3.previous_sibling.should eq @n2
-      @n4.previous_sibling.should eq @n3
+      expect(@n2.previous_sibling).to be_nil
+      expect(@n3.previous_sibling).to eq @n2
+      expect(@n4.previous_sibling).to eq @n3
       
       
       
-      @n.child_nodes[0].should eq @n2
-      @n.child_nodes[1].should eq @n3
-      @n.child_nodes[2].should eq @n4
+      expect(@n.child_nodes[0]).to eq @n2
+      expect(@n.child_nodes[1]).to eq @n3
+      expect(@n.child_nodes[2]).to eq @n4
       
     end
     it "method replace_child" do
@@ -143,20 +143,20 @@ describe Rubyvis::Dom do
       @n.append_child(@n3)
       @n.replace_child(@n4,@n3)
       
-      @n.child_nodes.size.should eq 2
+      expect(@n.child_nodes.size).to eq 2
       
-      @n.child_nodes[0].should eq @n2
-      @n.child_nodes[1].should eq @n4
+      expect(@n.child_nodes[0]).to eq @n2
+      expect(@n.child_nodes[1]).to eq @n4
 
-      @n2.next_sibling.should eq @n4
-      @n4.next_sibling.should eq nil
+      expect(@n2.next_sibling).to eq @n4
+      expect(@n4.next_sibling).to eq nil
      
-      @n2.previous_sibling.should be_nil
-      @n4.previous_sibling.should eq @n2
+      expect(@n2.previous_sibling).to be_nil
+      expect(@n4.previous_sibling).to eq @n2
 
       
-      @n.first_child.should eq @n2
-      @n.last_child.should eq @n4
+      expect(@n.first_child).to eq @n2
+      expect(@n.last_child).to eq @n4
     end
     describe "visit methods" do
       before do
@@ -172,21 +172,21 @@ describe Rubyvis::Dom do
         @n.visit_before {|n,d|
           @a.push([n.node_value,d])
         }
-        @a.should eq [[:a, 0], [:b, 1], [:e, 2], [:c, 1], [:d, 2]]
+        expect(@a).to eq [[:a, 0], [:b, 1], [:e, 2], [:c, 1], [:d, 2]]
       end
       
       it "method visit_after" do
         @n.visit_after {|n,d|
           @a.push([n.node_value,d])
         }
-        @a.should eq [[:e, 2], [:b, 1], [:d, 2], [:c, 1], [:a, 0]]
+        expect(@a).to eq [[:e, 2], [:b, 1], [:d, 2], [:c, 1], [:a, 0]]
       end
       it "method each_child" do
         @n.append_child(@n5)        
         @n.each_child {|d|
           @a.push(d.node_value)
         }
-        @a.should eq [:b, :c,:e]
+        expect(@a).to eq [:b, :c,:e]
       end
     end
     it "should sort correctly" do
@@ -197,20 +197,20 @@ describe Rubyvis::Dom do
       
       @n.sort {|a,b| a.node_value.to_s<=>b.node_value.to_s}
       
-      @n.child_nodes.should eq [@n2,@n3,@n4,@n5]
+      expect(@n.child_nodes).to eq [@n2,@n3,@n4,@n5]
       
-      @n.first_child.should eq @n2
-      @n.last_child.should eq @n5
+      expect(@n.first_child).to eq @n2
+      expect(@n.last_child).to eq @n5
       
-      @n2.next_sibling.should eq @n3
-      @n3.next_sibling.should eq @n4
-      @n4.next_sibling.should eq @n5
-      @n5.next_sibling.should be_nil
+      expect(@n2.next_sibling).to eq @n3
+      expect(@n3.next_sibling).to eq @n4
+      expect(@n4.next_sibling).to eq @n5
+      expect(@n5.next_sibling).to be_nil
 
-      @n2.previous_sibling.should be_nil
-      @n3.previous_sibling.should eq @n2
-      @n4.previous_sibling.should eq @n3
-      @n5.previous_sibling.should eq @n4
+      expect(@n2.previous_sibling).to be_nil
+      expect(@n3.previous_sibling).to eq @n2
+      expect(@n4.previous_sibling).to eq @n3
+      expect(@n5.previous_sibling).to eq @n4
     end
     it "should reverse correctly" do
       @n.append_child(@n3)
@@ -218,7 +218,7 @@ describe Rubyvis::Dom do
       @n.append_child(@n2)
       @n.append_child(@n4)
       @n.reverse
-      @n.child_nodes.should eq [@n4,@n2,@n5,@n3]
+      expect(@n.child_nodes).to eq [@n4,@n2,@n5,@n3]
     end
     
   end

data/spec/dot_spec.rb

@@ -4,10 +4,10 @@ require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
   it "should have correct properties" do
     props=[:antialias, :bottom, :cursor, :data, :events, :fill_style,  :id, :left, :line_width, :reverse, :right, :shape, :shape_angle, :shape_radius, :shape_size, :stroke_style, :title, :top, :visible].inject({}) {|ac, v| ac[v]=true; ac}
     
-    Rubyvis::Dot.properties.should==props
+    expect(Rubyvis::Dot.properties).to eq(props)
   end
   it "Rubyvis.Dot be the same as Rubyvis::Dot" do
-    Rubyvis.Dot.should eql Rubyvis::Dot
+    expect(Rubyvis.Dot).to eql Rubyvis::Dot
   end
   
   it "should render correctly 'dot-anchor' example" do
@@ -34,7 +34,7 @@ require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
     vis.render()
     
     pv_out=fixture_svg_read("dot_anchor.svg")
-    vis.to_svg.should have_same_svg_elements(pv_out)
+    expect(vis.to_svg).to have_same_svg_elements(pv_out)
   end
   
   

data/spec/flatten_spec.rb

@@ -37,11 +37,11 @@ describe Rubyvis::Flatten do
     }
     expected=[{"band"=>"Genesis", "type"=>"Live", "album"=>"Genesis Live", "year"=>1973}, {"band"=>"Genesis", "type"=>"Live", "album"=>"Seconds Out", "year"=>1977}, {"band"=>"Genesis", "type"=>"Studio", "album"=>"Nursery Cryme", "year"=>1971}, {"band"=>"Genesis", "type"=>"Studio", "album"=>"Foxtrot", "year"=>1972}, {"band"=>"Rush", "type"=>"Studio", "album"=>"Permanent Waves", "year"=>1980}, {"band"=>"Rush", "type"=>"Studio", "album"=>"Moving Pictures", "year"=>1981}, {"band"=>"Rush", "type"=>"Live", "album"=>"Exit...Stage Left", "year"=>1981}, {"band"=>"Rush", "type"=>"Live", "album"=>"A Show of Hands", "year"=>1989}].sort(&sorting)
     
-    @flatten.array.sort(&sorting).should eq expected
+    expect(@flatten.array.sort(&sorting)).to eq expected
   end
   it "other example" do
     @flatten.leaf(lambda {|f| f.is_a? Numeric})
     expected=[{:keys=>["Genesis", "Live", "Genesis Live"], :value=>1973}, {:keys=>["Genesis", "Live", "Seconds Out"], :value=>1977}, {:keys=>["Genesis", "Studio", "Nursery Cryme"], :value=>1971}, {:keys=>["Genesis", "Studio", "Foxtrot"], :value=>1972}, {:keys=>["Rush", "Studio", "Permanent Waves"], :value=>1980}, {:keys=>["Rush", "Studio", "Moving Pictures"], :value=>1981}, {:keys=>["Rush", "Live", "Exit...Stage Left"], :value=>1981}, {:keys=>["Rush", "Live", "A Show of Hands"], :value=>1989}]
-    @flatten.array.should eql expected
+    expect(@flatten.array).to eql expected
   end
 end

data/spec/histogram_spec.rb

@@ -9,20 +9,20 @@ describe Rubyvis::Histogram do
       @bins=@hist.bins
     end
     it "size should be correct" do
-      @bins.size.should eq 8
+      expect(@bins.size).to eq 8
     end
     it "bin.x should be correct" do
-      @bins.map {|b| b.x}.should eq [-0.8, -0.6, -0.4, -0.2, 0, 0.2,0.4, 0.6]
+      expect(@bins.map {|b| b.x}).to eq [-0.8, -0.6, -0.4, -0.2, 0, 0.2,0.4, 0.6]
     end
     it "bin.dx should be correct" do
-      @bins.map {|b| b.dx}.should eq [0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2]
+      expect(@bins.map {|b| b.dx}).to eq [0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2]
     end
     it "bin.y should be correct" do
-      @bins.map {|b| b.y}.should eq [19,5,6,7,8,8,11,36]
+      expect(@bins.map {|b| b.y}).to eq [19,5,6,7,8,8,11,36]
     end
     it "bin.y should be correct using frequency=false" do
       @hist.frequency=false
-      @hist.bins.map {|b| b.y}.should eq [0.19,0.05,0.06,0.07,0.08,0.08,0.11,0.36]
+      expect(@hist.bins.map {|b| b.y}).to eq [0.19,0.05,0.06,0.07,0.08,0.08,0.11,0.36]
     end
   end
 end

data/spec/image_spec.rb

@@ -4,7 +4,7 @@ describe Rubyvis::Image do
   include Rubyvis::GeneralSpec
 
   it "Rubyvis.Image be the same as Rubyvis::Image" do
-    Rubyvis.Image.should eql Rubyvis::Image
+    expect(Rubyvis.Image).to eql Rubyvis::Image
   end
   
   it "should render correctly" do
@@ -21,7 +21,7 @@ describe Rubyvis::Image do
     vis.render()
     
     pv_out=fixture_svg_read("image.svg")
-    vis.to_svg.should have_same_svg_elements(pv_out)
+    expect(vis.to_svg).to have_same_svg_elements(pv_out)
   end
    
 end

data/spec/internal_spec.rb

@@ -4,22 +4,22 @@ describe "Rubyvis module methods" do
     it "method identify should always return the same value" do
       f=Rubyvis.identity
       a="a"
-      f.js_call(a, 5).should==5
+      expect(f.js_call(a, 5)).to eq(5)
     end
     it "method index should return index method from a object" do
       o1=Rubyvis.o_index(1)
       o2=Rubyvis.o_index(10)
-      Rubyvis.index.js_call(o1,1,2).should==1
-      Rubyvis.index.js_call(o2,1,2).should==10
+      expect(Rubyvis.index.js_call(o1,1,2)).to eq(1)
+      expect(Rubyvis.index.js_call(o2,1,2)).to eq(10)
     end
   end
   describe "from pv-internal.js" do 
     it "should create a infinite succesion with id" do
       f=Rubyvis.id
-      Rubyvis.id.should==f+1
+      expect(Rubyvis.id).to eq(f+1)
     end
     it "should return a lambda with functor" do
-      Rubyvis.functor(5).call.should==5
+      expect(Rubyvis.functor(5).call).to eq(5)
     end
   end
   describe "from data/Arrays.js" do 
@@ -27,123 +27,123 @@ describe "Rubyvis module methods" do
       f=lambda {|d| "#{self.index}-#{d}"}
       i=%w{a b c}
       o=%w{0-a 1-b 2-c}
-      Rubyvis.map(i).should==i
-      Rubyvis.map(i,f).should==o
+      expect(Rubyvis.map(i)).to eq(i)
+      expect(Rubyvis.map(i,f)).to eq(o)
     end
     it "repeat method should repeat the specified array n times" do
-      Rubyvis.repeat([1,2]).should==[1,2,1,2]
-      Rubyvis.repeat([1,2],3).should==[1,2,1,2,1,2]
+      expect(Rubyvis.repeat([1,2])).to eq([1,2,1,2])
+      expect(Rubyvis.repeat([1,2],3)).to eq([1,2,1,2,1,2])
     end
     it "cross method should return an array of all posible pairs of element" do
-      Rubyvis.cross([1,2],[3,4]).should==[[1,3],[1,4],[2,3],[2,4]]
+      expect(Rubyvis.cross([1,2],[3,4])).to eq([[1,3],[1,4],[2,3],[2,4]])
     end
     it "blend method should concatenates the arrays into a single array" do
-      Rubyvis.blend([[1,2,3],[4,5,6],[7,8,9]]).should==(1..9).to_a
+      expect(Rubyvis.blend([[1,2,3],[4,5,6],[7,8,9]])).to eq((1..9).to_a)
     end
     it "transpose method should returns a transposed array of arrays" do
-      Rubyvis.transpose([[1,2,3],[4,5,6]]).should==[[1,4],[2,5],[3,6]]
+      expect(Rubyvis.transpose([[1,2,3],[4,5,6]])).to eq([[1,4],[2,5],[3,6]])
     end
     it "normalize method should returns a normalized copy of array" do
-      Rubyvis.normalize([1,1,3]).should==[0.2,0.2,0.6]
+      expect(Rubyvis.normalize([1,1,3])).to eq([0.2,0.2,0.6])
       a=%w{aa ccc ddddd}
       f=lambda {|e| e.size}
-      Rubyvis.normalize(a,f).should==[0.2,0.3,0.5]
+      expect(Rubyvis.normalize(a,f)).to eq([0.2,0.3,0.5])
     end
     it "permute method allows to permute the order of elements" do
-      Rubyvis.permute(%w{a b c},[1,2,0]).should==%w{b c a}
+      expect(Rubyvis.permute(%w{a b c},[1,2,0])).to eq(%w{b c a})
       f=lambda {|e| [self.index,e]}
-      Rubyvis.permute(%w{a b c},[1,2,0],f).should==[[1,"b"],[2,"c"],[0,"a"]]
+      expect(Rubyvis.permute(%w{a b c},[1,2,0],f)).to eq([[1,"b"],[2,"c"],[0,"a"]])
     end
     it "numerate should  map from key to index for the specified keys array" do
-      Rubyvis.numerate(["a", "b", "c"]).should=={"a"=>0,"b"=>1,"c"=>2}
+      expect(Rubyvis.numerate(["a", "b", "c"])).to eq({"a"=>0,"b"=>1,"c"=>2})
     end
     it "method uniq returns the unique elements in the specified array" do
-      Rubyvis.uniq(["a", "b", "c","c"]).should==["a","b","c"]
-      Rubyvis.uniq(["a", "b", "c","c"], lambda{|e| e*2}).should==["aa","bb","cc"]
+      expect(Rubyvis.uniq(["a", "b", "c","c"])).to eq(["a","b","c"])
+      expect(Rubyvis.uniq(["a", "b", "c","c"], lambda{|e| e*2})).to eq(["aa","bb","cc"])
     end
     it "method search should return correct values" do
       a=(0..9).to_a
-      Rubyvis.search(a,1).should==1
-      Rubyvis.search(a,20).should==-11
-      Rubyvis.search(a,5.5).should==-7
+      expect(Rubyvis.search(a,1)).to eq(1)
+      expect(Rubyvis.search(a,20)).to eq(-11)
+      expect(Rubyvis.search(a,5.5)).to eq(-7)
     end
     it "method search_index should return correct values" do
       a=(0..9).to_a
-      Rubyvis.search_index(a,1).should==1
-      Rubyvis.search_index(a,20).should==10
-      Rubyvis.search_index(a,5.5).should==6
+      expect(Rubyvis.search_index(a,1)).to eq(1)
+      expect(Rubyvis.search_index(a,20)).to eq(10)
+      expect(Rubyvis.search_index(a,5.5)).to eq(6)
     end
   end
   describe "from data/Numbers.js" do
     it "method range should create range of numbers" do
-      Rubyvis.range(1,10).should==[1,2,3,4,5,6,7,8,9]
-      Rubyvis.range(1,10,0.5).should==[1,1.5,2,2.5,3,3.5,4,4.5,5,5.5,6,6.5,7,7.5,8,8.5,9,9.5]
-      Rubyvis.range(1,10,3).should==[1,4,7]  
-      lambda {Rubyvis.range(1,10,0)}.should raise_exception
+      expect(Rubyvis.range(1,10)).to eq([1,2,3,4,5,6,7,8,9])
+      expect(Rubyvis.range(1,10,0.5)).to eq([1,1.5,2,2.5,3,3.5,4,4.5,5,5.5,6,6.5,7,7.5,8,8.5,9,9.5])
+      expect(Rubyvis.range(1,10,3)).to eq([1,4,7])  
+      expect {Rubyvis.range(1,10,0)}.to raise_exception
     end
     it "method random returns a random number between values" do
       srand(10)
-      100.times.map{ Rubyvis.random(5)}.uniq.sort.should==(0..4).to_a
-      100.times.map{ Rubyvis.random(1,5)}.uniq.sort.should==(1..4).to_a
-      100.times.map{ Rubyvis.random(1,3,0.5)}.uniq.sort.should== [1.0,1.5,2.0,2.5]
+      expect(100.times.map{ Rubyvis.random(5)}.uniq.sort).to eq((0..4).to_a)
+      expect(100.times.map{ Rubyvis.random(1,5)}.uniq.sort).to eq((1..4).to_a)
+      expect(100.times.map{ Rubyvis.random(1,3,0.5)}.uniq.sort).to eq([1.0,1.5,2.0,2.5])
     end
     it "methods sum returns a sum" do
-      Rubyvis.sum([1,2,3,4]).should==(1+2+3+4)
-      Rubyvis.sum(%w{1 4 3 2 5}, lambda {|v| v.to_i * self.index}).should==(4*1 + 3*2 + 2*3 + 5*4)
+      expect(Rubyvis.sum([1,2,3,4])).to eq(1+2+3+4)
+      expect(Rubyvis.sum(%w{1 4 3 2 5}, lambda {|v| v.to_i * self.index})).to eq(4*1 + 3*2 + 2*3 + 5*4)
     end
     it "method max returns maximum value" do
-      Rubyvis.max([1,2,3,4]).should==4
-      Rubyvis.max([1,2,3,4], Rubyvis.index).should==3
-      Rubyvis.max(%w{1 4 3 2 5}, lambda {|v| v.to_i * self.index}).should==20
+      expect(Rubyvis.max([1,2,3,4])).to eq(4)
+      expect(Rubyvis.max([1,2,3,4], Rubyvis.index)).to eq(3)
+      expect(Rubyvis.max(%w{1 4 3 2 5}, lambda {|v| v.to_i * self.index})).to eq(20)
     end
     it "method max_index returns maximum value index" do
-      Rubyvis.max_index([1,2,4,3]).should==2
-      Rubyvis.max_index(%w{1 4 3 2 5}, lambda {|v| v.to_i * self.index}).should==4
+      expect(Rubyvis.max_index([1,2,4,3])).to eq(2)
+      expect(Rubyvis.max_index(%w{1 4 3 2 5}, lambda {|v| v.to_i * self.index})).to eq(4)
     end
     it "method min returns minimum value" do
-      Rubyvis.min([1,2,3,4]).should==1
-      Rubyvis.min([1,2,3,4], Rubyvis.index).should==0
-      Rubyvis.min(%w{2 0 3 2 5}, lambda {|v| v.to_i + self.index}).should==1
+      expect(Rubyvis.min([1,2,3,4])).to eq(1)
+      expect(Rubyvis.min([1,2,3,4], Rubyvis.index)).to eq(0)
+      expect(Rubyvis.min(%w{2 0 3 2 5}, lambda {|v| v.to_i + self.index})).to eq(1)
     end
     it "method min_index returns minimum value index" do
-      Rubyvis.min_index([1,2,4,-1]).should==3
-      Rubyvis.min_index(%w{1 4 3 2 5}, lambda {|v| v.to_i * self.index}).should==0
+      expect(Rubyvis.min_index([1,2,4,-1])).to eq(3)
+      expect(Rubyvis.min_index(%w{1 4 3 2 5}, lambda {|v| v.to_i * self.index})).to eq(0)
     end
     it "method mean returns mean of values" do
       a,b,c,d=rand,rand,rand,rand
       #Rubyvis.mean([a,b,c,d]).should==(a+b+c+d).quo(4)
-      Rubyvis.mean([a,b,c,d].map {|x| x.to_s}, lambda {|v| v.to_f+1}).should==(a+b+c+d).quo(4)+1
+      expect(Rubyvis.mean([a,b,c,d].map {|x| x.to_s}, lambda {|v| v.to_f+1})).to eq((a+b+c+d).quo(4)+1)
     end
     it "method median returns median of values" do
-      Rubyvis.median([1,2,4,3]).should==2.5
-      Rubyvis.median([1,3,2,5,3]).should==3
-      Rubyvis.median([1,3,2,5,3].map {|v| v.to_s}, lambda {|v| v.to_f}).should==3
+      expect(Rubyvis.median([1,2,4,3])).to eq(2.5)
+      expect(Rubyvis.median([1,3,2,5,3])).to eq(3)
+      expect(Rubyvis.median([1,3,2,5,3].map {|v| v.to_s}, lambda {|v| v.to_f})).to eq(3)
     end
     it "method variance returns sum of squares" do
-      Rubyvis.variance([5,7,9,11]).should==20
-      Rubyvis.variance([5,7,9,11], lambda {|x| x+self.index}).should==45
+      expect(Rubyvis.variance([5,7,9,11])).to eq(20)
+      expect(Rubyvis.variance([5,7,9,11], lambda {|x| x+self.index})).to eq(45)
     end
     it "method deviation returns standard deviation" do
-      Rubyvis.deviation([5,7,9,11]).should be_within( 0.001).of(2.581)
+      expect(Rubyvis.deviation([5,7,9,11])).to be_within( 0.001).of(2.581)
     end
     it "method log" do
-      Rubyvis.log(5,4).should be_within( 0.001).of(1.16)
+      expect(Rubyvis.log(5,4)).to be_within( 0.001).of(1.16)
     end
     it "method log_symmetric" do
-      Rubyvis.log_symmetric(-5,4).should be_within( 0.001).of(-1.16)
+      expect(Rubyvis.log_symmetric(-5,4)).to be_within( 0.001).of(-1.16)
     end
     it "method log_adjusted" do
-      Rubyvis.log_adjusted(6,10).should be_within( 0.001).of(0.806)
+      expect(Rubyvis.log_adjusted(6,10)).to be_within( 0.001).of(0.806)
     end
     it "method log_floor" do
-      Rubyvis.log_floor(-5,4).should be_within( 0.001).of(16)
+      expect(Rubyvis.log_floor(-5,4)).to be_within( 0.001).of(16)
     end
     it "method log_ceil" do
-      Rubyvis.log_ceil(-5,4).should be_within( 0.001).of(-4)
+      expect(Rubyvis.log_ceil(-5,4)).to be_within( 0.001).of(-4)
     end
     it "method dict" do
-      Rubyvis.dict(["one", "three", "seventeen"], lambda {|s| s.size}).should=={"one"=> 3, "three"=> 5, "seventeen"=> 9}
-      Rubyvis.dict(["one", "three", nil, "seventeen"], lambda {|s| s.size}).should=={"one"=> 3, "three"=> 5, "seventeen"=> 9}
+      expect(Rubyvis.dict(["one", "three", "seventeen"], lambda {|s| s.size})).to eq({"one"=> 3, "three"=> 5, "seventeen"=> 9})
+      expect(Rubyvis.dict(["one", "three", nil, "seventeen"], lambda {|s| s.size})).to eq({"one"=> 3, "three"=> 5, "seventeen"=> 9})
       
     end
   end