rubyvis 0.6.1 → 0.7.0

data/spec/layout_treemap_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
 describe Rubyvis::Layout::Treemap do
   include Rubyvis::LayoutSpec
   it "should have correct properties" do
-    props=[:antialias, :bottom, :canvas, :cursor, :data, :events, :fill_style, :height, :id, :left, :line_width, :links, :mode, :nodes, :order, :overflow, :padding_bottom, :padding_left, :padding_right, :padding_top, :reverse, :right, :round, :stroke_style, :title, :top, :transform, :visible, :width].inject({}) {|ac, v| ac[v]=true; ac}
+    props=[:antialias, :bottom, :canvas, :cursor, :data, :events, :fill_style, :height, :id, :left, :line_width, :links, :mode, :nodes, :order, :overflow, :padding_bottom, :padding_left, :padding_right, :padding_top, :reverse, :right, :round, :stroke_style, :title, :top, :transform, :visible, :view_box, :width].inject({}) {|ac, v| ac[v]=true; ac}
     Rubyvis::Layout::Treemap.properties.should==props 
   end
   describe "rendered" do
@@ -35,7 +35,7 @@ describe Rubyvis::Layout::Treemap do
     end
     
     it "should render equal to protovis version " do 
-      @vis.to_svg.should have_same_svg_elements(@pv_out)
+      expect(@vis.to_svg).to have_same_svg_elements(@pv_out)
     end
   end
 end

data/spec/line_spec.rb

@@ -3,7 +3,7 @@ describe Rubyvis::Line do
   include Rubyvis::GeneralSpec
   it "should have correct properties" do
     props=[:antialias, :bottom, :cursor, :data, :eccentricity, :events, :fill_style, :id, :interpolate, :left, :line_join, :line_width, :reverse, :right, :segmented, :stroke_dasharray, :stroke_style, :tension, :title, :top, :visible].inject({}) {|ac, v| ac[v]=true; ac}
