mime-types 2.5 → 2.6

data/lib/mime/type/columnar.rb

@@ -0,0 +1,112 @@
+require 'mime/type'
+
+# A version of MIME::Type that works hand-in-hand with a MIME::Types::Columnar
+# container to load data by columns.
+#
+# When a field is has not yet been loaded, that data will be loaded for all
+# types in the container before forwarding the message to MIME::Type.
+#
+# More information can be found in MIME::Types::Columnar.
+#
+# 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 encoding # :nodoc:
+    @container.send(:load_encoding) unless defined?(@encoding)
+    @encoding
+  end
+
+  def docs # :nodoc:
+    @container.send(:load_docs) unless defined?(@docs)
+    @docs
+  end
+
+  def obsolete? # :nodoc:
+    @container.send(:load_obsolete) unless defined?(@obsolete)
+    super
+  end
+
+  def references(*) # :nodoc:
+    @container.send(:load_references) unless defined?(@references)
+    super if @references
+  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 system?(*) # :nodoc:
+    @container.send(:load_system) unless defined?(@system)
+    super
+  end
+
+  def system # :nodoc:
+    @container.send(:load_system) unless defined?(@system)
+    @system
+  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_system) unless defined?(@system)
+    @container.send(:load_docs) unless defined?(@docs)
+    @container.send(:load_references) unless defined?(@references)
+    super
+  end
+
+  def to_hash # :nodoc:
+    @container.send(:load_encoding) unless defined?(@encoding)
+    @container.send(:load_system) unless defined?(@system)
+    @container.send(:load_docs) unless defined?(@docs)
+    @container.send(:load_references) unless defined?(@references)
+    super
+  end
+
+  def encode_with(coder) # :nodoc:
+    @container.send(:load_friendly) unless defined?(@friendly)
+    @container.send(:load_encoding) unless defined?(@encoding)
+    @container.send(:load_system) unless defined?(@system)
+    @container.send(:load_docs) unless defined?(@docs)
+    @container.send(:load_references) unless defined?(@references)
+    @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_system) unless defined?(@system)
+    @container.send(:load_registered) unless defined?(@registered)
+    @container.send(:load_signature) unless defined?(@signature)
+    super
+  end
+end

data/lib/mime/types.rb

@@ -1,5 +1,6 @@
 # -*- ruby encoding: utf-8 -*-
 
+require 'mime/types/deprecations'
 require 'mime/type'
 require 'mime/types/cache'
 require 'mime/types/loader'
@@ -75,18 +76,21 @@ class MIME::Types
     @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.deprecated(self, __method__, :private)
+    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.deprecated(self, __method__, :private)
+    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.deprecated(self, __method__)
+    MIME::Types.deprecated(self, __method__)
     @type_variants.values.flatten
   end
 
@@ -137,7 +141,7 @@ class MIME::Types
   # platform) is currently supported but deprecated.
   def [](type_id, flags = {})
     if flags[:platform]
-      MIME.deprecated(self, __method__, "using the :platform flag")
+      MIME::Types.deprecated(self, __method__, 'using the :platform flag')
     end
 
     matches = case type_id
@@ -173,8 +177,7 @@ class MIME::Types
     }.compact.sort { |a, b| a.priority_compare(b) }.uniq
 
     if platform
-      MIME.deprecated(self, __method__,
-                      "using the platform parameter")
+      MIME::Types.deprecated(self, __method__, 'using the platform parameter')
       types.select(&:platform?)
     else
       types
@@ -205,17 +208,18 @@ class MIME::Types
     end
   end
 
-  # Add a single MIME::Type object to the set of known types. If the type is
-  # already known, a warning will be displayed. The +quiet+ parameter may be
-  # a truthy value to suppress that warning.
-  def add_type(mime_type, quiet = false)
-    if !quiet and @type_variants[mime_type.simplified].include?(mime_type)
-      warn('Type %s is already registered as a variant of %s.' %
-           [ mime_type, mime_type.simplified ])
+  # Add a single MIME::Type object to the set of known types. If the +type+ is
+  # already known, a warning will be displayed. The +quiet+ parameter may be a
+  # truthy value to suppress that warning.
+  def add_type(type, quiet = false)
+    if !quiet and @type_variants[type.simplified].include?(type)
+      MIME::Types.logger.warn <<-warning
+Type #{type} is already registered as a variant of #{type.simplified}.
+      warning
     end
 
