postfinancecheckout-ruby-sdk 3.0.2 → 3.1.4

data/vendor/bundle/ruby/2.4.0/gems/typhoeus-1.4.0/lib/typhoeus/expectation.rb

@@ -0,0 +1,217 @@
+module Typhoeus
+
+  # This class represents an expectation. It is part
+  # of the stubbing mechanism. An expectation contains
+  # a url and options, like a request. They are compared
+  # to the request url and options in order to evaluate
+  # whether they match. If that's the case, the attached
+  # responses are returned one by one.
+  #
+  # @example Stub a request and get specified response.
+  #   expected = Typhoeus::Response.new
+  #   Typhoeus.stub("www.example.com").and_return(expected)
+  #
+  #   actual = Typhoeus.get("www.example.com")
+  #   expected == actual
+  #   #=> true
+  #
+  # @example Stub a request and get a lazily-constructed response containing data from actual widgets that exist in the system when the stubbed request is made.
+  #   Typhoeus.stub("www.example.com/widgets") do
+  #     actual_widgets = Widget.all
+  #     Typhoeus::Response.new(
+  #       :body => actual_widgets.inject([]) do |ids, widget|
+  #         ids << widget.id
+  #       end.join(",")
+  #     )
+  #   end
+  #
+  # @example Stub a request and get a lazily-constructed response in the format requested.
+  #   Typhoeus.stub("www.example.com") do |request|
+  #     accept = (request.options[:headers]||{})['Accept'] || "application/json"
+  #     format = accept.split(",").first
+  #     body_obj = { 'things' => [ { 'id' => 'foo' } ] }
+  #
+  #     Typhoeus::Response.new(
+  #       :headers => {
+  #         'Content-Type' => format
+  #       },
+  #       :body => SERIALIZERS[format].serialize(body_obj)
+  #     )
+  #   end
+  class Expectation
+
+    # @api private
+    attr_reader :base_url
+
+    # @api private
+    attr_reader :options
+
+    # @api private
+    attr_reader :from
+
+    class << self
+
+      # Returns all expectations.
+      #
+      # @example Return expectations.
+      #   Typhoeus::Expectation.all
+      #
+      # @return [ Array<Typhoeus::Expectation> ] The expectations.
+      def all
+        @expectations ||= []
+      end
+
+      # Clears expectations. This is handy while
+      # testing, and you want to make sure that
+      # you don't get canned responses.
+      #
+      # @example Clear expectations.
+      #   Typhoeus::Expectation.clear
+      def clear
+        all.clear
+      end
+
+      # Returns stubbed response matching the
+      # provided request.
+      #
+      # @example Find response
+      #   Typhoeus::Expectation.response_for(request)
+      #
+      # @return [ Typhoeus::Response ] The stubbed response from a
+      #   matching expectation, or nil if no matching expectation
+      #   is found.
+      #
+      # @api private
+      def response_for(request)
+        expectation = find_by(request)
+        return nil if expectation.nil?
+
+        expectation.response(request)
+      end
+
+      # @api private
+      def find_by(request)
+        all.find do |expectation|
+          expectation.matches?(request)
+        end
+      end
+    end
+
+    # Creates an expectation.
+    #
+    # @example Create expectation.
+    #   Typhoeus::Expectation.new(base_url)
+    #
+    # @return [ Expectation ] The created expectation.
+    #
+    # @api private
+    def initialize(base_url, options = {})
+      @base_url = base_url
+      @options = options
+      @response_counter = 0
+      @from = nil
+    end
+
+    # Set from value to mark an expectaion. Useful for
+    # other libraries, e.g. WebMock.
+    #
+    # @example Mark expectation.
+    #   expectation.from(:webmock)
+    #
+    # @param [ String ] value Value to set.
+    #
+    # @return [ Expectation ] Returns self.
+    #
+    # @api private
+    def stubbed_from(value)
+      @from = value
+      self
+    end
+
+    # Specify what should be returned,
+    # when this expectation is hit.
+    #
+    # @example Add response.
+    #   expectation.and_return(response)
+    #
+    # @return [ void ]
+    def and_return(response=nil, &block)
+      new_response = (response.nil? ? block : response)
+      responses.push(*new_response)
+    end
+
+    # Checks whether this expectation matches
+    # the provided request.
+    #
+    # @example Check if request matches.
+    #   expectation.matches? request
+    #
+    # @param [ Request ] request The request to check.
+    #
+    # @return [ Boolean ] True when matches, else false.
+    #
+    # @api private
+    def matches?(request)
+      url_match?(request.base_url) && options_match?(request)
+    end
+
+    # Return canned responses.
+    #
+    # @example Return responses.
+    #   expectation.responses
+    #
+    # @return [ Array<Typhoeus::Response> ] The responses.
+    #
+    # @api private
+    def responses
+      @responses ||= []
+    end
+
+    # Return the response. When there are
+    # multiple responses, they are returned one
+    # by one.
+    #
+    # @example Return response.
+    #   expectation.response
+    #
+    # @return [ Response ] The response.
+    #
+    # @api private
+    def response(request)
+      response = responses.fetch(@response_counter, responses.last)
+      if response.respond_to?(:call)
+        response = response.call(request)
+      end
+      @response_counter += 1
+      response.mock = @from || true
+      response
+    end
+
+    private
+
+    # Check whether the options matches the request options.
+    # I checks options and original options.
+    def options_match?(request)
+      (options ? options.all?{ |k,v| request.original_options[k] == v || request.options[k] == v } : true)
+    end
+
+    # Check whether the base_url matches the request url.
+    # The base_url can be a string, regex or nil. String and
+    # regexp are checked, nil is always true, else false.
+    #
+    # Nil serves as a placeholder in case you want to match
+    # all urls.
+    def url_match?(request_url)
+      case base_url
+      when String
+        base_url == request_url
+      when Regexp
+        base_url === request_url
+      when nil
+        true
+      else
+        false
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/typhoeus-1.4.0/lib/typhoeus/hydra/addable.rb

