hearth 1.0.0.pre1 → 1.0.0.pre2

data/lib/hearth/middleware_builder.rb

@@ -1,246 +0,0 @@
-# frozen_string_literal: true
-
-module Hearth
-  # A utility class for registering middleware for a request.
-  # You register middleware handlers to execute relative to
-  # Middleware classes.  You can register middleware
-  # before/after/around any middleware class in the stack.
-  # You may also remove middleware from the stack.
-  # There are also convenience methods
-  # (eg: before_build, after_parse, ect)
-  # defined for all of the key request lifecycle events:
-  #
-  # * validate
-  # * host_prefix
-  # * build
-  # * send
-  # * parse
-  # * retry
-  #
-  # You can register request handlers that invoke before, after,
-  # or around each lifecycle events. These handlers are
-  # request, response, or around handlers.
-  #
-  # All before/after/around methods are defined on the class
-  # and instance and are chainable:
-  #
-  #    MiddlewareBuilder.before_send(my_request_handler)
-  #       .after_parse(my_response_handler)
-  #
-  # ## Request Handlers
-  #
-  # A request handler is invoked before the request is sent.
-  #
-  #    # invoked after a request has been built, but before it has
-  #    # been signed/authorized
-  #    middleware.before_build do |input, context|
-  #      # use input, inspect or modify the request
-  #      # context.request
-  #    end
-  #
-  # ## Response Handlers
-  #
-  # A response handler is invoked after the HTTP request has been sent
-  # and a HTTP response has been received.
-  #
-  #    # invoked after the HTTP response has been parsed
-  #    middleware.after_parse do |output, context|
-  #      # inspect or modify the output or context
-  #      # output.data
-  #      # output.error
-  #      # context.response
-  #    end
-  #
-  # ## Around Handlers
-  #
-  # Around handlers see a request before it has been sent along
-  # with the response returned. Around handlers must invoke `#call`
-  # method of the next middleware in the stack. Around handlers
-  # must also return the response returned from the next middleware.
-  #
-  #     # invoke before the request  has been sent, receives the
-  #     # response from the send middleware
-  #     middleware.around_send do |app, input, context|
-  #
-  #       # this code is invoked before the request is sent
-  #       # ...
-  #
-  #       # around handlers MUST call the next middleware in the stack
-  #       output = app.call(input, context)
-  #
-  #       # this code is invoked after the response has been received
-  #       # ...
-  #
-  #       # around handlers must return the response down the stack
-  #       output
-  #     end
-  #
-  # ## Removing Middleware
-  # You may remove existing middleware from the stack using either the class
-  # or instance `remove` methods and providing the middleware class to
-  # be removed.  The remove methods are chainable and convenience methods are
-  # defined for the same set of lifecycle events as the `before`, `after`
-  # and `around` methods:
-  #
-  #   # create a middleware builder that removes send and build middlewares
-  #   MiddlewareBuilder
-  #     .remove_send
-  #     .remove_build
-  #
-  class MiddlewareBuilder
-    # @private
-    BOTH = 'expected a handler or a Proc, got both'
-
-    # @private
-    NEITHER = 'expected a handler or a Proc, got neither'
-
-    # @private
-    TOO_MANY = 'wrong number of arguments (given %<count>d, expected 0 or 1)'
-
-    # @private
-    CALLABLE = 'expected handler to respond to #call'
-
-    # @param [Proc, MiddlewareBuilder] middleware
-    #
-    #   If `middleware` is another {MiddlewareBuilder} instance, then
-    #   the middleware handlers are copied.
-    #
-    def initialize(middleware = nil)
-      @middleware = []
-      case middleware
-      when MiddlewareBuilder then @middleware.concat(middleware.to_a)
-      when nil then nil
-      else
-        raise ArgumentError, 'expected :middleware to be a' \
-                             'Hearth::MiddlewareBuilder,' \
-                             " got #{middleware.class}"
-      end
-    end
-
-    # @param [MiddlewareStack] middleware_stack
-    def apply(middleware_stack)
-      @middleware.each do |handler|
-        method, relation, middleware, kwargs = handler
-        if method == :remove
-          middleware_stack.remove(relation)
-        else
-          middleware_stack.send(method, relation, middleware, **kwargs)
-        end
-      end
-    end
-
-    def before(klass, *args, &block)
-      @middleware << [
-        :use_before,
-        klass,
-        Middleware::RequestHandler,
-        { handler: handler_or_proc!(args, &block) }
-      ]
-      self
-    end
-
-    def after(klass, *args, &block)
-      @middleware << [
-        :use_before,
-        klass,
-        Middleware::ResponseHandler,
-        { handler: handler_or_proc!(args, &block) }
-      ]
-      self
-    end
-
-    def around(klass, *args, &block)
-      @middleware << [
-        :use_before,
-        klass,
-        Middleware::AroundHandler,
-        { handler: handler_or_proc!(args, &block) }
-      ]
-      self
-    end
-
-    def remove(klass)
-      @middleware << [
-        :remove,
-        klass,
-        nil,
-        nil
-      ]
-      self
-    end
-
-    # Define convenience methods for chaining
-    class << self
-      def before(klass, *args, &block)
-        MiddlewareBuilder.new.before(klass, *args, &block)
-      end
-
-      def after(klass, *args, &block)
-        MiddlewareBuilder.new.after(klass, *args, &block)
-      end
-
-      def around(klass, *args, &block)
-        MiddlewareBuilder.new.around(klass, *args, &block)
-      end
-
-      def remove(klass)
-        MiddlewareBuilder.new.remove(klass)
-      end
-    end
-
-    # define convenience methods for standard middleware classes
-    # these define methods and class methods for before,after,around
-    # eg: before_build, after_build, around_build.
-    STANDARD_MIDDLEWARE = [
-      Hearth::Middleware::Validate,
-      Hearth::Middleware::HostPrefix,
-      Hearth::Middleware::Build,
-      Hearth::Middleware::Send,
-      Hearth::Middleware::Retry,
-      Hearth::Middleware::Parse
-    ].freeze
-
-    STANDARD_MIDDLEWARE.each do |klass|
-      simple_step_name = klass.to_s.split('::').last.downcase
-      %w[before after around].each do |method|
-        method_name = "#{method}_#{simple_step_name}"
-        define_method(method_name) do |*args, &block|
-          return send(method, klass, *args, &block)
-        end
-
-        define_singleton_method(method_name) do |*args, &block|
-          return send(method, klass, *args, &block)
-        end
-      end
-
-      remove_method_name = "remove_#{simple_step_name}"
-      define_method(remove_method_name) do
-        return remove(klass)
-      end
-
-      define_singleton_method(remove_method_name) do
-        return remove(klass)
-      end
-    end
-
-    def to_a
-      @middleware
-    end
-
-    private
-
-    def handler_or_proc!(args, &block)
-      validate_args!(args, &block)
-      callable = args.first || Proc.new(&block)
-      raise ArgumentError, CALLABLE unless callable.respond_to?(:call)
-
-      callable
-    end
-
-    def validate_args!(args, &block)
-      raise ArgumentError, BOTH if args.size.positive? && block
-      raise ArgumentError, NEITHER if args.empty? && block.nil?
-      raise ArgumentError, format(TOO_MANY, count: args.size) if args.size > 1
-    end
-  end
-end

