mime-types 3.3.1 → 3.4.1

data/test/test_mime_types.rb

@@ -1,128 +1,128 @@
 # frozen_string_literal: true
 
-require 'mime/types'
-require 'minitest_helper'
+require "mime/types"
+require "minitest_helper"
 
 describe MIME::Types do
   def mime_types
     @mime_types ||= MIME::Types.new.tap { |mt|
-      mt.add MIME::Type.new(['text/plain', %w(txt)]),
-             MIME::Type.new(['image/jpeg', %w(jpg jpeg)]),
-             MIME::Type.new('application/x-wordperfect6.1'),
-             MIME::Type.new(
-               'content-type' => 'application/x-www-form-urlencoded',
-               'registered' => true
-             ),
-             MIME::Type.new(['application/x-gzip', %w(gz)]),
-             MIME::Type.new(
-               'content-type' => 'application/gzip',
-               'extensions' => 'gz',
-               'registered' => true
-             )
+      mt.add MIME::Type.new(["text/plain", %w[txt]]),
+        MIME::Type.new(["image/jpeg", %w[jpg jpeg]]),
+        MIME::Type.new("application/x-wordperfect6.1"),
+        MIME::Type.new(
+          "content-type" => "application/x-www-form-urlencoded",
+          "registered" => true
+        ),
+        MIME::Type.new(["application/x-gzip", %w[gz]]),
+        MIME::Type.new(
+          "content-type" => "application/gzip",
+          "extensions" => "gz",
+          "registered" => true
+        )
     }
   end
 
-  describe 'is enumerable' do
-    it 'correctly uses an Enumerable method like #any?' do
-      assert(mime_types.any? { |type| type.content_type == 'text/plain' })
+  describe "is enumerable" do
+    it "correctly uses an Enumerable method like #any?" do
+      assert(mime_types.any? { |type| type.content_type == "text/plain" })
     end
 
-    it 'implements each with no parameters to return an Enumerator' do
+    it "implements each with no parameters to return an Enumerator" do
       assert_kind_of Enumerator, mime_types.each
       assert_kind_of Enumerator, mime_types.map
     end
 
-    it 'will create a lazy enumerator' do
+    it "will create a lazy enumerator" do
       assert_kind_of Enumerator::Lazy, mime_types.lazy
       assert_kind_of Enumerator::Lazy, mime_types.map.lazy
     end
 
-    it 'is countable with an enumerator' do
+    it "is countable with an enumerator" do
       assert_equal 6, mime_types.each.count
       assert_equal 6, mime_types.lazy.count
     end
   end
 
-  describe '#[]' do
-    it 'can be searched with a MIME::Type' do
-      text_plain = MIME::Type.new('text/plain')
-      assert_includes mime_types[text_plain], 'text/plain'
+  describe "#[]" do
+    it "can be searched with a MIME::Type" do
+      text_plain = MIME::Type.new("text/plain")
+      assert_includes mime_types[text_plain], "text/plain"
       assert_equal 1, mime_types[text_plain].size
     end
 
-    it 'can be searched with a regular expression' do
-      assert_includes mime_types[/plain$/], 'text/plain'
+    it "can be searched with a regular expression" do
+      assert_includes mime_types[/plain$/], "text/plain"
       assert_equal 1, mime_types[/plain$/].size
     end
 
-    it 'sorts by priority with multiple matches' do
-      assert_equal %w(application/gzip application/x-gzip), mime_types[/gzip$/]
+    it "sorts by priority with multiple matches" do
+      assert_equal %w[application/gzip application/x-gzip], mime_types[/gzip$/]
       assert_equal 2, mime_types[/gzip$/].size
     end
 
-    it 'can be searched with a string' do
-      assert_includes mime_types['text/plain'], 'text/plain'
-      assert_equal 1, mime_types['text/plain'].size
+    it "can be searched with a string" do
+      assert_includes mime_types["text/plain"], "text/plain"
+      assert_equal 1, mime_types["text/plain"].size
     end
 
