mime-types 2.99.3 → 3.4.1

data/lib/mime/types/loader.rb

@@ -1,9 +1,12 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
+##
 module MIME; end
+
+##
 class MIME::Types; end
 
-require 'mime/types/loader_path'
+require "mime/types/data"
 
 # This class is responsible for initializing the MIME::Types registry from
 # the data files supplied with the mime-types library.
@@ -11,7 +14,7 @@ require 'mime/types/loader_path'
 # 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::Loader::PATH.
+# 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
@@ -24,15 +27,11 @@ class MIME::Types::Loader
   attr_reader :container
 
   # Creates a Loader object that can be used to load MIME::Types registries
-  # into memory, using YAML, JSON, or v1 registry format loaders.
+  # 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::Loader::PATH
+    path = path || ENV["RUBY_MIME_TYPES_DATA"] || MIME::Types::Data::PATH
     @container = container || MIME::Types.new
     @path = File.expand_path(path)
-    # begin
-    #   require 'mime/lazy_types'
-    #   @container.extend(MIME::LazyTypes)
-    # end
   end
 
   # Loads a MIME::Types registry from YAML files (<tt>*.yml</tt> or
@@ -41,8 +40,7 @@ class MIME::Types::Loader
   # 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 either the v1
-  # format or the JSON format.
+  # 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
@@ -69,7 +67,7 @@ class MIME::Types::Loader
   # Loads a MIME::Types registry from columnar files recursively found in
   # +path+.
   def load_columnar
-    require 'mime/types/columnar' unless defined?(MIME::Types::Columnar)
+    require "mime/types/columnar" unless defined?(MIME::Types::Columnar)
     container.extend(MIME::Types::Columnar)
     container.load_base_data(path)
 
@@ -81,7 +79,7 @@ class MIME::Types::Loader
   #
   # 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 })
+  def load(options = {columnar: false})
     if options[:columnar] && !Dir[columnar_path].empty?
       load_columnar
     else
@@ -89,132 +87,35 @@ class MIME::Types::Loader
     end
   end
 
-  # Loads a MIME::Types registry from files found in +path+ that are in the
-  # v1 data format. The file search for this will exclude both JSON
-  # (<tt>*.json</tt>) and YAML (<tt>*.yml</tt> or <tt>*.yaml</tt>) files.
-  #
-  # This method has been deprecated and will be removed from mime-types 3.0.
-  def load_v1
-    MIME::Types.deprecated(self.class, __method__)
-    Dir[v1_path].sort.each do |f|
-      next if f =~ /\.(?:ya?ml|json|column)$/
-      container.add(self.class.load_from_v1(f, true), true)
-    end
-    container
-  end
-
-  # Raised when a V1 format file is discovered. This exception will be removed
-  # for mime-types 3.0.
-  BadV1Format = Class.new(Exception)
-
   class << self
     # Loads the default MIME::Type registry.
-    def load(options = { columnar: false })
+    def load(options = {columnar: false})
       new.load(options)
     end
 
-    # Build the type list from a file in the format:
-    #
-    #   [*][!][os:]mt/st[<ws>@ext][<ws>:enc][<ws>'url-list][<ws>=docs]
-    #
-    # == *
-    # An unofficial MIME type. This should be used if and only if the MIME type
-    # is not properly specified (that is, not under either x-type or
-    # vnd.name.type).
-    #
-    # == !
-    # An obsolete MIME type. May be used with an unofficial MIME type.
-    #
-    # == os:
-    # Platform-specific MIME type definition.
-    #
-    # == mt
-    # The media type.
-    #
-    # == st
-    # The media subtype.
-    #
-    # == <ws>@ext
-    # The list of comma-separated extensions.
-    #
-    # == <ws>:enc
-    # The encoding.
-    #
-    # == <ws>'url-list
-    # The list of comma-separated URLs.
-    #
-    # == <ws>=docs
-    # The documentation string.
-    #
-    # That is, everything except the media type and the subtype is optional. The
-    # more information that's available, though, the richer the values that can
-    # be provided.
-    #
-    # This method has been deprecated and will be removed in mime-types 3.0.
-    def load_from_v1(filename, __internal__ = false)
-      MIME::Types.deprecated(self.class, __method__) unless __internal__
-      data = read_file(filename).split($/)
-      mime = MIME::Types.new
-      data.each_with_index { |line, index|
-        item = line.chomp.strip
-        next if item.empty?
-
-        m = V1_FORMAT.match(item)
-
-        unless m
-          MIME::Types.logger.warn <<-EOS
-#{filename}:#{index + 1}: Parsing error in v1 MIME type definition.
-=> #{line}
-          EOS
-          fail BadV1Format, line
-        end
-
-        unregistered, obsolete, _, mediatype, subtype, extensions, encoding,
-          urls, docs, _ = *m.captures
-
-        next if mediatype.nil?
-
-        extensions &&= extensions.split(/,/)
-        urls &&= urls.split(/,/)
-
-        if docs.nil?
-          use_instead = nil
-        else
-          use_instead = docs.scan(%r{use-instead:(\S+)}).flatten.first
-          docs = docs.gsub(%r{use-instead:\S+}, '').squeeze(' \t')
-        end
-
-        mime_type = MIME::Type.new("#{mediatype}/#{subtype}") do |t|
-          t.extensions  = extensions
-          t.encoding    = encoding
-          t.obsolete    = obsolete
-          t.registered  = false if unregistered
-          t.use_instead = use_instead
-          t.docs        = docs
-        end
-
-        mime.add_type(mime_type, true)
-      }
-      mime
-    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 either the v1
-    # format or the JSON format.
+    # 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'
+        require "psych"
       rescue LoadError
         nil
       end
