# mime-types¶ ↑

home

  github.com/mime-types/ruby-mime-types/

code

  github.com/mime-types/ruby-mime-types/

bugs

  github.com/mime-types/ruby-mime-types/issues

rdoc

  rdoc.info/gems/mime-types/

continuous integration

test coverage

## Description¶ ↑

The mime-types library provides a library and registry for information about MIME content type definitions. It can be used to determine defined filename extensions for MIME types, or to use filename extensions to look up the likely MIME type definitions.

MIME content types are used in MIME-compliant communications, as in e-mail or HTTP traffic, to indicate the type of content which is transmitted. The mime-types library provides the ability for detailed information about MIME entities (provided as an enumerable collection of MIME::Type objects) to be determined and used. There are many types defined by RFCs and vendors, so the list is long but by definition incomplete; don't hesitate to add additional type definitions. MIME type definitions found in mime-types are from RFCs, W3C recommendations, the IANA Media Types registry, and user contributions. It conforms to RFCs 2045 and 2231.

This is release 2.6 with two new experimental features. The first new feature is a new default registry storage format that greatly reduces the initial memory use of the mime-types library. This feature is enabled by requiring `mime/types/columnar` instead of `mime/types` with a small performance cost and no change in total memory use if certain methods are called (see Columnar Store for more details). The second new feature is a logger interface that conforms to the expectations of an ActiveSupport::Logger so that warnings can be written to an application's log rather than the default location for `warn`. This interface may be used for other logging purposes in the future.

mime-types 2.6 is the last planned version of mime-types 2.x, so deprecation warnings are no longer cached but provided every time the method is called. mime-types 2.6 supports Ruby 1.9.2 or later.

### mime-types 1.x End of Life¶ ↑

mime-types 2.0 was released in late 2013, and as of early 2015 there have been no reported security issues for mime-types 1.x. With the release of mime-types 2.5, I set the formal End of Life for mime-types 1.x for 2015-10-27 (the second anniversary of the release of mime-types 2.0). After this date, absolutely no pull requests for mime-types 1.x will be accepted.

### mime-types Future¶ ↑

There are a number of issues open that make clear to me that there are some fundamental changes that need to happen to both the data representation and the API provided by mime-types. This cannot happen under the current release, so all new development is focussing on an upcoming 3.0 release. The target for the release is on or before the beginning of RubyConf 2015 (2015-11-15).

When 3.0 is released, mime-types 2.x will receive regular updates of the IANA registry for two years following the release. It will also receive security updates, if needed, for the same period. There will be no further feature development on mime-types 2.x following the 3.0 release.

Coincident with the 3.0 release, I will release mime-types 2.99.0 that no longer imports the data to fields that have been deprecated, or exports it if it is present. If they work because they derive data from the data that is still present, the will continue to work. The quarterly updates will be against 2.99.x.

If the possible loss of this deprecated data matters, be sure to set your dependency appropriately:

    gem 'mime-types', '~> 2.6, < 2.99'

## Synopsis¶ ↑

MIME types are used in MIME entities, as in email or HTTP traffic. It is useful at times to have information available about MIME types (or, inversely, about files). A MIME::Type stores the known information about one MIME type.

    require 'mime/types'

    plaintext = MIME::Types['text/plain'] # => [ text/plain ]
    text = plaintext.first
    puts text.media_type            # => 'text'
    puts text.sub_type              # => 'plain'

    puts text.extensions.join(' ')  # => 'txt asc c cc h hh cpp hpp dat hlp'
    puts text.preferred_extension   # => 'txt'
    puts text.friendly              # => 'Text Document'
    puts text.i18n_key              # => 'text.plain'

    puts text.encoding              # => quoted-printable
    puts text.default_encoding      # => quoted-printable
    puts text.binary?               # => false
    puts text.ascii?                # => true
    puts text.obsolete?             # => false
    puts text.registered?           # => true
    puts text.complete?             # => true

    puts text                       # => 'text/plain'

    puts text == 'text/plain'       # => true
    puts 'text/plain' == text       # => true
    puts text == 'text/x-plain'     # => false
    puts 'text/x-plain' == text     # => false

    puts MIME::Type.simplified('x-appl/x-zip') # => 'appl/zip'
    puts MIME::Type.i18n_key('x-appl/x-zip') # => 'appl.zip'

    puts text.like?('text/x-plain') # => true
    puts text.like?(MIME::Type.new('x-text/x-plain')) # => true

    puts text.xrefs.inspect # => { "rfc" => [ "rfc2046", "rfc3676", "rfc5147" ] }
    puts text.urls # => [ "http://www.iana.org/go/rfc2046",
                   #      "http://www.iana.org/go/rfc3676",
                   #      "http://www.iana.org/go/rfc5147" ]

    xtext = MIME::Type.new('x-text/x-plain')
    puts xtext.media_type # => 'text'
    puts xtext.raw_media_type # => 'x-text'
    puts xtext.sub_type # => 'plain'
    puts xtext.raw_sub_type # => 'x-plain'
    puts xtext.complete? # => false

    puts MIME::Types.any? { |type| type.content_type == 'text/plain' } # => true
    puts MIME::Types.all?(&:registered?) # => false

    # Various string representations of MIME types
    qcelp = MIME::Types['audio/QCELP'].first # => audio/QCELP
    puts qcelp.content_type         # => 'audio/QCELP'
    puts qcelp.simplified           # => 'audio/qcelp'

    xwingz = MIME::Types['application/x-Wingz'].first # => application/x-Wingz
    puts xwingz.content_type        # => 'application/x-Wingz'
    puts xwingz.simplified          # => 'application/wingz'

