vagrant-unbundled 2.2.19.0 → 2.3.2.0

data/vendor/bundle/ruby/3.0.0/gems/mime-types-3.4.1/lib/mime/types/_columnar.rb

@@ -1,137 +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]) || 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))
-      type.instance_variable_set(:@provisional, 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/bundle/ruby/3.0.0/gems/mime-types-3.4.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 && 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.strip
-        Could not load MIME::Types cache: invalid version
-      WARNING
-      nil
-    end
-  rescue => e
-    MIME::Types.logger.warn <<-WARNING.chomp.strip
-      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

data/vendor/bundle/ruby/3.0.0/gems/mime-types-3.4.1/lib/mime/types/columnar.rb

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

data/vendor/bundle/ruby/3.0.0/gems/mime-types-3.4.1/lib/mime/types/container.rb

@@ -1,96 +0,0 @@
-# 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.is_a?(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.is_a?(Set)
-
-      container[k] = Set[*v]
-    end
-  end
-
-  EMPTY_SET = Set.new.freeze
-  private_constant :EMPTY_SET
-end

data/vendor/bundle/ruby/3.0.0/gems/mime-types-3.4.1/lib/mime/types/deprecations.rb

@@ -1,36 +0,0 @@
-# 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.strip
-        #{caller(2..2).first}: #{klass}#{level}#{sym} is deprecated #{message}.
-      WARNING
-
-      return unless block
-      block.call
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/mime-types-3.4.1/lib/mime/types/full.rb

@@ -1,19 +0,0 @@
-# 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/bundle/ruby/3.0.0/gems/mime-types-3.4.1/lib/mime/types/loader.rb

@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-##
-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"
-
-      if old_yaml?
-        YAML.safe_load(read_file(filename), [MIME::Type])
-      else
-        YAML.safe_load(read_file(filename), permitted_classes: [MIME::Type])
-      end
-    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
-
-    def old_yaml?
-      @old_yaml ||=
-        begin
-          require "rubygems/version"
-          Gem::Version.new(YAML::VERSION) < Gem::Version.new("3.1")
-        end
-    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/bundle/ruby/3.0.0/gems/mime-types-3.4.1/lib/mime/types/logger.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-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/bundle/ruby/3.0.0/gems/mime-types-3.4.1/lib/mime/types/registry.rb

@@ -1,90 +0,0 @@
-# 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_method :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.strip
-      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__) && @__types__) || 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