plotrb 0.0.1

data/spec/plotrb/data_spec.rb

@@ -0,0 +1,258 @@
+require_relative '../spec_helper'
+
+describe 'Data' do
+
+  subject { ::Plotrb::Data.new }
+
+  describe '#name' do
+
+    it 'sets name if valid' do
+      subject.name('foo')
+      subject.name.should == 'foo'
+    end
+
+    it 'raises error if name is nil' do
+      expect { subject.send(:process_name) }.to raise_error(ArgumentError)
+    end
+
+    it 'raises error if name in blank' do
+      subject.name = '    '
+      expect { subject.send(:process_name) }.to raise_error(ArgumentError)
+    end
+
+    it 'raises error if name is not unique' do
+      ::Plotrb::Kernel.stub(:duplicate_data?).and_return(false)
+      expect { subject.send(:process_name) }.to raise_error(ArgumentError)
+    end
+
+  end
+
+  describe '#format' do
+
+    it 'sets format as a new Format instance' do
+      ::Plotrb::Data::Format.should_receive(:new).with(:foo)
+      subject.format(:foo)
+    end
+
+  end
+
+  describe '#values' do
+
+    it 'sets values if valid JSON is given' do
+      subject.values('{"foo":1, "bar":{"baz":2}}')
+      subject.values.should == '{"foo":1, "bar":{"baz":2}}'
+    end
+
+    it 'sets values if array is given' do
+      subject.values([1,2,3,4])
+      subject.values.should match_array([1,2,3,4])
+    end
+
+    it 'sets values if hash is given' do
+      subject.values(foo: 1, bar: 2)
+      subject.values.should == {foo: 1, bar: 2}
+    end
+
+    it 'raises error if values are invalid JSON' do
+      subject.values("{foo:1, 'bar':}")
+      expect { subject.send(:process_values) }.to raise_error ArgumentError
+    end
+
+  end
+
+  describe '#source' do
+
+    it 'sets source if valid' do
+      subject.source('foo')
+      subject.source.should == 'foo'
+    end
+
+    it 'raises error if source does not exist' do
+      ::Plotrb::Kernel.stub(:find_data).and_return(false)
+      subject.source('foo')
+      expect { subject.send(:process_source) }.to raise_error ArgumentError
+    end
+
+    it 'gets the name of the existing data object' do
+      foo = ::Plotrb::Data.new.name('foo')
+      subject.source(foo)
+      subject.send(:process_source)
+      subject.source.should == 'foo'
+    end
+
+  end
+
+  describe '#url' do
+
+    it 'sets valid absolute url' do
+      subject.url('http://foo.com/bar')
+      subject.url.should == 'http://foo.com/bar'
+    end
+
+    it 'sets valid relative url' do
+      subject.url('data/bar.json')
+      subject.url.should == 'data/bar.json'
+    end
+
+    it 'raises error when url is invalid' do
+      subject.url('http://foo/#-|r|$@')
+      expect { subject.send(:process_url) }.to raise_error ArgumentError
+    end
+
+  end
+
+  describe '#file' do
+
+    it 'sets url if file exists'
+
+    it 'raises error is file does not exist'
+
+  end
+
+  describe '#transform' do
+
+    class Bar; end
+
+    let(:foo) { ::Plotrb::Transform.new(:array) }
+    let(:bar) { Bar.new }
+
+    it 'sets transform if a transform object is given' do
+      subject.transform(foo)
+      subject.transform.should == [foo]
+    end
+
+    it 'sets transform if multiple transforms are given' do
+      subject.transform(foo, foo)
+      subject.transform.should == [foo, foo]
+    end
+
+    it 'raises error if array contains non-transforms' do
+      subject.transform(foo, bar)
+      expect { subject.send(:process_transform) }.to raise_error ArgumentError
+    end
+
+  end
+
+  describe '#method_missing' do
+
+    it 'sets format via as_foo' do
+      subject.should_receive(:format).with(:csv)
+      subject.as_csv
+    end
+
+  end
+
+  describe 'Format' do
+
+    it 'raises error if format type is not recognized' do
+      expect { ::Plotrb::Data::Format.new(:foo) }.to raise_error ArgumentError
+    end
+
+    context 'json' do
+
+      subject { ::Plotrb::Data::Format.new(:json) }
+
+      it 'has parse and property attributes' do
+        subject.attributes.should match_array([:type, :parse, :property])
+      end
+
+      describe '#parse' do
+
+        it 'sets parse if valid hash is given' do
+          subject.parse('foo' => :number, 'bar' => :date)
+          subject.parse.should == {'foo' => :number, 'bar' => :date }
+        end
+
+        it 'raises error if parse object has unknown data type' do
+          subject.parse('foo' => :bar)
+          expect { subject.send(:process_parse) }.to raise_error ArgumentError
+        end
+
+      end
+
+      describe '#as_date' do
+
+        it 'parses the field as date' do
+          subject.as_date('foo')
+          subject.parse['foo'].should == :date
+        end
+
+        it 'allows setting multiple fields' do
+          subject.as_date('foo', 'bar')
+          subject.parse.should == {'foo' => :date, 'bar' => :date}
+        end
+
+      end
+
+      describe '#as_boolean' do
+
+        it 'parses the field as boolean' do
+          subject.as_boolean('foo')
+          subject.parse['foo'].should == :boolean
+        end
+
+      end
+
+      describe '#as_number' do
+
+        it 'parses the field as number' do
+          subject.as_number('foo')
+          subject.parse['foo'].should == :number
+        end
+
+      end
+
+      describe '#property' do
+
+        it 'sets the property' do
+          subject.property('values.features')
+          subject.property.should == 'values.features'
+        end
+
+      end
+
+    end
+
+    context 'csv' do
+
+      subject { ::Plotrb::Data::Format.new(:csv) }
+
+      it 'has parse attribute' do
+        subject.attributes.should match_array([:type, :parse])
+      end
+
+    end
+
+    context 'tsv' do
+
+      subject { ::Plotrb::Data::Format.new(:tsv) }
+
+      it 'has parse attribute' do
+        subject.attributes.should match_array([:type, :parse])
+      end
+
+    end
+
+    context 'topojson' do
+
+      subject { ::Plotrb::Data::Format.new(:topojson) }
+
+      it 'has feature and mesh attribute' do
+        subject.attributes.should match_array([:type, :feature, :mesh])
+      end
+
+    end
+
+    context 'treejson' do
+
+      subject { ::Plotrb::Data::Format.new(:treejson) }
+
+      it 'has parse and children attribute' do
+        subject.attributes.should match_array([:type, :parse, :children])
+      end
+
+    end
+
+  end
+
+end

