plotrb 0.0.1

data/lib/plotrb/version.rb

@@ -0,0 +1,3 @@
+module Plotrb
+  VERSION = '0.0.1'
+end

data/lib/plotrb/visualization.rb

@@ -0,0 +1,55 @@
+module Plotrb
+
+  # The container for all visual elements.
+  # See {https://github.com/trifacta/vega/wiki/Visualization}
+  class Visualization
+
+    include ::Plotrb::Base
+    include ::Plotrb::Kernel
+
+    # @!attributes name
+    #   @return [String] the name of the visualization
+    # @!attributes width
+    #   @return [Integer] the total width of the data rectangle
+    # @!attributes height
+    #   @return [Integer] the total height of the data rectangle
+    # @!attributes viewport
+    #   @return [Array(Integer, Integer)] the width and height of the viewport
+    # @!attributes padding
+    #   @return [Integer, Hash] the internal padding from the visualization
+    # @!attributes data
+    #   @return [Array<Data>] the data for visualization
+    # @!attributes scales
+    #   @return [Array<Scales>] the scales for visualization
+    # @!attributes marks
+    #   @return [Array<Marks>] the marks for visualization
+    # @!attributes axes
+    #   @return [Array<Axis>] the axes for visualization
+    # @!attributes legends
+    #   @return [Array<Legend>] the legends for visualization
+    add_attributes :name, :width, :height, :viewport, :padding, :data, :scales,
+                  :marks, :axes, :legends
+
+    def initialize(&block)
+      define_single_val_attributes(:name, :width, :height, :viewport, :padding)
+      define_multi_val_attributes(:data, :scales, :marks, :axes, :legends)
+      self.instance_eval(&block) if block_given?
+    end
+
+    def generate_spec(format=nil)
+      if format == :pretty
+        JSON.pretty_generate(self.collect_attributes)
+      else
+        JSON.generate(self.collect_attributes)
+      end
+    end
+
+  private
+
+    def attribute_post_processing
+
+    end
+
+  end
+
+end

data/plotrb.gemspec

@@ -0,0 +1,27 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'plotrb/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'plotrb'
+  spec.version       = Plotrb::VERSION
+  spec.authors       = ['Zuhao Wan']
+  spec.email         = 'wanzuhao@gmail.com'
+  spec.description   = %q{Plotrb is a plotting tool in Ruby.}
+  spec.summary       = %q{Plotrb is a plotting tool in Ruby, built on Vega and D3, and is part of the SciRuby Project.}
+  spec.homepage      = 'https://github.com/sciruby/plotrb'
+  spec.license       = 'BSD 2-clause'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = %w(lib)
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'yard'
+  spec.add_dependency 'yajl-ruby'
+  spec.add_dependency 'activemodel'
+end
+

data/spec/plotrb/axes_spec.rb

