mime-types 2.99.3 → 3.3.1

data/lib/mime/types/cache.rb

@@ -1,80 +1,58 @@
-# -*- ruby encoding: utf-8 -*-
-
-class MIME::Types
-  Cache = Struct.new(:version, :data) # :nodoc:
-
-  # 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.
-  class Cache
-    class << self
-      # 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 ||= ENV['RUBY_MIME_TYPES_CACHE']
-        return nil unless cache_file and File.exist?(cache_file)
-
-        cache = Marshal.load(File.binread(cache_file))
-        if cache.version == MIME::Types::VERSION
-          Marshal.load(cache.data)
-        else
-          MIME::Types.logger.warn <<-warning.chomp
+# frozen_string_literal: true
+
+MIME::Types::Cache = Struct.new(:version, :data) # :nodoc:
+
+# 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-data-version basis; a cache file for
+# version 3.2015.1118 will not be reused with version 3.2015.1201.
+class << MIME::Types::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 ||= ENV['RUBY_MIME_TYPES_CACHE']
+    return nil unless cache_file and File.exist?(cache_file)
+
+    cache = Marshal.load(File.binread(cache_file))
+    if cache.version == MIME::Types::Data::VERSION
+      Marshal.load(cache.data)
+    else
+      MIME::Types.logger.warn <<-WARNING.chomp
 Could not load MIME::Types cache: invalid version
-          warning
-          nil
-        end
-      rescue => e
-        MIME::Types.logger.warn <<-warning.chomp
-Could not load MIME::Types cache: #{e}
-        warning
-        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 ||= ENV['RUBY_MIME_TYPES_CACHE']
-        return nil unless cache_file
-
-        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
+      WARNING
+      nil
     end
+  rescue => e
+    MIME::Types.logger.warn <<-WARNING.chomp
+Could not load MIME::Types cache: #{e}
+    WARNING
+    nil
   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.default_proc = ->(h, k) { h[k] = [] }
-      self.merge!(hash)
+  # 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 ||= ENV['RUBY_MIME_TYPES_CACHE']
+    return nil unless cache_file
+
+    types ||= MIME::Types.send(:__types__)
+
+    File.open(cache_file, 'wb') do |f|
+      f.write(
+        Marshal.dump(new(MIME::Types::Data::VERSION, Marshal.dump(types)))
+      )
     end
   end
 end

data/lib/mime/types/columnar.rb

@@ -1,148 +1,3 @@
-module MIME
-  class Types
-  end
-end
+# frozen_string_literal: true
 
-require 'mime/type/columnar'
-
-# MIME::Types::Columnar is used to extend a MIME::Types container to load data
-# by columns instead of from JSON or YAML. Column loads of MIME types loaded
-# through the columnar store are synchronized with a Mutex.
-#
-# MIME::Types::Columnar is not intended to be used directly, but will be added
-# to an instance of MIME::Types when it is loaded with
-# MIME::Types::Loader#load_columnar.
-module MIME::Types::Columnar
-  LOAD_MUTEX = Mutex.new # :nodoc:
-
-  def self.extended(obj) # :nodoc:
-    super
-    obj.instance_variable_set(:@__mime_data__, [])
-    obj.instance_variable_set(:@__attributes__, [])
-  end
-
-  # Load the first column data file (type and extensions).
-  def load_base_data(path) #:nodoc:
-    @__root__ = path
-
-    each_file_line('content_type', false) do |line|
-      content_type, *extensions = line.split
-
-      type = MIME::Type::Columnar.new(self, content_type, extensions)
-      @__mime_data__ << type
-      add(type)
-    end
-
-    self
-  end
-
-  private
-
-  def each_file_line(name, lookup = true)
-    LOAD_MUTEX.synchronize do
-      next if @__attributes__.include?(name)
-
-      File.open(File.join(@__root__, "mime.#{name}.column"), 'r:UTF-8') do |f|
-        i = -1
-
-        f.each_line do |line|
-          line.chomp!
-
-          if lookup
-            type = @__mime_data__[i += 1] or next
-            yield type, line
-          else
-            yield line
-          end
-        end
-      end
-
-      @__attributes__ << name
-    end
-  end
-
-  def load_encoding
-    pool = {}
-    each_file_line('encoding') do |type, line|
-      line.freeze
-      type.encoding = (pool[line] ||= line)
-    end
-  end
-
-  def load_docs
-    each_file_line('docs') do |type, line|
-      type.docs = arr(line)
-    end
-  end
-
-  def load_obsolete
-    each_file_line('obsolete') do |type, line|
-      type.obsolete = bool(line)
-    end
-  end
-
-  def load_registered
-    each_file_line('registered') do |type, line|
-      type.registered = bool(line)
-    end
-  end
-
-  def load_signature
-    each_file_line('signature') do |type, line|
-      type.signature = bool(line)
-    end
-  end
-
-  def load_xrefs
-    each_file_line('xrefs') { |type, line| type.xrefs = dict(line) }
-  end
-
-  def load_friendly
-    each_file_line('friendly') { |type, line|
-      v = dict(line)
-      type.friendly = v.empty? ? nil : v
-    }
-  end
-
-  def load_use_instead
-    each_file_line('use_instead') do |type, line|
-      type.use_instead = (line unless line == '-'.freeze)
-    end
-  end
-
-  def dict(line)
-    if line == '-'.freeze
-      {}
-    else
-      line.split('|'.freeze).each_with_object({}) { |l, h|
-        k, v = l.split('^'.freeze)
-        v = [ nil ] if v.empty?
-        h[k] = v
-      }
-    end
-  end
-
-  def arr(line)
-    if line == '-'.freeze
-      []
-    else
-      line.split('|'.freeze).flatten.compact.uniq
-    end
-  end
-
-  def bool(line)
-    line == '1'.freeze ? true : false
-  end
-end
-
-unless MIME::Types.private_method_defined?(:load_mode)
-  class << MIME::Types
-    private
-
-    def load_mode
-      { columnar: true }
-    end
-  end
-
-  require 'mime/types'
-end
+require 'mime/types'