### Columnar Store¶ ↑

mime-types 2.6 has an experimental columnar storage format that reduces the default memory footprint. It does this by selectively loading data. When a registry is first loaded from a columnar store, only the canonical MIME type and registered extensions will be loaded and the MIME type will be connected to its registry. When extended data is required (including registered, obsolete, use_instead), that data is loaded from its own column file for all types in the registry. This load is done with a Mutex to ensure that the types are updated safely in a multithreaded environment.

Columnar storage is slated to become the default storage format for mime-types 3.0, but until that is released, the default is still to use the JSON storage format. As such, columnar storage can only currently be loaded at an application level with the following specification in the application Gemfile:

    gem 'mime-types', require: 'mime/types/columnar'

Projects that do not use Bundler, and libraries that wish to suggest this behaviour to applications are encouraged to require this directly, but only if you specify a dependency on mime-types 2.6.

    require 'mime/types/columnar'

Although this require will not be necessary after mime-types 3, it will work through at least version 4 and possibly beyond.

Note that the new Columnar class (MIME::Type::Columnar) and module (MIME::Types::Columnar) are considered private variant implementations of MIME::Type and MIME::Types and the specific implementation should not be relied upon by consumers of the mime-types library. Instead, depend on the public implementations only.

### Cached Storage¶ ↑

Since version 2.0, mime-types has supported a cache of MIME types based on `Marshal.dump`. The cache is invalidated for each released version of mime-types so that version 2.5 is not reused for version 2.6. If the environment variable `RUBY_MIME_TYPES_CACHE` is set to a cache file, mime-types will attempt to load the MIME type registry from the cache file. If it cannot, it will load the types normally and then saves the registry to the cache file.

The current mime-types cache is not compatible with the columnar storage format. This will be resolved for mime-types 3.

## mime-types Modified Semantic Versioning¶ ↑

The mime-types library has one version number, but this single version number tracks both API changes and registry data changes; this is not wholly compatible with all aspects of Semantic Versioning; removing a MIME type from the registry could be considered a breaking change under some interpretations of semantic versioning (as lookups for that particular type would no longer work by default).

mime-types uses a modified semantic versioning scheme. Given the version MAJOR.MINOR:

1. If an incompatible API (code) change is made, the MAJOR version will be incremented, MINOR will be set to zero, and PATCH will be reset to the implied zero.

2. If an API (code) feature is added that does not break compatibilty OR if there are MIME types added, removed, or changed in the registry, the MINOR version will be incremented and PATCH will be reset to the implied zero.

3. If there is a bugfix to a feature added in the most recent MAJOR.MINOR release, OR if purely typographical errors are fixed in MIME types, the implied PATCH value will be incremented resulting in MAJOR.MINOR.PATCH.

In practical terms, there should be a MINOR release roughly monthly to track updated or changed MIME types from the official IANA registry. This does not indicate when new API features have been added, but all minor versions of mime-types 2.x will be backwards compatible; the interfaces marked deprecated will be removed in mime-types 3.x.

## Contributing¶ ↑

I value any contribution to mime-types you can provide: a bug report, a feature request, or code contributions.

There are a few guidelines for contributing to mime-types:

- Code changes will not be accepted without tests. The test suite is written with Minitest.

- Match my coding style.

- Use a thoughtfully-named topic branch that contains your change. Rebase your commits into logical chunks as necessary.

- Use quality commit messages.

- Do not change the version number; when your patch is accepted and a release is made, the version will be updated at that point.

- Submit a GitHub pull request with your changes.

- New or changed behaviours require new or updated documentation.

### Adding or Modifying MIME Types¶ ↑

The mime-types registry is loaded from encoded files in `data`. These are not editable and cannot be compared meaningfully in a pull request; pull requests that include changes to these files will require amendment to revert these files.