data/lib/hearth/stubbing/client_stubs.rb

@@ -1,115 +0,0 @@
-# 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.
-  # This module should be included in generated service clients.
-  #
-  # Pass `stub_responses: true` to a client constructor to enable this
-  # behavior.
-  module ClientStubs
-    # Configures what data / errors should be returned from the named operation
-    # when response stubbing is enabled.
-    #
-    # ## Basic usage
-    #
-    # When you enable response stubbing, the client will generate fake
-    # responses and will not make any HTTP requests.
-    #
-    #     client = Service::Client.new(stub_responses: true)
-    #     client.operation
-    #     #=> #<struct Service:Types::Operation param1=[], param2=nil>
-    #
-    # You can specify the stub data using {#stub_responses}
-    #
-    #     client = Service::Client.new(stub_responses: true)
-    #     client.stub_responses(:operation, {
-    #       param1: [{ name: 'value1' }]
-    #     })
-    #
-    #     client.operation.param1.map(&:name)
-    #     #=> ['value1']
-    #
-    # ## Stubbing Errors
-    #
-    # When stubbing is enabled, the SDK will default to generate
-    # fake responses with placeholder values. You can override the data
-    # returned. You can also specify errors it should raise.
-    #
-    #     # to simulate errors, give the error class, you must
-    #     # be able to construct an instance with `.new`
-    #     client.stub_responses(:operation, Timeout::Error)
-    #     client.operation(param1: 'value')
-    #     #=> raises new Timeout::Error
-    #
-    #     # or you can give an instance of an error class
-    #     client.stub_responses(:operation, RuntimeError.new('custom message'))
-    #     client.operation(param1: 'value')
-    #     #=> raises the given runtime error object
-    #
-    # ## Dynamic Stubbing
-    #
-    # In addition to creating static stubs, it's also possible to generate
-    # stubs dynamically based on the parameters with which operations were
-    # called, by passing a `Proc` object:
-    #
-    #     client.stub_responses(:operation, -> (context) {
-    #       if context.params[:param] == 'foo'
-    #         # return a stub
-    #         { param1: [{ name: 'value1'}]}
-    #       else
-    #         # return an error
-    #         Services::Errors::NotFound
-    #       end
-    #     })
-    #
-    # ## Stubbing Raw Protocol Responses
-    #
-    # As an alternative to providing the response data, you can modify the
-    # response object provided by the `Proc` object and then
-    # return nil.
-    #
-    #     client.stub_responses(:operation, -> (context) {
-    #       context.response.status = 404 # simulate an error
-    #       nil
-    #     })
-    #
-    # ## Stubbing Multiple Responses
-    #
-    # Calling an operation multiple times will return similar responses.
-    # You can configure multiple stubs and they will be returned in sequence.
-    #
-    #     client.stub_responses(:operation, [
-    #       Errors::NotFound,
-    #       { content_length: 150 },
-    #     ])
-    #
-    #     client.operation(param1: 'value1')
-    #     #=> raises Errors::NotFound
-    #
-    #     resp = client.operation(param1: 'value2')
-    #     resp.content_length #=> 150
-    #
-    # @param [Symbol] operation_name
-    #
-    # @param [Mixed] stubs One or more responses to return from the named
-    #   operation.
-    #
-    # @return [void]
-    #
-    # @raise [RuntimeError] Raises a runtime error when called
-    #   on a client that has not enabled response stubbing via
-    #   `:stub_responses => true`.
-    def stub_responses(operation_name, *stubs)
-      if @stub_responses
-        @stubs.add_stubs(operation_name, stubs.flatten)
-      else
-        msg = 'Stubbing is not enabled. Enable stubbing in the constructor '\
-              'with `stub_responses: true`'
-        raise ArgumentError, msg
-      end
-    end
-  end
-end