data/spec/plotrb/kernel_spec.rb

@@ -0,0 +1,54 @@
+require_relative '../spec_helper'
+
+describe 'Kernel' do
+
+  class Object
+    include ::Plotrb::Kernel
+  end
+
+  describe '#visualization' do
+
+    it 'creates new visualization object' do
+      v = visualization
+      v.is_a?(::Plotrb::Visualization).should be_true
+    end
+
+  end
+
+  describe '#pdata' do
+
+    it 'creates new data object' do
+      d = pdata
+      d.is_a?(::Plotrb::Data).should be_true
+    end
+
+  end
+
+  describe '#method_missing' do
+
+    it 'creates axis object' do
+      a = x_axis
+      a.is_a?(::Plotrb::Axis).should be_true
+      a.type.should == :x
+    end
+
+    it 'creates scale object' do
+      s = linear_scale
+      s.is_a?(::Plotrb::Scale).should be_true
+      s.type.should == :linear
+    end
+
+    it 'creates mark object' do
+      m = rect_mark
+      m.is_a?(::Plotrb::Mark).should be_true
+      m.type.should == :rect
+    end
+
+    it 'creates transform object' do
+      t = filter_transform
+      t.is_a?(::Plotrb::Transform).should be_true
+      t.type.should == :filter
+    end
+  end
+
+end

data/spec/plotrb/legends_spec.rb

