mime-types 1.17.2 → 3.0

data/Manifest.txt

@@ -1,42 +1,40 @@
+.autotest
+.gemtest
+.gitignore
 .hoerc
+Code-of-Conduct.rdoc
+Contributing.rdoc
 History.rdoc
-License.rdoc
+Licence.rdoc
 Manifest.txt
 README.rdoc
 Rakefile
+lib/mime-types.rb
+lib/mime/type.rb
+lib/mime/type/columnar.rb
 lib/mime/types.rb
-lib/mime/types/application
-lib/mime/types/application.mac
-lib/mime/types/application.nonstandard
-lib/mime/types/application.obsolete
-lib/mime/types/audio
-lib/mime/types/audio.nonstandard
-lib/mime/types/audio.obsolete
-lib/mime/types/image
-lib/mime/types/image.nonstandard
-lib/mime/types/image.obsolete
-lib/mime/types/message
-lib/mime/types/message.obsolete
-lib/mime/types/model
-lib/mime/types/multipart
-lib/mime/types/multipart.nonstandard
-lib/mime/types/multipart.obsolete
-lib/mime/types/other.nonstandard
-lib/mime/types/text
-lib/mime/types/text.nonstandard
-lib/mime/types/text.obsolete
-lib/mime/types/text.vms
-lib/mime/types/video
-lib/mime/types/video.nonstandard
-lib/mime/types/video.obsolete
-mime-types.gemspec
+lib/mime/types/cache.rb
+lib/mime/types/columnar.rb
+lib/mime/types/container.rb
+lib/mime/types/deprecations.rb
+lib/mime/types/full.rb
+lib/mime/types/loader.rb
+lib/mime/types/logger.rb
+lib/mime/types/registry.rb
+support/benchmarks/load.rb
+support/benchmarks/load_allocations.rb
+support/benchmarks/object_counts.rb
+support/profile/columnar.rb
+support/profile/columnar_full.rb
+support/profile/full.rb
+test/bad-fixtures/malformed
+test/fixture/json.json
+test/fixture/old-data
+test/fixture/yaml.yaml
+test/minitest_helper.rb
 test/test_mime_type.rb
 test/test_mime_types.rb
-type-lists/application.txt
-type-lists/audio.txt
-type-lists/image.txt
-type-lists/message.txt
-type-lists/model.txt
-type-lists/multipart.txt
-type-lists/text.txt
-type-lists/video.txt
+test/test_mime_types_cache.rb
+test/test_mime_types_class.rb
+test/test_mime_types_lazy.rb
+test/test_mime_types_loader.rb

data/README.rdoc

