berkeley_library-tind 0.4.0 → 0.5.0

data/lib/berkeley_library/util/uris/appender.rb

@@ -1,162 +0,0 @@
-require 'berkeley_library/util/paths'
-require 'uri'
-require 'typesafe_enum'
-
-module BerkeleyLibrary
-  module Util
-    module URIs
-
-      # Appends the specified paths to the path of the specified URI, removing any extraneous slashes,
-      # and builds a new URI with that path and the same scheme, host, query, fragment, etc.
-      # as the original.
-      class Appender
-        attr_reader :original_uri, :elements
-
-        # Creates and invokes a new {Appender}.
-        #
-        # @param uri [URI, String] the original URI
-        # @param elements [Array<String, Symbol>] the URI elements to join.
-        # @raise URI::InvalidComponentError if appending the specified elements would create an invalid URI
-        def initialize(uri, *elements)
-          raise ArgumentError, 'uri cannot be nil' unless (@original_uri = URIs.uri_or_nil(uri))
-
-          @elements = elements.map(&:to_s)
-          @elements.each_with_index do |element, elem_index|
-            next start_query_at(elem_index) if element.include?('?')
-            next start_fragment_at(elem_index) if element.include?('#')
-
-            add_element(element)
-          end
-        end
-
-        # Returns the new URI.
-        #
-        # @return [URI] a new URI appending the joined path elements.
-        # @raise URI::InvalidComponentError if appending the specified elements would create an invalid URI
-        def to_uri
-          original_uri.dup.tap do |new_uri|
-            new_uri.path = Paths.join(original_uri.path, *path_elements)
-            new_uri.query = query unless query_elements.empty?
-            new_uri.fragment = fragment unless fragment_elements.empty?
-          end
-        end
-
-        private
-
-        def state
-          @state ||= :path
-        end
-
-        def in_query?
-          state == :query
-        end
-
-        def in_fragment?
-          state == :fragment
-        end
-
-        def query
-          query_elements.join
-        end
-
-        def fragment
-          fragment_elements.join
-        end
-
-        def path_elements
-          @path_elements ||= []
-        end
-
-        def query_elements
-          @query_elements ||= [].tap { |e| e << original_uri.query if original_uri.query }
-        end
-
-        def fragment_elements
-          @fragment_elements ||= [].tap { |e| e << original_uri.fragment if original_uri.fragment }
-        end
-
-        def start_query_at(elem_index)
-          raise URI::InvalidComponentError, err_query_after_fragment(elem_index) if in_fragment?
-          raise URI::InvalidComponentError, err_too_many_queries(elem_index) unless query_elements.empty?
-
-          handle_query_start(elem_index)
-          @state = :query
-        end
-
-        def start_fragment_at(elem_index)
-          raise URI::InvalidComponentError, err_too_many_fragments(elem_index) unless fragment_elements.empty?
-          raise URI::InvalidComponentError, err_query_after_fragment(elem_index) if query_after_fragment?(elem_index)
-
-          handle_fragment_start(elem_index)
-          @state = :fragment
-        end
-
-        def query_after_fragment?(elem_index)
-          e = elements[elem_index]
-          e.index('?', e.index('#'))
-        end
-
-        def add_element(e)
-          return fragment_elements << e if in_fragment?
-          return query_elements << e if in_query? || (e.include?('&') && !query_elements.empty?)
-
-          path_elements << e
-        end
-
-        def handle_query_start(elem_index)
-          element = elements[elem_index]
-
-          # if there's anything before the '?', we treat that excess as a path element
-          excess, q_start = split_around(element, element.index('?'))
-          q_start = push_fragment_start(elem_index, q_start)
-
-          query_elements << q_start
-          path_elements << excess
-        end
-
-        # if the fragment starts in the middle of this element, we keep the part before
-        # the fragment delimiter '#', and push the rest (w/'#') back onto the next element
-        # to be parsed in the next iteration
-        def push_fragment_start(elem_index, q_start)
-          return q_start unless (f_index = q_start.index('#'))
-
-          next_index = elem_index + 1
-          q_start, q_next = split_around(q_start, f_index)           # NOTE: this doesn't return the '#'
-          elements[next_index] = "##{q_next}#{elements[next_index]}" #       so we prepend one here
-          q_start
-        end
-
-        def handle_fragment_start(elem_index)
-          element = elements[elem_index]
-
-          # if there's anything before the '#', we treat that excess as a path element,
-          # or as a query element if there's a query
-          excess, f_start = split_around(element, element.index('#'))
-
-          fragment_elements << f_start
-          if in_query?
-            query_elements << excess
-          else
-            path_elements << excess
-          end
-        end
-
-        def split_around(s, i)
-          [s[0...i], s[(i + 1)..]]
-        end
-
-        def err_too_many_queries(elem_index)
-          "#{elements[elem_index].inspect}: URI already has a query string: #{query.inspect}"
-        end
-
-        def err_query_after_fragment(elem_index)
-          "#{elements[elem_index].inspect}: Query delimiter '?' cannot follow fragment delimeter '#'"
-        end
-
-        def err_too_many_fragments(elem_index)
-          "#{elements[elem_index].inspect}: URI already has a fragment: #{fragment.inspect}"
-        end
-      end
-    end
-  end
-end

