vagrant-unbundled 2.2.18.0 → 2.2.19.0

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

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

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

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

@@ -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.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

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

@@ -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/bundle/ruby/3.0.0/gems/mime-types-3.4.1/lib/mime/types/loader.rb

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

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

@@ -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_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