daru_lite 0.1.2 → 0.2.0

data/lib/daru_lite/io/sql_data_source.rb

@@ -16,24 +16,6 @@ module DaruLite
         end
       end
 
-      # Private adapter class for DBI::DatabaseHandle
-      # @private
-      class DbiAdapter < Adapter
-        private
-
-        def column_names
-          result.column_names
-        end
-
-        def rows
-          result.to_a.map(&:to_a)
-        end
-
-        def result
-          @result ||= @conn.execute(@query)
-        end
-      end
-
       # Private adapter class for connections of ActiveRecord
       # @private
       class ActiveRecordConnectionAdapter < Adapter
@@ -52,7 +34,6 @@ module DaruLite
         end
       end
 
-      private_constant :DbiAdapter
       private_constant :ActiveRecordConnectionAdapter
 
       def self.make_dataframe(db, query)
@@ -76,8 +57,6 @@ module DaruLite
         db = attempt_sqlite3_connection(db) if db.is_a?(String) && Pathname(db).exist?
 
         case db
-        when DBI::DatabaseHandle
-          DbiAdapter.new(db, query)
         when ActiveRecord::ConnectionAdapters::AbstractAdapter
           ActiveRecordConnectionAdapter.new(db, query)
         else
@@ -86,11 +65,15 @@ module DaruLite
       end
 
       def attempt_sqlite3_connection(db)
-        DBI.connect("DBI:SQLite3:#{db}")
-      rescue SQLite3::NotADatabaseException
+        ActiveRecord::Base.establish_connection(
+          adapter: 'sqlite3',
+          database: db
+        )
+        ActiveRecord::Base.connection.tap(&:verify!)
+      rescue ActiveRecord::StatementInvalid
         raise ArgumentError, "Expected #{db} to point to a SQLite3 database"
       rescue NameError
-        raise NameError, "In order to establish a connection to #{db}, please require 'dbi'"
+        raise NameError, "In order to establish a connection to #{db}, please require 'ActiveRecord'"
       end
     end
   end

data/lib/daru_lite/maths/statistics/dataframe.rb

@@ -165,10 +165,10 @@ module DaruLite
 
         private
 
-        def apply_method_to_numerics(method, *args)
+        def apply_method_to_numerics(method, *)
           numerics = @vectors.to_a.map { |n| [n, @data[@vectors[n]]] }
                              .select { |_n, v| v.numeric? }
-          computed = numerics.map { |_n, v| v.send(method, *args) }
+          computed = numerics.map { |_n, v| v.send(method, *) }
 
           DaruLite::DataFrame.new(computed, index: @index, order: numerics.map(&:first), clone: false)
         end

data/lib/daru_lite/maths/statistics/vector.rb

@@ -89,8 +89,8 @@ module DaruLite
           #
           #   dv.max(2) { |a,b| a.size <=> b.size }
           #   #=> ["Jon Starkgaryen","Daenerys"]
-          def max(size = nil, &block)
-            reject_values(*DaruLite::MISSING_VALUES).to_a.max(size, &block)
+          def max(size = nil, &)
+            reject_values(*DaruLite::MISSING_VALUES).to_a.max(size, &)
           end
 
           # Returns the maximum value(s) present in the vector, with a compulsory object block.
@@ -134,8 +134,8 @@ module DaruLite
           #
           #   dv.min(2) { |a,b| a.size <=> b.size }
           #   #=> ["Tyrion","Daenerys"]
-          def min(size = nil, &block)
-            reject_values(*DaruLite::MISSING_VALUES).to_a.min(size, &block)
+          def min(size = nil, &)
+            reject_values(*DaruLite::MISSING_VALUES).to_a.min(size, &)
           end
 
           # Returns the minimum value(s) present in the vector, with a compulsory object block.
@@ -179,9 +179,9 @@ module DaruLite
           #
           #   dv.max(2) { |a,b| a.size <=> b.size }
           #   #=> ["Jon Starkgaryen","Daenerys"]
-          def max(size = nil, &block)
+          def max(size = nil, &)
             range = size.nil? ? 0 : (0..size - 1)
-            reject_values(*DaruLite::MISSING_VALUES).to_a.sort(&block).reverse[range]
+            reject_values(*DaruLite::MISSING_VALUES).to_a.sort(&).reverse[range]
           end
 
           # Returns the maximum value(s) present in the vector, with a compulsory object block.
