berkeley_library-tind 0.4.0

data/spec/berkeley_library/tind/export/row_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module TIND
+    # noinspection RubyYardParamTypeMatch
+    module Export
+      describe Table do
+        describe Row do
+          describe :values do
+
+            it 'returns the values for the specified row' do
+              records = MARC::XMLReader.read('spec/data/records-manual-search.xml', freeze: true).to_a
+              table = Table.from_records(records)
+
+              record = records[0]
+              expected_values = record.data_fields.map(&:subfields).flatten.map(&:value)
+
+              table << record
+              values = table.rows[0].values
+
+              # match_array gives a better error message than #eq() but doesn't enforce order
+              expect(values).to match_array(expected_values)
+              expect(values).to eq(expected_values)
+            end
+
+            it 'handles adding records with extra fields' do
+              records = %w[184453 184458].map { |n| MARC::XMLReader.read("spec/data/record-#{n}.xml", freeze: true).first }
+              table = Table.from_records(records, freeze: true)
+
+              vv_actual = (0..1).map { |row| table.rows[row].values }
+
+              vv_expected = records.map { |r| r.data_fields.map(&:subfields).flatten.map(&:value) }
+              vv_expected.each_with_index do |expected, index|
+                expect(vv_actual[index].compact).to eq(expected)
+              end
+
+              # 184458 has 260 & 269, 184453 doesn't
+              vv_184453 = vv_actual[0]
+              vv_184458 = vv_actual[1]
+              expect(vv_184453.size).to eq(vv_184458.size)
+              expect(vv_184453[3..4]).to contain_exactly(nil, nil)
+            end
+
+            it 'handles records with missing fields' do
+              records = %w[184458 184453].map { |n| MARC::XMLReader.read("spec/data/record-#{n}.xml", freeze: true).first }
+              table = Table.from_records(records, freeze: true)
+
+              vv_actual = (0..1).map { |row| table.rows[row].values }
+
+              vv_expected = records.map { |r| r.data_fields.map(&:subfields).flatten.map(&:value) }
+              vv_expected.each_with_index do |expected, index|
+                expect(vv_actual[index].compact).to eq(expected)
+              end
+
+              # 184458 has 260 & 269, 184453 doesn't
+              vv_184458 = vv_actual[0]
+              vv_184453 = vv_actual[1]
+              expect(vv_184453.size).to eq(vv_184458.size)
+              expect(vv_184453[3..4]).to contain_exactly(nil, nil)
+            end
+
+            it 'handles records with disjoint fields' do
+              records = MARC::XMLReader.read('spec/data/disjoint-records.xml', freeze: true).to_a
+              table = Table.from_records(records, freeze: true)
+
+              vv_actual = (0...records.size).map { |row| table.rows[row].values }
+
+              vv_expected = records.map { |r| r.data_fields.map(&:subfields).flatten.map(&:value) }
+              vv_expected.each_with_index do |expected, index|
+                expect(vv_actual[index]).not_to be_nil
+                expect(vv_actual[index].compact).to eq(expected)
+              end
+            end
+
+          end
+
+          describe :each_value do
+            it 'yields the values' do
+              records = MARC::XMLReader.read('spec/data/disjoint-records.xml', freeze: true).to_a
+              table = Table.from_records(records, freeze: true)
+
+              vv_actual = table.each_row.with_object([]) do |row, vv_all|
+                vv_row = [].tap do |vv|
+                  row.each_value { |v| vv << v }
+                end
+                vv_all << vv_row
+              end
+
+              vv_expected = records.map { |r| r.data_fields.map(&:subfields).flatten.map(&:value) }
+              vv_expected.each_with_index do |expected, index|
+                expect(vv_actual[index]).not_to be_nil
+                expect(vv_actual[index].compact).to eq(expected)
+              end
+            end
+
+            it 'is indexable' do
+              records = MARC::XMLReader.read('spec/data/disjoint-records.xml', freeze: true).to_a
+              table = Table.from_records(records, freeze: true)
+
+              vv_actual = table.each_row.with_object([]) do |row, vv_all|
+                vv_row = [].tap do |vv|
+                  row.each_value.with_index { |v, i| vv[i] = v }
+                end
+                vv_all << vv_row
+              end
+
+              vv_expected = records.map { |r| r.data_fields.map(&:subfields).flatten.map(&:value) }
+              vv_expected.each_with_index do |expected, index|
+                expect(vv_actual[index]).not_to be_nil
+                expect(vv_actual[index].compact).to eq(expected)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/export/table_spec.rb