data/lib/mime/types/container.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'forwardable'
+
+# MIME::Types requires a serializable keyed container that returns an empty Set
+# on a key miss. Hash#default_value cannot be used because, while it traverses
+# the Marshal format correctly, it won't survive any other serialization
+# format (plus, a default of a mutable object resuls in a shared mess).
+# Hash#default_proc cannot be used without a wrapper because it prevents
+# Marshal serialization (and doesn't survive the round-trip).
+class MIME::Types::Container #:nodoc:
+  extend Forwardable
+
+  def initialize(hash = {})
+    @container = {}
+    merge!(hash)
+  end
+
+  def [](key)
+    container[key] || EMPTY_SET
+  end
+
+  def []=(key, value)
+    container[key] =
+      case value
+      when Set
+        value
+      else
+        Set[*value]
+      end
+  end
+
+  def merge(other)
+    self.class.new(other)
+  end
+
+  def merge!(other)
+    tap {
+      other = other.kind_of?(MIME::Types::Container) ? other.container : other
+      container.merge!(other)
+      normalize
+    }
+  end
+
+  def to_hash
+    container
+  end
+
+  def_delegators :@container,
+                 :==,
+                 :count,
+                 :each,
+                 :each_value,
+                 :empty?,
+                 :flat_map,
+                 :keys,
+                 :select,
+                 :values
+
+  def add(key, value)
+    (container[key] ||= Set.new).add(value)
+  end
+
+  def marshal_dump
+    {}.merge(container)
+  end
+
+  def marshal_load(hash)
+    @container = hash
+  end
+
+  def encode_with(coder)
+    container.each { |k, v| coder[k] = v.to_a }
+  end
+
+  def init_with(coder)
+    @container = {}
+    coder.map.each { |k, v| container[k] = Set[*v] }
+  end
+
+  protected
+
+  attr_accessor :container
+
+  def normalize
+    container.each do |k, v|
+      next if v.kind_of?(Set)
+
+      container[k] = Set[*v]
+    end
+  end
+
+  EMPTY_SET = Set.new.freeze
+  private_constant :EMPTY_SET
+end

data/lib/mime/types/deprecations.rb

@@ -1,9 +1,10 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'mime/types/logger'
 
 # The namespace for MIME applications, tools, and libraries.
 module MIME
+  ##
   class Types
     # Used to mark a method as deprecated in the mime-types interface.
     def self.deprecated(klass, sym, message = nil, &block) # :nodoc:
@@ -22,32 +23,10 @@ module MIME
                 else
                   message
                 end
-      MIME::Types.logger.warn <<-warning.chomp
+      MIME::Types.logger.warn <<-WARNING.chomp
 #{caller[1]}: #{klass}#{level}#{sym} is deprecated #{message}.
-      warning
+      WARNING
       block.call if block
     end
   end
-
-  class << self
-    # MIME::InvalidContentType was moved to MIME::Type::InvalidContentType.
-    # Provide a single warning about this fact in the interim.
-    def const_missing(name) # :nodoc:
-      case name.to_s
-      when 'InvalidContentType'
-        warn_about_moved_constants(name)
-        MIME::Type.const_get(name.to_sym)
-      else
-        super
-      end
-    end
-
-    private
-
-    def warn_about_moved_constants(name)
-      MIME::Types.logger.warn <<-warning.chomp
-#{caller[1]}: MIME::#{name} is deprecated. Use MIME::Type::#{name} instead.
-      warning
-    end
-  end
 end

