mime-types 3.5.1 → 3.7.0

data/lib/mime/types/deprecations.rb

@@ -2,35 +2,55 @@
 
 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
+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
-      message =
-        case message
+
+        method = "#{klass}#{msep}#{options.fetch(:method)}"
+        pre = " #{options[:pre]}" if options[:pre]
+        post = case options[:next]
         when :private, :protected
-          "and will be #{message}"
-        when nil
-          "and will be removed"
+          " and will be made #{options[:next]}"
+        when :removed
+          " and will be removed"
+        when nil, ""
+          nil
         else
-          message
+          " #{options[:next]}"
         end
-      MIME::Types.logger.debug <<-WARNING.chomp.strip
-        #{caller(2..2).first}: #{klass}#{level}#{sym} is deprecated #{message}.
-      WARNING
 
-      return unless block
-      block.call
+        <<-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/loader.rb

@@ -13,7 +13,7 @@ require "mime/types/data"
 #
 # 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
@@ -79,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

data/lib/mime/types/logger.rb

@@ -9,7 +9,18 @@ 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:
@@ -25,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
 
@@ -45,11 +47,11 @@ class << MIME::Types
   def lazy_load?
     return unless ENV.key?("RUBY_MIME_TYPES_LAZY_LOAD")
 
-    MIME::Types.logger.debug <<-WARNING.chomp.strip
-      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__

data/lib/mime/types/version.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+##
+module MIME
+  class Types
+    # The released version of the mime-types library.
+    VERSION = "3.7.0"
+  end
+
+  class Type
+    # The released version of the mime-types library.
+    VERSION = MIME::Types::VERSION
+  end
+end

data/lib/mime/types.rb

@@ -66,9 +66,6 @@ require "mime/type"
 #  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.
@@ -133,9 +130,7 @@ class MIME::Types
         @type_variants[MIME::Type.simplified(type_id)]
       end
 
-    prune_matches(matches, complete, registered).sort { |a, b|
-      a.priority_compare(b)
-    }
+    prune_matches(matches, complete, registered).sort
   end
 
   # Return the list of MIME::Types which belongs to the file based on its
@@ -151,10 +146,14 @@ class MIME::Types
   #   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[/\.?([^.]*?)\z/m, 1]]
-    }.compact.inject(Set.new, :+).sort { |a, b|
-      a.priority_compare(b)
+    wanted = Array(filename).map { |fn| fn.chomp.downcase[/\.?([^.]*?)\z/m, 1] }
+
+    wanted
+      .flat_map { |ext| @extension_index[ext] }
+      .compact
+      .reduce(Set.new, :+)
+      .sort { |a, b|
+      a.__extension_priority_compare(b, wanted)
     }
   end
   alias_method :of, :type_for
@@ -165,7 +164,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) || (types.last == true))
+    quiet = (types.last == :silent) || (types.last == true)
 
     types.each do |mime_type|
       case mime_type
@@ -196,6 +195,10 @@ class MIME::Types
     index_extensions!(type)
   end
 
+  def __fully_loaded? # :nodoc:
+    true
+  end
+
   private
 
   def add_type_variant!(mime_type)
@@ -223,6 +226,12 @@ class MIME::Types
       k =~ pattern
     }.values.inject(Set.new, :+)
   end
+
+  # def stable_sort(list)
+  #   list.lazy.each_with_index.sort { |(a, ai), (b, bi)|
+  #     a.priority_compare(b).nonzero? || ai <=> bi
+  #   }.map(&:first)
+  # end
 end
 
 require "mime/types/cache"
@@ -231,3 +240,4 @@ require "mime/types/loader"
 require "mime/types/logger"
 require "mime/types/_columnar"
 require "mime/types/registry"
+require "mime/types/version"

data/test/minitest_helper.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
-require "mime/type"
-require "fileutils"
-
 gem "minitest"
 require "minitest/focus"
-require "minitest-bonus-assertions"
 require "minitest/hooks"
 
+require "fileutils"
+
+require "mime/type"
 ENV["RUBY_MIME_TYPES_LAZY_LOAD"] = "yes"

data/test/test_mime_type.rb

@@ -9,13 +9,13 @@ describe MIME::Type do
   end
 
   let(:x_appl_x_zip) {
-    mime_type("x-appl/x-zip") { |t| t.extensions = %w[zip zp] }
+    mime_type("content-type" => "x-appl/x-zip") { |t| t.extensions = %w[zip zp] }
   }
