berkeley_library-util 0.1.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/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,59 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module Util
+    describe Strings do
+      describe :ascii_numeric do
+        it 'returns true for ASCII numeric strings' do
+          str = '8675309'
+          expect(Strings.ascii_numeric?(str)).to eq(true)
+        end
+
+        it 'returns false for non-ASCII numeric strings' do
+          strs = %w[
+            ٨٦٧٥٣٠٩
+            八六七五三〇九
+          ]
+          aggregate_failures 'non-ASCII numeric strings' do
+            strs.each do |str|
+              expect(Strings.ascii_numeric?(str)).to eq(false), "Expected #{str.inspect} to be non-ASCII-numeric"
+            end
+          end
+        end
+
+        it 'returns false for mixed ASCII numeric and non-numeric strings' do
+          strs = [
+            '867-5309',
+            '867 5309',
+            ' 8675309 '
+          ]
+          aggregate_failures 'ASCII mixed numeric and non-numeric strings' do
+            strs.each do |str|
+              expect(Strings.ascii_numeric?(str)).to eq(false), "Expected #{str.inspect} to be non-ASCII-numeric"
+            end
+          end
+        end
+      end
+
+      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/requester_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module Util
+    module URIs
+      describe Requester do
+        describe :get do
+          it 'returns an HTTP response body for a URL string' do
+            url = 'https://example.org/'
+            expected_body = 'Help! I am trapped in a unit test'
+            stub_request(:get, url).to_return(body: expected_body)
+
+            result = Requester.get(url)
+            expect(result).to eq(expected_body)
+          end
+
+          it 'returns an HTTP response body for a URI' do
+            uri = URI.parse('https://example.org/')
+            expected_body = 'Help! I am trapped in a unit test'
+            stub_request(:get, uri).to_return(body: expected_body)
+
+            result = Requester.get(uri)
+            expect(result).to eq(expected_body)
+          end
+
+          it 'appends query parameters' do
+            url = 'https://example.org/'
+            params = { p1: 1, p2: 2 }
+            url_with_query = "#{url}?#{URI.encode_www_form(params)}"
+            expected_body = 'Help! I am trapped in a unit test'
+            stub_request(:get, url_with_query).to_return(body: expected_body)
+
+            result = Requester.get(url, params: params)
+            expect(result).to eq(expected_body)
+          end
+
+          it 'sends request headers' do
+            url = 'https://example.org/'
+            headers = { 'X-help' => 'I am trapped in a unit test' }
+            expected_body = 'Help! I am trapped in a unit test'
+            stub_request(:get, url).with(headers: headers).to_return(body: expected_body)
+
+            result = Requester.get(url, headers: headers)
+            expect(result).to eq(expected_body)
+          end
+
+          it 'raises an error for a failure status' do
+            url = 'https://example.org/'
+            stub_request(:get, url).to_return(status: 404)
+
+            expect { Requester.get(url) }.to raise_error(RestClient::RequestFailed)
+          end
+
+          it 'raises an error for a weird non-failure status' do
+            url = 'https://example.org/'
+            stub_request(:get, url).to_return(status: 207)
+
+            expect { Requester.get(url) }.to raise_error(RestClient::RequestFailed)
+          end
+
+          it 'handles redirects' do
+            url1 = 'https://example.org/'
+            url2 = 'https://example.edu/'
+            stub_request(:get, url1).to_return(status: 302, headers: { 'Location' => url2 })
+            expected_body = 'Help! I am trapped in a unit test'
+            stub_request(:get, url2).to_return(body: expected_body)
+
+            result = Requester.get(url1)
+            expect(result).to eq(expected_body)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/util/uris/validator_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module Util
+    module URIs
+      describe Validator do
+        describe :uri_or_nil do
+          it 'returns a URI unchanged' do
+            uri = URI.parse('http://example.org/')
+            expect(Validator.uri_or_nil(uri)).to be(uri)
+          end
+
+          it 'converts a string to a URI' do
+            url = 'http://example.org/'
+            expect(Validator.uri_or_nil(url)).to eq(URI.parse(url))
+          end
+
+          it 'returns nil for nil' do
+            expect(Validator.uri_or_nil(nil)).to be_nil
+          end
+
+          it 'raises an error for invalid URL strings' do
+            bad_url = 'not a uri'
+            expect { Validator.uri_or_nil(bad_url) }.to raise_error(URI::InvalidURIError)
+          end
+        end
+
+        describe :url_str_or_nil do
+          it 'returns a URL string for a URI' do
+            uri = URI.parse('http://example.org/')
+            expect(Validator.url_str_or_nil(uri)).to eq(uri.to_s)
+          end
+
+          it 'returns a URL string' do
+            url = 'http://example.org/'
+            expect(Validator.url_str_or_nil(url)).to eq(url)
+          end
+
+          it 'returns nil for nil' do
+            expect(Validator.url_str_or_nil(nil)).to be_nil
+          end
+
+          it 'raises an error for invalid URL strings' do
+            bad_url = 'not a uri'
+            expect { Validator.url_str_or_nil(bad_url) }.to raise_error(URI::InvalidURIError)
+          end
+        end
+      end
+    end
+  end
+end