@@ -1,19 +1,204 @@
-= MIME::Types for Ruby
+= mime-types for Ruby
+
+home :: https://github.com/mime-types/ruby-mime-types/
+code :: https://github.com/mime-types/ruby-mime-types/
+bugs :: https://github.com/mime-types/ruby-mime-types/issues
+rdoc :: http://rdoc.info/gems/mime-types/
+continuous integration :: {<img src="https://travis-ci.org/mime-types/ruby-mime-types.png" />}[https://travis-ci.org/mime-types/ruby-mime-types]
+test coverage :: {<img src="https://coveralls.io/repos/mime-types/ruby-mime-types/badge.png" alt="Coverage Status" />}[https://coveralls.io/r/mime-types/ruby-mime-types]
 
 == Description
 
-This library allows for the identification of a file's likely MIME content
-type. This is release 1.17.2. The identification of MIME content type is based
-on a file's filename extensions.
+The mime-types library provides a library and registry for information about
+MIME content type definitions. It can be used to determine defined filename
+extensions for MIME types, or to use filename extensions to look up the likely
+MIME type definitions.
+
+Version 3.0 is a major release that requires Ruby 2.0 compatibility and removes
+deprecated functions. The columnar registry format introduced in 2.6 has been
+made the primary format; the registry data has been extracted from this library
+and put into {mime-types-data}[https://github.com/mime-types/mime-types-data].
+Additionally, mime-types is now licensed exclusively under the MIT licence and
+there is a code of conduct in effect. There are a number of other smaller
+changes described in the History file.
+
+=== About MIME Media Types
+
+MIME content types are used in MIME-compliant communications, as in e-mail or
+HTTP traffic, to indicate the type of content which is transmitted. The
+mime-types library provides the ability for detailed information about MIME
+entities (provided as an enumerable collection of MIME::Type objects) to be
+determined and used. There are many types defined by RFCs and vendors, so the
+list is long but by definition incomplete; don't hesitate to add additional
+type definitions. MIME type definitions found in mime-types are from RFCs, W3C
+recommendations, the {IANA Media Types
+registry}[https://www.iana.org/assignments/media-types/media-types.xhtml], and
+user contributions. It conforms to RFCs 2045 and 2231.
+
+=== mime-types 1.x End of Life
+
+mime-types 1.x is no longer supported as of 2015-10-27.
+
+=== mime-types 2.x End of Life
+
+mime-types 2.x is supported as 2.99.x receiving quarterly updates of the IANA
+registry and security updates for two years. It will reach full end of life on
+2017-11-21.
+
+=== mime-types 3.x
+
+Users are encouraged to upgrade to mime-types 3.x as soon as is practical.
+mime-types 3.x requires Ruby 2.0 compatibility and a simpler licensing scheme.
+
+== Synopsis
+
+MIME types are used in MIME entities, as in email or HTTP traffic. It is useful
+at times to have information available about MIME types (or, inversely, about
+files). A MIME::Type stores the known information about one MIME type.
+
+   require 'mime/types'
+
+   plaintext = MIME::Types['text/plain'] # => [ text/plain ]
+   text = plaintext.first
+   puts text.media_type            # => 'text'
+   puts text.sub_type              # => 'plain'
+
+   puts text.extensions.join(' ')  # => 'txt asc c cc h hh cpp hpp dat hlp'
+   puts text.preferred_extension   # => 'txt'
+   puts text.friendly              # => 'Text Document'
+   puts text.i18n_key              # => 'text.plain'
+
+   puts text.encoding              # => quoted-printable
+   puts text.default_encoding      # => quoted-printable
+   puts text.binary?               # => false
+   puts text.ascii?                # => true
+   puts text.obsolete?             # => false
+   puts text.registered?           # => true
+   puts text.complete?             # => true
+
+   puts text                       # => 'text/plain'
+
+   puts text == 'text/plain'       # => true
+   puts 'text/plain' == text       # => true
+   puts text == 'text/x-plain'     # => false
+   puts 'text/x-plain' == text     # => false
+
+   puts MIME::Type.simplified('x-appl/x-zip') # => 'appl/zip'
+   puts MIME::Type.i18n_key('x-appl/x-zip') # => 'appl.zip'
+
+   puts text.like?('text/x-plain') # => true
+   puts text.like?(MIME::Type.new('x-text/x-plain')) # => true
+
+   puts text.xrefs.inspect # => { "rfc" => [ "rfc2046", "rfc3676", "rfc5147" ] }
+   puts text.xref_urls # => [ "http://www.iana.org/go/rfc2046",
+                       #      "http://www.iana.org/go/rfc3676",
+                       #      "http://www.iana.org/go/rfc5147" ]
+
+   xtext = MIME::Type.new('x-text/x-plain')
+   puts xtext.media_type # => 'text'
+   puts xtext.raw_media_type # => 'x-text'
+   puts xtext.sub_type # => 'plain'
+   puts xtext.raw_sub_type # => 'x-plain'
+   puts xtext.complete? # => false
+
+   puts MIME::Types.any? { |type| type.content_type == 'text/plain' } # => true
+   puts MIME::Types.all?(&:registered?) # => false
+
+   # Various string representations of MIME types
+   qcelp = MIME::Types['audio/QCELP'].first # => audio/QCELP
+   puts qcelp.content_type         # => 'audio/QCELP'
+   puts qcelp.simplified           # => 'audio/qcelp'
+
+   xwingz = MIME::Types['application/x-Wingz'].first # => application/x-Wingz
+   puts xwingz.content_type        # => 'application/x-Wingz'
+   puts xwingz.simplified          # => 'application/wingz'
+
+=== Columnar Store
+
+mime-types uses as its primary registry storage format a columnar storage
+format reducing the default memory footprint. This is done by selectively
+loading the data on a per-attribute basis. When the registry is first loaded
+from the columnar store, only the canonical MIME content type and known
+extensions and the MIME type will be connected to its loading registry. When
+other data about the type is required (including +preferred_extension+,
+<tt>obsolete?</tt>, and <tt>registered?</tt>) that data is loaded from its own
+column file for all types in the registry.
+
+The load of any column data is performed with a Mutex to ensure that types are
+updated safely in a multithreaded environment. Benchmarks show that while
+columnar data loading is slower than the JSON store, it cuts the memory use by
+a third over the JSON store.
+
+If you prefer to load all the data at once, this can be specified in your
+application Gemfile as:
+
+   gem 'mime-types', require: 'mime/types/full'
+
+Projects that do not use Bundler should +require+ the same:
+
+   require 'mime/types/full'
+
+Libraries that use mime-types are discouraged from choosing the JSON store.
+
+For applications and clients that used mime-types 2.6 when the columnar store
+was introduced, the require used previously will still work through at least
+{version
+4}[https://github.com/mime-types/ruby-mime-types/pull/96#issuecomment-100725400]
+and possibly beyond; it is effectively an empty operation. You are recommended
+to change your Gemfile as soon as is practical.
+
+   require 'mime/types/columnar'
+
+Note that MIME::Type::Columnar and MIME::Types::Columnar are considered private
+variant implementations of MIME::Type and MIME::Types and the specific
+implementation should not be relied upon by consumers of the mime-types
+library. Instead, depend on the public implementations (MIME::Type and
+MIME::Types) only.
+
+=== Cached Storage
+
+mime-types supports a cache of MIME types using <tt>Marshal.dump</tt>. The
+cache is invalidated for each version of the mime-types-data gem so that data
+version 3.2015.1201 will not be reused with data version 3.2016.0101. If the
+environment variable +RUBY_MIME_TYPES_CACHE+ is set to a cache file, mime-types
+will attempt to load the MIME type registry from the cache file. If it cannot,
+it will load the types normally and then saves the registry to the cache file.
+
+The caching works with both full stores and columnar stores. Only the data that
+has been loaded prior to saving the cache will be stored.
+
+== mime-types Modified Semantic Versioning
+
+The mime-types library has one version number, but this single version number
+tracks both API changes and registry data changes; this is not wholly
+compatible with all aspects of {Semantic Versioning}[http://semver.org/];
+removing a MIME type from the registry *could* be considered a breaking change
+under some interpretations of semantic versioning (as lookups for that
+particular type would no longer work by default).
+
+mime-types uses a modified semantic versioning scheme. Given the version
+MAJOR.MINOR:
+
+1. If an incompatible API (code) change is made, the MAJOR version will be
+   incremented, MINOR will be set to zero, and PATCH will be reset to the
+   implied zero.
+
+2. If an API (code) feature is added that does not break compatibilty OR if
+   there are MIME types added, removed, or changed in the registry, the MINOR
+   version will be incremented and PATCH will be reset to the implied zero.
+
+3. If there is a bugfix to a feature added in the most recent MAJOR.MINOR
+   release, OR if purely typographical errors are fixed in MIME types, the
+   implied PATCH value will be incremented resulting in MAJOR.MINOR.PATCH.
+
+In practical terms, there should be a MINOR release roughly monthly to track
+updated or changed MIME types from the official IANA registry. This does not
+indicate when new API features have been added, but all minor versions of
+mime-types 2.x will be backwards compatible; the interfaces marked deprecated
+will be removed in mime-types 3.x.
 
-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.
+:include: Code-of-Conduct.rdoc
 
-Homepage::  http://mime-types.rubyforge.org/
-GitHub::    http://github.com/halostatue/mime-types/
-Copyright:: 2002 - 2011, Austin Ziegler
-            Based in part on prior work copyright Mark Overmeer
+:include: Contributing.rdoc
 
-:include: License.rdoc
+:include: Licence.rdoc

data/Rakefile

@@ -2,197 +2,219 @@
 
 require 'rubygems'
 require 'hoe'
+require 'rake/clean'
 
 Hoe.plugin :doofus
-Hoe.plugin :gemspec
-Hoe.plugin :rubyforge
+Hoe.plugin :gemspec2
 Hoe.plugin :git
 Hoe.plugin :minitest
+Hoe.plugin :travis
+Hoe.plugin :email unless ENV['CI'] or ENV['TRAVIS']
 
 spec = Hoe.spec 'mime-types' do
-  self.rubyforge_name = self.name
+  developer('Austin Ziegler', 'halostatue@gmail.com')
+  self.need_tar = true
 
-  developer('Austin Ziegler', 'austin@rubyforge.org')
-
-  self.url = "http://mime-types.rubyforge.org/"
-  self.remote_rdoc_dir = 'rdoc'
-  self.rsync_args << ' --exclude=statsvn/'
+  require_ruby_version '>= 2.0'
 
   self.history_file = 'History.rdoc'
   self.readme_file = 'README.rdoc'
-  self.extra_rdoc_files = FileList["*.rdoc"].to_a
-
-  self.extra_dev_deps << ['nokogiri', '~> 1.5']
-  self.extra_dev_deps << ['minitest', '~> 2.0']
-  self.extra_dev_deps << ['hoe-doofus', '~> 1.0']
-  self.extra_dev_deps << ['hoe-gemspec', '~> 1.0']
-  self.extra_dev_deps << ['hoe-git', '~> 1.0']
-  self.extra_dev_deps << ['hoe-seattlerb', '~> 1.0']
+
+  license 'MIT'
+
+  extra_deps << ['mime-types-data', '~> 3.2015']
+
+  extra_dev_deps << ['hoe-doofus', '~> 1.0']
+  extra_dev_deps << ['hoe-gemspec2', '~> 1.1']
+  extra_dev_deps << ['hoe-git', '~> 1.6']
+  extra_dev_deps << ['hoe-rubygems', '~> 1.0']
+  extra_dev_deps << ['hoe-travis', '~> 1.2']
+  extra_dev_deps << ['minitest', '~> 5.4']
+  extra_dev_deps << ['minitest-autotest', '~> 1.0']
+  extra_dev_deps << ['minitest-focus', '~> 1.0']
+  extra_dev_deps << ['minitest-bonus-assertions', '~> 2.0']
+  extra_dev_deps << ['rake', '~> 10.0']
+  extra_dev_deps << ['fivemat', '~> 1.3' ]
+  extra_dev_deps << ['minitest-rg', '~> 5.2']
+
+  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.0')
+    extra_dev_deps << ['simplecov', '~> 0.7']
+    # if ENV['CI'] or ENV['TRAVIS']
+    #   extra_dev_deps << ['coveralls', '~> 0.8']
+    # end
+  end
 end
 
-namespace :mime do
-  desc "Download the current MIME type registrations from IANA."
-  task :iana, :save, :destination do |t, args|
-    save_type = (args.save || :text).to_sym
+namespace :benchmark do
+  task :support do
+    %w(lib support).each { |path|
+      $LOAD_PATH.unshift(File.join(Rake.application.original_dir, path))
+    }
+  end
 
-    case save_type
-    when :text, :both, :html
-      nil
-    else
-      raise "Unknown save type provided. Must be one of text, both, or html."
-    end
+  desc 'Benchmark Load Times'
+  task :load, [ :repeats ] => 'benchmark:support' do |_, args|
+    require 'benchmarks/load'
+    Benchmarks::Load.report(
+      File.join(Rake.application.original_dir, 'lib'),
+      args.repeats
+    )
+  end
 
-    destination = args.destination || "type-lists"
+  desc 'Allocation counts'
+  task :allocations, [ :top_x, :mime_types_only ] => 'benchmark:support' do |_, args|
+    require 'benchmarks/load_allocations'
+    Benchmarks::LoadAllocations.report(
+      top_x: args.top_x,
+      mime_types_only: args.mime_types_only
+    )
+  end
 
-    require 'open-uri'
-    require 'nokogiri'
-    require 'cgi'
+  desc 'Columnar allocation counts'
+  task 'allocations:columnar', [ :top_x, :mime_types_only ] => 'benchmark:support' do |_, args|
+    require 'benchmarks/load_allocations'
+    Benchmarks::LoadAllocations.report(
+      columnar: true,
+      top_x: args.top_x,
+      mime_types_only: args.mime_types_only
+    )
+  end
 
-    class IANAParser
-      include Comparable
+  desc 'Columnar allocation counts (full load)'
+  task 'allocations:columnar:full', [ :top_x, :mime_types_only ] => 'benchmark:support' do |_, args|
+    require 'benchmarks/load_allocations'
+    Benchmarks::LoadAllocations.report(
+      columnar: true,
+      top_x: args.top_x,
+      mime_types_only: args.mime_types_only,
+      full: true
+    )
+  end
 
-      INDEX = %q(http://www.iana.org/assignments/media-types/)
-      CONTACT_PEOPLE = %r{http://www.iana.org/assignments/contact-people.html?#(.*)}
-      RFC_EDITOR = %r{http://www.rfc-editor.org/rfc/rfc(\d+).txt}
-      IETF_RFC = %r{http://www.ietf.org/rfc/rfc(\d+).txt}
-      IETF_RFC_TOOLS = %r{http://tools.ietf.org/html/rfc(\d+)}
+  desc 'Object counts'
+  task objects: 'benchmark:support' do
+    require 'benchmarks/object_counts'
+    Benchmarks::ObjectCounts.report
+  end
 
-      class << self
-        def load_index
-          @types ||= {}
+  desc 'Columnar object counts'
+  task 'objects:columnar' => 'benchmark:support' do
+    require 'benchmarks/object_counts'
+    Benchmarks::ObjectCounts.report(columnar: true)
+  end
 
-          Nokogiri::HTML(open(INDEX) { |f| f.read }).xpath('//p/a').each do |tag|
-            href_match = %r{^/assignments/media-types/(.+)/$}.match(tag['href'])
-            next if href_match.nil?
-            type = href_match.captures[0]
-            @types[tag.content] = IANAParser.new(tag.content, type)
-          end
-        end
+  desc 'Columnar object counts (full load)'
+  task 'objects:columnar:full' => 'benchmark:support' do
+    require 'benchmarks/object_counts'
+    Benchmarks::ObjectCounts.report(columnar: true, full: true)
+  end
+end
 
-        attr_reader :types
-      end
+namespace :profile do
+  directory 'tmp/profile'
+
+  CLEAN.add 'tmp'
+
+  def ruby_prof(script)
+    require 'pathname'
+    output = Pathname('tmp/profile').join(script)
+    output.mkpath
+    script = Pathname('support/profile').join("#{script}.rb")
+
+    args = [
+      '-W0',
+      '-Ilib',
+      '-S', 'ruby-prof',
+      '-R', 'mime/types',
+      '-s', 'self',
+      '-p', 'multi',
+      '-f', "#{output}",
+      script.to_s
+    ]
+    ruby args.join(' ')
+  end
 
-      def initialize(name, type)
-        @name = name
-        @type = type
-        @url  = File.join(INDEX, @type)
-      end
+  task full: 'tmp/profile' do
+    ruby_prof 'full'
+  end
 
-      attr_reader :name
-      attr_reader :type
-      attr_reader :url
-      attr_reader :html
+  task columnar: :support do
+    ruby_prof 'columnar'
+  end
 
-      def download(name = nil)
-        @html = Nokogiri::HTML(open(name || @url) { |f| f.read })
-      end
+  task 'columnar:full' => :support do
+    ruby_prof 'columnar_full'
+  end
+end
 
-      def save_html
-        File.open("#@name.html", "wb") { |w| w.write @html }
-      end
+if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.0')
+  namespace :test do
+    # Coveralls needs to be disabled for now because it transitively depends on
+    # an earlier version of mime-types.
+    # if ENV['CI'] or ENV['TRAVIS']
+    #   task :coveralls do
+    #     spec.test_prelude = [
+    #       'require "psych"',
+    #       'require "simplecov"',
+    #       'require "coveralls"',
+    #       'SimpleCov.formatter = Coveralls::SimpleCov::Formatter',
+    #       'SimpleCov.start("test_frameworks") { command_name "Minitest" }',
+    #       'gem "minitest"'
+    #     ].join('; ')
+    #     Rake::Task['test'].execute
+    #   end
+
+    #   Rake::Task['travis'].prerequisites.replace(%w(test:coveralls))
+    # end
+
+    desc 'Run test coverage'
+    task :coverage do
+      spec.test_prelude = [
+        'require "simplecov"',
+        'SimpleCov.start("test_frameworks") { command_name "Minitest" }',
+        'gem "minitest"'
+      ].join('; ')
+      Rake::Task['test'].execute
+    end
+  end
+end
 
-      def <=>(o)
-        self.name <=> o.name
-      end
+namespace :convert do
+  namespace :docs do
+    task :setup do
+      gem 'rdoc'
+      require 'rdoc/rdoc'
+      @doc_converter ||= RDoc::Markup::ToMarkdown.new
+    end
 
-      def parse
-        nodes = html.xpath("//table//table//tr")
-
-        # How many <td> children does the first node have?
-        node_count = nodes.first.children.select { |n| n.elem? }.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 = nodes.first.next.children.select { |n| n.elem? }.size
-        end
-
-        @mime_types = nodes.map do |node|
-          next if node == nodes.first
-          elems = node.children.select { |n| n.elem? }
-          next if elems.size.zero?
-
-          raise "size mismatch #{elems.size} != #{node_count}" if node_count != elems.size
-
-          case elems.size
-          when 3
-            subtype_index = 1
-            refnode_index = 2
-          when 4
-            subtype_index = 1
-            refnode_index = 3
-          else
-            raise "Unknown element size."
-          end
-
-          subtype   = elems[subtype_index].content.chomp.strip
-          refnodes  = elems[refnode_index].children.select { |n| n.elem? }.map { |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 %r{(https?://.*)}
-          "{#{ref.content}=#$1}"
-            else
-              ref
-            end
-          }
-          refs = refnodes.join(',')
-
-      "#@type/#{subtype} 'IANA,#{refs}"
-        end.compact
-
-        @mime_types
-      end
+    FileList['*.rdoc'].each do |name|
+      rdoc = "#{name}.rdoc"
+      mark = "#{name}.md"
 
-      def save_text
-        File.open("#@name.txt", "wb") { |w| w.write @mime_types.join("\n") }
+      file mark => [ rdoc, :setup ] do |t|
+        puts "#{rdoc} => #{mark}"
+        File.open(t.name, 'wb') { |target|
+          target.write @doc_converter.convert(IO.read(t.prerequisites.first))
+        }
       end
-    end
 
-    puts "Downloading index of MIME types from #{IANAParser::INDEX}."
-    IANAParser.load_index
-
-    require 'fileutils'
-    FileUtils.mkdir_p destination
-    Dir.chdir destination do
-      IANAParser.types.values.sort.each do |parser|
-        next if parser.name == "example" or parser.name == "mime"
-        puts "Downloading #{parser.name} from #{parser.url}"
-        parser.download
-
-        if :html == save_type || :both == save_type
-          puts "Saving #{parser.name}.html"
-          parser.save_html
-        end
-
-        puts "Parsing #{parser.name} HTML"
-        parser.parse
-
-        if :text == save_type || :both == save_type
-          puts "Saving #{parser.name}.txt"
-          parser.save_text
-        end
-      end
+      CLEAN.add mark
+
+      task run: [ mark ]
     end
   end
 
-  desc "Shows known MIME type sources."
-  task :mime_type_sources do
-    puts <<-EOS
-http://www.ltsw.se/knbase/internet/mime.htp
-http://www.webmaster-toolkit.com/mime-types.shtml
-http://plugindoc.mozdev.org/winmime.php
-http://standards.freedesktop.org/shared-mime-info-spec/shared-mime-info-spec-latest.html  
-http://www.feedforall.com/mime-types.htm
-http://www.iana.org/assignments/media-types/
-  EOS
+  desc 'Convert documentation from RDoc to Markdown'
+  task docs: 'convert:docs:run'
+end
+
+task :console do
+  arguments = %w(pry)
+  arguments.push(*spec.spec.require_paths.map { |dir| "-I#{dir}" })
+  arguments.push("-r#{spec.spec.name.gsub('-', File::SEPARATOR)}")
+  unless system(*arguments)
+    error "Command failed: #{show_command}"
+    abort
   end
 end