mime-types 3.3.1 → 3.4.0
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/Code-of-Conduct.md +10 -10
- data/Contributing.md +82 -93
- data/History.md +158 -138
- data/Licence.md +3 -3
- data/README.rdoc +1 -0
- data/Rakefile +131 -145
- data/lib/mime/type/columnar.rb +3 -3
- data/lib/mime/type.rb +141 -94
- data/lib/mime/types/_columnar.rb +20 -19
- data/lib/mime/types/cache.rb +8 -8
- data/lib/mime/types/columnar.rb +1 -1
- data/lib/mime/types/container.rb +14 -14
- data/lib/mime/types/deprecations.rb +15 -11
- data/lib/mime/types/full.rb +2 -2
- data/lib/mime/types/loader.rb +28 -15
- data/lib/mime/types/logger.rb +3 -5
- data/lib/mime/types/registry.rb +7 -7
- data/lib/mime/types.rb +18 -16
- data/lib/mime-types.rb +1 -1
- data/test/minitest_helper.rb +7 -9
- data/test/test_mime_type.rb +272 -261
- data/test/test_mime_types.rb +72 -72
- data/test/test_mime_types_cache.rb +38 -38
- data/test/test_mime_types_class.rb +59 -59
- data/test/test_mime_types_lazy.rb +16 -16
- data/test/test_mime_types_loader.rb +14 -14
- metadata +15 -43
data/test/test_mime_types.rb
CHANGED
@@ -1,128 +1,128 @@
|
|
1
1
|
# frozen_string_literal: true
|
2
2
|
|
3
|
-
require
|
4
|
-
require
|
3
|
+
require "mime/types"
|
4
|
+
require "minitest_helper"
|
5
5
|
|
6
6
|
describe MIME::Types do
|
7
7
|
def mime_types
|
8
8
|
@mime_types ||= MIME::Types.new.tap { |mt|
|
9
|
-
mt.add MIME::Type.new([
|
10
|
-
|
11
|
-
|
12
|
-
|
13
|
-
|
14
|
-
|
15
|
-
|
16
|
-
|
17
|
-
|
18
|
-
|
19
|
-
|
20
|
-
|
21
|
-
|
9
|
+
mt.add MIME::Type.new(["text/plain", %w[txt]]),
|
10
|
+
MIME::Type.new(["image/jpeg", %w[jpg jpeg]]),
|
11
|
+
MIME::Type.new("application/x-wordperfect6.1"),
|
12
|
+
MIME::Type.new(
|
13
|
+
"content-type" => "application/x-www-form-urlencoded",
|
14
|
+
"registered" => true
|
15
|
+
),
|
16
|
+
MIME::Type.new(["application/x-gzip", %w[gz]]),
|
17
|
+
MIME::Type.new(
|
18
|
+
"content-type" => "application/gzip",
|
19
|
+
"extensions" => "gz",
|
20
|
+
"registered" => true
|
21
|
+
)
|
22
22
|
}
|
23
23
|
end
|
24
24
|
|
25
|
-
describe
|
26
|
-
it
|
27
|
-
assert(mime_types.any? { |type| type.content_type ==
|
25
|
+
describe "is enumerable" do
|
26
|
+
it "correctly uses an Enumerable method like #any?" do
|
27
|
+
assert(mime_types.any? { |type| type.content_type == "text/plain" })
|
28
28
|
end
|
29
29
|
|
30
|
-
it
|
30
|
+
it "implements each with no parameters to return an Enumerator" do
|
31
31
|
assert_kind_of Enumerator, mime_types.each
|
32
32
|
assert_kind_of Enumerator, mime_types.map
|
33
33
|
end
|
34
34
|
|
35
|
-
it
|
35
|
+
it "will create a lazy enumerator" do
|
36
36
|
assert_kind_of Enumerator::Lazy, mime_types.lazy
|
37
37
|
assert_kind_of Enumerator::Lazy, mime_types.map.lazy
|
38
38
|
end
|
39
39
|
|
40
|
-
it
|
40
|
+
it "is countable with an enumerator" do
|
41
41
|
assert_equal 6, mime_types.each.count
|
42
42
|
assert_equal 6, mime_types.lazy.count
|
43
43
|
end
|
44
44
|
end
|
45
45
|
|
46
|
-
describe
|
47
|
-
it
|
48
|
-
text_plain = MIME::Type.new(
|
49
|
-
assert_includes mime_types[text_plain],
|
46
|
+
describe "#[]" do
|
47
|
+
it "can be searched with a MIME::Type" do
|
48
|
+
text_plain = MIME::Type.new("text/plain")
|
49
|
+
assert_includes mime_types[text_plain], "text/plain"
|
50
50
|
assert_equal 1, mime_types[text_plain].size
|
51
51
|
end
|
52
52
|
|
53
|
-
it
|
54
|
-
assert_includes mime_types[/plain$/],
|
53
|
+
it "can be searched with a regular expression" do
|
54
|
+
assert_includes mime_types[/plain$/], "text/plain"
|
55
55
|
assert_equal 1, mime_types[/plain$/].size
|
56
56
|
end
|
57
57
|
|
58
|
-
it
|
59
|
-
assert_equal %w
|
58
|
+
it "sorts by priority with multiple matches" do
|
59
|
+
assert_equal %w[application/gzip application/x-gzip], mime_types[/gzip$/]
|
60
60
|
assert_equal 2, mime_types[/gzip$/].size
|
61
61
|
end
|
62
62
|
|
63
|
-
it
|
64
|
-
assert_includes mime_types[
|
65
|
-
assert_equal 1, mime_types[
|
63
|
+
it "can be searched with a string" do
|
64
|
+
assert_includes mime_types["text/plain"], "text/plain"
|
65
|
+
assert_equal 1, mime_types["text/plain"].size
|
66
66
|
end
|
67
67
|
|
68
|
-
it
|
68
|
+
it "can be searched with the complete flag" do
|
69
69
|
assert_empty mime_types[
|
70
|
-
|
70
|
+
"application/x-www-form-urlencoded",
|
71
71
|
complete: true
|
72
72
|
]
|
73
|
-
assert_includes mime_types[
|
74
|
-
assert_equal 1, mime_types[
|
73
|
+
assert_includes mime_types["text/plain", complete: true], "text/plain"
|
74
|
+
assert_equal 1, mime_types["text/plain", complete: true].size
|
75
75
|
end
|
76
76
|
|
77
|
-
it
|
78
|
-
assert_empty mime_types[
|
77
|
+
it "can be searched with the registered flag" do
|
78
|
+
assert_empty mime_types["application/x-wordperfect6.1", registered: true]
|
79
79
|
refute_empty mime_types[
|
80
|
-
|
80
|
+
"application/x-www-form-urlencoded",
|
81
81
|
registered: true
|
82
82
|
]
|
83
83
|
refute_empty mime_types[/gzip/, registered: true]
|
84
84
|
refute_equal mime_types[/gzip/], mime_types[/gzip/, registered: true]
|
85
85
|
end
|
86
86
|
|
87
|
-
it
|
87
|
+
it "properly returns an empty result on a regular expression miss" do
|
88
88
|
assert_empty mime_types[/^foo/]
|
89
89
|
assert_empty mime_types[/^foo/, registered: true]
|
90
90
|
assert_empty mime_types[/^foo/, complete: true]
|
91
91
|
end
|
92
92
|
end
|
93
93
|
|
94
|
-
describe
|
95
|
-
let(:eruby) { MIME::Type.new(
|
96
|
-
let(:jinja) { MIME::Type.new(
|
94
|
+
describe "#add" do
|
95
|
+
let(:eruby) { MIME::Type.new("application/x-eruby") }
|
96
|
+
let(:jinja) { MIME::Type.new("application/jinja2") }
|
97
97
|
|
98
|
-
it
|
98
|
+
it "successfully adds a new type" do
|
99
99
|
mime_types.add(eruby)
|
100
|
-
assert_equal mime_types[
|
100
|
+
assert_equal mime_types["application/x-eruby"], [eruby]
|
101
101
|
end
|
102
102
|
|
103
|
-
it
|
103
|
+
it "complains about adding a duplicate type" do
|
104
104
|
mime_types.add(eruby)
|
105
|
-
assert_output
|
105
|
+
assert_output "", /is already registered as a variant/ do
|
106
106
|
mime_types.add(eruby)
|
107
107
|
end
|
108
|
-
assert_equal mime_types[
|
108
|
+
assert_equal mime_types["application/x-eruby"], [eruby]
|
109
109
|
end
|
110
110
|
|
111
|
-
it
|
111
|
+
it "does not complain about adding a duplicate type when quiet" do
|
112
112
|
mime_types.add(eruby)
|
113
|
-
assert_output
|
113
|
+
assert_output "", "" do
|
114
114
|
mime_types.add(eruby, :silent)
|
115
115
|
end
|
116
|
-
assert_equal mime_types[
|
116
|
+
assert_equal mime_types["application/x-eruby"], [eruby]
|
117
117
|
end
|
118
118
|
|
119
|
-
it
|
119
|
+
it "successfully adds from an array" do
|
120
120
|
mime_types.add([eruby, jinja])
|
121
|
-
assert_equal mime_types[
|
122
|
-
assert_equal mime_types[
|
121
|
+
assert_equal mime_types["application/x-eruby"], [eruby]
|
122
|
+
assert_equal mime_types["application/jinja2"], [jinja]
|
123
123
|
end
|
124
124
|
|
125
|
-
it
|
125
|
+
it "successfully adds from another MIME::Types" do
|
126
126
|
mt = MIME::Types.new
|
127
127
|
mt.add(mime_types)
|
128
128
|
assert_equal mime_types.count, mt.count
|
@@ -133,36 +133,36 @@ describe MIME::Types do
|
|
133
133
|
end
|
134
134
|
end
|
135
135
|
|
136
|
-
describe
|
137
|
-
it
|
138
|
-
assert_equal %w
|
139
|
-
|
136
|
+
describe "#type_for" do
|
137
|
+
it "finds all types for a given extension" do
|
138
|
+
assert_equal %w[application/gzip application/x-gzip],
|
139
|
+
mime_types.type_for("gz")
|
140
140
|
end
|
141
141
|
|
142
|
-
it
|
143
|
-
assert_equal %w
|
142
|
+
it "separates the extension from filenames" do
|
143
|
+
assert_equal %w[image/jpeg], mime_types.of(["foo.jpeg", "bar.jpeg"])
|
144
144
|
end
|
145
145
|
|
146
|
-
it
|
147
|
-
assert_equal %w
|
148
|
-
|
146
|
+
it "finds multiple extensions" do
|
147
|
+
assert_equal %w[image/jpeg text/plain],
|
148
|
+
mime_types.type_for(%w[foo.txt foo.jpeg])
|
149
149
|
end
|
150
150
|
|
151
|
-
it
|
151
|
+
it "does not find unknown extensions" do
|
152
152
|
keys = mime_types.instance_variable_get(:@extension_index).keys
|
153
|
-
assert_empty mime_types.type_for(
|
153
|
+
assert_empty mime_types.type_for("zzz")
|
154
154
|
assert_equal keys, mime_types.instance_variable_get(:@extension_index).keys
|
155
155
|
end
|
156
156
|
|
157
|
-
it
|
158
|
-
plain_text = mime_types[
|
159
|
-
plain_text.add_extensions(
|
160
|
-
assert_includes mime_types.type_for(
|
157
|
+
it "modifying type extensions causes reindexing" do
|
158
|
+
plain_text = mime_types["text/plain"].first
|
159
|
+
plain_text.add_extensions("xtxt")
|
160
|
+
assert_includes mime_types.type_for("xtxt"), "text/plain"
|
161
161
|
end
|
162
162
|
end
|
163
163
|
|
164
|
-
describe
|
165
|
-
it
|
164
|
+
describe "#count" do
|
165
|
+
it "can count the number of types inside" do
|
166
166
|
assert_equal 6, mime_types.count
|
167
167
|
end
|
168
168
|
end
|
@@ -1,25 +1,25 @@
|
|
1
1
|
# frozen_string_literal: true
|
2
2
|
|
3
|
-
require
|
4
|
-
require
|
3
|
+
require "mime/types"
|
4
|
+
require "minitest_helper"
|
5
|
+
|
6
|
+
MUTEX = Mutex.new
|
5
7
|
|
6
8
|
describe MIME::Types::Cache do
|
7
9
|
include Minitest::Hooks
|
8
10
|
|
9
|
-
MUTEX = Mutex.new
|
10
|
-
|
11
11
|
def around
|
12
|
-
require
|
12
|
+
require "fileutils"
|
13
13
|
|
14
14
|
MUTEX.synchronize do
|
15
|
-
@cache_file = File.expand_path(
|
16
|
-
ENV[
|
15
|
+
@cache_file = File.expand_path("../cache.tst", __FILE__)
|
16
|
+
ENV["RUBY_MIME_TYPES_CACHE"] = @cache_file
|
17
17
|
clear_cache_file
|
18
18
|
|
19
19
|
super
|
20
20
|
|
21
21
|
clear_cache_file
|
22
|
-
ENV.delete(
|
22
|
+
ENV.delete("RUBY_MIME_TYPES_CACHE")
|
23
23
|
end
|
24
24
|
end
|
25
25
|
|
@@ -32,67 +32,67 @@ describe MIME::Types::Cache do
|
|
32
32
|
FileUtils.rm @cache_file if File.exist? @cache_file
|
33
33
|
end
|
34
34
|
|
35
|
-
describe
|
36
|
-
it
|
37
|
-
ENV.delete(
|
35
|
+
describe ".load" do
|
36
|
+
it "does not use cache when RUBY_MIME_TYPES_CACHE is unset" do
|
37
|
+
ENV.delete("RUBY_MIME_TYPES_CACHE")
|
38
38
|
assert_nil MIME::Types::Cache.load
|
39
39
|
end
|
40
40
|
|
41
|
-
it
|
41
|
+
it "does not use cache when missing" do
|
42
42
|
assert_nil MIME::Types::Cache.load
|
43
43
|
end
|
44
44
|
|
45
|
-
it
|
45
|
+
it "registers the data to be updated by #add_extensions" do
|
46
46
|
MIME::Types::Cache.save
|
47
47
|
reset_mime_types
|
48
|
-
assert_equal([], MIME::Types.type_for(
|
49
|
-
html = MIME::Types[
|
50
|
-
html.add_extensions(
|
51
|
-
assert_equal([html], MIME::Types.type_for(
|
48
|
+
assert_equal([], MIME::Types.type_for("foo.additional"))
|
49
|
+
html = MIME::Types["text/html"][0]
|
50
|
+
html.add_extensions("additional")
|
51
|
+
assert_equal([html], MIME::Types.type_for("foo.additional"))
|
52
52
|
end
|
53
53
|
|
54
|
-
it
|
54
|
+
it "outputs an error when there is an invalid version" do
|
55
55
|
v = MIME::Types::Data::VERSION
|
56
56
|
MIME::Types::Data.send(:remove_const, :VERSION)
|
57
|
-
MIME::Types::Data.const_set(:VERSION,
|
57
|
+
MIME::Types::Data.const_set(:VERSION, "0.0")
|
58
58
|
MIME::Types::Cache.save
|
59
59
|
MIME::Types::Data.send(:remove_const, :VERSION)
|
60
60
|
MIME::Types::Data.const_set(:VERSION, v)
|
61
61
|
MIME::Types.instance_variable_set(:@__types__, nil)
|
62
|
-
assert_output
|
63
|
-
MIME::Types[
|
62
|
+
assert_output "", /MIME::Types cache: invalid version/ do
|
63
|
+
MIME::Types["text/html"]
|
64
64
|
end
|
65
65
|
end
|
66
66
|
|
67
|
-
it
|
67
|
+
it "outputs an error when there is a marshal file incompatibility" do
|
68
68
|
MIME::Types::Cache.save
|
69
69
|
data = File.binread(@cache_file).reverse
|
70
|
-
File.open(@cache_file,
|
70
|
+
File.open(@cache_file, "wb") { |f| f.write(data) }
|
71
71
|
MIME::Types.instance_variable_set(:@__types__, nil)
|
72
|
-
assert_output
|
73
|
-
MIME::Types[
|
72
|
+
assert_output "", /incompatible marshal file format/ do
|
73
|
+
MIME::Types["text/html"]
|
74
74
|
end
|
75
75
|
end
|
76
76
|
end
|
77
77
|
|
78
|
-
describe
|
79
|
-
it
|
80
|
-
ENV.delete(
|
78
|
+
describe ".save" do
|
79
|
+
it "does not create cache when RUBY_MIME_TYPES_CACHE is unset" do
|
80
|
+
ENV.delete("RUBY_MIME_TYPES_CACHE")
|
81
81
|
assert_nil MIME::Types::Cache.save
|
82
82
|
end
|
83
83
|
|
84
|
-
it
|
84
|
+
it "creates the cache " do
|
85
85
|
assert_equal(false, File.exist?(@cache_file))
|
86
86
|
MIME::Types::Cache.save
|
87
87
|
assert_equal(true, File.exist?(@cache_file))
|
88
88
|
end
|
89
89
|
|
90
|
-
it
|
91
|
-
MIME::Types[
|
90
|
+
it "uses the cache" do
|
91
|
+
MIME::Types["text/html"].first.add_extensions("hex")
|
92
92
|
MIME::Types::Cache.save
|
93
93
|
MIME::Types.instance_variable_set(:@__types__, nil)
|
94
94
|
|
95
|
-
assert_includes MIME::Types[
|
95
|
+
assert_includes MIME::Types["text/html"].first.extensions, "hex"
|
96
96
|
|
97
97
|
reset_mime_types
|
98
98
|
end
|
@@ -100,19 +100,19 @@ describe MIME::Types::Cache do
|
|
100
100
|
end
|
101
101
|
|
102
102
|
describe MIME::Types::Container do
|
103
|
-
it
|
103
|
+
it "marshals and unmarshals correctly" do
|
104
104
|
container = MIME::Types::Container.new
|
105
|
-
container.add(
|
105
|
+
container.add("xyz", "abc")
|
106
106
|
|
107
107
|
# default proc should return Set[]
|
108
|
-
assert_equal(Set[], container[
|
109
|
-
assert_equal(Set[
|
108
|
+
assert_equal(Set[], container["abc"])
|
109
|
+
assert_equal(Set["abc"], container["xyz"])
|
110
110
|
|
111
111
|
marshalled = Marshal.dump(container)
|
112
112
|
loaded_container = Marshal.load(marshalled)
|
113
113
|
|
114
114
|
# default proc should still return Set[]
|
115
|
-
assert_equal(Set[], loaded_container[
|
116
|
-
assert_equal(Set[
|
115
|
+
assert_equal(Set[], loaded_container["abc"])
|
116
|
+
assert_equal(Set["abc"], container["xyz"])
|
117
117
|
end
|
118
118
|
end
|
@@ -1,74 +1,74 @@
|
|
1
1
|
# frozen_string_literal: true
|
2
2
|
|
3
|
-
require
|
4
|
-
require
|
3
|
+
require "mime/types"
|
4
|
+
require "minitest_helper"
|
5
5
|
|
6
|
-
describe MIME::Types,
|
6
|
+
describe MIME::Types, "registry" do
|
7
7
|
def setup
|
8
8
|
MIME::Types.send(:load_default_mime_types)
|
9
9
|
end
|
10
10
|
|
11
|
-
describe
|
12
|
-
it
|
13
|
-
assert(MIME::Types.any? { |type| type.content_type ==
|
11
|
+
describe "is enumerable" do
|
12
|
+
it "correctly uses an Enumerable method like #any?" do
|
13
|
+
assert(MIME::Types.any? { |type| type.content_type == "text/plain" })
|
14
14
|
end
|
15
15
|
|
16
|
-
it
|
16
|
+
it "implements each with no parameters to return an Enumerator" do
|
17
17
|
assert_kind_of Enumerator, MIME::Types.each
|
18
18
|
assert_kind_of Enumerator, MIME::Types.map
|
19
19
|
end
|
20
20
|
|
21
|
-
it
|
21
|
+
it "will create a lazy enumerator" do
|
22
22
|
assert_kind_of Enumerator::Lazy, MIME::Types.lazy
|
23
23
|
assert_kind_of Enumerator::Lazy, MIME::Types.map.lazy
|
24
24
|
end
|
25
25
|
|
26
|
-
it
|
26
|
+
it "is countable with an enumerator" do
|
27
27
|
assert MIME::Types.each.count > 999
|
28
28
|
assert MIME::Types.lazy.count > 999
|
29
29
|
end
|
30
30
|
end
|
31
31
|
|
32
|
-
describe
|
33
|
-
it
|
34
|
-
text_plain = MIME::Type.new(
|
35
|
-
assert_includes MIME::Types[text_plain],
|
32
|
+
describe ".[]" do
|
33
|
+
it "can be searched with a MIME::Type" do
|
34
|
+
text_plain = MIME::Type.new("text/plain")
|
35
|
+
assert_includes MIME::Types[text_plain], "text/plain"
|
36
36
|
assert_equal 1, MIME::Types[text_plain].size
|
37
37
|
end
|
38
38
|
|
39
|
-
it
|
40
|
-
assert_includes MIME::Types[/plain$/],
|
39
|
+
it "can be searched with a regular expression" do
|
40
|
+
assert_includes MIME::Types[/plain$/], "text/plain"
|
41
41
|
assert_equal 1, MIME::Types[/plain$/].size
|
42
42
|
end
|
43
43
|
|
44
|
-
it
|
44
|
+
it "sorts by priority with multiple matches" do
|
45
45
|
types = MIME::Types[/gzip$/].select { |t|
|
46
|
-
%w
|
46
|
+
%w[application/gzip application/x-gzip multipart/x-gzip].include?(t)
|
47
47
|
}
|
48
48
|
# This is this way because of a new type ending with gzip that only
|
49
49
|
# appears in some data files.
|
50
|
-
assert_equal %w
|
50
|
+
assert_equal %w[application/gzip application/x-gzip multipart/x-gzip], types
|
51
51
|
assert_equal 3, types.size
|
52
52
|
end
|
53
53
|
|
54
|
-
it
|
55
|
-
assert_includes MIME::Types[
|
56
|
-
assert_equal 1, MIME::Types[
|
54
|
+
it "can be searched with a string" do
|
55
|
+
assert_includes MIME::Types["text/plain"], "text/plain"
|
56
|
+
assert_equal 1, MIME::Types["text/plain"].size
|
57
57
|
end
|
58
58
|
|
59
|
-
it
|
59
|
+
it "can be searched with the complete flag" do
|
60
60
|
assert_empty MIME::Types[
|
61
|
-
|
61
|
+
"application/x-www-form-urlencoded",
|
62
62
|
complete: true
|
63
63
|
]
|
64
|
-
assert_includes MIME::Types[
|
65
|
-
assert_equal 1, MIME::Types[
|
64
|
+
assert_includes MIME::Types["text/plain", complete: true], "text/plain"
|
65
|
+
assert_equal 1, MIME::Types["text/plain", complete: true].size
|
66
66
|
end
|
67
67
|
|
68
|
-
it
|
69
|
-
assert_empty MIME::Types[
|
68
|
+
it "can be searched with the registered flag" do
|
69
|
+
assert_empty MIME::Types["application/x-wordperfect6.1", registered: true]
|
70
70
|
refute_empty MIME::Types[
|
71
|
-
|
71
|
+
"application/x-www-form-urlencoded",
|
72
72
|
registered: true
|
73
73
|
]
|
74
74
|
refute_empty MIME::Types[/gzip/, registered: true]
|
@@ -76,75 +76,75 @@ describe MIME::Types, 'registry' do
|
|
76
76
|
end
|
77
77
|
end
|
78
78
|
|
79
|
-
describe
|
80
|
-
it
|
81
|
-
assert_equal %w
|
82
|
-
|
79
|
+
describe ".type_for" do
|
80
|
+
it "finds all types for a given extension" do
|
81
|
+
assert_equal %w[application/gzip application/x-gzip],
|
82
|
+
MIME::Types.type_for("gz")
|
83
83
|
end
|
84
84
|
|
85
|
-
it
|
86
|
-
assert_equal %w
|
85
|
+
it "separates the extension from filenames" do
|
86
|
+
assert_equal %w[image/jpeg], MIME::Types.of(["foo.jpeg", "bar.jpeg"])
|
87
87
|
end
|
88
88
|
|
89
|
-
it
|
90
|
-
assert_equal %w
|
91
|
-
|
89
|
+
it "finds multiple extensions" do
|
90
|
+
assert_equal %w[image/jpeg text/plain],
|
91
|
+
MIME::Types.type_for(%w[foo.txt foo.jpeg])
|
92
92
|
end
|
93
93
|
|
94
|
-
it
|
95
|
-
assert_empty MIME::Types.type_for(
|
94
|
+
it "does not find unknown extensions" do
|
95
|
+
assert_empty MIME::Types.type_for("zzz")
|
96
96
|
end
|
97
97
|
|
98
|
-
it
|
99
|
-
plain_text = MIME::Types[
|
100
|
-
plain_text.add_extensions(
|
101
|
-
assert_includes MIME::Types.type_for(
|
98
|
+
it "modifying type extensions causes reindexing" do
|
99
|
+
plain_text = MIME::Types["text/plain"].first
|
100
|
+
plain_text.add_extensions("xtxt")
|
101
|
+
assert_includes MIME::Types.type_for("xtxt"), "text/plain"
|
102
102
|
end
|
103
103
|
end
|
104
104
|
|
105
|
-
describe
|
106
|
-
it
|
105
|
+
describe ".count" do
|
106
|
+
it "can count the number of types inside" do
|
107
107
|
assert MIME::Types.count > 999
|
108
108
|
end
|
109
109
|
end
|
110
110
|
|
111
|
-
describe
|
111
|
+
describe ".add" do
|
112
112
|
def setup
|
113
113
|
MIME::Types.instance_variable_set(:@__types__, nil)
|
114
114
|
MIME::Types.send(:load_default_mime_types)
|
115
115
|
end
|
116
116
|
|
117
|
-
let(:eruby) { MIME::Type.new(
|
118
|
-
let(:jinja) { MIME::Type.new(
|
117
|
+
let(:eruby) { MIME::Type.new("application/x-eruby") }
|
118
|
+
let(:jinja) { MIME::Type.new("application/jinja2") }
|
119
119
|
|
120
|
-
it
|
120
|
+
it "successfully adds a new type" do
|
121
121
|
MIME::Types.add(eruby)
|
122
|
-
assert_equal MIME::Types[
|
122
|
+
assert_equal MIME::Types["application/x-eruby"], [eruby]
|
123
123
|
end
|
124
124
|
|
125
|
-
it
|
125
|
+
it "complains about adding a duplicate type" do
|
126
126
|
MIME::Types.add(eruby)
|
127
|
-
assert_output
|
127
|
+
assert_output "", /is already registered as a variant/ do
|
128
128
|
MIME::Types.add(eruby)
|
129
129
|
end
|
130
|
-
assert_equal MIME::Types[
|
130
|
+
assert_equal MIME::Types["application/x-eruby"], [eruby]
|
131
131
|
end
|
132
132
|
|
133
|
-
it
|
133
|
+
it "does not complain about adding a duplicate type when quiet" do
|
134
134
|
MIME::Types.add(eruby)
|
135
135
|
assert_silent do
|
136
136
|
MIME::Types.add(eruby, :silent)
|
137
137
|
end
|
138
|
-
assert_equal MIME::Types[
|
138
|
+
assert_equal MIME::Types["application/x-eruby"], [eruby]
|
139
139
|
end
|
140
140
|
|
141
|
-
it
|
141
|
+
it "successfully adds from an array" do
|
142
142
|
MIME::Types.add([eruby, jinja])
|
143
|
-
assert_equal MIME::Types[
|
144
|
-
assert_equal MIME::Types[
|
143
|
+
assert_equal MIME::Types["application/x-eruby"], [eruby]
|
144
|
+
assert_equal MIME::Types["application/jinja2"], [jinja]
|
145
145
|
end
|
146
146
|
|
147
|
-
it
|
147
|
+
it "successfully adds from another MIME::Types" do
|
148
148
|
old_count = MIME::Types.count
|
149
149
|
|
150
150
|
mt = MIME::Types.new
|