mime-types 1.25.1 → 2.0

data/docs/artistic.txt

@@ -1,127 +1,127 @@
-The "Artistic License"
-
-				Preamble
-
-The intent of this document is to state the conditions under which a
-Package may be copied, such that the Copyright Holder maintains some
-semblance of artistic control over the development of the package,
-while giving the users of the package the right to use and distribute
-the Package in a more-or-less customary fashion, plus the right to make
-reasonable modifications.
-
-Definitions:
-
-	"Package" refers to the collection of files distributed by the
-	Copyright Holder, and derivatives of that collection of files
-	created through textual modification.
-
-	"Standard Version" refers to such a Package if it has not been
-	modified, or has been modified in accordance with the wishes
-	of the Copyright Holder as specified below.
-
-	"Copyright Holder" is whoever is named in the copyright or
-	copyrights for the package.
-
-	"You" is you, if you're thinking about copying or distributing
-	this Package.
-
-	"Reasonable copying fee" is whatever you can justify on the
-	basis of media cost, duplication charges, time of people involved,
-	and so on.  (You will not be required to justify it to the
-	Copyright Holder, but only to the computing community at large
-	as a market that must bear the fee.)
-
-	"Freely Available" means that no fee is charged for the item
-	itself, though there may be fees involved in handling the item.
-	It also means that recipients of the item may redistribute it
-	under the same conditions they received it.
-
-1. You may make and give away verbatim copies of the source form of the
-Standard Version of this Package without restriction, provided that you
-duplicate all of the original copyright notices and associated disclaimers.
-
-2. You may apply bug fixes, portability fixes and other modifications
-derived from the Public Domain or from the Copyright Holder.  A Package
-modified in such a way shall still be considered the Standard Version.
-
-3. You may otherwise modify your copy of this Package in any way, provided
-that you insert a prominent notice in each changed file stating how and
-when you changed that file, and provided that you do at least ONE of the
-following:
-
-    a) place your modifications in the Public Domain or otherwise make them
-    Freely Available, such as by posting said modifications to Usenet or
-    an equivalent medium, or placing the modifications on a major archive
-    site such as uunet.uu.net, or by allowing the Copyright Holder to include
-    your modifications in the Standard Version of the Package.
-
-    b) use the modified Package only within your corporation or organization.
-
-    c) rename any non-standard executables so the names do not conflict
-    with standard executables, which must also be provided, and provide
-    a separate manual page for each non-standard executable that clearly
-    documents how it differs from the Standard Version.
-
-    d) make other distribution arrangements with the Copyright Holder.
-
-4. You may distribute the programs of this Package in object code or
-executable form, provided that you do at least ONE of the following:
-
-    a) distribute a Standard Version of the executables and library files,
-    together with instructions (in the manual page or equivalent) on where
-    to get the Standard Version.
-
-    b) accompany the distribution with the machine-readable source of
-    the Package with your modifications.
-
-    c) give non-standard executables non-standard names, and clearly
-    document the differences in manual pages (or equivalent), together
-    with instructions on where to get the Standard Version.
-
-    d) make other distribution arrangements with the Copyright Holder.
-
-5. You may charge a reasonable copying fee for any distribution of this
-Package.  You may charge any fee you choose for support of this
-Package.  You may not charge a fee for this Package itself.  However,
-you may distribute this Package in aggregate with other (possibly
-commercial) programs as part of a larger (possibly commercial) software
-distribution provided that you do not advertise this Package as a
-product of your own.  You may embed this Package's interpreter within
-an executable of yours (by linking); this shall be construed as a mere
-form of aggregation, provided that the complete Standard Version of the
-interpreter is so embedded.
-
-6. The scripts and library files supplied as input to or produced as
-output from the programs of this Package do not automatically fall
-under the copyright of this Package, but belong to whoever generated
-them, and may be sold commercially, and may be aggregated with this
-Package.  If such scripts or library files are aggregated with this
-Package via the so-called "undump" or "unexec" methods of producing a
-binary executable image, then distribution of such an image shall
-neither be construed as a distribution of this Package nor shall it
-fall under the restrictions of Paragraphs 3 and 4, provided that you do
-not represent such an executable image as a Standard Version of this
-Package.
-
-7. C subroutines (or comparably compiled subroutines in other
-languages) supplied by you and linked into this Package in order to
-emulate subroutines and variables of the language defined by this
-Package shall not be considered part of this Package, but are the
-equivalent of input as in Paragraph 6, provided these subroutines do
-not change the language in any way that would cause it to fail the
-regression tests for the language.
-
-8. Aggregation of this Package with a commercial distribution is always
-permitted provided that the use of this Package is embedded; that is,
-when no overt attempt is made to make this Package's interfaces visible
-to the end user of the commercial distribution.  Such use shall not be
-construed as a distribution of this Package.
-
-9. The name of the Copyright Holder may not be used to endorse or promote
-products derived from this software without specific prior written permission.
-
-10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
-IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
-WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-
-				The End
+= The "Artistic License"
+
+          Preamble
+
+  The intent of this document is to state the conditions under which a
+  Package may be copied, such that the Copyright Holder maintains some
+  semblance of artistic control over the development of the package,
+  while giving the users of the package the right to use and distribute
+  the Package in a more-or-less customary fashion, plus the right to make
+  reasonable modifications.
+
+  Definitions:
+
+    "Package" refers to the collection of files distributed by the
+    Copyright Holder, and derivatives of that collection of files
+    created through textual modification.
+
+    "Standard Version" refers to such a Package if it has not been
+    modified, or has been modified in accordance with the wishes
+    of the Copyright Holder as specified below.
+
+    "Copyright Holder" is whoever is named in the copyright or
+    copyrights for the package.
+
+    "You" is you, if you're thinking about copying or distributing
+    this Package.
+
+    "Reasonable copying fee" is whatever you can justify on the
+    basis of media cost, duplication charges, time of people involved,
+    and so on.  (You will not be required to justify it to the
+    Copyright Holder, but only to the computing community at large
+    as a market that must bear the fee.)
+
+    "Freely Available" means that no fee is charged for the item
+    itself, though there may be fees involved in handling the item.
+    It also means that recipients of the item may redistribute it
+    under the same conditions they received it.
+
+  1. You may make and give away verbatim copies of the source form of the
+  Standard Version of this Package without restriction, provided that you
+  duplicate all of the original copyright notices and associated disclaimers.
+
+  2. You may apply bug fixes, portability fixes and other modifications
+  derived from the Public Domain or from the Copyright Holder.  A Package
+  modified in such a way shall still be considered the Standard Version.
+
+  3. You may otherwise modify your copy of this Package in any way, provided
+  that you insert a prominent notice in each changed file stating how and
+  when you changed that file, and provided that you do at least ONE of the
+  following:
+
+      a) place your modifications in the Public Domain or otherwise make them
+      Freely Available, such as by posting said modifications to Usenet or
+      an equivalent medium, or placing the modifications on a major archive
+      site such as uunet.uu.net, or by allowing the Copyright Holder to include
+      your modifications in the Standard Version of the Package.
+
+      b) use the modified Package only within your corporation or organization.
+
+      c) rename any non-standard executables so the names do not conflict
+      with standard executables, which must also be provided, and provide
+      a separate manual page for each non-standard executable that clearly
+      documents how it differs from the Standard Version.
+
+      d) make other distribution arrangements with the Copyright Holder.
+
+  4. You may distribute the programs of this Package in object code or
+  executable form, provided that you do at least ONE of the following:
+
+      a) distribute a Standard Version of the executables and library files,
+      together with instructions (in the manual page or equivalent) on where
+      to get the Standard Version.
+
+      b) accompany the distribution with the machine-readable source of
+      the Package with your modifications.
+
+      c) give non-standard executables non-standard names, and clearly
+      document the differences in manual pages (or equivalent), together
+      with instructions on where to get the Standard Version.
+
+      d) make other distribution arrangements with the Copyright Holder.
+
+  5. You may charge a reasonable copying fee for any distribution of this
+  Package.  You may charge any fee you choose for support of this
+  Package.  You may not charge a fee for this Package itself.  However,
+  you may distribute this Package in aggregate with other (possibly
+  commercial) programs as part of a larger (possibly commercial) software
+  distribution provided that you do not advertise this Package as a
+  product of your own.  You may embed this Package's interpreter within
+  an executable of yours (by linking); this shall be construed as a mere
+  form of aggregation, provided that the complete Standard Version of the
+  interpreter is so embedded.
+
+  6. The scripts and library files supplied as input to or produced as
+  output from the programs of this Package do not automatically fall
+  under the copyright of this Package, but belong to whoever generated
+  them, and may be sold commercially, and may be aggregated with this
+  Package.  If such scripts or library files are aggregated with this
+  Package via the so-called "undump" or "unexec" methods of producing a
+  binary executable image, then distribution of such an image shall
+  neither be construed as a distribution of this Package nor shall it
+  fall under the restrictions of Paragraphs 3 and 4, provided that you do
+  not represent such an executable image as a Standard Version of this
+  Package.
+
+  7. C subroutines (or comparably compiled subroutines in other
+  languages) supplied by you and linked into this Package in order to
+  emulate subroutines and variables of the language defined by this
+  Package shall not be considered part of this Package, but are the
+  equivalent of input as in Paragraph 6, provided these subroutines do
+  not change the language in any way that would cause it to fail the
+  regression tests for the language.
+
+  8. Aggregation of this Package with a commercial distribution is always
+  permitted provided that the use of this Package is embedded; that is,
+  when no overt attempt is made to make this Package's interfaces visible
+  to the end user of the commercial distribution.  Such use shall not be
+  construed as a distribution of this Package.
+
+  9. The name of the Copyright Holder may not be used to endorse or promote
+  products derived from this software without specific prior written permission.
+
+  10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+  WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+
+          The End