@@ -0,0 +1,157 @@
+require_relative '../spec_helper'
+
+describe 'Legend' do
+	subject { ::Plotrb::Legend.new }
+	
+	describe '#size' do
+		
+		it 'sets the scale backing the legend size by name' do
+			subject.size('foo_scale')
+			subject.size.should == 'foo_scale'
+		end
+	
+		it 'sets the scale backing the legend size by the scale object' do
+			scale = ::Plotrb::Scale.new.name('foo_scale')
+			subject.size(scale)
+			subject.send(:process_size)
+			subject.size.should == 'foo_scale'
+		end
+
+		it 'raises error if scale is not found' do
+			subject.size('foo_scale')
+			::Plotrb::Kernel.stub(:find_scale).and_return(nil)
+			expect { subject.send(:process_size) }.to raise_error(ArgumentError)
+		end
+	
+	end
+
+	describe '#shape' do
+		
+		it 'sets the scale backing the legend shape by name' do
+			subject.shape('foo_scale')
+			subject.shape.should == 'foo_scale'
+		end
+	
+		it 'sets the scale backing the legend shape by the scale object' do
+			scale = ::Plotrb::Scale.new.name('foo_scale')
+			subject.shape(scale)
+			subject.send(:process_shape)
+			subject.shape.should == 'foo_scale'
+		end
+
+		it 'raises error if scale is not found' do
+			subject.shape('foo_scale')
+			::Plotrb::Kernel.stub(:find_scale).and_return(nil)
+			expect { subject.send(:process_shape) }.to raise_error(ArgumentError)
+		end
+	
+	end
+
+	describe '#fill' do
+		
+		it 'sets the scale backing the legend fill color by name' do
+			subject.fill('foo_scale')
+			subject.fill.should == 'foo_scale'
+		end
+	
+		it 'sets the scale backing the legend fill color by the scale object' do
+			scale = ::Plotrb::Scale.new.name('foo_scale')
+			subject.fill(scale)
+			subject.send(:process_fill)
+			subject.fill.should == 'foo_scale'
+		end
+
+		it 'raises error if scale is not found' do
+			subject.fill('foo_scale')
+			::Plotrb::Kernel.stub(:find_scale).and_return(nil)
+			expect { subject.send(:process_fill) }.to raise_error(ArgumentError)
+		end
+	
+	end
+
+	describe '#stroke' do
+		
+		it 'sets the scale backing the legend stroke color by name' do
+			subject.stroke('foo_scale')
+			subject.stroke.should == 'foo_scale'
+		end
+	
+		it 'sets the scale backing the legend stroke color by the scale object' do
+			scale = ::Plotrb::Scale.new.name('foo_scale')
+			subject.stroke(scale)
+			subject.send(:process_stroke)
+			subject.stroke.should == 'foo_scale'
+		end
+
+		it 'raises error if scale is not found' do
+			subject.stroke('foo_scale')
+			::Plotrb::Kernel.stub(:find_scale).and_return(nil)
+			expect { subject.send(:process_stroke) }.to raise_error(ArgumentError)
+		end
+	
+	end
+	
+	describe '#orient' do
+
+		it 'sets the orient of the axis' do
+			subject.at_left
+			subject.orient.should == :left
+		end
+		
+		it 'raises error if orient is invalid' do
+			subject.orient(:top)
+			expect { subject.send(:process_orient) }.to raise_error(ArgumentError)
+		end
+
+	end
+	
+	describe '#title' do
+
+		it 'sets title of the axis' do
+			subject.title('foo')
+			subject.title.should == 'foo'
+		end
+
+	end
+	
+    describe 'format' do
+
+		it 'accepts valid format specifier' do
+			subject.format('04d')
+			expect { subject.send(:process_format) }.to_not raise_error(ArgumentError)
+		end
+
+		it 'raises error if format specifier is invalid' do
+			subject.format('{$s04d,g')
+			expect { subject.send(:process_format) }.to raise_error(ArgumentError)
+		end
+
+	end
+
+	describe '#offset' do
+
+		it 'sets offset of the axis' do
+			subject.offset_by(10)
+			subject.offset.should == 10
+		end
+
+	end
+	
+	
+	describe '#values' do
+
+		it 'sets values if given as an array' do
+			subject.values([1,2,3,4])
+			subject.values.should match_array([1,2,3,4])
+		end
+
+		it 'sets values if given one by one as arguments' do
+			subject.values(1,2,3,4)
+			subject.values.should match_array([1,2,3,4])
+		end
+
+  end
+	
+	
+
+end