daru_lite 0.1

data/spec/core/merge_spec.rb

@@ -0,0 +1,179 @@
+describe DaruLite::DataFrame do
+  context "#join" do
+    before do
+      @left = DaruLite::DataFrame.new({
+        :id   => [1,2,3,4],
+        :name => ['Pirate', 'Monkey', 'Ninja', 'Spaghetti']
+      })
+      @right = DaruLite::DataFrame.new({
+        :id => [1,2,3,4],
+        :name => ['Rutabaga', 'Pirate', 'Darth Vader', 'Ninja']
+      })
+      @right_many = DaruLite::DataFrame.new({
+        :id => [1,1,1,1],
+        :name => ['Rutabaga', 'Pirate', 'Darth Vader', 'Ninja']
+      })
+      @empty = DaruLite::DataFrame.new({
+        :id => [],
+        :name => []
+      })
+    end
+
+    it "performs an inner join of two dataframes" do
+      answer = DaruLite::DataFrame.new({
+        :id_1   => [3,1],
+        :name => ['Ninja', 'Pirate'],
+        :id_2   => [4,2]
+      }, order: [:id_1, :name, :id_2])
+      expect(@left.join(@right, how: :inner, on: [:name])).to eq(answer)
+    end
+
+    it "performs an inner join of two dataframes that has one to many mapping" do
+      answer = DaruLite::DataFrame.new({
+        :name_1 => ['Pirate', 'Pirate', 'Pirate', 'Pirate'],
+        :id => [1,1,1,1],
+        :name_2 => ['Rutabaga', 'Pirate', 'Darth Vader', 'Ninja']
+      }, order: [:name_1, :id, :name_2])
+      expect(@left.join(@right_many, how: :inner, on: [:id])).to eq(answer)
+    end
+
+    it "performs an inner join of two dataframes that has many to one mapping" do
+      left_many = @right_many
+      right = @left
+
+      answer = DaruLite::DataFrame.new({
+        :name_2 => ['Pirate', 'Pirate', 'Pirate', 'Pirate'],
+        :id => [1,1,1,1],
+        :name_1 => ['Rutabaga', 'Pirate', 'Darth Vader', 'Ninja']
+      }, order: [:name_1, :id, :name_2])
+      expect(left_many.join(right, how: :inner, on: [:id])).to eq(answer)
+    end
+
+    it "performs an inner join of two dataframes that has many to many mapping" do
+      @left[:id].recode! { |v| v == 2 ? 1 : v }
+      answer = DaruLite::DataFrame.new({
+        :name_1 => ['Pirate', 'Pirate', 'Pirate', 'Pirate', 'Monkey', 'Monkey', 'Monkey', 'Monkey'],
+        :id => [1,1,1,1,1,1,1,1],
+        :name_2 => ['Rutabaga', 'Pirate', 'Darth Vader', 'Ninja', 'Rutabaga', 'Pirate', 'Darth Vader', 'Ninja']
+      }, order: [:name_1, :id, :name_2])
+      expect(@left.join(@right_many, how: :inner, on: [:id])).to eq(answer)
+    end
+
+    it "performs a full outer join" do
+      answer = DaruLite::DataFrame.new({
+        :id_1 => [nil,2,3,1,nil,4],
+        :name => ["Darth Vader", "Monkey", "Ninja", "Pirate", "Rutabaga", "Spaghetti"],
+        :id_2 => [3,nil,4,2,1,nil]
+      }, order: [:id_1, :name, :id_2])
+      expect(@left.join(@right, how: :outer, on: [:name])).to eq(answer)
+    end
+
+    it "adds a left/right indicator" do
+      answer = DaruLite::DataFrame.new({
+        :id_1 => [nil,2,3,1,nil,4],
+        :name => ["Darth Vader", "Monkey", "Ninja", "Pirate", "Rutabaga", "Spaghetti"],
+        :id_2 => [3,nil,4,2,1,nil]
+      }, order: [:id_1, :name, :id_2])
+
+      outer = @left.join(@right, how: :outer, on: [:name], indicator: :my_indicator)
+      expect(outer[:my_indicator].to_a).to eq [:right_only, :left_only, :both, :both, :right_only, :left_only]
+    end
+
+
+    it "performs a full outer join when the right join keys have nils" do
+      @right[:name].recode! { |v| v == 'Rutabaga' ? nil : v }
+      answer = DaruLite::DataFrame.new({
+        :id_1 => [nil, nil,2,3,1,4],
+        :name => [nil, "Darth Vader", "Monkey", "Ninja", "Pirate", "Spaghetti"],
+        :id_2 => [1,3,nil,4,2,nil]
+      }, order: [:id_1, :name, :id_2])
+      expect(@left.join(@right, how: :outer, on: [:name])).to eq(answer)
+    end
+
+    it "performs a full outer join when the left join keys have nils" do
+      @left[:name].recode! { |v| v == 'Monkey' ? nil : v }
+      answer = DaruLite::DataFrame.new({
+        :id_1 => [2,nil,3,1,nil,4],
+        :name => [nil, "Darth Vader", "Ninja", "Pirate", "Rutabaga", "Spaghetti"],
+        :id_2 => [nil,3,4,2,1,nil]
+      }, order: [:id_1, :name, :id_2])
+      expect(@left.join(@right, how: :outer, on: [:name])).to eq(answer)
+    end
+
+    it "performs a full outer join when both left and right join keys have nils" do
+      @left[:name].recode! { |v| v == 'Monkey' ? nil : v }
+      @right[:name].recode! { |v| v == 'Rutabaga' ? nil : v }
+
+      answer = DaruLite::DataFrame.new({
+        :id_1 => [nil,2,nil,3,1,4],
+        :name => [nil, nil, "Darth Vader", "Ninja", "Pirate", "Spaghetti"],
+        :id_2 => [1,nil,3,4,2,nil]
+      }, order: [:id_1, :name, :id_2])
+      expect(@left.join(@right, how: :outer, on: [:name])).to eq(answer)
+    end
+
+    it "performs a left outer join" do
+      answer = DaruLite::DataFrame.new({
+        :id_1 => [2,3,1,4],
+        :name => ["Monkey", "Ninja", "Pirate", "Spaghetti"],
+        :id_2 => [nil,4,2,nil]
+      }, order: [:id_1, :name, :id_2])
+      expect(@left.join(@right, how: :left, on: [:name])).to eq(answer)
+    end
+
+    it "performs a left join with an empty dataframe" do
+
+      answer = DaruLite::DataFrame.new({
+        :id_1 => [2,3,1,4],
+        :name => ["Monkey", "Ninja", "Pirate", "Spaghetti"],
+        :id_2 => [nil,nil,nil,nil]
+      }, order: [:id_1, :name, :id_2])
+
+      expect(@left.join(@empty, how: :left, on: [:name])).to eq(answer)
+    end
+
+    it "performs a right outer join" do
+      answer = DaruLite::DataFrame.new({
+        :id_1 => [nil,3,1,nil],
+        :name => ["Darth Vader", "Ninja", "Pirate", "Rutabaga"],
+        :id_2 => [3,4,2,1]
+      }, order: [:id_1, :name, :id_2])
+      expect(@left.join(@right, how: :right, on: [:name])).to eq(answer)
+    end
+
+    it "doesn't convert false into nil when joining boolean values" do
+      left = DaruLite::DataFrame.new({ key: [1,2,3], left_value: [true, false, true] })
+      right = DaruLite::DataFrame.new({ key: [1,2,3], right_value: [true, false, true] })
+
+      answer = DaruLite::DataFrame.new({
+        left_value: [true, false, true],
+        key: [1,2,3],
+        right_value: [true, false, true]
+      }, order: [:left_value, :key, :right_value] )
+
+      expect(left.join(right, on: [:key], how: :inner)).to eq answer
+    end
+
+    it "raises if :on field are absent in one of dataframes" do
+      @right.vectors = DaruLite::Index.new [:id, :other_name]
+      expect { @left.join(@right, how: :right, on: [:name]) }.to \
+        raise_error(ArgumentError, /Both dataframes expected .* :name/)
+
+      expect { @left.join(@right, how: :right, on: [:other_name]) }.to \
+        raise_error(ArgumentError, /Both dataframes expected .* :other_name/)
+    end
+
+    it "is able to join by several :on fields" do
+      @left.gender = ['m', 'f', 'm', nil]
+      @right.gender = ['m', 'm', nil, 'f']
+
+      answer = DaruLite::DataFrame.new({
+        id_1: [1],
+        name: ['Pirate'],
+        gender: ['m'],
+        id_2: [2]
+      }, order: [:id_1, :name, :gender, :id_2])
+      expect(@left.join(@right, how: :inner, on: [:name, :gender])).to eq(answer)
+    end
+  end
+end

