berkeley_library-tind 0.4.0

data/spec/berkeley_library/util/ods/xml/table/table_spec.rb

@@ -0,0 +1,218 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        module Table
+          describe Table do
+            let(:content) { ContentDoc.new }
+            let(:doc_content) { content.document_content }
+            let(:table_name) { "Table for #{File.basename(__FILE__, '.rb')}" }
+
+            attr_reader :table
+
+            before(:each) do
+              @table = doc_content.add_table(table_name)
+            end
+
+            # TODO: move to some kind of helper & share w/table_spec
+            def doc_content_xml
+              xml_str = content.to_xml
+              # File.open("tmp/content-#{Time.now.to_i}.xml", 'wb') { |f| f.write(xml_str) }
+              rexml_doc = REXML::Document.new(xml_str)
+              rexml_doc.root
+            end
+
+            # TODO: move to some kind of helper & share w/table_spec
+            def find_table_xml(dc_xml = doc_content_xml, table_index = 1)
+              body = dc_xml.elements[4]
+              expect(body).to be_a(REXML::Element) # just to be sure
+
+              spreadsheet = body.elements[1]
+              expect(spreadsheet).to be_a(REXML::Element) # just to be sure
+
+              spreadsheet.elements[table_index]
+            end
+
+            describe :add_column do
+              attr_reader :header_str
+              attr_reader :width
+              attr_reader :col
+
+              before(:each) do
+                timestamp = Time.now.to_i
+                @header_str = "Header #{timestamp}"
+                @width = "#{timestamp % 10}.#{timestamp % 100}.in"
+                @col = table.add_column(header_str, width)
+              end
+
+              it 'adds a column' do
+                expect(col).to be_a(TableColumn)
+              end
+
+              it 'sets the header' do
+                expect(table.get_value_at(0, 0)).to eq(header_str)
+              end
+
+              it 'creates an associated style' do
+                styles = doc_content.automatic_styles
+                col_style = styles.find_column_style(width)
+                expect(col_style).to be_a(Style::ColumnStyle)
+
+                expect(col.column_style).to be(col_style)
+
+                dc_xml = doc_content_xml
+                styles_xml = dc_xml.elements[1, 'automatic-styles']
+                expect(styles_xml).to be_a(REXML::Element) # just to be sure
+
+                style_xml = styles_xml.elements.find do |elem|
+                  elem.prefix == 'style' &&
+                    elem.name == 'style' &&
+                    elem['style:family'] == 'table-column' &&
+                    elem['style:name'] == col_style.style_name
+                end
+                expect(style_xml).to be_a(REXML::Element)
+
+                props_xml = style_xml.elements[1]
+                expect(props_xml.prefix).to eq('style')
+                expect(props_xml.name).to eq('table-column-properties')
+                expect(props_xml['style:column-width']).to eq(width)
+              end
+
+              it 'writes the column to XML' do
+                col_style = doc_content.automatic_styles.find_column_style(width)
+
+                table_xml = find_table_xml
+                col_xml = table_xml.elements[1, 'table-column']
+                expect(col_xml).to be_a(REXML::Element)
+                expect(col_xml.prefix).to eq('table')
+                expect(col_xml['table:style-name']).to eq(col_style.style_name)
+              end
+
+              describe 'protected' do
+                attr_reader :pcol
+
+                before(:each) do
+                  timestamp = Time.now.to_i
+                  header_str = "Protected #{timestamp}"
+                  @pcol = table.add_column(header_str, protected: true)
+                end
+
+                it 'adds a column' do
+                  expect(pcol).to be_a(TableColumn)
+                end
+
+                it 'adds a protected cell style' do
+                  col_style = pcol.column_style
+
+                  default_cell_style = pcol.default_cell_style
+                  expect(default_cell_style.protected?).to eq(true)
+
+                  table_xml = find_table_xml
+                  col_xml = table_xml.elements[2, 'table-column']
+                  expect(col_xml['table:style-name']).to eq(col_style.style_name)
+                  expect(col_xml['table:default-cell-style-name']).to eq(default_cell_style.style_name)
+                end
+              end
+            end
+
+            describe :to_xml do
+              let(:columns_added) { 15 }
+              let(:expected_dummy_cols) { Table::MIN_COLUMNS - columns_added }
+
+              describe 'column repeats' do
+
+                it 'adds dummy columns as needed' do
+                  expected_dummy_cols = Table::MIN_COLUMNS - columns_added
+                  columns_added.times { |col| table.add_column("Column #{col}", "1.#{col}in") }
+
+                  table_xml = find_table_xml
+                  columns_xml = table_xml.elements.select { |e| e.name == 'table-column' }
+                  expect(columns_xml.size).to eq(columns_added + 1)
+
+                  dummy_column_xml = columns_xml.last
+                  expect(dummy_column_xml['table:number-columns-repeated']).to eq(expected_dummy_cols.to_s)
+
+                  header_row_xml = table_xml.elements[1, 'table-row']
+                  header_cells_xml = header_row_xml.elements.select { |e| e.name == 'table-cell' }
+                  expect(header_cells_xml.size).to eq(columns_added + 1)
+
+                  columns_added.times do |col|
+                    expected_header = "Column #{col}"
+                    expect(table.get_value_at(0, col)).to eq(expected_header) # just to be sure
+
+                    header_cell_xml = header_cells_xml[col]
+                    header_p = header_cell_xml.elements[1, 'p']
+                    header_texts = header_p.texts
+                    expect(header_texts.size).to eq(1)
+
+                    expect(header_texts[0].value).to eq(expected_header)
+                  end
+
+                  dummy_cell_xml = header_cells_xml.last
+                  expect(dummy_cell_xml['table:number-columns-repeated']).to eq(expected_dummy_cols.to_s)
+                end
+
+                it 'uses repeats for identical columns' do
+                  columns_added.times { |col| table.add_column("Column #{col}") }
+
+                  table_xml = find_table_xml
+                  columns_xml = table_xml.elements.select { |e| e.name == 'table-column' }
+                  expect(columns_xml.size).to eq(2)
+
+                  repeated_column_xml = columns_xml[0]
+                  expect(repeated_column_xml['table:number-columns-repeated']).to eq(columns_added.to_s)
+
+                  dummy_column_xml = columns_xml.last
+                  expect(dummy_column_xml['table:number-columns-repeated']).to eq(expected_dummy_cols.to_s)
+                end
+
+              end
+
+              describe 'dummy rows' do
+                let(:rows_added) { 15 }
+
+                it 'adds dummy rows as needed' do
+                  columns_added.times { |col| table.add_column("Column #{col}") }
+                  rows_added.times do |r|
+                    row = table.add_row
+                    columns_added.times do |c|
+                      value = "value for (#{r + 1}, c)"
+                      row.set_value_at(c, value)
+                    end
+                  end
+
+                  columns_added.times do |c|
+                    expect(table.get_value_at(0, c)).to eq("Column #{c}")
+                    rows_added.times do |r|
+                      value = "value for (#{r + 1}, c)" # skip header row
+                      expect(table.get_value_at(r + 1, c)).to eq(value)
+                    end
+                  end
+
+                  table_xml = find_table_xml
+                  rows_xml = table_xml.elements.select { |e| e.name == 'table-row' }
+                  expect(rows_xml.size).to eq(2 + rows_added)
+
+                  # TODO: do we need a final unrepeated row?
+                  expected_dummy_rows = Table::MIN_ROWS - (1 + rows_added)
+                  dummy_row_xml = rows_xml.last
+                  expect(dummy_row_xml['table:number-rows-repeated']).to eq(expected_dummy_rows.to_s)
+
+                  dummy_cells_xml = dummy_row_xml.elements.select { |e| e.name == 'table-cell' }
+                  expect(dummy_cells_xml.size).to eq(1)
+
+                  dummy_cell_xml = dummy_cells_xml[0]
+                  expect(dummy_cell_xml['table:number-columns-repeated']).to eq(Table::MIN_COLUMNS.to_s)
+                end
+
+              end
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/util/paths_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'berkeley_library/util/paths'
+
+module BerkeleyLibrary::Util
+  describe Paths do
+    describe :clean do
+      {
+        # nil
+        nil => nil,
+
+        # Already clean
+        '' => '.',
+        'abc' => 'abc',
+        'abc/def' => 'abc/def',
+        'a/b/c' => 'a/b/c',
+        '.' => '.',
+        '..' => '..',
+        '../..' => '../..',
+        '../../abc' => '../../abc',
+        '/abc' => '/abc',
+        '/' => '/',
+
+        # Remove trailing slash
+        'abc/' => 'abc',
+        'abc/def/' => 'abc/def',
+        'a/b/c/' => 'a/b/c',
+        './' => '.',
+        '../' => '..',
+        '../../' => '../..',
+        '/abc/' => '/abc',
+
+        # Remove doubled slash
+        'abc//def//ghi' => 'abc/def/ghi',
+        '//abc' => '/abc',
+        '///abc' => '/abc',
+        '//abc//' => '/abc',
+        'abc//' => 'abc',
+
+        # Remove . elements
+        'abc/./def' => 'abc/def',
+        '/./abc/def' => '/abc/def',
+        'abc/.' => 'abc',
+
+        # Remove .. elements
+        'abc/def/ghi/../jkl' => 'abc/def/jkl',
+        'abc/def/../ghi/../jkl' => 'abc/jkl',
+        'abc/def/..' => 'abc',
+        'abc/def/../..' => '.',
+        '/abc/def/../..' => '/',
+        'abc/def/../../..' => '..',
+        '/abc/def/../../..' => '/',
+        'abc/def/../../../ghi/jkl/../../../mno' => '../../mno',
+
+        # Combinations
+        'abc/./../def' => 'def',
+        'abc//./../def' => 'def',
+        'abc/../../././../def' => '../../def'
+      }.each do |orig, expected|
+        it "clean(#{orig.inspect}) -> #{expected.inspect}" do
+          expect(Paths.clean(orig)).to eq(expected)
+        end
+      end
+    end
+
+    describe :join do
+      {
+        # zero parameters
+        [] => '',
+
+        # one parameter
+        [''] => '',
+        ['a'] => 'a',
+
+        # two parameters
+        ['a', 'b'] => 'a/b',
+        ['a', ''] => 'a',
+        ['', 'b'] => 'b',
+        ['/', 'a'] => '/a',
+        ['/', ''] => '/',
+        ['a/', 'b'] => 'a/b',
+        ['a/', ''] => 'a',
+        ['', ''] => ''
+      }.each do |orig, expected|
+        it "join(#{orig.map(&:inspect).join(', ')}) -> #{expected.inspect}" do
+          expect(Paths.join(*orig)).to eq(expected)
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/util/stringios_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+require 'berkeley_library/util/stringios'
+
+module BerkeleyLibrary
+  module Util
+    describe StringIOs do
+      describe :getbyte do
+        let(:s) { '祇園精舎の鐘の声、諸行無常の響きあり。' }
+        let(:bytes) { s.bytes }
+        let(:sio) { StringIO.new(s) }
+
+        it 'gets the byte at the specified byte index' do
+          bytes.each_with_index do |b, i|
+            expect(StringIOs.getbyte(sio, i)).to eq(b)
+          end
+        end
+
+        it 'resets the current offset' do
+          StringIOs.getbyte(sio, bytes.size / 2)
+          expect(sio.pos).to eq(0)
+        end
+
+        it 'returns nil for a too-large positive offset' do
+          expect(StringIOs.getbyte(s, bytes.size)).to be_nil
+        end
+
+        it 'returns nil for a too-large negative offset' do
+          expect(StringIOs.getbyte(s, -(1 + bytes.size))).to be_nil
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/util/strings_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module Util
+    describe Strings do
+      describe :diff_index do
+        it 'returns nil for identical strings' do
+          s = 'elvis'
+          expect(Strings.diff_index(s, s)).to be_nil
+        end
+
+        it 'returns the index for different strings' do
+          s1 = 'elvis aaron presley'
+          s2 = 'elvis nikita presley'
+          expect(Strings.diff_index(s1, s2)).to eq(6)
+        end
+
+        it 'returns the length of the shorter string for prefixes' do
+          s1 = 'elvis'
+          s2 = 'elvis aaron presley'
+          expect(Strings.diff_index(s1, s2)).to eq(5)
+          expect(Strings.diff_index(s2, s1)).to eq(5)
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/util/times_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'berkeley_library/util/times'
+
+module BerkeleyLibrary
+  module Util
+    describe Times do
+      describe :ensure_utc do
+        it 'returns a UTC time unchanged' do
+          time = Time.parse('2021-02-05 16:19:11.37707 -0800')
+          utc_time = time.getutc
+          expect(Times.ensure_utc(utc_time)).to be(utc_time)
+        end
+
+        it 'converts a non-UTC time' do
+          time = Time.parse('2021-02-06 08:19:11.37707 +0800')
+          expect(Times.ensure_utc(time)).to eq(time.getutc)
+          expect(time.gmt_offset).to eq(28_800), 'Times.ensure_utc() should not modify its argument'
+        end
+
+        it 'accepts a Date' do
+          date = Date.new(2021, 2, 6)
+          utc_time = Time.new(2021, 2, 6).getutc
+          expect(Times.ensure_utc(date)).to eq(utc_time)
+        end
+
+        it 'accepts a Datetime' do
+          datetime = DateTime.parse('2021-02-05 16:19:11.37707 -0800')
+          utc_time = Time.parse('2021-02-06 00:19:11.37707 UTC')
+          expect(Times.ensure_utc(datetime)).to eq(utc_time)
+        end
+
+        it 'rejects non-date/time objects' do
+          # noinspection RubyYardParamTypeMatch
+          expect { Times.ensure_utc(Object.new) }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/util/uris_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+module BerkeleyLibrary::Util
+  describe URIs do
+    describe :append do
+      it 'appends paths' do
+        original_uri = URI('https://example.org/foo/bar')
+        new_uri = URIs.append(original_uri, 'qux', 'corge', 'garply')
+        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux/corge/garply'))
+      end
+
+      it 'does not modify the original URI' do
+        original_uri = URI('https://example.org/foo/bar')
+        original_url = original_uri.to_s
+        new_uri = URIs.append(original_uri, 'qux', 'corge', 'garply')
+        expect(new_uri).not_to be(original_uri)
+        expect(original_uri.to_s).to eq(original_url)
+      end
+
+      it 'removes extraneous slashes' do
+        original_uri = URI('https://example.org/foo/bar')
+        new_uri = URIs.append(original_uri, '/qux', '/corge/', '//garply')
+        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux/corge/garply'))
+      end
+
+      it 'preserves queries' do
+        original_uri = URI('https://example.org/foo/bar?baz=qux')
+        new_uri = URIs.append(original_uri, '/qux', '/corge/', '//garply')
+        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux/corge/garply?baz=qux'))
+      end
+
+      it 'preserves fragments' do
+        original_uri = URI('https://example.org/foo/bar#baz')
+        new_uri = URIs.append(original_uri, '/qux', '/corge/', '//garply')
+        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux/corge/garply#baz'))
+      end
+
+      it 'accepts a query string if no previous query present' do
+        original_uri = URI('https://example.org/foo/bar#baz')
+        new_uri = URIs.append(original_uri, '/qux', '/corge/', '//garply?grault=xyzzy')
+        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux/corge/garply?grault=xyzzy#baz'))
+      end
+
+      it 'allows the ? to be passed separately' do
+        original_uri = URI('https://example.org/foo/bar#baz')
+        new_uri = URIs.append(original_uri, '/qux', '/corge/', '//garply', '?', 'grault=xyzzy')
+        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux/corge/garply?grault=xyzzy#baz'))
+      end
+
+      it 'appends query parameters with &' do
+        original_uri = URI('https://example.org/foo/bar#baz')
+        new_uri = URIs.append(original_uri, '/qux', '/corge/', '//garply?grault=xyzzy', '&plugh=flob')
+        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux/corge/garply?grault=xyzzy&plugh=flob#baz'))
+      end
+
+      it 'appends query parameters to original URI query' do
+        original_uri = URI('https://example.org/foo/bar/qux/corge/garply?grault=xyzzy')
+        new_uri = URIs.append(original_uri, '&plugh=flob')
+        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux/corge/garply?grault=xyzzy&plugh=flob'))
+      end
+
+      it 'treats & as a path element if no query is present' do
+        original_uri = URI('https://example.org/foo/bar#baz')
+        new_uri = URIs.append(original_uri, '/qux', '/corge/', 'garply', '&plugh=flob')
+        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux/corge/garply/&plugh=flob#baz'))
+      end
+
+      it 'accepts a fragment if no previous fragment present' do
+        original_uri = URI('https://example.org/foo/bar?baz=qux')
+        new_uri = URIs.append(original_uri, '/qux', '/corge/', '//garply#grault')
+        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux/corge/garply?baz=qux#grault'))
+      end
+
+      it 'rejects a query string if the original URI already has one' do
+        original_uri = URI('https://example.org/foo/bar?baz=qux')
+        expect { URIs.append(original_uri, '/qux?corge') }.to raise_error(URI::InvalidComponentError)
+      end
+
+      it 'rejects a fragment if the original URI already has one' do
+        original_uri = URI('https://example.org/foo/bar#baz')
+        expect { URIs.append(original_uri, '/qux#corge') }.to raise_error(URI::InvalidComponentError)
+      end
+
+      it 'rejects appending multiple queries' do
+        original_uri = URI('https://example.org/foo/bar')
+        expect { URIs.append(original_uri, 'baz?qux=corge', 'grault?plugh=xyzzy') }.to raise_error(URI::InvalidComponentError)
+      end
+
+      it 'rejects appending multiple fragments' do
+        original_uri = URI('https://example.org/foo/bar')
+        expect { URIs.append(original_uri, 'baz#qux', 'grault#plugh') }.to raise_error(URI::InvalidComponentError)
+      end
+
+      it 'rejects queries after fragments' do
+        original_uri = URI('https://example.org/foo/bar')
+        expect { URIs.append(original_uri, 'baz#qux', '?grault=plugh') }.to raise_error(URI::InvalidComponentError)
+      end
+
+      it 'correctly handles fragments in mid-path-segment' do
+        original_uri = URI('https://example.org/foo/bar')
+        new_uri = URIs.append(original_uri, 'qux#corge')
+        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux#corge'))
+      end
+
+      it 'correctly handles fragments in query start' do
+        original_uri = URI('https://example.org/foo/bar')
+        new_uri = URIs.append(original_uri, '?qux=corge&grault=plugh#xyzzy')
+        expect(new_uri).to eq(URI('https://example.org/foo/bar?qux=corge&grault=plugh#xyzzy'))
+      end
+
+      it 'correctly handles fragments in mid-query' do
+        original_uri = URI('https://example.org/foo/bar')
+        new_uri = URIs.append(original_uri, '?qux=corge', '&grault=plugh#xyzzy')
+        expect(new_uri).to eq(URI('https://example.org/foo/bar?qux=corge&grault=plugh#xyzzy'))
+      end
+    end
+  end
+end