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

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.


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

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.


23
24
25
# File 'lib/mime/types/loader.rb', line 23

def container
  @container
end

#pathObject (readonly)

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


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

def path
  @path
end

Class Method Details

.loadObject

Loads the default MIME::Type registry.


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

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.


208
209
210
211
# File 'lib/mime/types/loader.rb', line 208

def load_from_json(filename)
  require 'json'
  JSON.load(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.


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
173
174
175
176
177
178
179
180
181
182
# File 'lib/mime/types/loader.rb', line 126

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

    begin
      m = MIME::Types::Loader::V1_FORMAT.match(item).captures
    rescue Exception
      warn <<-EOS
#{filename}:#{index}: Parsing error in v1 MIME type definition.
=> #{line}
      EOS
      raise
    end

    unregistered, obsolete, platform, mediatype, subtype, extensions,
      encoding, urls, docs, comment = *m

    if mediatype.nil?
      if comment.nil?
        warn <<-EOS
#{filename}:#{index}: Parsing error in v1 MIME type definition (no media type).
=> #{line}
        EOS
        raise
      end

      next
    end

    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.


193
194
195
196
197
198
199
200
201
# File 'lib/mime/types/loader.rb', line 193

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.


59
60
61
62
63
64
65
66
67
# File 'lib/mime/types/loader.rb', line 59

def load_json
  Dir[json_path].sort.each do |f|
    types = self.class.load_from_json(f).map { |type|
      MIME::Type.new(type)
    }
    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.


75
76
77
78
79
80
81
82
# File 'lib/mime/types/loader.rb', line 75

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.


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

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