data/lib/mime.rb

@@ -0,0 +1,50 @@
+# -*- ruby encoding: utf-8 -*-
+
+# The namespace for MIME applications, tools, and libraries.
+module MIME # :nodoc:
+end
+
+class << MIME
+  # Used to mark a method as deprecated in the mime-types interface.
+  def deprecated(klass, sym, message = nil) # :nodoc:
+    level = case klass
+            when Class, Module
+              '.'
+            else
+              klass = klass.class
+              '#'
+            end
+    unless defined?(@__deprecated) and @__deprecated["#{klass}#{level}#{sym}"]
+      message = case message
+                when :private, :protected
+                  "and will be #{message}"
+                when nil
+                  "and will be removed"
+                else
+                  message
+                end
+      warn "#{klass}#{level}#{sym} is deprecated #{message}."
+      (@__deprecated ||= {})["#{klass}#{level}#{sym}"] = true
+    end
+  end
+
+  # MIME::InvalidContentType was moved to MIME::Type::InvalidContentType.
+  # Provide a single warning about this fact in the interim.
+  def const_missing(name) # :nodoc:
+    case name.to_s
+    when "InvalidContentType"
+      warn_about_moved_constants(name)
+      MIME::Type.const_get(name.to_sym)
+    else
+      super
+    end
+  end
+
+  private
+  def warn_about_moved_constants(name) # :nodoc:
+    unless defined?(@__warned_constants) and @__warned_constants[name]
+      warn "MIME::#{name} is deprecated. Use MIME::Type::#{name} instead."
+      (@__warned_constants ||= {})[name] = true
+    end
+  end
+end

