hearth 1.0.0.pre2 → 1.0.0.pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bace852980aa4785929fce82aeb1a0b683fd6cf1f77d83d1dee39315d8177361
-  data.tar.gz: bff4b301d6940ccb485973b728b761e0d773489068cb093bf1789fcfe8cd1c35
+  metadata.gz: 5a6aa5be0acf82ba6ba9b2d399c702fd0da402764dd4769cc3d72a632074dbb4
+  data.tar.gz: f7b14b1778860d004cb9fcea31c1fb0d230760c330447136414342f37cbd3a52
 SHA512:
-  metadata.gz: 27e9e5a1c32430314c3df34e843efef873231e5691d4d7df262615e4a9b65fb1f29dbdf8c0b4037e2a86d13d7597e2ff29b45d8eea8db87b2ed1559740b4c53c
-  data.tar.gz: ae6db7148e7cc6b98d8a2d0cc0bab09327ff10774c78e5b3fd76ef8a219ac07ebff636fd7636c7c17ed53f3fcbf964ce111a8e3d11d090120d59f95d2eafb227
+  metadata.gz: dd6f92a2e98ab0942ddd68a6edb86cd4e274389c4d1595ec2ff360a6c6a7a9887a5534a58271009eef0697018bf8327b5c144cc47a541e102d57a0f3fe198be2
+  data.tar.gz: 7ae01e2405d9d7301ea2b9f6b8805fcd438de16d498b9e394f7e0ba5452a3acc6e681b5a32e7371b3cbe9fced1984ded25e4b16bb3512d1bf282f19079490614

data/CHANGELOG.md

@@ -1,6 +1,11 @@
 Unreleased Changes
 ------------------
 
+1.0.0.pre3 (2024-05-01)
+------------------
+
+* Feature - Third initial public pre-release for Smithy Ruby SDKs.
+
 1.0.0.pre2 (2023-12-19)
 ------------------
 

data/VERSION

@@ -1 +1 @@
-1.0.0.pre2
+1.0.0.pre3

data/lib/hearth/anonymous_auth_resolver.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Hearth
+  # Always returns the Anonymous/noAuth auth scheme.
+  # Can be used to effectively disable/skip auth.
+  class AnonymousAuthResolver
+    def resolve(_params)
+      [Hearth::AuthOption.new(scheme_id: 'smithy.api#noAuth')]
+    end
+  end
+end

data/lib/hearth/auth_schemes/anonymous.rb

@@ -12,9 +12,9 @@ module Hearth
         )
       end
 
-      # @return [IdentityResolver, nil]
-      def identity_resolver(_identity_resolvers = {})
-        Hearth::IdentityResolver.new(proc { Identities::Anonymous.new })
+      # @return [IdentityProvider, nil]
+      def identity_provider(_identity_providers = {})
+        Hearth::IdentityProvider.new(proc { Identities::Anonymous.new })
       end
     end
   end

data/lib/hearth/auth_schemes.rb

@@ -14,9 +14,9 @@ module Hearth
       # @return [String]
       attr_reader :scheme_id
 
-      # @return [IdentityResolver, nil]
-      def identity_resolver(identity_resolvers = {})
-        identity_resolvers[@identity_type]
+      # @return [IdentityProvider, nil]
+      def identity_provider(identity_provider = {})
+        identity_provider[@identity_type]
       end
 
       # @return [Signers::Base]

