mime-types 2.99.3 → 3.4.1

data/lib/mime/type.rb

@@ -1,29 +1,69 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
+
+##
+module MIME
+end
 
 # The definition of one MIME content-type.
 #
 # == Usage
 #  require 'mime/types'
 #
-#  plaintext = MIME::Types['text/plain'].first
-#  # returns [text/plain, text/plain]
+#  plaintext = MIME::Types['text/plain'] # => [ text/plain ]
 #  text = plaintext.first
-#  print text.media_type           # => 'text'
-#  print text.sub_type             # => 'plain'
+#  puts text.media_type            # => 'text'
+#  puts text.sub_type              # => 'plain'
 #
-#  puts text.extensions.join(" ")  # => 'asc txt c cc h hh cpp'
+#  puts text.extensions.join(' ')  # => 'txt asc c cc h hh cpp hpp dat hlp'
+#  puts text.preferred_extension   # => 'txt'
+#  puts text.friendly              # => 'Text Document'
+#  puts text.i18n_key              # => 'text.plain'
 #
-#  puts text.encoding              # => 8bit
+#  puts text.encoding              # => quoted-printable
+#  puts text.default_encoding      # => quoted-printable
 #  puts text.binary?               # => false
 #  puts text.ascii?                # => true
+#  puts text.obsolete?             # => false
+#  puts text.registered?           # => true
+#  puts text.provisional?          # => false
+#  puts text.complete?             # => true
+#
+#  puts text                       # => 'text/plain'
+#
 #  puts text == 'text/plain'       # => true
-#  puts MIME::Type.simplified('x-appl/x-zip') # => 'appl/zip'
+#  puts 'text/plain' == text       # => true
+#  puts text == 'text/x-plain'     # => false
+#  puts 'text/x-plain' == text     # => false
+#
+#  puts MIME::Type.simplified('x-appl/x-zip') # => 'x-appl/x-zip'
+#  puts MIME::Type.i18n_key('x-appl/x-zip') # => 'x-appl.x-zip'
+#
+#  puts text.like?('text/x-plain') # => true
+#  puts text.like?(MIME::Type.new('x-text/x-plain')) # => true
+#
+#  puts text.xrefs.inspect # => { "rfc" => [ "rfc2046", "rfc3676", "rfc5147" ] }
+#  puts text.xref_urls # => [ "http://www.iana.org/go/rfc2046",
+#                      #      "http://www.iana.org/go/rfc3676",
+#                      #      "http://www.iana.org/go/rfc5147" ]
+#
+#  xtext = MIME::Type.new('x-text/x-plain')
+#  puts xtext.media_type # => 'text'
+#  puts xtext.raw_media_type # => 'x-text'
+#  puts xtext.sub_type # => 'plain'
+#  puts xtext.raw_sub_type # => 'x-plain'
+#  puts xtext.complete? # => false
+#
+#  puts MIME::Types.any? { |type| type.content_type == 'text/plain' } # => true
+#  puts MIME::Types.all?(&:registered?) # => false
+#
+#  # Various string representations of MIME types
+#  qcelp = MIME::Types['audio/QCELP'].first # => audio/QCELP
+#  puts qcelp.content_type         # => 'audio/QCELP'
+#  puts qcelp.simplified           # => 'audio/qcelp'
 #
-#  puts MIME::Types.any? { |type|
-#    type.content_type == 'text/plain'
-#  }                               # => true
-#  puts MIME::Types.all?(&:registered?)
-#                                  # => false
+#  xwingz = MIME::Types['application/x-Wingz'].first # => application/x-Wingz
+#  puts xwingz.content_type        # => 'application/x-Wingz'
+#  puts xwingz.simplified          # => 'application/x-wingz'
 class MIME::Type
   # Reflects a MIME content-type specification that is not correctly
   # formatted (it isn't +type+/+subtype+).
@@ -53,81 +93,69 @@ class MIME::Type
   end
 
   # The released version of the mime-types library.
-  VERSION = '2.99.3'
+  VERSION = "3.4.1"
 
   include Comparable
 
   # :stopdoc:
