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/mime-types-3.3.1/lib/mime/type/columnar.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require 'mime/type'
-
-# A version of MIME::Type that works hand-in-hand with a MIME::Types::Columnar
-# container to load data by columns.
-#
-# When a field is has not yet been loaded, that data will be loaded for all
-# types in the container before forwarding the message to MIME::Type.
-#
-# More information can be found in MIME::Types::Columnar.
-#
-# MIME::Type::Columnar is *not* intended to be created except by
-# MIME::Types::Columnar containers.
-class MIME::Type::Columnar < MIME::Type
-  def initialize(container, content_type, extensions) # :nodoc:
-    @container = container
-    self.content_type = content_type
-    self.extensions = extensions
-  end
-
-  def self.column(*methods, file: nil) # :nodoc:
-    file ||= methods.first
-
-    file_method = :"load_#{file}"
-    methods.each do |m|
-      define_method m do |*args|
-        @container.send(file_method)
-        super(*args)
-      end
-    end
-  end
-
-  column :friendly
-  column :encoding, :encoding=
-  column :docs, :docs=
-  column :preferred_extension, :preferred_extension=
-  column :obsolete, :obsolete=, :obsolete?, :registered, :registered=,
-         :registered?, :signature, :signature=, :signature?, file: 'flags'
-  column :xrefs, :xrefs=, :xref_urls
-  column :use_instead, :use_instead=
-
-  def encode_with(coder) # :nodoc:
-    @container.send(:load_friendly)
-    @container.send(:load_encoding)
-    @container.send(:load_docs)
-    @container.send(:load_flags)
-    @container.send(:load_use_instead)
-    @container.send(:load_xrefs)
-    @container.send(:load_preferred_extension)
-    super
-  end
-
-  class << self
-    undef column
-  end
-end

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