data/lib/hearth/client.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'client_stubs'
+
+module Hearth
+  # Base Client class for all generated SDK clients.
+  class Client
+    include ClientStubs
+
+    # Plugins applied to all instances of this client.
+    # @return [Hearth::PluginList]
+    def self.plugins
+      @plugins ||= PluginList.new
+    end
+
+    # @param [Hash] options
+    #   Options used to construct an instance of {Config}
+    # @param [Class] config_class
+    #   The configuration class to use.
+    def initialize(options, config_class)
+      @config = initialize_config(options, config_class)
+    end
+
+    # @return [Configuration]
+    attr_reader :config
+
+    private
+
+    def initialize_config(options, config_class)
+      client_interceptors = options.delete(:interceptors) || []
+      config = config_class.new(**options)
+      config.validate!
+      self.class.plugins.each { |p| p.call(config) }
+      config.plugins.each { |p| p.call(config) }
+      config.interceptors.concat(client_interceptors)
+      config.validate!
+      config.freeze
+    end
+
+    def operation_config(options)
+      return @config if options.empty?
+
+      if options.include?(:stub_responses) || options.include?(:stubs)
+        msg = 'Overriding stubs or stub_responses on ' \
+              'operations is not allowed'
+        raise ArgumentError, msg
+      end
+
+      operation_plugins = options.delete(:plugins)
+      operation_interceptors = options.delete(:interceptors) || []
+      config = @config.merge(options)
+      config.validate!
+      operation_plugins&.each { |p| p.call(config) }
+      config.interceptors.concat(operation_interceptors)
+      config.validate!
+      config.freeze
+    end
+
+    def output_stream(options = {}, &block)
+      return options.delete(:output_stream) if options[:output_stream]
+      return Hearth::BlockIO.new(block) if block
+
+      ::StringIO.new
+    end
+  end
+end

data/lib/hearth/client_stubs.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'stubs'
-
 module Hearth
   # This module provides the ability to specify the data and/or errors to
   # return when a client is using stubbed responses.
@@ -119,7 +117,7 @@ module Hearth
     #   `:stub_responses => true`.
     def stub_responses(operation_name, *stubs)
       if @config.stub_responses
-        @stubs.add_stubs(operation_name, stubs.flatten)
+        @config.stubs.set_stubs(operation_name, stubs.flatten)
       else
         msg = 'Stubbing is not enabled. Enable stubbing in Config ' \
               'with `stub_responses: true`'

data/lib/hearth/config/resolver.rb

@@ -38,11 +38,12 @@ module Hearth
 
       def resolve_default(key)
         @defaults[key]&.each do |default|
-          value = if default.respond_to?(:call)
-                    default.call(self)
-                  else
-                    default
-                  end
+          value =
+            if default.respond_to?(:call)
+              default.call(self)
+            else
+              default
+            end
           return value unless value.nil?
         end
         nil

data/lib/hearth/context.rb

@@ -14,6 +14,7 @@ module Hearth
       @response = options[:response]
       @logger = options[:logger]
       @interceptors = options[:interceptors] || InterceptorList.new
+      @auth = options[:auth]
       @metadata = options[:metadata] || {}
     end
 

data/lib/hearth/dns/host_address.rb

@@ -3,21 +3,25 @@
 module Hearth
   module DNS
     # Address results from a DNS lookup in {HostResolver}.
-    class HostAddress
-      def initialize(address_type:, address:, hostname:)
-        @address_type = address_type
-        @address = address
-        @hostname = hostname
-      end
-
-      # @return [Symbol]
-      attr_reader :address_type
-
-      # @return [String]
-      attr_reader :address
-
-      # @return [String]
-      attr_reader :hostname
-    end
+    # @!method initialize(*args)
+    #   @option args [Symbol] :address_type The type of address. For example,
+    #    :A or :AAAA.
+    #   @option args [String] :address The IP address.
+    #   @option args [String] :hostname The hostname that was resolved.
+    # @!attribute address_type
+    #   The type of address. For example, :A or :AAAA.
+    #   @return [Symbol]
+    # @!attribute address
+    #   The IP address.
+    #   @return [String]
+    # @!attribute hostname
+    #   The hostname that was resolved.
+    #   @return [String]
+    HostAddress = Struct.new(
+      :address_type,
+      :address,
+      :hostname,
+      keyword_init: true
+    )
   end
 end