-    Rubyvis::Line.properties.should==props
+    expect(Rubyvis::Line.properties).to eq(props)
   end
   it "should render correctly 'line_interpolation.html' example" do
     data = pv.range(0, 10, 0.2).map {|x|
@@ -54,7 +54,7 @@ top(5)
     end
     vis.render()
     pv_out=fixture_svg_read("line_interpolation.svg")
-    vis.to_svg.should have_same_svg_elements(pv_out)
+    expect(vis.to_svg).to have_same_svg_elements(pv_out)
   end
   it "should render correctly 'line_interpolation_segmented.html' example" do
     data = pv.range(0, 10, 0.2).map {|x|
@@ -106,7 +106,7 @@ top(5)
     end
     vis.render()
     pv_out=fixture_svg_read("line_interpolation_segmented.svg")
-    vis.to_svg.should have_same_svg_elements(pv_out)
+    expect(vis.to_svg).to have_same_svg_elements(pv_out)
   end
   it "SvgScene.path_join should return correct value" do
     s0=OpenStruct.new({:left=>1,:top=>2,:visible=>true, :line_width=>2.5})
@@ -116,9 +116,9 @@ top(5)
     # obj.attributes["d"].value
     exp_data="M2.1161165235168156,4.883883476483184L4.116116523516816,6.883883476483184 5.883883476483184,5.116116523516816 3.8838834764831844,3.1161165235168156"
     obs=""
-    obs.stub(:attributes).and_return({'d'=>OpenStruct.new({:value=>Rubyvis::SvgScene.path_join(s0,s1,s2,s3)})})
+    allow(obs).to receive(:attributes).and_return({'d'=>OpenStruct.new({:value=>Rubyvis::SvgScene.path_join(s0,s1,s2,s3)})})
     
-    obs.should have_path_data_close_to exp_data
+    expect(obs).to have_path_data_close_to exp_data
     
     s0=OpenStruct.new({:left=>1.5,:top=>2,:visible=>true, :line_width=>3})
     s1=OpenStruct.new({:left=>3.5,:top=>4,:visible=>true, :line_width=>3.5})
@@ -126,8 +126,8 @@ top(5)
     s3=OpenStruct.new({:left=>7.5,:top=>8,:visible=>true, :line_width=>4.5})
     exp_data="M2.2625631329235425,5.2374368670764575L4.2625631329235425,7.2374368670764575 6.7374368670764575,4.7625631329235425 4.7374368670764575,2.7625631329235425"
     obs=""
-    obs.stub(:attributes).and_return({'d'=>OpenStruct.new({:value=>Rubyvis::SvgScene.path_join(s0,s1,s2,s3)})})
-    obs.should have_path_data_close_to exp_data
+    allow(obs).to receive(:attributes).and_return({'d'=>OpenStruct.new({:value=>Rubyvis::SvgScene.path_join(s0,s1,s2,s3)})})
+    expect(obs).to have_path_data_close_to exp_data
   
   end
   context "rendered" do
@@ -143,26 +143,26 @@ top(5)
     it "should return correct default (linear) path" do
       @vis.render
       doc=Nokogiri::XML(@vis.to_svg)
-      doc.at_xpath("//xmlns:path").should have_path_data_close_to  "M0 180L20 160L40 180L60 120L80 180L100 100L100 200L80 200L60 200L40 200L20 200L0 200Z"
+      expect(doc.at_xpath("//xmlns:path")).to have_path_data_close_to  "M0 180L20 160L40 180L60 120L80 180L100 100L100 200L80 200L60 200L40 200L20 200L0 200Z"
     end
     it "should return correct path for interpolate=step-before" do
       @area.interpolate('step-before')
       @vis.render
       doc=Nokogiri::XML(@vis.to_svg)
-      doc.at_xpath("//xmlns:path").should have_path_data_close_to "M0,180V160H20V180H40V120H60V180H80V100H100"
+      expect(doc.at_xpath("//xmlns:path")).to have_path_data_close_to "M0,180V160H20V180H40V120H60V180H80V100H100"
     end
     it "should return correct path for interpolate=step-after" do
       @area.interpolate('step-after')
       @vis.render
       doc=Nokogiri::XML(@vis.to_svg)
-      doc.at_xpath("//xmlns:path").should have_path_data_close_to "M0,180H20V160H40V180H60V120H80V180H100V100"
+      expect(doc.at_xpath("//xmlns:path")).to have_path_data_close_to "M0,180H20V160H40V180H60V120H80V180H100V100"
     end
     
     it "should return correct path for interpolate=polar" do
       @area.interpolate('polar')
       @vis.render
       doc=Nokogiri::XML(@vis.to_svg)
-      doc.at_xpath("//xmlns:path").should have_path_data_close_to "M0,180A14.142135623730951,14.142135623730951 0 0,1 20,160A14.142135623730951,14.142135623730951 0 0,1 40,180A31.622776601683793,31.622776601683793 0 0,1 60,120A31.622776601683793,31.622776601683793 0 0,1 80,180A41.23105625617661,41.23105625617661 0 0,1 100,100"
+      expect(doc.at_xpath("//xmlns:path")).to have_path_data_close_to "M0,180A14.142135623730951,14.142135623730951 0 0,1 20,160A14.142135623730951,14.142135623730951 0 0,1 40,180A31.622776601683793,31.622776601683793 0 0,1 60,120A31.622776601683793,31.622776601683793 0 0,1 80,180A41.23105625617661,41.23105625617661 0 0,1 100,100"
     end
     
     
@@ -171,19 +171,19 @@ top(5)
       @area.interpolate('polar-reverse')
       @vis.render
       doc=Nokogiri::XML(@vis.to_svg)
-      doc.at_xpath("//xmlns:path").should have_path_data_close_to "M0,180A14.142135623730951,14.142135623730951 0 0,0 20,160A14.142135623730951,14.142135623730951 0 0,0 40,180A31.622776601683793,31.622776601683793 0 0,0 60,120A31.622776601683793,31.622776601683793 0 0,0 80,180A41.23105625617661,41.23105625617661 0 0,0 100,100"
+      expect(doc.at_xpath("//xmlns:path")).to have_path_data_close_to "M0,180A14.142135623730951,14.142135623730951 0 0,0 20,160A14.142135623730951,14.142135623730951 0 0,0 40,180A31.622776601683793,31.622776601683793 0 0,0 60,120A31.622776601683793,31.622776601683793 0 0,0 80,180A41.23105625617661,41.23105625617661 0 0,0 100,100"
     end
     it "should return correct path for interpolate=basis" do
       @area.interpolate('basis')
       @vis.render
       doc=Nokogiri::XML(@vis.to_svg)
-      doc.at_xpath("//xmlns:path").should have_path_data_close_to "M0 180C0 180 0 180 3.333333333333333 176.66666666666666C6.666666666666666 173.33333333333331 13.333333333333332 166.66666666666666 20 166.66666666666666C26.666666666666664 166.66666666666666 33.33333333333333 173.33333333333331 40 166.66666666666666C46.666666666666664 160 53.33333333333333 140 60 140C66.66666666666666 140 73.33333333333333 160 80 156.66666666666666C86.66666666666666 153.33333333333331 93.33333333333331 126.66666666666666 96.66666666666666 113.33333333333331C99.99999999999999 99.99999999999999 99.99999999999999 99.99999999999999 99.99999999999997 99.99999999999997"
+      expect(doc.at_xpath("//xmlns:path")).to have_path_data_close_to "M0 180C0 180 0 180 3.333333333333333 176.66666666666666C6.666666666666666 173.33333333333331 13.333333333333332 166.66666666666666 20 166.66666666666666C26.666666666666664 166.66666666666666 33.33333333333333 173.33333333333331 40 166.66666666666666C46.666666666666664 160 53.33333333333333 140 60 140C66.66666666666666 140 73.33333333333333 160 80 156.66666666666666C86.66666666666666 153.33333333333331 93.33333333333331 126.66666666666666 96.66666666666666 113.33333333333331C99.99999999999999 99.99999999999999 99.99999999999999 99.99999999999999 99.99999999999997 99.99999999999997"
     end   
     it "should return correct path for interpolate=cardinal" do 
       @area.interpolate('cardinal')
       @vis.render
       doc=Nokogiri::XML(@vis.to_svg)
-      doc.at_xpath("//xmlns:path").should have_path_data_close_to "M0 180Q16 160 20 160C26 160 34 186 40 180S54 120 60 120S74 183 80 180Q84 178 100 100"
+      expect(doc.at_xpath("//xmlns:path")).to have_path_data_close_to "M0 180Q16 160 20 160C26 160 34 186 40 180S54 120 60 120S74 183 80 180Q84 178 100 100"
     end
   end
 end

data/spec/mark_spec.rb

@@ -2,19 +2,19 @@ require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
 describe Rubyvis::Mark do
   it "should have correct properties" do
     props=[:antialias, :bottom, :cursor, :data, :events, :id, :left, :reverse, :right, :title, :top, :visible].inject({}) {|ac, v| ac[v]=true; ac}
-    Rubyvis::Mark.properties.should==props
+    expect(Rubyvis::Mark.properties).to eq(props)
   end
   it "should return correct defaults" do
     props=Rubyvis::Mark.defaults._properties.sort {|a,b| a.name.to_s<=>b.name.to_s}
-    props[1].name.should==:data
-    props[1].value.should be_instance_of Proc
-    props[3].name.should==:visible
-    props[0].name.should==:antialias
-    props[2].name.should==:events
+    expect(props[1].name).to eq(:data)
+    expect(props[1].value).to be_instance_of Proc
+    expect(props[3].name).to eq(:visible)
+    expect(props[0].name).to eq(:antialias)
+    expect(props[2].name).to eq(:events)
   end
   it "should have 'mark' as type" do
     m=Rubyvis::Mark.new
-    m.type.should eql "mark"
+    expect(m.type).to eql "mark"
   end
   
 end

data/spec/nest_spec.rb

@@ -12,13 +12,13 @@ describe Rubyvis::Nest do
     nest = pv.nest(@data).key(lambda {|d| d[:year]}).key(lambda {|d|  d[:city]}).map()
     
     expected={2010=>{"London"=>[{:year=>2010, :city=>"London", :value=>1}], "France"=>[{:year=>2010, :city=>"France", :value=>2}]}, 2011=>{"London"=>[{:year=>2011, :city=>"London", :value=>5}], "France"=>[{:year=>2011, :city=>"France", :value=>6}]}}
-    nest.should==expected
+    expect(nest).to eq(expected)
 
   end
   it "should generate correct rollup" do
     nest = pv.nest(@data).key(lambda {|d| d[:year]}).key(lambda {|d|  d[:city]}).rollup(lambda {|d| d.map{|dd| dd[:value]}})
     expected={2010=>{"London"=>[1], "France"=>[2]}, 2011=>{"London"=>[5], "France"=>[6]}}
-    nest.should==expected
+    expect(nest).to eq(expected)
     
   end
   it "should generate correct entries" do
@@ -40,7 +40,7 @@ describe Rubyvis::Nest do
       ])
     ]
     