data/lib/hearth/stubbing/stubs.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Hearth
-  # @api private
-  module Stubbing
-    # Provides a thread safe data structure for adding and getting stubs
-    # per operation.
-    class Stubs
-      def initialize
-        @stubs = {}
-        @stub_mutex = Mutex.new
-      end
-
-      def add_stubs(operation_name, stubs)
-        @stub_mutex.synchronize do
-          @stubs[operation_name.to_sym] = stubs
-        end
-      end
-
-      def next(operation_name)
-        @stub_mutex.synchronize do
-          stubs = @stubs[operation_name] || []
-          case stubs.length
-          when 0 then nil
-          when 1 then stubs.first
-          else stubs.shift
-          end
-        end
-      end
-    end
-  end
-end

data/lib/hearth/waiters/errors.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Hearth
-  module Waiters
-    module Errors
-      class WaiterFailed < StandardError; end
-
-      class FailureStateError < StandardError; end
-
-      class UnexpectedError < StandardError; end
-
-      class MaxWaitTimeExceeded < StandardError; end
-    end
-  end
-end

data/sig/lib/seahorse/api_error.rbs

@@ -1,10 +0,0 @@
-module Hearth
-  # Base class for errors returned from an API. This excludes networking
-  # errors and errors generated on the client-side.
-  class ApiError < StandardError
-    def initialize: (error_code: String, ?message: String) -> ApiError
-
-    # @return [String]
-    attr_reader error_code: String
-  end
-end

