berkeley_library-tind 0.4.1 → 0.4.2

data/lib/berkeley_library/util/stringios.rb

@@ -1,30 +0,0 @@
-require 'stringio'
-
-module BerkeleyLibrary
-  module Util
-    module StringIOs
-      class << self
-        include StringIOs
-      end
-
-      # Returns the byte (**not** character) at the specified byte index
-      # in the specified `StringIO`.
-      #
-      # @param s [StringIO] the StringIO to search in
-      # @param i [Integer] the byte index
-      # @return [Integer, nil] the byte, or nil if the byte index is invalid.
-      def getbyte(s, i)
-        return if i >= s.size
-        return if s.size + i < 0
-
-        pos_orig = s.pos
-        begin
-          s.seek(i >= 0 ? i : s.size + i)
-          s.getbyte
-        ensure
-          s.seek(pos_orig)
-        end
-      end
-    end
-  end
-end

data/lib/berkeley_library/util/strings.rb

@@ -1,42 +0,0 @@
-module BerkeleyLibrary
-  module Util
-    module Strings
-
-      ASCII_0 = '0'.ord
-      ASCII_9 = '9'.ord
-
-      def ascii_numeric?(s)
-        s.chars.all? do |c|
-          ord = c.ord
-          ord >= ASCII_0 && ord <= ASCII_9
-        end
-      end
-
-      # Locates the point at which two strings differ
-      #
-      # @return [Integer, nil] the index of the first character in either string
-      #   that differs from the other, or `nil` if the strings are identical,
-      #   or are not strings
-      def diff_index(s1, s2)
-        return unless string_like?(s1, s2)
-
-        shorter, longer = s1.size > s2.size ? [s2, s1] : [s1, s2]
-        shorter.chars.each_with_index do |c, i|
-          return i if c != longer[i]
-        end
-        shorter.length if shorter.length < longer.length # otherwise they're equal
-      end
-
-      class << self
-        include Strings
-      end
-
-      private
-
-      def string_like?(*strs)
-        strs.all? { |s| s.respond_to?(:chars) && s.respond_to?(:size) }
-      end
-
-    end
-  end
-end

data/lib/berkeley_library/util/sys_exits.rb

@@ -1,15 +0,0 @@
-module BerkeleyLibrary
-  module Util
-    # cf. BSD sysexits.h https://cgit.freebsd.org/src/tree/include/sysexits.h?h=releng/2.0
-    module SysExits
-      # successful termination
-      EX_OK = 0
-
-      # command line usage error
-      EX_USAGE = 64
-
-      # internal software error
-      EX_SOFTWARE = 70 # command line usage error
-    end
-  end
-end

data/lib/berkeley_library/util/times.rb

@@ -1,22 +0,0 @@
-require 'time'
-
-module BerkeleyLibrary
-  module Util
-    module Times
-      class << self
-        include Times
-      end
-
-      # @param time [Time, Date] the time
-      # @return the UTC time corresponding to `time`
-      def ensure_utc(time)
-        return unless time
-        return time if time.respond_to?(:utc?) && time.utc?
-        return time.getutc if time.respond_to?(:getutc)
-        return time.to_time.getutc if time.respond_to?(:to_time)
-
-        raise ArgumentError, "Not a date or time: #{time.inspect}"
-      end
-    end
-  end
-end

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