data/lib/mime/types/full.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+##
+module MIME
+  ##
+  class Types
+    unless private_method_defined?(:load_mode)
+      class << self
+        private
+
+        def load_mode
+          { columnar: false }
+        end
+      end
+    end
+  end
+end
+
+require 'mime/types'

data/lib/mime/types/loader.rb

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 # -*- ruby encoding: utf-8 -*-
 
+##
 module MIME; end
+##
 class MIME::Types; end
 
-require 'mime/types/loader_path'
+require 'mime/types/data'
 
 # This class is responsible for initializing the MIME::Types registry from
 # the data files supplied with the mime-types library.
@@ -11,7 +15,7 @@ require 'mime/types/loader_path'
 # 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.
+# 3.  The value of MIME::Types::Data::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
@@ -24,15 +28,11 @@ class MIME::Types::Loader
   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.
+  # into memory, using YAML, JSON, or Columnar registry format loaders.
   def initialize(path = nil, container = nil)
-    path = path || ENV['RUBY_MIME_TYPES_DATA'] || MIME::Types::Loader::PATH
+    path = path || ENV['RUBY_MIME_TYPES_DATA'] || MIME::Types::Data::PATH
     @container = container || MIME::Types.new
     @path = File.expand_path(path)
-    # begin
-    #   require 'mime/lazy_types'
-    #   @container.extend(MIME::LazyTypes)
-    # end
   end
 
   # Loads a MIME::Types registry from YAML files (<tt>*.yml</tt> or
@@ -41,8 +41,7 @@ class MIME::Types::Loader
   # 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 that the YAML format is about 2½ times *slower* than the JSON format.
   #
   # NOTE: The purpose of this format is purely for maintenance reasons.
   def load_yaml
@@ -89,122 +88,19 @@ class MIME::Types::Loader
     end
   end
 
-  # 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 and will be removed from mime-types 3.0.
-  def load_v1
-    MIME::Types.deprecated(self.class, __method__)
-    Dir[v1_path].sort.each do |f|
-      next if f =~ /\.(?:ya?ml|json|column)$/
-      container.add(self.class.load_from_v1(f, true), true)
-    end
-    container
-  end
-
-  # Raised when a V1 format file is discovered. This exception will be removed
-  # for mime-types 3.0.
-  BadV1Format = Class.new(Exception)
-
   class << self
     # Loads the default MIME::Type registry.
     def load(options = { columnar: false })
       new.load(options)
     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.
-    #
-    # This method has been deprecated and will be removed in mime-types 3.0.
-    def load_from_v1(filename, __internal__ = false)
-      MIME::Types.deprecated(self.class, __method__) unless __internal__
-      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
-          MIME::Types.logger.warn <<-EOS
-#{filename}:#{index + 1}: Parsing error in v1 MIME type definition.
-=> #{line}
-          EOS
-          fail BadV1Format, line
-        end
-
-        unregistered, obsolete, _, 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.first
-          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.obsolete    = obsolete
-          t.registered  = false if unregistered
-          t.use_instead = use_instead
-          t.docs        = docs
-        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 that the YAML format is about 2½ times *slower* than the JSON
+    # format.
     #
     # NOTE: The purpose of this format is purely for maintenance reasons.
     def load_from_yaml(filename)
@@ -230,7 +126,7 @@ class MIME::Types::Loader
     private
 
     def read_file(filename)
-      File.open(filename, 'r:UTF-8:-') { |f| f.read }
+      File.open(filename, 'r:UTF-8:-', &:read)
     end
   end
 
@@ -247,29 +143,4 @@ class MIME::Types::Loader
   def columnar_path
     File.join(path, '*.column')
   end
-
-  def v1_path
-    File.join(path, '*')
-  end
-
-  # The regular expression used to match a v1-format file-based MIME type
-  # definition.
-  #
-  # This constant has been deprecated and will be removed in mime-types 3.0.
-  V1_FORMAT = # :nodoc:
-    %r{\A\s*
-    ([*])?                                        # 0:    Unregistered?
-    (!)?                                          # 1:    Obsolete?
-    (?:(\w+):)?                                   # 2:    Platform marker
-    ([-\w.+]+)/([-\w.+]*)                         # 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*([#].*)?)?                              #       Comments
-    \s*
-    \z
-    }x
-
-  private_constant :V1_FORMAT if respond_to? :private_constant
 end