@@ -1,231 +0,0 @@
-# frozen_string_literal: true
-
-##
-module MIME
-  ##
-  class Types
-  end
-end
-
-require 'mime/type'
-
-# MIME::Types is a registry of MIME types. It is both a class (created with
-# MIME::Types.new) and a default registry (loaded automatically or through
-# interactions with MIME::Types.[] and MIME::Types.type_for).
-#
-# == The Default mime-types Registry
-#
-# The default mime-types registry is loaded automatically when the library
-# is required (<tt>require 'mime/types'</tt>), but it may be lazily loaded
-# (loaded on first use) with the use of the environment variable
-# +RUBY_MIME_TYPES_LAZY_LOAD+ having any value other than +false+. The
-# initial startup is about 14× faster (~10 ms vs ~140 ms), but the
-# registry will be loaded at some point in the future.
-#
-# The default mime-types registry can also be loaded from a Marshal cache
-# file specific to the version of MIME::Types being loaded. This will be
-# handled automatically with the use of a file referred to in the
-# environment variable +RUBY_MIME_TYPES_CACHE+. MIME::Types will attempt to
-# load the registry from this cache file (MIME::Type::Cache.load); if it
-# cannot be loaded (because the file does not exist, there is an error, or
-# the data is for a different version of mime-types), the default registry
-# will be loaded from the normal JSON version and then the cache file will
-# be *written* to the location indicated by +RUBY_MIME_TYPES_CACHE+. Cache
-# file loads just over 4½× faster (~30 ms vs ~140 ms).
-# loads.
-#
-# Notes:
-# * The loading of the default registry is *not* atomic; when using a
-#   multi-threaded environment, it is recommended that lazy loading is not
-#   used and mime-types is loaded as early as possible.
-# * Cache files should be specified per application in a multiprocess
-#   environment and should be initialized during deployment or before
-#   forking to minimize the chance that the multiple processes will be
-#   trying to write to the same cache file at the same time, or that two
-#   applications that are on different versions of mime-types would be
-#   thrashing the cache.
-# * Unless cache files are preinitialized, the application using the
-#   mime-types cache file must have read/write permission to the cache file.
-#
-# == Usage
-#  require 'mime/types'
-#
-#  plaintext = MIME::Types['text/plain']
-#  print plaintext.media_type           # => 'text'
-#  print plaintext.sub_type             # => 'plain'
-#
-#  puts plaintext.extensions.join(" ")  # => 'asc txt c cc h hh cpp'
-#
-#  puts plaintext.encoding              # => 8bit
-#  puts plaintext.binary?               # => false
-#  puts plaintext.ascii?                # => true
-#  puts plaintext.obsolete?             # => false
-#  puts plaintext.registered?           # => true
-#  puts plaintext == 'text/plain'       # => true
-#  puts MIME::Type.simplified('x-appl/x-zip') # => 'appl/zip'
-#
-class MIME::Types
-  # The release version of Ruby MIME::Types
-  VERSION = MIME::Type::VERSION
-
-  include Enumerable
-
-  # Creates a new MIME::Types registry.
-  def initialize
-    @type_variants    = Container.new
-    @extension_index  = Container.new
-  end
-
-  # Returns the number of known type variants.
-  def count
-    @type_variants.values.inject(0) { |a, e| a + e.size }
-  end
-
-  def inspect # :nodoc:
-    "#<#{self.class}: #{count} variants, #{@extension_index.count} extensions>"
-  end
-
-  # Iterates through the type variants.
-  def each
-    if block_given?
-      @type_variants.each_value { |tv| tv.each { |t| yield t } }
-    else
-      enum_for(:each)
-    end
-  end
-
-  @__types__ = nil
-
-  # Returns a list of MIME::Type objects, which may be empty. The optional
-  # flag parameters are <tt>:complete</tt> (finds only complete MIME::Type
-  # objects) and <tt>:registered</tt> (finds only MIME::Types that are
-  # registered). It is possible for multiple matches to be returned for
-  # either type (in the example below, 'text/plain' returns two values --
-  # one for the general case, and one for VMS systems).
-  #
-  #   puts "\nMIME::Types['text/plain']"
-  #   MIME::Types['text/plain'].each { |t| puts t.to_a.join(", ") }
-  #
-  #   puts "\nMIME::Types[/^image/, complete: true]"
-  #   MIME::Types[/^image/, :complete => true].each do |t|
-  #     puts t.to_a.join(", ")
-  #   end
-  #
-  # If multiple type definitions are returned, returns them sorted as
-  # follows:
-  #   1. Complete definitions sort before incomplete ones;
-  #   2. IANA-registered definitions sort before LTSW-recorded
-  #      definitions.
-  #   3. Current definitions sort before obsolete ones;
-  #   4. Obsolete definitions with use-instead clauses sort before those
-  #      without;
-  #   5. Obsolete definitions use-instead clauses are compared.
-  #   6. Sort on name.
-  def [](type_id, complete: false, registered: false)
-    matches = case type_id
-              when MIME::Type
-                @type_variants[type_id.simplified]
-              when Regexp
-                match(type_id)
-              else
-                @type_variants[MIME::Type.simplified(type_id)]
-              end
-
-    prune_matches(matches, complete, registered).sort { |a, b|
-      a.priority_compare(b)
-    }
-  end
-
-  # Return the list of MIME::Types which belongs to the file based on its
-  # filename extension. If there is no extension, the filename will be used
-  # as the matching criteria on its own.
-  #
-  # This will always return a merged, flatten, priority sorted, unique array.
-  #
-  #   puts MIME::Types.type_for('citydesk.xml')
-  #     => [application/xml, text/xml]
-  #   puts MIME::Types.type_for('citydesk.gif')
-  #     => [image/gif]
-  #   puts MIME::Types.type_for(%w(citydesk.xml citydesk.gif))
-  #     => [application/xml, image/gif, text/xml]
-  def type_for(filename)
-    Array(filename).flat_map { |fn|
-      @extension_index[fn.chomp.downcase[/\.?([^.]*?)$/, 1]]
-    }.compact.inject(Set.new, :+).sort { |a, b|
-      a.priority_compare(b)
-    }
-  end
-  alias of type_for
-
-  # Add one or more MIME::Type objects to the set of known types. If the
-  # type is already known, a warning will be displayed.
-  #
-  # The last parameter may be the value <tt>:silent</tt> or +true+ which
-  # will suppress duplicate MIME type warnings.
-  def add(*types)
-    quiet = ((types.last == :silent) or (types.last == true))
-
-    types.each do |mime_type|
-      case mime_type
-      when true, false, nil, Symbol
-        nil
-      when MIME::Types
-        variants = mime_type.instance_variable_get(:@type_variants)
-        add(*variants.values.inject(Set.new, :+).to_a, quiet)
-      when Array
-        add(*mime_type, quiet)
-      else
-        add_type(mime_type, quiet)
-      end
-    end
-  end
-
-  # Add a single MIME::Type object to the set of known types. If the +type+ is
-  # already known, a warning will be displayed. The +quiet+ parameter may be a
-  # truthy value to suppress that warning.
-  def add_type(type, quiet = false)
-    if !quiet and @type_variants[type.simplified].include?(type)
-      MIME::Types.logger.warn <<-WARNING
-Type #{type} is already registered as a variant of #{type.simplified}.
-      WARNING
-    end
-
-    add_type_variant!(type)
-    index_extensions!(type)
-  end
-
-  private
-
-  def add_type_variant!(mime_type)
-    @type_variants.add(mime_type.simplified, mime_type)
-  end
-
-  def reindex_extensions!(mime_type)
-    return unless @type_variants[mime_type.simplified].include?(mime_type)
-
-    index_extensions!(mime_type)
-  end
-
-  def index_extensions!(mime_type)
-    mime_type.extensions.each { |ext| @extension_index.add(ext, mime_type) }
-  end
-
-  def prune_matches(matches, complete, registered)
-    matches.delete_if { |e| !e.complete? } if complete
-    matches.delete_if { |e| !e.registered? } if registered
-    matches
-  end
-
-  def match(pattern)
-    @type_variants.select { |k, _|
-      k =~ pattern
-    }.values.inject(Set.new, :+)
-  end
-end
-
-require 'mime/types/cache'
-require 'mime/types/container'
-require 'mime/types/loader'
-require 'mime/types/logger'
-require 'mime/types/_columnar'
-require 'mime/types/registry'