-  let(:text_plain) { mime_type("text/plain") }
-  let(:text_html) { mime_type("text/html") }
-  let(:image_jpeg) { mime_type("image/jpeg") }
+  let(:text_plain) { mime_type("content-type" => "text/plain") }
+  let(:text_html) { mime_type("content-type" => "text/html") }
+  let(:image_jpeg) { mime_type("content-type" => "image/jpeg") }
   let(:application_javascript) {
-    mime_type("application/javascript") do |js|
+    mime_type("content-type" => "application/javascript") do |js|
       js.friendly("en" => "JavaScript")
       js.xrefs = {
         "rfc" => %w[rfc4239 rfc4239],
@@ -27,7 +27,7 @@ describe MIME::Type do
     end
   }
   let(:text_x_yaml) {
-    mime_type("text/x-yaml") do |yaml|
+    mime_type("content-type" => "text/x-yaml") do |yaml|
       yaml.extensions = %w[yaml yml]
       yaml.encoding = "8bit"
       yaml.friendly("en" => "YAML Structured Document")
@@ -88,20 +88,22 @@ describe MIME::Type do
   describe ".new" do
     it "fails if an invalid content type is provided" do
       exception = assert_raises MIME::Type::InvalidContentType do
-        MIME::Type.new("apps")
+        MIME::Type.new("content-type" => "apps")
       end
       assert_equal 'Invalid Content-Type "apps"', exception.to_s
     end
 
     it "creates a valid content type just from a string" do
-      type = MIME::Type.new("text/x-yaml")
+      assert_output "", /MIME::Type.new when called with a String is deprecated\./ do
+        type = MIME::Type.new("text/x-yaml")
 
-      assert_instance_of MIME::Type, type
-      assert_equal "text/x-yaml", type.content_type
+        assert_instance_of MIME::Type, type
+        assert_equal "text/x-yaml", type.content_type
+      end
     end
 
     it "yields the content type in a block" do
-      MIME::Type.new("text/x-yaml") do |type|
+      MIME::Type.new("content-type" => "text/x-yaml") do |type|
         assert_instance_of MIME::Type, type
         assert_equal "text/x-yaml", type.content_type
       end
@@ -118,10 +120,12 @@ describe MIME::Type do
     end
 
     it "creates a valid content type from an array" do
-      type = MIME::Type.new(%w[text/x-yaml yaml yml yz])
-      assert_instance_of MIME::Type, type
-      assert_equal "text/x-yaml", type.content_type
-      assert_equal %w[yaml yml yz], type.extensions
+      assert_output "", /MIME::Type.new when called with an Array is deprecated\./ do
+        type = MIME::Type.new(%w[text/x-yaml yaml yml yz])
+        assert_instance_of MIME::Type, type
+        assert_equal "text/x-yaml", type.content_type
+        assert_equal %w[yaml yml yz], type.extensions
+      end
     end
   end
 
@@ -143,7 +147,7 @@ describe MIME::Type do
     end
 
     it "correctly compares equivalent types" do
-      right = mime_type("text/Plain")
+      right = mime_type("content-type" => "text/Plain")
       refute_same text_plain, right
       assert_equal text_plain, right
     end
@@ -171,11 +175,6 @@ describe MIME::Type do
       refute_equal text_plain, "text/html"
       assert_operator text_plain, :>, "text/html"
     end
-
-    it "correctly compares against nil" do
-      refute_equal text_html, nil
-      assert_operator text_plain, :<, nil
-    end
   end
 
   describe "#ascii?" do
@@ -204,14 +203,14 @@ describe MIME::Type do
     end
 
     it "is false when there are no extensions" do
-      refute mime_type("text/plain").complete?
+      refute mime_type("content-type" => "text/plain").complete?
     end
   end
 
   describe "#content_type" do
     it "preserves the original case" do
       assert_equal "text/plain", text_plain.content_type
-      assert_equal "text/vCard", mime_type("text/vCard").content_type
+      assert_equal "text/vCard", mime_type("content-type" => "text/vCard").content_type
     end
 
     it "does not remove x- prefixes" do
@@ -266,27 +265,27 @@ describe MIME::Type do
     end
 
     it "is true for an equivalent MIME::Type" do
-      assert text_plain.eql?(mime_type("text/Plain"))
+      assert text_plain.eql?(mime_type("content-type" => "text/Plain"))
     end
 
     it "is true for an equivalent subclass of MIME::Type" do
       subclass = Class.new(MIME::Type)
-      assert text_plain.eql?(subclass.new("text/plain"))
+      assert text_plain.eql?(subclass.new("content-type" => "text/plain"))
     end
   end
 
   describe "#hash" do
     it "is the same between #eql? MIME::Type instances" do
-      assert_equal text_plain.hash, mime_type("text/plain").hash
+      assert_equal text_plain.hash, mime_type("content-type" => "text/plain").hash
     end
 
     it "is the same between #eql? MIME::Type instances of different classes" do
       subclass = Class.new(MIME::Type)
-      assert_equal text_plain.hash, subclass.new("text/plain").hash
+      assert_equal text_plain.hash, subclass.new("content-type" => "text/plain").hash
     end
 
     it "uses the #simplified value" do
-      assert_equal text_plain.hash, mime_type("text/Plain").hash
+      assert_equal text_plain.hash, mime_type("content-type" => "text/Plain").hash
     end
   end
 
@@ -322,41 +321,56 @@ describe MIME::Type do
   end
 
   describe "#priority_compare" do
+    def priority(type)
+      priority = "OpRceXtN"
+        .chars
+        .zip(("%08b" % type.__sort_priority).chars)
+        .map { |e| e.join(":") }
+        .join(" ")
+
+      "#{type} (#{priority} / #{type.__sort_priority})"
+    end
+
     def assert_priority_less(left, right)
-      assert_equal(-1, left.priority_compare(right))
+      assert_equal(-1, left.priority_compare(right), "#{priority(left)} is not less than #{priority(right)}")
     end
 
     def assert_priority_same(left, right)
-      assert_equal 0, left.priority_compare(right)
+      assert_equal 0, left.priority_compare(right), "#{priority(left)} is not equal to #{priority(right)}"
     end
 
     def assert_priority_more(left, right)
-      assert_equal 1, left.priority_compare(right)
+      assert_equal 1, left.priority_compare(right), "#{priority(left)} is not more than #{priority(right)}"
     end
 
     def assert_priority(left, middle, right)
       assert_priority_less left, right
       assert_priority_same left, middle
-      assert_priority_more right, left
+      assert_priority_more right, middle
     end
 
-    let(:text_1) { mime_type("text/1") }
-    let(:text_1p) { mime_type("text/1") }
-    let(:text_2) { mime_type("text/2") }
+    let(:text_1) { mime_type("content-type" => "text/1") }
+    let(:text_1p) { mime_type("content-type" => "text/1") }
+    let(:text_2) { mime_type("content-type" => "text/2") }
 
-    it "sorts (1) based on the simplified type" do
+    it "sorts based on the simplified type when the sort priorities are the same" do
       assert_priority text_1, text_1p, text_2
     end
 
-    it "sorts (2) based on extensions" do
-      text_1.extensions = ["foo", "bar"]
-      text_2.extensions = ["foo"]
+    it "sorts obsolete types higher than non-obsolete types" do
+      text_1.obsolete = text_1p.obsolete = false
+      text_1b = mime_type(text_1) { |t| t.obsolete = true }
 
-      assert_priority_same text_1, text_2
+      assert_priority_less text_1, text_1b
+
+      assert_priority text_1, text_1p, text_1b
+    end
 
-      text_2.registered = true
+    it "sorts provisional types higher than non-provisional types" do
+      text_1.provisional = text_1p.provisional = false
+      text_1b = mime_type(text_1) { |t| t.provisional = true }
 
-      assert_priority_more text_1, text_2
+      assert_priority text_1, text_1p, text_1b
     end
 
     it "sorts (3) based on the registration state" do
@@ -373,29 +387,17 @@ describe MIME::Type do
       assert_priority text_1, text_1p, text_1b
     end
 
-    it "sorts (5) based on obsolete status" do
-      text_1.obsolete = text_1p.obsolete = false
-      text_1b = mime_type(text_1) { |t| t.obsolete = true }
-
-      assert_priority text_1, text_1p, text_1b
-    end
-
-    it "sorts (5) based on the use-instead value" do
-      text_1.obsolete = text_1p.obsolete = true
-      text_1.use_instead = text_1p.use_instead = "abc/xyz"
-      text_1b = mime_type(text_1) { |t| t.use_instead = nil }
-
-      assert_priority text_1, text_1p, text_1b
-
-      text_1b.use_instead = "abc/zzz"
+    it "sorts based on extensions (more extensions sort lower)" do
+      text_1.extensions = ["foo", "bar"]
+      text_2.extensions = ["foo"]
 
-      assert_priority text_1, text_1p, text_1b
+      assert_priority_less text_1, text_2
     end
   end
 
   describe "#raw_media_type" do
     it "extracts the media type as case-preserved" do
-      assert_equal "Text", mime_type("Text/plain").raw_media_type
+      assert_equal "Text", mime_type("content-type" => "Text/plain").raw_media_type
     end
 
     it "does not remove x- prefixes" do
@@ -415,7 +417,7 @@ describe MIME::Type do
 
   describe "#raw_media_type" do
     it "extracts the media type as case-preserved" do
-      assert_equal "Text", mime_type("Text/plain").raw_media_type
+      assert_equal "Text", mime_type("content-type" => "Text/plain").raw_media_type
     end
 
     it "does not remove x- prefixes" do
@@ -435,7 +437,7 @@ describe MIME::Type do
 
   describe "#raw_sub_type" do
     it "extracts the sub type as case-preserved" do
-      assert_equal "Plain", mime_type("text/Plain").raw_sub_type
+      assert_equal "Plain", mime_type("content-type" => "text/Plain").raw_sub_type
     end
 
     it "does not remove x- prefixes" do
@@ -444,56 +446,72 @@ describe MIME::Type do
   end
 
   describe "#to_h" do
-    let(:t) { mime_type("a/b") }
+    let(:t) { mime_type("content-type" => "a/b") }
+
+    def assert_has_keys(wanted_keys, actual, msg = nil)
+      wanted_keys = Array(wanted_keys).uniq.sort
+      actual_keys = if actual.is_a?(Hash)
+        actual.keys
+      else
+        actual.to_h.keys
+      end
+
+      missing = wanted_keys - actual_keys
+      pretty_wanted_keys = (wanted_keys + actual_keys).uniq.sort
+
+      msg = message(msg) {
+        "#{mu_pp(actual)} is missing attribute values\n#{diff(pretty_wanted_keys, actual_keys)}"
+      }
+
+      assert missing.empty?, msg
+    end
 
     it "has the required keys (content-type, registered, encoding)" do
-      assert_has_keys t.to_h, %w[content-type registered encoding]
+      assert_has_keys %w[content-type registered encoding], t
     end
 
     it "has the docs key if there are documents" do
-      assert_has_keys mime_type(t) { |v| v.docs = "a" }.to_h, %w[docs]
+      assert_has_keys "docs", mime_type(t) { |v| v.docs = "a" }
     end
 
     it "has the extensions key if set" do
-      assert_has_keys mime_type(t) { |v| v.extensions = "a" }.to_h,
-        "extensions"
+      assert_has_keys "extensions", mime_type(t) { |v| v.extensions = "a" }
     end
 
     it "has the preferred-extension key if set" do
-      assert_has_keys mime_type(t) { |v| v.preferred_extension = "a" }.to_h,
-        "preferred-extension"
+      assert_has_keys "preferred-extension", mime_type(t) { |v| v.preferred_extension = "a" }
     end
 
     it "has the obsolete key if set" do
-      assert_has_keys mime_type(t) { |v| v.obsolete = true }.to_h, "obsolete"
+      assert_has_keys "obsolete", mime_type(t) { |v| v.obsolete = true }
     end
 
     it "has the obsolete and use-instead keys if set" do
-      assert_has_keys mime_type(t) { |v|
+      assert_has_keys %w[obsolete use-instead], mime_type(t) { |v|
         v.obsolete = true
         v.use_instead = "c/d"
-      }.to_h, %w[obsolete use-instead]
+      }
     end
 
     it "has the signature key if set" do
-      assert_has_keys mime_type(t) { |v| v.signature = true }.to_h, "signature"
+      assert_has_keys "signature", mime_type(t) { |v| v.signature = true }
     end
   end
 
   describe "#to_json" do
     let(:expected_1) {
-      '{"content-type":"a/b","encoding":"base64","registered":false}'
+      '{"content-type":"a/b","encoding":"base64","registered":false,"sort-priority":48}'
     }
     let(:expected_2) {
-      '{"content-type":"a/b","encoding":"base64","registered":true,"provisional":true}'
+      '{"content-type":"a/b","encoding":"base64","registered":true,"provisional":true,"sort-priority":80}'
     }
 
     it "converts to JSON when requested" do
-      assert_equal expected_1, mime_type("a/b").to_json
+      assert_equal expected_1, mime_type("content-type" => "a/b").to_json
     end
 
     it "converts to JSON with provisional when requested" do
-      type = mime_type("a/b") do |t|
+      type = mime_type("content-type" => "a/b") do |t|
         t.registered = true
         t.provisional = true
       end
@@ -543,7 +561,7 @@ describe MIME::Type do
     }
 
     let(:type) {
-      mime_type("a/b").tap do |t|
+      mime_type("content-type" => "a/b").tap do |t|
         t.xrefs = {
           "draft" => ["RFC1"],
           "template" => ["a/b"],