@@ -0,0 +1,227 @@
+require_relative '../spec_helper'
+
+describe 'Axis' do
+
+  subject { ::Plotrb::Axis.new(:x) }
+
+  describe '#type' do
+
+    it 'raises error if type is neither x or y' do
+      subject.instance_variable_set(:@type, :foo)
+      expect { subject.send(:process_type) }.to raise_error(ArgumentError)
+    end
+
+  end
+
+  describe '#scale' do
+
+    it 'sets the scale backing the axis by name' do
+      subject.from('foo_scale')
+      subject.scale.should == 'foo_scale'
+    end
+
+    it 'sets the scale backing the axis by the scale object' do
+      scale = ::Plotrb::Scale.new.name('foo_scale')
+      subject.from(scale)
+      subject.send(:process_scale)
+      subject.scale.should == 'foo_scale'
+    end
+
+    it 'raises error if scale is not found' do
+      subject.from('foo_scale')
+      ::Plotrb::Kernel.stub(:find_scale).and_return(nil)
+      expect { subject.send(:process_scale) }.to raise_error(ArgumentError)
+    end
+
+  end
+
+  describe '#orient' do
+
+    it 'sets the orient of the axis' do
+      subject.at_bottom
+      subject.orient.should == :bottom
+    end
+
+  end
+
+  describe '#title' do
+
+    it 'sets title of the axis' do
+      subject.title('foo')
+      subject.title.should == 'foo'
+    end
+
+  end
+
+  describe '#title_offset' do
+
+    it 'sets offset of the title' do
+      subject.offset_title_by(5)
+      subject.title_offset.should == 5
+    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 '#ticks' do
+
+    it 'sets ticks of the axis' do
+      subject.with_20_ticks
+      subject.ticks.should == 20
+    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
+
+  describe '#subdivide' do
+
+    it 'sets subdivide of the ticks' do
+      subject.subdivide_by(10)
+      subject.subdivide.should == 10
+    end
+
+  end
+
+  describe '#tick_padding' do
+
+    it 'sets padding for the ticks' do
+      subject.tick_padding(5)
+      subject.tick_padding.should == 5
+    end
+
+  end
+
+  describe '#tick_size' do
+
+    it 'sets size for the ticks' do
+      subject.tick_size(5)
+      subject.tick_size.should == 5
+    end
+
+  end
+
+  describe '#tick_size_major' do
+
+    it 'sets major tick size' do
+      subject.major_tick_size(10)
+      subject.tick_size_major.should == 10
+    end
+
+  end
+
+  describe '#tick_size_minor' do
+
+    it 'sets minor tick size' do
+      subject.minor_tick_size(10)
+      subject.tick_size_minor.should == 10
+    end
+
+  end
+
+  describe '#tick_size_end' do
+
+    it 'sets end tick size' do
+      subject.end_tick_size(10)
+      subject.tick_size_end.should == 10
+    end
+
+  end
+
+  describe '#offset' do
+
+    it 'sets offset of the axis' do
+      subject.offset_by(10)
+      subject.offset.should == 10
+    end
+
+  end
+
+  describe '#layer' do
+
+    it 'sets the layer of the axis' do
+      subject.in_front
+      subject.layer.should == :front
+    end
+
+  end
+
+  describe 'above' do
+
+    it 'sets the layer to front' do
+      subject.above
+      subject.layer.should == :front
+      subject.above?.should be_true
+    end
+
+  end
+
+  describe 'below' do
+
+    it 'sets the layer to back' do
+      subject.below
+      subject.layer.should == :back
+      subject.below?.should be_true
+    end
+
+  end
+
+  describe '#grid' do
+
+    it 'sets if grid-lines should be shown' do
+      subject.show_grid
+      subject.grid?.should be_true
+    end
+
+  end
+
+  describe '#method_missing' do
+
+    it 'sets ticks if in_some_ticks is called' do
+      subject.with_20_ticks
+      subject.ticks.should == 20
+    end
+
+    it 'sets subdivide if subdivide_by_some is called' do
+      subject.subdivide_by_10
+      subject.subdivide.should == 10
+    end
+
+    it 'sets orient if at_orient_position is called' do
+      subject.at_bottom
+      subject.orient.should == :bottom
+    end
+
+    it 'sets layer if at_layer_position is called' do
+      subject.in_front
+      subject.layer.should == :front
+    end
+
+  end
+
+end

data/spec/plotrb/base_spec.rb

