daru_lite 0.2.0 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bebf18b1b341f84a4728386060168694ffb47fdd49af1c4621db8a4a3591aa44
-  data.tar.gz: 1f1bbf2e6ef445496d1f7c58a79e8b74054a78b6cfdcf1f8e4431870cddce437
+  metadata.gz: 027d1747a070b7555d839ffc99bf4ad075c1d2e88551f2c77cb97c4cfc49a5d9
+  data.tar.gz: 196e960c448e230c18b337017426d6a6a06ac6e2e06e658f2f82cddb46064ec9
 SHA512:
-  metadata.gz: e1a020700e73fb9a48bfefb225ab79d465658df60fd95bed92ad4053533a0f6f4d6ea1d4e7b5e4dd10a11b79d7f2a5ade80345a87a81efb2eea5124db29d77be
-  data.tar.gz: 148611db5a2ef6c16b2974131f1c7a1e8298f7537d9868d26a248181478266bae61ce2e1810f6d513391fbfa7deaf66c239491102eae56d698791da26665827a
+  metadata.gz: 42131c6e6fce7e99c5791e58c9a2ba94460e67c60f1c37ab9827ff85990f0f10ecb7de1972f47ce91429289de994c7b44283f07d07689e0168ba86834ae78ef9
+  data.tar.gz: 1f8f4c6c51a19ad5c1f8b8c1612632c8f23e600f27493183c2055522e55149719cd352b797fd6feb6a2adcc9fd29570618f2723ae833b8afc536820fc83f8835

data/.github/workflows/ci.yml

@@ -1,15 +1,6 @@
 name: CI
 on: [push]
 
-env:
-  CC_TEST_REPORTER_ID: ${{secrets.CC_TEST_REPORTER_ID}}
-  # `github.ref` points to the *merge commit* when running tests on a pull request, which will be a commit
-  # that doesn't exists in our code base. Since this workflow triggers from a PR, we use the HEAD SHA instead.
-  #
-  # NOTE: These are both used by Code Climate (cc-test-reporter).
-  GIT_COMMIT_SHA: ${{github.event.pull_request.head.sha}}
-  GIT_BRANCH: ${{github.head_ref}}
-
 jobs:
   lint:
     runs-on: ubuntu-latest
@@ -38,16 +29,5 @@ jobs:
       with:
         ruby-version: ${{ matrix.ruby-version }}
         bundler-cache: true # runs 'bundle install' and caches installed gems automatically
-    - name: "Download cc-test-reporter from codeclimate.com"
-      run: |
-        curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
-        chmod +x ./cc-test-reporter
-    - name: "Report to Code Climate that we will send a coverage report."
-      run: ./cc-test-reporter before-build
     - name: Run tests
       run: bundle exec rspec
-    - name: Upload code coverage to Code Climate
-      run: |
-        ./cc-test-reporter after-build \
-          --coverage-input-type simplecov \
-          ./coverage/.resultset.json

data/.rubocop_todo.yml

@@ -80,7 +80,7 @@ Naming/MethodParameterName:
 # ForbiddenPrefixes: is_, has_, have_
 # AllowedMethods: is_a?
 # MethodDefinitionMacros: define_method, define_singleton_method
-Naming/PredicateName:
+Naming/PredicatePrefix:
   Exclude:
     - 'spec/**/*'
     - 'lib/daru_lite/data_frame/missable.rb'

data/README.md

