piko-clean-pkg 0.0.1

data/httparty-0.24.2/lib/httparty/logger/logstash_formatter.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+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
+        require 'json'
+        {
+          '@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/httparty-0.24.2/lib/httparty/module_inheritable_attributes.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+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|
+          singleton_class.attr_accessor(arg)
+        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)
+            subclass.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def self.#{inheritable_attribute}
+                duplicate = ModuleInheritableAttributes.hash_deep_dup(#{ivar})
+                #{ivar} = superclass.#{inheritable_attribute}.merge(duplicate)
+              end
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

data/httparty-0.24.2/lib/httparty/net_digest_auth.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+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?
+          header << %(cnonce="#{@cnonce}")
+          header << %(qop="#{@response['qop']}")
+          header << 'nc=00000001'
+        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/httparty-0.24.2/lib/httparty/parser.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+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
+      require 'multi_xml'
+      MultiXml.parse(body)
+    end
+
+    UTF8_BOM = "\xEF\xBB\xBF"
+
+    def json
+      require 'json'
+      JSON.parse(body, :quirks_mode => true, :allow_nan => true)
+    end
+
+    def csv
+      require '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
+      if respond_to?(format, true)
+        send(format)
+      else
+        raise NotImplementedError, "#{self.class.name} has not implemented a parsing method for the #{format.inspect} format."
+      end
+    end
+  end
+end

data/httparty-0.24.2/lib/httparty/request/body.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative 'multipart_boundary'
+require_relative 'streaming_multipart_body'
+
+module HTTParty
+  class Request
+    class Body
+      NEWLINE = "\r\n"
+      private_constant :NEWLINE
+
+      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
+
+      def streaming?
+        multipart? && has_file?(params)
+      end
+
+      def to_stream
+        return nil unless streaming?
+        StreamingMultipartBody.new(prepared_parts, boundary)
+      end
+
+      def prepared_parts
+        normalized_params = params.flat_map { |key, value| HashConversions.normalize_keys(key, value) }
+        normalized_params.map do |key, value|
+          [key, value, file?(value)]
+        end
+      end
+
+      private
+
+      # https://html.spec.whatwg.org/#multipart-form-data
+      MULTIPART_FORM_DATA_REPLACEMENT_TABLE = {
+        '"'  => '%22',
+        "\r" => '%0D',
+        "\n" => '%0A'
+      }.freeze
+
+      def generate_multipart
+        normalized_params = params.flat_map { |key, value| HashConversions.normalize_keys(key, value) }
+
+        multipart = normalized_params.inject(''.b) do |memo, (key, value)|
+          memo << "--#{boundary}#{NEWLINE}".b
+          memo << %(Content-Disposition: form-data; name="#{key}").b
+          # value.path is used to support ActionDispatch::Http::UploadedFile
+          # https://github.com/jnunemaker/httparty/pull/585
+          memo << %(; filename="#{file_name(value).gsub(/["\r\n]/, MULTIPART_FORM_DATA_REPLACEMENT_TABLE)}").b if file?(value)
+          memo << NEWLINE.b
+          memo << "Content-Type: #{content_type(value)}#{NEWLINE}".b if file?(value)
+          memo << NEWLINE.b
+          memo << content_body(value)
+          memo << NEWLINE.b
+        end
+
+        multipart << "--#{boundary}--#{NEWLINE}".b
+      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_body(object)
+        if file?(object)
+          object = (file = object).read
+          object.force_encoding(Encoding::BINARY) if object.respond_to?(:force_encoding)
+          file.rewind if file.respond_to?(:rewind)
+          object.to_s
+        else
+          object.to_s.b
+        end
+      end
+
+      def content_type(object)
+        return object.content_type if object.respond_to?(:content_type)
+        require 'mini_mime'
+        mime = MiniMime.lookup_by_filename(object.path)
+        mime ? mime.content_type : 'application/octet-stream'
+      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/httparty-0.24.2/lib/httparty/request/multipart_boundary.rb

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