mime-types 1.16 → 1.17

data/lib/mime/types/text

@@ -0,0 +1,54 @@
+text/1d-interleaved-parityfec 'IANA,RFC6015
+text/RED 'IANA,RFC4102
+text/calendar 'IANA,RFC5545
+text/css @css :8bit 'IANA,RFC2318
+text/csv @csv :8bit 'IANA,RFC4180
+text/dns 'IANA,RFC4027
+text/enriched 'IANA,RFC1896
+text/example 'IANA,RFC4735
+text/fwdred 'IANA,RFC6354
+text/html @html,htm,htmlx,shtml,htx :8bit 'IANA,RFC2854
+text/n3 'IANA,[Prud'hommeaux=Prudhommeaux],[W3C]
+text/parityfec 'IANA,RFC5109
+text/plain @txt,asc,c,cc,h,hh,cpp,hpp,dat,hlp 'IANA,RFC2046,RFC3676,RFC5147
+text/prs.fallenstein.rst @rst 'IANA,[Fallenstein]
+text/prs.lines.tag 'IANA,[Lines]
+text/rfc822-headers 'IANA,RFC3462
+text/richtext @rtx :8bit 'IANA,RFC2045,RFC2046
+text/rtf @rtf :8bit 'IANA,[Lindner]
+text/rtp-enc-aescm128 'IANA,[3GPP]
+text/rtx 'IANA,RFC4588
+text/sgml @sgml,sgm 'IANA,RFC1874
+text/t140 'IANA,RFC4103
+text/tab-separated-values @tsv 'IANA,[Lindner]
+text/troff @t,tr,roff,troff :8bit 'IANA,RFC4263
+text/turtle 'IANA,[Prud'hommeaux=Prudhommeaux],[W3C]
+text/ulpfec 'IANA,RFC5109
+text/uri-list 'IANA,RFC2483
+text/vcard 'IANA,RFC6350
+text/vnd.DMClientScript 'IANA,[Bradley]
+text/vnd.IPTC.NITF 'IANA,[IPTC]
+text/vnd.IPTC.NewsML 'IANA,[IPTC]
+text/vnd.abc 'IANA,[Allen]
+text/vnd.curl 'IANA,[Byrnes]
+text/vnd.dvb.subtitle 'IANA,[Siebert],[Lagally]
+text/vnd.esmertec.theme-descriptor 'IANA,[Eilemann]
+text/vnd.fly 'IANA,[Gurney]
+text/vnd.fmi.flexstor 'IANA,[Hurtta]
+text/vnd.graphviz 'IANA,[Ellson]
+text/vnd.in3d.3dml 'IANA,[Powers]
+text/vnd.in3d.spot 'IANA,[Powers]
+text/vnd.latex-z 'IANA,[Lubos]
+text/vnd.motorola.reflex 'IANA,[Patton]
+text/vnd.ms-mediapackage 'IANA,[Nelson]
+text/vnd.net2phone.commcenter.command @ccc 'IANA,[Xie]
+text/vnd.radisys.msml-basic-layout 'IANA,RFC5707
+text/vnd.si.uricatalogue 'IANA,[Parks Young=ParksYoung]
+text/vnd.sun.j2me.app-descriptor @jad :8bit 'IANA,[G.Adams]
+text/vnd.trolltech.linguist 'IANA,[D.Lambert]
+text/vnd.wap.si @si 'IANA,[WAP-Forum]
+text/vnd.wap.sl @sl 'IANA,[WAP-Forum]
+text/vnd.wap.wml @wml 'IANA,[Stark]
+text/vnd.wap.wmlscript @wmls 'IANA,[Stark]
+text/xml @xml,dtd :8bit 'IANA,RFC3023
+text/xml-external-parsed-entity 'IANA,RFC3023

data/lib/mime/types/text.nonstandard

@@ -0,0 +1,5 @@
+text/x-component @htc :8bit
+text/x-setext @etx
+text/x-vcalendar @vcs :8bit
+text/x-vcard @vcf :8bit
+text/x-yaml @yaml,yml :8bit

data/lib/mime/types/text.obsolete