data/lib/hearth/endpoint_rules.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require 'ipaddr'
+require 'uri'
+
+module Hearth
+  # Functions in the Smithy rules engine are named routines that
+  # operate on a finite set of specified inputs, returning an output.
+  # The rules engine has a set of included functions that can be
+  # invoked without additional dependencies, called the standard library.
+  module EndpointRules
+    # An Authentication Scheme supported by an Endpoint
+    # @!attribute scheme_id
+    #   The identifier of the authentication scheme.
+    #   @return [String]
+    # @!attribute properties
+    #   Additional properties of the authentication scheme.
+    #   @return [Hash]
+    AuthScheme = Struct.new(
+      :scheme_id,
+      :properties,
+      keyword_init: true
+    ) do
+      # @option args [String] :scheme_id
+      # @option args [Hash] :properties ({})
+      def initialize(*args)
+        super
+        self.properties ||= {}
+      end
+    end
+
+    # An Endpoint resolved by an EndpointProvider
+    # @!attribute uri
+    #   The URI of the endpoint.
+    #   @return [String]
+    # @!attribute auth_schemes
+    #   The authentication schemes supported by the endpoint.
+    #   @return [Array<AuthScheme>]
+    # @!attribute headers
+    #   The headers to include in requests to the endpoint.
+    #   @return [Hash]
+    Endpoint = Struct.new(
+      :uri,
+      :auth_schemes,
+      :headers,
+      keyword_init: true
+    ) do
+      # @option args [String] :uri
+      # @option args [Array<AuthScheme>] :auth_schemes ([])
+      # @option args [Hash] :headers ({})
+      def initialize(*args)
+        super
+        self.auth_schemes ||= []
+        self.headers ||= {}
+      end
+    end
+
+    # Evaluates whether the input string is a compliant RFC 1123 host segment.
+    # When allowSubDomains is true, evaluates whether the input string is
+    # composed of values that are each compliant RFC 1123 host segments
+    # joined by dot (.) characters.
+    # @api private
+    # rubocop:disable Style/OptionalBooleanParameter
+    def self.valid_host_label?(value, allow_sub_domains = false)
+      return false if value.empty?
+
+      if allow_sub_domains
+        labels = value.split('.', -1)
+        return labels.all? { |l| valid_host_label?(l, false) }
+      end
+
+      !!(value =~ /\A(?!-)[a-zA-Z0-9-]{1,63}(?<!-)\z/)
+    end
+    # rubocop:enable Style/OptionalBooleanParameter
+
+    # Computes a URL structure given an input string.
+    # @api private
+    def self.parse_url(value)
+      URL.new(value).as_json
+    rescue ArgumentError, URI::InvalidURIError
+      nil
+    end
+
+    # Computes a portion of a given string based on
+    # the provided start and end indices.
+    # @api private
+    def self.substring(input, start, stop, reverse)
+      return nil if start >= stop || input.size < stop
+
+      return nil if input.chars.any? { |c| c.ord > 127 }
+
+      return input[start...stop] unless reverse
+
+      r_start = input.size - stop
+      r_stop = input.size - start
+      input[r_start...r_stop]
+    end
+
+    # Performs RFC 3986#section-2.1 defined percent-encoding on the input value.
+    # @api private
+    def self.uri_encode(value)
+      CGI.escape(value.encode('UTF-8')).gsub('+', '%20').gsub('%7E', '~')
+    end
+
+    # @api private
+    class URL
+      def initialize(url)
+        uri = URI(url)
+        @scheme = uri.scheme
+        # only support http and https schemes
+        raise ArgumentError unless %w[https http].include?(@scheme)
+
+        # do not support query
+        raise ArgumentError if uri.query
+
+        @authority = _authority(url, uri)
+        @path = uri.path
+        @normalized_path = uri.path + (uri.path[-1] == '/' ? '' : '/')
+        @is_ip = _is_ip(uri.host)
+      end
+
+      attr_reader :scheme, :authority, :path, :normalized_path, :is_ip
+
+      def as_json(_options = {})
+        {
+          'scheme' => scheme,
+          'authority' => authority,
+          'path' => path,
+          'normalizedPath' => normalized_path,
+          'isIp' => is_ip
+        }
+      end
+
+      private
+
+      def _authority(url, uri)
+        # don't include port if it's default and not parsed originally
+        if uri.default_port == uri.port && !url.include?(":#{uri.port}")
+          uri.host
+        else
+          "#{uri.host}:#{uri.port}"
+        end
+      end
+
+      def _is_ip(authority)
+        IPAddr.new(authority)
+        true
+      rescue IPAddr::InvalidAddressError
+        false
+      end
+    end
+  end
+end

data/lib/hearth/http/client.rb

