mime-types 3.3.1 → 3.7.0

data/lib/mime/type.rb

@@ -4,33 +4,71 @@
 module MIME
 end
 
+require "mime/types/deprecations"
+
 # The definition of one MIME content-type.
 #
 # == Usage
-#  require 'mime/types'
+#  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 == 'text/plain'       # => true
-#  puts MIME::Type.simplified('x-appl/x-zip') # => 'appl/zip'
+#  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 "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("content-type" => "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
 #
-#  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"
+#
+#  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+).
+  # formatted (it is not +type+/+subtype+).
   class InvalidContentType < ArgumentError
     # :stopdoc:
     def initialize(type_string)
@@ -56,51 +94,70 @@ class MIME::Type
     # :startdoc:
   end
 
-  # The released version of the mime-types library.
-  VERSION = '3.3.1'
-
   include Comparable
 
   # :stopdoc:
-  # 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
+  # Full conformance with RFC 6838 §4.2 (the recommendation for < 64 characters is not
+  # enforced or reported because MIME::Types mostly deals with registered data). RFC 4288
+  # §4.2 does not restrict the first character to alphanumeric, but the total length of
+  # each part is limited to 127 characters. RFCC 2045 §5.1 does not restrict the character
+  # composition except for whitespace, but MIME::Type was always more strict than this.
+  restricted_name_first = "[0-9a-zA-Z]"
+  restricted_name_chars = "[-!#{$&}^_.+0-9a-zA-Z]{0,126}"
+  restricted_name = "#{restricted_name_first}#{restricted_name_chars}"
+  MEDIA_TYPE_RE = %r{(#{restricted_name})/(#{restricted_name})}.freeze
+  I18N_RE = /[^[:alnum:]]/.freeze
+  BINARY_ENCODINGS = %w[base64 8bit].freeze
+  ASCII_ENCODINGS = %w[7bit quoted-printable].freeze
   # :startdoc:
 
   private_constant :MEDIA_TYPE_RE, :I18N_RE, :BINARY_ENCODINGS,
-                   :ASCII_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.
+  #
+  # There are two deprecated initialization forms:
+  #
   # * 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 = {}
-    @obsolete = @registered = false
-    @preferred_extension = @docs = @use_instead = nil
+    @obsolete = @registered = @provisional = false
+    @preferred_extension = @docs = @use_instead = @__sort_priority = nil
+
     self.extensions = []
 
     case content_type
     when Hash
       init_with(content_type)
     when Array
+      MIME::Types.deprecated(
+        class: MIME::Type,
+        method: :new,
+        pre: "when called with an Array",
+        once: true
+      )
       self.content_type = content_type.shift
       self.extensions = content_type.flatten
     when MIME::Type
       init_with(content_type.to_h)
     else
+      MIME::Types.deprecated(
+        class: MIME::Type,
+        method: :new,
+        pre: "when called with a String",
+        once: true
+      )
       self.content_type = content_type
     end
 
@@ -108,16 +165,19 @@ 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
   # <tt>==</tt> because <tt>x-</tt> prefixes are removed for this comparison.
   def like?(other)
-    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
+    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
 
@@ -125,65 +185,93 @@ 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
-  #    don't 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 and ((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
   # match.
   def eql?(other)
-    other.kind_of?(MIME::Type) and self == other
+    other.is_a?(MIME::Type) && (self == other)
+  end
+
+  # Returns a hash based on the #simplified value.
+  #
+  # This maintains the invariant that two #eql? instances must have the same
+  # #hash (although having the same #hash does *not* imply that the objects are
+  # #eql?).
+  #
+  # To see why, suppose a MIME::Type instance +a+ is compared to another object
+  # +b+, and that <code>a.eql?(b)</code> is true. By the definition of #eql?,
+  # we know the following:
+  #
+  # 1. +b+ is a MIME::Type instance itself.
+  # 2. <code>a == b</code> is true.
+  #
+  # Due to the first point, we know that +b+ should respond to the #simplified
+  # method. Thus, per the definition of #<=>, we know that +a.simplified+ must
+  # be equal to +b.simplified+, as compared by the <=> method corresponding to
+  # +a.simplified+.
+  #
+  # Presumably, if <code>a.simplified <=> b.simplified</code> is +0+, then
+  # +a.simplified+ has the same hash as +b.simplified+. So we assume it is
+  # suitable for #hash to delegate to #simplified in service of the #eql?
+  # invariant.
+  def hash
+    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.
@@ -197,8 +285,7 @@ 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  => x-chemical/x-pdb
@@ -241,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
@@ -256,7 +344,7 @@ class MIME::Type
   # 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.
+  # extension, this will be added to #extensions.
   #
   # :attr_accessor: preferred_extension
 
@@ -280,7 +368,7 @@ class MIME::Type
   # provided is invalid.
   #
   # If the encoding is not provided on construction, this will be either
-  # 'quoted-printable' (for text/* media types) and 'base64' for eveything
+  # "quoted-printable" (for text/* media types) and "base64" for eveything
   # else.
   #
   # :attr_accessor: encoding
@@ -290,9 +378,9 @@ class MIME::Type
 
   ##
   def encoding=(enc) # :nodoc:
-    if enc.nil? or enc == :default
+    if enc.nil? || (enc == :default)
       @encoding = default_encoding
-    elsif BINARY_ENCODINGS.include?(enc) or ASCII_ENCODINGS.include?(enc)
+    elsif BINARY_ENCODINGS.include?(enc) || ASCII_ENCODINGS.include?(enc)
       @encoding = enc
     else
       fail InvalidEncoding, enc
@@ -301,7 +389,7 @@ class MIME::Type
 
   # 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
 
   ##
@@ -320,8 +408,16 @@ class MIME::Type
   attr_writer :use_instead
 
   # Returns +true+ if the media type is obsolete.
-  attr_accessor :obsolete
-  alias obsolete? 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
@@ -330,8 +426,8 @@ class MIME::Type
   #
   # call-seq:
   #   text_plain.friendly         # => "Text File"
-  #   text_plain.friendly('en')   # => "Text File"
-  def friendly(lang = 'en')
+  #   text_plain.friendly("en")   # => "Text File"
+  def friendly(lang = "en")
     @friendly ||= {}
 
     case lang
@@ -343,7 +439,7 @@ class MIME::Type
       @friendly.update(lang)
     else
       fail ArgumentError,
-           "Expected a language or translation set, not #{lang.inspect}"
+        "Expected a language or translation set, not #{lang.inspect}"
     end
   end
 
@@ -374,14 +470,38 @@ class MIME::Type
   # The decoded cross-reference URL list for this MIME::Type.
   def xref_urls
     xrefs.flat_map { |type, values|
-      name = :"xref_url_for_#{type.tr('-', '_')}"
-      respond_to?(name, true) and xref_map(values, name) or values.to_a
+      name = :"xref_url_for_#{type.tr("-", "_")}"
+      respond_to?(name, true) && xref_map(values, name) || values.to_a
     }
   end
 
   # Indicates whether the MIME type has been registered with IANA.
-  attr_accessor :registered
-  alias registered? 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_reader :provisional
+
+  ##
+  def provisional=(value)
+    clear_sort_priority
+    @provisional = !!value
+  end
+
+  # 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
@@ -399,7 +519,7 @@ class MIME::Type
 
   # Indicateswhether the MIME type is declared as a signature type.
   attr_accessor :signature
-  alias signature? signature
+  alias_method :signature?, :signature
 
   # Returns +true+ if the MIME::Type specifies an extension list,
   # indicating that it is a complete MIME::Type.
@@ -415,14 +535,14 @@ class MIME::Type
   # Returns the MIME::Type as a string for implicit conversions. This allows
   # MIME::Type objects to appear on either side of a comparison.
   #
-  #   'text/plain' == MIME::Type.new('text/plain')
+  #   "text/plain" == MIME::Type.new("content-type" => "text/plain")
   def to_str
     content_type
   end
 
   # Converts the MIME::Type to a JSON string.
   def to_json(*args)
-    require 'json'
+    require "json"
     to_h.to_json(*args)
   end
 
@@ -438,26 +558,28 @@ 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.nil? or @friendly.empty?
-    coder['encoding'] = @encoding
-    coder['extensions'] = @extensions.to_a unless @extensions.empty?
-    coder['preferred-extension'] = @preferred_extension if @preferred_extension
+    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
     unless xrefs.empty?
       {}.tap do |hash|
         xrefs.each do |k, v|
           hash[k] = v.to_a.sort
         end
-        coder['xrefs'] = hash
+        coder["xrefs"] = hash
       end
     end
-    coder['registered'] = registered?
-    coder['signature'] = signature? if signature?
+    coder["registered"] = registered?
+    coder["provisional"] = provisional? if provisional?
+    coder["signature"] = signature? if signature?
+    coder["sort-priority"] = __sort_priority || 0b11111111
     coder
   end
 
@@ -466,18 +588,22 @@ 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'] || ''
-    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.signature           = coder['signature']
-    self.xrefs               = coder['xrefs'] || {}
-    self.use_instead         = coder['use-instead']
+    @__sort_priority = 0
+    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"] || {})
 
-    friendly(coder['friendly'] || {})
+    update_sort_priority
   end
 
   def inspect # :nodoc:
@@ -501,8 +627,8 @@ class MIME::Type
     # Converts a provided +content_type+ into a translation key suitable for
     # use with the I18n library.
     def i18n_key(content_type)
-      simplify_matchdata(match(content_type), joiner: '.') { |e|
-        e.gsub!(I18N_RE, '-')
+      simplify_matchdata(match(content_type), joiner: ".") { |e|
+        e.gsub!(I18N_RE, "-")
       }
     end
 
@@ -519,12 +645,12 @@ class MIME::Type
 
     private
 
-    def simplify_matchdata(matchdata, remove_x = false, joiner: '/')
+    def simplify_matchdata(matchdata, remove_x = false, joiner: "/")
       return nil unless matchdata
 
       matchdata.captures.map { |e|
         e.downcase!
-        e.sub!(/^x-/, '') if remove_x
+        e.sub!(/^x-/, "") if remove_x
         yield e if block_given?
         e
       }.join(joiner)
@@ -533,15 +659,46 @@ 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?
 
-    @content_type                  = intern_string(type_string)
+    @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
+    @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
 
     @raw_media_type = intern_string(@raw_media_type)
     @raw_sub_type = intern_string(@raw_sub_type)
@@ -554,7 +711,7 @@ class MIME::Type
       -string
     end
   else
-    # MRI 2.2 and older don't have a method for string interning,
+    # MRI 2.2 and older do not have a method for string interning,
     # so we simply freeze them for keeping a similar interface
     def intern_string(string)
       string.freeze
@@ -566,22 +723,24 @@ class MIME::Type
   end
 
   def xref_url_for_rfc(value)
-    'http://www.iana.org/go/%s' % value
+    "http://www.iana.org/go/%s" % value
   end
 
   def xref_url_for_draft(value)
-    'http://www.iana.org/go/%s' % value.sub(/\ARFC/, 'draft')
+    "http://www.iana.org/go/%s" % value.sub(/\ARFC/, "draft")
   end
 
   def xref_url_for_rfc_errata(value)
-    'http://www.rfc-editor.org/errata_search.php?eid=%s' % value
+    "http://www.rfc-editor.org/errata_search.php?eid=%s" % value
   end
 
   def xref_url_for_person(value)
-    'http://www.iana.org/assignments/media-types/media-types.xhtml#%s' % value
+    "http://www.iana.org/assignments/media-types/media-types.xhtml#%s" % value
   end
 
   def xref_url_for_template(value)
-    'http://www.iana.org/assignments/media-types/%s' % value
+    "http://www.iana.org/assignments/media-types/%s" % value
   end
 end
+
+require "mime/types/version"