daru-view 0.1.0

data/lib/tasks/high_charts.rake

@@ -0,0 +1,60 @@
+# using code from lazy _high_charts gem with some modification
+
+def say(msg, &block)
+  print "#{msg}..."
+
+  if block_given?
+      yield
+    puts " Done."
+  end
+end
+
+namespace :highcharts do
+  desc "Update highcharts.js from latest Builds on Highcharts codebase: http://code.highcharts.com/"
+  task :update => [:core, :stock]
+  task :core do
+    say "Grabbing Core from Highcharts codebase..." do
+      sh "mkdir -p lib/daru/view/adapters/js/highcharts_js/modules/"
+      sh "mkdir -p lib/daru/view/adapters/js/highcharts_js/adapters/"
+
+      sh "curl -# http://code.highcharts.com/highcharts.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/highcharts.js"
+      sh "curl -# http://code.highcharts.com/highcharts-more.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/highcharts-more.js"
+      sh "curl -# http://code.highcharts.com/highcharts-3d.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/highcharts-3d.js"
+
+      # Modules
+      sh "curl -# http://code.highcharts.com/modules/accessibility.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/modules/accessibility.js"
+      sh "curl -# http://code.highcharts.com/modules/annotations.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/modules/annotations.js"
+      sh "curl -# http://code.highcharts.com/modules/boost.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/modules/boost.js"
+      sh "curl -# http://code.highcharts.com/modules/broken-axis.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/modules/broken-axis.js"
+      sh "curl -# http://code.highcharts.com/modules/canvas-tools.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/modules/canvas-tools.js"
+      sh "curl -# http://code.highcharts.com/modules/data.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/modules/data.js"
+      sh "curl -# http://code.highcharts.com/modules/exporting.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/modules/exporting.js"
+      sh "curl -# http://code.highcharts.com/modules/drilldown.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/modules/drilldown.js"
+      sh "curl -# http://code.highcharts.com/modules/funnel.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/modules/funnel.js"
+      sh "curl -# http://code.highcharts.com/modules/heatmap.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/modules/heatmap.js"
+      sh "curl -# http://code.highcharts.com/modules/no-data-to-display.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/modules/no-data-to-display.js"
+      sh "curl -# http://code.highcharts.com/modules/offline-exporting.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/modules/offline-exporting.js"
+      sh "curl -# http://code.highcharts.com/modules/solid-gauge.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/modules/solid-gauge.js"
+      sh "curl -# http://code.highcharts.com/modules/treemap.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/modules/treemap.js"
+
+      sh "curl -# http://code.highcharts.com/adapters/mootools-adapter.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/adapters/mootools-adapter.js"
+      sh "curl -# http://code.highcharts.com/adapters/prototype-adapter.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/adapters/prototype-adapter.js"
+    end
+  end
+
+  task :stock do
+    say "Grabbing Highcharts Stock JS from Upstream..." do
+
+      sh "mkdir -p lib/daru/view/adapters/js/highcharts_js/stock/modules/"
+      sh "mkdir -p lib/daru/view/adapters/js/highcharts_js/stock/adapters/"
+
+      sh "curl -# http://code.highcharts.com/stock/highstock.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/highstock.js"
+      sh "curl -# http://code.highcharts.com/stock/highcharts-more.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/stock/highcharts-more.js"
+      sh "curl -# http://code.highcharts.com/stock/modules/exporting.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/stock/modules/exporting.js"
+      sh "curl -# http://code.highcharts.com/stock/modules/funnel.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/stock/modules/funnel.js"
+      sh "curl -# http://code.highcharts.com/stock/adapters/mootools-adapter.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/stock/adapters/mootools-adapter.js"
+      sh "curl -# http://code.highcharts.com/stock/adapters/prototype-adapter.js -L --compressed -o lib/daru/view/adapters/js/highcharts_js/stock/adapters/prototype-adapter.js"
+    end
+  end
+
+end

data/lib/tasks/nyaplot.rake