@@ -0,0 +1,23 @@
+module Typhoeus
+  class Hydra
+
+    # This module handles the request adding on
+    # hydra.
+    #
+    # @api private
+    module Addable
+
+      # Adds request to multi.
+      #
+      # @example Add request.
+      #   hydra.add(request)
+      #
+      # @param [ Typhoeus::Request ] request to add.
+      #
+      # @return [ void ]
+      def add(request)
+        multi.add(EasyFactory.new(request, self).get)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/typhoeus-1.4.0/lib/typhoeus/hydra/before.rb

@@ -0,0 +1,31 @@
+module Typhoeus
+  class Hydra
+
+    # This module provides a way to hook into before
+    # a request gets queued in hydra. This is very powerful
+    # and you should be careful because when you accidently
+    # return a falsy value the request won't be executed.
+    #
+    # @api private
+    module Before
+
+      # Overrride add in order to execute callbacks in
+      # Typhoeus.before. Will break and return when a
+      # callback returns nil, false or a response. Calls super
+      # otherwise.
+      #
+      # @example Add the request.
+      #   hydra.add(request)
+      def add(request)
+        Typhoeus.before.each do |callback|
+          value = callback.call(request)
+          if value.nil? || value == false || value.is_a?(Response)
+            dequeue
+            return value
+          end
+        end
+        super
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/typhoeus-1.4.0/lib/typhoeus/hydra/block_connection.rb

@@ -0,0 +1,35 @@
+module Typhoeus
+  class Hydra
+
+    # This module handles the blocked connection request mode on
+    # the hydra side, where only stubbed requests
+    # are allowed.
+    # Connection blocking needs to be turned on:
+    #   Typhoeus.configure do |config|
+    #     config.block_connection = true
+    #   end
+    #
+    # When trying to do real requests a NoStub error
+    # is raised.
+    #
+    # @api private
+    module BlockConnection
+
+      # Overrides add in order to check before if block connection
+      # is turned on. If thats the case a NoStub error is
+      # raised.
+      #
+      # @example Add the request.
+      #   hydra.add(request)
+      #
+      # @param [ Request ] request The request to enqueue.
+      def add(request)
+        if request.blocked?
+          raise Typhoeus::Errors::NoStub.new(request)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/typhoeus-1.4.0/lib/typhoeus/hydra/cacheable.rb

@@ -0,0 +1,15 @@
+module Typhoeus
+  class Hydra
+    module Cacheable
+      def add(request)
+        if request.cacheable? && response = request.cached_response
+          response.cached = true
+          request.finish(response)
+          dequeue
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/typhoeus-1.4.0/lib/typhoeus/hydra/memoizable.rb

@@ -0,0 +1,56 @@
+module Typhoeus
+  class Hydra
+
+    # This module handles the GET request memoization
+    # on the hydra side. Memoization needs to be turned
+    # on:
+    #   Typhoeus.configure do |config|
+    #     config.memoize = true
+    #   end
+    #
+    # @api private
+    module Memoizable
+
+      # Return the memory.
+      #
+      # @example Return the memory.
+      #   hydra.memory
+      #
+      # @return [ Hash ] The memory.
+      def memory
+        @memory ||= {}
+      end
+
+      # Overrides add in order to check before if request
+      # is memoizable and already in memory. If thats the case,
+      # super is not called, instead the response is set and
+      # the on_complete callback called.
+      #
+      # @example Add the request.
+      #   hydra.add(request)
+      #
+      # @param [ Request ] request The request to add.
+      #
+      # @return [ Request ] The added request.
+      def add(request)
+        if request.memoizable? && memory.has_key?(request)
+          response = memory[request]
+          request.finish(response, true)
+          dequeue
+        else
+          super
+        end
+      end
+
+      # Overrides run to make sure the memory is cleared after
+      # each run.
+      #
+      # @example Run hydra.
+      #   hydra.run
+      def run
+        super
+        memory.clear
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/typhoeus-1.4.0/lib/typhoeus/hydra/queueable.rb

