mime-types 3.3.1 → 3.7.0

data/lib/mime/types/_columnar.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'mime/type/columnar'
+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
@@ -18,21 +18,28 @@ module MIME::Types::Columnar
     obj.instance_variable_set(:@__files__, Set.new)
   end
 
+  def __fully_loaded? # :nodoc:
+    @__files__.size == 10
+  end
+
   # Load the first column data file (type and extensions).
-  def load_base_data(path) #:nodoc:
+  def load_base_data(path) # :nodoc:
     @__root__ = path
 
-    each_file_line('content_type', false) do |line|
+    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
 
+    each_file_byte("spri") do |type, byte|
+      type.instance_variable_set(:@__sort_priority, byte)
+    end
+
     self
   end
 
@@ -45,11 +52,11 @@ module MIME::Types::Columnar
       i = -1
       column = File.join(@__root__, "mime.#{name}.column")
 
-      IO.readlines(column, encoding: 'UTF-8').each do |line|
+      IO.readlines(column, encoding: "UTF-8").each do |line|
         line.chomp!
 
         if lookup
-          type = @__mime_data__[i += 1] or next
+          (type = @__mime_data__[i += 1]) || next
           yield type, line
         else
           yield line
@@ -60,77 +67,118 @@ module MIME::Types::Columnar
     end
   end
 
+  def each_file_byte(name)
+    LOAD_MUTEX.synchronize do
+      next if @__files__.include?(name)
+
+      i = -1
+
+      filename = File.join(@__root__, "mime.#{name}.column")
+
+      next unless File.exist?(filename)
+
+      IO.binread(filename).unpack("C*").each do |byte|
+        (type = @__mime_data__[i += 1]) || next
+        yield type, byte
+      end
+
+      @__files__ << name
+    end
+  end
+
   def load_encoding
-    each_file_line('encoding') do |type, line|
+    each_file_line("encoding") do |type, line|
       pool ||= {}
-      type.instance_variable_set(:@encoding, (pool[line] ||= line))
+      type.instance_variable_set(:@encoding, pool[line] ||= line)
     end
   end
 
   def load_docs
-    each_file_line('docs') do |type, line|
+    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|
+    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|
+    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))
+    each_file_line("xrefs") { |type, line|
+      type.instance_variable_set(:@xrefs, dict(line, transform: :array))
     }
   end
 
   def load_friendly
