mime-types 3.6.0 → 3.7.0

data/lib/mime/type.rb

@@ -94,9 +94,6 @@ class MIME::Type
     # :startdoc:
   end
 
-  # The released version of the mime-types library.
-  VERSION = "3.6.0"
-
   include Comparable
 
   # :stopdoc:
@@ -136,7 +133,8 @@ class MIME::Type
   def initialize(content_type) # :yields: self
     @friendly = {}
     @obsolete = @registered = @provisional = false
-    @preferred_extension = @docs = @use_instead = nil
+    @preferred_extension = @docs = @use_instead = @__sort_priority = nil
+
     self.extensions = []
 
     case content_type
@@ -167,6 +165,8 @@ class MIME::Type
     self.xrefs ||= {}
 
     yield self if block_given?
+
+    update_sort_priority
   end
 
   # Indicates that a MIME type is like another type. This differs from
@@ -185,60 +185,54 @@ class MIME::Type
   # simplified type (the simplified type will be used if comparing against
   # something that can be treated as a String with #to_s). In comparisons, this
   # is done against the lowercase version of the MIME::Type.
+  #
+  # Note that this implementation of #<=> is deprecated and will be changed
+  # in the next major version to be the same as #priority_compare.
+  #
+  # Note that MIME::Types no longer compare against nil.
   def <=>(other)
-    if other.nil?
-      -1
-    elsif other.respond_to?(:simplified)
+    return priority_compare(other) if other.is_a?(MIME::Type)
+    simplified <=> other
+  end
+
+  # Compares the +other+ MIME::Type using a pre-computed sort priority value,
+  # then the simplified representation for an alphabetical sort.
+  #
+  # For the next major version of MIME::Types, this method will become #<=> and
+  # #priority_compare will be removed.
+  def priority_compare(other)
+    if (cmp = __sort_priority <=> other.__sort_priority) == 0
       simplified <=> other.simplified
     else
-      filtered = "silent" if other == :silent
-      filtered ||= "true" if other == true
-      filtered ||= other.to_s
-
-      simplified <=> MIME::Type.simplified(filtered)
+      cmp
     end
   end
 
-  # Compares the +other+ MIME::Type based on how reliable it is before doing a
-  # normal <=> comparison. Used by MIME::Types#[] to sort types. The
-  # comparisons involved are:
-  #
-  # 1. self.simplified <=> other.simplified (ensures that we
-  #    do not try to compare different types)
-  # 2. IANA-registered definitions < other definitions.
-  # 3. Complete definitions < incomplete definitions.
-  # 4. Current definitions < obsolete definitions.
-  # 5. Obselete with use-instead names < obsolete without.
-  # 6. Obsolete use-instead definitions are compared.
+  # Uses a modified pre-computed sort priority value based on whether one of the provided
+  # extensions is the preferred extension for a type.
   #
-  # While this method is public, its use is strongly discouraged by consumers
-  # of mime-types. In mime-types 3, this method is likely to see substantial
-  # revision and simplification to ensure current registered content types sort
-  # before unregistered or obsolete content types.
-  def priority_compare(other)
-    pc = simplified <=> other.simplified
-    if pc.zero? || !(extensions & other.extensions).empty?
-      pc =
-        if (reg = registered?) != other.registered?
-          reg ? -1 : 1 # registered < unregistered
-        elsif (comp = complete?) != other.complete?
-          comp ? -1 : 1 # complete < incomplete
-        elsif (obs = obsolete?) != other.obsolete?
-          obs ? 1 : -1 # current < obsolete
-        elsif obs && ((ui = use_instead) != (oui = other.use_instead))
-          if ui.nil?
-            1
-          elsif oui.nil?
-            -1
-          else
-            ui <=> oui
-          end
-        else
-          0
-        end
+  # This is an internal function. If an extension provided is a preferred extension either
+  # for this instance or the compared instance, the corresponding extension has its top
+  # _extension_ bit cleared from its sort priority. That means that a type with between
+  # 0 and 8 extensions will be treated as if it had 9 extensions.
+  def __extension_priority_compare(other, exts) # :nodoc:
+    tsp = __sort_priority
+
+    if exts.include?(preferred_extension) && tsp & 0b1000 != 0
+      tsp = tsp & 0b11110111 | 0b0111
+    end
+
+    osp = other.__sort_priority
+
+    if exts.include?(other.preferred_extension) && osp & 0b1000 != 0
+      osp = osp & 0b11110111 | 0b0111
     end
 
-    pc
+    if (cmp = tsp <=> osp) == 0
+      simplified <=> other.simplified
+    else
+      cmp
+    end
   end
 
   # Returns +true+ if the +other+ object is a MIME::Type and the content types
@@ -273,6 +267,13 @@ class MIME::Type
     simplified.hash
   end
 
+  # The computed sort priority value. This is _not_ intended to be used by most
+  # callers.
+  def __sort_priority # :nodoc:
+    update_sort_priority if !instance_variable_defined?(:@__sort_priority) || @__sort_priority.nil?
+    @__sort_priority
+  end
+
   # Returns the whole MIME content-type string.
   #
   # The content type is a presentation value from the MIME type registry and
@@ -327,6 +328,7 @@ class MIME::Type
 
   ##
   def extensions=(value) # :nodoc:
+    clear_sort_priority
     @extensions = Set[*Array(value).flatten.compact].freeze
     MIME::Types.send(:reindex_extensions, self)
   end
@@ -353,9 +355,7 @@ class MIME::Type
 
   ##
   def preferred_extension=(value) # :nodoc:
-    if value
-      add_extensions(value)
-    end
+    add_extensions(value) if value
     @preferred_extension = value
   end
 