@@ -0,0 +1,7 @@
+!text/directory 'IANA,RFC2425,RFC6350
+!text/ecmascript 'IANA,RFC4329
+!text/javascript 'IANA,RFC4329
+!text/x-rtf @rtf :8bit =use-instead:text/rtf
+!text/x-vnd.flatland.3dml =use-instead:model/vnd.flatland.3dml
+*!text/comma-separated-values @csv :8bit =use-instead:text/csv
+*!text/vnd.flatland.3dml =use-instead:model/vnd.flatland.3dml

data/lib/mime/types/text.vms

@@ -0,0 +1 @@
+vms:text/plain @doc :8bit

data/lib/mime/types/video

@@ -0,0 +1,68 @@
+video/1d-interleaved-parityfec 'IANA,RFC6015
+video/3gpp @3gp,3gpp 'IANA,RFC3839,RFC6381
+video/3gpp-tt 'IANA,RFC4396
+video/3gpp2 'IANA,RFC4393,RFC6381
+video/BMPEG 'IANA,RFC3555
+video/BT656 'IANA,RFC3555
+video/CelB 'IANA,RFC3555
+video/DV 'IANA,RFC3189
+video/H261 'IANA,RFC4587
+video/H263 'IANA,RFC3555
+video/H263-1998 'IANA,RFC4629
+video/H263-2000 'IANA,RFC4629
+video/H264 'IANA,RFC6184
+video/H264-RCDO 'IANA,RFC6185
+video/H264-SVC 'IANA,RFC6190
+video/JPEG 'IANA,RFC3555
+video/MJ2 @mj2,mjp2 'IANA,RFC3745
+video/MP1S 'IANA,RFC3555
+video/MP2P 'IANA,RFC3555
+video/MP2T 'IANA,RFC3555
+video/MP4V-ES 'IANA,RFC6416
+video/MPV 'IANA,RFC3555
+video/SMPTE292M 'IANA,RFC3497
+video/example 'IANA,RFC4735
+video/jpeg2000 'IANA,RFC5371,RFC5372
+video/mp4 @mp4,mpg4 'IANA,RFC4337,RFC6381
+video/mpeg @mp2,mpe,mp3g,mpg :base64 'IANA,RFC2045,RFC2046
+video/mpeg4-generic 'IANA,RFC3640
+video/nv 'IANA,RFC4856
+video/ogg @ogv 'IANA,RFC5334
+video/parityfec 'IANA,RFC5109
+video/pointer 'IANA,RFC2862
+video/quicktime @qt,mov :base64 'IANA,[Lindner]
+video/raw 'IANA,RFC4175
+video/rtp-enc-aescm128 'IANA,[3GPP]
+video/rtx 'IANA,RFC4588
+video/ulpfec 'IANA,RFC5109
+video/vc1 'IANA,RFC4425
+video/vnd.CCTV 'IANA,[Rottmann]
+video/vnd.dece.hd 'IANA,[Dolan]
+video/vnd.dece.mobile 'IANA,[Dolan]
+video/vnd.dece.mp4 'IANA,[Dolan]
+video/vnd.dece.pd 'IANA,[Dolan]
+video/vnd.dece.sd 'IANA,[Dolan]
+video/vnd.dece.video 'IANA,[Dolan]
+video/vnd.directv.mpeg 'IANA,[Zerbe]
+video/vnd.dvb.file 'IANA,[Siebert],[Murray]
+video/vnd.fvt 'IANA,[Fuldseth]
+video/vnd.hns.video 'IANA,[Swaminathan]
+video/vnd.iptvforum.1dparityfec-1010 'IANA,[Nakamura]
+video/vnd.iptvforum.1dparityfec-2005 'IANA,[Nakamura]
+video/vnd.iptvforum.2dparityfec-1010 'IANA,[Nakamura]
+video/vnd.iptvforum.2dparityfec-2005 'IANA,[Nakamura]
+video/vnd.iptvforum.ttsavc 'IANA,[Nakamura]
+video/vnd.iptvforum.ttsmpeg2 'IANA,[Nakamura]
+video/vnd.motorola.video 'IANA,[McGinty]
+video/vnd.motorola.videop 'IANA,[McGinty]
+video/vnd.mpegurl @mxu,m4u :8bit 'IANA,[Recktenwald]
+video/vnd.ms-playready.media.pyv 'IANA,[DiAcetis]
+video/vnd.nokia.interleaved-multimedia @nim 'IANA,[Kangaslampi]
+video/vnd.nokia.videovoip 'IANA,[Nokia]
+video/vnd.objectvideo @mp4 'IANA,[Clark]
+video/vnd.sealed.mpeg1 @s11 'IANA,[Petersen]
+video/vnd.sealed.mpeg4 @smpg,s14 'IANA,[Petersen]
+video/vnd.sealed.swf @sswf,ssw 'IANA,[Petersen]
+video/vnd.sealedmedia.softseal.mov @smov,smo,s1q 'IANA,[Petersen]
+video/vnd.uvvu.mp4 'IANA,[Dolan]
+video/vnd.vivo @viv,vivo 'IANA,[Wolfe]