@@ -225,9 +225,9 @@ module DaruLite
           #
           #   dv.min(2) { |a,b| a.size <=> b.size }
           #   #=> ["Tyrion","Daenerys"]
-          def min(size = nil, &block)
+          def min(size = nil, &)
             range = size.nil? ? 0 : (0..size - 1)
-            reject_values(*DaruLite::MISSING_VALUES).to_a.sort(&block)[range]
+            reject_values(*DaruLite::MISSING_VALUES).to_a.sort(&)[range]
           end
 
           # Returns the minimum value(s) present in the vector, with a compulsory object block.
@@ -276,8 +276,8 @@ module DaruLite
         #
         #   dv.index_of_max(2) { |a,b| a.size <=> b.size }
         #   #=> [:j, :d]
-        def index_of_max(size = nil, &block)
-          vals = max(size, &block)
+        def index_of_max(size = nil, &)
+          vals = max(size, &)
           dv   = reject_values(*DaruLite::MISSING_VALUES)
           vals.is_a?(Array) ? (vals.map { |x| dv.index_of(x) }) : dv.index_of(vals)
         end
@@ -299,8 +299,8 @@ module DaruLite
         #
         #   dv.index_of_max_by(2) { |i| i.size }
         #   #=> [:j, :d]
-        def index_of_max_by(size = nil, &block)
-          vals = max_by(size, &block)
+        def index_of_max_by(size = nil, &)
+          vals = max_by(size, &)
           dv   = reject_values(*DaruLite::MISSING_VALUES)
           vals.is_a?(Array) ? (vals.map { |x| dv.index_of(x) }) : dv.index_of(vals)
         end
@@ -325,8 +325,8 @@ module DaruLite
         #
         #   dv.index_of_min(2) { |a,b| a.size <=> b.size }
         #   #=> [:t, :d]
-        def index_of_min(size = nil, &block)
-          vals = min(size, &block)
+        def index_of_min(size = nil, &)
+          vals = min(size, &)
           dv   = reject_values(*DaruLite::MISSING_VALUES)
           vals.is_a?(Array) ? (vals.map { |x| dv.index_of(x) }) : dv.index_of(vals)
         end
@@ -348,8 +348,8 @@ module DaruLite
         #
         #   dv.index_of_min(2) { |i| i.size }
         #   #=> [:t, :d]
-        def index_of_min_by(size = nil, &block)
-          vals = min_by(size, &block)
+        def index_of_min_by(size = nil, &)
+          vals = min_by(size, &)
           dv   = reject_values(*DaruLite::MISSING_VALUES)
           vals.is_a?(Array) ? (vals.map { |x| dv.index_of(x) }) : dv.index_of(vals)
         end

data/lib/daru_lite/vector/aggregatable.rb

@@ -1,8 +1,8 @@
 module DaruLite
   class Vector
     module Aggregatable
-      def group_by(*args)
-        to_df.group_by(*args)
+      def group_by(*)
+        to_df.group_by(*)
       end
     end
   end

data/lib/daru_lite/vector/filterable.rb

@@ -58,8 +58,8 @@ module DaruLite
       #   #  0   3 days
       #   #  1   35 days
       #   #  2   14 days
-      def apply_where(bool_array, &block)
-        DaruLite::Core::Query.vector_apply_where self, bool_array, &block
+      def apply_where(bool_array, &)
+        DaruLite::Core::Query.vector_apply_where(self, bool_array, &)
       end
 
       # Keep only unique elements of the vector alongwith their indexes.

data/lib/daru_lite/vector/queryable.rb

@@ -17,12 +17,12 @@ module DaruLite
         values.any? { |v| include_with_nan? @data, v }
       end
 
-      def any?(&block)
-        @data.data.any?(&block)
+      def any?(&)
+        @data.data.any?(&)
       end
 
-      def all?(&block)
-        @data.data.all?(&block)
+      def all?(&)
+        @data.data.all?(&)
       end
 
       # Returns an array of either none or integer values, indicating the

data/lib/daru_lite/vector/sortable.rb

@@ -17,10 +17,10 @@ module DaruLite
       #   v = DaruLite::Vector.new ["My first guitar", "jazz", "guitar"]
       #   # Say you want to sort these strings by length.
       #   v.sort(ascending: false) { |a,b| a.length <=> b.length }