-    each_file_line('friendly') { |type, line|
+    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|
+    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 == '-'
+  def dict(line, transform: nil)
+    if line == "-"
       {}
     else
-      line.split('|').each_with_object({}) { |l, h|
-        k, v = l.split('^')
+      line.split("|").each_with_object({}) { |l, h|
+        k, v = l.split("^")
         v = nil if v.empty?
-        h[k] = array ? Array(v) : v
+
+        if transform
+          send(:"dict_#{transform}", h, k, v)
+        else
+          h[k] = v
+        end
       }
     end
   end
 
+  def dict_extension_priority(h, k, v)
+    return if v.nil?
+
+    v = v.to_i if v.is_a?(String)
+    v = v.trunc if v.is_a?(Float)
+    v = [[-20, v].max, 20].min
+
+    return if v.zero?
+
+    h[k] = v
+  end
+
+  def dict_array(h, k, v)
+    h[k] = Array(v)
+  end
+
   def arr(line)
-    if line == '-'
+    if line == "-"
       []
     else
-      line.split('|').flatten.compact.uniq
+      line.split("|").flatten.compact.uniq
     end
   end
 
   def opt(line)
-    line unless line == '-'
+    line unless line == "-"
   end
 
   def flag(line)
-    line == '1'
+    line == "1"
   end
 end

data/lib/mime/types/cache.rb

@@ -15,21 +15,21 @@ class << MIME::Types::Cache
   # 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_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
-Could not load MIME::Types cache: invalid version
+      MIME::Types.logger.error <<-WARNING.chomp.strip
+        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}
+    MIME::Types.logger.error <<-WARNING.chomp.strip
+      Could not load MIME::Types cache: #{e}
     WARNING
     nil
   end
@@ -44,15 +44,11 @@ Could not load MIME::Types cache: #{e}
   # +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']
+    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
+    File.binwrite(cache_file, Marshal.dump(new(MIME::Types::Data::VERSION, Marshal.dump(types))))
   end
 end

data/lib/mime/types/columnar.rb

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

data/lib/mime/types/container.rb

@@ -1,17 +1,14 @@
 # frozen_string_literal: true
 
-require 'set'
-require 'forwardable'
+require "set"
 
 # 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
+# the Marshal format correctly, it will not 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
-
+# Marshal serialization (and does not survive the round-trip).
+class MIME::Types::Container # :nodoc:
   def initialize(hash = {})
     @container = {}
     merge!(hash)
@@ -37,7 +34,7 @@ class MIME::Types::Container #:nodoc:
 
   def merge!(other)
     tap {
-      other = other.kind_of?(MIME::Types::Container) ? other.container : other
+      other = other.is_a?(MIME::Types::Container) ? other.container : other
       container.merge!(other)
       normalize
     }
@@ -47,16 +44,49 @@ class MIME::Types::Container #:nodoc:
     container
   end
 
-  def_delegators :@container,
-                 :==,
-                 :count,
-                 :each,
-                 :each_value,
-                 :empty?,
-                 :flat_map,
-                 :keys,
-                 :select,
-                 :values
+  def ==(other)
+    container == other
+  end
+
+  def count(*args, &block)
+    if args.size == 0
+      container.count
+    elsif block
+      container.count(&block)
+    else
+      container.count(args.first)
+    end
+  end
+
+  def each_pair(&block)
+    container.each_pair(&block)
+  end
+
+  alias_method :each, :each_pair
+
+  def each_value(&block)
+    container.each_value(&block)
+  end
+
+  def empty?
+    container.empty?
+  end
+
+  def flat_map(&block)
+    container.flat_map(&block)
+  end
+
+  def keys
+    container.keys
+  end
+
+  def values
+    container.values
+  end
+
+  def select(&block)
+    container.select(&block)
+  end
 
   def add(key, value)
     (container[key] ||= Set.new).add(value)
@@ -85,7 +115,7 @@ class MIME::Types::Container #:nodoc:
 
   def normalize
     container.each do |k, v|
-      next if v.kind_of?(Set)
+      next if v.is_a?(Set)
 
       container[k] = Set[*v]
     end

data/lib/mime/types/deprecations.rb

@@ -1,32 +1,56 @@
 # 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
+require "mime/types/logger"
+
+class << MIME::Types
+  # Used to mark a method as deprecated in the mime-types interface.
+  def deprecated(options = {}, &block) # :nodoc:
+    message =
+      if options[:message]
+        options[:message]
+      else
+        klass = options.fetch(:class)
+
+        msep = case klass
+        when Class, Module
+          "."
+        else
+          klass = klass.class
+          "#"
+        end
+
+        method = "#{klass}#{msep}#{options.fetch(:method)}"
+        pre = " #{options[:pre]}" if options[:pre]
+        post = case options[:next]
+        when :private, :protected
+          " and will be made #{options[:next]}"
+        when :removed
+          " and will be removed"
+        when nil, ""
+          nil
+        else
+          " #{options[:next]}"
+        end
+
+        <<-WARNING.chomp.strip
+        #{caller(2..2).first}: #{klass}#{msep}#{method}#{pre} is deprecated#{post}.
+        WARNING
+      end
+
+    if !__deprecation_logged?(message, options[:once])
+      MIME::Types.logger.__send__(options[:level] || :debug, message)
     end
+
+    return unless block
+    block.call
+  end
+
+  private
+
+  def __deprecation_logged?(message, once)
+    return false unless once
+
+    @__deprecations_logged = {} unless defined?(@__deprecations_logged)
+    @__deprecations_logged.key?(message)
   end
 end

data/lib/mime/types/full.rb

@@ -9,11 +9,11 @@ module MIME
         private
 
         def load_mode
-          { columnar: false }
+          {columnar: false}
         end
       end
     end
   end
 end
 
-require 'mime/types'
+require "mime/types"

data/lib/mime/types/loader.rb

@@ -1,20 +1,19 @@
 # frozen_string_literal: true
 
-# -*- ruby encoding: utf-8 -*-
-
 ##
 module MIME; end
+
 ##
 class MIME::Types; end
 
-require 'mime/types/data'
+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
+# 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
@@ -30,7 +29,7 @@ class MIME::Types::Loader
   # 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
+    path = path || ENV["RUBY_MIME_TYPES_DATA"] || MIME::Types::Data::PATH
     @container = container || MIME::Types.new
     @path = File.expand_path(path)
   end
@@ -68,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)
 
