paynow_sdk 1.0.9 → 1.1.2

data/vendor/bundle/ruby/2.7.0/gems/httparty-0.18.1/lib/httparty/logger/curl_formatter.rb

@@ -1,91 +0,0 @@
-module HTTParty
-  module Logger
-    class CurlFormatter #:nodoc:
-      TAG_NAME = HTTParty.name
-      OUT      = '>'.freeze
-      IN       = '<'.freeze
-
-      attr_accessor :level, :logger
-
-      def initialize(logger, level)
-        @logger   = logger
-        @level    = level.to_sym
-        @messages = []
-      end
-
-      def format(request, response)
-        @request  = request
-        @response = response
-
-        log_request
-        log_response
-
-        logger.public_send level, messages.join("\n")
-      end
-
-      private
-
-      attr_reader :request, :response
-      attr_accessor :messages
-
-      def log_request
-        log_url
-        log_headers
-        log_query
-        log OUT, request.raw_body if request.raw_body
-        log OUT
-      end
-
-      def log_response
-        log IN, "HTTP/#{response.http_version} #{response.code}"
-        log_response_headers
-        log IN, "\n#{response.body}"
-        log IN
-      end
-
-      def log_url
-        http_method = request.http_method.name.split("::").last.upcase
-        uri = if request.options[:base_uri]
-                request.options[:base_uri] + request.path.path
-              else
-                request.path.to_s
-              end
-
-        log OUT, "#{http_method} #{uri}"
-      end
-
-      def log_headers
-        return unless request.options[:headers] && request.options[:headers].size > 0
-
-        log OUT, 'Headers: '
-        log_hash request.options[:headers]
-      end
-
-      def log_query
-        return unless request.options[:query]
-
-        log OUT, 'Query: '
-        log_hash request.options[:query]
-      end
-
-      def log_response_headers
-        headers = response.respond_to?(:headers) ? response.headers : response
-        response.each_header do |response_header|
-          log IN, "#{response_header.capitalize}: #{headers[response_header]}"
-        end
-      end
-
-      def log_hash(hash)
-        hash.each { |k, v| log(OUT, "#{k}: #{v}") }
-      end
-
-      def log(direction, line = '')
-        messages << "[#{TAG_NAME}] [#{current_time}] #{direction} #{line}"
-      end
-
-      def current_time
-        Time.now.strftime("%Y-%m-%d %H:%M:%S %z")
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/httparty-0.18.1/lib/httparty/logger/logger.rb

@@ -1,28 +0,0 @@
-require 'httparty/logger/apache_formatter'
-require 'httparty/logger/curl_formatter'
-require 'httparty/logger/logstash_formatter'
-
-module HTTParty
-  module Logger
-    def self.formatters
-      @formatters ||= {
-        :curl => Logger::CurlFormatter,
-        :apache => Logger::ApacheFormatter,
-        :logstash => Logger::LogstashFormatter,
-      }
-    end
-
-    def self.add_formatter(name, formatter)
-      raise HTTParty::Error.new("Log Formatter with name #{name} already exists") if formatters.include?(name)
-      formatters.merge!(name.to_sym => formatter)
-    end
-
-    def self.build(logger, level, formatter)
-      level ||= :info
-      formatter ||= :apache
-
-      logger_klass = formatters[formatter] || Logger::ApacheFormatter
-      logger_klass.new(logger, level)
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/httparty-0.18.1/lib/httparty/logger/logstash_formatter.rb

@@ -1,59 +0,0 @@
-module HTTParty
-  module Logger
-    class LogstashFormatter #:nodoc:
-      TAG_NAME = HTTParty.name
-
-      attr_accessor :level, :logger
-
-      def initialize(logger, level)
-        @logger = logger
-        @level  = level.to_sym
-      end
-
-      def format(request, response)
-        @request = request
-        @response = response
-
-        logger.public_send level, logstash_message
-      end
-
-      private
-
-      attr_reader :request, :response
-
-      def logstash_message
-        {
-          '@timestamp' => current_time,
-          '@version' => 1,
-          'content_length' => content_length || '-',
-          'http_method' => http_method,
-          'message' => message,
-          'path' => path,
-          'response_code' => response.code,
-          'severity' => level,
-          'tags' => [TAG_NAME],
-        }.to_json
-      end
-
-      def message
-        "[#{TAG_NAME}] #{response.code} \"#{http_method} #{path}\" #{content_length || '-'} "
-      end
-
-      def current_time
-        Time.now.strftime("%Y-%m-%d %H:%M:%S %z")
-      end
-
-      def http_method
-        @http_method ||= request.http_method.name.split("::").last.upcase
-      end
-
-      def path
-        @path ||= request.path.to_s
-      end
-
-      def content_length
-        @content_length ||= response.respond_to?(:headers) ? response.headers['Content-Length'] : response['Content-Length']
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/httparty-0.18.1/lib/httparty/module_inheritable_attributes.rb

