mime-types 1.25.1 → 2.0

data/lib/mime/types/cache.rb

@@ -0,0 +1,73 @@
+# -*- ruby encoding: utf-8 -*-
+
+class MIME::Types
+  # Caching of MIME::Types registries is advisable if you will be loading
+  # the default registry relatively frequently. With the class methods on
+  # MIME::Types::Cache, any MIME::Types registry can be marshaled quickly
+  # and easily.
+  #
+  # The cache is invalidated on a per-version basis; a cache file for
+  # version 2.0 will not be reused with version 2.0.1.
+  Cache = Struct.new(:version, :data)
+
+  class << Cache
+    # Attempts to load the cache from the file provided as a parameter or in
+    # the environment variable +RUBY_MIME_TYPES_CACHE+. Returns +nil+ if the
+    # file does not exist, if the file cannot be loaded, or if the data in
+    # the cache version is different than this version.
+    def load(cache_file = nil)
+      cache_file = cache_file || ENV['RUBY_MIME_TYPES_CACHE']
+      return nil unless cache_file and File.exists?(cache_file)
+
+      cache = Marshal.load(File.binread(cache_file))
+      if cache.version == MIME::Types::VERSION
+        Marshal.load(cache.data)
+      else
+        warn "Could not load MIME::Types cache: invalid version"
+        nil
+      end
+    rescue => e
+      warn "Could not load MIME::Types cache: #{e}"
+      return nil
+    end
+
+    # Attempts to save the types provided to the cache file provided.
+    #
+    # If +types+ is not provided or is +nil+, the cache will contain the
+    # current MIME::Types default registry.
+    #
+    # If +cache_file+ is not provided or is +nil+, the cache will be written
+    # to the file specified in the environment variable
+    # +RUBY_MIME_TYPES_CACHE+. If there is no cache file specified either
+    # directly or through the environment, this method will return +nil+
+    def save(types = nil, cache_file = nil)
+      cache_file = cache_file || ENV['RUBY_MIME_TYPES_CACHE']
+      return nil unless cache_file
+
+      types      = types || MIME::Types.send(:__types__)
+
+      File.open(cache_file, 'wb') do |f|
+        f.write(Marshal.dump(new(types.data_version, Marshal.dump(types))))
+      end
+    end
+  end
+
+  # MIME::Types requires a container Hash with a default values for keys
+  # resulting in an empty array (<tt>[]</tt>), but this cannot be dumped
+  # through Marshal because of the presence of that default Proc. This class
+  # exists solely to satisfy that need.
+  class Container < Hash # :nodoc:
+    def initialize
+      super
+      self.default_proc = ->(h, k) { h[k] = [] }
+    end
+
+    def marshal_dump
+      {}.merge(self)
+    end
+
+    def marshal_load(hash)
+      self.merge!(hash)
+    end
+  end
+end

data/lib/mime/types/loader.rb