-      def sort(opts = {}, &block)
+      def sort(opts = {}, &)
         opts = { ascending: true }.merge(opts)
 
-        vector_index = resort_index(@data.each_with_index, opts, &block)
+        vector_index = resort_index(@data.each_with_index, opts, &)
         vector, index = vector_index.transpose
 
         index = @index.reorder index
@@ -68,8 +68,8 @@ module DaruLite
       # Just sort the data and get an Array in return using Enumerable#sort.
       # Non-destructive.
       # :nocov:
-      def sorted_data(&block)
-        @data.to_a.sort(&block)
+      def sorted_data(&)
+        @data.to_a.sort(&)
       end
       # :nocov:
 

data/lib/daru_lite/vector.rb

@@ -413,7 +413,7 @@ module DaruLite
 
       "#<#{self.class}(#{size})#{':category' if category?}>\n" +
         Formatters::Table.format(
-          to_a.lazy.map { |v| [v] },
+          to_a.lazy.zip,
           headers: @name && [@name],
           row_headers: row_headers,
           threshold: threshold,
@@ -508,7 +508,7 @@ module DaruLite
       DaruLite::DataFrame.new ps
     end
 
-    DATE_REGEXP = /^(\d{2}-\d{2}-\d{4}|\d{4}-\d{2}-\d{2})$/.freeze
+    DATE_REGEXP = /^(\d{2}-\d{2}-\d{4}|\d{4}-\d{2}-\d{2})$/
 
     # Returns the database type for the vector, according to its content
     def db_type
@@ -563,10 +563,8 @@ module DaruLite
       dv
     end
 
-    def method_missing(name, *args, &block)
-      # FIXME: it is shamefully fragile. Should be either made stronger
-      # (string/symbol dychotomy, informative errors) or removed totally. - zverok
-      if name =~ /(.+)=/
+    def method_missing(name, *args, &)
+      if name =~ /^([^=]+)=/
         self[Regexp.last_match(1).to_sym] = args[0]
       elsif has_index?(name)
         self[name]

data/lib/daru_lite/version.rb

@@ -1,3 +1,3 @@
 module DaruLite
-  VERSION = '0.1.2'.freeze
+  VERSION = '0.2.0'.freeze
 end

data/spec/data_frame/filterable_example.rb

@@ -128,8 +128,6 @@ shared_examples_for 'a filterable DataFrame' do
   end
 
   describe "#keep_row_if" do
-    subject { df.keep_row_if { |row| row[:a] % 10 == 0 } }
-
     let(:index) { [:one, :two, :three, :four, :five] }
     let(:order) { [:a, :b, :c] }
     let(:df)  do
@@ -143,33 +141,194 @@ shared_examples_for 'a filterable DataFrame' do
       )
     end
 
-    context DaruLite::Index do
+    shared_examples_for '#keep_row_if' do
+      before { subject }
+
       it "keeps row if block evaluates to true" do
-        subject
-        expect(df).to eq(
+        expect(df).to eq(expected_df)
+      end
+
+      it 'returns correct index' do
+        expect(df.index).to eq(expected_index)
+      end
+
+      it "all vectors have the same index" do
+        expect(df.map(&:index)).to all(eq(expected_index))
+      end
+    end
+
+    context 'a single row is removed' do
+      context DaruLite::Index do
+        subject { df.keep_row_if { |row| row.name != :four } }
+
+        let(:expected_index) { DaruLite::Index.new([:one, :two, :three, :five]) }
+        let(:expected_df) do
           DaruLite::DataFrame.new(
-            { b: [10, 12, 20], a: [50, 30, 30], c: [10, 20, 30] },
+            { b: [10, 12, 20, 30], a: [50, 30, 30, 5], c: [10, 20, 30, 50] },
             order:,
-            index: index[..2]
+            index: expected_index
           )
-        )
+        end
+
+        it_behaves_like '#keep_row_if'
+      end
+
+      context DaruLite::CategoricalIndex do
+        subject { df.keep_row_if { |row| row.name != :a } }
+
+        let (:index) { DaruLite::CategoricalIndex.new([:a, 1, 1, :a, :c]) }
+        let(:expected_index) { DaruLite::CategoricalIndex.new([1, 1, :c]) }
+        let(:expected_df) do
+          DaruLite::DataFrame.new(
+            {
+              b: [12, 20, 30],
+              a: [30, 30, 5],
+              c: [20, 30, 50]
+            },
+            order:,
+            index: expected_index
+          )
+        end
+
+        it_behaves_like '#keep_row_if'
+      end
+
+      context DaruLite::MultiIndex do
+        subject { df.keep_row_if { |row| !row.name.include?('two') } }
+
+        let(:index) do
+          DaruLite::MultiIndex.from_tuples([[:a, :one], [:a, :two], [:b, :one], [:b, :two], [:c, :one]])
+        end
+        let(:expected_index) do
+          DaruLite::MultiIndex.from_tuples([[:a, :one], [:b, :one], [:c, :one]])
+        end
+        let(:expected_df) do
+          DaruLite::DataFrame.new(
+            {
+              b: [10, 20, 30],
+              a: [50, 30, 5],
+              c: [10, 30, 50]
+            },
+            order:,
+            index: expected_index
+          )
+        end
+
+        it_behaves_like '#keep_row_if'
       end
     end
 
-    context DaruLite::CategoricalIndex do
-      let (:index) { DaruLite::CategoricalIndex.new([:a, 1, 1, :a, :c]) }
+    context 'several rows are removed' do
+      subject { df.keep_row_if { |row| row[:a] % 10 == 0 } }
 
-      it "keeps row if block evaluates to true" do
-        subject
-        expect(df).to eq(
+      context DaruLite::Index do
+        let(:expected_index) { DaruLite::Index.new([:one, :two, :three]) }
+        let(:expected_df) do
+          DaruLite::DataFrame.new(
+            { b: [10, 12, 20], a: [50, 30, 30], c: [10, 20, 30] },
+            order:,
+            index: expected_index
+          )
+        end
+
+        it_behaves_like '#keep_row_if'
+      end
+
+      context DaruLite::CategoricalIndex do
+        let (:index) { DaruLite::CategoricalIndex.new([:a, 1, 1, :a, :c]) }
+        let(:expected_index) { DaruLite::CategoricalIndex.new([:a, 1, 1]) }
+        let(:expected_df) do
           DaruLite::DataFrame.new(
             { b: [10, 12, 20], a: [50, 30, 30], c: [10, 20, 30] },
             order:,
-            index: DaruLite::CategoricalIndex.new([:a, 1, 1])
+            index: expected_index
           )
-        )
+        end
+
+        it_behaves_like '#keep_row_if'
+      end
+
+      context DaruLite::MultiIndex do
+        let(:index) { DaruLite::MultiIndex.from_tuples([[:a, :one], [:a, :two], [:b, :one], [:b, :two], [:c, :one]]) }
+        let(:expected_index) do
+          DaruLite::MultiIndex.from_tuples([[:a, :one], [:a, :two], [:b, :one]])
+        end
+        let(:expected_df) do
+          DaruLite::DataFrame.new(
+            { b: [10, 12, 20], a: [50, 30, 30], c: [10, 20, 30] },
+            order:,
+            index: expected_index
+          )
+        end
+
+        it_behaves_like '#keep_row_if'
       end
     end
+
+    # context DaruLite::MultiIndex do
+    #   subject { df.keep_row_if { |row| row.name != 'No answer' } }
+
+    #   let(:df) do
+    #     order = DaruLite::MultiIndex.from_tuples(
+    #       [
+    #         [:a, :total],
+    #         [:a, "Male"],
+    #         [:a, "Female"],
+    #         [:a, "Prefer not to answer"],
+    #         [:a, "No answer"],
+    #         [:b, :total],
+    #         [:b, "Male"],
+    #         [:b, "Female"],
+    #         [:b, "Prefer not to answer"],
+    #         [:b, "No answer"],
+    #         [:c, :total],
+    #         [:c, "Male"],
+    #         [:c, "Female"],
+    #         [:c, "Prefer not to answer"],
+    #         [:c, "No answer"]
+    #       ]
+    #     )
+    #     index = [
+    #       :base,
+    #       "Single Malt Whisky",
+    #       "Blended/ Other Whisky",
+    #       "Vodka",
+    #       "Cognac",
+    #       "Brandy",
+    #       "Rum",
+    #       "Gin",
+    #       "Tequila",
+    #       "No answer",
+    #       "NET"
+    #     ]
+    #     DaruLite::DataFrame.new(
+    #       [
+    #         [0.0, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [Float::NAN, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [0, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [0, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [0, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [0, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [0, nil, nil, nil, nil, nil, nil, nil, nil],
+    #       ],
+    #       index:,
+    #       order:
+    #     )
+    #   end
+
+    #   it "all vectors have the same index" do
+    #     subject
+    #     expect(df.map(&:index)).to all(eq(df.index))
+    #   end
+    # end
   end
 
   describe "#keep_vector_if" do