-    nest.should==expected
+    expect(nest).to eq(expected)
       
   end
   

data/spec/panel_spec.rb

@@ -3,33 +3,33 @@ describe Rubyvis::Panel do
   before do
     @h=200
     @w=200
-    @vis = Rubyvis.Panel.new.width(@w).height(@h)
+    @vis = Rubyvis.Panel.new.width(@w).height(@h).view_box("0 0 #{@w} #{@h}")
   end
   it "should have correct properties" do
-    props=[:antialias, :bottom, :canvas, :cursor, :data, :events, :fill_style, :height, :id, :left, :line_width, :overflow, :reverse, :right, :stroke_style, :title, :top, :transform, :visible, :width].inject({}) {|ac, v| ac[v]=true; ac}
+    props=[:antialias, :bottom, :canvas, :cursor, :data, :events, :fill_style, :height, :id, :left, :line_width, :overflow, :reverse, :right, :stroke_style, :title, :top, :transform, :view_box, :visible, :width].inject({}) {|ac, v| ac[v]=true; ac}
     Rubyvis::Panel.properties.should==props
   end
   it "should have correct defaults" do
-    Rubyvis::Panel.defaults._properties.size.should==2
+    expect(Rubyvis::Panel.defaults._properties.size).to eq(2)
   end
   it "should build propertly" do