data/vendor/cache/ruby/2.7.0/gems/paynow_sdk-0.1.6/vendor/cache/ruby/2.7.0/gems/mime-types-3.3.1/lib/mime/types/_columnar.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-require 'mime/type/columnar'
-
-# MIME::Types::Columnar is used to extend a MIME::Types container to load data
-# by columns instead of from JSON or YAML. Column loads of MIME types loaded
-# through the columnar store are synchronized with a Mutex.
-#
-# MIME::Types::Columnar is not intended to be used directly, but will be added
-# to an instance of MIME::Types when it is loaded with
-# MIME::Types::Loader#load_columnar.
-module MIME::Types::Columnar
-  LOAD_MUTEX = Mutex.new # :nodoc:
-
-  def self.extended(obj) # :nodoc:
-    super
-    obj.instance_variable_set(:@__mime_data__, [])
-    obj.instance_variable_set(:@__files__, Set.new)
-  end
-
-  # Load the first column data file (type and extensions).
-  def load_base_data(path) #:nodoc:
-    @__root__ = path
-
-    each_file_line('content_type', false) do |line|
-      line = line.split
-      content_type = line.shift
-      extensions = line
-      # content_type, *extensions = line.split
-
-      type = MIME::Type::Columnar.new(self, content_type, extensions)
-      @__mime_data__ << type
-      add(type)
-    end
-
-    self
-  end
-
-  private
-
-  def each_file_line(name, lookup = true)
-    LOAD_MUTEX.synchronize do
-      next if @__files__.include?(name)
-
-      i = -1
-      column = File.join(@__root__, "mime.#{name}.column")
-
-      IO.readlines(column, encoding: 'UTF-8').each do |line|
-        line.chomp!
-
-        if lookup
-          type = @__mime_data__[i += 1] or next
-          yield type, line
-        else
-          yield line
-        end
-      end
-
-      @__files__ << name
-    end
-  end
-
-  def load_encoding
-    each_file_line('encoding') do |type, line|
-      pool ||= {}
-      type.instance_variable_set(:@encoding, (pool[line] ||= line))
-    end
-  end
-
-  def load_docs
-    each_file_line('docs') do |type, line|
-      type.instance_variable_set(:@docs, opt(line))
-    end
-  end
-
-  def load_preferred_extension
-    each_file_line('pext') do |type, line|
-      type.instance_variable_set(:@preferred_extension, opt(line))
-    end
-  end
-
-  def load_flags
-    each_file_line('flags') do |type, line|
-      line = line.split
-      type.instance_variable_set(:@obsolete, flag(line.shift))
-      type.instance_variable_set(:@registered, flag(line.shift))
-      type.instance_variable_set(:@signature, flag(line.shift))
-    end
-  end
-
-  def load_xrefs
-    each_file_line('xrefs') { |type, line|
-      type.instance_variable_set(:@xrefs, dict(line, array: true))
-    }
-  end
-
-  def load_friendly
-    each_file_line('friendly') { |type, line|
-      type.instance_variable_set(:@friendly, dict(line))
-    }
-  end
-
-  def load_use_instead
-    each_file_line('use_instead') do |type, line|
-      type.instance_variable_set(:@use_instead, opt(line))
-    end
-  end
-
-  def dict(line, array: false)
-    if line == '-'
-      {}
-    else
-      line.split('|').each_with_object({}) { |l, h|
-        k, v = l.split('^')
-        v = nil if v.empty?
-        h[k] = array ? Array(v) : v
-      }
-    end
-  end
-
-  def arr(line)
-    if line == '-'
-      []
-    else
-      line.split('|').flatten.compact.uniq
-    end
-  end
-
-  def opt(line)
-    line unless line == '-'
-  end
-
-  def flag(line)
-    line == '1'
-  end
-end

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

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-MIME::Types::Cache = Struct.new(:version, :data) # :nodoc:
-
-# Caching of MIME::Types registries is advisable if you will be loading
-# the default registry relatively frequently. With the class methods on
-# MIME::Types::Cache, any MIME::Types registry can be marshaled quickly
-# and easily.
-#
-# The cache is invalidated on a per-data-version basis; a cache file for
-# version 3.2015.1118 will not be reused with version 3.2015.1201.
-class << MIME::Types::Cache
-  # Attempts to load the cache from the file provided as a parameter or in
-  # the environment variable +RUBY_MIME_TYPES_CACHE+. Returns +nil+ if the
-  # file does not exist, if the file cannot be loaded, or if the data in
-  # the cache version is different than this version.
-  def load(cache_file = nil)
-    cache_file ||= ENV['RUBY_MIME_TYPES_CACHE']
-    return nil unless cache_file and File.exist?(cache_file)
-
-    cache = Marshal.load(File.binread(cache_file))
-    if cache.version == MIME::Types::Data::VERSION
-      Marshal.load(cache.data)
-    else
-      MIME::Types.logger.warn <<-WARNING.chomp
-Could not load MIME::Types cache: invalid version
-      WARNING
-      nil
-    end
-  rescue => e
-    MIME::Types.logger.warn <<-WARNING.chomp
-Could not load MIME::Types cache: #{e}
-    WARNING
-    nil
-  end
-
-  # Attempts to save the types provided to the cache file provided.
-  #
-  # If +types+ is not provided or is +nil+, the cache will contain the
-  # current MIME::Types default registry.
-  #
-  # If +cache_file+ is not provided or is +nil+, the cache will be written
-  # to the file specified in the environment variable
-  # +RUBY_MIME_TYPES_CACHE+. If there is no cache file specified either
-  # directly or through the environment, this method will return +nil+
-  def save(types = nil, cache_file = nil)
-    cache_file ||= ENV['RUBY_MIME_TYPES_CACHE']
-    return nil unless cache_file
-
-    types ||= MIME::Types.send(:__types__)
-
-    File.open(cache_file, 'wb') do |f|
-      f.write(
-        Marshal.dump(new(MIME::Types::Data::VERSION, Marshal.dump(types)))
-      )
-    end
-  end
-end