data/lib/mime/type.rb

@@ -0,0 +1,634 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'mime'
+require 'json'
+
+# The definition of one MIME content-type.
+#
+# == Usage
+#  require 'mime/types'
+#
+#  plaintext = MIME::Types['text/plain'].first
+#  # returns [text/plain, text/plain]
+#  text      = plaintext.first
+#  print text.media_type           # => 'text'
+#  print text.sub_type             # => 'plain'
+#
+#  puts text.extensions.join(" ")  # => 'asc txt c cc h hh cpp'
+#
+#  puts text.encoding              # => 8bit
+#  puts text.binary?               # => false
+#  puts text.ascii?                # => true
+#  puts text == 'text/plain'       # => true
+#  puts MIME::Type.simplified('x-appl/x-zip') # => 'appl/zip'
+#
+#  puts MIME::Types.any? { |type|
+#    type.content_type == 'text/plain'
+#  }                               # => true
+#  puts MIME::Types.all?(&:registered?)
+#                                  # => false
+class MIME::Type
+  # Reflects a MIME content-type specification that is not correctly
+  # formatted (it isn't +type+/+subtype+).
+  class InvalidContentType < ArgumentError
+    # :stopdoc:
+    def initialize(type_string)
+      @type_string = type_string
+    end
+
+    def to_s
+      "Invalid Content-Type #{@type_string.inspect}"
+    end
+    # :startdoc:
+  end
+
+  # Reflects an unsupported MIME encoding.
+  class InvalidEncoding < ArgumentError
+    # :stopdoc:
+    def initialize(encoding)
+      @encoding = encoding
+    end
+
+    def to_s
+      "Invalid Encoding #{@encoding.inspect} (valid values are " +
+        "#{MIME::Type::VALID_ENCODINGS.inspect})."
+    end
+    # :startdoc:
+  end
+
+  # The released version of the mime-types library.
+  VERSION = '2.0'
+
+  include Comparable
+
+  # :stopdoc:
+  MEDIA_TYPE_RE     = %r{([-\w.+]+)/([-\w.+]*)}o
+  UNREGISTERED_RE   = %r{[Xx]-}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"
+  LTSW_URL          = "http://www.ltsw.se/knbase/internet/%s.htp"
+  CONTACT_URL       = "http://www.iana.org/assignments/contact-people.htm#%s"
+  # :startdoc:
+
+  # Builds a MIME::Type object from the provided MIME Content Type value
+  # (e.g., 'text/plain' or 'applicaton/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.
+  # * Otherwise, the content_type will be used as a string.
+  def initialize(content_type) # :yields self:
+    self.system      = nil
+    self.obsolete    = false
+    self.registered  = nil
+    self.use_instead = nil
+    self.signature   = nil
+
+    case content_type
+    when Hash
+      init_with(content_type)
+    when Array
+      self.content_type = content_type[0]
+      self.extensions   = content_type[1] || []
+    when MIME::Type
+      init_with(content_type.to_h)
+    else
+      self.content_type = content_type
+    end
+
+    self.extensions   ||= []
+    self.docs         ||= nil
+    self.encoding     ||= :default
+    self.references   ||= []
+
+    yield self if block_given?
+  end
+
+  # Returns +true+ if the simplified type matches the current
+  def like?(other)
+    if other.respond_to?(:simplified)
+      @simplified == other.simplified
+    else
+      @simplified == MIME::Type.simplified(other)
+    end
+  end
+
+  # Compares the MIME::Type against the exact content type or the 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.
+  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)
+    end
+  end
+
+  # Compares the 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. Generic definitions < platform definitions.
+  # 3. Complete definitions < incomplete definitions.
+  # 4. Current definitions < obsolete definitions.
+  # 5. Obselete with use-instead references < obsolete without.
+  # 6. Obsolete use-instead definitions are compared.
+  def priority_compare(other)
+    pc = simplified <=> other.simplified
+    if pc.zero?
+      pc = if (registered? != other.registered?)
+             registered? ? -1 : 1 # registered < unregistered
+           elsif (platform? != other.platform?)
+             platform? ? 1 : -1 # generic < platform
+           elsif (complete? != other.complete?)
+             complete? ? -1 : 1 # complete < incomplete
+           elsif (obsolete? != other.obsolete?)
+             obsolete? ? 1 : -1 # current < obsolete
+           elsif obsolete? and (use_instead != other.use_instead)
+             if use_instead.nil?
+               1
+             elsif other.use_instead.nil?
+               -1
+             else
+               use_instead <=> other.use_instead
+             end
+           else
+             0
+           end
+    end
+
+    pc
+  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
+  end
+
+  # Returns the whole MIME content-type string.
+  #
+  #   text/plain        => text/plain
+  #   x-chemical/x-pdb  => x-chemical/x-pdb
+  attr_reader :content_type
+  # Returns the media type of the simplified MIME::Type.
+  #
+  #   text/plain        => text
+  #   x-chemical/x-pdb  => chemical
+  attr_reader :media_type
+  # Returns the media type of the unmodified MIME::Type.
+  #
+  #   text/plain        => text
+  #   x-chemical/x-pdb  => x-chemical
+  attr_reader :raw_media_type
+  # Returns the sub-type of the simplified MIME::Type.
+  #
+  #   text/plain        => plain
+  #   x-chemical/x-pdb  => pdb
+  attr_reader :sub_type
+  # Returns the media type of the unmodified MIME::Type.
+  #
+  #   text/plain        => plain
+  #   x-chemical/x-pdb  => x-pdb
+  attr_reader :raw_sub_type
+  # 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 can disappear, adds to the confusing
+  # proliferation of MIME types. The simplified string has the <tt>x-</tt>
+  # removed and are translated to lowercase.
+  #
+  #   text/plain        => text/plain
+  #   x-chemical/x-pdb  => chemical/pdb
+  attr_reader :simplified
+  # 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 = [ext].flatten.compact.sort.uniq
+  end
+
+  # Merge the extensions provided into this MIME::Type. The extensions added
+  # will be merged uniquely.
+  def add_extensions(*ext)
+    @extensions = (@extensions + ext).flatten.compact.sort.uniq
+  end
+
+  # The encoding (7bit, 8bit, quoted-printable, or base64) required to
+  # transport the data of this content type safely across a network, which
+  # roughly corresponds to Content-Transfer-Encoding. A value of +nil+ or
+  # <tt>:default</tt> will reset the #encoding to the #default_encoding for
+  # the MIME::Type. Raises ArgumentError if the encoding 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
+  # else.
+  attr_reader :encoding
+  def encoding=(enc) # :nodoc:
+    if DEFAULT_ENCODINGS.include?(enc)
+      @encoding = self.default_encoding
+    elsif BINARY_ENCODINGS.include?(enc) or TEXT_ENCODINGS.include?(enc)
+      @encoding = enc
+    else
+      raise InvalidEncoding, enc
+    end
+  end
+
+  # If the MIME::Type is a system-specific MIME::Type, returns the regular
+  # expression for the operating system indicated.
+  #
+  # This information about MIME content types is deprecated.
+  def system
+    MIME.deprecated(self, __method__)
+    @system
+  end
+  def system=(os) # :nodoc:
+    if os.nil? or os.kind_of?(Regexp)
+      @system = os
+    else
+      @system = %r|#{os}|
+    end
+  end
+
+  # Returns the default encoding for the MIME::Type based on the media type.
+  def default_encoding
+    (@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.
+  def use_instead
+    return nil unless obsolete?
+    @use_instead
+  end
+  attr_writer :use_instead # :nodoc:
+
+  # Returns +true+ if the media type is obsolete.
+  def obsolete?
+    !!@obsolete
+  end
+  def obsolete=(v) # :nodoc:
+    @obsolete = !!v
+  end
+
+  # The documentation for this MIME::Type.
+  attr_accessor :docs
+
+  # The encoded references URL list for this MIME::Type. See #urls for more
+  # information.
+  #
+  # This was previously called #url.
+  attr_reader :references
+  def references=(r) # :nodoc:
+    @references = [ r ].flatten.compact.uniq
+  end
+
+  def url # :nodoc:
+    MIME.deprecated(self, __method__, "and has been renamed to #references")
+    references
+  end
+  def url=(r) # :nodoc:
+    MIME.deprecated(self, __method__, "and has been renamed to #references=")
+    self.references = r
+  end
+
+  # The decoded URL list for this MIME::Type.
+  #
+  # The special URL value IANA will be translated into:
+  #   http://www.iana.org/assignments/media-types/<mediatype>/<subtype>
+  #
+  # The special URL value RFC### will be translated into:
+  #   http://www.rfc-editor.org/rfc/rfc###.txt
+  #
+  # The special URL value DRAFT:name will be translated into:
+  #   https://datatracker.ietf.org/public/idindex.cgi?
+  #       command=id_detail&filename=<name>
+  #
+  # The special URL value LTSW will be translated into:
+  #   http://www.ltsw.se/knbase/internet/<mediatype>.htp
+  #
+  # The special URL value [token] will be translated into:
+  #   http://www.iana.org/assignments/contact-people.htm#<token>
+  #
+  # These values will be accessible through #urls, which always returns an
+  # array.
+  def urls
+    @references.map do |el|
+      case el
+      when %r{^IANA$}
+        IANA_URL % [ @media_type, @sub_type ]
+      when %r{^RFC(\d+)$}
+        RFC_URL % $1
+      when %r{^DRAFT:(.+)$}
+        DRAFT_URL % $1
+      when %r{^LTSW$}
+        LTSW_URL % @media_type
+      when %r{^\{([^=]+)=([^\}]+)\}}
+        [$1, $2]
+      when %r{^\[([^=]+)=([^\]]+)\]}
+        [$1, CONTACT_URL % $2]
+      when %r{^\[([^\]]+)\]}
+        CONTACT_URL % $1
+      else
+        el
+      end
+    end
+  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.
+  def registered?
+    if @registered.nil?
+      (@raw_media_type !~ UNREGISTERED_RE) and
+        (@raw_sub_type !~ UNREGISTERED_RE)
+    else
+      !!@registered
+    end
+  end
+  def registered=(v) # :nodoc:
+    @registered = v.nil? ? v : !!v
+  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)
+  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?
+    not binary?
+  end
+
+  # Returns +true+ when the simplified MIME::Type is in the list of known
+  # digital signatures.
+  def signature?
+    !!@signature
+  end
+  def signature=(v) # :nodoc:
+    @signature = !!v
+  end
+
+  # Returns +true+ if the MIME::Type is specific to an operating system.
+  #
+  # This method is deprecated.
+  def system?
+    MIME.deprecated(self, __method__)
+    not @system.nil?
+  end
+
+  # Returns +true+ if the MIME::Type is specific to the current operating
+  # system as represented by RUBY_PLATFORM.
+  #
+  # This method is deprecated.
+  def platform?
+    MIME.deprecated(self, __method__)
+    system? and (RUBY_PLATFORM =~ @system)
+  end
+
+  # Returns +true+ if the MIME::Type specifies an extension list,
+  # indicating that it is a complete MIME::Type.
+  def complete?
+    not @extensions.empty?
+  end
+
+  # Returns the MIME::Type as a string.
+  def to_s
+    @content_type
+  end
+
+  # 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')
+  def to_str
+    @content_type
+  end
+
+  # Returns the MIME::Type as an array suitable for use with
+  # MIME::Type.from_array.
+  #
+  # This method is deprecated.
+  def to_a
+    MIME.deprecated(self, __method__)
+    [ @content_type, @extensions, @encoding, @system, obsolete?, @docs,
+      @references, registered? ]
+  end
+
+  # Returns the MIME::Type as an array suitable for use with
+  # MIME::Type.from_hash.
+  #
+  # This method is deprecated.
+  def to_hash
+    MIME.deprecated(self, __method__)
+    { 'Content-Type'              => @content_type,
+      'Content-Transfer-Encoding' => @encoding,
+      'Extensions'                => @extensions,
+      'System'                    => @system,
+      'Obsolete'                  => obsolete?,
+      'Docs'                      => @docs,
+      'URL'                       => @references,
+      'Registered'                => registered?,
+    }
+  end
+
+  # Converts the MIME::Type to a JSON string.
+  def to_json(*args)
+    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.
+  def to_h
+    encode_with({})
+  end
+
+  # :stopdoc:
+  def encode_with(coder)
+    coder['content-type']   = @content_type
+    coder['docs']           = @docs unless @docs.nil? or @docs.empty?
+    coder['encoding']       = @encoding
+    coder['extensions']     = @extensions unless @extensions.empty?
+    if obsolete?
+      coder['obsolete']     = obsolete?
+      coder['use-instead']  = use_instead if use_instead
+    end
+    coder['references']     = references unless references.empty?
+    coder['registered']     = registered?
+    if signature?
+      coder['signature']      = signature?
+    end
+    coder['system']         = @system if @system
+    coder
+  end
+
+  def init_with(coder)
+    self.content_type = coder['content-type']
+    self.docs         = coder['docs'] || []
+    self.encoding     = coder['encoding']
+    self.extensions   = coder['extensions'] || []
+    self.obsolete     = coder['obsolete']
+    self.references   = coder['references'] || []
+    self.registered   = coder['registered']
+    self.signature    = coder['signature']
+    self.system       = coder['system']
+    self.use_instead  = coder['use-instead']
+  end
+  # :startdoc:
+
+  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 can disappear, adds to the confusing
+    # proliferation of MIME types. The simplified string has the <tt>x-</tt>
+    # removed and are translated to lowercase.
+    def simplified(content_type)
+      matchdata = MEDIA_TYPE_RE.match(content_type)
+
+      if matchdata.nil?
+        nil
+      else
+        matchdata.captures.map { |e|
+          e.downcase.gsub(UNREGISTERED_RE, '')
+        }.join('/')
+      end
+    end
+
+    # Creates a MIME::Type from an array in the form of:
+    #   [type-name, [extensions], encoding, system]
+    #
+    # +extensions+, +encoding+, and +system+ are optional.
+    #
+    #   MIME::Type.from_array("application/x-ruby", ['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
+    #
+    # This method is deprecated.
+    def from_array(*args) # :yields MIME::Type.new:
+      MIME.deprecated(self, __method__)
+
+      # Dereferences the array one level, if necessary.
+      args = args.first if args.first.kind_of? Array
+
+      unless args.size.between?(1, 8)
+        raise ArgumentError, "Array provided must contain between one and eight elements."
+      end
+
+      MIME::Type.new(args.shift) do |t|
+        t.extensions, t.encoding, t.system, t.obsolete, t.docs, t.references,
+          t.registered = *args
+        yield t if block_given?
+      end
+    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>.
+    #
+    #   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
+    #
+    # This method has been deprecated.
+    def from_hash(hash) # :yields MIME::Type.new:
+      MIME.deprecated(self, __method__)
+      type = {}
+      hash.each_pair do |k, v|
+        type[k.to_s.tr('A-Z', 'a-z').gsub(/-/, '_').to_sym] = v
+      end
+
+      MIME::Type.new(type[:content_type]) do |t|
+        t.extensions  = type[:extensions]
+        t.encoding    = type[:content_transfer_encoding]
+        t.system      = type[:system]
+        t.obsolete    = type[:obsolete]
+        t.docs        = type[:docs]
+        t.url         = type[:url]
+        t.registered  = type[:registered]
+
+        yield t if block_given?
+      end
+    end
+
+    # Essentially a copy constructor.
+    #
+    #   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
+    #
+    # This method has been deprecated.
+    def from_mime_type(mime_type) # :yields the new MIME::Type:
+      MIME.deprecated(self, __method__)
+      new(mime_type)
+    end
+  end
+
+  private
+  def content_type=(type_string)
+    match = MEDIA_TYPE_RE.match(type_string)
+    raise InvalidContentType, type_string if match.nil?
+
+    @content_type                  = type_string
+    @raw_media_type, @raw_sub_type = *match.captures
+    @simplified                    = MIME::Type.simplified(type_string)
+    @media_type, @sub_type         =
+      *MEDIA_TYPE_RE.match(@simplified).captures
+  end
+end