@@ -0,0 +1,83 @@
+module Typhoeus
+  class Hydra
+
+    # This module handles the request queueing on
+    # hydra.
+    #
+    # @api private
+    module Queueable
+
+      # Return the queued requests.
+      #
+      # @example Return queued requests.
+      #   hydra.queued_requests
+      #
+      # @return [ Array<Typhoeus::Request> ] The queued requests.
+      def queued_requests
+        @queued_requests ||= []
+      end
+
+      # Abort the current hydra run as good as
+      # possible. This means that it only
+      # clears the queued requests and can't do
+      # anything about already running requests.
+      #
+      # @example Abort hydra.
+      #   hydra.abort
+      def abort
+        queued_requests.clear
+      end
+
+      # Enqueues a request in order to be performed
+      # by the hydra. This can even be done while
+      # the hydra is running. Also sets hydra on
+      # request.
+      #
+      # @example Queue request.
+      #   hydra.queue(request)
+      def queue(request)
+        request.hydra = self
+        queued_requests << request
+      end
+
+      # Pushes a request to the front of the queue,
+      # to be performed by the hydra. Also sets hydra
+      # on request
+      #
+      # @example Queue reques.
+      #   hydra.queue_front(request)
+      def queue_front(request)
+        request.hydra = self
+        queued_requests.unshift request
+      end
+
+      # Removes a request from queued_requests and
+      # adds it to the hydra in order to be
+      # performed next.
+      #
+      # @example Dequeue request.
+      #   hydra.dequeue
+      #
+      # @since 0.6.4
+      def dequeue
+        add(queued_requests.shift) unless queued_requests.empty?
+      end
+
+      # Removes requests from queued_requests and
+      # adds them to the hydra until max_concurrency
+      # is reached.
+      #
+      # @example Dequeue requests.
+      #   hydra.dequeue_many
+      #
+      # @since 0.6.8
+      def dequeue_many
+        number = multi.easy_handles.count
+        until number == max_concurrency || queued_requests.empty?
+          add(queued_requests.shift)
+          number += 1
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/typhoeus-1.4.0/lib/typhoeus/hydra/runnable.rb

@@ -0,0 +1,19 @@
+module Typhoeus
+  class Hydra
+
+    # This module contains logic to run a hydra.
+    module Runnable
+
+      # Start the hydra run.
+      #
+      # @example Start hydra run.
+      #   hydra.run
+      #
+      # @return [ Symbol ] Return value from multi.perform.
+      def run
+        dequeue_many
+        multi.perform
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/typhoeus-1.4.0/lib/typhoeus/hydra/stubbable.rb

@@ -0,0 +1,28 @@
+module Typhoeus
+  class Hydra
+
+    # This module handles stubbing on the hydra side.
+    # It plays well with the block_connection configuration,
+    # which raises when you make a request which is not stubbed.
+    #
+    # @api private
+    module Stubbable
+
+      # Override add in order to check for matching expecations.
+      # When an expecation is found, super is not called. Instead a
+      # canned response is assigned to the request.
+      #
+      # @example Add the request.
+      #   hydra.add(request)
+      def add(request)
+        if response = Expectation.response_for(request)
+          request.execute_headers_callbacks(response)
+          request.on_body.each{ |callback| callback.call(response.body, response) }
+          request.finish(response)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/typhoeus-1.4.0/lib/typhoeus/hydra.rb

