mime-types 1.25.1 → 2.0

data/support/iana_downloader.rb

@@ -0,0 +1,201 @@
+# -*- ruby encoding: utf-8 -*-
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'open-uri'
+require 'nokogiri'
+require 'cgi'
+require 'fileutils'
+require 'yaml'
+
+ENV['RUBY_MIME_TYPES_LAZY_LOAD'] = 'yes'
+require 'mime/types'
+
+class IANADownloader
+  INDEX_URL = %q(https://www.iana.org/assignments/media-types/)
+  MIME_HREF = %r{/assignments/media-types/(.+)/?$}
+
+  def self.download_to(destination)
+    new(destination).download_all
+  end
+
+  attr_reader :destination
+
+  def initialize(destination = nil)
+    @destination =
+      File.expand_path(destination ||
+                       File.expand_path('../../type-lists', __FILE__))
+  end
+
+  def download_all
+    puts "Downloading index of MIME types from #{INDEX_URL}."
+    index = Nokogiri::HTML(open(INDEX_URL) { |f| f.read })
+    index.xpath('//a').each do |tag|
+      next unless tag['href']
+      href_match = MIME_HREF.match(tag['href'])
+      next unless href_match
+      href = href_match.captures.first
+      next if tag.content == 'example'
+      download_one(href, tag.content, href)
+    end
+  end
+
+  def download_one(url, name = url, type = nil)
+    if url =~ %r{^https?://}
+      name = File.basename(url) if name == url
+    else
+      url  = File.join(INDEX_URL, url)
+    end
+
+    Parser.download(name, from: url, to: @destination, type: type)
+  end
+end
+
+class IANADownloader::Parser
+  def self.download(name, options = {})
+    new(name, options) do |parser|
+      parser.parse(parser.download)
+      parser.save
+    end
+  end
+
+  def initialize(name, options = {})
+    raise ArgumentError, ":from not specified" unless options[:from]
+    raise ArgumentError, ":to not specified" unless options[:to]
+
+    @name  = "#{File.basename(name, '.yml')}.yml"
+    @from  = options[:from]
+    @to    = File.expand_path(options[:to])
+    @type  = File.basename(options[:type] || name, '.yml')
+    @file  = File.join(@to, @name)
+    @types = load_mime_types || MIME::Types.new
+
+    yield self if block_given?
+  end
+
+  def download
+    puts "Downloading #{@name} from #{@from}"
+    Nokogiri::HTML(open(@from) { |f| f.read })
+  end
+
+  def parse(html)
+    nodes = html.xpath('//table//table//tr')
+
+    # How many <td> children does the first node have?
+    node_count = child_elems(nodes.first).size
+
+    if node_count == 1
+      # The title node doesn't have what we expect. Let's try it based on
+      # the first real node.
+      node_count = child_elems(nodes.first.next).size
+    end
+
+    nodes.each do |node|
+      next if node == nodes.first
+
+      elems = child_elems(node)
+      next if elems.size.zero?
+
+      if elems.size != node_count
+        warn "size mismatch (#{elems.size} != #{node_count}) in node: #{node}"
+        next
+      end
+
+      sub_ix, ref_ix = case elems.size
+                       when 3
+                         [ 1, 2 ]
+                       when 4
+                         [ 1, 3 ]
+                       else
+                         warn "size error (#{elems.size} != {3,4}) in node: #{node}"
+                         raise
+                       end
+      subtype = elems[sub_ix].content.chomp.strip
+      refs    = child_elems(elems[ref_ix]).map { |ref|
+        ref = ref.xpath('a') unless ref.name == 'a'
+        [ ref ].flatten.map { |r| href_to_ref(r) }
+
+      }.flatten
+
+      content_type = [ @type, subtype].join('/')
+      use_instead  = nil
+      obsolete     = false
+
+      if content_type =~ OBSOLETE
+        content_type = $1
+        obsolete     = true
+      elsif content_type =~ DEPRECATED
+        content_type = $1
+        use_instead  = [ $2 ]
+        obsolete     = true
+      end
+
+      types        = @types.select { |t|
+        (t.content_type == content_type)
+      }
+
+      if types.empty?
+        MIME::Type.new(content_type) do |mt|
+          mt.references  = %w(IANA) + refs
+          mt.registered  = true
+          mt.obsolete    = obsolete if obsolete
+          mt.use_instead = use_instead if use_instead
+          @types << mt
+        end
+      else
+        types.each { |mt|
+          mt.references  = %w(IANA) + refs
+          mt.registered  = true
+          mt.obsolete    = obsolete if obsolete
+          mt.use_instead = use_instead if use_instead
+        }
+      end
+    end
+  end
+
+  def save
+    FileUtils.mkdir_p(@to)
+    File.open(@file, 'wb') { |f|
+      f.puts @types.map.to_a.sort.to_yaml
+    }
+  end
+
+  private
+  def child_elems(node)
+    node.children.select { |n| n.elem? }
+  end
+
+  def load_mime_types
+    if File.exist?(@file)
+      MIME::Types::Loader.load_from_yaml(@file)
+    end
+  end
+
+  def href_to_ref(ref)
+    case ref['href']
+    when CONTACT_PEOPLE
+      tag = CGI::unescape($1).chomp.strip
+      if tag == ref.content
+        "[#{ref.content}]"
+      else
+        "[#{ref.content}=#{tag}]"
+      end
+    when RFC_EDITOR, IETF_RFC, IETF_RFC_TOOLS
+      "RFC#$1"
+    when RFC_BAD_EDITOR
+      ref.content
+    when %r{(https?://.*)}
+      "{#{ref.content}=#$1}"
+    else
+      ref
+    end
+  end
+
+  CONTACT_PEOPLE = %r{https?://www.iana.org/assignments/contact-people.html?l?#(.*)}
+  RFC_EDITOR = %r{https?://www.rfc-editor.org/rfc/rfc(\d+).txt}
+  RFC_BAD_EDITOR = %r{https?://www.rfc-editor.org/rfc/rfcxxxx.txt}
+  IETF_RFC = %r{https?://www.ietf.org/rfc/rfc(\d+).txt}
+  IETF_RFC_TOOLS = %r{https?://tools.ietf.org/html/rfc(\d+)}
+  OBSOLETE   = %r{(.+)\s+\((?:obsolete|deprecated)\)}i
+  DEPRECATED = %r{(.+)\s+-\s+DEPRECATED\s+-\s+Please\s+use\s+(.+)}
+end

data/test/fixture/json.json

@@ -0,0 +1 @@
+[{"content-type":"application/smil","encoding":"8bit","extensions":["smi","smil"],"obsolete":true,"use-instead":["application/smil+xml"],"references":["IANA","RFC4536"],"registered":true},{"content-type":"audio/vnd.qcelp","encoding":"base64","extensions":["qcp"],"obsolete":true,"use-instead":["audio/QCELP"],"references":["IANA","RFC3625"],"registered":true},{"content-type":"image/bmp","encoding":"base64","extensions":["bmp"],"obsolete":true,"use-instead":["image/x-bmp"],"registered":false},{"content-type":"application/acad","encoding":"base64","references":["LTSW"],"registered":false},{"content-type":"audio/webm","encoding":"base64","extensions":["webm"],"references":["{WebM=http://www.webmproject.org/code/specs/container/}"],"registered":false},{"content-type":"image/pjpeg","docs":"Fixes a bug with IE6 and progressive JPEGs","encoding":"base64","registered":false},{"content-type":"application/1d-interleaved-parityfec","encoding":"base64","references":["IANA","RFC6015"],"registered":true},{"content-type":"audio/1d-interleaved-parityfec","encoding":"base64","references":["IANA","RFC6015"],"registered":true},{"content-type":"application/x-apple-diskimage","encoding":"base64","extensions":["dmg"],"registered":false,"system":"mac"}]

data/test/fixture/old-data

@@ -0,0 +1,9 @@
+!application/smil @smi,smil :8bit 'IANA,RFC4536 =use-instead:application/smil+xml
+!audio/vnd.qcelp @qcp 'IANA,RFC3625 =use-instead:audio/QCELP
+*!image/bmp @bmp =use-instead:image/x-bmp
+*application/acad 'LTSW
+*audio/webm @webm '{WebM=http://www.webmproject.org/code/specs/container/}
+*image/pjpeg :base64 =Fixes a bug with IE6 and progressive JPEGs
+application/1d-interleaved-parityfec 'IANA,RFC6015
+audio/1d-interleaved-parityfec 'IANA,RFC6015
+mac:application/x-apple-diskimage @dmg

data/test/fixture/yaml.yaml

@@ -0,0 +1,75 @@
+---
+- !ruby/object:MIME::Type
+  content-type: application/smil
+  encoding: 8bit
+  extensions:
+  - smi
+  - smil
+  obsolete: true
+  use-instead:
+  - application/smil+xml
+  references:
+  - IANA
+  - RFC4536
+  registered: true
+- !ruby/object:MIME::Type
+  content-type: audio/vnd.qcelp
+  encoding: base64
+  extensions:
+  - qcp
+  obsolete: true
+  use-instead:
+  - audio/QCELP
+  references:
+  - IANA
+  - RFC3625
+  registered: true
+- !ruby/object:MIME::Type
+  content-type: image/bmp
+  encoding: base64
+  extensions:
+  - bmp
+  obsolete: true
+  use-instead:
+  - image/x-bmp
+  registered: false
+- !ruby/object:MIME::Type
+  content-type: application/acad
+  encoding: base64
+  references:
+  - LTSW
+  registered: false
+- !ruby/object:MIME::Type
+  content-type: audio/webm
+  encoding: base64
+  extensions:
+  - webm
+  references:
+  - ! '{WebM=http://www.webmproject.org/code/specs/container/}'
+  registered: false
+- !ruby/object:MIME::Type
+  content-type: image/pjpeg
+  docs: Fixes a bug with IE6 and progressive JPEGs
+  encoding: base64
+  registered: false
+- !ruby/object:MIME::Type
+  content-type: application/1d-interleaved-parityfec
+  encoding: base64
+  references:
+  - IANA
+  - RFC6015
+  registered: true
+- !ruby/object:MIME::Type
+  content-type: audio/1d-interleaved-parityfec
+  encoding: base64
+  references:
+  - IANA
+  - RFC6015
+  registered: true
+- !ruby/object:MIME::Type
+  content-type: application/x-apple-diskimage
+  encoding: base64
+  extensions:
+  - dmg
+  registered: false
+  system: !ruby/regexp /mac/

data/test/minitest_helper.rb

@@ -0,0 +1,22 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'mime/type'
+require 'fileutils'
+
+gem 'minitest'
+require 'minitest/autorun'
+
+module MIME
+  @__deprecated = Hash.new { |h, k| h[k] = true }
+
+  class << self
+    attr_reader :__deprecated
+  end
+end
+
+def assert_deprecated(name, message = "and will be removed")
+  MIME.__deprecated[name] = false
+  assert_output(nil, /#{Regexp.escape(name)} is deprecated #{Regexp.escape(message)}./) { yield }
+ensure
+  MIME.__deprecated[name] = true
+end

data/test/test_mime_type.rb

@@ -1,46 +1,77 @@
 # -*- ruby encoding: utf-8 -*-
 
 require 'mime/types'
+require 'minitest_helper'
 
 class TestMIMEType < Minitest::Test
-  def yaml_mime_type_from_array
-    MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit', 'd9d172f608')
+  def make(content_type)
+    MIME::Type.new(content_type) { |mt| yield mt if block_given? }
+  end
+
+  def make_yaml_mime_type
+    make('text/x-yaml') do |yaml|
+      yaml.extensions = %w(yaml yml)
+      yaml.encoding   = '8bit'
+      yaml.system     = 'd9d172f608'
+    end
+  end
+
+  def make_yaml_mime_type_with_docs
+    make('text/x-yaml') do |yaml|
+      yaml.extensions = %w(yaml yml)
+      yaml.encoding   = '8bit'
+      yaml.system     = 'd9d172f608'
+      yaml.docs       = 'Test YAML'
+    end
   end
 
   def setup
-    @zip = MIME::Type.new('x-appl/x-zip') { |t| t.extensions = ['zip', 'zp'] }
+    @applzip = MIME::Type.new('x-appl/x-zip') { |t|
+      t.extensions = ['zip', 'zp']
+    }
   end
 
   def test_class_from_array
-    yaml = yaml_mime_type_from_array
+    yaml = nil
+    assert_deprecated("MIME::Type.from_array") do
+      yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
+                                   'd9d172f608')
+    end
     assert_instance_of(MIME::Type, yaml)
     assert_equal('text/yaml', yaml.simplified)
+    assert_raises(ArgumentError) { MIME::Type.from_array }
   end
 
   def test_class_from_hash
-    yaml = MIME::Type.from_hash('Content-Type' => 'text/x-yaml',
-                                'Content-Transfer-Encoding' => '8bit',
-                                'System' => 'd9d172f608',
-                                'Extensions' => %w(yaml yml))
+    yaml = nil
+    assert_deprecated("MIME::Type.from_hash") do
+      yaml = MIME::Type.from_hash('Content-Type' => 'text/x-yaml',
+                                  'Content-Transfer-Encoding' => '8bit',
+                                  'System' => 'd9d172f608',
+                                  'Extensions' => %w(yaml yml))
+    end
     assert_instance_of(MIME::Type, yaml)
     assert_equal('text/yaml', yaml.simplified)
   end
 
   def test_class_from_mime_type
-    zip2 = MIME::Type.from_mime_type(@zip)
-    assert_instance_of(MIME::Type, @zip)
-    assert_equal('appl/zip', @zip.simplified)
-    refute_equal(@zip.object_id, zip2.object_id)
+    zip2 = nil
+    assert_deprecated("MIME::Type.from_mime_type") do
+      zip2 = MIME::Type.from_mime_type(@applzip)
+    end
+    assert_instance_of(MIME::Type, @applzip)
+    assert_equal('appl/zip', @applzip.simplified)
+    refute_equal(@applzip.object_id, zip2.object_id)
   end
 
   def test_class_simplified
-    assert_equal(MIME::Type.simplified('text/plain'), 'text/plain')
-    assert_equal(MIME::Type.simplified('image/jpeg'), 'image/jpeg')
-    assert_equal(MIME::Type.simplified('application/x-msword'), 'application/msword')
-    assert_equal(MIME::Type.simplified('text/vCard'), 'text/vcard')
-    assert_equal(MIME::Type.simplified('application/pkcs7-mime'), 'application/pkcs7-mime')
-    assert_equal(@zip.simplified, 'appl/zip')
-    assert_equal(MIME::Type.simplified('x-xyz/abc'), 'xyz/abc')
+    assert_equal('text/plain', MIME::Type.simplified('text/plain'))
+    assert_equal('image/jpeg', MIME::Type.simplified('image/jpeg'))
+    assert_equal('application/msword', MIME::Type.simplified('application/x-msword'))
+    assert_equal('text/vcard', MIME::Type.simplified('text/vCard'))
+    assert_equal('application/pkcs7-mime', MIME::Type.simplified('application/pkcs7-mime'))
+    assert_equal('xyz/abc', MIME::Type.simplified('x-xyz/abc'))
+    assert_nil(MIME::Type.simplified('text'))
   end
 
   def test_CMP # '<=>'
@@ -63,7 +94,7 @@ class TestMIMEType < Minitest::Test
     refute(MIME::Type.new('application/x-msword').ascii?)
     assert(MIME::Type.new('text/vCard').ascii?)
     refute(MIME::Type.new('application/pkcs7-mime').ascii?)
-    refute(@zip.ascii?)
+    refute(@applzip.ascii?)
   end
 
   def test_binary_eh
@@ -72,52 +103,69 @@ class TestMIMEType < Minitest::Test
     assert(MIME::Type.new('application/x-msword').binary?)
     refute(MIME::Type.new('text/vCard').binary?)
     assert(MIME::Type.new('application/pkcs7-mime').binary?)
-    assert(@zip.binary?)
+    assert(@applzip.binary?)
   end
 
   def test_complete_eh
-    yaml = yaml_mime_type_from_array
+    yaml = make_yaml_mime_type
     assert(yaml.complete?)
     yaml.extensions = nil
     refute(yaml.complete?)
   end
 
   def test_content_type
-    assert_equal(MIME::Type.new('text/plain').content_type, 'text/plain')
-    assert_equal(MIME::Type.new('image/jpeg').content_type, 'image/jpeg')
-    assert_equal(MIME::Type.new('application/x-msword').content_type, 'application/x-msword')
-    assert_equal(MIME::Type.new('text/vCard').content_type, 'text/vCard')
-    assert_equal(MIME::Type.new('application/pkcs7-mime').content_type, 'application/pkcs7-mime')
-    assert_equal(@zip.content_type, 'x-appl/x-zip');
+    assert_equal('text/plain', MIME::Type.new('text/plain').content_type)
+    assert_equal('image/jpeg', MIME::Type.new('image/jpeg').content_type)
+    assert_equal('application/x-msword',
+                 MIME::Type.new('application/x-msword').content_type)
+    assert_equal('text/vCard', MIME::Type.new('text/vCard').content_type)
+    assert_equal('application/pkcs7-mime',
+                 MIME::Type.new('application/pkcs7-mime').content_type)
+    assert_equal('x-appl/x-zip', @applzip.content_type);
+    assert_equal('base64', @applzip.encoding)
   end
 
   def test_encoding
-    assert_equal(MIME::Type.new('text/plain').encoding, 'quoted-printable')
-    assert_equal(MIME::Type.new('image/jpeg').encoding, 'base64')
-    assert_equal(MIME::Type.new('application/x-msword').encoding, 'base64')
-    assert_equal(MIME::Type.new('text/vCard').encoding, 'quoted-printable')
-    assert_equal(MIME::Type.new('application/pkcs7-mime').encoding, 'base64')
-
-    yaml = yaml_mime_type_from_array
-    assert_equal(yaml.encoding, '8bit')
+    assert_equal('quoted-printable', MIME::Type.new('text/plain').encoding)
+    assert_equal('base64', MIME::Type.new('image/jpeg').encoding)
+    assert_equal('base64', MIME::Type.new('application/x-msword').encoding)
+    assert_equal('quoted-printable', MIME::Type.new('text/vCard').encoding)
+    assert_equal('base64', MIME::Type.new('application/pkcs7-mime').encoding)
+  end
+
+  def test_encoding_equals
+    yaml = make_yaml_mime_type
+    assert_equal('8bit', yaml.encoding)
     yaml.encoding = 'base64'
-    assert_equal(yaml.encoding, 'base64')
+    assert_equal('base64', yaml.encoding)
     yaml.encoding = :default
-    assert_equal(yaml.encoding, 'quoted-printable')
-    assert_raises(ArgumentError) { yaml.encoding = 'binary' }
-    assert_equal(@zip.encoding, 'base64')
+    assert_equal('quoted-printable', yaml.encoding)
+    begin
+      yaml.encoding = 'binary'
+    rescue MIME::Type::InvalidEncoding => ex
+      assert_equal('Invalid Encoding "binary" (valid values are [nil, :default, "base64", "8bit", "7bit", "quoted-printable"]).', ex.message)
+    end
   end
 
-  def _test_default_encoding
-    raise NotImplementedError, 'Need to write test_default_encoding'
+  def test_default_encoding
+    %w(text/plain text/html).each { |mt|
+      assert_equal('quoted-printable', MIME::Type.new(mt).default_encoding)
+    }
+    %w(image/jpeg applicatoin/pkcs7-mime).each { |mt|
+      assert_equal('base64', MIME::Type.new(mt).default_encoding)
+    }
   end
 
-  def _test_docs
-    raise NotImplementedError, 'Need to write test_docs'
+  def test_docs
+    yaml = make_yaml_mime_type_with_docs
+    assert_equal('Test YAML', yaml.docs)
   end
 
-  def _test_docs_equals
-    raise NotImplementedError, 'Need to write test_docs_equals'
+  def test_docs_equals
+    yaml = make_yaml_mime_type
+    assert_nil(yaml.docs)
+    yaml.docs = 'YAML docs'
+    assert_equal('YAML docs', yaml.docs)
   end
 
   def test_eql?
@@ -127,25 +175,30 @@ class TestMIMEType < Minitest::Test
     refute(MIME::Type.new('text/plain').eql?('image/jpeg'))
   end
 
-  def _test_encoding
-    raise NotImplementedError, 'Need to write test_encoding'
-  end
-
-  def _test_encoding_equals
-    raise NotImplementedError, 'Need to write test_encoding_equals'
-  end
-
   def test_extensions
-    yaml = yaml_mime_type_from_array
-    assert_equal(yaml.extensions, %w(yaml yml))
+    yaml = make_yaml_mime_type
+    assert_equal(%w(yaml yml), yaml.extensions)
+    assert_equal(2, @applzip.extensions.size)
+    assert_equal(%w(zip zp), @applzip.extensions)
+  end
+
+  def test_add_extensions
+    expected = make_yaml_mime_type
+    test_doc = make_yaml_mime_type
+    test_doc.add_extensions(nil)
+    assert_equal(expected.extensions, test_doc.extensions)
+    test_doc.add_extensions('yaml')
+    assert_equal(expected.extensions, test_doc.extensions)
+    test_doc.add_extensions(%w(yaml))
+    assert_equal(expected.extensions, test_doc.extensions)
+    test_doc.add_extensions('yz')
+    assert_equal(%w(yaml yml yz), test_doc.extensions)
+  end
+
+  def test_extensions_equals
+    yaml = make_yaml_mime_type
     yaml.extensions = 'yaml'
-    assert_equal(yaml.extensions, ['yaml'])
-    assert_equal(@zip.extensions.size, 2)
-    assert_equal(@zip.extensions, ['zip', 'zp'])
-  end
-
-  def _test_extensions_equals
-    raise NotImplementedError, 'Need to write test_extensions_equals'
+    assert_equal(%w(yaml), yaml.extensions)
   end
 
   def test_like_eh
@@ -158,50 +211,92 @@ class TestMIMEType < Minitest::Test
   end
 
   def test_media_type
-    assert_equal(MIME::Type.new('text/plain').media_type, 'text')
-    assert_equal(MIME::Type.new('image/jpeg').media_type, 'image')
-    assert_equal(MIME::Type.new('application/x-msword').media_type, 'application')
-    assert_equal(MIME::Type.new('text/vCard').media_type, 'text')
-    assert_equal(MIME::Type.new('application/pkcs7-mime').media_type, 'application')
-    assert_equal(MIME::Type.new('x-chemical/x-pdb').media_type, 'chemical')
-    assert_equal(@zip.media_type, 'appl')
+    assert_equal('text', MIME::Type.new('text/plain').media_type)
+    assert_equal('image', MIME::Type.new('image/jpeg').media_type)
+    assert_equal('application', MIME::Type.new('application/x-msword').media_type)
+    assert_equal('text', MIME::Type.new('text/vCard').media_type)
+    assert_equal('application', MIME::Type.new('application/pkcs7-mime').media_type)
+    assert_equal('chemical', MIME::Type.new('x-chemical/x-pdb').media_type)
+    assert_equal('appl', @applzip.media_type)
   end
 
-  def _test_obsolete_eh
-    raise NotImplementedError, 'Need to write test_obsolete_eh'
+  def test_obsolete_eh
+    type = MIME::Type.new('content-type' => 'test/type',
+                          'obsolete'     => true)
+    assert(type.obsolete?)
+    refute(make_yaml_mime_type.obsolete?)
   end
 
-  def _test_obsolete_equals
-    raise NotImplementedError, 'Need to write test_obsolete_equals'
+  def test_obsolete_equals
+    yaml = make_yaml_mime_type
+    refute(yaml.obsolete?)
+    yaml.obsolete = true
+    assert(yaml.obsolete?)
   end
 
   def test_platform_eh
-    yaml = yaml_mime_type_from_array
-    refute(yaml.platform?)
+    yaml = nil
+    assert_deprecated("MIME::Type#platform?") do
+      yaml = make_yaml_mime_type
+      refute(yaml.platform?)
+    end
     yaml.system = nil
     refute(yaml.platform?)
     yaml.system = %r{#{RUBY_PLATFORM}}
     assert(yaml.platform?)
   end
 
-  def test_raw_media_type
-    assert_equal(MIME::Type.new('text/plain').raw_media_type, 'text')
-    assert_equal(MIME::Type.new('image/jpeg').raw_media_type, 'image')
-    assert_equal(MIME::Type.new('application/x-msword').raw_media_type, 'application')
-    assert_equal(MIME::Type.new('text/vCard').raw_media_type, 'text')
-    assert_equal(MIME::Type.new('application/pkcs7-mime').raw_media_type, 'application')
+  def assert_priority(l, e, r)
+    assert_equal(-1, l.first.priority_compare(l.last))
+    assert_equal(0, e.first.priority_compare(e.last))
+    assert_equal(1, r.first.priority_compare(r.last))
+  end
+
+  def test_priority_compare
+    tl, te, tr = make('text/1'), make('text/1'), make('text/2')
+    assert_priority([tl, tr], [tl, te], [tr, tl])
+
+    tl.registered = te.registered = true
+    tr = make(tl) { |t| t.registered = false }
+    assert_priority([tl, tr], [tl, te], [tr, tl])
 
-    assert_equal(MIME::Type.new('x-chemical/x-pdb').raw_media_type, 'x-chemical')
-    assert_equal(@zip.raw_media_type, 'x-appl')
+    tl.system = te.system = nil
+    tr = make(tl) { |t| t.system = /#{RUBY_PLATFORM}/ }
+    assert_priority([tl, tr], [tl, te], [tr, tl])
+
+    tl.extensions = te.extensions = %w(1)
+    tr = make(tl) { |t| t.extensions = nil }
+    assert_priority([tl, tr], [tl, te], [tr, tl])
+
+    tl.obsolete = te.obsolete = false
+    tr = make(tl) { |t| t.obsolete = true }
+    assert_priority([tl, tr], [tl, te], [tr, tl])
+
+    tl.obsolete = te.obsolete = true
+    tl.use_instead = te.use_instead = 'abc/xyz'
+    tr = make(tl) { |t| t.use_instead = nil }
+    assert_priority([tl, tr], [tl, te], [tr, tl])
+    tr.use_instead = 'abc/zzz'
+    assert_priority([tl, tr], [tl, te], [tr, tl])
+  end
+
+  def test_raw_media_type
+    assert_equal('text', MIME::Type.new('text/plain').raw_media_type)
+    assert_equal('image', MIME::Type.new('image/jpeg').raw_media_type)
+    assert_equal('application', MIME::Type.new('application/x-msword').raw_media_type)
+    assert_equal('text', MIME::Type.new('text/vCard').raw_media_type)
+    assert_equal('application', MIME::Type.new('application/pkcs7-mime').raw_media_type)
+    assert_equal('x-chemical', MIME::Type.new('x-chemical/x-pdb').raw_media_type)
+    assert_equal('x-appl', @applzip.raw_media_type)
   end
 
   def test_raw_sub_type
-    assert_equal(MIME::Type.new('text/plain').raw_sub_type, 'plain')
-    assert_equal(MIME::Type.new('image/jpeg').raw_sub_type, 'jpeg')
-    assert_equal(MIME::Type.new('application/x-msword').raw_sub_type, 'x-msword')
-    assert_equal(MIME::Type.new('text/vCard').raw_sub_type, 'vCard')
-    assert_equal(MIME::Type.new('application/pkcs7-mime').raw_sub_type, 'pkcs7-mime')
-    assert_equal(@zip.raw_sub_type, 'x-zip')
+    assert_equal('plain', MIME::Type.new('text/plain').raw_sub_type)
+    assert_equal('jpeg', MIME::Type.new('image/jpeg').raw_sub_type)
+    assert_equal('x-msword', MIME::Type.new('application/x-msword').raw_sub_type)
+    assert_equal('vCard', MIME::Type.new('text/vCard').raw_sub_type)
+    assert_equal('pkcs7-mime', MIME::Type.new('application/pkcs7-mime').raw_sub_type)
+    assert_equal('x-zip', @applzip.raw_sub_type)
   end
 
   def test_registered_eh
@@ -210,107 +305,206 @@ class TestMIMEType < Minitest::Test
     refute(MIME::Type.new('application/x-msword').registered?)
     assert(MIME::Type.new('text/vCard').registered?)
     assert(MIME::Type.new('application/pkcs7-mime').registered?)
-    refute(@zip.registered?)
+    refute(@applzip.registered?)
+    refute(MIME::Types['image/webp'].first.registered?)
+    # Temporarily broken: requires the new data format to be enabled.
+    assert(MIME::Types['application/x-www-form-urlencoded'].first.registered?)
   end
 
-  def _test_registered_equals
-    raise NotImplementedError, 'Need to write test_registered_equals'
+  def test_registered_equals
+    [ nil, false, true ].each { |v|
+      @applzip.registered = v
+      assert_equal(v, @applzip.instance_variable_get(:@registered))
+    }
+    @applzip.registered = 1
+    assert_equal(true, @applzip.instance_variable_get(:@registered))
   end
 
   def test_signature_eh
     refute(MIME::Type.new('text/plain').signature?)
     refute(MIME::Type.new('image/jpeg').signature?)
     refute(MIME::Type.new('application/x-msword').signature?)
-    assert(MIME::Type.new('text/vCard').signature?)
-    assert(MIME::Type.new('application/pkcs7-mime').signature?)
+  end
+
+  def test_signature_equals
+    sig = MIME::Type.new('text/vCard') { |t| t.signature = true }
+    assert(sig.signature?)
   end
 
   def test_simplified
-    assert_equal(MIME::Type.new('text/plain').simplified, 'text/plain')
-    assert_equal(MIME::Type.new('image/jpeg').simplified, 'image/jpeg')
-    assert_equal(MIME::Type.new('application/x-msword').simplified, 'application/msword')
-    assert_equal(MIME::Type.new('text/vCard').simplified, 'text/vcard')
-    assert_equal(MIME::Type.new('application/pkcs7-mime').simplified, 'application/pkcs7-mime')
-    assert_equal(MIME::Type.new('x-chemical/x-pdb').simplified, 'chemical/pdb')
+    assert_equal('text/plain', MIME::Type.new('text/plain').simplified)
+    assert_equal('image/jpeg', MIME::Type.new('image/jpeg').simplified)
+    assert_equal('application/msword', MIME::Type.new('application/x-msword').simplified)
+    assert_equal('text/vcard', MIME::Type.new('text/vCard').simplified)
+    assert_equal('application/pkcs7-mime', MIME::Type.new('application/pkcs7-mime').simplified)
+    assert_equal('chemical/pdb', MIME::Type.new('x-chemical/x-pdb').simplified)
   end
 
   def test_sub_type
-    assert_equal(MIME::Type.new('text/plain').sub_type, 'plain')
-    assert_equal(MIME::Type.new('image/jpeg').sub_type, 'jpeg')
-    assert_equal(MIME::Type.new('application/x-msword').sub_type, 'msword')
-    assert_equal(MIME::Type.new('text/vCard').sub_type, 'vcard')
-    assert_equal(MIME::Type.new('application/pkcs7-mime').sub_type, 'pkcs7-mime')
-    assert_equal(@zip.sub_type, 'zip')
+    assert_equal('plain', MIME::Type.new('text/plain').sub_type)
+    assert_equal('jpeg', MIME::Type.new('image/jpeg').sub_type)
+    assert_equal('msword', MIME::Type.new('application/x-msword').sub_type)
+    assert_equal('vcard', MIME::Type.new('text/vCard').sub_type)
+    assert_equal('pkcs7-mime', MIME::Type.new('application/pkcs7-mime').sub_type)
+    assert_equal('zip', @applzip.sub_type)
+  end
+
+  def test_system
+    assert_deprecated("MIME::Type#system") do
+      yaml = make_yaml_mime_type
+      assert_equal(%r{d9d172f608}, yaml.system)
+    end
   end
 
   def test_system_equals
-    yaml = yaml_mime_type_from_array
-    assert_equal(yaml.system, %r{d9d172f608})
+    yaml = make_yaml_mime_type
     yaml.system = /win32/
-    assert_equal(yaml.system, %r{win32})
+    assert_equal(%r{win32}, yaml.system)
     yaml.system = nil
     assert_nil(yaml.system)
   end
 
   def test_system_eh
-    yaml = yaml_mime_type_from_array
-    assert(yaml.system?)
+    yaml = make_yaml_mime_type
+    assert_deprecated("MIME::Type#system?") do
+      assert(yaml.system?)
+    end
     yaml.system = nil
     refute(yaml.system?)
   end
 
   def test_to_a
-    yaml = yaml_mime_type_from_array
-    assert_equal(yaml.to_a, ['text/x-yaml', %w(yaml yml), '8bit',
-                 /d9d172f608/, nil, nil, nil, false])
+    yaml = make_yaml_mime_type
+    assert_deprecated("MIME::Type#to_a") do
+      assert_equal(['text/x-yaml', %w(yaml yml), '8bit', /d9d172f608/,
+                    false, nil, [], false], yaml.to_a)
+    end
   end
 
   def test_to_hash
-    yaml = yaml_mime_type_from_array
-    assert_equal(yaml.to_hash,
-                 { 'Content-Type' => 'text/x-yaml',
+    yaml = make_yaml_mime_type
+    assert_deprecated("MIME::Type#to_hash") do
+      assert_equal({'Content-Type'              => 'text/x-yaml',
                     'Content-Transfer-Encoding' => '8bit',
-                    'Extensions' => %w(yaml yml),
-                    'System' => /d9d172f608/,
-                    'Registered' => false,
-                    'URL' => nil,
-                    'Obsolete' => nil,
-                    'Docs' => nil })
+                    'Extensions'                => %w(yaml yml),
+                    'System'                    => /d9d172f608/,
+                    'Registered'                => false,
+                    'URL'                       => [],
+                    'Obsolete'                  => false,
+                    'Docs'                      => nil },
+                    yaml.to_hash)
+    end
+  end
+
+  def assert_type_has_keys(type, *keys)
+    hash = type.to_h
+    keys.flatten.each { |key| assert(hash.has_key?(key)) }
+  end
+
+  def test_to_h
+    t = make('a/b')
+    assert_type_has_keys(t, %w(content-type registered encoding))
+    assert_type_has_keys(make(t) { |v| v.docs = 'Something' }, 'docs')
+    assert_type_has_keys(make(t) { |v| v.extensions = %w(b) }, 'extensions')
+    assert_type_has_keys(make(t) { |v| v.obsolete = true }, 'obsolete')
+    assert_type_has_keys(make(t) { |v| v.obsolete = true; v.use_instead = 'c/d' },
+                         'obsolete', 'use-instead')
+    assert_type_has_keys(make(t) { |v| v.references = 'IANA' }, 'references')
+    assert_type_has_keys(make(t) { |v| v.signature = true }, 'signature')
+    assert_type_has_keys(make(t) { |v| v.system = /xyz/ }, 'system')
+  end
+
+  def test_to_json
+    assert_equal('{"content-type":"a/b","encoding":"base64","registered":true}',
+                 make('a/b').to_json)
   end
 
   def test_to_s
-    assert_equal("#{MIME::Type.new('text/plain')}", 'text/plain')
+    assert_equal('text/plain', "#{MIME::Type.new('text/plain')}")
   end
 
   def test_class_constructors
-    refute_nil(@zip)
-    yaml = MIME::Type.new('text/x-yaml') do |y|
-      y.extensions = %w(yaml yml)
-      y.encoding = '8bit'
-      y.system = 'd9d172f608'
+    assert_instance_of(MIME::Type, MIME::Type.new('text/x-yaml'))
+    assert_instance_of(MIME::Type, MIME::Type.new('text/x-yaml') { |y|
+      assert_instance_of(MIME::Type, y)
+    })
+    assert_instance_of(MIME::Type, MIME::Type.new('content-type' => 'text/x-yaml'))
+    assert_instance_of(MIME::Type, MIME::Type.new(['text/x-yaml', %w(yaml)]))
+    assert_raises(MIME::Type::InvalidContentType) { MIME::Type.new('apps') }
+    begin
+      MIME::Type.new(nil)
+    rescue MIME::Type::InvalidContentType => ex
+      assert_equal("Invalid Content-Type nil", ex.message)
     end
-    assert_instance_of(MIME::Type, yaml)
-    assert_raises(MIME::InvalidContentType) { MIME::Type.new('apps') }
-    assert_raises(MIME::InvalidContentType) { MIME::Type.new(nil) }
   end
 
-  def _test_to_str
-    raise NotImplementedError, 'Need to write test_to_str'
+  def test_to_str
+    assert_equal('stringy', 'text/plain'.sub(MIME::Type.new('text/plain'), 'stringy'))
   end
 
-  def _test_url
-    raise NotImplementedError, 'Need to write test_url'
+  def test_references
+    assert_empty(make_yaml_mime_type.references)
   end
 
-  def _test_url_equals
-    raise NotImplementedError, 'Need to write test_url_equals'
+  def test_references_equals
+    yaml = make_yaml_mime_type
+    yaml.references = "IANA"
+    assert_equal(%W(IANA), yaml.references)
   end
 
-  def _test_urls
-    raise NotImplementedError, 'Need to write test_urls'
+  def test_url
+    assert_deprecated("MIME::Type#url", "and has been renamed to #references") do
+      assert_empty(make_yaml_mime_type.url)
+    end
   end
 
-  def __test_use_instead
-    raise NotImplementedError, 'Need to write test_use_instead'
+  def test_url_equals
+    yaml = make_yaml_mime_type
+    assert_deprecated("MIME::Type#url=", "and has been renamed to #references=") do
+      yaml.url = "IANA"
+    end
+    assert_equal(%W(IANA), yaml.url)
+  end
+
+  def test_urls
+    yaml = make_yaml_mime_type
+    assert_empty(yaml.urls)
+    yaml.references = %w(IANA RFC123 DRAFT:xyz LTSW [abc])
+    assert_equal(%w(http://www.iana.org/assignments/media-types/text/yaml
+                    http://rfc-editor.org/rfc/rfc123.txt
+                    http://datatracker.ietf.org/public/idindex.cgi?command=id_details&filename=xyz
+                    http://www.ltsw.se/knbase/internet/text.htp
+                    http://www.iana.org/assignments/contact-people.htm#abc),
+                 yaml.urls)
+    yaml.references = '[def=lax]'
+    assert_equal([%w(def http://www.iana.org/assignments/contact-people.htm#lax)],
+                 yaml.urls)
+    yaml.references = '{mno=pqr}'
+    assert_equal([%w(mno pqr)], yaml.urls)
+    yaml.references = 'hoge'
+    assert_equal(%w(hoge), yaml.urls)
+  end
+
+  def test_use_instead
+    t = make('t/1') { |v| v.use_instead = 't/2' }
+    assert_nil(t.use_instead)
+    t.obsolete = true
+    assert_equal('t/2', t.use_instead)
+  end
+
+  def test_use_instead_equals
+    t = make('t/1') { |v| v.obsolete = true }
+    assert_nil(t.use_instead)
+    t.use_instead = 't/2'
+    assert_equal('t/2', t.use_instead)
+  end
+
+  def test_deprecated_constant
+    assert_output(nil, /MIME::InvalidContentType/) do
+      assert_same(MIME::InvalidContentType, MIME::Type::InvalidContentType)
+    end
+    assert_silent do
+      assert_same(MIME::InvalidContentType, MIME::Type::InvalidContentType)
+    end
   end
 end