data/lib/mime/types/video.nonstandard

@@ -0,0 +1,11 @@
+video/x-dl @dl :base64
+video/x-fli @fli :base64
+video/x-flv @flv :base64
+video/x-gl @gl :base64
+video/x-ms-asf @asf,asx
+video/x-ms-wm @wm
+video/x-ms-wmv @wmv
+video/x-ms-wmx @wmx
+video/x-ms-wvx @wvx
+video/x-msvideo @avi :base64
+video/x-sgi-movie @movie :base64

data/lib/mime/types/video.obsolete

@@ -0,0 +1,3 @@
+*!video/dl @dl :base64 =use-instead:video/x-dl
+*!video/gl @gl :base64 =use-instead:video/x-gl
+*!video/vnd.dlna.mpeg-tts 'IANA,[Heredia]

data/mime-types.gemspec

@@ -1,43 +1,57 @@
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = %q{mime-types}
-  s.version = "1.16"
+  s.name = "mime-types"
+  s.version = "1.16.20111022003230"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Austin Ziegler"]
-  s.cert_chain = ["/Users/austin/.gem/gem-public_cert.pem"]
-  s.date = %q{2009-03-01}
-  s.description = %q{MIME::Types for Ruby originally based on and synchronized with MIME::Types for Perl by Mark Overmeer, copyright 2001 - 2009. As of version 1.15, the data format for the MIME::Type list has changed and the synchronization will no longer happen.}
+  s.date = "2011-10-22"
+  s.description = "This library allows for the identification of a file's likely MIME content\ntype. This is release 1.17. The identification of MIME content type is based\non a file's filename extensions.\n\nMIME::Types for Ruby originally based on and synchronized with MIME::Types for\nPerl by Mark Overmeer, copyright 2001 - 2009. As of version 1.15, the data\nformat for the MIME::Type list has changed and the synchronization will no\nlonger happen.\n\nHomepage::  http://mime-types.rubyforge.org/\nCopyright:: 2002 - 2011, Austin Ziegler\n            Based in part on prior work copyright Mark Overmeer\n\n:include: License.rdoc"
   s.email = ["austin@rubyforge.org"]
-  s.extra_rdoc_files = ["History.txt", "Install.txt", "Licence.txt", "README.txt"]
-  s.files = ["History.txt", "Install.txt", "Licence.txt", "Manifest.txt", "README.txt", "Rakefile", "lib/mime/types.rb", "lib/mime/types.rb.data", "setup.rb", "test/test_mime_type.rb", "test/test_mime_types.rb"]
-  s.has_rdoc = true
-  s.homepage = %q{http://mime-types.rubyforge.org/}
-  s.rdoc_options = ["--main", "README.txt"]
+  s.extra_rdoc_files = ["History.txt", "Install.txt", "Licence.txt", "Manifest.txt", "README.txt", "History.rdoc", "Licence.rdoc", "README.rdoc"]
+  s.files = ["History.txt", "Install.txt", "Licence.txt", "Manifest.txt", "README.txt", "Rakefile", "lib/mime/types.rb", "lib/mime/types.rb.data", "mime-types.gemspec", "setup.rb", "test/test_mime_type.rb", "test/test_mime_types.rb", "History.rdoc", "Licence.rdoc", "README.rdoc", ".gemtest"]
+  s.homepage = "http://mime-types.rubyforge.org/"
+  s.rdoc_options = ["--main", "README.rdoc"]
   s.require_paths = ["lib"]
-  s.rubyforge_project = %q{mime-types}
-  s.rubygems_version = %q{1.3.1}
-  s.signing_key = %q{/Users/austin/.gem/gem-private_key.pem}
-  s.summary = %q{Manages a MIME Content-Type database that will return the Content-Type for a given filename.}
+  s.rubyforge_project = "mime-types"
+  s.rubygems_version = "1.8.10"
+  s.summary = "This library allows for the identification of a file's likely MIME content type"
   s.test_files = ["test/test_mime_type.rb", "test/test_mime_types.rb"]
 
   if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 2
+    s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<archive-tar-minitar>, ["~> 0.5.1"])
-      s.add_development_dependency(%q<nokogiri>, ["~> 1.2.1"])
-      s.add_development_dependency(%q<hoe>, [">= 1.8.3"])
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rubyforge>, [">= 2.0.4"])
+      s.add_development_dependency(%q<minitest>, [">= 2.6.2"])
+      s.add_development_dependency(%q<nokogiri>, ["~> 1.2"])
+      s.add_development_dependency(%q<minitest>, ["~> 2.0"])
+      s.add_development_dependency(%q<hoe-doofus>, ["~> 1.0"])
+      s.add_development_dependency(%q<hoe-gemspec>, ["~> 1.0"])
+      s.add_development_dependency(%q<hoe-git>, ["~> 1.0"])
+      s.add_development_dependency(%q<hoe-seattlerb>, ["~> 1.0"])
+      s.add_development_dependency(%q<hoe>, ["~> 2.12"])
     else
