paynow_sdk 0.1.7 → 0.1.8

data/vendor/cache/ruby/2.7.0/gems/paynow_sdk-0.1.6/vendor/cache/ruby/2.7.0/gems/httparty-0.18.1/lib/httparty/request.rb

@@ -1,379 +0,0 @@
-require 'erb'
-
-module HTTParty
-  class Request #:nodoc:
-    SupportedHTTPMethods = [
-      Net::HTTP::Get,
-      Net::HTTP::Post,
-      Net::HTTP::Patch,
-      Net::HTTP::Put,
-      Net::HTTP::Delete,
-      Net::HTTP::Head,
-      Net::HTTP::Options,
-      Net::HTTP::Move,
-      Net::HTTP::Copy,
-      Net::HTTP::Mkcol,
-      Net::HTTP::Lock,
-      Net::HTTP::Unlock,
-    ]
-
-    SupportedURISchemes  = ['http', 'https', 'webcal', nil]
-
-    NON_RAILS_QUERY_STRING_NORMALIZER = proc do |query|
-      Array(query).sort_by { |a| a[0].to_s }.map do |key, value|
-        if value.nil?
-          key.to_s
-        elsif value.respond_to?(:to_ary)
-          value.to_ary.map {|v| "#{key}=#{ERB::Util.url_encode(v.to_s)}"}
-        else
-          HashConversions.to_params(key => value)
-        end
-      end.flatten.join('&')
-    end
-
-    JSON_API_QUERY_STRING_NORMALIZER = proc do |query|
-      Array(query).sort_by { |a| a[0].to_s }.map do |key, value|
-        if value.nil?
-          key.to_s
-        elsif value.respond_to?(:to_ary)
-          values = value.to_ary.map{|v| ERB::Util.url_encode(v.to_s)}
-          "#{key}=#{values.join(',')}"
-        else
-          HashConversions.to_params(key => value)
-        end
-      end.flatten.join('&')
-    end
-
-    attr_accessor :http_method, :options, :last_response, :redirect, :last_uri
-    attr_reader :path
-
-    def initialize(http_method, path, o = {})
-      @changed_hosts = false
-      @credentials_sent = false
-
-      self.http_method = http_method
-      self.options = {
-        limit: o.delete(:no_follow) ? 1 : 5,
-        assume_utf16_is_big_endian: true,
-        default_params: {},
-        follow_redirects: true,
-        parser: Parser,
-        uri_adapter: URI,
-        connection_adapter: ConnectionAdapter
-      }.merge(o)
-      self.path = path
-      set_basic_auth_from_uri
-    end
-
-    def path=(uri)
-      uri_adapter = options[:uri_adapter]
-
-      @path = if uri.is_a?(uri_adapter)
-        uri
-      elsif String.try_convert(uri)
-        uri_adapter.parse(uri).normalize
-      else
-        raise ArgumentError,
-          "bad argument (expected #{uri_adapter} object or URI string)"
-      end
-    end
-
-    def request_uri(uri)
-      if uri.respond_to? :request_uri
-        uri.request_uri
-      else
-        uri.path
-      end
-    end
-
-    def uri
-      if redirect && path.relative? && path.path[0] != "/"
-        last_uri_host = @last_uri.path.gsub(/[^\/]+$/, "")
-
-        path.path = "/#{path.path}" if last_uri_host[-1] != "/"
-        path.path = last_uri_host + path.path
-      end
-
-      if path.relative? && path.host
-        new_uri = options[:uri_adapter].parse("#{@last_uri.scheme}:#{path}").normalize
-      elsif path.relative?
-        new_uri = options[:uri_adapter].parse("#{base_uri}#{path}").normalize
-      else
-        new_uri = path.clone
-      end
-
-      # avoid double query string on redirects [#12]
-      unless redirect
-        new_uri.query = query_string(new_uri)
-      end
-
-      unless SupportedURISchemes.include? new_uri.scheme
-        raise UnsupportedURIScheme, "'#{new_uri}' Must be HTTP, HTTPS or Generic"
-      end
-
-      @last_uri = new_uri
-    end
-
-    def base_uri
-      if redirect
-        base_uri = "#{@last_uri.scheme}://#{@last_uri.host}"
-        base_uri += ":#{@last_uri.port}" if @last_uri.port != 80
-        base_uri
-      else
-        options[:base_uri] && HTTParty.normalize_base_uri(options[:base_uri])
-      end
-    end
-
-    def format
-      options[:format] || (format_from_mimetype(last_response['content-type']) if last_response)
-    end
-
-    def parser
-      options[:parser]
-    end
-
-    def connection_adapter
-      options[:connection_adapter]
-    end
-
-    def perform(&block)
-      validate
-      setup_raw_request
-      chunked_body = nil
-      current_http = http
-
-      self.last_response = current_http.request(@raw_request) do |http_response|
-        if block
-          chunks = []
-
-          http_response.read_body do |fragment|
-            encoded_fragment = encode_text(fragment, http_response['content-type'])
-            chunks << encoded_fragment if !options[:stream_body]
-            block.call ResponseFragment.new(encoded_fragment, http_response, current_http)
-          end
-
-          chunked_body = chunks.join
-        end
-      end
-
-      handle_host_redirection if response_redirects?
-      result = handle_unauthorized
-      result ||= handle_response(chunked_body, &block)
-      result
-    end
-
-    def handle_unauthorized(&block)
-      return unless digest_auth? && response_unauthorized? && response_has_digest_auth_challenge?
-      return if @credentials_sent
-      @credentials_sent = true
-      perform(&block)
-    end
-
-    def raw_body
-      @raw_request.body
-    end
-
-    private
-
-    def http
-      connection_adapter.call(uri, options)
-    end
-
-    def credentials
-      (options[:basic_auth] || options[:digest_auth]).to_hash
-    end
-
-    def username
-      credentials[:username]
-    end
-
-    def password
-      credentials[:password]
-    end
-
-    def normalize_query(query)
-      if query_string_normalizer
-        query_string_normalizer.call(query)
-      else
-        HashConversions.to_params(query)
-      end
-    end
-
-    def query_string_normalizer
-      options[:query_string_normalizer]
-    end
-
-    def setup_raw_request
-      if options[:headers].respond_to?(:to_hash)
-        headers_hash = options[:headers].to_hash
-      else
-        headers_hash = nil
-      end
-
-      @raw_request = http_method.new(request_uri(uri), headers_hash)
-      @raw_request.body_stream = options[:body_stream] if options[:body_stream]
-
-      if options[:body]
-        body = Body.new(
-          options[:body],
-          query_string_normalizer: query_string_normalizer,
-          force_multipart: options[:multipart]
-        )
-
-        if body.multipart?
-          content_type = "multipart/form-data; boundary=#{body.boundary}"
-          @raw_request['Content-Type'] = content_type
-        end
-        @raw_request.body = body.call
-      end
-
-      if options[:basic_auth] && send_authorization_header?
-        @raw_request.basic_auth(username, password)
-        @credentials_sent = true
-      end
-      setup_digest_auth if digest_auth? && response_unauthorized? && response_has_digest_auth_challenge?
-    end
-
-    def digest_auth?
-      !!options[:digest_auth]
-    end
-
-    def response_unauthorized?
-      !!last_response && last_response.code == '401'
-    end
-
-    def response_has_digest_auth_challenge?
-      !last_response['www-authenticate'].nil? && last_response['www-authenticate'].length > 0
-    end
-
-    def setup_digest_auth
-      @raw_request.digest_auth(username, password, last_response)
-    end
-
-    def query_string(uri)
-      query_string_parts = []
-      query_string_parts << uri.query unless uri.query.nil?
-
-      if options[:query].respond_to?(:to_hash)
-        query_string_parts << normalize_query(options[:default_params].merge(options[:query].to_hash))
-      else
-        query_string_parts << normalize_query(options[:default_params]) unless options[:default_params].empty?
-        query_string_parts << options[:query] unless options[:query].nil?
-      end
-
-      query_string_parts.reject!(&:empty?) unless query_string_parts == [""]
-      query_string_parts.size > 0 ? query_string_parts.join('&') : nil
-    end
-
-    def assume_utf16_is_big_endian
-      options[:assume_utf16_is_big_endian]
-    end
-
-    def handle_response(body, &block)
-      if response_redirects?
-        options[:limit] -= 1
-        if options[:logger]
-          logger = HTTParty::Logger.build(options[:logger], options[:log_level], options[:log_format])
-          logger.format(self, last_response)
-        end
-        self.path = last_response['location']
-        self.redirect = true
-        if last_response.class == Net::HTTPSeeOther
-          unless options[:maintain_method_across_redirects] && options[:resend_on_redirect]
-            self.http_method = Net::HTTP::Get
-          end
-        elsif last_response.code != '307' && last_response.code != '308'
-          unless options[:maintain_method_across_redirects]
-            self.http_method = Net::HTTP::Get
-          end
-        end
-        capture_cookies(last_response)
-        perform(&block)
-      else
-        body ||= last_response.body
-        body = body.nil? ? body : encode_text(body, last_response['content-type'])
-        Response.new(self, last_response, lambda { parse_response(body) }, body: body)
-      end
-    end
-
-    def handle_host_redirection
-      check_duplicate_location_header
-      redirect_path = options[:uri_adapter].parse(last_response['location']).normalize
-      return if redirect_path.relative? || path.host == redirect_path.host
-      @changed_hosts = true
-    end
-
-    def check_duplicate_location_header
-      location = last_response.get_fields('location')
-      if location.is_a?(Array) && location.count > 1
-        raise DuplicateLocationHeader.new(last_response)
-      end
-    end
-
-    def send_authorization_header?
-      !@changed_hosts
-    end
-
-    def response_redirects?
-      case last_response
-      when Net::HTTPNotModified # 304
-        false
-      when Net::HTTPRedirection
-        options[:follow_redirects] && last_response.key?('location')
-      end
-    end
-
-    def parse_response(body)
-      parser.call(body, format)
-    end
-
-    def capture_cookies(response)
-      return unless response['Set-Cookie']
-      cookies_hash = HTTParty::CookieHash.new
-      cookies_hash.add_cookies(options[:headers].to_hash['Cookie']) if options[:headers] && options[:headers].to_hash['Cookie']
-      response.get_fields('Set-Cookie').each { |cookie| cookies_hash.add_cookies(cookie) }
-
-      options[:headers] ||= {}
-      options[:headers]['Cookie'] = cookies_hash.to_cookie_string
-    end
-
-    # Uses the HTTP Content-Type header to determine the format of the
-    # response It compares the MIME type returned to the types stored in the
-    # SupportedFormats hash
-    def format_from_mimetype(mimetype)
-      if mimetype && parser.respond_to?(:format_from_mimetype)
-        parser.format_from_mimetype(mimetype)
-      end
-    end
-
-    def validate
-      raise HTTParty::RedirectionTooDeep.new(last_response), 'HTTP redirects too deep' if options[:limit].to_i <= 0
-      raise ArgumentError, 'only get, post, patch, put, delete, head, and options methods are supported' unless SupportedHTTPMethods.include?(http_method)
-      raise ArgumentError, ':headers must be a hash' if options[:headers] && !options[:headers].respond_to?(:to_hash)
-      raise ArgumentError, 'only one authentication method, :basic_auth or :digest_auth may be used at a time' if options[:basic_auth] && options[:digest_auth]
-      raise ArgumentError, ':basic_auth must be a hash' if options[:basic_auth] && !options[:basic_auth].respond_to?(:to_hash)
-      raise ArgumentError, ':digest_auth must be a hash' if options[:digest_auth] && !options[:digest_auth].respond_to?(:to_hash)
-      raise ArgumentError, ':query must be hash if using HTTP Post' if post? && !options[:query].nil? && !options[:query].respond_to?(:to_hash)
-    end
-
-    def post?
-      Net::HTTP::Post == http_method
-    end
-
-    def set_basic_auth_from_uri
-      if path.userinfo
-        username, password = path.userinfo.split(':')
-        options[:basic_auth] = {username: username, password: password}
-        @credentials_sent = true
-      end
-    end
-
-    def encode_text(text, content_type)
-      TextEncoder.new(
-        text,
-        content_type: content_type,
-        assume_utf16_is_big_endian: assume_utf16_is_big_endian
-      ).call
-    end
-  end
-end

