paynow_sdk 0.1.1 → 0.1.8

data/vendor/cache/ruby/2.7.0/gems/mime-types-3.3.1/lib/mime/types/columnar.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'mime/types'

data/vendor/cache/ruby/2.7.0/gems/mime-types-3.3.1/lib/mime/types/container.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'forwardable'
+
+# MIME::Types requires a serializable keyed container that returns an empty Set
+# on a key miss. Hash#default_value cannot be used because, while it traverses
+# the Marshal format correctly, it won't survive any other serialization
+# format (plus, a default of a mutable object resuls in a shared mess).
+# Hash#default_proc cannot be used without a wrapper because it prevents
+# Marshal serialization (and doesn't survive the round-trip).
+class MIME::Types::Container #:nodoc:
+  extend Forwardable
+
+  def initialize(hash = {})
+    @container = {}
+    merge!(hash)
+  end
+
+  def [](key)
+    container[key] || EMPTY_SET
+  end
+
+  def []=(key, value)
+    container[key] =
+      case value
+      when Set
+        value
+      else
+        Set[*value]
+      end
+  end
+
+  def merge(other)
+    self.class.new(other)
+  end
+
+  def merge!(other)
+    tap {
+      other = other.kind_of?(MIME::Types::Container) ? other.container : other
+      container.merge!(other)
+      normalize
+    }
+  end
+
+  def to_hash
+    container
+  end
+
+  def_delegators :@container,
+                 :==,
+                 :count,
+                 :each,
+                 :each_value,
+                 :empty?,
+                 :flat_map,
+                 :keys,
+                 :select,
+                 :values
+
+  def add(key, value)
+    (container[key] ||= Set.new).add(value)
+  end
+
+  def marshal_dump
+    {}.merge(container)
+  end
+
+  def marshal_load(hash)
+    @container = hash
+  end
+
+  def encode_with(coder)
+    container.each { |k, v| coder[k] = v.to_a }
+  end
+
+  def init_with(coder)
+    @container = {}
+    coder.map.each { |k, v| container[k] = Set[*v] }
+  end
+
+  protected
+
+  attr_accessor :container
+
+  def normalize
+    container.each do |k, v|
+      next if v.kind_of?(Set)
+
+      container[k] = Set[*v]
+    end
+  end
+
+  EMPTY_SET = Set.new.freeze
+  private_constant :EMPTY_SET
+end

data/vendor/cache/ruby/2.7.0/gems/mime-types-3.3.1/lib/mime/types/deprecations.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'mime/types/logger'
+
+# The namespace for MIME applications, tools, and libraries.
+module MIME
+  ##
+  class Types
+    # Used to mark a method as deprecated in the mime-types interface.
+    def self.deprecated(klass, sym, message = nil, &block) # :nodoc:
+      level = case klass
+              when Class, Module
+                '.'
+              else
+                klass = klass.class
+                '#'
+              end
+      message = case message
+                when :private, :protected
+                  "and will be #{message}"
+                when nil
+                  'and will be removed'
+                else
+                  message
+                end
+      MIME::Types.logger.warn <<-WARNING.chomp
+#{caller[1]}: #{klass}#{level}#{sym} is deprecated #{message}.
+      WARNING
+      block.call if block
+    end
+  end
+end

data/vendor/cache/ruby/2.7.0/gems/mime-types-3.3.1/lib/mime/types/full.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+##
+module MIME
+  ##
+  class Types
+    unless private_method_defined?(:load_mode)
+      class << self
+        private
+
+        def load_mode
+          { columnar: false }
+        end
+      end
+    end
+  end
+end
+
+require 'mime/types'

