Class: MIME::Types::Loader

Inherits:
Object
  • Object
show all
Defined in:
lib/mime/types/loader.rb,
lib/mime/types/loader_path.rb

Overview

This class is responsible for initializing the MIME::Types registry from the data files supplied with the mime-types library.

The Loader will use one of the following paths:

  1. The path provided in its constructor argument;

  2. The value of ENV; or

  3. The value of MIME::Types::Loader::PATH.

When #load is called, the path will be searched recursively for all YAML (.yml or .yaml) files. By convention, there is one file for each media type (application.yml, audio.yml, etc.), but this is not required.

Constant Summary collapse

BadV1Format =

Raised when a V1 format file is discovered.

Class.new(Exception)
PATH =

The path that will be used for loading the MIME::Types data. The default location is __FILE__/../../../../data, which is where the data lives in the gem installation of the mime-types library.

The MIME::Types::Loader will load all YAML files contained in this path. By convention, there is one file for each media type (e.g., application.yml, audio.yml, etc.).

System repackagers note: this is the constant that you would change if you repackage mime-types for your system. It is recommended that the path be something like /usr/share/ruby/mime-types/.

File.expand_path('../../../../data', __FILE__)

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(path = nil, container = nil) ⇒ Loader

Creates a Loader object that can be used to load MIME::Types registries into memory, using YAML, JSON, or v1 registry format loaders.


25
26
27
28
29
30
# File 'lib/mime/types/loader.rb', line 25

def initialize(path = nil, container = nil)
  path       = path || ENV['RUBY_MIME_TYPES_DATA'] ||
    MIME::Types::Loader::PATH
  @path      = File.expand_path(File.join(path, '**'))
  @container = container || MIME::Types.new
end

Instance Attribute Details

#containerObject (readonly)

The MIME::Types container instance that will be loaded. If not provided at initialization, a new MIME::Types instance will be constructed.


21
22
23
# File 'lib/mime/types/loader.rb', line 21

def container
  @container
end

#pathObject (readonly)

The path that will be read for the MIME::Types files.


18
19
20
# File 'lib/mime/types/loader.rb', line 18

def path
  @path
end

Class Method Details

.loadObject

Loads the default MIME::Type registry.


85
86
87
# File 'lib/mime/types/loader.rb', line 85

def load
  new.load
end

.load_from_json(filename) ⇒ Object

Loads MIME::Types from a single JSON file.

It is expected that the JSON objects will be an array of hash objects. The JSON format is the registry format for the MIME types registry shipped with the mime-types library.


198
199
200
201
# File 'lib/mime/types/loader.rb', line 198

def load_from_json(filename)
  require 'json'
  JSON.parse(read_file(filename)).map { |type| MIME::Type.new(type) }
end

.load_from_v1(filename) ⇒ Object

Build the type list from a file in the format:

[*][!][os:]mt/st[<ws>@ext][<ws>:enc][<ws>'url-list][<ws>=docs]

*

An unofficial MIME type. This should be used if and only if the MIME type is not properly specified (that is, not under either x-type or vnd.name.type).

!

An obsolete MIME type. May be used with an unofficial MIME type.

os:

Platform-specific MIME type definition.

mt

The media type.

st

The media subtype.

<ws>@ext

The list of comma-separated extensions.

<ws>:enc

The encoding.

<ws>'url-list

The list of comma-separated URLs.

<ws>=docs

The documentation string.

That is, everything except the media type and the subtype is optional. The more information that's available, though, the richer the values that can be provided.


125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
# File 'lib/mime/types/loader.rb', line 125

def load_from_v1(filename)
  MIME.deprecated(self.class, __method__)
  data = read_file(filename).split($/)
  mime = MIME::Types.new
  data.each_with_index { |line, index|
    item = line.chomp.strip
    next if item.empty?

    m = V1_FORMAT.match(item)

    unless m
      warn <<-EOS
#{filename}:#{index + 1}: Parsing error in v1 MIME type definition.
=> #{line}
      EOS
      raise BadV1Format, line
    end

    unregistered, obsolete, platform, mediatype, subtype, extensions,
      encoding, urls, docs, _ = *m.captures

    next if mediatype.nil?

    extensions &&= extensions.split(/,/)
    urls &&= urls.split(/,/)

    if docs.nil?
      use_instead = nil
    else
      use_instead = docs.scan(%r{use-instead:(\S+)}).flatten
      docs = docs.gsub(%r{use-instead:\S+}, "").squeeze(" \t")
    end

    mime_type = MIME::Type.new("#{mediatype}/#{subtype}") do |t|
      t.extensions  = extensions
      t.encoding    = encoding
      t.system      = platform
      t.obsolete    = obsolete
      t.registered  = false if unregistered
      t.use_instead = use_instead
      t.docs        = docs
      t.references  = urls
    end

    mime.add_type(mime_type, true)
  }
  mime
end

.load_from_yaml(filename) ⇒ Object

Loads MIME::Types from a single YAML file.

It is expected that the YAML objects contained within the registry array will be tagged as !ruby/object:MIME::Type.

Note that the YAML format is about 2½ times slower than either the v1 format or the JSON format.

NOTE: The purpose of this format is purely for maintenance reasons.


183
184
185
186
187
188
189
190
191
# File 'lib/mime/types/loader.rb', line 183

def load_from_yaml(filename)
  begin
    require 'psych'
  rescue LoadError
    nil
  end
  require 'yaml'
  YAML.load(read_file(filename))
end

Instance Method Details

#load_jsonObject Also known as: load

Loads a MIME::Types registry from JSON files (*.json) recursively found in path.

It is expected that the JSON objects will be an array of hash objects. The JSON format is the registry format for the MIME types registry shipped with the mime-types library.

This method is aliased to #load.


57
58
59
60
61
62
63
# File 'lib/mime/types/loader.rb', line 57

def load_json
  Dir[json_path].sort.each do |f|
    types = self.class.load_from_json(f)
    container.add(*types, :silent)
  end
  container
end

#load_v1Object

Loads a MIME::Types registry from files found in path that are in the v1 data format. The file search for this will exclude both JSON (*.json) and YAML (*.yml or *.yaml) files.

This method has been deprecated.


71
72
73
74
75
76
77
78
# File 'lib/mime/types/loader.rb', line 71

def load_v1
  MIME.deprecated(self.class, __method__)
  Dir[v1_path].sort.each do |f|
    next if f =~ /\.ya?ml$|\.json$/
    container.add(self.class.load_from_v1(f), true)
  end
  container
end

#load_yamlObject

Loads a MIME::Types registry from YAML files (*.yml or *.yaml) recursively found in path.

It is expected that the YAML objects contained within the registry array will be tagged as !ruby/object:MIME::Type.

Note that the YAML format is about 2½ times slower than either the v1 format or the JSON format.

NOTE: The purpose of this format is purely for maintenance reasons.


42
43
44
45
46
47
# File 'lib/mime/types/loader.rb', line 42

def load_yaml
  Dir[yaml_path].sort.each do |f|
    container.add(*self.class.load_from_yaml(f), :silent)
  end
  container
end