rubyvis 0.6.1 → 0.7.0

data/spec/scale_log_spec.rb

@@ -21,27 +21,27 @@ describe Rubyvis::Scale::Log 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)
         
       end
       it "nice() implemented equally" do
@@ -49,7 +49,7 @@ describe Rubyvis::Scale::Log 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
@@ -66,35 +66,35 @@ describe Rubyvis::Scale::Log do
     @y = Rubyvis.Scale.log(1, @h_dom).range(1,@h)
   end
   it "y should be a Scale" do
-    @y.should be_a(Rubyvis::Scale::Log)
+    expect(@y).to be_a(Rubyvis::Scale::Log)
   end
   it "should respond to domain" do
-    @y.domain.should==[1, 1000]
+    expect(@y.domain).to eq([1, 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==[1, 280]
+    expect(@y.range).to eq([1, 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(121.995)
+    expect(@y.scale(val)).to be_within( 0.001).of(121.995)
   end
   it "should returns correct invert" do
-    @y.invert(100).should be_within( 0.001).of(11.601)
-    @y.invert(200).should be_within( 0.001).of(137.970)
+    expect(@y.invert(100)).to be_within( 0.001).of(11.601)
+    expect(@y.invert(200)).to be_within( 0.001).of(137.970)
   end
   it "should returns correct ticks" do
     t=1,2,3,4,5,6,7,8,9,10,20,30,40,50,60,70,80,90,100,200,300,400,500,600,700,800,900,1000
-    @y.ticks.should==t
+    expect(@y.ticks).to eq(t)
   end
   it "should return :ArgumentError on domain that includes 0 or less" do
     h=280
@@ -104,17 +104,17 @@ describe Rubyvis::Scale::Log do
   end
   it "should returns correct ticks with subdivisions" do
     t=1,5,10,50,100,500,1000
-    @y.ticks(2).should==t
+    expect(@y.ticks(2)).to eq(t)
     t=1,2.5,5,7.5,10,25,50,75,100,250,500,750,1000
-    @y.ticks(4).should==t
+    expect(@y.ticks(4)).to eq(t)
     t=1,2,4,6,8,10,20,40,60,80,100,200,400,600,800,1000
-    @y.ticks(5).should==t
+    expect(@y.ticks(5)).to eq(t)
     t=1,10,100,1000
-    @y.ticks(1).should==t
+    expect(@y.ticks(1)).to eq(t)
   end
   it "should nice nicely" do
     @y.domain([0.20147987687960267, 0.996679553296417])
     @y.nice
-    @y.domain().should==[0.1,1]
+    expect(@y.domain()).to eq([0.1,1])
   end  
 end

data/spec/scale_ordinal_spec.rb

@@ -21,17 +21,17 @@ describe Rubyvis::Scale::Ordinal do
       it "domain() implemented equally" do
         @y.domain(@base[0])
         @rt.evaluate("y.domain(domain[0])")
-        @y.domain.should==@rt.evaluate("y.domain()").to_a
+        expect(@y.domain).to eq(@rt.evaluate("y.domain()").to_a)
         @y.domain(@base[0],@base[1])
         @rt.evaluate("y.domain(domain[0],domain[1])")
-        @y.domain.should==@rt.evaluate("y.domain()").to_a        
+        expect(@y.domain).to eq(@rt.evaluate("y.domain()").to_a)        
       end
       
     end
   end
   describe "on ruby domain" do 
     it "should be created as Javascript" do
-      lambda {y = Rubyvis.Scale.ordinal(%w{a b c}).range(%w{red blue black})}.should_not raise_exception
+      expect {y = Rubyvis.Scale.ordinal(%w{a b c}).range(%w{red blue black})}.not_to raise_exception
     end
     
     before do
@@ -40,45 +40,45 @@ describe Rubyvis::Scale::Ordinal do
       @y = Rubyvis.Scale.ordinal(@domain).range(@range)
     end
     it "y should be a Scale::Ordinal" do
-      @y.should be_a(Rubyvis::Scale::Ordinal)
+      expect(@y).to be_a(Rubyvis::Scale::Ordinal)
     end
     it "should respond to domain" do
-      @y.domain.should==%w{a b c}
+      expect(@y.domain).to eq(%w{a b c})
       @y.domain(%w{a})
-      @y.domain.should==%w{a}
+      expect(@y.domain).to eq(%w{a})
       @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==@range.map {|c| pv.color(c)}
+      expect(@y.range).to eq(@range.map {|c| pv.color(c)})
       @y.range('red')
-      @y.range.should==[pv.color('red')]
+      expect(@y.range).to eq([pv.color('red')])
       @y.range('black','white')
-      @y.range.should==[pv.color('black'), pv.color('white')]
+      expect(@y.range).to eq([pv.color('black'), pv.color('white')])
     end
     it "should returns correct scale with unknown values" do
-      @y.scale(1).should==pv.color('red')
-      @y.scale('x').should==pv.color('white')
-      @y.scale(9).should==pv.color('blue')
-      @y.scale(1).should==pv.color('red')      
+      expect(@y.scale(1)).to eq(pv.color('red'))
+      expect(@y.scale('x')).to eq(pv.color('white'))
+      expect(@y.scale(9)).to eq(pv.color('blue'))
+      expect(@y.scale(1)).to eq(pv.color('red'))      
     end
     it "should return the same using [] and scale()" do
       a=rand()
-      @y[a].should==@y.scale(a)
+      expect(@y[a]).to eq(@y.scale(a))
     end
     it "should returns correct scale with known values" do
-      @y.scale('a').should==pv.color('red')
-      @y.scale('b').should==pv.color('white')
-      @y.scale('c').should==pv.color('blue')
+      expect(@y.scale('a')).to eq(pv.color('red'))
+      expect(@y.scale('b')).to eq(pv.color('white'))
+      expect(@y.scale('c')).to eq(pv.color('blue'))
     end
     it "should return correct by" do
       @y = Rubyvis.Scale.ordinal(@domain).range(@range).by(lambda {|v| v.nombre})
       a=OpenStruct.new({:nombre=>'c'})
       b=OpenStruct.new({:nombre=>'b'})
       c=OpenStruct.new({:nombre=>'a'})
-      @y.call(a).should==pv.color('blue')
-      @y.call(b).should==pv.color('white')
-      @y.call(c).should==pv.color('red')
+      expect(@y.call(a)).to eq(pv.color('blue'))
+      expect(@y.call(b)).to eq(pv.color('white'))
+      expect(@y.call(c)).to eq(pv.color('red'))
       
     end
   end

data/spec/scale_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
 describe Rubyvis::Scale do
   it "should return a correct numeric interpolator" do
     i=Rubyvis::Scale.interpolator(0,20)
-    i[10].should==200
-    i[20].should==400
+    expect(i[10]).to eq(200)
+    expect(i[20]).to eq(400)
   end
 end

data/spec/spec_helper.rb

@@ -14,6 +14,7 @@ require 'rubyvis'
 require 'pp'
 require 'nokogiri'
 
+RSpec::Expectations.configuration.warn_about_potential_false_positives = false
 
 $PROTOVIS_DIR=File.dirname(__FILE__)+"/../vendor/protovis/src"
 module Rubyvis
@@ -95,11 +96,11 @@ end
 RSpec::Matchers.define :have_svg_attributes do |exp|
   match do |obs|
     exp.each {|k,v|
-      obs.attributes[k].should be_truthy
-      obs.attributes[k].value.should==v
+      expect(obs.attributes[k]).to be_truthy
+      expect(obs.attributes[k].value).to eq(v)
     }
   end
-  failure_message_for_should do |obs|
+  failure_message do |obs|
     "\n#{exp} attributes expected, but xml doesn't contains them \n#{obs.to_s}"
   end
 end
@@ -197,7 +198,7 @@ RSpec::Matchers.define :have_same_svg_elements do |exp|
     end
     correct
   end
-  failure_message_for_should do |obs|
+  failure_message do |obs|
     "#{@error[:type]}: #{@error[:exp].to_s} expected, but #{@error[:obs]} retrieved, on #{@error[:attr]} -> #{@error[:i]} : '#{@error[:exp_attr]}' <> '#{@error[:obs_attr]}'"
   end
   
@@ -242,7 +243,7 @@ RSpec::Matchers.define :have_path_data_close_to do |exp|
     }
     correct
   end
-  failure_message_for_should do |obs|
+  failure_message do |obs|
     obs_array=path_scan(obs.attributes["d"].value)
     exp_array=path_scan(exp)
     "\n#{obs_array} path should be equal to \n#{exp_array}"

data/spec/vector_spec.rb

@@ -6,31 +6,31 @@ describe Rubyvis::Vector do
     @v2=Rubyvis::Vector.new(@x2,@y2)
   end
   it "should return the same as Rubyvis.vector" do
-    Rubyvis.vector(@x1,@y1).should== @v1
+    expect(Rubyvis.vector(@x1,@y1)).to eq(@v1)
   end
   it "method perp" do
-    @v1.perp.should==Rubyvis::Vector.new(-@y1,@x1)
+    expect(@v1.perp).to eq(Rubyvis::Vector.new(-@y1,@x1))
   end
   it "method times" do
     times=rand(10)+1
-    @v1.times(times).should==Rubyvis::Vector.new(@x1*times,@y1*times)
+    expect(@v1.times(times)).to eq(Rubyvis::Vector.new(@x1*times,@y1*times))
   end
   it "method length" do
     l=Math.sqrt(@x1*@x1+@y1*@y1)
-    @v1.length.should eq l
+    expect(@v1.length).to eq l
   end
   it "method norm" do
     l=@v1.length
-    @v1.norm.should==@v1.times(1/l.to_f)
+    expect(@v1.norm).to eq(@v1.times(1/l.to_f))
   end
   it "method plus" do
-    @v1.plus(@v2).should==Rubyvis::Vector.new(@x1+@x2,@y1+@y2)
+    expect(@v1.plus(@v2)).to eq(Rubyvis::Vector.new(@x1+@x2,@y1+@y2))
   end
   it "method minus" do
-    @v1.minus(@v2).should==Rubyvis::Vector.new(@x1-@x2,@y1-@y2)
+    expect(@v1.minus(@v2)).to eq(Rubyvis::Vector.new(@x1-@x2,@y1-@y2))
   end
   it "method dot" do
-    @v1.dot(@v2).should==@x1*@x2+@y1*@y2
+    expect(@v1.dot(@v2)).to eq(@x1*@x2+@y1*@y2)
   end
 end
 

data/spec/wedge_spec.rb

@@ -3,10 +3,10 @@ describe Rubyvis::Wedge do
   include Rubyvis::GeneralSpec
   it "should have correct properties" do
     props=[:angle, :antialias, :bottom, :cursor, :data, :end_angle, :events, :fill_style,  :id, :inner_radius, :left, :line_width, :outer_radius, :reverse, :right, :start_angle, :stroke_style, :title, :top, :visible].inject({}) {|ac, v| ac[v]=true; ac}
-    Rubyvis::Wedge.properties.should==props
+    expect(Rubyvis::Wedge.properties).to eq(props)
   end
   it "Rubyvis.Wedge be the same as Rubyvis::Wedge" do
-    Rubyvis.Wedge.should eql Rubyvis::Wedge
+    expect(Rubyvis.Wedge).to eql Rubyvis::Wedge
   end
   it "should render equal to protovis 'wedge-anchor.html' test" do
     
@@ -32,7 +32,7 @@ text(lambda {anchors[self.index]})
 
     vis.render();
     pv_out=fixture_svg_read("wedge_anchor.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 equal to protovis 'wedge-donut.html' test" do
@@ -60,7 +60,7 @@ text(lambda {|d| "%0.2f" % d})
     @vis.render();
 
     @pv_out=fixture_svg_read("wedge_donut.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/web/build_site.rb

@@ -74,7 +74,7 @@ files.each do |f|
   # Read svg size
   width=350
   height=200
-  if File.exists? "examples/#{page.svg_file}"
+  if File.exist? "examples/#{page.svg_file}"
     File.open("examples/#{page.svg_file}","r") {|fp|
       header=fp.gets(">")
       if header=~/\sheight=['"]([^']+)['"]/ 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubyvis
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Claudio Bustos
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-07 00:00:00.000000000 Z
+date: 2019-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -159,6 +159,7 @@ files:
 - lib/rubyvis/sceneelement.rb
 - lib/rubyvis/transform.rb
 - lib/rubyvis/vector.rb
+- lib/rubyvis/version.rb
 - rubyvis.gemspec
 - spec/anchor_spec.rb
 - spec/area_spec.rb
@@ -272,8 +273,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Rubyvis