data/vendor/cache/ruby/2.7.0/gems/paynow_sdk-0.1.6/vendor/cache/ruby/2.7.0/gems/httparty-0.18.1/lib/httparty/request/body.rb

@@ -1,84 +0,0 @@
-require_relative 'multipart_boundary'
-
-module HTTParty
-  class Request
-    class Body
-      def initialize(params, query_string_normalizer: nil, force_multipart: false)
-        @params = params
-        @query_string_normalizer = query_string_normalizer
-        @force_multipart = force_multipart
-      end
-
-      def call
-        if params.respond_to?(:to_hash)
-          multipart? ? generate_multipart : normalize_query(params)
-        else
-          params
-        end
-      end
-
-      def boundary
-        @boundary ||= MultipartBoundary.generate
-      end
-
-      def multipart?
-        params.respond_to?(:to_hash) && (force_multipart || has_file?(params))
-      end
-
-      private
-
-      def generate_multipart
-        normalized_params = params.flat_map { |key, value| HashConversions.normalize_keys(key, value) }
-
-        multipart = normalized_params.inject('') do |memo, (key, value)|
-          memo += "--#{boundary}\r\n"
-          memo += %(Content-Disposition: form-data; name="#{key}")
-          # value.path is used to support ActionDispatch::Http::UploadedFile
-          # https://github.com/jnunemaker/httparty/pull/585
-          memo += %(; filename="#{file_name(value)}") if file?(value)
-          memo += "\r\n"
-          memo += "Content-Type: #{content_type(value)}\r\n" if file?(value)
-          memo += "\r\n"
-          memo += file?(value) ? value.read : value.to_s
-          memo += "\r\n"
-        end
-
-        multipart += "--#{boundary}--\r\n"
-      end
-
-      def has_file?(value)
-        if value.respond_to?(:to_hash)
-          value.to_hash.any? { |_, v| has_file?(v) }
-        elsif value.respond_to?(:to_ary)
-          value.to_ary.any? { |v| has_file?(v) }
-        else
-          file?(value)
-        end
-      end
-
-      def file?(object)
-        object.respond_to?(:path) && object.respond_to?(:read)
-      end
-
-      def normalize_query(query)
-        if query_string_normalizer
-          query_string_normalizer.call(query)
-        else
-          HashConversions.to_params(query)
-        end
-      end
-
-      def content_type(object)
-        return object.content_type if object.respond_to?(:content_type)
-        mime = MIME::Types.type_for(object.path)
-        mime.empty? ? 'application/octet-stream' : mime[0].content_type
-      end
-
-      def file_name(object)
-        object.respond_to?(:original_filename) ? object.original_filename : File.basename(object.path)
-      end
-
-      attr_reader :params, :query_string_normalizer, :force_multipart
-    end
-  end
-end