data/vendor/cache/ruby/2.7.0/gems/mime-types-3.3.1/lib/mime/types/loader.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+# -*- ruby encoding: utf-8 -*-
+
+##
+module MIME; end
+##
+class MIME::Types; end
+
+require 'mime/types/data'
+
+# This class is responsible for initializing the MIME::Types registry from
+# the data files supplied with the mime-types library.
+#
+# The Loader will use one of the following paths:
+# 1.  The +path+ provided in its constructor argument;
+# 2.  The value of ENV['RUBY_MIME_TYPES_DATA']; or
+# 3.  The value of MIME::Types::Data::PATH.
+#
+# When #load is called, the +path+ will be searched recursively for all YAML
+# (.yml or .yaml) files. By convention, there is one file for each media
+# type (application.yml, audio.yml, etc.), but this is not required.
+class MIME::Types::Loader
+  # The path that will be read for the MIME::Types files.
+  attr_reader :path
+  # The MIME::Types container instance that will be loaded. If not provided
+  # at initialization, a new MIME::Types instance will be constructed.
+  attr_reader :container
+
+  # Creates a Loader object that can be used to load MIME::Types registries
+  # into memory, using YAML, JSON, or Columnar registry format loaders.
+  def initialize(path = nil, container = nil)
+    path = path || ENV['RUBY_MIME_TYPES_DATA'] || MIME::Types::Data::PATH
+    @container = container || MIME::Types.new
+    @path = File.expand_path(path)
+  end
+
+  # Loads a MIME::Types registry from YAML files (<tt>*.yml</tt> or
+  # <tt>*.yaml</tt>) recursively found in +path+.
+  #
+  # It is expected that the YAML objects contained within the registry array
+  # will be tagged as <tt>!ruby/object:MIME::Type</tt>.
+  #
+  # Note that the YAML format is about 2½ times *slower* than the JSON format.
+  #
+  # NOTE: The purpose of this format is purely for maintenance reasons.
+  def load_yaml
+    Dir[yaml_path].sort.each do |f|
+      container.add(*self.class.load_from_yaml(f), :silent)
+    end
+    container
+  end
+
+  # Loads a MIME::Types registry from JSON files (<tt>*.json</tt>)
+  # recursively found in +path+.
+  #
+  # It is expected that the JSON objects will be an array of hash objects.
+  # The JSON format is the registry format for the MIME types registry
+  # shipped with the mime-types library.
+  def load_json
+    Dir[json_path].sort.each do |f|
+      types = self.class.load_from_json(f)
+      container.add(*types, :silent)
+    end
+    container
+  end
+
+  # Loads a MIME::Types registry from columnar files recursively found in
+  # +path+.
+  def load_columnar
+    require 'mime/types/columnar' unless defined?(MIME::Types::Columnar)
+    container.extend(MIME::Types::Columnar)
+    container.load_base_data(path)
+
+    container
+  end
+
+  # Loads a MIME::Types registry. Loads from JSON files by default
+  # (#load_json).
+  #
+  # This will load from columnar files (#load_columnar) if <tt>columnar:
+  # true</tt> is provided in +options+ and there are columnar files in +path+.
+  def load(options = { columnar: false })
+    if options[:columnar] && !Dir[columnar_path].empty?
+      load_columnar
+    else
+      load_json
+    end
+  end
+
+  class << self
+    # Loads the default MIME::Type registry.
+    def load(options = { columnar: false })
+      new.load(options)
+    end
+
+    # Loads MIME::Types from a single YAML file.
+    #
+    # It is expected that the YAML objects contained within the registry
+    # array will be tagged as <tt>!ruby/object:MIME::Type</tt>.
+    #
+    # Note that the YAML format is about 2½ times *slower* than the JSON
+    # format.
+    #
+    # NOTE: The purpose of this format is purely for maintenance reasons.
+    def load_from_yaml(filename)
+      begin
+        require 'psych'
+      rescue LoadError
+        nil
+      end
+      require 'yaml'
+      YAML.load(read_file(filename))
+    end
+
+    # Loads MIME::Types from a single JSON file.
+    #
+    # It is expected that the JSON objects will be an array of hash objects.
+    # The JSON format is the registry format for the MIME types registry
+    # shipped with the mime-types library.
+    def load_from_json(filename)
+      require 'json'
+      JSON.parse(read_file(filename)).map { |type| MIME::Type.new(type) }
+    end
+
+    private
+
+    def read_file(filename)
+      File.open(filename, 'r:UTF-8:-', &:read)
+    end
+  end
+
+  private
+
+  def yaml_path
+    File.join(path, '*.y{,a}ml')
+  end
+
+  def json_path
+    File.join(path, '*.json')
+  end
+
+  def columnar_path
+    File.join(path, '*.column')
+  end
+end

data/vendor/cache/ruby/2.7.0/gems/mime-types-3.3.1/lib/mime/types/logger.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# -*- ruby encoding: utf-8 -*-
+
+require 'logger'
+
+##
+module MIME
+  ##
+  class Types
+    class << self
+      # Configure the MIME::Types logger. This defaults to an instance of a
+      # logger that passes messages (unformatted) through to Kernel#warn.
+      attr_accessor :logger
+    end
+
+    class WarnLogger < ::Logger #:nodoc:
+      class WarnLogDevice < ::Logger::LogDevice #:nodoc:
+        def initialize(*)
+        end
+
+        def write(m)
+          Kernel.warn(m)
+        end
+
+        def close
+        end
+      end
+
+      def initialize(_one, _two = nil, _three = nil)
+        super nil
+        @logdev = WarnLogDevice.new
+        @formatter = ->(_s, _d, _p, m) { m }
+      end
+    end
+
+    self.logger = WarnLogger.new(nil)
+  end
+end