-    add_type_variant!(mime_type)
-    index_extensions!(mime_type)
+    add_type_variant!(type)
+    index_extensions!(type)
   end
 
   class << self
@@ -223,9 +227,9 @@ class MIME::Types
 
     # Load MIME::Types from a v1 file registry.
     #
-    # This method has been deprecated.
+    # This method has been deprecated and will be removed in mime-types 3.0.
     def load_from_file(filename)
-      MIME.deprecated(self, __method__)
+      MIME::Types.deprecated(self, __method__)
       MIME::Types::Loader.load_from_v1(filename)
     end
 
@@ -260,8 +264,10 @@ class MIME::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.deprecated(self, __method__)
+      MIME::Types.deprecated(self, __method__)
       ENV['RUBY_MIME_TYPES_CACHE']
     end
 
@@ -274,6 +280,7 @@ class MIME::Types
     end
 
     private
+
     def lazy_load?
       (lazy = ENV['RUBY_MIME_TYPES_LAZY_LOAD']) && (lazy != 'false')
     end
@@ -282,10 +289,16 @@ class MIME::Types
       (defined?(@__types__) and @__types__) or load_default_mime_types
     end
 
-    def load_default_mime_types
+    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
+        @__types__ = MIME::Types::Loader.load(mode)
         MIME::Types::Cache.save(@__types__)
       end
       @__types__
@@ -293,6 +306,7 @@ class MIME::Types
   end
 
   private
+
   def add_type_variant!(mime_type)
     @type_variants[mime_type.simplified] << mime_type
   end
@@ -302,17 +316,17 @@ class MIME::Types
   end
 
   def prune_matches(matches, flags)
-    matches.delete_if { |e| not e.complete? } if flags[:complete]
-    matches.delete_if { |e| not e.platform? } if flags[:platform]
-    matches.delete_if { |e| not e.registered? } if flags[:registered]
+    matches.delete_if { |e| !e.complete? } if flags[:complete]
+    matches.delete_if { |e| !e.platform? } if flags[:platform]
+    matches.delete_if { |e| !e.registered? } if flags[:registered]
     matches
   end
 
   def match(pattern)
-    @type_variants.select { |k, v| k =~ pattern }.values.flatten
+    @type_variants.select { |k, _| k =~ pattern }.values.flatten
   end
 
-  load_default_mime_types unless lazy_load?
+  load_default_mime_types(load_mode) unless lazy_load?
 end
 
 # vim: ft=ruby

data/lib/mime/types/cache.rb

@@ -1,6 +1,8 @@
 # -*- 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
@@ -8,46 +10,50 @@ class MIME::Types
   #
   # 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.exist?(cache_file)
+  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
-        warn "Could not load MIME::Types cache: invalid version"
-        nil
+        cache = Marshal.load(File.binread(cache_file))
+        if cache.version == MIME::Types::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
-    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
+      # 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      = types || MIME::Types.send(:__types__)
+        types ||= MIME::Types.send(:__types__)
 
-      File.open(cache_file, 'wb') do |f|
-        f.write(Marshal.dump(new(types.data_version, Marshal.dump(types))))
+        File.open(cache_file, 'wb') do |f|
+          f.write(Marshal.dump(new(types.data_version, Marshal.dump(types))))
+        end
       end
     end
   end

data/lib/mime/types/columnar.rb

@@ -0,0 +1,160 @@
+module MIME
+  class Types
+  end
+end
+
+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_references
+    each_file_line('references') do |type, line|
+      type.instance_variable_set(:@references, arr(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_system
+    each_file_line('system') do |type, line|
+      type.system = (line unless line == '-'.freeze)
+    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_instad = (line unless line == '-'.freeze)
+    end
+  end
+
+  def dict(line)
+    if line == '-'.freeze
+      {}
+    else
+      line.split('|'.freeze).each_with_object({}) { |h, l|
+        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