data/lib/berkeley_library/util/uris/requester.rb

@@ -1,62 +0,0 @@
-require 'rest-client'
-require 'berkeley_library/util/uris/appender'
-require 'berkeley_library/util/uris/validator'
-require 'berkeley_library/logging'
-
-module BerkeleyLibrary
-  module Util
-    module URIs
-      module Requester
-        class << self
-          include BerkeleyLibrary::Logging
-
-          # Performs a GET request.
-          #
-          # @param uri [URI, String] the URI to GET
-          # @param params [Hash] the query parameters to add to the URI. (Note that the URI may already include query parameters.)
-          # @param headers [Hash] the request headers.
-          # @return [String] the body as a string.
-          # @raise [RestClient::Exception] in the event of an error.
-          def get(uri, params = {}, headers = {})
-            url_str = url_str_with_params(uri, params)
-            resp = get_or_raise(url_str, headers)
-            resp.body
-          end
-
-          private
-
-          def url_str_with_params(uri, params)
-            raise ArgumentError, 'uri cannot be nil' unless (url_str = Validator.url_str_or_nil(uri))
-
-            elements = [].tap do |ee|
-              ee << url_str
-              ee << '?' unless url_str.include?('?')
-              ee << URI.encode_www_form(params)
-            end
-
-            uri = Appender.new(*elements).to_uri
-            uri.to_s
-          end
-
-          def get_or_raise(url_str, headers)
-            resp = RestClient.get(url_str, headers)
-            begin
-              return resp if (status = resp.code) == 200
-
-              raise(exception_for(resp, status))
-            ensure
-              logger.info("GET #{url_str} returned #{status}")
-            end
-          end
-
-          def exception_for(resp, status)
-            RestClient::RequestFailed.new(resp, status).tap do |ex|
-              status_message = RestClient::STATUSES[status] || '(Unknown)'
-              ex.message = "#{status} #{status_message}"
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/berkeley_library/util/uris/validator.rb

@@ -1,32 +0,0 @@
-require 'uri'
-
-module BerkeleyLibrary
-  module Util
-    module URIs
-      module Validator
-        class << self
-
-          # Returns the specified URL as a URI.
-          # @param url [String, URI] the URL.
-          # @return [URI] the URI.
-          # @raise [URI::InvalidURIError] if `url` cannot be parsed as a URI.
-          def uri_or_nil(url)
-            return unless url
-
-            # noinspection RubyYardReturnMatch
-            url.is_a?(URI) ? url : URI.parse(url.to_s)
-          end
-
-          # Returns the specified URL as a string.
-          # @param url [String, URI] the URL.
-          # @return [String] the URL.
-          # @raise [URI::InvalidURIError] if `url` cannot be parsed as a URI.
-          def url_str_or_nil(url)
-            uri = Validator.uri_or_nil(url)
-            uri.to_s if uri
-          end
-        end
-      end
-    end
-  end
-end

data/lib/berkeley_library/util/uris.rb

@@ -1,44 +0,0 @@
-require 'berkeley_library/util/uris/appender'
-require 'berkeley_library/util/uris/requester'
-require 'berkeley_library/util/uris/validator'
-
-module BerkeleyLibrary
-  module Util
-    module URIs
-      class << self
-        include URIs
-      end
-
-      # Appends the specified paths to the path of the specified URI, removing any extraneous slashes
-      # and merging additional query parameters, and returns a new URI with that path and the same scheme,
-      # host, query, fragment, etc. as the original.
-      #
-      # @param uri [URI, String] the original URI
-      # @param elements [Array<String, Symbol>] the URI elements to join.
-      # @return [URI] a new URI appending the joined path elements.
-      # @raise URI::InvalidComponentError if appending the specified elements would create an invalid URI
-      def append(uri, *elements)
-        Appender.new(uri, *elements).to_uri
-      end
-
-      # Performs a GET request.
-      #
-      # @param uri [URI, String] the URI to GET
-      # @param params [Hash] the query parameters to add to the URI. (Note that the URI may already include query parameters.)
-      # @param headers [Hash] the request headers.
-      # @return [String] the body as a string.
-      # @raise [RestClient::Exception] in the event of an error.
-      def get(uri, params = {}, headers = {})
-        Requester.get(uri, params, headers)
-      end
-
-      # Returns the specified URL as a URI.
-      # @param url [String, URI] the URL.
-      # @return [URI] the URI.
-      # @raise [URI::InvalidURIError] if `url` cannot be parsed as a URI.
-      def uri_or_nil(url)
-        Validator.uri_or_nil(url)
-      end
-    end
-  end
-end

data/spec/berkeley_library/util/arrays_spec.rb

@@ -1,340 +0,0 @@
-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