daru 0.1.3.1 → 0.1.4

data/spec/math/arithmetic/vector_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper.rb'
-
 describe Daru::Vector do
   before :each do
     @dv1 = Daru::Vector.new [1,2,3,4], name: :boozy, index: [:bud, :kf, :henie, :corona]
@@ -30,7 +28,7 @@ describe Daru::Vector do
       v1 = Daru::Vector.new([1,2,3])
       v2 = Daru::Vector.new([1,2,3], index: [:a,:b,:c])
 
-      expect(v1 + v2).to eq(Daru::Vector.new([nil]*6, index: [0,1,2,:a,:b,:c]))      
+      expect(v1 + v2).to eq(Daru::Vector.new([nil]*6, index: [0,1,2,:a,:b,:c]))
     end
   end
 
@@ -50,7 +48,7 @@ describe Daru::Vector do
     end
 
     it "multiplies number to each element of the entire vector" do
-      
+
     end
   end
 
@@ -60,7 +58,7 @@ describe Daru::Vector do
     end
 
     it "divides number from each element of the entire vector" do
-      
+
     end
   end
 
@@ -69,13 +67,13 @@ describe Daru::Vector do
   end
 
   context "#**" do
-    
+
   end
 
   context "#exp" do
     it "calculates exp of all numbers" do