@@ -408,9 +408,17 @@ class MIME::Type
   attr_writer :use_instead
 
   # Returns +true+ if the media type is obsolete.
-  attr_accessor :obsolete
+  #
+  # :attr_accessor: obsolete
+  attr_reader :obsolete
   alias_method :obsolete?, :obsolete
 
+  ##
+  def obsolete=(value)
+    clear_sort_priority
+    @obsolete = !!value
+  end
+
   # The documentation for this MIME::Type.
   attr_accessor :docs
 
@@ -468,11 +476,27 @@ class MIME::Type
   end
 
   # Indicates whether the MIME type has been registered with IANA.
-  attr_accessor :registered
+  #
+  # :attr_accessor: registered
+  attr_reader :registered
   alias_method :registered?, :registered
 
+  ##
+  def registered=(value)
+    clear_sort_priority
+    @registered = !!value
+  end
+
   # Indicates whether the MIME type's registration with IANA is provisional.
-  attr_accessor :provisional
+  #
+  # :attr_accessor: provisional
+  attr_reader :provisional
+
+  ##
+  def provisional=(value)
+    clear_sort_priority
+    @provisional = !!value
+  end
 
   # Indicates whether the MIME type's registration with IANA is provisional.
   def provisional?
@@ -555,6 +579,7 @@ class MIME::Type
     coder["registered"] = registered?
     coder["provisional"] = provisional? if provisional?
     coder["signature"] = signature? if signature?
+    coder["sort-priority"] = __sort_priority || 0b11111111
     coder
   end
 
@@ -563,6 +588,7 @@ class MIME::Type
   #
   # This method should be considered a private implementation detail.
   def init_with(coder)
+    @__sort_priority = 0
     self.content_type = coder["content-type"]
     self.docs = coder["docs"] || ""
     self.encoding = coder["encoding"]
@@ -576,6 +602,8 @@ class MIME::Type
     self.use_instead = coder["use-instead"]
 
     friendly(coder["friendly"] || {})
+
+    update_sort_priority
   end
 
   def inspect # :nodoc:
@@ -631,6 +659,37 @@ class MIME::Type
 
   private
 
+  def clear_sort_priority
+    @__sort_priority = nil
+  end
+
+  # Update the __sort_priority value. Lower numbers sort better, so the
+  # bitmapping may seem a little odd. The _best_ sort priority is 0.
+  #
+  # | bit | meaning         | details   |
+  # | --- | --------------- | --------- |
+  # | 7   | obsolete        | 1 if true |
+  # | 6   | provisional     | 1 if true |
+  # | 5   | registered      | 0 if true |
+  # | 4   | complete        | 0 if true |
+  # | 3   | # of extensions | see below |
+  # | 2   | # of extensions | see below |
+  # | 1   | # of extensions | see below |
+  # | 0   | # of extensions | see below |
+  #
+  # The # of extensions is marked as the number of extensions subtracted from
+  # 16, to a minimum of 0.
+  def update_sort_priority
+    extension_count = @extensions.length
+    obsolete = (instance_variable_defined?(:@obsolete) && @obsolete) ? 1 << 7 : 0
+    provisional = (instance_variable_defined?(:@provisional) && @provisional) ? 1 << 6 : 0
+    registered = (instance_variable_defined?(:@registered) && @registered) ? 0 : 1 << 5
+    complete = extension_count.nonzero? ? 0 : 1 << 4
+    extension_count = [0, 16 - extension_count].max
+
+    @__sort_priority = obsolete | registered | provisional | complete | extension_count
+  end
+
   def content_type=(type_string)
     match = MEDIA_TYPE_RE.match(type_string)
     fail InvalidContentType, type_string if match.nil?
@@ -683,3 +742,5 @@ class MIME::Type
     "http://www.iana.org/assignments/media-types/%s" % value
   end
 end
+
+require "mime/types/version"

data/lib/mime/types/_columnar.rb

@@ -18,6 +18,10 @@ 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:
     @__root__ = path
@@ -26,13 +30,16 @@ module MIME::Types::Columnar
       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
 
@@ -60,10 +67,29 @@ 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|
       pool ||= {}
-      type.instance_variable_set(:@encoding, (pool[line] ||= line))
+      type.instance_variable_set(:@encoding, pool[line] ||= line)
     end
   end
 
@@ -91,7 +117,7 @@ module MIME::Types::Columnar
 
   def load_xrefs
     each_file_line("xrefs") { |type, line|
-      type.instance_variable_set(:@xrefs, dict(line, array: true))
+      type.instance_variable_set(:@xrefs, dict(line, transform: :array))
     }
   end
 
@@ -107,18 +133,39 @@ module MIME::Types::Columnar
     end
   end
 
-  def dict(line, array: false)
+  def dict(line, transform: nil)
     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
+
+        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 == "-"
       []

data/lib/mime/types/container.rb

@@ -1,7 +1,6 @@
 # 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
@@ -10,8 +9,6 @@ require "forwardable"
 # Hash#default_proc cannot be used without a wrapper because it prevents
 # Marshal serialization (and does not survive the round-trip).
 class MIME::Types::Container # :nodoc:
-  extend Forwardable
-
   def initialize(hash = {})
     @container = {}
     merge!(hash)
@@ -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)

data/lib/mime/types/loader.rb

@@ -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)
+      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/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
@@ -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,10 +1,10 @@
 # frozen_string_literal: true
 
-require "mime/type"
-require "fileutils"
-
 gem "minitest"
 require "minitest/focus"
 require "minitest/hooks"
 
+require "fileutils"
+
+require "mime/type"
 ENV["RUBY_MIME_TYPES_LAZY_LOAD"] = "yes"