-  MEDIA_TYPE_RE     = %r{([-\w.+]+)/([-\w.+]*)}o
-  UNREGISTERED_RE   = %r{[Xx]-}o
-  I18N_RE           = %r{[^[:alnum:]]}o
-  PLATFORM_RE       = %r{#{RUBY_PLATFORM}}o
-
-  DEFAULT_ENCODINGS = [ nil, :default ]
-  BINARY_ENCODINGS  = %w(base64 8bit)
-  TEXT_ENCODINGS    = %w(7bit quoted-printable)
-  VALID_ENCODINGS   = DEFAULT_ENCODINGS + BINARY_ENCODINGS + TEXT_ENCODINGS
-
-  IANA_URL          = 'http://www.iana.org/assignments/media-types/%s/%s'
-  RFC_URL           = 'http://rfc-editor.org/rfc/rfc%s.txt'
-  DRAFT_URL         = 'http://datatracker.ietf.org/public/idindex.cgi?command=id_details&filename=%s' # rubocop:disable Metrics/LineLength
-  CONTACT_URL       = 'http://www.iana.org/assignments/contact-people.htm#%s'
+  # TODO verify mime-type character restrictions; I am pretty sure that this is
+  # too wide open.
+  MEDIA_TYPE_RE = %r{([-\w.+]+)/([-\w.+]*)}.freeze
+  I18N_RE = /[^[:alnum:]]/.freeze
+  BINARY_ENCODINGS = %w[base64 8bit].freeze
+  ASCII_ENCODINGS = %w[7bit quoted-printable].freeze
   # :startdoc:
 
-  if respond_to? :private_constant
-    private_constant :MEDIA_TYPE_RE, :UNREGISTERED_RE, :I18N_RE, :PLATFORM_RE,
-                     :DEFAULT_ENCODINGS, :BINARY_ENCODINGS, :TEXT_ENCODINGS,
-                     :VALID_ENCODINGS, :IANA_URL, :RFC_URL, :DRAFT_URL,
-                     :CONTACT_URL
-  end
+  private_constant :MEDIA_TYPE_RE, :I18N_RE, :BINARY_ENCODINGS,
+    :ASCII_ENCODINGS
 
   # Builds a MIME::Type object from the +content_type+, a MIME Content Type
-  # value (e.g., 'text/plain' or 'applicaton/x-eruby'). The constructed object
+  # value (e.g., 'text/plain' or 'application/x-eruby'). The constructed object
   # is yielded to an optional block for additional configuration, such as
   # associating extensions and encoding information.
   #
   # * When provided a Hash or a MIME::Type, the MIME::Type will be
   #   constructed with #init_with.
-  # * When provided an Array, the MIME::Type will be constructed only using
-  #   the first two elements of the array as the content type and
-  #   extensions.
+  # * When provided an Array, the MIME::Type will be constructed using
+  #   the first element as the content type and the remaining flattened
+  #   elements as extensions.
   # * Otherwise, the content_type will be used as a string.
   #
   # Yields the newly constructed +self+ object.
-  def initialize(content_type) # :yields self:
+  def initialize(content_type) # :yields: self
     @friendly = {}
-    self.obsolete = false
-    self.registered = nil
-    self.use_instead = nil
-    self.signature = nil
+    @obsolete = @registered = @provisional = false
+    @preferred_extension = @docs = @use_instead = nil
+    self.extensions = []
 
     case content_type
     when Hash
       init_with(content_type)
     when Array
-      self.content_type = content_type[0]
-      self.extensions = content_type[1] || []
+      self.content_type = content_type.shift
+      self.extensions = content_type.flatten
     when MIME::Type
       init_with(content_type.to_h)
     else
       self.content_type = content_type
     end
 
-    self.extensions ||= []
-    self.docs ||= []
     self.encoding ||= :default
     self.xrefs ||= {}
 
     yield self if block_given?
   end
 
-  # Returns +true+ if the +other+ simplified type matches the current type.
+  # Indicates that a MIME type is like another type. This differs from
+  # <tt>==</tt> because <tt>x-</tt> prefixes are removed for this comparison.
   def like?(other)
-    if other.respond_to?(:simplified)
-      @simplified == other.simplified
-    else
-      @simplified == MIME::Type.simplified(other)
-    end
+    other =
+      if other.respond_to?(:simplified)
+        MIME::Type.simplified(other.simplified, remove_x_prefix: true)
+      else
+        MIME::Type.simplified(other.to_s, remove_x_prefix: true)
+      end
+    MIME::Type.simplified(simplified, remove_x_prefix: true) == other
   end
 
   # Compares the +other+ MIME::Type against the exact content type or the
@@ -135,10 +163,16 @@ class MIME::Type
   # something that can be treated as a String with #to_s). In comparisons, this
   # is done against the lowercase version of the MIME::Type.
   def <=>(other)
-    if other.respond_to?(:content_type)
-      @content_type.downcase <=> other.content_type.downcase
-    elsif other.respond_to?(:to_s)
-      @simplified <=> MIME::Type.simplified(other.to_s)
+    if other.nil?
+      -1
+    elsif other.respond_to?(:simplified)
+      simplified <=> other.simplified
+    else
+      filtered = "silent" if other == :silent
+      filtered ||= "true" if other == true
+      filtered ||= other.to_s
+
+      simplified <=> MIME::Type.simplified(filtered)
     end
   end
 
@@ -160,24 +194,25 @@ class MIME::Type
   # before unregistered or obsolete content types.
   def priority_compare(other)
     pc = simplified <=> other.simplified
-    if pc.zero?
-      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 and ((ui = use_instead) != (oui = other.use_instead))
-             if ui.nil?
-               1
-             elsif oui.nil?
-               -1
-             else
-               ui <=> oui
-             end
-           else
-             0
-           end
+    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
     end
 
     pc
@@ -186,7 +221,7 @@ class MIME::Type
   # Returns +true+ if the +other+ object is a MIME::Type and the content types
   # match.
   def eql?(other)
-    other.kind_of?(MIME::Type) and self == other
+    other.is_a?(MIME::Type) && (self == other)
   end
 
   # Returns the whole MIME content-type string.
@@ -200,58 +235,77 @@ class MIME::Type
   #   audio/QCELP       => audio/QCELP
   attr_reader :content_type
   # A simplified form of the MIME content-type string, suitable for
-  # case-insensitive comparison, with any extension markers (<tt>x-</tt)
-  # removed and converted to lowercase.
+  # case-insensitive comparison, with the content_type converted to lowercase.
   #
   #   text/plain        => text/plain
-  #   x-chemical/x-pdb  => chemical/pdb
+  #   x-chemical/x-pdb  => x-chemical/x-pdb
   #   audio/QCELP       => audio/qcelp
   attr_reader :simplified
   # Returns the media type of the simplified MIME::Type.
   #
   #   text/plain        => text
-  #   x-chemical/x-pdb  => chemical
+  #   x-chemical/x-pdb  => x-chemical
+  #   audio/QCELP       => audio
   attr_reader :media_type
   # Returns the media type of the unmodified MIME::Type.
   #
   #   text/plain        => text
   #   x-chemical/x-pdb  => x-chemical
+  #   audio/QCELP       => audio
   attr_reader :raw_media_type
   # Returns the sub-type of the simplified MIME::Type.
   #
   #   text/plain        => plain
   #   x-chemical/x-pdb  => pdb
+  #   audio/QCELP       => QCELP
   attr_reader :sub_type
   # Returns the media type of the unmodified MIME::Type.
   #
   #   text/plain        => plain
   #   x-chemical/x-pdb  => x-pdb
+  #   audio/QCELP       => qcelp
   attr_reader :raw_sub_type
 
+  ##
   # The list of extensions which are known to be used for this MIME::Type.
   # Non-array values will be coerced into an array with #to_a. Array values
   # will be flattened, +nil+ values removed, and made unique.
-  attr_reader :extensions
-  def extensions=(ext) # :nodoc:
-    @extensions = Array(ext).flatten.compact.uniq
-    # TODO: In mime-types 3.x, we probably want to have a clue about the
-    # container(s) we belong to so we can trigger reindexing when this is done.
+  #
+  # :attr_accessor: extensions
+  def extensions
+    @extensions.to_a
+  end
+
+  ##
+  def extensions=(value) # :nodoc:
+    @extensions = Set[*Array(value).flatten.compact].freeze
+    MIME::Types.send(:reindex_extensions, self)
   end
 
   # Merge the +extensions+ provided into this MIME::Type. The extensions added
   # will be merged uniquely.
   def add_extensions(*extensions)
-    self.extensions = self.extensions + extensions
+    self.extensions += extensions
   end
 
   ##
-  # The preferred extension for this MIME type, if one is set.
+  # The preferred extension for this MIME type. If one is not set and there are
+  # exceptions defined, the first extension will be used.
+  #
+  # When setting #preferred_extensions, if #extensions does not contain this
+  # extension, this will be added to #xtensions.
   #
-  # :attr_reader: preferred_extension
+  # :attr_accessor: preferred_extension
 
   ##
   def preferred_extension
-    extensions.first
+    @preferred_extension || extensions.first
+  end
+
+  ##
+  def preferred_extension=(value) # :nodoc:
+    add_extensions(value) if value
+    @preferred_extension = value
   end
 
   ##
@@ -270,60 +324,41 @@ class MIME::Type
 
   ##
   attr_reader :encoding
+
+  ##
   def encoding=(enc) # :nodoc:
-    if DEFAULT_ENCODINGS.include?(enc)
+    if enc.nil? || (enc == :default)
       @encoding = default_encoding
-    elsif BINARY_ENCODINGS.include?(enc) or TEXT_ENCODINGS.include?(enc)
+    elsif BINARY_ENCODINGS.include?(enc) || ASCII_ENCODINGS.include?(enc)
       @encoding = enc
     else
       fail InvalidEncoding, enc
     end
   end
 
-  # Returns +nil+ and assignments are ignored. Prior to mime-types 2.99, this
-  # would return the regular expression for the operating system indicated if
-  # the MIME::Type is a system-specific MIME::Type,
-  #
-  # This information about MIME content types is deprecated and will be removed
-  # in mime-types 3.
-  def system
-    MIME::Types.deprecated(self, __method__)
-    nil
-  end
-
-  def system=(_os) # :nodoc:
-    MIME::Types.deprecated(self, __method__)
-  end
-
   # Returns the default encoding for the MIME::Type based on the media type.
   def default_encoding
-    (@media_type == 'text') ? 'quoted-printable' : 'base64'
+    @media_type == "text" ? "quoted-printable" : "base64"
   end
 
   ##
-  # Returns the media type or types that should be used instead of this
-  # media type, if it is obsolete. If there is no replacement media type, or
-  # it is not obsolete, +nil+ will be returned.
+  # Returns the media type or types that should be used instead of this media
+  # type, if it is obsolete. If there is no replacement media type, or it is
+  # not obsolete, +nil+ will be returned.
   #
   # :attr_accessor: use_instead
 
   ##
   def use_instead
-    return nil unless obsolete?
-    @use_instead
+    obsolete? ? @use_instead : nil
   end
 
   ##
   attr_writer :use_instead
 
   # Returns +true+ if the media type is obsolete.
-  def obsolete?
-    !!@obsolete
-  end
-
-  def obsolete=(v) # :nodoc:
-    @obsolete = !!v
-  end
+  attr_accessor :obsolete
+  alias_method :obsolete?, :obsolete
 
   # The documentation for this MIME::Type.
   attr_accessor :docs
@@ -333,18 +368,19 @@ class MIME::Type
   # call-seq:
   #   text_plain.friendly         # => "Text File"
   #   text_plain.friendly('en')   # => "Text File"
-  def friendly(lang = 'en'.freeze)
+  def friendly(lang = "en")
     @friendly ||= {}
 
     case lang
-    when String
-      @friendly[lang]
+    when String, Symbol
+      @friendly[lang.to_s]
     when Array
-      @friendly.merge!(Hash[*lang])
+      @friendly.update(Hash[*lang])
     when Hash
-      @friendly.merge!(lang)
+      @friendly.update(lang)
     else
-      fail ArgumentError
+      fail ArgumentError,
+        "Expected a language or translation set, not #{lang.inspect}"
     end
   end
 
@@ -359,50 +395,6 @@ class MIME::Type
   #      # from application/x-msword
   attr_reader :i18n_key
 
-  ##
-  # Returns an empty array and warns that this method has been deprecated.
-  # Assignments are ignored. Prior to mime-types 2.99, this was the encoded
-  # references URL list for this MIME::Type.
-  #
-  # This was previously called #url.
-  #
-  # #references has been deprecated and both versions (#references and #url)
-  # will be removed in mime-types 3.
-  #
-  # :attr_accessor: references
-
-  ##
-  def references(*)
-    MIME::Types.deprecated(self, __method__)
-    []
-  end
-
-  ##
-  def references=(_r) # :nodoc:
-    MIME::Types.deprecated(self, __method__)
-  end
-
-  ##
-  # Returns an empty array and warns that this method has been deprecated.
-  # Assignments are ignored. Prior to mime-types 2.99, this was the encoded
-  # references URL list for this MIME::Type. See #urls for more information.
-  #
-  # #url has been deprecated and both versions (#references and #url) will be
-  # removed in mime-types 3.
-  #
-  # :attr_accessor: url
-
-  ##
-  def url
-    MIME::Types.deprecated(self, __method__)
-    []
-  end
-
-  ##
-  def url=(_r) # :nodoc:
-    MIME::Types.deprecated(self, __method__)
-  end
-
   ##
   # The cross-references list for this MIME::Type.
   #
@@ -412,134 +404,47 @@ class MIME::Type
   attr_reader :xrefs
 
   ##
-  def xrefs=(x) # :nodoc:
-    @xrefs = MIME::Types::Container.new.merge(x)
-    @xrefs.each_value(&:sort!)
-    @xrefs.each_value(&:uniq!)
-  end
-
-  # Returns an empty array. Prior to mime-types 2.99, this returned the decoded
-  # URL list for this MIME::Type.
-  #
-  # The special URL value IANA was translated into:
-  #   http://www.iana.org/assignments/media-types/<mediatype>/<subtype>
-  #
-  # The special URL value RFC### was translated into:
-  #   http://www.rfc-editor.org/rfc/rfc###.txt
-  #
-  # The special URL value DRAFT:name was translated into:
-  #   https://datatracker.ietf.org/public/idindex.cgi?
-  #       command=id_detail&filename=<name>
-  #
-  # The special URL value [token] was translated into:
-  #   http://www.iana.org/assignments/contact-people.htm#<token>
-  #
-  # These values were accessible through #urls, which always returns an array.
-  #
-  # This method is deprecated and will be removed in mime-types 3.
-  def urls
-    MIME::Types.deprecated(self, __method__)
-    []
+  def xrefs=(xrefs) # :nodoc:
+    @xrefs = MIME::Types::Container.new(xrefs)
   end
 
   # The decoded cross-reference URL list for this MIME::Type.
   def xref_urls
-    xrefs.flat_map { |(type, values)|
-      case type
-      when 'rfc'.freeze
-        values.map { |data| 'http://www.iana.org/go/%s'.freeze % data }
-      when 'draft'.freeze
-        values.map { |data|
-          'http://www.iana.org/go/%s'.freeze % data.sub(/\ARFC/, 'draft')
-        }
-      when 'rfc-errata'.freeze
-        values.map { |data|
-          'http://www.rfc-editor.org/errata_search.php?eid=%s'.freeze % data
-        }
-      when 'person'.freeze
-        values.map { |data|
-          'http://www.iana.org/assignments/media-types/media-types.xhtml#%s'.freeze % data # rubocop:disable Metrics/LineLength
-        }
-      when 'template'.freeze
-        values.map { |data|
-          'http://www.iana.org/assignments/media-types/%s'.freeze % data
-        }
-      else # 'uri', 'text', etc.
-        values
-      end
+    xrefs.flat_map { |type, values|
+      name = :"xref_url_for_#{type.tr("-", "_")}"
+      respond_to?(name, true) && xref_map(values, name) || values.to_a
     }
   end
 
-  ##
-  # Prior to BCP 178 (RFC 6648), it could be assumed that MIME content types
-  # that start with <tt>x-</tt> were unregistered MIME. Per this BCP, this
-  # assumption is no longer being made by default in this library.
-  #
-  # There are three possible registration states for a MIME::Type:
-  # - Explicitly registered, like application/x-www-url-encoded.
-  # - Explicitly not registered, like image/webp.
-  # - Unspecified, in which case the media-type and the content-type will be
-  #   scanned to see if they start with <tt>x-</tt>, indicating that they
-  #   are assumed unregistered.
-  #
-  # In mime-types 3, only a MIME content type that is explicitly registered
-  # will be used; there will be assumption that <tt>x-</tt> types are
-  # unregistered.
-  def registered?
-    if @registered.nil?
-      (@raw_media_type !~ UNREGISTERED_RE) and
-        (@raw_sub_type !~ UNREGISTERED_RE)
-    else
-      !!@registered
-    end
-  end
+  # Indicates whether the MIME type has been registered with IANA.
+  attr_accessor :registered
+  alias_method :registered?, :registered
 
-  def registered=(v) # :nodoc:
-    @registered = v.nil? ? v : !!v
+  # Indicates whether the MIME type's registration with IANA is provisional.
+  attr_accessor :provisional
+
+  # Indicates whether the MIME type's registration with IANA is provisional.
+  def provisional?
+    registered? && @provisional
   end
 
   # MIME types can be specified to be sent across a network in particular
   # formats. This method returns +true+ when the MIME::Type encoding is set
   # to <tt>base64</tt>.
   def binary?
-    BINARY_ENCODINGS.include?(@encoding)
+    BINARY_ENCODINGS.include?(encoding)
   end
 
   # MIME types can be specified to be sent across a network in particular
   # formats. This method returns +false+ when the MIME::Type encoding is
   # set to <tt>base64</tt>.
   def ascii?
-    !binary?
+    ASCII_ENCODINGS.include?(encoding)
   end
 
-  # Returns +true+ when the simplified MIME::Type is one of the known digital
-  # signature types.
-  def signature?
-    !!@signature
-  end
-
-  def signature=(v) # :nodoc:
-    @signature = !!v
-  end
-
-  # Returns +false+. Prior to mime-types 2.99, would return +true+ if the
-  # MIME::Type is specific to an operating system.
-  #
-  # This method is deprecated and will be removed in mime-types 3.
-  def system?(*)
-    MIME::Types.deprecated(self, __method__)
-    false
-  end
-
-  # Returns +false+. Prior to mime-types 2.99, would return +true+ if the
-  # MIME::Type is specific to the current operating system as represented by
-  # RUBY_PLATFORM.
-  #
-  # This method is deprecated and will be removed in mime-types 3.
-  def platform?(*)
-    MIME::Types.deprecated(self, __method__)
-    false
-  end
+  # Indicateswhether the MIME type is declared as a signature type.
+  attr_accessor :signature
+  alias_method :signature?, :signature
 
   # Returns +true+ if the MIME::Type specifies an extension list,
   # indicating that it is a complete MIME::Type.
@@ -560,41 +465,14 @@ class MIME::Type
     content_type
   end
 
-  # Returns the MIME::Type as an array suitable for use with
-  # MIME::Type.from_array.
-  #
-  # This method is deprecated and will be removed in mime-types 3.
-  def to_a
-    MIME::Types.deprecated(self, __method__)
-    [ @content_type, @extensions, @encoding, nil, obsolete?, @docs, [],
-      registered? ]
-  end
-
-  # Returns the MIME::Type as an array suitable for use with
-  # MIME::Type.from_hash.
-  #
-  # This method is deprecated and will be removed in mime-types 3.
-  def to_hash
-    MIME::Types.deprecated(self, __method__)
-    { 'Content-Type'              => @content_type,
-      'Content-Transfer-Encoding' => @encoding,
-      'Extensions'                => @extensions,
-      'System'                    => nil,
-      'Obsolete'                  => obsolete?,
-      'Docs'                      => @docs,
-      'URL'                       => [],
-      'Registered'                => registered?,
-    }
-  end
-
   # Converts the MIME::Type to a JSON string.
   def to_json(*args)
-    require 'json'
+    require "json"
     to_h.to_json(*args)
   end
 
-  # Converts the MIME::Type to a hash suitable for use in JSON. The output
-  # of this method can also be used to initialize a MIME::Type.
+  # Converts the MIME::Type to a hash. The output of this method can also be
+  # used to initialize a MIME::Type.
   def to_h
     encode_with({})
   end
@@ -605,18 +483,27 @@ class MIME::Type
   #
   # This method should be considered a private implementation detail.
   def encode_with(coder)
-    coder['content-type']   = @content_type
-    coder['docs']           = @docs unless @docs.nil? or @docs.empty?
-    coder['friendly']       = @friendly unless @friendly.empty?
-    coder['encoding']       = @encoding
-    coder['extensions']     = @extensions unless @extensions.empty?
+    coder["content-type"] = @content_type
+    coder["docs"] = @docs unless @docs.nil? || @docs.empty?
+    coder["friendly"] = @friendly unless @friendly.nil? || @friendly.empty?
+    coder["encoding"] = @encoding
+    coder["extensions"] = @extensions.to_a unless @extensions.empty?
+    coder["preferred-extension"] = @preferred_extension if @preferred_extension
     if obsolete?
-      coder['obsolete']     = obsolete?
-      coder['use-instead']  = use_instead if use_instead
+      coder["obsolete"] = obsolete?
+      coder["use-instead"] = use_instead if use_instead
     end
-    coder['xrefs']          = xrefs unless xrefs.empty?
-    coder['registered']     = registered?
-    coder['signature']      = signature? if signature?
+    unless xrefs.empty?
+      {}.tap do |hash|
+        xrefs.each do |k, v|
+          hash[k] = v.to_a.sort
+        end
+        coder["xrefs"] = hash
+      end
+    end
+    coder["registered"] = registered?
+    coder["provisional"] = provisional? if provisional?
+    coder["signature"] = signature? if signature?
     coder
   end
 
@@ -625,174 +512,123 @@ class MIME::Type
   #
   # This method should be considered a private implementation detail.
   def init_with(coder)
-    self.content_type = coder['content-type']
-    self.docs         = coder['docs'] || []
-    friendly(coder['friendly'] || {})
-    self.encoding     = coder['encoding']
-    self.extensions   = coder['extensions'] || []
-    self.obsolete     = coder['obsolete']
-    self.registered   = coder['registered']
-    self.signature    = coder['signature']
-    self.xrefs        = coder['xrefs'] || {}
-    self.use_instead  = coder['use-instead']
+    self.content_type = coder["content-type"]
+    self.docs = coder["docs"] || ""
+    self.encoding = coder["encoding"]
+    self.extensions = coder["extensions"] || []
+    self.preferred_extension = coder["preferred-extension"]
+    self.obsolete = coder["obsolete"] || false
+    self.registered = coder["registered"] || false
+    self.provisional = coder["provisional"] || false
+    self.signature = coder["signature"]
+    self.xrefs = coder["xrefs"] || {}
+    self.use_instead = coder["use-instead"]
+
+    friendly(coder["friendly"] || {})
   end
 
-  class << self
-    # The MIME types main- and sub-label can both start with <tt>x-</tt>,
-    # which indicates that it is a non-registered name. Of course, after
-    # registration this flag may disappear, adds to the confusing
-    # proliferation of MIME types. The simplified +content_type+ string has the
-    # <tt>x-</tt> removed and is translated to lowercase.
-    def simplified(content_type)
-      matchdata = case content_type
-                  when MatchData
-                    content_type
-                  else
-                    MEDIA_TYPE_RE.match(content_type)
-                  end
-
-      return unless matchdata
+  def inspect # :nodoc:
+    # We are intentionally lying here because MIME::Type::Columnar is an
+    # implementation detail.
+    "#<MIME::Type: #{self}>"
+  end
 
-      matchdata.captures.map { |e|
-        e.downcase!
-        e.gsub!(UNREGISTERED_RE, ''.freeze)
-        e
-      }.join('/'.freeze)
+  class << self
+    # MIME media types are case-insensitive, but are typically presented in a
+    # case-preserving format in the type registry. This method converts
+    # +content_type+ to lowercase.
+    #
+    # In previous versions of mime-types, this would also remove any extension
+    # prefix (<tt>x-</tt>). This is no longer default behaviour, but may be
+    # provided by providing a truth value to +remove_x_prefix+.
+    def simplified(content_type, remove_x_prefix: false)
+      simplify_matchdata(match(content_type), remove_x_prefix)
     end
 
     # Converts a provided +content_type+ into a translation key suitable for
     # use with the I18n library.
     def i18n_key(content_type)
-      matchdata = case content_type
-                  when MatchData
-                    content_type
-                  else
-                    MEDIA_TYPE_RE.match(content_type)
-                  end
+      simplify_matchdata(match(content_type), joiner: ".") { |e|
+        e.gsub!(I18N_RE, "-")
+      }
+    end
+
+    # Return a +MatchData+ object of the +content_type+ against pattern of
+    # media types.
+    def match(content_type)
+      case content_type
+      when MatchData
+        content_type
+      else
+        MEDIA_TYPE_RE.match(content_type)
+      end
+    end
+
+    private
 
-      return unless matchdata
+    def simplify_matchdata(matchdata, remove_x = false, joiner: "/")
+      return nil unless matchdata
 
       matchdata.captures.map { |e|
         e.downcase!
-        e.gsub!(UNREGISTERED_RE, ''.freeze)
-        e.gsub!(I18N_RE, '-'.freeze)
+        e.sub!(/^x-/, "") if remove_x
+        yield e if block_given?
         e
-      }.join('.'.freeze)
+      }.join(joiner)
     end
+  end
 
-    # Creates a MIME::Type from an +args+ array in the form of:
-    #   [ type-name, [ extensions ], encoding, system ]
-    #
-    # +extensions+, and +encoding+ are optional; +system+ is ignored.
-    #
-    #   MIME::Type.from_array('application/x-ruby', %w(rb), '8bit')
-    #   MIME::Type.from_array([ 'application/x-ruby', [ 'rb' ], '8bit' ])
-    #
-    # These are equivalent to:
-    #
-    #   MIME::Type.new('application/x-ruby') do |t|
-    #     t.extensions  = %w(rb)
-    #     t.encoding    = '8bit'
-    #   end
-    #
-    # It will yield the type (+t+) if a block is given.
-    #
-    # This method is deprecated and will be removed in mime-types 3.
-    def from_array(*args) # :yields t:
-      MIME::Types.deprecated(self, __method__)
+  private
 
-      # Dereferences the array one level, if necessary.
-      args = args.first if args.first.kind_of? Array
+  def content_type=(type_string)
+    match = MEDIA_TYPE_RE.match(type_string)
+    fail InvalidContentType, type_string if match.nil?
 
-      unless args.size.between?(1, 8)
-        fail ArgumentError,
-             'Array provided must contain between one and eight elements.'
-      end
+    @content_type = intern_string(type_string)
+    @raw_media_type, @raw_sub_type = match.captures
+    @simplified = intern_string(MIME::Type.simplified(match))
+    @i18n_key = intern_string(MIME::Type.i18n_key(match))
+    @media_type, @sub_type = MEDIA_TYPE_RE.match(@simplified).captures
 
-      MIME::Type.new(args.shift) do |t|
-        t.extensions, t.encoding, _system, t.obsolete, t.docs, _references,
-          t.registered = *args
-        yield t if block_given?
-      end
-    end
+    @raw_media_type = intern_string(@raw_media_type)
+    @raw_sub_type = intern_string(@raw_sub_type)
+    @media_type = intern_string(@media_type)
+    @sub_type = intern_string(@sub_type)
+  end
 
-    # Creates a MIME::Type from a +hash+. Keys are case-insensitive, dashes
-    # may be replaced with underscores, and the internal Symbol of the
-    # lowercase-underscore version can be used as well. That is,
-    # Content-Type can be provided as content-type, Content_Type,
-    # content_type, or :content_type.
-    #
-    # Known keys are <tt>Content-Type</tt>,
-    # <tt>Content-Transfer-Encoding</tt>, <tt>Extensions</tt>, and
-    # <tt>System</tt>. +System+ is ignored.
-    #
-    #   MIME::Type.from_hash('Content-Type' => 'text/x-yaml',
-    #                        'Content-Transfer-Encoding' => '8bit',
-    #                        'System' => 'linux',
-    #                        'Extensions' => ['yaml', 'yml'])
-    #
-    # This is equivalent to:
-    #
-    #   MIME::Type.new('text/x-yaml') do |t|
-    #     t.encoding    = '8bit'
-    #     t.system      = 'linux'
-    #     t.extensions  = ['yaml', 'yml']
-    #   end
-    #
-    # It will yield the constructed type +t+ if a block has been provided.
-    #
-    #
-    # This method is deprecated and will be removed in mime-types 3.
-    def from_hash(hash) # :yields t:
-      MIME::Types.deprecated(self, __method__)
-      type = {}
-      hash.each_pair do |k, v|
-        type[k.to_s.tr('A-Z', 'a-z').gsub(/-/, '_').to_sym] = v
-      end
+  if String.method_defined?(:-@)
+    def intern_string(string)
+      -string
+    end
+  else
+    # MRI 2.2 and older don't have a method for string interning,
+    # so we simply freeze them for keeping a similar interface
+    def intern_string(string)
+      string.freeze
+    end
+  end
 
-      MIME::Type.new(type[:content_type]) do |t|
-        t.extensions  = type[:extensions]
-        t.encoding    = type[:content_transfer_encoding]
-        t.obsolete    = type[:obsolete]
-        t.docs        = type[:docs]
-        t.url         = type[:url]
-        t.registered  = type[:registered]
+  def xref_map(values, helper)
+    values.map { |value| send(helper, value) }
+  end
 
-        yield t if block_given?
-      end
-    end
+  def xref_url_for_rfc(value)
+    "http://www.iana.org/go/%s" % value
+  end
 
-    # Essentially a copy constructor for +mime_type+.
-    #
-    #   MIME::Type.from_mime_type(plaintext)
-    #
-    # is equivalent to:
-    #
-    #   MIME::Type.new(plaintext.content_type.dup) do |t|
-    #     t.extensions  = plaintext.extensions.dup
-    #     t.system      = plaintext.system.dup
-    #     t.encoding    = plaintext.encoding.dup
-    #   end
-    #
-    # It will yield the type (+t+) if a block is given.
-    #
-    # This method is deprecated and will be removed in mime-types 3.
-    def from_mime_type(mime_type) # :yields the new MIME::Type:
-      MIME::Types.deprecated(self, __method__)
-      new(mime_type)
-    end
+  def xref_url_for_draft(value)
+    "http://www.iana.org/go/%s" % value.sub(/\ARFC/, "draft")
   end
 
-  private
+  def xref_url_for_rfc_errata(value)
+    "http://www.rfc-editor.org/errata_search.php?eid=%s" % value
+  end
 
-  def content_type=(type_string)
-    match = MEDIA_TYPE_RE.match(type_string)
-    fail InvalidContentType, type_string if match.nil?
+  def xref_url_for_person(value)
+    "http://www.iana.org/assignments/media-types/media-types.xhtml#%s" % value
+  end
 
-    @content_type                  = type_string
-    @raw_media_type, @raw_sub_type = match.captures
-    @simplified                    = MIME::Type.simplified(match)
-    @i18n_key                      = MIME::Type.i18n_key(match)
-    @media_type, @sub_type         = MEDIA_TYPE_RE.match(@simplified).captures
+  def xref_url_for_template(value)
+    "http://www.iana.org/assignments/media-types/%s" % value
   end
 end