@@ -1,56 +0,0 @@
-module HTTParty
-  module ModuleInheritableAttributes #:nodoc:
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    # borrowed from Rails 3.2 ActiveSupport
-    def self.hash_deep_dup(hash)
-      duplicate = hash.dup
-
-      duplicate.each_pair do |key, value|
-        if value.is_a?(Hash)
-          duplicate[key] = hash_deep_dup(value)
-        elsif value.is_a?(Proc)
-          duplicate[key] = value.dup
-        else
-          duplicate[key] = value
-        end
-      end
-
-      duplicate
-    end
-
-    module ClassMethods #:nodoc:
-      def mattr_inheritable(*args)
-        @mattr_inheritable_attrs ||= [:mattr_inheritable_attrs]
-        @mattr_inheritable_attrs += args
-
-        args.each do |arg|
-          module_eval %(class << self; attr_accessor :#{arg} end)
-        end
-
-        @mattr_inheritable_attrs
-      end
-
-      def inherited(subclass)
-        super
-        @mattr_inheritable_attrs.each do |inheritable_attribute|
-          ivar = "@#{inheritable_attribute}"
-          subclass.instance_variable_set(ivar, instance_variable_get(ivar).clone)
-
-          if instance_variable_get(ivar).respond_to?(:merge)
-            method = <<-EOM
-              def self.#{inheritable_attribute}
-                duplicate = ModuleInheritableAttributes.hash_deep_dup(#{ivar})
-                #{ivar} = superclass.#{inheritable_attribute}.merge(duplicate)
-              end
-            EOM
-
-            subclass.class_eval method
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/httparty-0.18.1/lib/httparty/net_digest_auth.rb

@@ -1,136 +0,0 @@
-require 'digest/md5'
-require 'net/http'
-
-module Net
-  module HTTPHeader
-    def digest_auth(username, password, response)
-      authenticator = DigestAuthenticator.new(
-        username,
-        password,
-        @method,
-        @path,
-        response
-      )
-
-      authenticator.authorization_header.each do |v|
-        add_field('Authorization', v)
-      end
-
-      authenticator.cookie_header.each do |v|
-        add_field('Cookie', v)
-      end
-    end
-
-    class DigestAuthenticator
-      def initialize(username, password, method, path, response_header)
-        @username = username
-        @password = password
-        @method   = method
-        @path     = path
-        @response = parse(response_header)
-        @cookies  = parse_cookies(response_header)
-      end
-
-      def authorization_header
-        @cnonce = md5(random)
-        header = [
-          %(Digest username="#{@username}"),
-          %(realm="#{@response['realm']}"),
-          %(nonce="#{@response['nonce']}"),
-          %(uri="#{@path}"),
-          %(response="#{request_digest}")
-        ]
-
-        header << %(algorithm="#{@response['algorithm']}") if algorithm_present?
-
-        if qop_present?
-          fields = [
-            %(cnonce="#{@cnonce}"),
-            %(qop="#{@response['qop']}"),
-            "nc=00000001"
-          ]
-          fields.each { |field| header << field }
-        end
-
-        header << %(opaque="#{@response['opaque']}") if opaque_present?
-        header
-      end
-
-      def cookie_header
-        @cookies
-      end
-
-      private
-
-      def parse(response_header)
-        header = response_header['www-authenticate']
-
-        header = header.gsub(/qop=(auth(?:-int)?)/, 'qop="\\1"')
-
-        header =~ /Digest (.*)/
-        params = {}
-        if $1
-          non_quoted = $1.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
-          non_quoted.gsub(/(\w+)=([^,]*)/) { params[$1] = $2 }
-        end
-        params
-      end
-
-      def parse_cookies(response_header)
-        return [] unless response_header['Set-Cookie']
-
-        cookies = response_header['Set-Cookie'].split('; ')
-
-        cookies.reduce([]) do |ret, cookie|
-          ret << cookie
-          ret
-        end
-
-        cookies
-      end
-
-      def opaque_present?
-        @response.key?('opaque') && !@response['opaque'].empty?
-      end
-
-      def qop_present?
-        @response.key?('qop') && !@response['qop'].empty?
-      end
-
-      def random
-        format "%x", (Time.now.to_i + rand(65535))
-      end
-
-      def request_digest
-        a = [md5(a1), @response['nonce'], md5(a2)]
-        a.insert(2, "00000001", @cnonce, @response['qop']) if qop_present?
-        md5(a.join(":"))
-      end
-
-      def md5(str)
-        Digest::MD5.hexdigest(str)
-      end
-
-      def algorithm_present?
-        @response.key?('algorithm') && !@response['algorithm'].empty?
-      end
-
-      def use_md5_sess?
-        algorithm_present? && @response['algorithm'] == 'MD5-sess'
-      end
-
-      def a1
-        a1_user_realm_pwd =  [@username, @response['realm'], @password].join(':')
-        if use_md5_sess?
-          [ md5(a1_user_realm_pwd), @response['nonce'], @cnonce ].join(':')
-        else
-          a1_user_realm_pwd
-        end
-      end
-
-      def a2
-        [@method, @path].join(":")
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/httparty-0.18.1/lib/httparty/parser.rb

@@ -1,150 +0,0 @@
-module HTTParty
-  # The default parser used by HTTParty, supports xml, json, html, csv and
-  # plain text.
-  #
-  # == Custom Parsers
-  #
-  # If you'd like to do your own custom parsing, subclassing HTTParty::Parser
-  # will make that process much easier. There are a few different ways you can
-  # utilize HTTParty::Parser as a superclass.
-  #
-  # @example Intercept the parsing for all formats
-  #   class SimpleParser < HTTParty::Parser
-  #     def parse
-  #       perform_parsing
-  #     end
-  #   end
-  #
-  # @example Add the atom format and parsing method to the default parser
-  #   class AtomParsingIncluded < HTTParty::Parser
-  #     SupportedFormats.merge!(
-  #       {"application/atom+xml" => :atom}
-  #     )
-  #
-  #     def atom
-  #       perform_atom_parsing
-  #     end
-  #   end
-  #
-  # @example Only support the atom format
-  #   class ParseOnlyAtom < HTTParty::Parser
-  #     SupportedFormats = {"application/atom+xml" => :atom}
-  #
-  #     def atom
-  #       perform_atom_parsing
-  #     end
-  #   end
-  #
-  # @abstract Read the Custom Parsers section for more information.
-  class Parser
-    SupportedFormats = {
-      'text/xml'                    => :xml,
-      'application/xml'             => :xml,
-      'application/json'            => :json,
-      'application/vnd.api+json'    => :json,
-      'application/hal+json'        => :json,
-      'text/json'                   => :json,
-      'application/javascript'      => :plain,
-      'text/javascript'             => :plain,
-      'text/html'                   => :html,
-      'text/plain'                  => :plain,
-      'text/csv'                    => :csv,
-      'application/csv'             => :csv,
-      'text/comma-separated-values' => :csv
-    }
-
-    # The response body of the request
-    # @return [String]
-    attr_reader :body
-
-    # The intended parsing format for the request
-    # @return [Symbol] e.g. :json
-    attr_reader :format
-
-    # Instantiate the parser and call {#parse}.
-    # @param [String] body the response body
-    # @param [Symbol] format the response format
-    # @return parsed response
-    def self.call(body, format)
-      new(body, format).parse
-    end
-
-    # @return [Hash] the SupportedFormats hash
-    def self.formats
-      const_get(:SupportedFormats)
-    end
-
-    # @param [String] mimetype response MIME type
-    # @return [Symbol]
-    # @return [nil] mime type not supported
-    def self.format_from_mimetype(mimetype)
-      formats[formats.keys.detect {|k| mimetype.include?(k)}]
-    end
-
-    # @return [Array<Symbol>] list of supported formats
-    def self.supported_formats
-      formats.values.uniq
-    end
-
-    # @param [Symbol] format e.g. :json, :xml
-    # @return [Boolean]
-    def self.supports_format?(format)
-      supported_formats.include?(format)
-    end
-
-    def initialize(body, format)
-      @body = body
-      @format = format
-    end
-
-    # @return [Object] the parsed body
-    # @return [nil] when the response body is nil, an empty string, spaces only or "null"
-    def parse
-      return nil if body.nil?
-      return nil if body == "null"
-      return nil if body.valid_encoding? && body.strip.empty?
-      if body.valid_encoding? && body.encoding == Encoding::UTF_8
-        @body = body.gsub(/\A#{UTF8_BOM}/, '')
-      end
-      if supports_format?
-        parse_supported_format
-      else
-        body
-      end
-    end
-
-    protected
-
-    def xml
-      MultiXml.parse(body)
-    end
-
-    UTF8_BOM = "\xEF\xBB\xBF".freeze
-
-    def json
-      JSON.parse(body, :quirks_mode => true, :allow_nan => true)
-    end
-
-    def csv
-      CSV.parse(body)
-    end
-
-    def html
-      body
-    end
-
-    def plain
-      body
-    end
-
-    def supports_format?
-      self.class.supports_format?(format)
-    end
-
-    def parse_supported_format
-      send(format)
-    rescue NoMethodError => e
-      raise NotImplementedError, "#{self.class.name} has not implemented a parsing method for the #{format.inspect} format.", e.backtrace
-    end
-  end
-end

data/vendor/bundle/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

data/vendor/bundle/ruby/2.7.0/gems/httparty-0.18.1/lib/httparty/request/multipart_boundary.rb

@@ -1,11 +0,0 @@
-require 'securerandom'
-
-module HTTParty
-  class Request
-    class MultipartBoundary
-      def self.generate
-        "------------------------#{SecureRandom.urlsafe_base64(12)}"
-      end
-    end
-  end
-end