daru_lite 0.1

data/spec/monkeys_spec.rb

@@ -0,0 +1,42 @@
+describe "Monkeys" do
+  context Matrix do
+    it "performs elementwise division" do
+      left  = Matrix[[3,6,9],[4,8,12],[2,4,6]]
+      right = Matrix[[3,6,9],[4,8,12],[2,4,6]]
+
+      expect(left.elementwise_division(right)).to eq(Matrix[[1,1,1],[1,1,1],[1,1,1]])
+    end
+  end
+
+  describe '#daru_lite_vector' do
+    it 'converts Array' do
+      expect([1,2,3].daru_lite_vector).to eq DaruLite::Vector.new [1,2,3]
+      expect([1,2,3].daru_lite_vector('test', [:a, :b, :c])).to eq \
+        DaruLite::Vector.new [1,2,3], name: 'test', index: [:a, :b, :c]
+    end
+
+    it 'converts Range' do
+      expect((1..3).daru_lite_vector).to eq DaruLite::Vector.new [1,2,3]
+      expect((1..3).daru_lite_vector('test', [:a, :b, :c])).to eq \
+        DaruLite::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_lite_vector('test')).to eq DaruLite::Vector.new [1,2,3], name: 'test', index: [:a, :b, :c]
+      #
+      expect({test: [1, 2, 3]}.daru_lite_vector).to eq DaruLite::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 DaruLite::Index.new [1,2,3]
+    end
+
+    it 'converts Range' do
+      expect((1..3).to_index).to eq DaruLite::Index.new [1,2,3]
+    end
+  end
+end

data/spec/shared/vector_display_spec.rb