@@ -0,0 +1,248 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'mime/types/loader_path'
+
+# 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['RUBY_MIME_TYPES_DATA']; 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.
+#
+#
+class MIME::Types::Loader
+  # The path that will be read for the MIME::Types files.
+  attr_reader :path
+  # The MIME::Types container instance that will be loaded. If not provided
+  # at initialization, a new MIME::Types instance will be constructed.
+  attr_reader :container
+
+  # Creates a Loader object that can be used to load MIME::Types registries
+  # into memory, using YAML, JSON, or v1 registry format loaders.
+  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
+
+  # Loads a MIME::Types registry from YAML files (<tt>*.yml</tt> or
+  # <tt>*.yaml</tt>) recursively found in +path+.
+  #
+  # It is expected that the YAML objects contained within the registry array
+  # will be tagged as <tt>!ruby/object:MIME::Type</tt>.
+  #
+  # 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.
+  def load_yaml
+    Dir[yaml_path].sort.each do |f|
+      container.add(*self.class.load_from_yaml(f), :silent)
+    end
+    container
+  end
+
+  # Loads a MIME::Types registry from JSON files (<tt>*.json</tt>)
+  # 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.
+  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
+  alias_method :load, :load_json
+
+  # 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
+  # (<tt>*.json</tt>) and YAML (<tt>*.yml</tt> or <tt>*.yaml</tt>) files.
+  #
+  # This method has been deprecated.
+  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
+
+  class << self
+    # Loads the default MIME::Type registry.
+    def load
+      new.load
+    end
+
+    # 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.
+    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
+
+    # Loads MIME::Types from a single YAML file.
+    #
+    # It is expected that the YAML objects contained within the registry
+    # array will be tagged as <tt>!ruby/object:MIME::Type</tt>.
+    #
+    # 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.
+    def load_from_yaml(filename)
+      begin
+        require 'psych'
+      rescue LoadError
+        nil
+      end
+      require 'yaml'
+      YAML.load(read_file(filename))
+    end
+
+    # 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.
+    def load_from_json(filename)
+      require 'json'
+      JSON.load(read_file(filename)).map { |type| MIME::Type.new(type) }
+    end
+
+    private
+    def read_file(filename)
+      File.open(filename, 'r:UTF-8:-') { |f| f.read }
+    end
+  end
+
+  private
+  def yaml_path
+    File.join(path, '*.y{,a}ml')
+  end
+
+  def json_path
+    File.join(path, '*.json')
+  end
+
+  def v1_path
+    File.join(path, '*')
+  end
+
+  # The regular expression used to match a v1-format file-based MIME type
+  # definition.
+  MIME::Types::Loader::V1_FORMAT = # :nodoc:
+    %r{\A\s*
+    ([*])?                                 # 0: Unregistered?
+    (!)?                                   # 1: Obsolete?
+    (?:(\w+):)?                            # 2: Platform marker
+    #{MIME::Type::MEDIA_TYPE_RE}?          # 3,4: Media type
+    (?:\s+@(\S+))?                         # 5: Extensions
+    (?:\s+:(base64|7bit|8bit|quoted\-printable))?  # 6: Encoding
+    (?:\s+'(\S+))?                         # 7: URL list
+    (?:\s+=(.+))?                          # 8: Documentation
+    (?:\s*([#].*)?)?
+    \s*
+    \z
+    }x
+end

data/lib/mime/types/loader_path.rb

@@ -0,0 +1,16 @@
+# -*- ruby encoding: utf-8 -*-
+
+class MIME::Types::Loader
+  # 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/.
+  PATH = File.expand_path('../../../../data', __FILE__)
+end

data/support/benchmarker.rb

@@ -0,0 +1,55 @@
+# -*- ruby encoding: utf-8 -*-
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'benchmark'
+
+class Benchmarker
+  def self.benchmark(repeats)
+    new(repeats.to_i).benchmark
+  end
+
+  def initialize(repeats = nil)
+    @cache_file = File.expand_path('../cache.mtc', __FILE__)
+    @repeats    = repeats.to_i
+    @repeats    = 50 if repeats.zero?
+  end
+
+  def reload_mime_types(repeats = 1, force_load = false)
+    path = File.expand_path('../../lib', __FILE__)
+
+    repeats.times {
+      Object.send(:remove_const, :MIME) if defined? MIME
+      $LOADED_FEATURES.delete_if { |n| n =~ /#{path}/ }
+      require 'mime/types'
+      MIME::Types.send(:__types__) if force_load
+    }
+  end
+
+  def benchmark
+    remove_cache
+
+    Benchmark.bm(17) do |mark|
+      mark.report("Normal:") { reload_mime_types(@repeats) }
+
+      ENV['RUBY_MIME_TYPES_LAZY_LOAD'] = 'yes'
+      mark.report("Lazy:") { reload_mime_types(@repeats) }
+      mark.report("Lazy+Load:") { reload_mime_types(@repeats, true) }
+
+      ENV.delete('RUBY_MIME_TYPES_LAZY_LOAD')
+
+      ENV['RUBY_MIME_TYPES_CACHE'] = @cache_file
+      reload_mime_types
+
+      mark.report("Cached:") { reload_mime_types(@repeats) }
+      ENV['RUBY_MIME_TYPES_LAZY_LOAD'] = 'yes'
+      mark.report("Lazy Cached:") { reload_mime_types(@repeats) }
+      mark.report("Lazy Cached Load:") { reload_mime_types(@repeats, true) }
+    end
+  ensure
+    remove_cache
+  end
+
+  def remove_cache
+    File.unlink(@cache_file) if File.exist?(@cache_file)
+  end
+end

data/support/convert.rb

@@ -0,0 +1,130 @@
+# -*- ruby encoding: utf-8 -*-
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'mime/types'
+require 'fileutils'
+
+class Convert
+  class << self
+    def from_yaml(path = nil)
+      new(path: path, from: :yaml)
+    end
+
+    def from_json(path = nil)
+      new(path: path, from: :json)
+    end
+
+    def from_v1(path = nil)
+      new(path: path, from: :v1)
+    end
+
+    def from_yaml_to_json(args)
+      from_yaml(yaml_path(args.source)).
+        to_json(destination:    json_path(args.destination),
+                multiple_files: multiple_files(args.multiple_files))
+    end
+
+    def from_json_to_yaml(args)
+      from_json(json_path(args.source)).
+        to_yaml(destination:    yaml_path(args.destination),
+                multiple_files: multiple_files(args.multiple_files))
+    end
+
+    private :new
+
+    private
+    def yaml_path(path)
+      if path.nil? or path.empty?
+        'type-lists'
+      else
+        path
+      end
+    end
+
+    def json_path(path)
+      if path.nil? or path.empty?
+        'data'
+      else
+        path
+      end
+    end
+
+    def multiple_files(flag)
+      case flag
+      when "true", "yes"
+        true
+      else
+        false
+      end
+    end
+  end
+
+  def initialize(options = {})
+    if options[:path].nil? or options[:path].empty?
+      raise ArgumentError, ':path is required'
+    end
+    if options[:from].nil? or options[:from].empty?
+      raise ArgumentError, ':from is required'
+    end
+
+    path = options[:path]
+
+    @loader = MIME::Types::Loader.new(options[:path])
+    load_from(options[:from])
+  end
+
+  def to_json(options = {})
+    raise ArgumentError, 'destination is required' unless options[:destination]
+    write_types(options.merge(format: :json))
+  end
+
+  def to_yaml(options = {})
+    raise ArgumentError, 'destination is required' unless options[:destination]
+    write_types(options.merge(format: :yaml))
+  end
+
+  private
+  def load_from(source_type)
+    method = :"load_#{source_type}"
+    @loader.send(method)
+  end
+
+  def write_types(options)
+    if options[:multiple_files]
+      write_multiple_files(options)
+    else
+      write_one_file(options)
+    end
+  end
+
+  def write_one_file(options)
+    d = options[:destination]
+    d = File.join(d, "mime-types.#{options[:format]}") if File.directory?(d)
+
+    File.open(d, 'wb') { |f|
+      f.puts convert(@loader.container.map.sort, options[:format])
+    }
+  end
+
+  def write_multiple_files(options)
+    d = options[:destination]
+    if File.exist?(d) and not File.directory?(d)
+      raise ArgumentError, 'Cannot write multiple files to a file.'
+    end
+
+    FileUtils.mkdir_p d unless File.exist?(d)
+
+    media_types = MIME::Types.map(&:media_type).uniq
+    media_types.each { |media_type|
+      n = File.join(d, "#{media_type}.#{options[:format]}")
+      t = @loader.container.select { |e| e.media_type == media_type }
+      File.open(n, 'wb') { |f|
+        f.puts convert(t.sort, options[:format])
+      }
+    }
+  end
+
+  def convert(data, format)
+    data.send(:"to_#{format}")
+  end
+end