1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
|
module Marcel
class MimeType
BINARY = "application/octet-stream"
class << self
def extend(type, extensions: [], parents: [], magic: nil)
existing = Marcel::TYPES[type] || [[], [], ""]
extensions = (Array(extensions) + existing[0]).uniq
parents = (Array(parents) + existing[1]).uniq
comment = existing[2]
Magic.add(type, extensions: extensions, magic: magic, parents: parents, comment: comment)
end
def for(pathname_or_io = nil, name: nil, extension: nil, declared_type: nil)
type_from_data = for_data(pathname_or_io)
fallback_type = for_declared_type(declared_type) || for_name(name) || for_extension(extension) || BINARY
if type_from_data
most_specific_type type_from_data, fallback_type
else
fallback_type
end
end
private
def for_data(pathname_or_io)
if pathname_or_io
with_io(pathname_or_io) do |io|
if magic = Marcel::Magic.by_magic(io)
magic.type.downcase
end
end
end
end
def for_name(name)
if name
if magic = Marcel::Magic.by_path(name)
magic.type.downcase
end
end
end
def for_extension(extension)
if extension
if magic = Marcel::Magic.by_extension(extension)
magic.type.downcase
end
end
end
def for_declared_type(declared_type)
type = parse_media_type(declared_type)
if type != BINARY && !type.nil?
type.downcase
end
end
def with_io(pathname_or_io, &block)
if defined?(Pathname) && pathname_or_io.is_a?(Pathname)
pathname_or_io.open(&block)
else
yield pathname_or_io
end
end
def parse_media_type(content_type)
if content_type
result = content_type.downcase.split(/[;,\s]/, 2).first
result if result && result.index("/")
end
end
# For some document types (notably Microsoft Office) we recognise the main content
# type with magic, but not the specific subclass. In this situation, if we can get a more
# specific class using either the name or declared_type, we should use that in preference
def most_specific_type(from_magic_type, fallback_type)
if (root_types(from_magic_type) & root_types(fallback_type)).any?
fallback_type
else
from_magic_type
end
end
def root_types(type)
if TYPES[type].nil? || TYPES[type][1].empty?
[ type ]
else
TYPES[type][1].map {|t| root_types t }.flatten
end
end
end
end
end
require 'marcel/mime_type/definitions'
|