-      expect(@with_md1.exp.round(3)).to eq(Daru::Vector.new([2.718281828459045, 
-        7.38905609893065, 20.085536923187668, nil, 148.4131591025766, nil], index: 
+      expect(@with_md1.exp.round(3)).to eq(Daru::Vector.new([2.718281828459045,
+        7.38905609893065, 20.085536923187668, nil, 148.4131591025766, nil], index:
         [:a, :b, :c, :obi, :wan, :corona], name: :missing).round(3))
     end
   end
@@ -95,6 +93,6 @@ describe Daru::Vector do
   context "#round" do
     it "rounds to given precision" do
       @with_md1.round(2)
-    end 
+    end
   end
-end
+end

data/spec/math/statistics/dataframe_spec.rb

@@ -1,9 +1,7 @@
-require 'spec_helper.rb'
-
 describe Daru::DataFrame do
   before do
     @df = Daru::DataFrame.new({
-      a: ['foo'  ,  'foo',  'foo',  'foo',  'foo',  'bar',  'bar',  'bar',  'bar'], 
+      a: ['foo'  ,  'foo',  'foo',  'foo',  'foo',  'bar',  'bar',  'bar',  'bar'],
       b: ['one'  ,  'one',  'one',  'two',  'two',  'one',  'one',  'two',  'two'],
       c: ['small','large','large','small','small','large','small','large','small'],
       d: [1,2,2,3,3,4,5,6,7],
@@ -14,7 +12,7 @@ describe Daru::DataFrame do
 
   context "#mean" do
     it "calculates mean of single level numeric only vectors and returns values in a Vector" do
-      expect(@df.mean.round(2)).to eq(Daru::Vector.new([3.67, 7.33, 36.67], 
+      expect(@df.mean.round(2)).to eq(Daru::Vector.new([3.67, 7.33, 36.67],
         index: [:d, :e, :f]
       ))
     end
@@ -130,7 +128,7 @@ describe Daru::DataFrame do
         b: [-0.0071019, 0.0020747, 0.0056071],
         c: [-0.0153640, 0.0056071, 0.0230777]
       })
-      
+
       test.cov.each_vector_with_index do |v, i|
         expect_correct_vector_in_delta v, ans[i], 0.01
       end

data/spec/math/statistics/vector_spec.rb

@@ -1,20 +1,14 @@
-require 'spec_helper.rb'
-
 describe Daru::Vector do
   [:array, :gsl].each do |dtype| #nmatrix still unstable
     describe dtype do
       before do
         @dv = Daru::Vector.new [323, 11, 555, 666, 234, 21, 666, 343, 1, 2], dtype: dtype
         @dv_with_nils = Daru::Vector.new [323, 11, 555, nil, 666, 234, 21, 666, 343, nil, 1, 2]
-        @dv_with_missing = Daru::Vector.new [1, 2, 3, 3], missing_values: [3], dtype: dtype
-        @dv_with_all_missing = Daru::Vector.new [3, 3], missing_values: [3], dtype: dtype
       end
 
       context "#mean" do
         it "calculates mean" do
           expect(@dv.mean).to eq(282.2)
-          expect(@dv_with_missing.mean).to eq(1.5)
-          expect(@dv_with_all_missing.mean).to eq(nil)
         end
       end
 
@@ -81,42 +75,18 @@ describe Daru::Vector do
         it "returns the max value" do
           expect(@dv.max).to eq(666)
         end
-        
-        it "returns the max value without considering values set as missing" do
-          expect(@dv_with_missing.max).to eq(2)
-        end
-        
-        it "returns nil when all values are set missing" do
-          expect(@dv_with_all_missing.max).to eq(nil)
-        end          
       end
 
       context "#min" do
         it "returns the min value" do
           expect(@dv.min).to eq(1)
         end
-        
-        it "returns the min value without considering values set as missing" do
-          expect(@dv_with_missing.min).to eq(1)
-        end
-        
-        it "returns nil when all values are set missing" do
-          expect(@dv_with_all_missing.min).to eq(nil)
-        end          
-      end 
+      end
 
       context "#sum" do
         it "returns the sum" do
           expect(@dv.sum).to eq(2822)
         end
-        
-        it "returns the sum without considering values set as missing" do
-          expect(@dv_with_missing.sum).to eq(3)
-        end
-        
-        it "returns nil when all values are set missing" do
-          expect(@dv_with_all_missing.sum).to eq(nil)
-        end        
       end
 
       context "#product" do
@@ -124,14 +94,6 @@ describe Daru::Vector do
           v = Daru::Vector.new [1, 2, 3, 4, 5], dtype: dtype
           expect(v.product).to eq(120)
         end
-
-        it "returns the product without considering values set as missing" do
-          expect(@dv_with_missing.product).to eq(2)
-        end
-        
-        it "returns nil when all values are set missing" do
-          expect(@dv_with_all_missing.product).to eq(nil)
-        end
       end
 
       context "#median" do
@@ -146,11 +108,11 @@ describe Daru::Vector do
           expect(mode_test_example.mode).to eq(4)
         end
       end
-      
+
       context "#describe" do
         it "generates count, mean, std, min and max of vectors in one shot" do
           expect(@dv.describe.round(2)).to eq(Daru::Vector.new([10.00, 282.20, 274.08, 1.00, 666.00],
-            index: [:count, :mean, :std, :min, :max], 
+            index: [:count, :mean, :std, :min, :max],
             name:  :statistics
           ))
         end
@@ -164,18 +126,22 @@ describe Daru::Vector do
 
       context "#count" do
         it "counts specified element" do
-          @dv.count(323)
+          expect(@dv.count(323)).to eq(1)
         end
 
         it "counts total number of elements" do
           expect(@dv.count).to eq(10)
         end
+
+        it "counts by block provided" do
+          expect(@dv.count{|e| e.to_i.even? }).to eq(4)
+        end
       end
 
       context "#value_counts" do
         it "counts number of unique values in the Vector" do
           vector = Daru::Vector.new(
-            ["America","America","America","America","America", 
+            ["America","America","America","America","America",
               "India","India", "China", "India", "China"])
           expect(vector.value_counts).to eq(
             Daru::Vector.new([5,3,2], index: ["America", "India", "China"]))
@@ -192,6 +158,15 @@ describe Daru::Vector do
         it "calculates mid point percentile" do
           expect(@dv.percentile(50)).to eq(278.5)
         end
+
+        it "calculates linear percentile" do
+          # FIXME: Not enough testing?..
+          expect(@dv.percentile(50, :linear)).to eq(278.5)
+        end
+
+        it "fails on unknown strategy" do
+          expect { @dv.percentile(50, :killemall) }.to raise_error(ArgumentError, /strategy/)
+        end
       end
 
       context "#average_deviation_population" do
@@ -235,7 +210,7 @@ describe Daru::Vector do
     end
   end # ALL DTYPE tests
 
-  # Only Array tests 
+  # Only Array tests
   context "#percentile" do
     it "tests linear percentile strategy" do
       values = Daru::Vector.new [102, 104, 105, 107, 108, 109, 110, 112, 115, 116].shuffle
@@ -257,13 +232,22 @@ describe Daru::Vector do
   context "#frequencies" do
     it "calculates frequencies" do
       vector = Daru::Vector.new([5,5,5,5,5,6,6,7,8,9,10,1,2,3,4,nil,-99,-99])
-      expect(vector.frequencies).to eq({ 
-        1=>1, 2=>1, 3=>1, 4=>1, 5=>5, 
+      expect(vector.frequencies).to eq({
+        1=>1, 2=>1, 3=>1, 4=>1, 5=>5,
         6=>2, 7=>1, 8=>1, 9=>1,10=>1, -99=>2
       })
     end
   end
 
+  context "#freqs" do
+    let(:vector) { Daru::Vector.new([5,5,5,5,5,6,6,7,8,9,10,1,2,3,4,nil,-99,-99]) }
+    subject { vector.freqs }
+    it { is_expected.to eq Daru::Vector.new(
+      [5,2,1,1,1,1,1,1,1,1,2],
+      index: [5,6,7,8,9,10,1,2,3,4,-99]
+    )}
+  end
+
   context "#ranked" do
     it "curates by rank" do
       vector = Daru::Vector.new([nil, 0.8, 1.2, 1.2, 2.3, 18, nil])
@@ -350,11 +334,11 @@ describe Daru::Vector do
       )
     end
   end
-  
+
   context "#sample_with_replacement" do
     it "calculates sample_with_replacement" do
       vec =  Daru::Vector.new(
-        [5, 5, 5, 5, 5, 6, 6, 7, 8, 9, 10, 1, 2, 3, 4, nil, -99, -99], 
+        [5, 5, 5, 5, 5, 6, 6, 7, 8, 9, 10, 1, 2, 3, 4, nil, -99, -99],
         name: :common_all_dtypes)
       srand(1)
       expect(vec.sample_with_replacement(100).size).to eq(100)
@@ -367,19 +351,19 @@ describe Daru::Vector do
   context "#sample_without_replacement" do
     it "calculates sample_without_replacement" do
       vec =  Daru::Vector.new(
-        [5, 5, 5, 5, 5, 6, 6, 7, 8, 9, 10, 1, 2, 3, 4, nil, -99, -99], 
+        [5, 5, 5, 5, 5, 6, 6, 7, 8, 9, 10, 1, 2, 3, 4, nil, -99, -99],
         name: :common_all_dtypes)
 
       srand(1)
       expect(vec.sample_without_replacement(17).sort).to eq(
-        vec.only_valid.to_a.sort)
+        vec.reject_values(*Daru::MISSING_VALUES).to_a.sort)
       expect {
         vec.sample_without_replacement(20)
       }.to raise_error(ArgumentError)
 
       srand(1)
       expect(vec.sample_without_replacement(17).sort).to eq(
-        vec.only_valid.to_a.sort)
+        vec.reject_values(*Daru::MISSING_VALUES).to_a.sort)
     end
   end
 
@@ -408,7 +392,7 @@ describe Daru::Vector do
     it "jack knife correctly with k > 1" do
       rng = Distribution::Normal.rng(0,1)
       a   = Daru::Vector.new_with_size(6) { rng.call}
-      
+
       ds = a.jackknife(:mean, 2)
       mean = a.mean
       exp = Daru::Vector.new [3 * mean - 2 * (a[2] + a[3] + a[4] + a[5]) / 4, 3 * mean - 2 * (a[0] + a[1] + a[4] + a[5]) / 4, 3 * mean - 2 * (a[0] + a[1] + a[2] + a[3]) / 4]
@@ -434,7 +418,7 @@ describe Daru::Vector do
       expect(acf[3]).to be_within(0.001) .of(0.486)
     end
   end
-  
+
   context "#percent_change" do
     it "calculates percent change" do
       vector = Daru::Vector.new([4,6,6,8,10],index: ['a','f','t','i','k'])
@@ -473,7 +457,7 @@ describe Daru::Vector do
 
       expect(ma5[-1]).to be_within(0.001).of(16.642)
       expect(ma5[-10]).to be_within(0.001).of(17.434)
-      expect(ma5[-15]).to be_within(0.001).of(17.74)      
+      expect(ma5[-15]).to be_within(0.001).of(17.74)
     end
 
     it "calculates rolling median" do
@@ -630,5 +614,11 @@ describe Daru::Vector do
       expect(vector.cumsum).to eq(
         Daru::Vector.new([1,3,6,10,15,21,28,36,45,55]))
     end
+
+    it "works with missing values" do
+      vector = Daru::Vector.new([1,2,nil,3,nil,4,5])
+      expect(vector.cumsum).to eq(
+        Daru::Vector.new([1,3,nil,6,nil,10,15]))
+    end
   end
-end 
+end

data/spec/monkeys_spec.rb

@@ -1,13 +1,4 @@
-require 'spec_helper.rb'
-
 describe "Monkeys" do
-  context Array do
-    it "#recode_repeated" do
-      expect([1,'a',1,'a','b',:c,2].recode_repeated).to eq(
-        ['1_1','a_1', '1_2','a_2','b',:c,2])
-    end
-  end
-
   context Matrix do
     it "performs elementwise division" do
       left  = Matrix[[3,6,9],[4,8,12],[2,4,6]]
@@ -16,4 +7,36 @@ describe "Monkeys" do
       expect(left.elementwise_division(right)).to eq(Matrix[[1,1,1],[1,1,1],[1,1,1]])
     end
   end
+
+  describe '#daru_vector' do
+    it 'converts Array' do
+      expect([1,2,3].daru_vector).to eq Daru::Vector.new [1,2,3]
+      expect([1,2,3].daru_vector('test', [:a, :b, :c])).to eq \
+        Daru::Vector.new [1,2,3], name: 'test', index: [:a, :b, :c]
+    end
+
+    it 'converts Range' do
+      expect((1..3).daru_vector).to eq Daru::Vector.new [1,2,3]
+      expect((1..3).daru_vector('test', [:a, :b, :c])).to eq \
+        Daru::Vector.new [1,2,3], name: 'test', index: [:a, :b, :c]
+    end
+
+    it 'converts Hash' do
+      # FIXME: is it most useful way of converting hashes?..
+      # I'd prefer something like
+      #   expect({a: 1, b: 2, c: 3}.daru_vector('test')).to eq Daru::Vector.new [1,2,3], name: 'test', index: [:a, :b, :c]
+      #
+      expect({test: [1, 2, 3]}.daru_vector).to eq Daru::Vector.new [1,2,3], name: :test
+    end
+  end
+
+  describe '#to_index' do
+    it 'converts Array' do
+      expect([1,2,3].to_index).to eq Daru::Index.new [1,2,3]
+    end
+
+    it 'converts Range' do
+      expect((1..3).to_index).to eq Daru::Index.new [1,2,3]
+    end
+  end
 end

data/spec/plotting/dataframe_spec.rb

@@ -0,0 +1,386 @@
+require 'spec_helper.rb'
+
+class Nyaplot::DataFrame
+  # Because it does not allow to any equality testing
+  def == other
+    other.is_a?(Nyaplot::DataFrame) && rows == other.rows
+  end
+end
+
+# FIXME: just guessed specs logic from code. As far as I can understand,
+# it can be broken in number of ways with incorrect arguments.
+#
+describe Daru::DataFrame, 'plotting' do
+  let(:data_frame) {
+    described_class.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') }
+  let(:diagram) { instance_double('Nyaplot::Diagram') }
+
+  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(plot).to receive(:show).ordered
+      data_frame.plot(type: :box)
+    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(plot).to receive(:show).ordered
+        data_frame.plot(type: :scatter, x: :x, y: :y1)
+      end
+
+      it 'works without :y provided' do
+        expect(plot).to receive(:add_with_df)
+          .with(data_frame.to_nyaplotdf, :scatter, :x)
+          .ordered
+
+        expect(plot).to receive(:show).ordered
+        data_frame.plot(type: :scatter, x: :x)
+      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(plot).to receive(:show).ordered
+
+        data_frame.plot(type: :scatter, x: [:x, :x], y: [:y1, :y2])
+      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(plot).to receive(:show).ordered
+
+        data_frame.plot(type: [:scatter, :line], x: [:x, :x], y: [:y1, :y2])
+      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(plot).to receive(:show).ordered
+
+        data_frame.plot(
+          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
+        )
+      end
+    end
+  end
+end
+
+describe Daru::DataFrame, 'category plotting' 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
+      expect(plot).to receive :show
+      df.plot(type: :scatter, x: :a, y: :b, categorized: {by: :c, method: :color}) 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(plot).to receive :show
+      df.plot(type: :scatter, x: :a, y: :b,
+        categorized: {by: :c, method: :color})
+    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(plot).to receive :show
+      df.plot(type: :scatter, x: :a, y: :b,
+        categorized: {by: :c, method: :color, color: [:red, :blue, :green]})
+    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(plot).to receive :show
+      df.plot(type: :scatter, x: :a, y: :b,
+        categorized: {by: :c, method: :shape})
+    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(plot).to receive :show
+      df.plot(type: :scatter, x: :a, y: :b,
+        categorized: {by: :c, method: :shape, shape: %w(circle triangle-up diamond)})
+    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(plot).to receive :show
+      df.plot(type: :scatter, x: :a, y: :b,
+        categorized: {by: :c, method: :size})
+    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(plot).to receive :show
+      df.plot(type: :scatter, x: :a, y: :b,
+        categorized: {by: :c, method: :size, size: [100, 200, 300]})
+    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
+      expect(plot).to receive :show
+      df.plot(type: :line, x: :a, y: :b, categorized: {by: :c, method: :color}) 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(plot).to receive :show
+      df.plot(type: :line, x: :a, y: :b, categorized: {by: :c, method: :color})
+    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(plot).to receive :show
+      df.plot(type: :line, x: :a, y: :b,
+        categorized: {by: :c, method: :color, color: [:red, :blue, :green]})
+    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(plot).to receive :show
+      df.plot(type: :line, x: :a, y: :b, categorized: {by: :c, method: :stroke_width})
+    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(plot).to receive :show
+      df.plot(type: :line, x: :a, y: :b,
+        categorized: {by: :c, method: :stroke_width, stroke_width: [100, 200, 300]})
+    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 { df.plot(type: :box, categorized: {by: :c, method: :color}) }.to raise_error ArgumentError }
+  end
+end
+
+describe Daru::DataFrame, 'plotting dataframe using gruff' do
+  before { Daru.plotting_library = :gruff }
+  let(:df) do
+    Daru::DataFrame.new({
+      a: [1, 3, 5, 2, 5, 0],
+      b: [1, 5, 2, 5, 1, 0],
+      c: [1, 6, 7, 2, 6, 0]
+    }, index: 'a'..'f')
+  end
+
+  context 'bar' do
+    let(:plot) { instance_double 'Gruff::Bar' }
+    before { allow(Gruff::Bar).to receive(:new).and_return(plot) }
+    it 'plots bar graph' do
+      expect(plot).to receive :labels=
+      expect(plot).to receive(:data).exactly(3).times
+      df.plot type: :bar
+    end
+    
+    it 'plots bar graph with block' do
+      expect(plot).to receive :labels=
+      expect(plot).to receive(:data).exactly(3).times
+      expect(plot).to receive :title=
+      df.plot(type: :bar) { |p| p.title = 'hello' }
+    end
+
+    it 'plots with specified columns' do
+      expect(plot).to receive :labels=
+      expect(plot).to receive(:data).exactly(2).times
+      df.plot type: :bar, y: [:a, :b]
+    end
+  end
+
+  context 'line' do
+    let(:plot) { instance_double 'Gruff::Line' }
+    before { allow(Gruff::Line).to receive(:new).and_return(plot) }
+    it 'plots line graph' do
+      expect(plot).to receive :labels=
+      expect(plot).to receive(:data).exactly(3).times
+      df.plot type: :line
+    end
+  end
+
+  context 'scatter' do
+    let(:plot) { instance_double 'Gruff::Scatter' }
+    before { allow(Gruff::Scatter).to receive(:new).and_return(plot) }
+    it 'plots scatter graph' do
+      expect(plot).to receive(:data).exactly(3).times
+      df.plot type: :scatter
+    end
+
+    it 'plots with specified columns' do
+      expect(plot).to receive(:data).exactly(1).times
+      df.plot type: :scatter, x: :c, y: :a
+    end
+  end
+  
+  context 'invalid type' do
+    it { expect { df.plot type: :lol }.to raise_error ArgumentError }
+  end
+end
+
+describe Daru::DataFrame, 'dataframe category plotting with gruff' do
+  before { Daru.plotting_library = :gruff }
+  let(:df) do
+    Daru::DataFrame.new({
+      a: [1, 3, 5, 2, 5, 0],
+      b: [1, 5, 2, 5, 1, 0],
+      c: [:a, :b, :a, :a, :b, :a]
+    }, index: 'a'..'f')
+  end
+  before { df.to_category :c }
+  
+  context 'scatter' do
+    let(:plot) { instance_double 'Gruff::Scatter' }
+    before { allow(Gruff::Scatter).to receive(:new).and_return(plot) }    
+    it 'plots scatter plot categorized by category vector' do
+      expect(plot).to receive(:data).exactly(2).times
+      df.plot type: :scatter, x: :a, y: :b, categorized: { by: :c }
+    end
+  end
+end