@@ -80,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: true})
     if options[:columnar] && !Dir[columnar_path].empty?
       load_columnar
     else
@@ -90,7 +89,7 @@ class MIME::Types::Loader
 
   class << self
     # Loads the default MIME::Type registry.
-    def load(options = { columnar: false })
+    def load(options = {columnar: false})
       new.load(options)
     end
 
@@ -105,12 +104,18 @@ class MIME::Types::Loader
     # 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.
@@ -119,28 +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:-', &: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
 end

data/lib/mime/types/logger.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-# -*- ruby encoding: utf-8 -*-
-
-require 'logger'
+require "logger"
 
 ##
 module MIME
@@ -11,11 +9,22 @@ module MIME
     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
+      # :attr_accessor: logger
+      attr_reader :logger
+
+      ##
+      def logger=(logger) # :nodoc
+        @logger =
+          if logger.nil?
+            NullLogger.new
+          else
+            logger
+          end
+      end
     end
 
-    class WarnLogger < ::Logger #:nodoc:
-      class WarnLogDevice < ::Logger::LogDevice #:nodoc:
+    class WarnLogger < ::Logger # :nodoc:
+      class WarnLogDevice < ::Logger::LogDevice # :nodoc:
         def initialize(*)
         end
 
@@ -27,13 +36,33 @@ module MIME
         end
       end
 
-      def initialize(_one, _two = nil, _three = nil)
-        super nil
+      def initialize(*)
+        super(nil)
         @logdev = WarnLogDevice.new
         @formatter = ->(_s, _d, _p, m) { m }
       end
     end
 
-    self.logger = WarnLogger.new(nil)
+    class NullLogger < ::Logger
+      def initialize(*)
+        super(nil)
+        @logdev = nil
+      end
+
+      def reopen(_)
+        self
+      end
+
+      def <<(_)
+      end
+
+      def close
+      end
+
+      def add(_severity, _message = nil, _progname = nil)
+      end
+    end
+
+    self.logger = WarnLogger.new
   end
 end

data/lib/mime/types/registry.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "mime/types/deprecations"
+
 class << MIME::Types
   include Enumerable
 
@@ -33,7 +35,7 @@ class << MIME::Types
   def type_for(filename)
     __types__.type_for(filename)
   end
-  alias of type_for
+  alias_method :of, :type_for
 
   # MIME::Types#add against the default MIME::Types registry.
   def add(*types)
@@ -43,22 +45,22 @@ class << MIME::Types
   private
 
   def lazy_load?
-    return unless ENV.key?('RUBY_MIME_TYPES_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
+    deprecated(
+      message: "Lazy loading ($RUBY_MIME_TYPES_LAZY_LOAD) is deprecated and will be removed."
+    )
 
-    (lazy = ENV['RUBY_MIME_TYPES_LAZY_LOAD']) && (lazy != 'false')
+    ENV["RUBY_MIME_TYPES_LAZY_LOAD"] != "false"
   end
 
   def __types__
-    (defined?(@__types__) and @__types__) or load_default_mime_types
+    (defined?(@__types__) && @__types__) || load_default_mime_types
   end
 
   unless private_method_defined?(:load_mode)
     def load_mode
-      { columnar: true }
+      {columnar: true}
     end
   end