-    it 'can be searched with the complete flag' do
+    it "can be searched with the complete flag" do
       assert_empty mime_types[
-        'application/x-www-form-urlencoded',
+        "application/x-www-form-urlencoded",
         complete: true
       ]
-      assert_includes mime_types['text/plain', complete: true], 'text/plain'
-      assert_equal 1, mime_types['text/plain', complete: true].size
+      assert_includes mime_types["text/plain", complete: true], "text/plain"
+      assert_equal 1, mime_types["text/plain", complete: true].size
     end
 
-    it 'can be searched with the registered flag' do
-      assert_empty mime_types['application/x-wordperfect6.1', registered: true]
+    it "can be searched with the registered flag" do
+      assert_empty mime_types["application/x-wordperfect6.1", registered: true]
       refute_empty mime_types[
-        'application/x-www-form-urlencoded',
+        "application/x-www-form-urlencoded",
         registered: true
       ]
       refute_empty mime_types[/gzip/, registered: true]
       refute_equal mime_types[/gzip/], mime_types[/gzip/, registered: true]
     end
 
-    it 'properly returns an empty result on a regular expression miss' do
+    it "properly returns an empty result on a regular expression miss" do
       assert_empty mime_types[/^foo/]
       assert_empty mime_types[/^foo/, registered: true]
       assert_empty mime_types[/^foo/, complete: true]
     end
   end
 
-  describe '#add' do
-    let(:eruby) { MIME::Type.new('application/x-eruby') }
-    let(:jinja) { MIME::Type.new('application/jinja2') }
+  describe "#add" do
+    let(:eruby) { MIME::Type.new("application/x-eruby") }
+    let(:jinja) { MIME::Type.new("application/jinja2") }
 
-    it 'successfully adds a new type' do
+    it "successfully adds a new type" do
       mime_types.add(eruby)
-      assert_equal mime_types['application/x-eruby'], [eruby]
+      assert_equal mime_types["application/x-eruby"], [eruby]
     end
 
-    it 'complains about adding a duplicate type' do
+    it "complains about adding a duplicate type" do
       mime_types.add(eruby)
-      assert_output '', /is already registered as a variant/ do
+      assert_output "", /is already registered as a variant/ do
         mime_types.add(eruby)
       end
-      assert_equal mime_types['application/x-eruby'], [eruby]
+      assert_equal mime_types["application/x-eruby"], [eruby]
     end
 
-    it 'does not complain about adding a duplicate type when quiet' do
+    it "does not complain about adding a duplicate type when quiet" do
       mime_types.add(eruby)
-      assert_output '', '' do
+      assert_output "", "" do
         mime_types.add(eruby, :silent)
       end
-      assert_equal mime_types['application/x-eruby'], [eruby]
+      assert_equal mime_types["application/x-eruby"], [eruby]
     end
 
-    it 'successfully adds from an array' do
+    it "successfully adds from an array" do
       mime_types.add([eruby, jinja])
-      assert_equal mime_types['application/x-eruby'], [eruby]
-      assert_equal mime_types['application/jinja2'], [jinja]
+      assert_equal mime_types["application/x-eruby"], [eruby]
+      assert_equal mime_types["application/jinja2"], [jinja]
     end
 
-    it 'successfully adds from another MIME::Types' do
+    it "successfully adds from another MIME::Types" do
       mt = MIME::Types.new
       mt.add(mime_types)
       assert_equal mime_types.count, mt.count
@@ -133,36 +133,36 @@ describe MIME::Types do
     end
   end
 
-  describe '#type_for' do
-    it 'finds all types for a given extension' do
-      assert_equal %w(application/gzip application/x-gzip),
-                   mime_types.type_for('gz')
+  describe "#type_for" do
+    it "finds all types for a given extension" do
+      assert_equal %w[application/gzip application/x-gzip],
+        mime_types.type_for("gz")
     end
 
-    it 'separates the extension from filenames' do
-      assert_equal %w(image/jpeg), mime_types.of(['foo.jpeg', 'bar.jpeg'])
+    it "separates the extension from filenames" do
+      assert_equal %w[image/jpeg], mime_types.of(["foo.jpeg", "bar.jpeg"])
     end
 
-    it 'finds multiple extensions' do
-      assert_equal %w(image/jpeg text/plain),
-                   mime_types.type_for(%w(foo.txt foo.jpeg))
+    it "finds multiple extensions" do
+      assert_equal %w[image/jpeg text/plain],
+        mime_types.type_for(%w[foo.txt foo.jpeg])
     end
 
-    it 'does not find unknown extensions' do
+    it "does not find unknown extensions" do
       keys = mime_types.instance_variable_get(:@extension_index).keys
-      assert_empty mime_types.type_for('zzz')
+      assert_empty mime_types.type_for("zzz")
       assert_equal keys, mime_types.instance_variable_get(:@extension_index).keys
     end
 
-    it 'modifying type extensions causes reindexing' do
-      plain_text = mime_types['text/plain'].first
-      plain_text.add_extensions('xtxt')
-      assert_includes mime_types.type_for('xtxt'), 'text/plain'
+    it "modifying type extensions causes reindexing" do
+      plain_text = mime_types["text/plain"].first
+      plain_text.add_extensions("xtxt")
+      assert_includes mime_types.type_for("xtxt"), "text/plain"
     end
   end
 
-  describe '#count' do
-    it 'can count the number of types inside' do
+  describe "#count" do
+    it "can count the number of types inside" do
       assert_equal 6, mime_types.count
     end
   end

data/test/test_mime_types_cache.rb

@@ -1,25 +1,25 @@
 # frozen_string_literal: true
 
-require 'mime/types'
-require 'minitest_helper'
+require "mime/types"
+require "minitest_helper"
+
+MUTEX = Mutex.new
 
 describe MIME::Types::Cache do
   include Minitest::Hooks
 
-  MUTEX = Mutex.new
-
   def around
-    require 'fileutils'
+    require "fileutils"
 
     MUTEX.synchronize do
-      @cache_file = File.expand_path('../cache.tst', __FILE__)
-      ENV['RUBY_MIME_TYPES_CACHE'] = @cache_file
+      @cache_file = File.expand_path("../cache.tst", __FILE__)
+      ENV["RUBY_MIME_TYPES_CACHE"] = @cache_file
       clear_cache_file
 
       super
 
       clear_cache_file
-      ENV.delete('RUBY_MIME_TYPES_CACHE')
+      ENV.delete("RUBY_MIME_TYPES_CACHE")
     end
   end
 
@@ -32,67 +32,67 @@ describe MIME::Types::Cache do
     FileUtils.rm @cache_file if File.exist? @cache_file
   end
 
-  describe '.load' do
-    it 'does not use cache when RUBY_MIME_TYPES_CACHE is unset' do
-      ENV.delete('RUBY_MIME_TYPES_CACHE')
+  describe ".load" do
+    it "does not use cache when RUBY_MIME_TYPES_CACHE is unset" do
+      ENV.delete("RUBY_MIME_TYPES_CACHE")
       assert_nil MIME::Types::Cache.load
     end
 
-    it 'does not use cache when missing' do
+    it "does not use cache when missing" do
       assert_nil MIME::Types::Cache.load
     end
 
-    it 'registers the data to be updated by #add_extensions' do
+    it "registers the data to be updated by #add_extensions" do
       MIME::Types::Cache.save
       reset_mime_types
-      assert_equal([], MIME::Types.type_for('foo.additional'))
-      html = MIME::Types['text/html'][0]
-      html.add_extensions('additional')
-      assert_equal([html], MIME::Types.type_for('foo.additional'))
+      assert_equal([], MIME::Types.type_for("foo.additional"))
+      html = MIME::Types["text/html"][0]
+      html.add_extensions("additional")
+      assert_equal([html], MIME::Types.type_for("foo.additional"))
     end
 
-    it 'outputs an error when there is an invalid version' do
+    it "outputs an error when there is an invalid version" do
       v = MIME::Types::Data::VERSION
       MIME::Types::Data.send(:remove_const, :VERSION)
-      MIME::Types::Data.const_set(:VERSION, '0.0')
+      MIME::Types::Data.const_set(:VERSION, "0.0")
       MIME::Types::Cache.save
       MIME::Types::Data.send(:remove_const, :VERSION)
       MIME::Types::Data.const_set(:VERSION, v)
       MIME::Types.instance_variable_set(:@__types__, nil)
-      assert_output '', /MIME::Types cache: invalid version/ do
-        MIME::Types['text/html']
+      assert_output "", /MIME::Types cache: invalid version/ do
+        MIME::Types["text/html"]
       end
     end
 
-    it 'outputs an error when there is a marshal file incompatibility' do
+    it "outputs an error when there is a marshal file incompatibility" do
       MIME::Types::Cache.save
       data = File.binread(@cache_file).reverse
-      File.open(@cache_file, 'wb') do |f| f.write(data) end
+      File.open(@cache_file, "wb") { |f| f.write(data) }
       MIME::Types.instance_variable_set(:@__types__, nil)
-      assert_output '', /incompatible marshal file format/ do
-        MIME::Types['text/html']
+      assert_output "", /incompatible marshal file format/ do
+        MIME::Types["text/html"]
       end
     end
   end
 
-  describe '.save' do
-    it 'does not create cache when RUBY_MIME_TYPES_CACHE is unset' do
-      ENV.delete('RUBY_MIME_TYPES_CACHE')
+  describe ".save" do
+    it "does not create cache when RUBY_MIME_TYPES_CACHE is unset" do
+      ENV.delete("RUBY_MIME_TYPES_CACHE")
       assert_nil MIME::Types::Cache.save
     end
 
-    it 'creates the cache ' do
+    it "creates the cache " do
       assert_equal(false, File.exist?(@cache_file))
       MIME::Types::Cache.save
       assert_equal(true, File.exist?(@cache_file))
     end
 
-    it 'uses the cache' do
-      MIME::Types['text/html'].first.add_extensions('hex')
+    it "uses the cache" do
+      MIME::Types["text/html"].first.add_extensions("hex")
       MIME::Types::Cache.save
       MIME::Types.instance_variable_set(:@__types__, nil)
 
-      assert_includes MIME::Types['text/html'].first.extensions, 'hex'
+      assert_includes MIME::Types["text/html"].first.extensions, "hex"
 
       reset_mime_types
     end
@@ -100,19 +100,19 @@ describe MIME::Types::Cache do
 end
 
 describe MIME::Types::Container do
-  it 'marshals and unmarshals correctly' do
+  it "marshals and unmarshals correctly" do
     container = MIME::Types::Container.new
-    container.add('xyz', 'abc')
+    container.add("xyz", "abc")
 
     # default proc should return Set[]
-    assert_equal(Set[], container['abc'])
-    assert_equal(Set['abc'], container['xyz'])
+    assert_equal(Set[], container["abc"])
+    assert_equal(Set["abc"], container["xyz"])
 
     marshalled = Marshal.dump(container)
     loaded_container = Marshal.load(marshalled)
 
     # default proc should still return Set[]
-    assert_equal(Set[], loaded_container['abc'])
-    assert_equal(Set['abc'], container['xyz'])
+    assert_equal(Set[], loaded_container["abc"])
+    assert_equal(Set["abc"], container["xyz"])
   end
 end

data/test/test_mime_types_class.rb

@@ -1,74 +1,74 @@
 # frozen_string_literal: true
 
-require 'mime/types'
-require 'minitest_helper'
+require "mime/types"
+require "minitest_helper"
 
-describe MIME::Types, 'registry' do
+describe MIME::Types, "registry" do
   def setup
     MIME::Types.send(:load_default_mime_types)
   end
 
-  describe 'is enumerable' do
-    it 'correctly uses an Enumerable method like #any?' do
-      assert(MIME::Types.any? { |type| type.content_type == 'text/plain' })
+  describe "is enumerable" do
+    it "correctly uses an Enumerable method like #any?" do
+      assert(MIME::Types.any? { |type| type.content_type == "text/plain" })
     end
 
-    it 'implements each with no parameters to return an Enumerator' do
+    it "implements each with no parameters to return an Enumerator" do
       assert_kind_of Enumerator, MIME::Types.each
       assert_kind_of Enumerator, MIME::Types.map
     end
 
-    it 'will create a lazy enumerator' do
+    it "will create a lazy enumerator" do
       assert_kind_of Enumerator::Lazy, MIME::Types.lazy
       assert_kind_of Enumerator::Lazy, MIME::Types.map.lazy
     end
 
-    it 'is countable with an enumerator' do
+    it "is countable with an enumerator" do
       assert MIME::Types.each.count > 999
       assert MIME::Types.lazy.count > 999
     end
   end
 
-  describe '.[]' do
-    it 'can be searched with a MIME::Type' do
-      text_plain = MIME::Type.new('text/plain')
-      assert_includes MIME::Types[text_plain], 'text/plain'
+  describe ".[]" do
+    it "can be searched with a MIME::Type" do
+      text_plain = MIME::Type.new("text/plain")
+      assert_includes MIME::Types[text_plain], "text/plain"
       assert_equal 1, MIME::Types[text_plain].size
     end
 
-    it 'can be searched with a regular expression' do
-      assert_includes MIME::Types[/plain$/], 'text/plain'
+    it "can be searched with a regular expression" do
+      assert_includes MIME::Types[/plain$/], "text/plain"
       assert_equal 1, MIME::Types[/plain$/].size
     end
 
-    it 'sorts by priority with multiple matches' do
+    it "sorts by priority with multiple matches" do
       types = MIME::Types[/gzip$/].select { |t|
-        %w(application/gzip application/x-gzip multipart/x-gzip).include?(t)
+        %w[application/gzip application/x-gzip multipart/x-gzip].include?(t)
       }
       # This is this way because of a new type ending with gzip that only
       # appears in some data files.
-      assert_equal %w(application/gzip application/x-gzip multipart/x-gzip), types
+      assert_equal %w[application/gzip application/x-gzip multipart/x-gzip], types
       assert_equal 3, types.size
     end
 
-    it 'can be searched with a string' do
-      assert_includes MIME::Types['text/plain'], 'text/plain'
-      assert_equal 1, MIME::Types['text/plain'].size
+    it "can be searched with a string" do
+      assert_includes MIME::Types["text/plain"], "text/plain"
+      assert_equal 1, MIME::Types["text/plain"].size
     end
 
-    it 'can be searched with the complete flag' do
+    it "can be searched with the complete flag" do
       assert_empty MIME::Types[
-        'application/x-www-form-urlencoded',
+        "application/x-www-form-urlencoded",
         complete: true
       ]
-      assert_includes MIME::Types['text/plain', complete: true], 'text/plain'
-      assert_equal 1, MIME::Types['text/plain', complete: true].size
+      assert_includes MIME::Types["text/plain", complete: true], "text/plain"
+      assert_equal 1, MIME::Types["text/plain", complete: true].size
     end
 
-    it 'can be searched with the registered flag' do
-      assert_empty MIME::Types['application/x-wordperfect6.1', registered: true]
+    it "can be searched with the registered flag" do
+      assert_empty MIME::Types["application/x-wordperfect6.1", registered: true]
       refute_empty MIME::Types[
-        'application/x-www-form-urlencoded',
+        "application/x-www-form-urlencoded",
         registered: true
       ]
       refute_empty MIME::Types[/gzip/, registered: true]
@@ -76,75 +76,75 @@ describe MIME::Types, 'registry' do
     end
   end
 
-  describe '.type_for' do
-    it 'finds all types for a given extension' do
-      assert_equal %w(application/gzip application/x-gzip),
-                   MIME::Types.type_for('gz')
+  describe ".type_for" do
+    it "finds all types for a given extension" do
+      assert_equal %w[application/gzip application/x-gzip],
+        MIME::Types.type_for("gz")
     end
 
-    it 'separates the extension from filenames' do
-      assert_equal %w(image/jpeg), MIME::Types.of(['foo.jpeg', 'bar.jpeg'])
+    it "separates the extension from filenames" do
+      assert_equal %w[image/jpeg], MIME::Types.of(["foo.jpeg", "bar.jpeg"])
     end
 
-    it 'finds multiple extensions' do
-      assert_equal %w(image/jpeg text/plain),
-                   MIME::Types.type_for(%w(foo.txt foo.jpeg))
+    it "finds multiple extensions" do
+      assert_equal %w[image/jpeg text/plain],
+        MIME::Types.type_for(%w[foo.txt foo.jpeg])
     end
 
-    it 'does not find unknown extensions' do
-      assert_empty MIME::Types.type_for('zzz')
+    it "does not find unknown extensions" do
+      assert_empty MIME::Types.type_for("zzz")
     end
 
-    it 'modifying type extensions causes reindexing' do
-      plain_text = MIME::Types['text/plain'].first
-      plain_text.add_extensions('xtxt')
-      assert_includes MIME::Types.type_for('xtxt'), 'text/plain'
+    it "modifying type extensions causes reindexing" do
+      plain_text = MIME::Types["text/plain"].first
+      plain_text.add_extensions("xtxt")
+      assert_includes MIME::Types.type_for("xtxt"), "text/plain"
     end
   end
 
-  describe '.count' do
-    it 'can count the number of types inside' do
+  describe ".count" do
+    it "can count the number of types inside" do
       assert MIME::Types.count > 999
     end
   end
 
-  describe '.add' do
+  describe ".add" do
     def setup
       MIME::Types.instance_variable_set(:@__types__, nil)
       MIME::Types.send(:load_default_mime_types)
     end
 
-    let(:eruby) { MIME::Type.new('application/x-eruby') }
-    let(:jinja) { MIME::Type.new('application/jinja2') }
+    let(:eruby) { MIME::Type.new("application/x-eruby") }
+    let(:jinja) { MIME::Type.new("application/jinja2") }
 
-    it 'successfully adds a new type' do
+    it "successfully adds a new type" do
       MIME::Types.add(eruby)
-      assert_equal MIME::Types['application/x-eruby'], [eruby]
+      assert_equal MIME::Types["application/x-eruby"], [eruby]
     end
 
-    it 'complains about adding a duplicate type' do
+    it "complains about adding a duplicate type" do
       MIME::Types.add(eruby)
-      assert_output '', /is already registered as a variant/ do
+      assert_output "", /is already registered as a variant/ do
         MIME::Types.add(eruby)
       end
-      assert_equal MIME::Types['application/x-eruby'], [eruby]
+      assert_equal MIME::Types["application/x-eruby"], [eruby]
     end
 
-    it 'does not complain about adding a duplicate type when quiet' do
+    it "does not complain about adding a duplicate type when quiet" do
       MIME::Types.add(eruby)
       assert_silent do
         MIME::Types.add(eruby, :silent)
       end
-      assert_equal MIME::Types['application/x-eruby'], [eruby]
+      assert_equal MIME::Types["application/x-eruby"], [eruby]
     end
 
-    it 'successfully adds from an array' do
+    it "successfully adds from an array" do
       MIME::Types.add([eruby, jinja])
-      assert_equal MIME::Types['application/x-eruby'], [eruby]
-      assert_equal MIME::Types['application/jinja2'], [jinja]
+      assert_equal MIME::Types["application/x-eruby"], [eruby]
+      assert_equal MIME::Types["application/jinja2"], [jinja]
     end
 
-    it 'successfully adds from another MIME::Types' do
+    it "successfully adds from another MIME::Types" do
       old_count = MIME::Types.count
 
       mt = MIME::Types.new