@@ -0,0 +1,95 @@
+require 'typhoeus/hydra/addable'
+require 'typhoeus/hydra/before'
+require 'typhoeus/hydra/cacheable'
+require 'typhoeus/hydra/block_connection'
+require 'typhoeus/hydra/memoizable'
+require 'typhoeus/hydra/queueable'
+require 'typhoeus/hydra/runnable'
+require 'typhoeus/hydra/stubbable'
+
+module Typhoeus
+
+  # Hydra manages making parallel HTTP requests. This
+  # is achieved by using libcurls multi interface:
+  # http://curl.haxx.se/libcurl/c/libcurl-multi.html
+  # The benefits are that you don't have to worry running
+  # the requests by yourself.
+  #
+  # Hydra will also handle how many requests you can
+  # make in parallel. Things will get flakey if you
+  # try to make too many requests at the same time.
+  # The built in limit is 200. When more requests than
+  # that are queued up, hydra will save them for later
+  # and start the requests as others are finished. You
+  # can raise or lower the concurrency limit through
+  # the Hydra constructor.
+  #
+  # Regarding the asynchronous behavior of the hydra,
+  # it is important to know that this is completely hidden
+  # from the developer and you are free to apply
+  # whatever technique you want to your code. That should not
+  # conflict with libcurls internal concurrency mechanism.
+  #
+  # @example Use the hydra to do multiple requests.
+  #   hydra = Typhoeus::Hydra.new
+  #   requests = (0..9).map{ Typhoeus::Request.new("www.example.com") }
+  #   requests.each{ |request| hydra.queue(request) }
+  #   hydra.run
+  #
+  # @note Callbacks are going to delay the request
+  #   execution.
+  class Hydra
+    include Hydra::Addable
+    include Hydra::Runnable
+    include Hydra::Memoizable
+    include Hydra::Cacheable
+    include Hydra::BlockConnection
+    include Hydra::Stubbable
+    include Hydra::Before
+    include Hydra::Queueable
+
+    # @example Set max_concurrency.
+    #   Typhoeus::Hydra.new(max_concurrency: 20)
+    attr_accessor :max_concurrency
+
+    # @api private
+    attr_reader :multi
+
+    class << self
+
+      # Returns a memoized hydra instance.
+      #
+      # @example Get a hydra.
+      #   Typhoeus::Hydra.hydra
+      #
+      # @return [Typhoeus::Hydra] A new hydra.
+      def hydra
+        Thread.current[:typhoeus_hydra] ||= new
+      end
+    end
+
+    # Create a new hydra. All
+    # {http://rubydoc.info/github/typhoeus/ethon/Ethon/Multi#initialize-instance_method Ethon::Multi#initialize}
+    # options are also available.
+    #
+    # @example Create a hydra.
+    #   Typhoeus::Hydra.new
+    #
+    # @example Create a hydra with max_concurrency.
+    #   Typhoeus::Hydra.new(max_concurrency: 20)
+    #
+    # @param [ Hash ] options The options hash.
+    #
+    # @option options :max_concurrency [ Integer ] Number
+    #  of max concurrent connections to create. Default is
+    #  200.
+    #
+    # @see http://rubydoc.info/github/typhoeus/ethon/Ethon/Multi#initialize-instance_method
+    #   Ethon::Multi#initialize
+    def initialize(options = {})
+      @options = options
+      @max_concurrency = Integer(@options.fetch(:max_concurrency, 200))
+      @multi = Ethon::Multi.new(options.reject{|k,_| k==:max_concurrency})
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/typhoeus-1.4.0/lib/typhoeus/pool.rb

@@ -0,0 +1,70 @@
+require 'thread'
+
+module Typhoeus
+
+  # The easy pool stores already initialized
+  # easy handles for future use. This is useful
+  # because creating them is expensive.
+  #
+  # @api private
+  module Pool
+    @mutex = Mutex.new
+    @pid = Process.pid
+
+    # Releases easy into the pool. The easy handle is
+    # reset before it gets back in.
+    #
+    # @example Release easy.
+    #   Typhoeus::Pool.release(easy)
+    def self.release(easy)
+      easy.cookielist = "flush" # dump all known cookies to 'cookiejar'
+      easy.cookielist = "all" # remove all cookies from memory for this handle
+      easy.reset
+      @mutex.synchronize { easies << easy }
+    end
+
+    # Return an easy from the pool.
+    #
+    # @example Return easy.
+    #   Typhoeus::Pool.get
+    #
+    # @return [ Ethon::Easy ] The easy.
+    def self.get
+      @mutex.synchronize do
+        if @pid == Process.pid
+          easies.pop
+        else
+          # Process has forked. Clear all easies to avoid sockets being
+          # shared between processes.
+          @pid = Process.pid
+          easies.clear
+          nil
+        end
+      end || Ethon::Easy.new
+    end
+
+    # Clear the pool
+    def self.clear
+      @mutex.synchronize { easies.clear }
+    end
+
+    # Use yielded easy, will be released automatically afterwards.
+    #
+    # @example Use easy.
+    #   Typhoeus::Pool.with_easy do |easy|
+    #     # use easy
+    #   end
+    def self.with_easy(&block)
+      easy = get
+      yield easy
+    ensure
+      release(easy) if easy
+    end
+
+    private
+
+    def self.easies
+      @easies ||= []
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/typhoeus-1.4.0/lib/typhoeus/railtie.rb

@@ -0,0 +1,12 @@
+require "typhoeus"
+
+module Rails
+  module Typhoeus
+    class Railtie < Rails::Railtie
+      # Need to include the Typhoeus middleware.
+      initializer "include the identity map" do |app|
+        app.config.middleware.use "Rack::Typhoeus::Middleware::ParamsDecoder"
+      end
+    end
+  end
+end