@@ -0,0 +1,322 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module TIND
+    # noinspection RubyYardParamTypeMatch
+    module Export
+      describe Table do
+
+        describe :<< do
+          let(:table) { Table.new }
+          let(:records) { MARC::XMLReader.read('spec/data/records-manual-search.xml', freeze: true).to_a }
+
+          it 'adds one record' do
+            table << (record = records.first)
+            expect(table.marc_records).to contain_exactly(record)
+          end
+
+          it 'adds multiple records' do
+            records.each { |r| table << r }
+            expect(table.marc_records).to eq(records)
+          end
+
+          it 'logs the MARC record ID and data field in the event of a bad indicator' do
+            tag = '245'
+            ind_bad = '!'
+
+            record = records.first
+            record[tag].indicator1 = ind_bad
+            expect { table << record }.to raise_error(Export::ExportException) do |e|
+              expect(e.message).to include('184458')
+              expect(e.message).to include(tag)
+              expect(e.message).to include(ind_bad)
+            end
+          end
+        end
+
+        describe :headers do
+          it 'aligns with the correct values' do
+            records = MARC::XMLReader.read('spec/data/disjoint-records.xml', freeze: true).to_a
+            table = Table.from_records(records)
+
+            headers = table.headers
+            records.each_with_index do |record, row|
+              values = table.rows[row].values
+              expect(values).not_to be_nil, "No values found for row #{row}"
+
+              # uncomment this to debug:
+
+              # puts "#{row}) #{record['245']['rows']}: #{record['500']['rows']}"
+              # headers.each_with_index { |h, i| puts "\t#{h}\t#{values[i]}" }
+              # puts "\n" if row + 1 < records.size
+
+              aggregate_failures 'headers' do
+                last_col = -1
+                record.data_fields_by_tag.each do |tag, dff|
+                  dff.each do |df|
+                    ind1 = df.indicator1 == ' ' ? '_' : df.indicator1
+                    ind2 = df.indicator2 == ' ' ? '_' : df.indicator2
+                    df_prefix = "#{tag}#{ind1}#{ind2}"
+
+                    expected_suffix = nil
+                    df.subfields.each do |sf|
+                      col = values.find_index(sf.value)
+                      expect(col).to be > last_col
+                      last_col = col
+
+                      expected_prefix = "#{df_prefix}#{sf.code}"
+
+                      header = headers[col]
+                      expect(header).to start_with(expected_prefix)
+
+                      header_suffix = header.scan(/(?<=-)[0-9]+$/).first.to_i
+                      if expected_suffix
+                        expect(header_suffix).to eq(expected_suffix), "#{row}, #{col}: (#{sf.value}) Expected #{expected_prefix}-#{expected_suffix}, was #{header}"
+                      else
+                        expected_suffix = header_suffix
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        describe :freeze do
+          it 'prevents adding new records' do
+            records = MARC::XMLReader.read('spec/data/records-manual-search.xml', freeze: true).to_a
+            table = records[0...3].each_with_object(Table.new) { |r, t| t << r }
+            table.freeze
+            expect(table.row_count).to eq(3) # just to be sure
+            original_headers = table.headers.dup
+
+            # noinspection RubyModifiedFrozenObject
+            expect { table << records.last }.to raise_error(FrozenError)
+            expect(table.row_count).to eq(3)
+            expect(table.headers).to eq(original_headers)
+          end
+
+          it 'freezes the MARC records array' do
+            records = MARC::XMLReader.read('spec/data/records-manual-search.xml', freeze: true).to_a
+            table = records.each_with_object(Table.new) { |r, t| t << r }
+            table.freeze
+            expect { table.marc_records << records.last }.to raise_error(FrozenError)
+          end
+
+          it 'freezes the columns' do
+            records = MARC::XMLReader.read('spec/data/records-manual-search.xml', freeze: true).to_a
+            table = records.each_with_object(Table.new) { |r, t| t << r }
+            table.freeze
+
+            expect { table.columns << Object.new }.to raise_error(FrozenError)
+          end
+
+          it 'freezes the rows' do
+            records = MARC::XMLReader.read('spec/data/records-manual-search.xml', freeze: true).to_a
+            table = records.each_with_object(Table.new) { |r, t| t << r }
+            table.freeze
+
+            expect { table.rows << Object.new }.to raise_error(FrozenError)
+          end
+
+          it 'returns self' do
+            records = MARC::XMLReader.read('spec/data/records-manual-search.xml', freeze: true).to_a
+            table = records.each_with_object(Table.new) { |r, t| t << r }
+            expect(table.freeze).to be(table)
+          end
+        end
+
+        describe :from_records do
+          let(:records) { MARC::XMLReader.read('spec/data/records-manual-search.xml', freeze: true).to_a }
+          it 'reads the records' do
+            table = Table.from_records(records)
+            expect(table.row_count).to eq(records.size)
+          end
+
+          it 'optionally freezes the table' do
+            table = Table.from_records(records, freeze: true)
+            expect(table.frozen?).to eq(true)
+          end
+
+          it 'parses the data fields into rows' do
+            table = Table.from_records(records, freeze: true)
+
+            aggregate_failures 'row parsing' do
+              records.each_with_index do |marc_record, row|
+                expected_headers = []
+                expected_values = []
+
+                marc_record.each_data_field.each do |df|
+                  prefix = ColumnGroup.prefix_for(df)
+                  df.subfields.each do |sf|
+                    expected_headers << "#{prefix}#{sf.code}"
+                    expected_values << sf.value
+                  end
+                end
+
+                expected_index = 0
+                table.rows[row].values.each_with_index do |actual_value, index|
+                  next unless actual_value
+
+                  expected_header = expected_headers[expected_index]
+                  actual_header = table.headers[index]
+                  expect(actual_header).to start_with(expected_header)
+
+                  expected_value = expected_values[expected_index]
+                  expect(actual_value).to eq(expected_value)
+
+                  expected_index += 1
+                end
+              end
+            end
+          end
+
+          describe :exportable_only do
+            it 'filters out non-exportable values' do
+              excluded_prefixes = (Filter::DO_NOT_EXPORT_FIELDS + Filter::DO_NOT_EXPORT_SUBFIELDS).map { |h| h.gsub(' ', '_') }
+              table = Table.from_records(records, freeze: true, exportable_only: true)
+
+              aggregate_failures 'row parsing' do
+                records.each_with_index do |marc_record, row|
+                  expected_headers = []
+                  expected_values = []
+
+                  marc_record.each_data_field.each do |df|
+                    prefix = ColumnGroup.prefix_for(df)
+                    df.subfields.each do |sf|
+                      header = "#{prefix}#{sf.code}"
+                      next if excluded_prefixes.any? { |h| header.start_with?(h) }
+
+                      expected_headers << header
+                      expected_values << sf.value
+                    end
+                  end
+
+                  expected_index = 0
+                  table.rows[row].values.each_with_index do |actual_value, index|
+                    next unless actual_value
+
+                    expected_header = expected_headers[expected_index]
+                    actual_header = table.headers[index]
+                    expect(actual_header).to start_with(expected_header)
+
+                    expected_value = expected_values[expected_index]
+                    expect(actual_value).to eq(expected_value)
+
+                    expected_index += 1
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        describe :rows do
+
+          it 'returns the rows' do
+            records = MARC::XMLReader.read('spec/data/records-manual-search.xml', freeze: true).to_a
+            table = Table.from_records(records)
+            rows = table.rows
+            expect(rows.size).to eq(records.size)
+            expect(rows.all? { |r| r.is_a?(Row) }).to eq(true)
+          end
+
+          it 'is not cached when table is not frozen' do
+            records = MARC::XMLReader.read('spec/data/records-manual-search.xml', freeze: true).to_a
+            some_records = records[0...3]
+            table = Table.from_records(some_records)
+            rows1 = table.rows
+            expect(rows1.size).to eq(some_records.size)
+            expect(rows1.all? { |r| r.is_a?(Row) }).to eq(true)
+
+            table << records.last
+            rows2 = table.rows
+            expect(rows2).not_to be(rows1)
+            expect(rows1.size).to eq(some_records.size) # just to be sure
+            expect(rows2.size).to eq(rows1.size + 1)
+          end
+
+          it 'is cached when table is frozen' do
+            records = MARC::XMLReader.read('spec/data/records-manual-search.xml', freeze: true).to_a
+            some_records = records[0...3]
+            table = Table.from_records(some_records, freeze: true)
+            rows = table.rows
+            expect(rows.size).to eq(some_records.size)
+            expect(table.rows).to be(rows)
+          end
+
+        end
+
+        describe :each_row do
+          let(:records) { MARC::XMLReader.read('spec/data/records-manual-search.xml', freeze: true).to_a }
+          let(:table) { Table.from_records(records) }
+
+          it 'yields each row' do
+            rows = []
+            table.each_row { |r| rows << r }
+            expect(rows.size).to eq(records.size)
+            expect(rows.all? { |r| r.is_a?(Row) }).to eq(true)
+          end
+
+          it 'returns an enumerator' do
+            enum = table.each_row
+            expect(enum).to be_an(Enumerator)
+            rows = enum.each_with_object([]) { |r, a| a << r }
+            expect(rows.size).to eq(records.size)
+            expect(rows.all? { |r| r.is_a?(Row) }).to eq(true)
+          end
+
+          it 'is indexable' do
+            rows = []
+            table.each_row.with_index do |row, i|
+              expect(rows[i]).to be_nil # just to be sure
+              rows[i] = row
+            end
+            expect(rows.size).to eq(records.size)
+          end
+        end
+
+        describe :to_csv do
+          let(:records) { MARC::XMLReader.read('spec/data/records-manual-search.xml', freeze: true) }
+          let(:table) { Table.from_records(records, freeze: true) }
+
+          it 'outputs CSV' do
+            csv_str = table.to_csv
+            expect(csv_str).to be_a(String)
+
+            CSV.parse(csv_str, headers: true).each_with_index do |csv_row, row|
+              expect(csv_row.headers).to eq(table.headers)
+              expect(csv_row.fields).to eq(table.rows[row].values)
+            end
+          end
+
+          it 'accepts an IO object' do
+            csv_str = StringIO.new.tap { |out| table.to_csv(out) }.string
+
+            aggregate_failures 'rows' do
+              CSV.parse(csv_str, headers: true).each_with_index do |csv_row, row|
+                expect(csv_row.headers).to eq(table.headers)
+                expect(csv_row.fields).to eq(table.rows[row].values)
+              end
+            end
+          end
+
+          it 'accepts a filename' do
+            Dir.mktmpdir(File.basename(__FILE__, '.rb')) do |dir|
+              out_path = File.join(dir, 'out.csv')
+              table.to_csv(out_path)
+              csv_str = File.read(out_path)
+
+              CSV.parse(csv_str, headers: true).each_with_index do |csv_row, row|
+                expect(csv_row.headers).to eq(table.headers)
+                expect(csv_row.fields).to eq(table.rows[row].values)
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/marc/xml_reader_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module TIND
+    module MARC
+      describe XMLReader do
+        let(:basename) { File.basename(__FILE__, '.rb') }
+
+        it 'reads MARC records' do
+          reader = XMLReader.new('spec/data/records-api-search.xml')
+          records = reader.to_a
+          expect(records.size).to eq(5)
+
+          record0 = records[0]
+          expect(record0).to be_a(::MARC::Record)
+          expect(record0['024']['a']).to eq('BANC PIC 1982.078:15--ALB')
+        end
+
+        describe :new do
+          it 'accepts a string path' do
+            path = 'spec/data/records-api-search.xml'
+            reader = XMLReader.new(path)
+            records = reader.to_a
+            expect(records.size).to eq(5)
+          end
+
+          it 'accepts a Pathname' do
+            path = Pathname.new('spec/data/records-api-search.xml')
+            reader = XMLReader.new(path)
+            records = reader.to_a
+            expect(records.size).to eq(5)
+          end
+
+          it 'accepts an XML string' do
+            xml = File.read('spec/data/records-api-search.xml')
+            reader = XMLReader.new(xml)
+            records = reader.to_a
+            expect(records.size).to eq(5)
+          end
+
+          it 'accepts an IO' do
+            File.open('spec/data/records-api-search.xml', 'rb') do |f|
+              reader = XMLReader.new(f)
+              records = reader.to_a
+              expect(records.size).to eq(5)
+            end
+          end
+
+          it 'raises ArgumentError if passed a nonexistent file' do
+            output_path = Dir.mktmpdir(basename) { |dir| File.join(dir, "#{basename}-missing.xml") }
+            expect(File.exist?(output_path)).to be_falsey # just to be sure
+            expect { XMLReader.new(output_path) }.to raise_error(ArgumentError)
+          end
+
+          it 'raises ArgumentError if passed a non-XML string' do
+            non_xml = File.read('spec/data/collections.json')
+            expect { XMLReader.new(non_xml) }.to raise_error(ArgumentError)
+          end
+
+          it 'raises ArgumentError if passed something random' do
+            non_xml = Object.new
+            # noinspection RubyYardParamTypeMatch
+            expect { XMLReader.new(non_xml) }.to raise_error(ArgumentError)
+          end
+        end
+
+        describe :total do
+          it 'parses <total/>' do
+            reader = XMLReader.new('spec/data/records-api-search.xml')
+            reader.take_while { true } # make sure we've parsed something
+            expect(reader.total).to eq(5)
+          end
+
+          it 'parses "Search-Engine-Total-Number-Of-Results"' do
+            reader = XMLReader.new('spec/data/records-manual-search.xml')
+            reader.take_while { true } # make sure we've parsed something
+            expect(reader.total).to eq(10)
+          end
+        end
+
+        describe :search_id do
+          it 'parses <search_id>' do
+            expected = 'DnF1ZXJ5VGhlbkZldG'
+            reader = XMLReader.new('spec/data/records-api-search-p1.xml')
+            reader.take_while { true } # make sure we've parsed something
+            expect(reader.search_id).to eq(expected)
+          end
+        end
+
+      end
+    end
+  end
+end