-      s.add_dependency(%q<archive-tar-minitar>, ["~> 0.5.1"])
-      s.add_dependency(%q<nokogiri>, ["~> 1.2.1"])
-      s.add_dependency(%q<hoe>, [">= 1.8.3"])
+      s.add_dependency(%q<rubyforge>, [">= 2.0.4"])
+      s.add_dependency(%q<minitest>, [">= 2.6.2"])
+      s.add_dependency(%q<nokogiri>, ["~> 1.2"])
+      s.add_dependency(%q<minitest>, ["~> 2.0"])
+      s.add_dependency(%q<hoe-doofus>, ["~> 1.0"])
+      s.add_dependency(%q<hoe-gemspec>, ["~> 1.0"])
+      s.add_dependency(%q<hoe-git>, ["~> 1.0"])
+      s.add_dependency(%q<hoe-seattlerb>, ["~> 1.0"])
+      s.add_dependency(%q<hoe>, ["~> 2.12"])
     end
   else
-    s.add_dependency(%q<archive-tar-minitar>, ["~> 0.5.1"])
-    s.add_dependency(%q<nokogiri>, ["~> 1.2.1"])
-    s.add_dependency(%q<hoe>, [">= 1.8.3"])
+    s.add_dependency(%q<rubyforge>, [">= 2.0.4"])
+    s.add_dependency(%q<minitest>, [">= 2.6.2"])
+    s.add_dependency(%q<nokogiri>, ["~> 1.2"])
+    s.add_dependency(%q<minitest>, ["~> 2.0"])
+    s.add_dependency(%q<hoe-doofus>, ["~> 1.0"])
+    s.add_dependency(%q<hoe-gemspec>, ["~> 1.0"])
+    s.add_dependency(%q<hoe-git>, ["~> 1.0"])
+    s.add_dependency(%q<hoe-seattlerb>, ["~> 1.0"])
+    s.add_dependency(%q<hoe>, ["~> 2.12"])
   end
 end

data/test/test_mime_type.rb

@@ -1,313 +1,276 @@
-#! /usr/bin/env ruby
-#--
-# MIME::Types
-# A Ruby implementation of a MIME Types information library. Based in spirit
-# on the Perl MIME::Types information library by Mark Overmeer.
-# http://rubyforge.org/projects/mime-types/
-#
-# Licensed under the Ruby disjunctive licence with the GNU GPL or the Perl
-# Artistic licence. See Licence.txt for more information.
-#
-# Copyright 2003 - 2009 Austin Ziegler
-#++
 $LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib") if __FILE__ == $0
 
 require 'mime/types'
-require 'test/unit' unless defined? $ZENTEST and $ZENTEST
+require 'minitest/autorun'
+#require 'test/unit' unless defined? $ZENTEST and $ZENTEST
 