@@ -0,0 +1,25 @@
+def say(msg, &block)
+  print "#{msg}..."
+
+  if block_given?
+      yield
+    puts " Done."
+  end
+end
+
+namespace :nyaplot do
+  desc "Update nyaplot.js from latest Builds on Nyaplotjs github repo and d3.js website"
+  task :update => [:nyaplot, :d3]
+  task :nyaplot do
+    say "Grabbing Core from Nyaplotjs codebase..." do
+      # TODO get the nyaplot js file
+    end
+  end
+
+  task :d3 do
+    say "Grabbing Highcharts Stock JS from Upstream..." do
+      # TODO : get the d3 and d3-downloaded
+    end
+  end
+
+end

data/spec/adapters/datatables_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper.rb'
+
+describe Daru::View::Table, 'table using daru-data_tables' do
+  before { Daru::View.table_library = :datatables }
+  before(:each) do
+    @data_array = [[1, 15], [2, 30], [4, 40]]
+    @data_vec1 = Daru::Vector.new([1 ,2, 4])
+    @data_vec2 = Daru::Vector.new([15 ,30, 40])
+    @data_df = Daru::DataFrame.new(arr1: @data_vec1, arr2: @data_vec2)
+
+    @options = {width: 800, height: 720}
+
+    @plot = Daru::View::Table.new(@data_df, @options)
+  end
+
+  describe "initialization Tables" do
+    it "Table class must be Daru::DataTables::DataTable " do
+      expect(Daru::View::Table.new.table).to be_a Daru::DataTables::DataTable
+    end
+  end
+end

data/spec/adapters/googlecharts_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper.rb'
+
+describe Daru::View::Plot, 'plotting with googlecharts' do
+  before { Daru::View.plotting_library = :googlecharts }
+  before(:each) do
+    @data_array = [[1, 15], [2, 30], [4, 40]]
+    @data_vec1 = Daru::Vector.new([1 ,2, 4])
+    @data_vec2 = Daru::Vector.new([15 ,30, 40])
+    @data_df = Daru::DataFrame.new(arr1: @data_vec1, arr2: @data_vec2)
+
+    @options = {width: 800, height: 720}
+
+    @plot = Daru::View::Plot.new(@data_df, @options)
+  end
+
+  describe "initialization Charts" do
+    it "Default chart GoogleVisualr::Interactive::LineChart " do
+      expect(Daru::View::Plot.new.chart).to be_a GoogleVisualr::Interactive::LineChart
+    end
+    it "Bar chart GoogleVisualr::Interactive::BarChart " do
+      expect(Daru::View::Plot.new([], type: :bar).chart).to be_a GoogleVisualr::Interactive::BarChart
+    end
+    it "Column chart GoogleVisualr::Interactive::ColumnChart " do
+      expect(Daru::View::Plot.new([], type: :column).chart).to be_a GoogleVisualr::Interactive::ColumnChart
+    end
+    # TODO: all other kinds of charts
+  end
+
+  describe "initialization Tables" do
+    it "Table class must be GoogleVisualr::DataTable " do
+      expect(Daru::View::Table.new.table).to be_a GoogleVisualr::DataTable
+    end
+  end
+end