data/sig/lib/seahorse/document.rbs

@@ -1,2 +0,0 @@
-# Declare an alias for Document shapes
-type document = Hash[Symbol,document] | Array[document] | String | bool | Numeric

data/sig/lib/seahorse/http/api_error.rbs

@@ -1,21 +0,0 @@
-module Hearth
-  module HTTP
-    # Base class for HTTP errors returned from an API. Inherits from
-    # {Hearth::ApiError}.
-    class ApiError < Hearth::ApiError
-      def initialize: (http_resp: Response, **untyped kwargs) -> ApiError
-
-      # @return [Integer]
-      attr_reader http_status: Integer
-
-      # @return [Hash<String, String>]
-      attr_reader http_headers: Hash[String, String]
-
-      # @return [String]
-      attr_reader http_body: String
-
-      # @return [String]
-      attr_reader request_id: String
-    end
-  end
-end

data/sig/lib/seahorse/http/headers.rbs

@@ -1,47 +0,0 @@
-module Hearth
-  module HTTP
-    # Provides Hash like access for Headers with key normalization
-    # @api private
-    class Headers
-      # @param [Hash<String,String>] headers
-      def initialize: (?headers: ::Hash[String, String] headers) -> Headers
-
-      # @param [String] key
-      def []: (String key) -> String
-
-      # @param [String] key
-      # @param [String] value
-      def []=: (String key, String value) -> String
-
-      # @param [String] key
-      # @return [Boolean] Returns `true` if there is a header with
-      #   the given key.
-      def key?: (String key) -> bool
-
-      # @return [Array<String>]
-      def keys: () -> Array[String]
-
-      # @param [String] key
-      # @return [String, nil] Returns the value for the deleted key.
-      def delete: (String key) -> (String | nil)
-
-      # @return [Enumerable<String,String>]
-      def each_pair: () { () -> String } -> Enumerable[Array[String]]
-
-      alias each each_pair
-
-      # @return [Hash]
-      def to_hash: () -> Hash[String, String]
-
-      alias to_h to_hash
-
-      # @return [Integer] Returns the number of entries in the headers
-      #   hash.
-      def size: () -> Integer
-
-      private
-
-      def normalize: (String key) -> String
-    end
-  end
-end

data/sig/lib/seahorse/http/response.rbs

@@ -1,21 +0,0 @@
-module Hearth
-  module HTTP
-    # Represents an HTTP Response.
-    # @api private
-    class Response
-      # @param [Integer] status
-      # @param [Headers] headers
-      # @param [IO] body
-      def initialize: (?status: ::Integer status, ?headers: Headers headers, ?body: IO body) -> Response
-
-      # @return [Integer]
-      attr_accessor status: Integer
-
-      # @return [Headers]
-      attr_accessor headers: Headers
-
-      # @return [IO]
-      attr_accessor body: IO
-    end
-  end
-end

data/sig/lib/seahorse/simple_delegator.rbs

@@ -1,3 +0,0 @@
-# Hack - https://github.com/ruby/delegate/issues/8
-class SimpleDelegator
-end

data/sig/lib/seahorse/structure.rbs

@@ -1,18 +0,0 @@
-module Hearth
-  # A module mixed into Structs that provides utility methods.
-  module Structure
-    # Deeply converts the Struct into a hash. Structure members that
-    # are `nil` are omitted from the resultant hash.
-    #
-    # @return [Hash]
-    def to_h: (?untyped obj) -> Hash[Symbol,untyped]
-
-    alias to_hash to_h
-
-    private
-
-    def _to_h_struct: (untyped obj) -> untyped
-
-    def _to_h_hash: (untyped obj) -> untyped
-  end
-end

data/sig/lib/seahorse/stubbing/client_stubs.rbs