-module TestMIME
-  class TestType < Test::Unit::TestCase #:nodoc:
-    def setup
-      @zip = MIME::Type.new('x-appl/x-zip') { |t| t.extensions = ['zip', 'zp'] }
-    end
+class TestMIME_Type < MiniTest::Unit::TestCase
+  def yaml_mime_type_from_array
+    yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit', 'linux')
+  end
 
-    def test_class_from_array
-      assert_nothing_raised do
-        @yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit', 'linux')
-      end
-      assert_instance_of(MIME::Type, @yaml)
-      assert_equal('text/yaml', @yaml.simplified)
-    end
+  def setup
+    @zip = MIME::Type.new('x-appl/x-zip') { |t| t.extensions = ['zip', 'zp'] }
+  end
 
-    def test_class_from_hash
-      assert_nothing_raised do
-        @yaml = MIME::Type.from_hash('Content-Type' => 'text/x-yaml',
-                                   'Content-Transfer-Encoding' => '8bit',
-                                   'System' => 'linux',
-                                   'Extensions' => %w(yaml yml))
-      end
-      assert_instance_of(MIME::Type, @yaml)
-      assert_equal('text/yaml', @yaml.simplified)
-    end
+  def test_class_from_array
+    yaml = yaml_mime_type_from_array
+    assert_instance_of(MIME::Type, yaml)
+    assert_equal('text/yaml', yaml.simplified)
+  end
 
-    def test_class_from_mime_type
-      assert_nothing_raised do
-        @zip2 = MIME::Type.from_mime_type(@zip)
-      end
-      assert_instance_of(MIME::Type, @zip)
-      assert_equal('appl/zip', @zip.simplified)
-      assert_not_equal(@zip.object_id, @zip2.object_id)
-    end
+  def test_class_from_hash
+    yaml = MIME::Type.from_hash('Content-Type' => 'text/x-yaml',
+                                'Content-Transfer-Encoding' => '8bit',
+                                'System' => 'linux',
+                                'Extensions' => %w(yaml yml))
+    assert_instance_of(MIME::Type, yaml)
+    assert_equal('text/yaml', yaml.simplified)
+  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')
-    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)
+  end
 
-    def test_CMP # '<=>'
-      assert(MIME::Type.new('text/plain') == MIME::Type.new('text/plain'))
-      assert(MIME::Type.new('text/plain') != MIME::Type.new('image/jpeg'))
-      assert(MIME::Type.new('text/plain') == 'text/plain')
-      assert(MIME::Type.new('text/plain') != 'image/jpeg')
-      assert(MIME::Type.new('text/plain') > MIME::Type.new('text/html'))
-      assert(MIME::Type.new('text/plain') > 'text/html')
-      assert(MIME::Type.new('text/html') < MIME::Type.new('text/plain'))
-      assert(MIME::Type.new('text/html') < 'text/plain')
-      assert('text/html' == MIME::Type.new('text/html'))
-      assert('text/html' < MIME::Type.new('text/plain'))
-      assert('text/plain' > MIME::Type.new('text/html'))
-    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')
+  end
 
-    def test_ascii_eh
-      assert(MIME::Type.new('text/plain').ascii?)
-      assert(!MIME::Type.new('image/jpeg').ascii?)
-      assert(!MIME::Type.new('application/x-msword').ascii?)
-      assert(MIME::Type.new('text/vCard').ascii?)
-      assert(!MIME::Type.new('application/pkcs7-mime').ascii?)
-      assert(!@zip.ascii?)
-    end
+  def test_CMP # '<=>'
+    assert(MIME::Type.new('text/plain') == MIME::Type.new('text/plain'))
+    assert(MIME::Type.new('text/plain') != MIME::Type.new('image/jpeg'))
+    assert(MIME::Type.new('text/plain') == 'text/plain')
+    assert(MIME::Type.new('text/plain') != 'image/jpeg')
+    assert(MIME::Type.new('text/plain') > MIME::Type.new('text/html'))
+    assert(MIME::Type.new('text/plain') > 'text/html')
+    assert(MIME::Type.new('text/html') < MIME::Type.new('text/plain'))
+    assert(MIME::Type.new('text/html') < 'text/plain')
+    assert('text/html' == MIME::Type.new('text/html'))
+    assert('text/html' < MIME::Type.new('text/plain'))
+    assert('text/plain' > MIME::Type.new('text/html'))
+  end
 