data/spec/adapters/highcharts_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper.rb'
+
+# some specs from lazy_high_charts specs
+describe Daru::View::Plot, 'plotting with highcharts' do
+  before { Daru::View.plotting_library = :highcharts }
+  before(:each) do
+    @data = [[1, 15], [2, 30], [4, 40]]
+
+    @placeholder = "placeholder"
+    @html_options = {:class => "stylin"}
+    @options = {:bars => {:show => true}}
+
+    @flot = Daru::View::Plot.new(@data, @options)
+  end
+
+  describe "initialization" do
+    it "shouldn't generate a nil placeholder" do
+      expect(Daru::View::Plot.new.chart.placeholder).not_to be_nil
+    end
+
+    let(:plt) { Daru::View::Plot.new }
+    before { plt.chart.placeholder = @placeholder }
+    it "should take an optional 'placeholder' argument" do
+      expect(plt.chart.placeholder).to eq(@placeholder)
+      expect(Daru::View::Plot.new.chart.placeholder).not_to eq(@placeholder)
+    end
+
+    it "should generate different placeholders for different charts" do
+      a_different_placeholder = Daru::View::Plot.new.chart.placeholder
+      expect(Daru::View::Plot.new.chart.placeholder).not_to eq(a_different_placeholder)
+    end
+
+    it "should able take an optional html_options argument (defaulting to 300px height)" do
+      expect(Daru::View::Plot.new.chart.html_options).to eq({})
+    end
+
+    before { plt.chart.html_options = @html_options }
+    it "should able take an optional html_options argument (defaulting to 300px height)" do
+      expect(plt.chart.html_options).to eq(@html_options)
+    end
+
+    it "should set options by default" do
+      expect(Daru::View::Plot.new.chart.options).to eq({
+          :title => {:text => nil},
+          :legend => {:layout => "vertical", :style => {}},
+          :xAxis => {},
+          :yAxis => {:title => {:text => nil}, :labels => {}},
+          :tooltip => {:enabled => true},
+          :credits => {:enabled => false},
+          :plotOptions => {:areaspline => {}},
+          :chart => {:defaultSeriesType => "line", :renderTo => nil},
+          :subtitle => {}})
+    end
+
+    it "should set data empty by default" do
+      expect(Daru::View::Plot.new.chart.series_data).to eq(
+        [{:type=>nil, :name=>nil, :data=>[]}])
+    end
+
+    let(:graph) { Daru::View::Plot.new }
+    it "should take a block setting attributes" do
+      graph.chart.tap do |f|
+        f.series_data = @data
+        f.options = @options
+      end
+      expect(graph.chart.series_data).to eq(@data)
+      expect(graph.chart.options).to eq(@options)
+    end
+
+    it "should take a block setting attributes" do
+      # Didn't understand why it fails :
+      # 1. when we do graph.chart do |f| ..
+      # 2. when we do graph.chart {|f| ..}
+      graph_chart = graph.chart.tap do |f|
+        f.options[:legend][:layout] = "horizontal"
+      end
+      expect(graph_chart.options[:legend][:layout]).to eq("horizontal")
+    end
+
+    it "should take a block setting attributes" do
+      graph_chart = graph.chart.tap do |f|
+        f.options[:range_selector] = {}
+        f.options[:range_selector][:selected] = 1
+      end
+      expect(graph_chart.options[:range_selector][:selected]).to eq(1)
+    end
+
+    it "should change a block data without overriding options" do
+      graph = Daru::View::Plot.new.chart.tap do |f|
+        f.series(:name => 'John', :data => [3, 20])
+        f.series(:name => 'Jane', :data => [1, 3])
+        # without overriding
+        f.options[:chart][:defaultSeriesType] = "area"
+        f.options[:chart][:inverted] = true
+        f.options[:legend][:layout] = "horizontal"
+        f.options[:xAxis][:categories] = ["uno", "dos", "tres", "cuatro"]
+      end
+      # {type: nil, :name => nil, :data => []} series is added during
+      # the initialzation of chart. User can remove it using this line:
+      # graph.delete({type: nil, :name => nil, :data => []})
+      expect(graph.series_data).to eq([
+        {type: nil, :name => nil, :data => []},
+        {:name => "John", :data => [3, 20]},
+        {:name => "Jane", :data => [1, 3]}
+      ])
+      expect(graph.options[:legend][:layout]).to eq("horizontal")
+      expect(graph.options[:xAxis][:categories]).to eq(["uno", "dos", "tres", "cuatro"])
+      expect(graph.options[:chart][:defaultSeriesType]).to eq("area")
+      expect(graph.options[:chart][:inverted]).to eq(true)
+    end
+
+    it "should change a block data with overriding entire options" do
+      graph = Daru::View::Plot.new.chart.tap do |f|
+        f.series(:name => 'John', :data => [3, 20])
+        f.series(:name => 'Jane', :data => [1, 3])
+        f.title({:text => nil})
+        # without overriding
+        f.xAxis(:categories => ["uno", "dos", "tres", "cuatro"], :labels => {:rotation => -45, :align => 'right'})
+        f.chart({:defaultSeriesType => "spline", :renderTo => "myRenderArea", :inverted => true})
+      end
+      expect(graph.options[:xAxis][:categories]).to eq(["uno", "dos", "tres", "cuatro"])
+      expect(graph.options[:xAxis][:labels][:rotation]).to eq(-45)
+      expect(graph.options[:xAxis][:labels][:align]).to eq("right")
+      expect(graph.options[:chart][:defaultSeriesType]).to eq("spline")
+      expect(graph.options[:chart][:renderTo]).to eq("myRenderArea")
+      expect(graph.options[:chart][:inverted]).to eq(true)
+    end
+
+    it "should have subtitles" do
+      graph = Daru::View::Plot.new.chart.tap do |f|
+        f.series(:name => 'John', :data => [3, 20])
+        f.series(:name => 'Jane', :data => [1, 3])
+        f.title({:text => nil})
+        # without overriding
+        f.x_axis(:categories => ["uno", "dos", "tres", "cuatro"], :labels => {:rotation => -45, :align => 'right'})
+        f.chart({:defaultSeriesType => "spline", :renderTo => "myRenderArea", :inverted => true})
+        f.subtitle({:text => "Bar"})
+      end
+      expect(graph.options[:subtitle][:text]).to eq("Bar")
+    end
+
+    it 'should override entire option by default when resetting it again' do
+      graph = Daru::View::Plot.new.chart.tap do |f|
+        f.xAxis(categories: [3, 5, 7])
+        f.xAxis(title: {text: 'x title'})
+      end
+      expect(graph.options[:xAxis][:categories]).to eq(nil)
+      expect(graph.options[:xAxis][:title][:text]).to eq('x title')
+    end
+
+    it 'should allow to build options step by step without overriding previously set values' do
+      graph = Daru::View::Plot.new.chart.tap do |f|
+        f.xAxis!(categories: [3, 5, 7])
+        f.xAxis!(title: {text: 'x title'})
+      end
+      expect(graph.options[:xAxis][:categories]).to eq([3, 5, 7])
+      expect(graph.options[:xAxis][:title][:text]).to eq('x title')
+    end
+
+    it 'should merge options and data into a full options hash' do
+      graph = Daru::View::Plot.new.chart.tap do |f|
+        f.series(name: 'John', data: [29.9, 71.5, 106.4, 129.2, 144.0, 176.0, 135.6, 148.5, 216.4, 194.1, 95.6, 54.4])
+        f.series(name: 'Jane', data: [140.02, 41.63, 66.72, 113.21, 107.98, 105.71, 28.59, 114.23, 5.56, 93.71, 137.35, 93.16])
+        f.title({text: 'Example Data'})
+        f.xAxis(categories: %w(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec), labels: {rotation: -45, align: 'right'})
+        f.options[:tooltip][:formatter] = "function(){ return '<b>'+ this.point.name +'</b>: '+ Highcharts.numberFormat(this.percentage, 2) +' %'; }"
+      end
+
+      json = graph.full_options
+      expect(json).to match /\"series\"/
+      expect(json).to match /\"title\"/
+      expect(json).to match /\"tooltip\": { \"enabled\": true,\"formatter\"/
+      expect(json).to match /\"data\": \[ 29.9,71.5,106.4,129.2,144.0,176.0,135.6,148.5,216.4,194.1,95.6,54.4 \]/
+    end
+
+  end
+end