@@ -1,103 +0,0 @@
-module Hearth
-  # This module provides the ability to specify the data and/or errors to
-  # return when a client is using stubbed responses.
-  # This module should be included in generated service clients.
-  #
-  # Pass `stub_responses: true` to a client constructor to enable this
-  # behavior.
-  module ClientStubs
-    # Configures what data / errors should be returned from the named operation
-    # when response stubbing is enabled.
-    #
-    # ## Basic usage
-    #
-    # When you enable response stubbing, the client will generate fake
-    # responses and will not make any HTTP requests.
-    #
-    #     client = Service::Client.new(stub_responses: true)
-    #     client.operation
-    #     #=> #<struct Service:Types::Operation param1=[], param2=nil>
-    #
-    # You can specify the stub data using {#stub_responses}
-    #
-    #     client = Service::Client.new(stub_responses: true)
-    #     client.stub_responses(:operation, {
-    #       param1: [{ name: 'value1' }]
-    #     })
-    #
-    #     client.operation.param1.map(&:name)
-    #     #=> ['value1']
-    #
-    # ## Stubbing Errors
-    #
-    # When stubbing is enabled, the SDK will default to generate
-    # fake responses with placeholder values. You can override the data
-    # returned. You can also specify errors it should raise.
-    #
-    #     # to simulate errors, give the error class, you must
-    #     # be able to construct an instance with `.new`
-    #     client.stub_responses(:operation, Timeout::Error)
-    #     client.operation(param1: 'value')
-    #     #=> raises new Timeout::Error
-    #
-    #     # or you can give an instance of an error class
-    #     client.stub_responses(:operation, RuntimeError.new('custom message'))
-    #     client.operation(param1: 'value')
-    #     #=> raises the given runtime error object
-    #
-    # ## Dynamic Stubbing
-    #
-    # In addition to creating static stubs, it's also possible to generate
-    # stubs dynamically based on the parameters with which operations were
-    # called, by passing a `Proc` object:
-    #
-    #     client.stub_responses(:operation, -> (context) {
-    #       if context.params[:param] == 'foo'
-    #         # return a stub
-    #         { param1: [{ name: 'value1'}]}
-    #       else
-    #         # return an error
-    #         Services::Errors::NotFound
-    #       end
-    #     })
-    #
-    # ## Stubbing Raw Protocol Responses
-    #
-    # As an alternative to providing the response data, you can modify the
-    # response object provided by the `Proc` object and then
-    # return nil.
-    #
-    #     client.stub_responses(:operation, -> (context) {
-    #       context.response.status = 404 # simulate an error
-    #       nil
-    #     })
-    #
-    # ## Stubbing Multiple Responses
-    #
-    # Calling an operation multiple times will return similar responses.
-    # You can configure multiple stubs and they will be returned in sequence.
-    #
-    #     client.stub_responses(:operation, [
-    #       Errors::NotFound,
-    #       { content_length: 150 },
-    #     ])
-    #
-    #     client.operation(param1: 'value1')
-    #     #=> raises Errors::NotFound
-    #
-    #     resp = client.operation(param1: 'value2')
-    #     resp.content_length #=> 150
-    #
-    # @param [Symbol] operation_name
-    #
-    # @param [Mixed] stubs One or more responses to return from the named
-    #   operation.
-    #
-    # @return [void]
-    #
-    # @raise [RuntimeError] Raises a runtime error when called
-    #   on a client that has not enabled response stubbing via
-    #   `:stub_responses => true`.
-    def stub_responses: (Symbol operation_name, *Hearth::Stubbing::Stubs stubs) -> void
-  end
-end

data/sig/lib/seahorse/stubbing/stubs.rbs

@@ -1,14 +0,0 @@
-module Hearth
-  # @api private
-  module Stubbing
-    # Provides a thread safe data structure for adding and getting stubs
-    # per operation.
-    class Stubs
-      def initialize: () -> Stubs
-
-      def add_stubs: (Symbol operation_name, Array[Hash[Symbol, untyped]] | Proc | StandardError stubs) -> void
-
-      def next: (Symbol operation_name) -> Hash[Symbol, untyped]
-    end
-  end
-end

data/sig/lib/seahorse/union.rbs

@@ -1,6 +0,0 @@
-module Hearth
-  # Top level class for all Union types
-  class Union < ::SimpleDelegator
-    include Hearth::Structure
-  end
-end