-    def test_binary_eh
-      assert(!MIME::Type.new('text/plain').binary?)
-      assert(MIME::Type.new('image/jpeg').binary?)
-      assert(MIME::Type.new('application/x-msword').binary?)
-      assert(!MIME::Type.new('text/vCard').binary?)
-      assert(MIME::Type.new('application/pkcs7-mime').binary?)
-      assert(@zip.binary?)
-    end
+  def test_ascii_eh
+    assert(MIME::Type.new('text/plain').ascii?)
+    refute(MIME::Type.new('image/jpeg').ascii?)
+    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?)
+  end
 
-    def test_complete_eh
-      assert_nothing_raised do
-        @yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
-                                    'linux')
-      end
-      assert(@yaml.complete?)
-      assert_nothing_raised { @yaml.extensions = nil }
-      assert(!@yaml.complete?)
-    end
+  def test_binary_eh
+    refute(MIME::Type.new('text/plain').binary?)
+    assert(MIME::Type.new('image/jpeg').binary?)
+    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?)
+  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');
-    end
+  def test_complete_eh
+    yaml = yaml_mime_type_from_array
+    assert(yaml.complete?)
+    yaml.extensions = nil
+    refute(yaml.complete?)
+  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')
-      assert_nothing_raised do
-        @yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
-                                    'linux')
-      end
-      assert_equal(@yaml.encoding, '8bit')
-      assert_nothing_raised { @yaml.encoding = 'base64' }
-      assert_equal(@yaml.encoding, 'base64')
-      assert_nothing_raised { @yaml.encoding = :default }
-      assert_equal(@yaml.encoding, 'quoted-printable')
-      assert_raises(ArgumentError) { @yaml.encoding = 'binary' }
-      assert_equal(@zip.encoding, 'base64')
-    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');
+  end
 
-    def _test_default_encoding
-      raise NotImplementedError, 'Need to write test_default_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')
+    yaml.encoding = 'base64'
+    assert_equal(yaml.encoding, 'base64')
+    yaml.encoding = :default
+    assert_equal(yaml.encoding, 'quoted-printable')
+    assert_raises(ArgumentError) { yaml.encoding = 'binary' }
+    assert_equal(@zip.encoding, 'base64')
+  end
 
-    def _test_docs
-      raise NotImplementedError, 'Need to write test_docs'
-    end
+  def _test_default_encoding
+    raise NotImplementedError, 'Need to write test_default_encoding'
+  end
 
-    def _test_docs_equals
-      raise NotImplementedError, 'Need to write test_docs_equals'
-    end
+  def _test_docs
+    raise NotImplementedError, 'Need to write test_docs'
+  end
 
-    def test_eql?
-      assert(MIME::Type.new('text/plain').eql?(MIME::Type.new('text/plain')))
-      assert(!MIME::Type.new('text/plain').eql?(MIME::Type.new('image/jpeg')))
-      assert(!MIME::Type.new('text/plain').eql?('text/plain'))
-      assert(!MIME::Type.new('text/plain').eql?('image/jpeg'))
-    end
+  def _test_docs_equals
+    raise NotImplementedError, 'Need to write test_docs_equals'
+  end
 
-    def _test_encoding
-      raise NotImplementedError, 'Need to write test_encoding'
-    end
+  def test_eql?
+    assert(MIME::Type.new('text/plain').eql?(MIME::Type.new('text/plain')))
+    refute(MIME::Type.new('text/plain').eql?(MIME::Type.new('image/jpeg')))
+    refute(MIME::Type.new('text/plain').eql?('text/plain'))
+    refute(MIME::Type.new('text/plain').eql?('image/jpeg'))
+  end
 
-    def _test_encoding_equals
-      raise NotImplementedError, 'Need to write test_encoding_equals'
-    end
+  def _test_encoding
+    raise NotImplementedError, 'Need to write test_encoding'
+  end
 
-    def test_extensions
-      assert_nothing_raised do
-        @yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
-                                    'linux')
-      end
-      assert_equal(@yaml.extensions, %w(yaml yml))
-      assert_nothing_raised { @yaml.extensions = 'yaml' }
-      assert_equal(@yaml.extensions, ['yaml'])
-      assert_equal(@zip.extensions.size, 2)
-      assert_equal(@zip.extensions, ['zip', 'zp'])
-    end
+  def _test_encoding_equals
+    raise NotImplementedError, 'Need to write test_encoding_equals'
+  end
 