data/spec/core/query_spec.rb

@@ -0,0 +1,347 @@
+describe DaruLite::Core::Query::BoolArray do
+  before do
+    @klass = DaruLite::Core::Query::BoolArray
+    @left = @klass.new([true, true, true, false, false, true])
+    @right = @klass.new([false, false, false, false, true, false])
+  end
+
+  context "#&" do
+    it "computes and logic of each element in the array" do
+      expect(@left & @right).to eq(
+        @klass.new([false, false, false, false, false, false]))
+    end
+  end
+
+  context "#|" do
+    it "computes or logic of each element in arrays" do
+      expect(@left | @right).to eq(
+        @klass.new([true, true, true, false, true, true]))
+    end
+  end
+
+  context "#!" do
+    it "computes not logic of each element" do
+      expect(!@left).to eq(
+        @klass.new([false, false, false, true, true, false])
+        )
+    end
+  end
+
+  context '#inspect' do
+    it 'is reasonable' do
+      expect(@left.inspect).to eq "#<DaruLite::Core::Query::BoolArray:#{@left.object_id} bool_arry=[true, true, true, false, false, true]>"
+    end
+  end
+end
+
+describe "Arel-like syntax" do
+  describe "comparison operators" do
+    describe DaruLite::Vector do
+      describe "non-categorical type" do
+        before do
+          @vector = DaruLite::Vector.new([23,51,1214,352,32,11])
+          @comparator = DaruLite::Vector.new([45,22,1214,55,32,9])
+          @klass = DaruLite::Core::Query::BoolArray
+        end
+
+        context "#eq" do
+          it "accepts scalar value" do
+            expect(@vector.eq(352)).to eq(
+              @klass.new([false,false,false,true,false,false]))
+          end
+
+          it "accepts vector and compares corrensponding elements" do
+            expect(@vector.eq(@comparator)).to eq(
+              @klass.new([false,false,true,false,true,false]))
+          end
+        end
+
+        context "#not_eq" do
+          it "accepts scalar value" do
+            expect(@vector.not_eq(51)).to eq(
+              @klass.new([true, false, true, true, true, true]))
+          end
+
+          it "accepts vector and compares corrensponding elements" do
+            expect(@vector.not_eq(@comparator)).to eq(
+              @klass.new([true, true, false, true, false, true]))
+          end
+        end
+
+        context "#lt" do
+          it "accepts scalar value" do
+            expect(@vector.lt(51)).to eq(
+              @klass.new([true, false, false, false, true, true]))
+          end
+
+          it "accepts vector and compares corrensponding elements" do
+            expect(@vector.lt(@comparator)).to eq(
+              @klass.new([true,false,false,false,false,false]))
+          end
+        end
+
+        context "#lteq" do
+          it "accepts scalar value" do
+            expect(@vector.lteq(51)).to eq(
+              @klass.new([true, true, false, false, true, true]))
+          end
+
+          it "accepts vector and compares corrensponding elements" do
+            expect(@vector.lteq(@comparator)).to eq(
+              @klass.new([true,false,true,false,true,false]))
+          end
+        end
+
+        context "#mt" do
+          it "accepts scalar value" do
+            expect(@vector.mt(51)).to eq(
+              @klass.new([false, false, true, true, false, false]))
+          end
+
+          it "accepts vector and compares corrensponding elements" do
+            expect(@vector.mt(@comparator)).to eq(
+              @klass.new([false,true,false,true,false,true]))
+          end
+        end
+
+        context "#mteq" do
+          it "accepts scalar value" do
+            expect(@vector.mteq(51)).to eq(
+              @klass.new([false, true, true, true, false, false]))
+          end
+
+          it "accepts vector and compares corrensponding elements" do
+            expect(@vector.mteq(@comparator)).to eq(
+              @klass.new([false,true,true,true,true,true]))
+          end
+        end
+
+        context "#in" do
+          it "checks if any of elements in the arg are present in the vector" do
+            expect(@vector.in([23,55,1,33,32])).to eq(
+              @klass.new([true, false, false, false, true, false]))
+          end
+        end
+      end
+
+      describe "categorical type" do
+        let(:dv) { DaruLite::Vector.new ['e', 'd', 'd', 'x', 'x'],
+          categories: ['a', 'x', 'c', 'd', 'e'], type: :category }
+        let(:comp) { DaruLite::Vector.new ['a', 'd', 'x', 'e', 'x'],
+          categories: ['a', 'x', 'c', 'd', 'e'], type: :category }
+        let(:query_bool_class) { DaruLite::Core::Query::BoolArray }
+
+        context "#eq" do
+          context "scalar" do
+            subject { dv.eq 'd' }
+
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [false, true, true, false, false] }
+          end
+
+          context "vector" do
+            subject { dv.eq comp }
+
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [false, true, false, false, true] }
+          end
+        end
+
+        context "#not_eq" do
+          context "scalar" do
+            subject { dv.not_eq 'd' }
+
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [true, false, false, true, true] }
+          end
+
+          context "vector" do
+            subject { dv.not_eq comp }
+
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [true, false, true, true, false] }
+          end
+        end
+
+        context "#lt" do
+          context "scalar" do
+            subject { dv.lt 'd' }
+
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [false, false, false, true, true] }
+          end
+
+          context "vector" do
+            subject { dv.lt comp }
+
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [false, false, false, true, false] }
+          end
+        end
+
+        context "#lteq" do
+          context "scalar" do
+            subject { dv.lteq 'd' }
+
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [false, true, true, true, true] }
+          end
+
+          context "vector" do
+            subject { dv.lteq comp }
+
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [false, true, false, true, true] }
+          end
+        end
+
+        context "#mt" do
+          context "scalar" do
+            subject { dv.mt 'd' }
+
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [true, false, false, false, false] }
+          end
+
+          context "vector" do
+            subject { dv.mt comp }
+
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [true, false, true, false, false] }
+          end
+        end
+
+        context "#mteq" do
+          context "scalar" do
+            subject { dv.mteq 'd' }
+
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [true, true, true, false, false] }
+          end
+
+          context "vector" do
+            subject { dv.mteq comp }
+
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [true, true, true, false, true] }
+          end
+        end
+
+        # context "#in" do
+        #   subject { dv.in ['b', 'd'] }
+        #   it { is_expected.to be_a query_bool_class }
+        #   its(:to_a) { is_expected.to eq [false, true, true, true, true] }
+        # end
+      end
+    end
+  end
+
+  describe "where clause" do
+    context DaruLite::DataFrame do
+      before do
+        @df = DaruLite::DataFrame.new({
+          number: [1,2,3,4,5,6,Float::NAN],
+          sym: [:one, :two, :three, :four, :five, :six, :seven],
+          names: ['sameer', 'john', 'james', 'omisha', 'priyanka', 'shravan',nil]
+        })
+      end
+
+      it "accepts simple single eq statement" do
+        answer = DaruLite::DataFrame.new({
+          number: [4],
+          sym: [:four],
+          names: ['omisha']
+          }, index: DaruLite::Index.new([3])
+        )
+        expect(@df.where(@df[:number].eq(4))).to eq(answer)
+      end
+
+      it "accepts somewhat complex comparison operator chaining" do
+        answer = DaruLite::DataFrame.new({
+          number: [3,4],
+          sym: [:three, :four],
+          names: ['james', 'omisha']
+        }, index: DaruLite::Index.new([2,3]))
+        expect(
+          @df.where (@df[:names].eq('james') | @df[:sym].eq(:four))
+          ).to eq(answer)
+      end
+
+      let(:dv) { DaruLite::Vector.new([1,11,32,Float::NAN,nil]) }
+      it "handles empty data" do
+        expect(dv.where(dv.lt(14))).to eq(DaruLite::Vector.new([1,11]))
+      end
+
+      it "does not give SystemStackError" do
+        v = DaruLite::Vector.new [1]*300_000
+        expect { v.where v.eq(1) }.not_to raise_error
+      end
+    end
+
+    context DaruLite::Vector do
+      context "non-categorical type" do
+        before do
+          @vector = DaruLite::Vector.new([2,5,1,22,51,4,nil,Float::NAN])
+        end
+
+        it "accepts a simple single statement" do
+          expect(@vector.where(@vector.lt(10))).to eq(
+            DaruLite::Vector.new([2,5,1,4], index: DaruLite::Index.new([0,1,2,5])))
+        end
+
+        it "accepts somewhat complex operator chaining" do
+          expect(@vector.where((@vector.lt(6) | @vector.eq(51)))).to eq(
+            DaruLite::Vector.new([2,5,1,51,4], index: DaruLite::Index.new([0,1,2,4,5])))
+        end
+      end
+
+      context "categorical type" do
+        let(:dv) { DaruLite::Vector.new ['a', 'c', 'x', 'x', 'c'],
+          categories: ['a', 'x', 'c'], type: :category }
+
+        context "simple single statement" do
+          subject { dv.where(dv.lt('x')) }
+
+          it { is_expected.to be_a DaruLite::Vector }
+          its(:type) { is_expected.to eq :category }
+          its(:to_a) { is_expected.to eq ['a'] }
+          its(:'index.to_a') { is_expected.to eq [0] }
+        end
+
+        context "complex operator chaining" do
+          subject { dv.where((dv.lt('x') | dv.eq('c'))) }
+
+          it { is_expected.to be_a DaruLite::Vector }
+          its(:type) { is_expected.to eq :category }
+          its(:to_a) { is_expected.to eq ['a', 'c', 'c'] }
+          its(:'index.to_a') { is_expected.to eq [0, 1, 4] }
+        end
+
+        context "preserve categories" do
+          subject { dv.where((dv.lt('x') | dv.eq('c'))) }
+
+          it { is_expected.to be_a DaruLite::Vector }
+          its(:type) { is_expected.to eq :category }
+          its(:to_a) { is_expected.to eq ['a', 'c', 'c'] }
+          its(:'index.to_a') { is_expected.to eq [0, 1, 4] }
+          its(:categories) { is_expected.to eq ['a', 'x', 'c'] }
+        end
+      end
+
+      it "preserves name" do
+        named_vector = DaruLite::Vector.new([1,2,3], name: 'named')
+        expect(named_vector.where(named_vector.lteq(2)).name).to eq('named')
+      end
+    end
+  end
+
+  describe "apply_where" do
+    context "matches regexp with block input" do
+      subject { dv.apply_where(dv.match /weeks/) { |x| "#{x.split.first.to_i * 7} days" } }
+
+      let(:dv) { DaruLite::Vector.new ['3 days', '5 weeks', '2 weeks'] }
+
+      it { is_expected.to eq(DaruLite::Vector.new ['3 days', '35 days', '14 days']) }
+    end
+  end
+end

data/spec/daru_lite_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe '#error' do
+  context 'by default' do
+    it { expect { DaruLite.error('test') }.to output("test\n").to_stderr_from_any_process }
+  end
+
+  context 'when set to nil' do
+    before { DaruLite.error_stream = nil }
+    it { expect { DaruLite.error('test') }.not_to output('test').to_stderr_from_any_process }
+  end
+
+  context 'when set to instance of custom class' do
+    let(:custom_stream) { double(puts: nil) }
+    before { DaruLite.error_stream = custom_stream }
+
+    it 'calls puts' do
+      expect { DaruLite.error('test') }.not_to output('test').to_stderr_from_any_process
+      expect(custom_stream).to have_received(:puts).with('test')
+    end
+  end
+end