-      require 'yaml'
-      YAML.load(read_file(filename))
+
+      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.
@@ -223,53 +124,36 @@ class MIME::Types::Loader
     # 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'
+      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:-') { |f| f.read }
+      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')
+    File.join(path, "*.y{,a}ml")
   end
 
   def json_path
-    File.join(path, '*.json')
+    File.join(path, "*.json")
   end
 
   def columnar_path
-    File.join(path, '*.column')
+    File.join(path, "*.column")
   end
-
-  def v1_path
-    File.join(path, '*')
-  end
-
-  # The regular expression used to match a v1-format file-based MIME type
-  # definition.
-  #
-  # This constant has been deprecated and will be removed in mime-types 3.0.
-  V1_FORMAT = # :nodoc:
-    %r{\A\s*
-    ([*])?                                        # 0:    Unregistered?
-    (!)?                                          # 1:    Obsolete?
-    (?:(\w+):)?                                   # 2:    Platform marker
-    ([-\w.+]+)/([-\w.+]*)                         # 3, 4: Media Type
-    (?:\s+@(\S+))?                                # 5:    Extensions
-    (?:\s+:(base64|7bit|8bit|quoted\-printable))? # 6:    Encoding
-    (?:\s+'(\S+))?                                # 7:    URL list
-    (?:\s+=(.+))?                                 # 8:    Documentation
-    (?:\s*([#].*)?)?                              #       Comments
-    \s*
-    \z
-    }x
-
-  private_constant :V1_FORMAT if respond_to? :private_constant
 end

data/lib/mime/types/logger.rb

@@ -1,8 +1,10 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
-require 'logger'
+require "logger"
 
+##
 module MIME
+  ##
   class Types
     class << self
       # Configure the MIME::Types logger. This defaults to an instance of a
@@ -10,8 +12,8 @@ module MIME
       attr_accessor :logger
     end
 
-    class WarnLogger < ::Logger #:nodoc:
-      class WarnLogDevice < ::Logger::LogDevice #:nodoc:
+    class WarnLogger < ::Logger # :nodoc:
+      class WarnLogDevice < ::Logger::LogDevice # :nodoc:
         def initialize(*)
         end
 
@@ -23,7 +25,7 @@ module MIME
         end
       end
 
-      def initialize(_1, _2 = nil, _3 = nil)
+      def initialize(_one, _two = nil, _three = nil)
         super nil
         @logdev = WarnLogDevice.new
         @formatter = ->(_s, _d, _p, m) { m }

data/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

data/lib/mime/types.rb

@@ -1,9 +1,13 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
-require 'mime/types/deprecations'
-require 'mime/type'
-require 'mime/types/cache'
-require 'mime/types/loader'
+##
+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
@@ -57,6 +61,7 @@ require 'mime/types/loader'
 #  puts plaintext.ascii?                # => true
 #  puts plaintext.obsolete?             # => false
 #  puts plaintext.registered?           # => true
+#  puts plaintext.provisional?          # => false
 #  puts plaintext == 'text/plain'       # => true
 #  puts MIME::Type.simplified('x-appl/x-zip') # => 'appl/zip'
 #
@@ -66,37 +71,19 @@ class MIME::Types
 
   include Enumerable
 
-  # The data version.
-  attr_reader :data_version
-
   # Creates a new MIME::Types registry.
   def initialize
-    @type_variants    = Container.new
-    @extension_index  = Container.new
-    @data_version     = VERSION.dup.freeze
-  end
-
-  # This method is deprecated and will be removed in mime-types 3.0.
-  def add_type_variant(mime_type) # :nodoc:
-    MIME::Types.deprecated(self, __method__, :private)
-    add_type_variant!(mime_type)
-  end
-
-  # This method is deprecated and will be removed in mime-types 3.0.
-  def index_extensions(mime_type) # :nodoc:
-    MIME::Types.deprecated(self, __method__, :private)
-    index_extensions!(mime_type)
-  end
-
-  # This method is deprecated and will be removed in mime-types 3.0.
-  def defined_types # :nodoc:
-    MIME::Types.deprecated(self, __method__)
-    @type_variants.values.flatten
+    @type_variants = Container.new
+    @extension_index = Container.new
   end
 
   # Returns the number of known type variants.
   def count
-    @type_variants.values.reduce(0) { |m, o| m + o.size }
+    @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.
@@ -108,7 +95,7 @@ class MIME::Types
     end
   end
 
-  @__types__  = nil
+  @__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
@@ -135,23 +122,20 @@ class MIME::Types
   #      without;
   #   5. Obsolete definitions use-instead clauses are compared.
   #   6. Sort on name.
-  #
-  # The previously supported (but deprecated) <tt>:platform</tt> flag is now ignored.
-  def [](type_id, flags = {})
-    if flags.key?(:platform)
-      MIME::Types.deprecated(self, __method__, 'using the :platform flag')
-    end
-
-    matches = case type_id
+  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
+      end
 
-    prune_matches(matches, flags).sort { |a, b| a.priority_compare(b) }
+    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
@@ -166,17 +150,12 @@ class MIME::Types
   #     => [image/gif]
   #   puts MIME::Types.type_for(%w(citydesk.xml citydesk.gif))
   #     => [application/xml, image/gif, text/xml]
-  #
-  # The deprecated +platform+ flag is ignored.
-  def type_for(filename, platform = :deprecated)
-    types = Array(filename).flat_map { |fn|
+  def type_for(filename)
+    Array(filename).flat_map { |fn|
       @extension_index[fn.chomp.downcase[/\.?([^.]*?)$/, 1]]
-    }.compact.sort { |a, b| a.priority_compare(b) }.uniq
-
-    unless platform == :deprecated
-      MIME::Types.deprecated(self, __method__, 'using the platform parameter')
-    end
-    types
+    }.compact.inject(Set.new, :+).sort { |a, b|
+      a.priority_compare(b)
+    }
   end
   alias_method :of, :type_for
 
@@ -186,7 +165,7 @@ class MIME::Types
   # 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))
+    quiet = ((types.last == :silent) || (types.last == true))
 
     types.each do |mime_type|
       case mime_type
@@ -194,7 +173,7 @@ class MIME::Types
         nil
       when MIME::Types
         variants = mime_type.instance_variable_get(:@type_variants)
-        add(*variants.values.flatten, quiet)
+        add(*variants.values.inject(Set.new, :+).to_a, quiet)
       when Array
         add(*mime_type, quiet)
       else
@@ -207,120 +186,48 @@ class MIME::Types
   # 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
+    if !quiet && @type_variants[type.simplified].include?(type)
+      MIME::Types.logger.warn <<-WARNING.chomp.strip
+        Type #{type} is already registered as a variant of #{type.simplified}.
+      WARNING
     end
 
     add_type_variant!(type)
     index_extensions!(type)
   end
 
-  class << self
-    include Enumerable
-
-    # Load MIME::Types from a v1 file registry.
-    #
-    # This method has been deprecated and will be removed in mime-types 3.0.
-    def load_from_file(filename)
-      MIME::Types.deprecated(self, __method__)
-      MIME::Types::Loader.load_from_v1(filename)
-    end
-
-    # MIME::Types#[] against the default MIME::Types registry.
-    def [](type_id, flags = {})
-      __types__[type_id, flags]
-    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, platform = :deprecated)
-      __types__.type_for(filename, platform)
-    end
-    alias_method :of, :type_for
-
-    # MIME::Types#add against the default MIME::Types registry.
-    def add(*types)
-      __types__.add(*types)
-    end
-
-    # Returns the currently defined cache file, if any.
-    #
-    # This method has been deprecated and will be removed in mime-types 3.0.
-    def cache_file
-      MIME::Types.deprecated(self, __method__)
-      ENV['RUBY_MIME_TYPES_CACHE']
-    end
-
-    def add_type_variant(mime_type) # :nodoc:
-      __types__.add_type_variant(mime_type)
-    end
-
-    def index_extensions(mime_type) # :nodoc:
-      __types__.index_extensions(mime_type)
-    end
-
-    private
-
-    def lazy_load?
-      (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
-        {}
-      end
-    end
+  private
 
-    def load_default_mime_types(mode = load_mode())
-      @__types__ = MIME::Types::Cache.load
-      unless @__types__
-        @__types__ = MIME::Types::Loader.load(mode)
-        MIME::Types::Cache.save(@__types__)
-      end
-      @__types__
-    end
+  def add_type_variant!(mime_type)
+    @type_variants.add(mime_type.simplified, mime_type)
   end
 
-  private
+  def reindex_extensions!(mime_type)
+    return unless @type_variants[mime_type.simplified].include?(mime_type)
 
-  def add_type_variant!(mime_type)
-    @type_variants[mime_type.simplified] << mime_type
+    index_extensions!(mime_type)
   end
 
   def index_extensions!(mime_type)
-    mime_type.extensions.each { |ext| @extension_index[ext] << mime_type }
+    mime_type.extensions.each { |ext| @extension_index.add(ext, mime_type) }
   end
 
-  def prune_matches(matches, flags)
-    matches.delete_if { |e| !e.complete? } if flags[:complete]
-    matches.delete_if { |e| !e.registered? } if flags[:registered]
+  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.flatten
+    @type_variants.select { |k, _|
+      k =~ pattern
+    }.values.inject(Set.new, :+)
   end
-
-  load_default_mime_types(load_mode) unless lazy_load?
 end
 
-# vim: ft=ruby
+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/lib/mime-types.rb

@@ -1,3 +1,3 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
-require 'mime/types'
+require "mime/types"