@@ -0,0 +1,213 @@
+describe DaruLite::Vector do
+  # TODO: Add inspect specs for category
+  context '#inspect' do
+    context 'simple' do
+      subject(:vector) { DaruLite::Vector.new [1,2,3],
+        index: [:a, :b, :c], name: 'test'}
+      its(:inspect) { is_expected.to eq %Q{
+        |#<DaruLite::Vector(3)>
+        |      test
+        |    a    1
+        |    b    2
+        |    c    3
+      }.unindent }
+    end
+
+    context 'no name' do
+      subject(:vector) { DaruLite::Vector.new [1,2,3], index: [:a, :b, :c]}
+      its(:inspect) { is_expected.to eq %Q{
+        |#<DaruLite::Vector(3)>
+        |   a   1
+        |   b   2
+        |   c   3
+      }.unindent }
+    end
+
+    context 'with nils' do
+      subject(:vector) { DaruLite::Vector.new [1,nil,3],
+        index: [:a, :b, :c], name: 'test'}
+      its(:inspect) { is_expected.to eq %Q{
+        |#<DaruLite::Vector(3)>
+        |      test
+        |    a    1
+        |    b  nil
+        |    c    3
+      }.unindent }
+    end
+
+    context 'very large amount of data' do
+      subject(:vector) { DaruLite::Vector.new [1,2,3] * 100, name: 'test'}
+      its(:inspect) { is_expected.to eq %Q{
+        |#<DaruLite::Vector(300)>
+        |      test
+        |    0    1
+        |    1    2
+        |    2    3
+        |    3    1
+        |    4    2
+        |    5    3
+        |    6    1
+        |    7    2
+        |    8    3
+        |    9    1
+        |   10    2
+        |   11    3
+        |   12    1
+        |   13    2
+        |   14    3
+        |  ...  ...
+      }.unindent }
+    end
+
+    context 'really long name or data' do
+      subject(:vector) { DaruLite::Vector.new [1,2,'this is ridiculously long'],
+        index: [:a, :b, :c], name: 'and this is not much better faithfully'}
+      its(:inspect) { is_expected.to eq %Q{
+        |#<DaruLite::Vector(3)>
+        |                      and this is not much
+        |                    a                    1
+        |                    b                    2
+        |                    c this is ridiculously
+      }.unindent }
+    end
+
+    context 'with multiindex' do
+      subject(:vector) {
+        DaruLite::Vector.new(
+          [1,2,3,4,5,6,7],
+          name: 'test',
+          index: DaruLite::MultiIndex.from_tuples([
+              %w[foo one],
+              %w[foo two],
+              %w[foo three],
+              %w[bar one],
+              %w[bar two],
+              %w[bar three],
+              %w[baz one],
+           ]),
+        )
+      }
+
+      its(:inspect) { is_expected.to eq %Q{
+        |#<DaruLite::Vector(7)>
+        |              test
+        |   foo   one     1
+        |         two     2
+        |       three     3
+        |   bar   one     4
+        |         two     5
+        |       three     6
+        |   baz   one     7
+      }.unindent}
+    end
+
+    context 'threshold and spacing settings' do
+    end
+  end
+
+  [nil, :category].each do |type|
+    context '#to_html' do
+      let(:doc) { Nokogiri::HTML(vector.to_html) }
+      subject(:table) { doc.at('table') }
+      let(:header) { doc.at('b') }
+
+      context 'simple' do
+        let(:vector) { DaruLite::Vector.new [1,nil,3],
+          index: [:a, :b, :c], name: 'test', type: type }
+        it { is_expected.not_to be_nil }
+
+        describe 'header' do
+          subject { header }
+          it { is_expected.not_to be_nil }
+          its(:text) { is_expected.to eq " DaruLite::Vector(3)"\
+            "#{":category" if type == :category} " }
+        end
+
+        describe 'name' do
+          subject(:name) { table.at('thead > tr:first-child > th:nth-child(2)') }
+          it { is_expected.not_to be_nil }
+          its(:text) { is_expected.to eq 'test' }
+
+          context 'withought name' do
+            let(:vector) { DaruLite::Vector.new [1,nil,3], index: [:a, :b, :c], type: type }
+
+            it { is_expected.to be_nil }
+          end
+        end
+
+        describe 'index' do
+          subject(:indexes) { table.search('tr > td:first-child').map(&:text) }
+          its(:count) { is_expected.to eq vector.size }
+          it { is_expected.to eq vector.index.to_a.map(&:to_s) }
+        end
+
+        describe 'values' do
+          subject(:indexes) { table.search('tr > td:last-child').map(&:text) }
+          its(:count) { is_expected.to eq vector.size }
+          it { is_expected.to eq vector.to_a.map(&:to_s) }
+        end
+      end
+
+      context 'large vector' do
+        subject(:vector) { DaruLite::Vector.new [1,2,3] * 100, name: 'test', type: type }
+        it 'has only 30 rows (+ 1 header rows, + 2 finishing rows)' do
+          expect(table.search('tr').size).to eq 33
+        end
+
+        describe '"skipped" row' do
+          subject(:row) { table.search('tr:nth-child(31) td').map(&:text) }
+          its(:count) { is_expected.to eq 2 }
+          it { is_expected.to eq ['...', '...'] }
+        end
+
+        describe 'last row' do
+          subject(:row) { table.search('tr:nth-child(32) td').map(&:text) }
+          its(:count) { is_expected.to eq 2 }
+          it { is_expected.to eq ['299', '3'] }
+        end
+      end
+
+      context 'multi-index' do
+        subject(:vector) {
+          DaruLite::Vector.new(
+            [1,2,3,4,5,6,7],
+            name: 'test',
+            type: type,
+            index: DaruLite::MultiIndex.from_tuples([
+                %w[foo one],
+                %w[foo two],
+                %w[foo three],
+                %w[bar one],
+                %w[bar two],
+                %w[bar three],
+                %w[baz one],
+             ]),
+          )
+        }
+
+        describe 'header' do
+          subject { header }
+          it { is_expected.not_to be_nil }
+          its(:text) { is_expected.to eq " DaruLite::Vector(7)"\
+            "#{":category" if type == :category} " }
+        end
+
+        describe 'name row' do
+          subject(:row) { table.at('thead > tr:nth-child(1)').search('th') }
+          its(:count) { should == 2 }
+          it { expect(row.first['colspan']).to eq '2' }
+        end
+
+        describe 'first data row' do
+          let(:row) { table.at('tbody > tr:first-child') }
+          subject { row.inner_html.scan(/<t[dh].+?<\/t[dh]>/) }
+          it { is_expected.to eq [
+            '<th rowspan="3">foo</th>',
+            '<th rowspan="1">one</th>',
+            '<td>1</td>'
+          ]}
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,87 @@
+require 'rspec'
+require 'rspec/its'
+require 'rspec/expectations'
+require 'matrix'
+require 'awesome_print'
+require 'distribution'
+require 'tempfile'
+require 'pry-byebug'
+require 'nokogiri'
+require 'webmock/rspec'
+
+def mri?
+  RUBY_ENGINE == 'ruby'
+end
+
+def jruby?
+  RUBY_ENGINE == 'jruby'
+end
+
+RSpec::Expectations.configuration.warn_about_potential_false_positives = false
+
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'vendor'
+  add_filter 'spec'
+  # minimum_coverage_by_file 95 -- too strict for now. Reconsider after specs redesign.
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'daru_lite'
+
+if jruby?
+  require 'mdarray'
+end
+
+ALL_DTYPES = [:array]
+
+# FIXME: This must go! Need to be able to use be_within
+def expect_correct_vector_in_delta v1, v2, delta
+  expect(v1.size).to eq(v2.size)
+  (0...v1.size).each do |v|
+    expect(v1[v]).to be_within(delta).of(v2[v])
+  end
+end
+
+def expect_correct_df_in_delta df1, df2, delta
+  df1.each_vector_with_index do |vector, i|
+    expect_correct_vector_in_delta vector, df2[i], delta
+  end
+end
+
+RSpec::Matchers.define :be_all_within do |delta|
+  match do |actual|
+    expect(@expected).to_not be_nil
+    expect(actual.size).to equal(actual.size)
+    (@act, @exp), @idx = actual.zip(@expected).each_with_index.detect { |(a, e), _| (a - e).abs > delta }
+    @idx.nil?
+  end
+
+  chain :of do |expected|
+    @expected = expected
+  end
+
+  failure_message do |actual|
+    return "expected value must be provided using '.of'." if @expected.nil?
+    return "expected.size must equal actual.size." if @expected.size != actual.size
+    "at index=[#{@idx}], expected '#{actual[@idx]}' to be within '#{delta}' of '#{@expected[@idx]}'."
+  end
+end
+
+class String
+  # allows to pretty test agains multiline strings:
+  #   %Q{
+  #     |test
+  #     |me
+  #   }.unindent # =>
+  # "test
+  # me"
+  def unindent
+    gsub(/\n\s+?\|/, "\n")    # for all lines looking like "<spaces>|" -- remove this.
+    .gsub(/\|\n/, "\n")       # allow to write trailing space not removed by editor
+    .gsub(/^\n|\n\s+$/, '')   # remove empty strings before and after
+  end
+end
+
+Dir[File.expand_path('../support/**/*.rb', __FILE__)].each {|f| require f }

data/spec/support/database_helper.rb

@@ -0,0 +1,30 @@
+require 'sqlite3'
+require 'dbi'
+require 'active_record'
+
+module DaruLite::RSpec
+  class Account < ActiveRecord::Base
+    self.table_name = 'accounts'
+  end
+end
+
+shared_context 'with accounts table in sqlite3 database' do
+  let(:db_name) do
+    'daru_lite_test'
+  end
+
+  before do
+    # just in case
+    FileUtils.rm(db_name) if File.file?(db_name)
+
+    SQLite3::Database.new(db_name).tap do |db|
+      db.execute "create table accounts(id integer, name varchar, age integer, primary key(id))"
+      db.execute "insert into accounts values(1, 'Homer', 20)"
+      db.execute "insert into accounts values(2, 'Marge', 30)"
+    end
+  end
+
+  after do
+    FileUtils.rm(db_name)
+  end
+end

data/spec/support/matchers.rb

@@ -0,0 +1,5 @@
+RSpec::Matchers.define :be_boolean do
+  match do |actual|
+    expect(actual.is_a?(TrueClass) || actual.is_a?(FalseClass)).to be true
+  end
+end