daru_lite 0.1

data/spec/formatters/table_formatter_spec.rb

@@ -0,0 +1,137 @@
+describe DaruLite::Formatters::Table do
+  let(:options) { {} }
+  subject {
+    DaruLite::Formatters::Table
+      .format(data, options.merge(headers: headers, row_headers: row_headers))
+  }
+
+  let(:data) { [[1,2,3], [4,5,6], [7,8,9]] }
+  let(:headers) { [:col1, :col2, :col3] }
+  let(:row_headers) { [:row1, :row2, :row3] }
+
+  context 'simple table' do
+    it { is_expected.to eq %Q{
+      |      col1 col2 col3
+      | row1    1    2    3
+      | row2    4    5    6
+      | row3    7    8    9
+    }.unindent}
+  end
+
+  context 'with nils' do
+    let(:data) { [[1,nil,3], [4,5,nil], [7,8,9]] }
+    let(:headers) { [:col1, :col2, nil] }
+    let(:row_headers) { [:row1, nil, :row3] }
+
+    it { is_expected.to eq %Q{
+      |      col1 col2     |
+      | row1    1  nil    3|
+      |         4    5  nil|
+      | row3    7    8    9|
+    }.unindent}
+  end
+
+  context 'with multivalue row headers' do
+    let(:row_headers) { [[:row,1], [:row,2], [:row,3]] }
+    it { is_expected.to eq %Q{
+      |           col1 col2 col3
+      |  row    1    1    2    3
+      |  row    2    4    5    6
+      |  row    3    7    8    9
+    }.unindent}
+  end
+
+  context 'with multivalue column headers' do
+    let(:headers) { [[:col,1], [:col,2], [:col,3]] }
+  end
+
+  context 'rows only' do
+    let(:data) { [] }
+    let(:headers) { nil }
+    it { is_expected.to eq %Q{
+      | row1
+      | row2
+      | row3
+    }.unindent}
+  end
+
+  context 'columns only' do
+    let(:data) { [] }
+    let(:row_headers) { nil }
+    it { is_expected.to eq %Q{
+      | col1 col2 col3
+    }.unindent}
+  end
+
+  context 'wide values' do
+    let(:options) { {spacing: 2} }
+
+    it { is_expected.to eq %Q{
+      |    co co co
+      | ro  1  2  3
+      | ro  4  5  6
+      | ro  7  8  9
+    }.unindent}
+  end
+
+  context 'with empty data' do
+    let(:data) { [] }
+    let(:headers) { [] }
+    let(:row_headers) { [] }
+
+    it { is_expected.to eq '' }
+  end
+
+
+  context '<more> threshold' do
+    let(:options) { {threshold: threshold} }
+    context 'lower than data size' do
+      let(:threshold) { 2 }
+      it { is_expected.to eq %Q{
+        |      col1 col2 col3
+        | row1    1    2    3
+        | row2    4    5    6
+        |  ...  ...  ...  ...
+      }.unindent}
+    end
+
+    context 'greater than data size' do
+      let(:threshold) { 5 }
+      it { is_expected.to eq %Q{
+        |      col1 col2 col3
+        | row1    1    2    3
+        | row2    4    5    6
+        | row3    7    8    9
+      }.unindent}
+    end
+  end
+
+  context 'no row and column headers' do
+    let(:headers) { nil }
+    let(:row_headers) { nil }
+    it { is_expected.to eq %Q{
+        |       1   2   3
+        |       4   5   6
+        |       7   8   9
+      }.unindent }
+  end
+
+  context 'row headers only' do
+    let(:headers) { nil }
+    it { is_expected.to eq %Q{
+        | row1    1    2    3
+        | row2    4    5    6
+        | row3    7    8    9
+      }.unindent }
+  end
+
+  context 'column headers only' do
+    let(:row_headers) { nil }
+    it { is_expected.to eq %Q{
+        |      col1 col2 col3
+        |         1    2    3
+        |         4    5    6
+        |         7    8    9
+      }.unindent }
+  end
+end

data/spec/helpers_spec.rb

@@ -0,0 +1,8 @@
+describe DaruLite::ArrayHelper do
+  context '#recode_repeated' do
+    let(:source) { [1,'a',1,'a','b',:c,2] }
+    subject { described_class.recode_repeated(source) }
+
+    it { is_expected.to eq ['1_1','a_1', '1_2','a_2','b',:c,2] }
+  end
+end

data/spec/index/categorical_index_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper.rb'
+
+describe DaruLite::CategoricalIndex do
+  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 }
+
+        it { is_expected.to eq [0, 2, 3] }
+      end
+
+      context "multiple categories" do
+        subject { idx.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 }
+      end
+
+      context "positional index" do
+        it { expect(idx.pos 0).to eq 0 }
+      end
+
+      context "invalid positional index" do
+        it { expect { idx.pos 5 }.to raise_error IndexError }
+      end
+
+      context "multiple positional indexes" do
+        subject { idx.pos 0, 1, 2 }
+
+        it { is_expected.to be_a Array }
+        its(:size) { is_expected.to eq 3 }
+        it { is_expected.to eq [0, 1, 2] }
+      end
+    end
+
+    context "when the category is numeric" do
+      let(:idx) { described_class.new [0, 1, 0, 0, 2] }
+
+      context "first preference to category" do
+        subject { idx.pos 0 }
+
+        it { is_expected.to be_a Array }
+        its(:size) { is_expected.to eq 3 }
+        it { is_expected.to eq [0, 2, 3] }
+      end
+
+      context "second preference to positional index" do
+        subject { idx.pos 3 }
+
+        it { is_expected.to eq 3 }
+      end
+    end
+  end
+
+  context "#subset" do
+    let(:idx) { described_class.new [:a, 1, :a, 1, :c] }
+
+    context "single index" do
+      context "multiple instances" do
+        subject { idx.subset :a }
+
+        it { is_expected.to be_a described_class }
+        its(:size) { is_expected.to eq 2 }
+        its(:to_a) { is_expected.to eq [:a, :a] }
+      end
+    end
+
+    context "multiple indexes" do
+      subject { idx.subset :a, 1 }
+
+      it { is_expected.to be_a described_class }
+      its(:size) { is_expected.to eq 4 }
+      its(:to_a) { is_expected.to eq [:a, 1, :a, 1] }
+    end
+
+    context "multiple positional indexes" do
+      subject { idx.subset 0, 2 }
+
+      it { is_expected.to be_a described_class }
+      its(:size) { is_expected.to eq 2 }
+      its(:to_a) { is_expected.to eq [:a, :a] }
+    end
+  end
+
+  context "#at" do
+    let(:idx) { described_class.new [:a, :a, :a, 1, :c] }
+
+    context "single position" do
+      it { expect(idx.at 1).to eq :a }
+    end
+
+    context "multiple positions" do
+      subject { idx.at 0, 2, 3 }
+
+      it { is_expected.to be_a described_class }
+      its(:size) { is_expected.to eq 3 }
+      its(:to_a) { is_expected.to eq [:a, :a, 1] }
+    end
+
+    context "range" do
+      subject { idx.at 2..3 }
+
+      it { is_expected.to be_a described_class }
+      its(:size) { is_expected.to eq 2 }
+      its(:to_a) { is_expected.to eq [:a, 1] }
+    end
+
+    context "range with negative integers" do
+      subject { idx.at 2..-2 }
+
+      it { is_expected.to be_a described_class }
+      its(:size) { is_expected.to eq 2 }
+      its(:to_a) { is_expected.to eq [:a, 1] }
+    end
+
+    context "rangle with single element" do
+      subject { idx.at 2..2 }
+
+      it { is_expected.to be_a described_class }
+      its(:size) { is_expected.to eq 1 }
+      its(:to_a) { is_expected.to eq [:a] }
+    end
+
+    context "invalid position" do
+      it { expect { idx.at 5 }.to raise_error IndexError }
+    end
+
+    context "invalid positions" do
+      it { expect { idx.at 2, 5 }.to raise_error IndexError }
+    end
+  end
+
+  context "#add" do
+    let(:idx) { described_class.new [:a, 1, :a, 1] }
+
+    context "single index" do
+      subject { idx.add :c }
+
+      its(:to_a) { is_expected.to eq [:a, 1, :a, 1, :c] }
+      its(:categories) { is_expected.to eq [:a, 1, :c] }
+    end
+
+    context "multiple indexes" do
+      subject { idx.add :c, :d }
+
+      its(:to_a) { is_expected.to eq [:a, 1, :a, 1, :c, :d] }
+      its(:categories) { is_expected.to eq [:a, 1, :c, :d] }
+    end
+  end
+
+  context "#valid?" do
+    let(:idx) { described_class.new [:a, 1, :a, 1] }
+
+    context "single index" do
+      it { expect(idx.valid? :a).to eq true }
+      it { expect(idx.valid? 2).to eq true }
+      it { expect(idx.valid? 4).to eq false }
+    end
+
+    context "multiple indexes" do
+      it { expect(idx.valid? :a, 1).to eq true }
+      it { expect(idx.valid? :a, 1, 5).to eq false }
+    end
+  end
+end