@@ -4,8 +4,6 @@ Simple, straightforward DataFrames for Ruby
 
 [![Build Status](https://github.com/pollandroll/daru_lite/actions/workflows/build.yml/badge.svg)](https://github.com/pollandroll/daru_lite/actions)
 [![Gem Version](https://img.shields.io/gem/v/daru_lite.svg)](https://rubygems.org/gems/daru_lite)
-[![Maintainability](https://api.codeclimate.com/v1/badges/f87d4ed10b5731e50184/maintainability)](https://codeclimate.com/github/pollandroll/daru_lite/maintainability)
-[![Test Coverage](https://api.codeclimate.com/v1/badges/f87d4ed10b5731e50184/test_coverage)](https://codeclimate.com/github/pollandroll/daru_lite/test_coverage)
 
 ## Introduction
 

data/lib/daru_lite/data_frame/fetchable.rb

@@ -222,7 +222,7 @@ module DaruLite
       end
 
       def access_vector_multi_index(*names)
-        pos = @vectors[names]
+        pos = @vectors[*names]
 
         return @data[pos] if pos.is_a?(Integer)
 

data/lib/daru_lite/data_frame/joinable.rb

@@ -22,7 +22,10 @@ module DaruLite
         df = row[*(@index.to_a - other_df.index.to_a)]
 
         df = df.concat(other_df)
-        df.index = DaruLite::Index.new(index)
+        df.index = @index.class.public_send(
+          @index.is_a?(DaruLite::MultiIndex) ? :from_tuples : :new,
+          index
+        )
         df
       end
 

data/lib/daru_lite/index/index.rb

@@ -229,7 +229,7 @@ module DaruLite
     #   #     2  false
     #   #     3  false
     #   #     4  true
-    def is_values(*indexes) # rubocop:disable Naming/PredicateName
+    def is_values(*indexes) # rubocop:disable Naming/PredicatePrefix
       bool_array = @keys.map { |r| indexes.include?(r) }
       DaruLite::Vector.new(bool_array)
     end

data/lib/daru_lite/index/multi_index.rb

@@ -122,16 +122,16 @@ module DaruLite
     end
 
     def [](*key)
-      key.flatten!
-      if key[0].is_a?(Range)
-        retrieve_from_range(key[0])
-      elsif key[0].is_a?(Integer) && key.size == 1
-        try_retrieve_from_integer(key[0])
+      if key.all? { |subkey| subkey.is_a?(Array) && subkey.length > 1 }
+        retrieve_from_tuples(*key)
       else
-        begin
-          retrieve_from_tuples key
-        rescue NoMethodError
-          raise IndexError, "Specified index #{key.inspect} do not exist"
+        key.flatten!
+        if key[0].is_a?(Range)
+          retrieve_from_range(key[0])
+        elsif key[0].is_a?(Integer) && key.size == 1
+          try_retrieve_from_integer(key[0])
+        else
+          retrieve_from_tuple(key)
         end
       end
     end
@@ -158,15 +158,19 @@ module DaruLite
 
         return indexes
       end
-      res = self[indexes]
+      res = self[*indexes]
       return res if res.is_a? Integer
 
       res.map { |i| self[i] }
     end
 
     def subset(*indexes)
-      if indexes.first.is_a? Integer
+      first_index = indexes.first
+      if first_index.is_a? Integer
         MultiIndex.from_tuples(indexes.map { |index| key(index) })
+      elsif first_index.is_a?(Array) && include?(first_index)
+        # Same logic as in DaruLite::Index#subset
+        MultiIndex.from_tuples indexes
       else
         self[indexes].conform indexes
       end
@@ -211,14 +215,19 @@ module DaruLite
     end
 
     def try_retrieve_from_integer(int)
-      @levels[0].key?(int) ? retrieve_from_tuples([int]) : int
+      @levels[0].key?(int) ? retrieve_from_tuple([int]) : int
     end
 
     def retrieve_from_range(range)
       MultiIndex.from_tuples(range.map { |index| key(index) })
     end
 
-    def retrieve_from_tuples(key)
+    def retrieve_from_tuples(*keys)
+      collection = keys.map { |key| retrieve_from_tuple(key) }
+      collection.one? ? collection.first : collection
+    end
+
+    def retrieve_from_tuple(key)
       chosen = []
 
       key.each_with_index do |k, depth|
@@ -232,6 +241,8 @@ module DaruLite
       return chosen[0] if chosen.size == 1 && key.size == @levels.size
 
       multi_index_from_multiple_selections(chosen)
+    rescue NoMethodError
+      raise IndexError, "Specified index #{key.inspect} do not exist"
     end
 
     def multi_index_from_multiple_selections(chosen)
@@ -281,8 +292,8 @@ module DaruLite
       raise SizeError, [error_msg, suggestion_msg].join("\n") if names.size < levels.size
     end
 
-    private :find_all_indexes, :multi_index_from_multiple_selections,
-            :retrieve_from_range, :retrieve_from_tuples, :validate_name
+    private :find_all_indexes, :multi_index_from_multiple_selections, :retrieve_from_range,
+            :retrieve_from_tuples, :retrieve_from_tuple, :validate_name
 
     def key(index)
       raise ArgumentError, "Key #{index} is too large" if index >= @labels[0].size

data/lib/daru_lite/vector/indexable.rb

@@ -15,7 +15,7 @@ module DaruLite
       end
 
       # Returns *true* if an index exists
-      def has_index?(index) # rubocop:disable Naming/PredicateName
+      def has_index?(index) # rubocop:disable Naming/PredicatePrefix
         @index.include? index
       end
 

data/lib/daru_lite/vector/missable.rb

@@ -4,7 +4,7 @@ module DaruLite
       extend Gem::Deprecate
 
       # Reports whether missing data is present in the Vector.
-      def has_missing_data? # rubocop:disable Naming/PredicateName
+      def has_missing_data? # rubocop:disable Naming/PredicatePrefix
         !indexes(*DaruLite::MISSING_VALUES).empty?
       end
       alias flawed? has_missing_data?

data/lib/daru_lite/version.rb

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

data/spec/data_frame/fetchable_example.rb

@@ -58,6 +58,11 @@ shared_examples_for 'a fetchable DataFrame' do
           DaruLite::Vector.new(vector_arry1, index: multi_index))
       end
 
+      it "returns a vector when specifying last tuple part as an array" do
+        expect(df_mi[:a, :one, [:bar]]).to eq(
+          DaruLite::Vector.new(vector_arry1, index: multi_index))
+      end
+
       it "returns DataFrame when specified first layer of MultiIndex" do
         sub_order = DaruLite::MultiIndex.from_tuples([
           [:one, :bar],

data/spec/data_frame/joinable_example.rb

@@ -41,66 +41,91 @@ shared_examples_for 'a joinable DataFrame' do
   end
 
 
-  context "#union" do
+  describe "#union" do
     let(:df1) do
       DaruLite::DataFrame.new({
         a: [1, 2, 3],
-        b: [1, 2, 3]},
-        index: [1,3,5]
+        b: [1, 2, 3]}
       )
     end
     let(:df2) do
       DaruLite::DataFrame.new({
         a: [4, 5, 6],
-        c: [4, 5, 6]},
-        index: [7,9,11]
+        c: [4, 5, 6]}
       )
     end
     let(:df3) do
       DaruLite::DataFrame.new({
         a: [4, 5, 6],
-        c: [4, 5, 6]},
-        index: [5,7,9]
+        c: [4, 5, 6]}
       )
     end
 
-    it 'does not modify the original dataframes' do
-      df1_a = df1[:a].to_a.dup
-      df2_a = df2[:a].to_a.dup
-
-      _ = df1.union df2
-      expect(df1[:a].to_a).to eq df1_a
-      expect(df2[:a].to_a).to eq df2_a
+    shared_examples_for '#union' do
+      it 'does not modify the original dataframes' do
+        df1_a = df1[:a].to_a.dup
+        df2_a = df2[:a].to_a.dup
+
+        _ = df1.union df2
+        expect(df1[:a].to_a).to eq df1_a
+        expect(df2[:a].to_a).to eq df2_a
+      end
+
+      it 'creates a new dataframe that is a concatenation of the two dataframe arguments' do
+        df1_a = df1[:a].to_a.dup
+        df2_a = df2[:a].to_a.dup
+
+        df_union = df1.union df2
+        expect(df_union[:a].to_a).to eq df1_a + df2_a
+      end
+
+      it 'fills in missing vectors with nils' do
+        df1_b = df1[:b].to_a.dup
+        df2_c = df2[:c].to_a.dup
+
+        df_union = df1.union df2
+        expect(df_union[:b].to_a).to eq df1_b + [nil] * df2.size
+        expect(df_union[:c].to_a).to eq [nil] * df1.size + df2_c
+      end
+
+      it 'overwrites part of the first dataframe if there are double indices' do
+        vec = DaruLite::Vector.new({a: 4, b: nil, c: 4})
+        expect(df1.union(df3).row[df1_df3_common_indice]).to eq vec
+      end
+
+      it 'concats the indices' do
+        v1 = df1.index.to_a
+        v2 = df2.index.to_a
+
+        df_union = df1.union df2
+        expect(df_union.index.to_a).to eq v1 + v2
+      end
     end
 
-    it 'creates a new dataframe that is a concatenation of the two dataframe arguments' do
-      df1_a = df1[:a].to_a.dup
-      df2_a = df2[:a].to_a.dup
+    context 'with regular index' do
+      let(:df1_df3_common_indice) { 5 }
+      let(:df2_df3_common_indices) { [7, 9] }
 
-      df_union = df1.union df2
-      expect(df_union[:a].to_a).to eq df1_a + df2_a
-    end
+      before do
+        df1.index = [1, 3, df1_df3_common_indice]
+        df2.index = [*df2_df3_common_indices, 11]
+        df3.index = [df1_df3_common_indice, *df2_df3_common_indices]
+      end
 
-    it 'fills in missing vectors with nils' do
-      df1_b = df1[:b].to_a.dup
-      df2_c = df2[:c].to_a.dup
-
-      df_union = df1.union df2
-      expect(df_union[:b].to_a).to eq df1_b + [nil] * df2.size
-      expect(df_union[:c].to_a).to eq [nil] * df1.size + df2_c
+      it_behaves_like '#union'
     end
 
-    it 'overwrites part of the first dataframe if there are double indices' do
-      vec = DaruLite::Vector.new({a: 4, b: nil, c: 4})
-      expect(df1.union(df3).row[5]).to eq vec
-    end
+    context 'with multi index' do
+      let(:df1_df3_common_indice) { [:c, 5] }
+      let(:df2_df3_common_indices) { [[:a, 7],[:b, 9]] }
 
-    it 'concats the indices' do
-      v1 = df1.index.to_a
-      v2 = df2.index.to_a
+      before do
+        df1.index = DaruLite::MultiIndex.from_tuples([[:a, 1], [:b, 3], df1_df3_common_indice])
+        df2.index = DaruLite::MultiIndex.from_tuples([*df2_df3_common_indices, [:c, 11]])
+        df3.index = DaruLite::MultiIndex.from_tuples([df1_df3_common_indice, *df2_df3_common_indices])
+      end
 
-      df_union = df1.union df2
-      expect(df_union.index.to_a).to eq v1 + v2
+      it_behaves_like '#union'
     end
   end
 end

data/spec/index/multi_index_spec.rb

@@ -141,6 +141,14 @@ describe DaruLite::MultiIndex do
       expect(index[:a, :one, :baz]).to eq(1)
     end
 
+    it "returns the row number when specifying last tuple part as an array" do
+      expect(index[:a, :one, [:baz]]).to eq(1)
+    end
+
+    it "returns the row numbers when specifying multiple tuples" do
+      expect(index[[:a, :one, :baz], [:b, :two, :bar]]).to eq([1, 5])
+    end
+
     it "returns MultiIndex when specifying incomplete tuple" do
       expect(index[:b]).to eq(DaruLite::MultiIndex.from_tuples([
         [:b,:one,:bar],
@@ -523,6 +531,14 @@ describe DaruLite::MultiIndex do
       it { is_expected.to eq [0, 1] }
     end
 
+    context "multiple tuple indexes" do
+      subject { idx.pos [:b,:two,:bar], [:b,:one,:foo] }
+
+      it { is_expected.to be_a Array }
+      its(:size) { is_expected.to eq 2 }
+      it { is_expected.to eq [1, 3] }
+    end
+
     # TODO: Add specs for IndexError
   end
 
@@ -552,6 +568,14 @@ describe DaruLite::MultiIndex do
       its(:to_a) { is_expected.to eq [[:b, :one, :bar], [:b, :two, :bar]] }
     end
 
+    context "multiple tuple indexes" do
+      subject { idx.subset [:b,:two,:bar], [:b,:one,:foo] }
+
+      it { is_expected.to be_a described_class }
+      its(:size) { is_expected.to eq 2 }
+      its(:to_a) { is_expected.to eq [[:b,:two,:bar], [:b,:one,:foo]] }
+    end
+
     # TODO: Checks for invalid indexes
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daru_lite
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.3
 platform: ruby
 authors:
 - Thomas Naude-Filonnière
@@ -9,9 +9,10 @@ authors:
 - Julie Thomas
 - Amar Slaoua
 - Mourtada Belhantri
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -316,6 +317,7 @@ description: |
   and can be used with many others like mixed_models, gnuplotrb and iruby.
 
   Daru Lite is a fork of Daru that aims to focus on data manipulation and stability.
+email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -531,6 +533,7 @@ homepage: https://github.com/pollandroll/daru
 licenses:
 - BSD-2-Clause
 metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -545,7 +548,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 3.4.10
+signing_key:
 specification_version: 4
 summary: Data Analysis in RUby, stripped down
 test_files: