mime-types 2.99.3 → 3.0

data/lib/mime/type/columnar.rb

@@ -11,80 +11,45 @@ require 'mime/type'
 # MIME::Type::Columnar is *not* intended to be created except by
 # MIME::Types::Columnar containers.
 class MIME::Type::Columnar < MIME::Type
-  attr_writer :friendly # :nodoc:
-
   def initialize(container, content_type, extensions) # :nodoc:
     @container = container
     self.content_type = content_type
     self.extensions = extensions
   end
 
-  def friendly(*) # :nodoc:
-    @container.send(:load_friendly) unless defined?(@friendly)
-    super if @friendly
-  end
+  def self.column(*methods, file: nil) # :nodoc:
+    file = methods.first unless file
 
-  def encoding # :nodoc:
-    @container.send(:load_encoding) unless defined?(@encoding)
-    @encoding
+    file_method = :"load_#{file}"
+    methods.each do |m|
+      define_method m do |*args|
+        @container.send(file_method)
+        super(*args)
+      end
+    end
   end
 
-  def docs # :nodoc:
-    @container.send(:load_docs) unless defined?(@docs)
-    @docs
-  end
+  column :friendly
+  column :encoding, :encoding=
+  column :docs, :docs=
+  column :preferred_extension, :preferred_extension=
+  column :obsolete, :obsolete=, :obsolete?, :registered, :registered=,
+    :registered?, :signature, :signature=, :signature?, file: 'flags'
+  column :xrefs, :xrefs=, :xref_urls
+  column :use_instead, :use_instead=
 
-  def obsolete? # :nodoc:
-    @container.send(:load_obsolete) unless defined?(@obsolete)
-    super
-  end
-
-  def registered? # :nodoc:
-    @container.send(:load_registered) unless defined?(@registered)
-    super
-  end
-
-  def signature? # :nodoc:
-    @container.send(:load_signature) unless defined?(@signature)
-    super
-  end
-
-  def xrefs # :nodoc:
-    @container.send(:load_xrefs) unless defined?(@xrefs)
-    @xrefs
-  end
-
-  def use_instead # :nodoc:
-    @container.send(:load_use_instead) unless defined?(@use_instead)
-    @use_instead
-  end
-
-  def binary? # :nodoc:
-    @container.send(:load_encoding) unless defined?(@encoding)
-    super
-  end
-
-  def to_a # :nodoc:
-    @container.send(:load_encoding) unless defined?(@encoding)
-    @container.send(:load_docs) unless defined?(@docs)
-    super
-  end
-
-  def to_hash # :nodoc:
-    @container.send(:load_encoding) unless defined?(@encoding)
-    @container.send(:load_docs) unless defined?(@docs)
+  def encode_with(coder) # :nodoc:
+    @container.send(:load_friendly)
+    @container.send(:load_encoding)
+    @container.send(:load_docs)
+    @container.send(:load_flags)
+    @container.send(:load_use_instead)
+    @container.send(:load_xrefs)
+    @container.send(:load_preferred_extension)
     super
   end
 
-  def encode_with(coder) # :nodoc:
-    @container.send(:load_friendly) unless defined?(@friendly)
-    @container.send(:load_encoding) unless defined?(@encoding)
-    @container.send(:load_docs) unless defined?(@docs)
-    @container.send(:load_obsolete) unless defined?(@obsolete)
-    @container.send(:load_use_instead) unless defined?(@use_instead)
-    @container.send(:load_xrefs) unless defined?(@xrefs)
-    @container.send(:load_registered) unless defined?(@registered)
-    @container.send(:load_signature) unless defined?(@signature)
-    super
+  class << self
+    undef column
   end
 end

data/lib/mime/types.rb

@@ -1,6 +1,12 @@
-# -*- ruby encoding: utf-8 -*-
+##
+module MIME
+  ##
+  class Types
+  end
+end
 
-require 'mime/types/deprecations'
+require 'mime/types/logger'
+require 'mime/types/container'
 require 'mime/type'
 require 'mime/types/cache'
 require 'mime/types/loader'
@@ -66,37 +72,19 @@ class MIME::Types
 
   include Enumerable
 
-  # The data version.
-  attr_reader :data_version
-
   # Creates a new MIME::Types registry.
   def initialize
     @type_variants    = Container.new
     @extension_index  = Container.new
-    @data_version     = VERSION.dup.freeze
-  end
-
-  # This method is deprecated and will be removed in mime-types 3.0.
-  def add_type_variant(mime_type) # :nodoc:
-    MIME::Types.deprecated(self, __method__, :private)
-    add_type_variant!(mime_type)
-  end
-
-  # This method is deprecated and will be removed in mime-types 3.0.
-  def index_extensions(mime_type) # :nodoc:
-    MIME::Types.deprecated(self, __method__, :private)
-    index_extensions!(mime_type)
-  end
-
-  # This method is deprecated and will be removed in mime-types 3.0.
-  def defined_types # :nodoc:
-    MIME::Types.deprecated(self, __method__)
-    @type_variants.values.flatten
   end
 
   # Returns the number of known type variants.
   def count
-    @type_variants.values.reduce(0) { |m, o| m + o.size }
+    @type_variants.values.inject(0) { |a, e| a + e.size }
+  end
+
+  def inspect # :nodoc:
+    "#<#{self.class}: #{count} variants, #{@extension_index.count} extensions>"
   end
 
   # Iterates through the type variants.
@@ -108,7 +96,7 @@ class MIME::Types
     end
   end
 
-  @__types__  = nil
+  @__types__ = nil
 
   # Returns a list of MIME::Type objects, which may be empty. The optional
   # flag parameters are <tt>:complete</tt> (finds only complete MIME::Type
@@ -135,13 +123,7 @@ class MIME::Types
   #      without;
   #   5. Obsolete definitions use-instead clauses are compared.
   #   6. Sort on name.
-  #
-  # The previously supported (but deprecated) <tt>:platform</tt> flag is now ignored.
-  def [](type_id, flags = {})
-    if flags.key?(:platform)
-      MIME::Types.deprecated(self, __method__, 'using the :platform flag')
-    end
-
+  def [](type_id, complete: false, registered: false)
     matches = case type_id
               when MIME::Type
                 @type_variants[type_id.simplified]
@@ -151,7 +133,9 @@ class MIME::Types
                 @type_variants[MIME::Type.simplified(type_id)]
               end
 
-    prune_matches(matches, flags).sort { |a, b| a.priority_compare(b) }
+    prune_matches(matches, complete, registered).sort { |a, b|
+      a.priority_compare(b)
+    }
   end
 
   # Return the list of MIME::Types which belongs to the file based on its
@@ -166,17 +150,12 @@ class MIME::Types
   #     => [image/gif]
   #   puts MIME::Types.type_for(%w(citydesk.xml citydesk.gif))
   #     => [application/xml, image/gif, text/xml]
-  #
-  # The deprecated +platform+ flag is ignored.
-  def type_for(filename, platform = :deprecated)
-    types = Array(filename).flat_map { |fn|
+  def type_for(filename)
+    Array(filename).flat_map { |fn|
       @extension_index[fn.chomp.downcase[/\.?([^.]*?)$/, 1]]
-    }.compact.sort { |a, b| a.priority_compare(b) }.uniq
-
-    unless platform == :deprecated
-      MIME::Types.deprecated(self, __method__, 'using the platform parameter')
-    end
-    types
+    }.compact.inject(:+).sort { |a, b|
+      a.priority_compare(b)
+    }
   end
   alias_method :of, :type_for
 
@@ -194,7 +173,7 @@ class MIME::Types
         nil
       when MIME::Types
         variants = mime_type.instance_variable_get(:@type_variants)
-        add(*variants.values.flatten, quiet)
+        add(*variants.values.inject(:+).to_a, quiet)
       when Array
         add(*mime_type, quiet)
       else
@@ -217,110 +196,33 @@ Type #{type} is already registered as a variant of #{type.simplified}.
     index_extensions!(type)
   end
 
-  class << self
-    include Enumerable
-
-    # Load MIME::Types from a v1 file registry.
-    #
-    # This method has been deprecated and will be removed in mime-types 3.0.
-    def load_from_file(filename)
-      MIME::Types.deprecated(self, __method__)
-      MIME::Types::Loader.load_from_v1(filename)
-    end
-
-    # MIME::Types#[] against the default MIME::Types registry.
-    def [](type_id, flags = {})
-      __types__[type_id, flags]
-    end
-
-    # MIME::Types#count against the default MIME::Types registry.
-    def count
-      __types__.count
-    end
-
-    # MIME::Types#each against the default MIME::Types registry.
-    def each
-      if block_given?
-        __types__.each { |t| yield t }
-      else
-        enum_for(:each)
-      end
-    end
-
-    # MIME::Types#type_for against the default MIME::Types registry.
-    def type_for(filename, platform = :deprecated)
-      __types__.type_for(filename, platform)
-    end
-    alias_method :of, :type_for
-
-    # MIME::Types#add against the default MIME::Types registry.
-    def add(*types)
-      __types__.add(*types)
-    end
-
-    # Returns the currently defined cache file, if any.
-    #
-    # This method has been deprecated and will be removed in mime-types 3.0.
-    def cache_file
-      MIME::Types.deprecated(self, __method__)
-      ENV['RUBY_MIME_TYPES_CACHE']
-    end
-
-    def add_type_variant(mime_type) # :nodoc:
-      __types__.add_type_variant(mime_type)
-    end
-
-    def index_extensions(mime_type) # :nodoc:
-      __types__.index_extensions(mime_type)
-    end
-
-    private
-
-    def lazy_load?
-      (lazy = ENV['RUBY_MIME_TYPES_LAZY_LOAD']) && (lazy != 'false')
-    end
-
-    def __types__
-      (defined?(@__types__) and @__types__) or load_default_mime_types
-    end
-
-    unless private_method_defined?(:load_mode)
-      def load_mode
-        {}
-      end
-    end
-
-    def load_default_mime_types(mode = load_mode())
-      @__types__ = MIME::Types::Cache.load
-      unless @__types__
-        @__types__ = MIME::Types::Loader.load(mode)
-        MIME::Types::Cache.save(@__types__)
-      end
-      @__types__
-    end
-  end
-
   private
 
   def add_type_variant!(mime_type)
     @type_variants[mime_type.simplified] << mime_type
   end
 
+  def reindex_extensions!(mime_type)
+    return unless @type_variants[mime_type.simplified].include?(mime_type)
+    index_extensions!(mime_type)
+  end
+
   def index_extensions!(mime_type)
     mime_type.extensions.each { |ext| @extension_index[ext] << mime_type }
   end
 
-  def prune_matches(matches, flags)
-    matches.delete_if { |e| !e.complete? } if flags[:complete]
-    matches.delete_if { |e| !e.registered? } if flags[:registered]
+  def prune_matches(matches, complete, registered)
+    matches.delete_if { |e| !e.complete? } if complete
+    matches.delete_if { |e| !e.registered? } if registered
     matches
   end
 
   def match(pattern)
-    @type_variants.select { |k, _| k =~ pattern }.values.flatten
+    @type_variants.select { |k, _|
+      k =~ pattern
+    }.values.inject(:+)
   end
-
-  load_default_mime_types(load_mode) unless lazy_load?
 end
 
-# vim: ft=ruby
+require 'mime/types/columnar' unless defined?(MIME::Types::Columnar)
+require 'mime/types/registry'

data/lib/mime/types/cache.rb

@@ -1,80 +1,56 @@
-# -*- 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
+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
+    return 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