-    lambda {@vis.render}.should_not raise_exception
+    expect {@vis.render}.not_to raise_exception
   end
   it "should return valid svg" do   
     @vis.render
     doc=Nokogiri::XML(@vis.to_svg)
-    doc.at_xpath("//xmlns:svg").should have_svg_attributes({"font-size"=>"10px", "font-family"=>"sans-serif", "fill"=>"none", "stroke"=>"none", "stroke-width"=>"1.5", "width"=>"200.0", "height"=>"200.0"})
+    doc.at_xpath("//xmlns:svg").should have_svg_attributes({"font-size"=>"10px", "font-family"=>"sans-serif", "fill"=>"none", "stroke"=>"none", "stroke-width"=>"1.5", "width"=>"200.0", "height"=>"200.0", "viewBox" => "0 0 200 200"})
   end
   it "should allow multiple panel definitions" do
-    vis2 = Rubyvis.Panel.new.width(@w+100).height(@h+100)
+    vis2 = Rubyvis.Panel.new.width(@w+100).height(@h+100).view_box("0 0 #{@w+100} #{@h+100}")
     @vis.render
     vis2.render
     doc1=Nokogiri::XML(@vis.to_svg)
     doc2=Nokogiri::XML(vis2.to_svg)
 
-    doc1.at_xpath("//xmlns:svg").should have_svg_attributes({"font-size"=>"10px", "font-family"=>"sans-serif", "fill"=>"none", "stroke"=>"none", "stroke-width"=>"1.5", "width"=>"200.0", "height"=>"200.0"})
-    
-    doc2.at_xpath("//xmlns:svg").should have_svg_attributes({"font-size"=>"10px", "font-family"=>"sans-serif", "fill"=>"none", "stroke"=>"none", "stroke-width"=>"1.5", "width"=>"300.0", "height"=>"300.0"})
+    doc1.at_xpath("//xmlns:svg").should have_svg_attributes({"font-size"=>"10px", "font-family"=>"sans-serif", "fill"=>"none", "stroke"=>"none", "stroke-width"=>"1.5", "width"=>"200.0", "height"=>"200.0", "viewBox" => "0 0 200 200"})
     
+    doc2.at_xpath("//xmlns:svg").should have_svg_attributes({"font-size"=>"10px", "font-family"=>"sans-serif", "fill"=>"none", "stroke"=>"none", "stroke-width"=>"1.5", "width"=>"300.0", "height"=>"300.0", "viewBox" => "0 0 300 300"})
+
   end
-end
+end

data/spec/readme_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
 describe "Rubyvis Readme" do
   it "should work with RBP API" do
     vis=nil
-    lambda {
+    expect {
     vis = Rubyvis::Panel.new do 
       width 150
       height 150
@@ -15,12 +15,12 @@ describe "Rubyvis Readme" do
       end
     end
     
-    vis.render}.should_not raise_exception
-    vis.to_svg.size.should>0
+    vis.render}.not_to raise_exception
+    expect(vis.to_svg.size).to be > 0
   end
   it "should work with Protovis API" do
     vis=nil
-    lambda {
+    expect {
     vis = Rubyvis::Panel.new.width(150).height(150);
     
     vis.add(pv.Bar).
@@ -31,8 +31,8 @@ describe "Rubyvis Readme" do
       left(lambda {self.index * 25});
     
     vis.render
-    }.should_not raise_exception
-    vis.to_svg.size.should>0
+    }.not_to raise_exception
+    expect(vis.to_svg.size).to be > 0
   end
   
 end

data/spec/ruby_api_spec.rb

@@ -5,12 +5,12 @@ shared_examples_for "Ruby API for Rubyvis" do
     @w=200
   end
   it "should create a Panel with a block" do
-    lambda {@vis = Rubyvis.Panel.new {
+    expect {@vis = Rubyvis.Panel.new {
       width @w
       height @h
     }
-    }.should_not raise_exception
-    @vis._properties.size.should==2
+    }.not_to raise_exception
+    expect(@vis._properties.size).to eq(2)
   end
   it "should create a Bar with new method" do
     vis1=Rubyvis.Panel.new.width(@w).height(@h)
@@ -41,7 +41,7 @@ shared_examples_for "Ruby API for Rubyvis" do
     }
     vis2.render
     svg2=vis2.to_svg
-    svg1.should==svg2
+    expect(svg1).to eq(svg2)
     
   end
 end

data/spec/rule_spec.rb

@@ -3,10 +3,10 @@ describe Rubyvis::Rule do
   include Rubyvis::GeneralSpec
   it "should have correct properties" do
     props=[:antialias, :bottom, :cursor, :data, :events, :height,  :id, :left, :line_width, :reverse, :right, :stroke_style, :stroke_dasharray, :title, :top, :visible, :width].inject({}) {|ac, v| ac[v]=true; ac}
-    Rubyvis::Rule.properties.should==props
+    expect(Rubyvis::Rule.properties).to eq(props)
   end
   it "Rubyvis.Rule be the same as Rubyvis::Rule" do
-    Rubyvis.Rule.should eql Rubyvis::Rule
+    expect(Rubyvis.Rule).to eql Rubyvis::Rule
   end
   it "should render equal to protovis 'rule-anchor.html' test" do
     vis = Rubyvis::Panel.new().
