berkeley_library-tind 0.4.0

data/spec/berkeley_library/util/arrays_spec.rb

@@ -0,0 +1,340 @@
+require 'spec_helper'
+
+require 'berkeley_library/util/arrays'
+
+module BerkeleyLibrary::Util
+  describe Arrays do
+    describe :ordered_superset do
+      let(:sup) { %w[a b c d e] }
+
+      it 'returns true for an identical subset' do
+        expect(Arrays.ordered_superset?(superset: sup, subset: sup.dup)).to eq(true)
+      end
+
+      it 'returns true for an empty subset' do
+        expect(Arrays.ordered_superset?(superset: sup, subset: [])).to eq(true)
+      end
+
+      it 'returns true for an exact sublist' do
+        subs = [
+          %w[a b c],
+          %w[b c d],
+          %w[c d e]
+        ]
+        subs.each do |sub|
+          expect(Arrays.ordered_superset?(superset: sup, subset: sub)).to eq(true)
+        end
+      end
+
+      it 'returns true when the superset interpolates extra elements' do
+        subs = [
+          %w[a c e],
+          %w[b d],
+          %w[a b d e]
+        ]
+        subs.each do |sub|
+          expect(Arrays.ordered_superset?(superset: sup, subset: sub)).to eq(true)
+        end
+      end
+
+      it 'returns false for a too-large subset' do
+        sub = %w[a b c d e f g]
+        expect(Arrays.ordered_superset?(superset: sup, subset: sub)).to eq(false)
+      end
+
+      it 'returns false when extra elements are present' do
+        subs = [
+          %w[a b c x],
+          %w[x b c d],
+          %w[c d x e]
+        ]
+        subs.each do |sub|
+          expect(Arrays.ordered_superset?(superset: sup, subset: sub)).to eq(false)
+        end
+      end
+    end
+
+    describe :count_while do
+      it 'returns the count of matching elements' do
+        a = [1, 3, 5, 2, 4, 6, 7, 11, 13]
+        expect(Arrays.count_while(values: a, &:odd?)).to eq(3)
+      end
+
+      it 'returns 0 if the first element does not match' do
+        a = [2, 4, 6, 7, 11, 13]
+        expect(Arrays.count_while(values: a, &:odd?)).to eq(0)
+      end
+
+      it 'returns an enumerator if not passed a block' do
+        a = [1, 3, 5, 2, 4, 6, 7, 11, 13]
+        e = Arrays.count_while(values: a)
+        expect(e.each(&:odd?)).to eq(3)
+      end
+
+      it 'works on non-arrays' do
+        a = [1, 3, 5, 2, 4, 6, 7, 11, 13]
+        e = Enumerator.new { |y| a.each { |x| y << x } }
+        expect(Arrays.count_while(values: e, &:odd?)).to eq(3)
+      end
+    end
+
+    describe :find_indices do
+      let(:target) { %w[a b c d e] }
+
+      it 'returns identity indices for an identical subset' do
+        expect(Arrays.find_indices(for_array: target.dup, in_array: target)).to eq([0, 1, 2, 3, 4])
+      end
+
+      it 'returns an empty array for an empty subset' do
+        expect(Arrays.find_indices(for_array: [], in_array: target)).to eq([])
+      end
+
+      it 'returns the expected subindices for an exact sublist' do
+        sources = {
+          %w[a b c] => [0, 1, 2],
+          %w[b c d] => [1, 2, 3],
+          %w[c d e] => [2, 3, 4]
+        }
+        sources.each do |source, expected|
+          expect(Arrays.find_indices(for_array: source, in_array: target)).to eq(expected)
+        end
+      end
+
+      it 'returns nil for a too-large subset' do
+        source = %w[a b c d e f g]
+        expect(Arrays.find_indices(for_array: source, in_array: target)).to be_nil
+      end
+
+      it 'returns nil when extra elements are present' do
+        sources = [
+          %w[a b c x],
+          %w[x b c d],
+          %w[c d x e]
+        ]
+        sources.each do |source|
+          expect(Arrays.find_indices(for_array: source, in_array: target)).to be_nil
+        end
+      end
+
+      it 'takes a comparison block' do
+        sub = %i[a c e]
+        expect(Arrays.find_indices(for_array: sub, in_array: target) { |source, target| target == source.to_s }).to eq([0, 2, 4])
+      end
+    end
+
+    describe :find_index do
+      let(:arr) { [0, 2, 4, 6, 4] }
+
+      it 'finds an index based on a value' do
+        expect(Arrays.find_index(4, in_array: arr)).to eq(2)
+        expect(Arrays.find_index(4, in_array: arr, start_index: 3)).to eq(4)
+      end
+
+      it 'finds an index based on a block' do
+        expect(Arrays.find_index(in_array: arr) { |x| x > 3 }).to eq(2)
+        expect(Arrays.find_index(in_array: arr, start_index: 3) { |x| x < 5 }).to eq(4)
+      end
+
+      it 'returns nil if no equal value found' do
+        expect(Arrays.find_index(7, in_array: arr)).to be_nil
+        expect(Arrays.find_index(2, in_array: arr, start_index: 2)).to be_nil
+      end
+
+      it 'returns nil if no matching value found' do
+        expect(Arrays.find_index(in_array: arr, &:odd?)).to be_nil
+        expect(Arrays.find_index(in_array: arr, start_index: 2) { |x| x < 4 }).to be_nil
+      end
+
+      # rubocop:disable Lint/Void
+      it 'returns an enumerator if given no arguments' do
+        e = Arrays.find_index(in_array: arr)
+        expect(e.each { |x| x > 3 }).to eq(2)
+
+        e = Arrays.find_index(in_array: arr, start_index: 3)
+        expect(e.each { |x| x < 5 }).to eq(4)
+      end
+      # rubocop:enable Lint/Void
+    end
+
+    describe :merge do
+      it 'merges two arrays' do
+        a1 = [1, 2, 3]
+        a2 = [2, 3, 4]
+        expect(Arrays.merge(a1, a2)).to eq([1, 2, 3, 4])
+        expect(Arrays.merge(a2, a1)).to eq([1, 2, 3, 4])
+      end
+
+      it 'merges disjoint arrays' do
+        a1 = [1, 3, 5]
+        a2 = [2, 4, 6]
+        expect(Arrays.merge(a1, a2)).to eq([1, 3, 5, 2, 4, 6])
+      end
+
+      it 'preserves duplicates' do
+        a1 = [1, 2, 2, 3, 4, 5]
+        a2 = [2, 4, 4, 5, 5, 6]
+
+        merged = Arrays.merge(a1, a2)
+        [a1, a2].each do |a|
+          expect(Arrays.ordered_superset?(superset: merged, subset: a)).to eq(true), "merge(#{[a1.join, a2.join].inspect}): #{a.join} not found in #{merged.join}"
+        end
+
+        expected = [1, 2, 2, 3, 4, 4, 5, 5, 6]
+        expect(merged.size).to eq(expected.size)
+        expect(merged).to eq(expected)
+      end
+
+      it 'merges gappy arrays' do
+        a1 = [1, 4, 5, 7, 9]
+        a2 = [2, 3, 4, 7, 8, 9]
+
+        merged = Arrays.merge(a1, a2)
+        [a1, a2].each do |a|
+          expect(Arrays.ordered_superset?(superset: merged, subset: a)).to eq(true), "merge(#{[a1.join, a2.join].inspect}): #{a.join} not found in #{merged.join}"
+        end
+
+        expected = [1, 2, 3, 4, 5, 7, 8, 9]
+        expect(merged.size).to eq(expected.size)
+        expect(merged).to eq(expected)
+      end
+
+      it 'preserves order when merging arrays with duplicates' do
+        a1 = [1, 3, 2, 2, 4]
+        a2 = [1, 2, 3, 2, 4]
+
+        merged = Arrays.merge(a1, a2)
+        [a1, a2].each do |a|
+          expect(Arrays.ordered_superset?(superset: merged, subset: a)).to eq(true), "merge(#{[a1.join, a2.join].inspect}): #{a.join} not found in #{merged.join}"
+        end
+
+        expected = [1, 2, 3, 2, 2, 4]
+        expect(merged.size).to eq(expected.size)
+        expect(merged).to eq(expected)
+      end
+
+      it 'preserves nil' do
+        a1 = [1, 3, nil, nil, 4]
+        a2 = [1, nil, 3, nil, 4]
+
+        merged = Arrays.merge(a1, a2)
+        [a1, a2].each do |a|
+          expect(Arrays.ordered_superset?(superset: merged, subset: a)).to eq(true), "merge(#{[a1.join, a2.join].inspect}): #{a.join} not found in #{merged.join}"
+        end
+
+        expected = [1, nil, 3, nil, nil, 4]
+        expect(merged.size).to eq(expected.size)
+        expect(merged).to eq(expected)
+      end
+
+      it 'works with non-comparable types' do
+        a1 = [1, 3, 'two', 'two', 4]
+        a2 = [1, 'two', 3, 'two', 4]
+
+        merged = Arrays.merge(a1, a2)
+        [a1, a2].each do |a|
+          expect(Arrays.ordered_superset?(superset: merged, subset: a)).to eq(true), "merge(#{[a1.join, a2.join].inspect}): #{a.join} not found in #{merged.join}"
+        end
+
+        expected = [1, 'two', 3, 'two', 'two', 4]
+        expect(merged.size).to eq(expected.size)
+        expect(merged).to eq(expected)
+      end
+
+      it 'returns the larger array if the smaller is already a subarray' do
+        a1 = [2, 3, 4]
+        a2 = [1, 2, 3, 4, 5]
+
+        merged = Arrays.merge(a1, a2)
+        [a1, a2].each do |a|
+          expect(Arrays.ordered_superset?(superset: merged, subset: a)).to eq(true), "merge(#{[a1.join, a2.join].inspect}): #{a.join} not found in #{merged.join}"
+        end
+
+        expected = a2
+        expect(merged.size).to eq(expected.size)
+        expect(merged).to eq(expected)
+
+        expect(Arrays.merge(a2, a1)).to eq(expected)
+      end
+
+      it 'sorts where sorting preserves order' do
+        a1 = [1, 2, 3, 4, 5]
+        a2 = [2, 3, 6, 9]
+
+        merged = Arrays.merge(a1, a2)
+        [a1, a2].each do |a|
+          expect(Arrays.ordered_superset?(superset: merged, subset: a)).to eq(true), "merge(#{[a1.join, a2.join].inspect}): #{a.join} not found in #{merged.join}"
+        end
+
+        expected = [1, 2, 3, 4, 5, 6, 9]
+        expect(merged.size).to eq(expected.size)
+        expect(merged).to eq(expected)
+
+        expect(Arrays.merge(a2, a1)).to eq(expected)
+      end
+
+      it "doesn't muck up partial matches" do
+        a1 = [1, 2, 3, 4, 5]
+        a2 = [6, 9, 2, 3]
+
+        merged = Arrays.merge(a1, a2)
+        [a1, a2].each do |a|
+          expect(Arrays.ordered_superset?(superset: merged, subset: a)).to eq(true), "merge(#{[a1.join, a2.join].inspect}): #{a.join} not found in #{merged.join}"
+        end
+
+        expected = [1, 6, 9, 2, 3, 4, 5]
+        expect(merged.size).to eq(expected.size)
+        expect(merged).to eq(expected)
+
+        expect(Arrays.merge(a2, a1)).to eq(expected)
+      end
+
+      it "doesn't much up disjoints" do
+        a1 = [1, 2, 3, 4, 5]
+        a2 = [6, 9]
+
+        merged = Arrays.merge(a1, a2)
+        [a1, a2].each do |a|
+          expect(Arrays.ordered_superset?(superset: merged, subset: a)).to eq(true), "merge(#{[a1.join, a2.join].inspect}): #{a.join} not found in #{merged.join}"
+        end
+
+        expected = [1, 2, 3, 4, 5, 6, 9]
+        expect(merged.size).to eq(expected.size)
+        expect(merged).to eq(expected)
+
+        expect(Arrays.merge(a2, a1)).to eq(expected)
+      end
+
+      it 'works on a selection of random values' do
+        next_int = ->(n) { (n * rand).to_i }
+        rand_array = -> { (0...next_int.call(10)).map { next_int.call(10) } }
+        aggregate_failures 'random values' do
+          100.times do
+            a1 = rand_array.call
+            a2 = rand_array.call
+
+            merged = Arrays.merge(a1, a2)
+            [a1, a2].each do |a|
+              expect(Arrays.ordered_superset?(superset: merged, subset: a)).to eq(true), "merge(#{[a1.join, a2.join].inspect}): #{a.join} not found in #{merged.join}"
+            end
+          end
+        end
+      end
+
+    end
+
+    describe :invert do
+      it 'inverts an array of ints' do
+        expect(Arrays.invert([0, 2, 3])).to eq([0, nil, 1, 2])
+      end
+
+      it 'fails if values are not ints' do
+        # noinspection RubyYardParamTypeMatch
+        expect { Arrays.invert(%i[a b c]) }.to raise_error(TypeError)
+      end
+
+      it 'fails if given duplicate values' do
+        expect { Arrays.invert([1, 2, 3, 2]) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/berkeley_library/util/ods/spreadsheet_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+require 'roo'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      describe Spreadsheet do
+        let(:basename) { File.basename(__FILE__, '.rb') }
+        let(:spreadsheet) { Spreadsheet.new }
+
+        let(:num_cols) { 6 }
+        let(:num_rows) { 12 }
+
+        before(:each) do
+          table = spreadsheet.add_table('Table 1')
+          num_cols.times { |c| table.add_column("Column #{c}") }
+          num_rows.times do |r|
+            row = table.add_row
+            num_cols.times { |c| row.set_value_at(c, (r * c).to_s) }
+          end
+        end
+
+        describe :write_to do
+          def check_cell_values(ss)
+            aggregate_failures 'cells' do
+              num_cols.times do |col|
+                # NOTE: spreadsheet rows are 1-indexed, but row 1 is header
+                cell_index = [1, 1 + col]
+                actual = ss.cell(*cell_index)
+                expected = "Column #{col}"
+                expect(actual).to eq(expected), "Wrong value at #{cell_index}; expected #{expected.inspect}, was #{actual.inspect}"
+
+                num_rows.times do |row|
+                  cell_index = [2 + row, 1 + col]
+                  actual = ss.cell(*cell_index)
+                  expected = (row * col).to_s
+                  expect(actual).to eq(expected), "Wrong value at #{cell_index}; expected #{expected.inspect}, was #{actual.inspect}"
+                end
+              end
+            end
+          end
+
+          it 'writes to a file' do
+            Dir.mktmpdir(basename) do |dir|
+              output_path = File.join(dir, "#{basename}.ods")
+              spreadsheet.write_to(output_path)
+
+              ss = Roo::Spreadsheet.open(output_path, file_warning: :warning)
+              check_cell_values(ss)
+            end
+          end
+
+          it 'writes to a file handle' do
+            Dir.mktmpdir(basename) do |dir|
+              output_path = File.join(dir, "#{basename}.ods")
+              File.open(output_path, 'wb') { |f| spreadsheet.write_to(f) }
+
+              ss = Roo::Spreadsheet.open(output_path, file_warning: :warning)
+              check_cell_values(ss)
+            end
+          end
+
+          it 'writes to a StringIO' do
+            Dir.mktmpdir(basename) do |dir|
+              output_path = File.join(dir, "#{basename}.ods")
+              result = StringIO.new.tap { |out| spreadsheet.write_to(out) }.string
+              File.open(output_path, 'wb') { |f| f.write(result) }
+
+              ss = Roo::Spreadsheet.open(output_path, file_warning: :warning)
+              check_cell_values(ss)
+            end
+          end
+
+          it 'returns a string' do
+            Dir.mktmpdir(basename) do |dir|
+              output_path = File.join(dir, "#{basename}.ods")
+              result = spreadsheet.write_to
+              File.open(output_path, 'wb') { |f| f.write(result) }
+
+              ss = Roo::Spreadsheet.open(output_path, file_warning: :warning)
+              check_cell_values(ss)
+            end
+          end
+
+          it 'writes a spreadsheet as exploded XML' do
+            Dir.mktmpdir(basename) do |dir|
+              expected_paths_relative = %w[META-INF/manifest.xml styles.xml content.xml]
+              expected_paths_absolute = expected_paths_relative.map do |path_relative|
+                joined_path = File.join(dir, path_relative)
+                File.absolute_path(joined_path)
+              end
+
+              files_written = spreadsheet.write_to(dir)
+              expect(files_written).to match_array(expected_paths_absolute)
+
+              expected_paths_absolute.each do |path_absolute|
+                expect(File.file?(path_absolute)).to eq(true)
+              end
+            end
+          end
+        end
+
+        describe :write_exploded do
+          it 'writes a spreadsheet as exploded XML' do
+            Dir.mktmpdir(basename) do |dir|
+              expected_paths_relative = %w[META-INF/manifest.xml styles.xml content.xml]
+              expected_paths_absolute = expected_paths_relative.map do |path_relative|
+                joined_path = File.join(dir, path_relative)
+                File.absolute_path(joined_path)
+              end
+
+              files_written = spreadsheet.write_exploded_to(dir)
+              expect(files_written).to match_array(expected_paths_absolute)
+
+              expected_paths_absolute.each do |path_absolute|
+                expect(File.file?(path_absolute)).to eq(true)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end