@@ -11,7 +11,7 @@ module Hearth
     class Client
       # @api private
       OPTIONS = {
-        logger: Logger.new($stdout),
+        logger: nil,
         debug_output: nil,
         proxy: nil,
         open_timeout: 15,
@@ -31,12 +31,11 @@ module Hearth
       #
       # @param [Hash] options The options for this HTTP Client
       #
-      # @option options [Logger] :logger (Logger.new($stdout)) A logger
-      #   used to log Net::HTTP requests and responses when `:debug_output`
-      #   is enabled.
+      # @option options [Logger] :logger (nil) A logger used to log Net::HTTP
+      #   requests and responses when `:debug_output` is enabled.
       #
       # @option options [Boolean] :debug_output (false) When `true`,
-      #   sets an output stream to the configured Logger for debugging.
+      #   sets an output stream to the configured Logger (if any) for debugging.
       #
       # @option options [String, URI] :proxy A proxy to send
       #   requests through. Formatted like 'http://proxy.com:123'.
@@ -131,11 +130,10 @@ module Hearth
       end
 
       # Starts and returns a new HTTP connection.
-      # @param [URI] endpoint
       # @return [Net::HTTP]
       def new_connection(endpoint, logger)
         http = create_http(endpoint)
-        http.set_debug_output(logger || @logger) if @debug_output
+        http.set_debug_output(@logger || logger) if @debug_output
         configure_timeouts(http)
 
         if endpoint.scheme == 'https'

data/lib/hearth/http/error_inspector.rb

@@ -5,7 +5,6 @@ require 'time'
 module Hearth
   module HTTP
     # An HTTP error inspector, using hints from status code and headers.
-    # @api private
     class ErrorInspector
       def initialize(error, http_response)
         @error = error
@@ -17,6 +16,7 @@ module Hearth
           throttling? ||
           transient? ||
           server?) &&
+          # IO does not respond to #truncate and is not rewindable
           @http_response.body.respond_to?(:truncate)
       end
 
@@ -77,7 +77,7 @@ module Hearth
         rescue ArgumentError # empty string, somehow
           nil
         end
-      rescue TypeError # header is not prseent
+      rescue TypeError # header is not present
         nil
       end
     end

data/lib/hearth/http/field.rb

@@ -5,9 +5,8 @@ module Hearth
     # Represents an HTTP field.
     class Field
       # @param [String] name The name of the field.
-      # @param [Array|#to_s] value (nil) The values for the field. It can be any
-      #   object that responds to `#to_s` or an Array of objects that respond to
-      #  `#to_s`.
+      # @param [#to_s] value (nil) The value for the field. It can be any
+      #   object that responds to `#to_s`.
       # @param [Symbol] kind The kind of field, either :header or :trailer.
       def initialize(name, value = nil, kind: :header)
         if name.nil? || name.empty?
@@ -25,17 +24,10 @@ module Hearth
       # @return [Symbol]
       attr_reader :kind
 
-      # Returns an escaped string representation of the field.
+      # Returns a string representation of the field.
       # @return [String]
       def value(encoding = nil)
-        value =
-          if @value.is_a?(Array)
-            @value.compact.map { |v| escape_value(v.to_s) }.join(', ')
-          else
-            @value.to_s
-          end
-        value = value.encode(encoding) if encoding
-        value
+        encoding ? @value.to_s.encode(encoding) : @value.to_s
       end
 
       # @return [Boolean]
@@ -52,13 +44,6 @@ module Hearth
       def to_h
         { @name => value }
       end
-
-      private
-
-      def escape_value(str)
-        s = str
-        s.include?('"') || s.include?(',') ? "\"#{s.gsub('"', '\"')}\"" : s
-      end
     end
   end
 end