@@ -27,7 +27,7 @@ describe Rubyvis::Rule do
     
     vis.render();
     pv_out=fixture_svg_read("rule_anchor.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/scale_linear_datetime_spec.rb

@@ -17,51 +17,51 @@ describe "Rubyvis::Scale::Linear with dates" do
   end
   it "should not crash on :week_day precision (bug #15)" do
     ct=Time.utc(2012,03,19,10,10,10)
-    @y.mock_ticks_floor(ct,:week_day).should==Time.utc(2012,03,18,10,10,10)
+    expect(@y.mock_ticks_floor(ct,:week_day)).to eq(Time.utc(2012,03,18,10,10,10))
   end
   it "y should be a Scale" do
-    @y.should be_a(Rubyvis::Scale::Linear)
+    expect(@y).to be_a(Rubyvis::Scale::Linear)
   end
   it "should respond to domain" do
-    @y.domain.should==[@bd, @ed]
+    expect(@y.domain).to eq([@bd, @ed])
     @y.domain(@bd)
-    @y.domain.should==[@bd,@bd]
+    expect(@y.domain).to eq([@bd,@bd])
     @y.domain(@bd,@ed,@ed+1)
-    @y.domain.should==[@bd,@ed,@ed+1]
+    expect(@y.domain).to eq([@bd,@ed,@ed+1])
   end
   it "should respond to range" do
-    @y.range.should==[0, @h]
+    expect(@y.range).to eq([0, @h])
     @y.range(1)
-    @y.range.should==[1,1]
+    expect(@y.range).to eq([1,1])
     @y.range(1,100,300)
-    @y.range.should==[1,100,300]
+    expect(@y.range).to eq([1,100,300])
   end
   it "should returns correct scale" do
-    @y.scale(@bd).should==0
-    @y.scale(@ed).should==@h
-    @y[@ed].should==@h
+    expect(@y.scale(@bd)).to eq(0)
+    expect(@y.scale(@ed)).to eq(@h)
+    expect(@y[@ed]).to eq(@h)
     val= (@ed.to_f+@bd.to_f) / 2.0
-    @y.scale(val).should be_within( 0.001).of(@h / 2.0)
+    expect(@y.scale(val)).to be_within( 0.001).of(@h / 2.0)
   end
   it "should returns correct invert" do
-    @y.invert(0).should==@bd
-    @y.invert(@h).should==@ed
+    expect(@y.invert(0)).to eq(@bd)
+    expect(@y.invert(@h)).to eq(@ed)
   end
   it "should returns correct ticks" do
-    @y.ticks.size.should==5
-    @y.ticks(5).size.should==5
-    @y.ticks(5)[0].should be_instance_of Time
+    expect(@y.ticks.size).to eq(5)
+    expect(@y.ticks(5).size).to eq(5)
+    expect(@y.ticks(5)[0]).to be_instance_of Time
     
     #p @y.ticks
   end
   it "should return correct tick_floor" do
     ct=Time.utc(2012,04,05,10,10,10)
-    @y.mock_ticks_floor(ct,:month).should==Time.utc(2012,01,05,10,10,10)
-    @y.mock_ticks_floor(ct,:month_day).should==Time.utc(2012,04,01,10,10,10)
-    @y.mock_ticks_floor(ct,:week_day).should==Time.utc(2012,04,01,10,10,10)
-    @y.mock_ticks_floor(ct,:hour).should==Time.utc(2012,04,05,00,10,10)
-    @y.mock_ticks_floor(ct,:minute).should==Time.utc(2012,04,05,10,00,10)
-    @y.mock_ticks_floor(ct,:second).should==Time.utc(2012,04,05,10,10,00)
+    expect(@y.mock_ticks_floor(ct,:month)).to eq(Time.utc(2012,01,05,10,10,10))
+    expect(@y.mock_ticks_floor(ct,:month_day)).to eq(Time.utc(2012,04,01,10,10,10))
+    expect(@y.mock_ticks_floor(ct,:week_day)).to eq(Time.utc(2012,04,01,10,10,10))
+    expect(@y.mock_ticks_floor(ct,:hour)).to eq(Time.utc(2012,04,05,00,10,10))
+    expect(@y.mock_ticks_floor(ct,:minute)).to eq(Time.utc(2012,04,05,10,00,10))
+    expect(@y.mock_ticks_floor(ct,:second)).to eq(Time.utc(2012,04,05,10,10,00))
     
   end 
   

data/spec/scale_linear_spec.rb

@@ -21,30 +21,30 @@ describe Rubyvis::Scale::Linear do
       it "domain() implemented equally" do
         @y.domain(@v1)
         @rt.evaluate("y.domain(v1)")
-        @y.domain.should==@rt.evaluate("y.domain()").to_a
+        expect(@y.domain).to eq(@rt.evaluate("y.domain()").to_a)
         @y.domain(@v1,@v2,@v3)
         @rt.evaluate("y.domain(v1,v2,v3)")
-        @y.domain.should==@rt.evaluate("y.domain()").to_a        
+        expect(@y.domain).to eq(@rt.evaluate("y.domain()").to_a)        
       end
       it "scale() implemented equally for complex domain" do
         @y.domain(@v1,@v2,@v3)
         @rt.evaluate("y.domain(v1,v2,v3)")
-        @y.scale(@v1+1).should==@rt.evaluate("y(v1+1)")
-        @y.scale(@v2+1).should==@rt.evaluate("y(v2+1)")
-        @y.scale(@v3+1).should==@rt.evaluate("y(v3+1)")
+        expect(@y.scale(@v1+1)).to eq(@rt.evaluate("y(v1+1)"))
+        expect(@y.scale(@v2+1)).to eq(@rt.evaluate("y(v2+1)"))
+        expect(@y.scale(@v3+1)).to eq(@rt.evaluate("y(v3+1)"))
       end
       it "invert() implemented equally" do
         @y.domain(@v1,@v2,@v3)
         @rt.evaluate("y.domain(v1,v2,v3)")
-        @y.invert(@v1+1).should==@rt.evaluate("y.invert(v1+1)")
-        @y.invert(@v2+1).should==@rt.evaluate("y.invert(v2+1)")
-        @y.invert(@v3+1).should==@rt.evaluate("y.invert(v3+1)")
+        expect(@y.invert(@v1+1)).to eq(@rt.evaluate("y.invert(v1+1)"))
+        expect(@y.invert(@v2+1)).to eq(@rt.evaluate("y.invert(v2+1)"))
+        expect(@y.invert(@v3+1)).to eq(@rt.evaluate("y.invert(v3+1)"))
       end
       it "ticks() implemented equally for numbers" do
-        @y.ticks.should==@rt.evaluate("y.ticks()").to_a
+        expect(@y.ticks).to eq(@rt.evaluate("y.ticks()").to_a)
         (5..20).each {|i|
           @rt[:i]=i
-          @y.ticks(i).should==@rt.evaluate("y.ticks(i)").to_a
+          expect(@y.ticks(i)).to eq(@rt.evaluate("y.ticks(i)").to_a)
         }
       end
       it "nice() implemented equally" do
@@ -52,7 +52,7 @@ describe Rubyvis::Scale::Linear do
         @rt.evaluate("y.domain(v1,v2)")
         @y.nice
         @rt.evaluate("y.nice()")
-        @y.domain.should==@rt.evaluate("y.domain()").to_a
+        expect(@y.domain).to eq(@rt.evaluate("y.domain()").to_a)
       end
    
     end
@@ -69,27 +69,27 @@ describe Rubyvis::Scale::Linear do
     @y = Rubyvis.Scale.linear(0, @h_dom).range(0,@h)
   end
   it "y should be a Scale" do
-    @y.should be_a(Rubyvis::Scale::Linear)
+    expect(@y).to be_a(Rubyvis::Scale::Linear)
   end
   it "should respond to domain" do
-    @y.domain.should==[0, 1000]
+    expect(@y.domain).to eq([0, 1000])
     @y.domain(1)
-    @y.domain.should==[1,1]
+    expect(@y.domain).to eq([1,1])
     @y.domain(1,100,300)
-    @y.domain.should==[1,100,300]
+    expect(@y.domain).to eq([1,100,300])
   end
   it "should respond to range" do
-    @y.range.should==[0, 280]
+    expect(@y.range).to eq([0, 280])
     @y.range(1)
-    @y.range.should==[1,1]
+    expect(@y.range).to eq([1,1])
     @y.range(1,100,300)
-    @y.range.should==[1,100,300]
+    expect(@y.range).to eq([1,100,300])
   end
   it "should returns correct scale" do
-    @y.scale(@h_dom).should==280
-    @y[@h_dom].should==280
+    expect(@y.scale(@h_dom)).to eq(280)
+    expect(@y[@h_dom]).to eq(280)
     val=20
-    @y.scale(val).should be_within( 0.001).of(val.quo(@h_dom)*@h.to_f)
+    expect(@y.scale(val)).to be_within( 0.001).of(val.quo(@h_dom)*@h.to_f)
   end
   it "should return correct scale when values are extracted from data " do
     data = pv.range(0, 10, 0.1).map {|x| OpenStruct.new({:x=> x, :y=> Math.sin(x) + 2+rand()}) }
@@ -97,44 +97,44 @@ describe Rubyvis::Scale::Linear do
     h = 200
     x = pv.Scale.linear(data, lambda {|d| d.x}).range(0, w)
     y = pv.Scale.linear(data, lambda {|d| d.y}).range(0, h)
-    lambda {y.scale 0.5}.should_not raise_error
+    expect {y.scale 0.5}.not_to raise_error
   end
   it "should returns correct invert" do
-    @y.invert(100).should be_within( 0.001).of(357.1428)
-    @y.invert(200).should be_within( 0.001).of(714.2857)
+    expect(@y.invert(100)).to be_within( 0.001).of(357.1428)
+    expect(@y.invert(200)).to be_within( 0.001).of(714.2857)
   end
   it "should returns correct ticks" do
-    @y.ticks.should==[0,100,200,300,400,500,600,700,800,900,1000]
-    @y.ticks(13).should==[0,100,200,300,400,500,600,700,800,900,1000]
-    @y.ticks(5).should==[0,200,400,600,800,1000]
+    expect(@y.ticks).to eq([0,100,200,300,400,500,600,700,800,900,1000])
+    expect(@y.ticks(13)).to eq([0,100,200,300,400,500,600,700,800,900,1000])
+    expect(@y.ticks(5)).to eq([0,200,400,600,800,1000])
   end
   it "should return correct tick when domain is a scalar" do
-    @y.domain(1,1,1).ticks.should==[1]
+    expect(@y.domain(1,1,1).ticks).to eq([1])
   end
 
   it "should nice nicely" do
     @y.domain([0.20147987687960267, 0.996679553296417])
     @y.nice
-    @y.domain().should==[0.2,1]
+    expect(@y.domain()).to eq([0.2,1])
   end
   
   it "should returns correct tick_format" do
-    @y.tick_format.should be_instance_of Proc
-    @y.tick_format.call( 2).should=='2'
-    @y.tick_format.call(2.0).should=='2'
-    @y.tick_format.call(2.1).should=='2.1'
-    @y.tick_format.call("a").should==''
+    expect(@y.tick_format).to be_instance_of Proc
+    expect(@y.tick_format.call( 2)).to eq('2')
+    expect(@y.tick_format.call(2.0)).to eq('2')
+    expect(@y.tick_format.call(2.1)).to eq('2.1')
+    expect(@y.tick_format.call("a")).to eq('')
   end
   it "should return correct tick_format for small numbers" do
     @y.domain(0.00001,0.0001)
     @y.range(0.000001,0.0001)
-    @y.ticks.should==[1.quo(100000), 1.quo(50000), 3.quo(100000), 1.quo(25000), 1.quo(20000), 3.quo(50000), 7.quo(100000), 1.quo(12500), 9.quo(100000), 1.quo(10000)]
-    @y.tick_format.call(0.2).should=='0.20000'
+    expect(@y.ticks).to eq([1.quo(100000), 1.quo(50000), 3.quo(100000), 1.quo(25000), 1.quo(20000), 3.quo(50000), 7.quo(100000), 1.quo(12500), 9.quo(100000), 1.quo(10000)])
+    expect(@y.tick_format.call(0.2)).to eq('0.20000')
   end
   it "should return correct by" do
     by=@y.by(lambda {|v| v.value})
     a=OpenStruct.new({:value=>rand})
-    by.call(a).should==@y[a.value]
+    expect(by.call(a)).to eq(@y[a.value])
   end
   
 end