data/spec/index/categorical_index_spec.rb

@@ -1,36 +1,47 @@
 require 'spec_helper.rb'
 
 describe DaruLite::CategoricalIndex do
+  let(:index) { described_class.new(keys) }
+  let(:keys) { [:a, :b, :a, :a, :c] }
+
+  describe "#to_a" do
+    subject { index.to_a }
+
+    it { is_expected.to eq(keys) }
+
+    it 'the returns array is not a variable of the index' do
+      expect { subject << 'four' }.not_to change { index.to_a }
+    end
+  end
+
   context "#pos" do
     context "when the category is non-numeric" do
-      let(:idx) { described_class.new [:a, :b, :a, :a, :c] }
-
       context "single category" do
-        subject { idx.pos :a }
+        subject { index.pos :a }
 
         it { is_expected.to eq [0, 2, 3] }
       end
 
       context "multiple categories" do
-        subject { idx.pos :a, :c }
+        subject { index.pos :a, :c }
 
         it { is_expected.to eq [0, 2, 3, 4] }
       end
 
       context "invalid category" do
-        it { expect { idx.pos :e }.to raise_error IndexError }
+        it { expect { index.pos :e }.to raise_error IndexError }
       end
 
       context "positional index" do
-        it { expect(idx.pos 0).to eq 0 }
+        it { expect(index.pos 0).to eq 0 }
       end
 
       context "invalid positional index" do
-        it { expect { idx.pos 5 }.to raise_error IndexError }
+        it { expect { index.pos 5 }.to raise_error IndexError }
       end
 
       context "multiple positional indexes" do
-        subject { idx.pos 0, 1, 2 }
+        subject { index.pos 0, 1, 2 }
 
         it { is_expected.to be_a Array }
         its(:size) { is_expected.to eq 3 }
@@ -167,4 +178,12 @@ describe DaruLite::CategoricalIndex do
       it { expect(idx.valid? :a, 1, 5).to eq false }
     end
   end
+
+  describe '#delete_at' do
+    subject { index.delete_at(3) }
+
+    let(:index) { described_class.new([:a, 1, :a, 1, 'c']) }
+
+    it { is_expected.to eq(described_class.new([:a, 1, :a, 'c'])) }
+  end
 end

data/spec/index/index_spec.rb

@@ -1,6 +1,9 @@
 require 'spec_helper.rb'
 
 describe DaruLite::Index do
+  let(:index) { described_class.new(keys) }
+  let(:keys) { ['one', 'two', 'three'] }
+
   context ".new" do
     it "creates an Index object if Index-like data is supplied" do
       i = DaruLite::Index.new [:one, 'one', 1, 2, :two]
@@ -147,6 +150,16 @@ describe DaruLite::Index do
     end
   end
 
+  describe "#to_a" do
+    subject { index.to_a }
+
+    it { is_expected.to eq(keys) }
+
+    it 'the returns array is not a variable of the index' do
+      expect { subject << 'four' }.not_to change { index.to_a }
+    end
+  end
+
   context "#&" do
     before :each do
       @left = DaruLite::Index.new [:miles, :geddy, :eric]
@@ -390,11 +403,11 @@ describe DaruLite::Index do
   end
 
   describe '#delete_at' do
-    subject { idx.delete_at(1)}
+    subject { index.delete_at(1) }
 
-    let(:idx) { DaruLite::Index.new([:a, :b, 1, 2]) }
+    let(:index) { described_class.new([:a, :b, 1, 2]) }
 
-    it { is_expected.to eq DaruLite::Index.new([:a, 1, 2]) }
+    it { is_expected.to eq(described_class.new([:a, 1, 2])) }
   end
 
   context '#to_df' do