@@ -0,0 +1,321 @@
+require_relative '../spec_helper'
+
+describe 'Base' do
+
+  class FooClass
+    include ::Plotrb::Base
+  end
+
+  class BarClass
+  end
+
+  class BazClass
+  end
+
+  describe 'ClassMethods' do
+
+    let(:foo) { Class.new { include ::Plotrb::Base } }
+
+    describe '.attributes' do
+
+      it 'has attributes' do
+        foo.respond_to?(:attributes).should be_true
+      end
+
+    end
+
+    describe '.add_attributes' do
+
+      before(:each) do
+        foo.class_eval { add_attributes :foo_foo }
+      end
+
+      it 'keeps track of all attributes defined for class' do
+        foo.attributes.should match_array([:foo_foo])
+      end
+
+      it 'adds setter method for the attribute' do
+        bar = foo.new
+        bar.foo_foo = 1
+        bar.instance_variable_get(:@foo_foo).should == 1
+      end
+
+    end
+
+  end
+
+  describe '#attributes' do
+
+    let(:foo) { FooClass.new }
+    before(:each) do
+      foo.singleton_class.class_eval { add_attributes :foo_foo }
+    end
+
+    it 'tracks both class-defined and instance-defined attributes' do
+      foo.add_attributes(:bar_bar)
+      foo.attributes.should match_array([:foo_foo, :bar_bar])
+    end
+
+  end
+
+  describe '#set_attribuets' do
+
+    let(:foo) { FooClass.new }
+
+    it 'creates attributes and sets values' do
+      foo.set_attributes(a: 1, b: 2)
+      foo.attributes.should match_array([:a, :b])
+      foo.instance_variable_get(:@a).should == 1
+      foo.instance_variable_get(:@b).should == 2
+    end
+
+  end
+
+  describe '#add_attributes' do
+
+    let(:foo) { FooClass.new }
+    let(:bar) { FooClass.new }
+    before(:each) do
+      FooClass.add_attributes(:foo_class)
+    end
+
+    it 'adds attributes to specific instance only' do
+      foo.add_attributes(:foo_foo)
+      bar.add_attributes(:bar_bar)
+      foo.attributes.should match_array([:foo_class, :foo_foo])
+      bar.attributes.should match_array([:foo_class, :bar_bar])
+    end
+
+  end
+
+  describe '#defined_attributes' do
+
+    let(:foo) { FooClass.new }
+
+    it 'only returns non-nil attributes' do
+      foo.set_attributes(a: 1, b: 2, c: nil)
+      foo.defined_attributes.should match_array([:a, :b])
+    end
+
+  end
+
+  describe '#collect_attributes' do
+
+    let(:foo) { FooClass.new }
+    let(:bar) { BarClass.new }
+    let(:baz) { BazClass.new }
+    before(:each) do
+      foo.add_attributes(:attr)
+      foo.stub(:attribute_post_processing)
+    end
+
+    it 'recursively collects attributes' do
+      BarClass.any_instance.stub(:respond_to?).with(:collect_attributes).
+          and_return(true)
+      BarClass.any_instance.stub(:collect_attributes).and_return('bar_values')
+      foo.attr = bar
+      foo.collect_attributes.should == { 'attr' => 'bar_values' }
+    end
+
+    it 'collects attributes of each of the array element' do
+      BarClass.any_instance.stub(:respond_to?).with(:collect_attributes).
+          and_return(true)
+      BazClass.any_instance.stub(:respond_to?).with(:collect_attributes).
+          and_return(true)
+      BarClass.any_instance.stub(:collect_attributes).and_return('bar_values')
+      BazClass.any_instance.stub(:collect_attributes).and_return('baz_values')
+      foo.attr = [bar, baz]
+      foo.collect_attributes.should == { 'attr' => %w(bar_values baz_values)}
+    end
+
+  end
+
+  describe '#define_boolean_attribute' do
+
+    let(:foo) { FooClass.new }
+
+    before(:each) do
+      foo.define_boolean_attribute(:bar)
+    end
+
+    it 'creates setter' do
+      foo.respond_to?(:bar).should be_true
+    end
+
+    it 'sets attribute to true when called' do
+      foo.bar
+      foo.instance_variable_get('@bar').should == true
+    end
+
+    it 'creates getter' do
+      foo.respond_to?(:bar?).should be_true
+    end
+
+  end
+
+  describe '#define_single_val_attribute' do
+
+    let(:foo) { FooClass.new }
+
+    context 'when no proc is provided' do
+
+      before(:each) do
+        foo.define_single_val_attribute(:bar)
+      end
+
+      it 'creates setter and getter' do
+        foo.respond_to?(:bar).should be_true
+      end
+
+      it 'acts as getter when no argument is provided' do
+        foo.should_receive(:instance_variable_get).with('@bar')
+        foo.bar
+      end
+
+      it 'sets value of the attribute if provided' do
+        foo.should_receive(:instance_variable_set).with('@bar', 1)
+        foo.bar(1)
+      end
+
+      it 'raises error if more than one value is given' do
+        expect { foo.bar(1,2,3) }.to raise_error(ArgumentError)
+      end
+
+    end
+
+    context 'when a proc is provided' do
+
+      it 'process the value before assigning to the attribute' do
+        p = lambda { |x| x + 1}
+        foo.define_single_val_attribute(:bar, p)
+        foo.bar(1)
+        foo.bar.should == 2
+      end
+
+      it 'raises error if condition check fails in proc' do
+        p = lambda { |x|
+          if x > 0
+            x + 1
+          else
+            raise ArgumentError
+          end
+        }
+        foo.define_single_val_attribute(:bar, p)
+        foo.bar(1)
+        foo.bar.should == 2
+        expect { foo.bar(0) }.to raise_error(ArgumentError)
+      end
+
+    end
+
+  end
+
+  describe '#define_multi_val_attribute' do
+
+    let(:foo) { FooClass.new }
+
+    context 'when no proc is provided' do
+
+      before(:each) do
+        foo.define_multi_val_attribute(:bar)
+      end
+
+      it 'creates setter and getter' do
+        foo.respond_to?(:bar).should be_true
+      end
+
+      it 'acts as getter when no argument is provided' do
+        foo.should_receive(:instance_variable_get).with('@bar')
+        foo.bar
+      end
+
+      it 'sets single value of the attribute if provided' do
+        foo.should_receive(:instance_variable_set).with('@bar', [1])
+        foo.bar(1)
+      end
+
+      it 'sets array of values' do
+        foo.should_receive(:instance_variable_set).with('@bar', [1, 2, 3])
+        foo.bar([1, 2, 3])
+      end
+
+      it 'sets multiple values' do
+        foo.should_receive(:instance_variable_set).with('@bar', [1, 2, 3])
+        foo.bar(1,2,3)
+      end
+
+    end
+
+    context 'when a proc is provided' do
+
+      it 'process the values before assigning to the attribute' do
+        p = lambda { |*x| x.each { |v| v + 1 } }
+        foo.define_multi_val_attribute(:bar, p)
+        foo.bar(1,2,3)
+        foo.bar.should == [1, 2, 3]
+      end
+
+      it 'is able to check argument size' do
+        p = lambda { |x, y, z| [x + 1, y + 1, z + 1] }
+        foo.define_multi_val_attribute(:bar, p)
+        foo.bar(1,2,3)
+        foo.bar.should == [2, 3, 4]
+        expect { foo.bar(1,2,3,4) }.to raise_error(ArgumentError)
+      end
+    end
+
+  end
+
+  describe '#classify' do
+
+    let(:foo) { Class.new { extend ::Plotrb::Base } }
+
+    it 'classifies string' do
+      foo.classify('visualization').should == 'Visualization'
+    end
+
+    it 'changes snake_case to CamelCase' do
+      foo.classify('foo_bar').should == 'FooBar'
+    end
+
+    it 'changes snake_case to camelCaseInJson' do
+      foo.classify('foo_bar_baz', :json).should == 'fooBarBaz'
+    end
+
+  end
+
+  describe 'Hash' do
+
+    describe '#reverse_merge' do
+
+      it 'should respond to reverse_merge' do
+        Hash.new.respond_to?(:reverse_merge).should be_true
+      end
+
+      it 'reverse merges hash' do
+        hash = {a: 1, b: 2}
+        default = {a:2, c:3}
+        hash.reverse_merge(default).should == {a: 1, b: 2, c: 3}
+      end
+
+    end
+
+    describe '#collect_attributes' do
+
+      it 'should respond to collect_attributes' do
+        Hash.new.respond_to?(:collect_attributes).should be_true
+      end
+
+      it 'recursively collects attributes' do
+        hash = {foo: FooClass.new, bar: BarClass.new}
+        FooClass.any_instance.stub(:collect_attributes).and_return('foo_value')
+        BarClass.any_instance.stub(:collect_attributes).and_return('bar_value')
+        hash.collect_attributes.should == {'foo' => 'foo_value',
+                                           'bar' => 'bar_value'}
+      end
+
+    end
+
+  end
+
+end