New or modified MIME types should be edited in the appropriate YAML file under `type-lists`. The format is as shown below for the `application/xml` MIME type in `type-lists/application.yml`.

    - !ruby/object:MIME::Type
      content-type: application/xml
      encoding: 8bit
      extensions:
      - xml
      - xsl
      references:
      - IANA
      - RFC3023
      xrefs: !ruby/hash:MIME::Types::Container
        rfc:
        - rfc3023
      registered: true

There are other fields that can be added, matching the fields discussed in the documentation for MIME::Type. Pull requests for MIME types should just contain the changes to the YAML files for the new or modified MIME types; I will convert the YAML files to JSON prior to a new release. I would rather not have to verify that the JSON matches the YAML changes, which is why it is not necessary to convert for the pull request.

If you are making a change for a private fork, use `rake convert:yaml:json` to convert the YAML to JSON, or `rake convert:yaml:columnar` to convert it to the new columnar format.

#### Updating Types from the IANA or Apache Lists¶ ↑

If you are maintaining a private fork and wish to update your copy of the MIME types registry used by this gem, you can do this with the rake tasks:

    $ rake mime:iana
    $ rake mime:apache

Both of these require Nokogiri, which is not installed by default. Install it in the usual way for your Ruby.

### Test Dependencies¶ ↑

mime-types uses Ryan Davis’s Hoe to manage the release process, and it adds a number of rake tasks. You will mostly be interested in:

    $ rake

which runs the tests the same way that:

    $ rake test
    $ rake travis

will do.

To assist with the installation of the development dependencies for mime-types, I have provided the simplest possible Gemfile pointing to the (generated) `mime-types.gemspec` file. This will permit you to do:

    $ bundle install

to get the development dependencies. If you aleady have `hoe` installed, you can accomplish the same thing with:

    $ rake newb

This task will install any missing dependencies, run the tests/specs, and generate the RDoc.

You can run tests with code coverage analysis by running:

    $ rake test:coverage

### Benchmarks¶ ↑

mime-types offers several benchmark tasks to measure different measures of performance.

There is a repeated load test, measuring how long it takes to start and load mime-types with its full registry. By default, it runs fifty loops and uses the built-in benchmark library.

    $ rake benchmark:load

There are two allocation tracing benchmarks (for normal and columnar loads). These can only be run on Ruby 2.1 or better and requires the allocation_tracer gem (not installed by default).

    $ rake benchmark:allocations
    $ rake benchmark:allocations:columnar

There are two loaded object count benchmarks (for normal and columnar loads). These use `ObjectSpace.count_objects`.

    $ rake benchmark:objects
    $ rake benchmark:objects:columnar

### Workflow¶ ↑

Here's the most direct way to get your work merged into the project:

- Fork the project.

- Clone down your fork (`git clone git://github.com/<username>/ruby-mime-types.git`).

- Create a topic branch to contain your change (`git checkout -b my_awesome_feature`).

- Hack away, add tests. Not necessarily in that order.

- Make sure everything still passes by running `rake`.

- If necessary, rebase your commits into logical chunks, without errors.

- Push the branch up (`git push origin my_awesome_feature`).

- Create a pull request against mime-types/ruby-mime-types and describe what your change does and the why you think it should be merged.

### Contributors¶ ↑

- Austin Ziegler created mime-types.

Thanks to everyone else who has contributed to mime-types:

- Aaron Patterson

- Aggelos Avgerinos

- Andre Pankratz

- Andy Brody

- Arnaud Meuret

- Brandon Galbraith

- Chris Gat

- David Genord

- Eric Marden

- Garret Alfert

- Godfrey Chan

- Greg Brockman

- Hans de Graaff

- Henrik Hodne

- Jeremy Evans

- Juanito Fatas

- Łukasz Śliwa

- Keerthi Siva

- Ken Ip

- Martin d'Allens

- Mauricio Linhares

- nycvotes-dev

- Postmodern

- Richard Hirner

- Richard Hurt

- Richard Schneeman

- Tibor Szolár

- Todd Carrico

## Licence¶ ↑

This software is available under three licences: the GNU GPL version 2 (or at your option, a later version), the Perl Artistic License, or the MIT License. The licence preferred by me is the MIT licence.

The original Perl MIME::Types was dually originally licensed with the Perl Artistic Licence and the GNU GPL (“the same terms as Perl itself”) and given that the Ruby implementation originally hewed pretty closely to the Perl version, I chose to maintain the additional licensing terms.

- Copyright 2003–2015 Austin Ziegler.

- Adapted from MIME::Types (Perl) by Mark Overmeer.

### MIT License¶ ↑

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

### Perl Artistic License (version 2)¶ ↑

See the file docs/artistic.txt in the main distribution.

### GNU GPL version 2¶ ↑

See the file docs/COPYING.txt in the main distribution.