paynow_sdk 0.1.1 → 0.1.8

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

@@ -0,0 +1,91 @@
+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/cache/ruby/2.7.0/gems/httparty-0.18.1/lib/httparty/logger/logger.rb

@@ -0,0 +1,28 @@
+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/cache/ruby/2.7.0/gems/httparty-0.18.1/lib/httparty/logger/logstash_formatter.rb

@@ -0,0 +1,59 @@
+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/cache/ruby/2.7.0/gems/httparty-0.18.1/lib/httparty/module_inheritable_attributes.rb

@@ -0,0 +1,56 @@
+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/cache/ruby/2.7.0/gems/httparty-0.18.1/lib/httparty/net_digest_auth.rb

@@ -0,0 +1,136 @@
+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/cache/ruby/2.7.0/gems/httparty-0.18.1/lib/httparty/parser.rb

@@ -0,0 +1,150 @@
+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