-    def _test_extensions_equals
-      raise NotImplementedError, 'Need to write test_extensions_equals'
-    end
+  def test_extensions
+    yaml = yaml_mime_type_from_array
+    assert_equal(yaml.extensions, %w(yaml yml))
+    yaml.extensions = 'yaml'
+    assert_equal(yaml.extensions, ['yaml'])
+    assert_equal(@zip.extensions.size, 2)
+    assert_equal(@zip.extensions, ['zip', 'zp'])
+  end
 
-    def test_like_eh
-      assert(MIME::Type.new('text/plain').like?(MIME::Type.new('text/plain')))
-      assert(MIME::Type.new('text/plain').like?(MIME::Type.new('text/x-plain')))
-      assert(!MIME::Type.new('text/plain').like?(MIME::Type.new('image/jpeg')))
-      assert(MIME::Type.new('text/plain').like?('text/plain'))
-      assert(MIME::Type.new('text/plain').like?('text/x-plain'))
-      assert(!MIME::Type.new('text/plain').like?('image/jpeg'))
-    end
+  def _test_extensions_equals
+    raise NotImplementedError, 'Need to write test_extensions_equals'
+  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')
-    end
+  def test_like_eh
+    assert(MIME::Type.new('text/plain').like?(MIME::Type.new('text/plain')))
+    assert(MIME::Type.new('text/plain').like?(MIME::Type.new('text/x-plain')))
+    refute(MIME::Type.new('text/plain').like?(MIME::Type.new('image/jpeg')))
+    assert(MIME::Type.new('text/plain').like?('text/plain'))
+    assert(MIME::Type.new('text/plain').like?('text/x-plain'))
+    refute(MIME::Type.new('text/plain').like?('image/jpeg'))
+  end
 
-    def _test_obsolete_eh
-      raise NotImplementedError, 'Need to write test_obsolete_eh'
-    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')
+  end
 
-    def _test_obsolete_equals
-      raise NotImplementedError, 'Need to write test_obsolete_equals'
-    end
+  def _test_obsolete_eh
+    raise NotImplementedError, 'Need to write test_obsolete_eh'
+  end
 
-    def test_platform_eh
-      assert_nothing_raised do
-        @yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
-                                    'oddbox')
-      end
-      assert(!@yaml.platform?)
-      assert_nothing_raised { @yaml.system = nil }
-      assert(!@yaml.platform?)
-      assert_nothing_raised { @yaml.system = /#{RUBY_PLATFORM}/ }
-        assert(@yaml.platform?)
-    end
+  def _test_obsolete_equals
+    raise NotImplementedError, 'Need to write test_obsolete_equals'
+  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 test_platform_eh
+    yaml = yaml_mime_type_from_array
+    refute(yaml.platform?)
+    yaml.system = nil
+    refute(yaml.platform?)
+    yaml.system = %r{#{RUBY_PLATFORM}}
+    assert(yaml.platform?)
+  end
 
-      assert_equal(MIME::Type.new('x-chemical/x-pdb').raw_media_type, 'x-chemical')
-      assert_equal(@zip.raw_media_type, 'x-appl')
-    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 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')
-    end
+    assert_equal(MIME::Type.new('x-chemical/x-pdb').raw_media_type, 'x-chemical')
+    assert_equal(@zip.raw_media_type, 'x-appl')
+  end
 
-    def test_registered_eh
-      assert(MIME::Type.new('text/plain').registered?)
-      assert(MIME::Type.new('image/jpeg').registered?)
-      assert(!MIME::Type.new('application/x-msword').registered?)
-      assert(MIME::Type.new('text/vCard').registered?)
-      assert(MIME::Type.new('application/pkcs7-mime').registered?)
-      assert(!@zip.registered?)
-    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')
+  end
 
-    def _test_registered_equals
-      raise NotImplementedError, 'Need to write test_registered_equals'
-    end
+  def test_registered_eh
+    assert(MIME::Type.new('text/plain').registered?)
+    assert(MIME::Type.new('image/jpeg').registered?)
+    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?)
+  end
 
-    def test_signature_eh
-      assert(!MIME::Type.new('text/plain').signature?)
-      assert(!MIME::Type.new('image/jpeg').signature?)
-      assert(!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_registered_equals
+    raise NotImplementedError, 'Need to write test_registered_equals'
+  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')
-    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_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')
-    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')
+  end
 
-    def test_system_equals
-      assert_nothing_raised do
-        @yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
-                                    'linux')
-      end
-      assert_equal(@yaml.system, %r{linux})
-      assert_nothing_raised { @yaml.system = /win32/ }
-      assert_equal(@yaml.system, %r{win32})
-      assert_nothing_raised { @yaml.system = nil }
-      assert_nil(@yaml.system)
-    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')
+  end
 
-    def test_system_eh
-      assert_nothing_raised do
-        @yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
-                                    'linux')
-      end
-      assert(@yaml.system?)
-      assert_nothing_raised { @yaml.system = nil }
-      assert(!@yaml.system?)
-    end
+  def test_system_equals
+    yaml = yaml_mime_type_from_array
+    assert_equal(yaml.system, %r{linux})
+    yaml.system = /win32/
+    assert_equal(yaml.system, %r{win32})
+    yaml.system = nil
+    assert_nil(yaml.system)
+  end
 