data/lib/hearth/http/header_list_builder.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Hearth
+  module HTTP
+    # @api private
+    module HeaderListBuilder
+      class << self
+        def build_list(value)
+          value.compact.join(', ')
+        end
+
+        # builds a string from a list of possibly quoted values
+        # ensures that quoted values are escaped
+        def build_string_list(value)
+          value.compact.map { |s| escape_value(s) }.join(', ')
+        end
+
+        def build_http_date_list(value)
+          value.compact.map { |t| Hearth::TimeHelper.to_http_date(t) }
+               .join(', ')
+        end
+
+        def build_date_time_list(value)
+          value.compact.map { |t| Hearth::TimeHelper.to_date_time(t) }
+               .join(', ')
+        end
+
+        def build_epoch_seconds_list(value)
+          value.compact.map { |t| Hearth::TimeHelper.to_epoch_seconds(t) }
+               .join(', ')
+        end
+
+        private
+
+        def escape_value(str)
+          s = str
+          s.include?('"') || s.include?(',') ? "\"#{s.gsub('"', '\"')}\"" : s
+        end
+      end
+    end
+  end
+end

data/lib/hearth/http/header_list_parser.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'strscan'
+
+module Hearth
+  module HTTP
+    # @api private
+    module HeaderListParser
+      class << self
+        def parse_boolean_list(value)
+          value.split(', ').map { |s| s == 'true' }
+        end
+
+        def parse_integer_list(value)
+          value.split(', ').map(&:to_i)
+        end
+
+        def parse_float_list(value)
+          value.split(', ').map(&:to_f)
+        end
+
+        # parse a list of possibly quoted and escaped string values
+        # Follows:
+        # # [RFC-7230's specification of header values](https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.6).
+        def parse_string_list(value)
+          buffer = StringScanner.new(value)
+          parsed = []
+
+          parsed << read_value(buffer) until buffer.eos?
+
+          parsed
+        end
+
+        #  rfc822/http-date has a comma after day but is NOT escaped.
+        # # eg: Mon, 16 Dec 2019 23:48:18 GMT, Mon, 16 Dec 2019 23:48:18 GMT
+        def parse_http_date_list(value)
+          value.split(',').each_slice(2).map { |v| Time.parse(v[0] + v[1]) }
+        end
+
+        def parse_date_time_list(value)
+          value.split(',').map { |v| Time.parse(v) }
+        end
+
+        def parse_epoch_seconds_list(value)
+          value.split(',').map { |v| Time.at(v.to_i) }
+        end
+
+        private
+
+        def read_value(buffer)
+          until buffer.eos?
+            case buffer.peek(1)
+            when ' ', "\t"
+              # drop leading whitespace
+              buffer.getch
+              next
+            when '"'
+              buffer.getch # drop the quote and advance
+              return read_quoted_value(buffer)
+            else
+              return read_unquoted_value(buffer)
+            end
+          end
+          # buffer is only whitespace
+          nil
+        end
+
+        def read_unquoted_value(buffer)
+          # there cannot be any escaped values
+          value = buffer.scan_until(/,|$/)
+          # drop the comma if we matched it
+          buffer.matched == ',' ? value.chop : value
+        end
+
+        def read_quoted_value(buffer)
+          # scan until we have an unescaped double quote
+          value = buffer.scan_until(/[^\\]"/)
+          unless value
+            raise ArgumentError,
+                  'Invalid String list: No closing quote found'
+          end
+
+          # drop any remaining whitespace/commas
+          buffer.scan_until(/[\s,]*/)
+          # the last character will always be the closing quote.
+          # Add a starting quote and then unescape (undump)
+          "\"#{value}".undump
+        end
+      end
+    end
+  end
+end

data/lib/hearth/http/middleware/content_length.rb

@@ -4,7 +4,6 @@ module Hearth
   module HTTP
     module Middleware
       # A middleware that sets Content-Length for any body that has a size.
-      # @api private
       class ContentLength
         include Hearth::Middleware::Logging
 
@@ -17,9 +16,10 @@ module Hearth
         # @return [Output]
         def call(input, context)
           request = context.request
+          body = request.body
           if !request.headers.key?('Content-Length') &&
-             request.body.respond_to?(:size)
-            length = request.body.size
+             (body.respond_to?(:size) && body.size.positive?)
+            length = body.size
             request.headers['Content-Length'] = length
             log_debug(context, "Set Content-Length to #{length}")
           end

data/lib/hearth/http/middleware/content_md5.rb

@@ -4,7 +4,6 @@ module Hearth
   module HTTP
     module Middleware
       # A middleware that sets Content-MD5 for any body.
-      # @api private
       class ContentMD5
         include Hearth::Middleware::Logging