data/spec/adapters/nyaplot_spec.rb

@@ -0,0 +1,447 @@
+require 'spec_helper.rb'
+
+# some specs from daru specs
+describe Daru::View::Plot, 'plotting Vector with nyaplot library' do
+  let(:vector) { Daru::Vector.new([11, 22, 33], index: [:a, :b, :c]) }
+  let(:plot) { instance_double('Nyaplot::Plot') }
+
+  before do
+    Daru::View.plotting_library = :nyaplot
+    allow(Nyaplot::Plot).to receive(:new).and_return(plot)
+  end
+
+  it 'plots the vector' do
+    expect(plot).to receive(:add).with(:box, [11, 22, 33]).ordered
+
+    expect(Daru::View::Plot.new(vector, type: :box).chart).to eq plot
+  end
+
+  context 'scatter' do
+    it 'is default type' do
+      expect(plot).to receive(:add).with(:scatter, instance_of(Array), instance_of(Array)).ordered
+
+      expect(Daru::View::Plot.new(vector).chart).to eq plot
+    end
+
+    it 'sets x_axis to 0...size' do
+      expect(plot).to receive(:add).with(:scatter, [0, 1, 2], [11, 22, 33]).ordered
+
+      expect(Daru::View::Plot.new(vector, type: :scatter).chart).to eq plot
+    end
+  end
+
+  [:box, :histogram].each do |type|
+    context type.to_s do
+      it 'does not set x axis' do
+        expect(plot).to receive(:add).with(type, [11, 22, 33]).ordered
+
+        expect(Daru::View::Plot.new(vector, type: type).chart).to eq plot
+      end
+    end
+  end
+
+  [:bar, :line].each do |type| # FIXME: what other types 2D plot could have?..
+    context type.to_s do
+      it 'sets x axis to index' do
+        expect(plot).to receive(:add).with(type, [:a, :b, :c], [11, 22, 33]).ordered
+
+        expect(Daru::View::Plot.new(vector, type: type).chart).to eq plot
+      end
+    end
+  end
+end
+
+# category vector
+describe Daru::View::Plot, 'plotting Category Vector with nyaplot library' do
+  let(:plot) { instance_double('Nyaplot::Plot') }
+  let(:dv) do
+    Daru::Vector.new ['III']*10 + ['II']*5 + ['I']*5,
+      type: :category,
+      categories: ['I', 'II', 'III']
+  end
+  before do
+    Daru::View.plotting_library = :nyaplot
+    allow(Nyaplot::Plot).to receive(:new).and_return(plot)
+  end
+  context 'bar' do
+    it 'plots bar graph taking a block' do
+      expect(plot).to receive(:add).with(:bar, ['I', 'II', 'III'], [5, 5, 10])
+      expect(plot).to receive :x_label
+      expect(plot).to receive :y_label
+      # need to write with tap, below test
+      Daru::View::Plot.new(dv, type: :bar).chart.tap do |p|
+        p.x_label 'Categories'
+        p.y_label 'Frequency'
+      end
+    end
+
+    it 'plots bar graph without taking a block' do
+      expect(plot).to receive(:add).with(:bar, ["I", "II", "III"], [5, 5, 10])
+      expect(Daru::View::Plot.new(dv, type: :bar).chart).to eq plot
+    end
+
+    it 'plots bar graph with percentage' do
+      expect(plot).to receive(:add).with(:bar, ["I", "II", "III"], [25, 25, 50])
+      expect(plot).to receive(:yrange).with [0, 100]
+      expect(Daru::View::Plot.new(dv, type: :bar, method: :percentage).chart).to eq plot
+    end
+
+    it 'plots bar graph with fraction' do
+      expect(plot).to receive(:add).with(:bar, ["I", "II", "III"], [0.25, 0.25, 0.50])
+      expect(plot).to receive(:yrange).with [0, 1]
+      expect(Daru::View::Plot.new(dv, type: :bar, method: :fraction).chart).to eq plot
+    end
+  end
+
+  context 'other type' do
+    it { expect { Daru::View::Plot.new(dv, type: :scatter) }.to raise_error ArgumentError }
+  end
+end
+
+# testing DataFrame
+class Nyaplot::DataFrame
+  # Because it does not allow to any equality testing
+  def == other
+    other.is_a?(Nyaplot::DataFrame) && rows == other.rows
+  end
+end
+
+describe Daru::View::Plot, 'plotting DataFrame with Nyaplot library' do
+  let(:data_frame) {
+    Daru::DataFrame.new({
+        x:  [1, 2, 3, 4],
+        y1: [5, 7, 9, 11],
+        y2: [-3, -7, -11, -15],
+        cat: [:a, :b, :c, :d]
+      },
+      index: [:one, :two, :three, :four]
+    )
+  }
+  let(:plot) { instance_double('Nyaplot::Plot') }
+
+  before do
+    allow(Nyaplot::Plot).to receive(:new).and_return(plot)
+  end
+
+  context 'box' do
+    let(:numerics) { data_frame.only_numerics }
+    it 'plots numeric vectors' do
+      expect(plot).to receive(:add_with_df)
+        .with(numerics.to_nyaplotdf, :box, :x, :y1, :y2)
+        .ordered
+
+      expect(Daru::View::Plot.new(data_frame, type: :box).chart).to eq plot
+    end
+  end
+
+  context 'other types' do
+    context 'single chart' do
+      it 'works with :y provided' do
+        expect(plot).to receive(:add_with_df)
+          .with(data_frame.to_nyaplotdf, :scatter, :x, :y1)
+          .ordered
+
+        expect(Daru::View::Plot.new(
+          data_frame,
+          type: :scatter, x: :x, y: :y1).chart
+        ).to eq plot
+      end
+
+      it 'works without :y provided' do
+        expect(plot).to receive(:add_with_df)
+          .with(data_frame.to_nyaplotdf, :scatter, :x)
+          .ordered
+
+        expect(Daru::View::Plot.new(
+          data_frame,
+          type: :scatter, x: :x).chart
+        ).to eq plot
+      end
+    end
+
+    context 'multiple charts' do
+      it 'works with single type provided' do
+        expect(plot).to receive(:add_with_df)
+          .with(data_frame.to_nyaplotdf, :scatter, :x, :y1)
+          .ordered
+        expect(plot).to receive(:add_with_df)
+          .with(data_frame.to_nyaplotdf, :scatter, :x, :y2)
+          .ordered
+
+        expect(
+          Daru::View::Plot.new(
+            data_frame, type: :scatter, x: [:x, :x], y: [:y1, :y2]).chart
+          ).to eq plot
+      end
+
+      it 'works with multiple types provided' do
+        expect(plot).to receive(:add_with_df)
+          .with(data_frame.to_nyaplotdf, :scatter, :x, :y1)
+          .ordered
+        expect(plot).to receive(:add_with_df)
+          .with(data_frame.to_nyaplotdf, :line, :x, :y2)
+          .ordered
+
+        expect(
+          Daru::View::Plot.new(
+            data_frame,
+            type: [:scatter, :line], x: [:x, :x], y: [:y1, :y2]).chart
+        ).to eq plot
+      end
+
+      it 'works with numeric var names' do
+        expect(plot).to receive(:add_with_df)
+          .with(data_frame.to_nyaplotdf, :scatter, :x, :y1)
+          .ordered
+        expect(plot).to receive(:add_with_df)
+          .with(data_frame.to_nyaplotdf, :line, :x, :y2)
+          .ordered
+
+        expect(
+          Daru::View::Plot.new(
+            data_frame,
+            type: [:scatter, :line],
+            # FIXME: this didn't work due to default type: :scatter opts
+            #type1: :scatter,
+            #type2: :line,
+            x1: :x,
+            x2: :x,
+            y1: :y1,
+            y2: :y2
+          ).chart
+        ).to eq plot
+      end
+    end
+  end
+end
+
+describe Daru::View::Plot, 'DataFrame category plotting with Nyaplot lib' do
+  context 'scatter' do
+    let(:df) do
+      Daru::DataFrame.new({
+        a: [1, 2, 4, -2, 5, 23, 0],
+        b: [3, 1, 3, -6, 2, 1, 0],
+        c: ['I', 'II', 'I', 'III', 'I', 'III', 'II']
+      })
+    end
+    let(:plot) { instance_double('Nyaplot::Plot') }
+    let(:diagram) { instance_double('Nyaplot::Diagram::Scatter') }
+
+    before do
+      df.to_category :c
+      allow(Nyaplot::Plot).to receive(:new).and_return(plot)
+      allow(plot).to receive(:add_with_df).and_return(diagram)
+    end
+
+    it 'plots scatter plot categoried by color with a block' do
+      expect(plot).to receive :add_with_df
+      expect(diagram).to receive(:title).exactly(3).times
+      expect(diagram).to receive(:color).exactly(3).times
+      expect(diagram).to receive(:tooltip_contents).exactly(3).times
+      expect(plot).to receive :legend
+      expect(plot).to receive :xrange
+      expect(plot).to receive :yrange
+      Daru::View::Plot.new(
+        df, type: :scatter, x: :a, y: :b,
+        categorized: {by: :c, method: :color}
+      ).chart.tap do |p, d|
+        p.xrange [-10, 10]
+        p.yrange [-10, 10]
+      end
+    end
+
+    it 'plots scatter plot categoried by color' do
+      expect(plot).to receive :add_with_df
+      expect(diagram).to receive(:title).exactly(3).times
+      expect(diagram).to receive(:color).exactly(3).times
+      expect(diagram).to receive(:tooltip_contents).exactly(3).times
+      expect(plot).to receive :legend
+      expect(
+        Daru::View::Plot.new(
+          df,
+          type: :scatter, x: :a, y: :b,
+          categorized: {by: :c, method: :color}).chart
+      ).to eq plot
+    end
+
+    it 'plots scatter plot categoried by custom colors' do
+      expect(plot).to receive :add_with_df
+      expect(diagram).to receive(:title).exactly(3).times
+      expect(diagram).to receive(:color).with :red
+      expect(diagram).to receive(:color).with :blue
+      expect(diagram).to receive(:color).with :green
+      expect(diagram).to receive(:tooltip_contents).exactly(3).times
+      expect(plot).to receive :legend
+      expect(
+        Daru::View::Plot.new(
+          df, type: :scatter, x: :a, y: :b,
+          categorized: {by: :c, method: :color, color: [:red, :blue, :green]}
+          ).chart
+        ).to eq plot
+    end
+
+    it 'plots scatter plot categoried by shape' do
+      expect(plot).to receive :add_with_df
+      expect(diagram).to receive(:title).exactly(3).times
+      expect(diagram).to receive(:shape).exactly(3).times
+      expect(diagram).to receive(:tooltip_contents).exactly(3).times
+      expect(plot).to receive :legend
+      expect(Daru::View::Plot.new(
+        df, type: :scatter, x: :a, y: :b,
+        categorized: {by: :c, method: :shape}).chart
+      ).to eq plot
+    end
+
+    it 'plots scatter plot categoried by custom shapes' do
+      expect(plot).to receive :add_with_df
+      expect(diagram).to receive(:title).exactly(3).times
+      expect(diagram).to receive(:shape).with 'circle'
+      expect(diagram).to receive(:shape).with 'triangle-up'
+      expect(diagram).to receive(:shape).with 'diamond'
+      expect(diagram).to receive(:tooltip_contents).exactly(3).times
+      expect(plot).to receive :legend
+      expect(
+        Daru::View::Plot.new(
+          df,
+          type: :scatter, x: :a, y: :b,
+          categorized: {
+            by: :c, method: :shape,
+            shape: %w(circle triangle-up diamond)}).chart
+      ).to eq plot
+    end
+
+    it 'plots scatter plot categoried by size' do
+      expect(plot).to receive :add_with_df
+      expect(diagram).to receive(:title).exactly(3).times
+      expect(diagram).to receive(:size).exactly(3).times
+      expect(diagram).to receive(:tooltip_contents).exactly(3).times
+      expect(plot).to receive :legend
+      expect(Daru::View::Plot.new(
+        df, type: :scatter, x: :a, y: :b,
+        categorized: {by: :c, method: :size}).chart).to eq plot
+    end
+
+    it 'plots scatter plot categoried by cusom sizes' do
+      expect(plot).to receive :add_with_df
+      expect(diagram).to receive(:title).exactly(3).times
+      expect(diagram).to receive(:size).with 100
+      expect(diagram).to receive(:size).with 200
+      expect(diagram).to receive(:size).with 300
+      expect(diagram).to receive(:tooltip_contents).exactly(3).times
+      expect(plot).to receive :legend
+      expect(
+        Daru::View::Plot.new(
+          df,
+          type: :scatter,
+          x: :a, y: :b,
+          categorized: {
+            by: :c,
+            method: :size,
+            size: [100, 200, 300]
+            }
+          ).chart
+        ).to eq plot
+    end
+  end
+
+  context 'line' do
+    let(:df) do
+      Daru::DataFrame.new({
+        a: [1, 2, 4, -2, 5, 23, 0],
+        b: [3, 1, 3, -6, 2, 1, 0],
+        c: ['I', 'II', 'I', 'III', 'I', 'III', 'II']
+      })
+    end
+    let(:plot) { instance_double('Nyaplot::Plot') }
+    let(:diagram) { instance_double('Nyaplot::Diagram::Scatter') }
+
+    before do
+      df.to_category :c
+      allow(Nyaplot::Plot).to receive(:new).and_return(plot)
+      allow(plot).to receive(:add_with_df).and_return(diagram)
+    end
+
+    it 'plots line plot categoried by color with a block' do
+      expect(plot).to receive :add_with_df
+      expect(diagram).to receive(:title).exactly(3).times
+      expect(diagram).to receive(:color).exactly(3).times
+      expect(plot).to receive :legend
+      expect(plot).to receive :xrange
+      expect(plot).to receive :yrange
+      Daru::View::Plot.new(
+        df, type: :line, x: :a, y: :b,
+        categorized: {by: :c, method: :color}).chart.tap do |p, d|
+          p.xrange [-10, 10]
+          p.yrange [-10, 10]
+      end
+    end
+
+    it 'plots line plot categoried by color' do
+      expect(plot).to receive :add_with_df
+      expect(diagram).to receive(:title).exactly(3).times
+      expect(diagram).to receive(:color).exactly(3).times
+      expect(plot).to receive :legend
+      expect(
+        Daru::View::Plot.new(df,
+          type: :line, x: :a, y: :b,
+          categorized: {by: :c, method: :color}
+        ).chart
+      ).to eq plot
+    end
+
+    it 'plots line plot categoried by custom colors' do
+      expect(plot).to receive :add_with_df
+      expect(diagram).to receive(:title).exactly(3).times
+      expect(diagram).to receive(:color).with :red
+      expect(diagram).to receive(:color).with :blue
+      expect(diagram).to receive(:color).with :green
+      expect(plot).to receive :legend
+      expect(
+        Daru::View::Plot.new(df,
+          type: :line, x: :a, y: :b,
+          categorized: {by: :c, method: :color, color: [:red, :blue, :green]}
+          ).chart
+      ).to eq plot
+    end
+
+    it 'plots line plot categoried by stroke width' do
+      expect(plot).to receive :add_with_df
+      expect(diagram).to receive(:title).exactly(3).times
+      expect(diagram).to receive(:stroke_width).exactly(3).times
+      expect(plot).to receive :legend
+      expect(
+        Daru::View::Plot.new(df,
+          type: :line, x: :a, y: :b,
+          categorized: {by: :c, method: :stroke_width}
+        ).chart
+      ).to eq plot
+    end
+
+    it 'plots line plot categoried by custom stroke widths' do
+      expect(plot).to receive :add_with_df
+      expect(diagram).to receive(:title).exactly(3).times
+      expect(diagram).to receive(:stroke_width).with 100
+      expect(diagram).to receive(:stroke_width).with 200
+      expect(diagram).to receive(:stroke_width).with 300
+      expect(plot).to receive :legend
+      expect(
+        Daru::View::Plot.new(df,
+          type: :line, x: :a, y: :b,
+          categorized: {
+            by: :c, method: :stroke_width, stroke_width: [100, 200, 300]}
+          ).chart
+      ).to eq plot
+    end
+  end
+
+  context "invalid type" do
+    let(:df) do
+      Daru::DataFrame.new({
+        a: [1, 2, 4, -2, 5, 23, 0],
+        b: [3, 1, 3, -6, 2, 1, 0],
+        c: ['I', 'II', 'I', 'III', 'I', 'III', 'II']
+      })
+    end
+    it { expect { Daru::View::Plot.new(df, type: :box, categorized: {by: :c, method: :color}).chart }.to raise_error ArgumentError }
+  end
+end