data/vendor/cache/ruby/2.7.0/gems/mime-types-3.3.1/lib/mime/types/registry.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+class << MIME::Types
+  include Enumerable
+
+  ##
+  def new(*) # :nodoc:
+    super.tap do |types|
+      __instances__.add types
+    end
+  end
+
+  # MIME::Types#[] against the default MIME::Types registry.
+  def [](type_id, complete: false, registered: false)
+    __types__[type_id, complete: complete, registered: registered]
+  end
+
+  # MIME::Types#count against the default MIME::Types registry.
+  def count
+    __types__.count
+  end
+
+  # MIME::Types#each against the default MIME::Types registry.
+  def each
+    if block_given?
+      __types__.each { |t| yield t }
+    else
+      enum_for(:each)
+    end
+  end
+
+  # MIME::Types#type_for against the default MIME::Types registry.
+  def type_for(filename)
+    __types__.type_for(filename)
+  end
+  alias of type_for
+
+  # MIME::Types#add against the default MIME::Types registry.
+  def add(*types)
+    __types__.add(*types)
+  end
+
+  private
+
+  def lazy_load?
+    return unless ENV.key?('RUBY_MIME_TYPES_LAZY_LOAD')
+
+    MIME::Types.logger.warn <<-WARNING.chomp
+Lazy loading ($RUBY_MIME_TYPES_LAZY_LOAD) is deprecated and will be removed.
+    WARNING
+
+    (lazy = ENV['RUBY_MIME_TYPES_LAZY_LOAD']) && (lazy != 'false')
+  end
+
+  def __types__
+    (defined?(@__types__) and @__types__) or load_default_mime_types
+  end
+
+  unless private_method_defined?(:load_mode)
+    def load_mode
+      { columnar: true }
+    end
+  end
+
+  def load_default_mime_types(mode = load_mode)
+    if (@__types__ = MIME::Types::Cache.load)
+      __instances__.add(@__types__)
+    else
+      @__types__ = MIME::Types::Loader.load(mode)
+      MIME::Types::Cache.save(@__types__)
+    end
+    @__types__
+  end
+
+  def __instances__
+    @__instances__ ||= Set.new
+  end
+
+  def reindex_extensions(type)
+    __instances__.each do |instance|
+      instance.send(:reindex_extensions!, type)
+    end
+    true
+  end
+end
+
+##
+class MIME::Types
+  load_default_mime_types(load_mode) unless lazy_load?
+end

data/vendor/cache/ruby/2.7.0/gems/mime-types-3.3.1/test/bad-fixtures/malformed

@@ -0,0 +1,9 @@
+!application.smil @smi,smil :8bit 'IANA,RFC4536 =use-instead:application/smil+xml
+!audio/vnd.qcelp @qcp 'IANA,RFC3625 =use-instead:audio/QCELP
+*!image/bmp @bmp =use-instead:image/x-bmp
+*application/acad 'LTSW
+*audio/webm @webm '{WebM=http://www.webmproject.org/code/specs/container/}
+*image/pjpeg :base64 =Fixes a bug with IE6 and progressive JPEGs
+application/1d-interleaved-parityfec 'IANA,RFC6015
+audio/1d-interleaved-parityfec 'IANA,RFC6015
+mac:application/x-apple-diskimage @dmg

data/vendor/cache/ruby/2.7.0/gems/mime-types-3.3.1/test/fixture/json.json

@@ -0,0 +1 @@
+[{"content-type":"application/smil","encoding":"8bit","extensions":["smi","smil"],"obsolete":true,"use-instead":"application/smil+xml","registered":true},{"content-type":"audio/vnd.qcelp","encoding":"base64","extensions":["qcp"],"obsolete":true,"use-instead":"audio/QCELP","registered":true},{"content-type":"image/bmp","encoding":"base64","extensions":["bmp"],"obsolete":true,"use-instead":"image/x-bmp","registered":false},{"content-type":"application/acad","encoding":"base64","registered":false},{"content-type":"audio/webm","encoding":"base64","extensions":["webm"],"registered":false},{"content-type":"image/pjpeg","docs":"Fixes a bug with IE6 and progressive JPEGs","encoding":"base64","registered":false},{"content-type":"application/1d-interleaved-parityfec","encoding":"base64","registered":true},{"content-type":"audio/1d-interleaved-parityfec","encoding":"base64","registered":true},{"content-type":"application/x-apple-diskimage","encoding":"base64","extensions":["dmg"],"registered":false}]

data/vendor/cache/ruby/2.7.0/gems/mime-types-3.3.1/test/fixture/old-data

@@ -0,0 +1,9 @@
+!application/smil @smi,smil :8bit 'IANA,RFC4536 =use-instead:application/smil+xml
+!audio/vnd.qcelp @qcp 'IANA,RFC3625 =use-instead:audio/QCELP
+*!image/bmp @bmp =use-instead:image/x-bmp
+*application/acad 'LTSW
+*audio/webm @webm '{WebM=http://www.webmproject.org/code/specs/container/}
+*image/pjpeg :base64 =Fixes a bug with IE6 and progressive JPEGs
+application/1d-interleaved-parityfec 'IANA,RFC6015
+audio/1d-interleaved-parityfec 'IANA,RFC6015
+mac:application/x-apple-diskimage @dmg