-    def test_to_a
-      assert_nothing_raised do
-        @yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
-                                    'linux')
-      end
-      assert_equal(@yaml.to_a, ['text/x-yaml', %w(yaml yml), '8bit',
-                   /linux/, nil, nil, nil, false])
-    end
+  def test_system_eh
+    yaml = yaml_mime_type_from_array
+    assert(yaml.system?)
+    yaml.system = nil
+    refute(yaml.system?)
+  end
 
-    def test_to_hash
-      assert_nothing_raised do
-        @yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
-                                    'linux')
-      end
-      assert_equal(@yaml.to_hash,
-                   { 'Content-Type' => 'text/x-yaml',
+  def test_to_a
+    yaml = yaml_mime_type_from_array
+    assert_equal(yaml.to_a, ['text/x-yaml', %w(yaml yml), '8bit',
+                 /linux/, nil, nil, nil, false])
+  end
+
+  def test_to_hash
+    yaml = yaml_mime_type_from_array
+    assert_equal(yaml.to_hash,
+                 { 'Content-Type' => 'text/x-yaml',
                     'Content-Transfer-Encoding' => '8bit',
                     'Extensions' => %w(yaml yml),
                     'System' => /linux/,
@@ -315,42 +278,41 @@ module TestMIME
                     'URL' => nil,
                     'Obsolete' => nil,
                     'Docs' => nil })
-    end
+  end
 
-    def test_to_s
-      assert_equal("#{MIME::Type.new('text/plain')}", 'text/plain')
-    end
+  def test_to_s
+    assert_equal("#{MIME::Type.new('text/plain')}", 'text/plain')
+  end
 
-    def test_class_constructors
-      assert_not_nil(@zip)
-      yaml = MIME::Type.new('text/x-yaml') do |y|
-        y.extensions = %w(yaml yml)
-        y.encoding = '8bit'
-        y.system = 'linux'
-      end
-      assert_instance_of(MIME::Type, yaml)
-      assert_raises(MIME::InvalidContentType) { MIME::Type.new('apps') }
-      assert_raises(MIME::InvalidContentType) { MIME::Type.new(nil) }
+  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 = 'linux'
     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'
-    end
+  def _test_to_str
+    raise NotImplementedError, 'Need to write test_to_str'
+  end
 
-    def _test_url
-      raise NotImplementedError, 'Need to write test_url'
-    end
+  def _test_url
+    raise NotImplementedError, 'Need to write test_url'
+  end
 
-    def _test_url_equals
-      raise NotImplementedError, 'Need to write test_url_equals'
-    end
+  def _test_url_equals
+    raise NotImplementedError, 'Need to write test_url_equals'
+  end
 
-    def _test_urls
-      raise NotImplementedError, 'Need to write test_urls'
-    end
+  def _test_urls
+    raise NotImplementedError, 'Need to write test_urls'
+  end
 
-    def __test_use_instead
-      raise NotImplementedError, 'Need to write test_use_instead'
-    end
+  def __test_use_instead
+    raise NotImplementedError, 'Need to write test_use_instead'
   end
 end