mime-types 2.99.3 → 3.3.1

data/lib/mime/type/columnar.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'mime/type'
 
 # A version of MIME::Type that works hand-in-hand with a MIME::Types::Columnar
@@ -11,80 +13,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 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 registered? # :nodoc:
-    @container.send(:load_registered) unless defined?(@registered)
-    super
-  end
-
-  def signature? # :nodoc:
-    @container.send(:load_signature) unless defined?(@signature)
-    super
-  end
+  def self.column(*methods, file: nil) # :nodoc:
+    file ||= methods.first
 
-  def xrefs # :nodoc:
-    @container.send(:load_xrefs) unless defined?(@xrefs)
-    @xrefs
+    file_method = :"load_#{file}"
+    methods.each do |m|
+      define_method m do |*args|
+        @container.send(file_method)
+        super(*args)
+      end
+    end
   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
+  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 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,9 +1,13 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
+
+##
+module MIME
+  ##
+  class Types
+  end
+end
 
-require 'mime/types/deprecations'
 require 'mime/type'
-require 'mime/types/cache'
-require 'mime/types/loader'
 
 # MIME::Types is a registry of MIME types. It is both a class (created with
 # MIME::Types.new) and a default registry (loaded automatically or through
@@ -66,37 +70,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 +94,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 +121,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 +131,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,19 +148,14 @@ 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(Set.new, :+).sort { |a, b|
+      a.priority_compare(b)
+    }
   end
-  alias_method :of, :type_for
+  alias of type_for
 
   # Add one or more MIME::Type objects to the set of known types. If the
   # type is already known, a warning will be displayed.
@@ -194,7 +171,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(Set.new, :+).to_a, quiet)
       when Array
         add(*mime_type, quiet)
       else
@@ -208,119 +185,47 @@ class MIME::Types
   # 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
+      MIME::Types.logger.warn <<-WARNING
 Type #{type} is already registered as a variant of #{type.simplified}.
-      warning
+      WARNING
     end
 
     add_type_variant!(type)
     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
+  private
 
-    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
+  def add_type_variant!(mime_type)
+    @type_variants.add(mime_type.simplified, mime_type)
   end
 
-  private
+  def reindex_extensions!(mime_type)
+    return unless @type_variants[mime_type.simplified].include?(mime_type)
 
-  def add_type_variant!(mime_type)
-    @type_variants[mime_type.simplified] << mime_type
+    index_extensions!(mime_type)
   end
 
   def index_extensions!(mime_type)
-    mime_type.extensions.each { |ext| @extension_index[ext] << mime_type }
+    mime_type.extensions.each { |ext| @extension_index.add(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(Set.new, :+)
   end
-
-  load_default_mime_types(load_mode) unless lazy_load?
 end
 
-# vim: ft=ruby
+require 'mime/types/cache'
+require 'mime/types/container'
+require 'mime/types/loader'
+require 'mime/types/logger'
+require 'mime/types/_columnar'
+require 'mime/types/registry'

data/lib/mime/types/_columnar.rb

@@ -0,0 +1,136 @@
+# 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(:@__files__, Set.new)
+  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|
+      line = line.split
+      content_type = line.shift
+      extensions = 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 @__files__.include?(name)
+
+      i = -1
+      column = File.join(@__root__, "mime.#{name}.column")
+
+      IO.readlines(column, encoding: 'UTF-8').each do |line|
+        line.chomp!
+
+        if lookup
+          type = @__mime_data__[i += 1] or next
+          yield type, line
+        else
+          yield line
+        end
+      end
+
+      @__files__ << name
+    end
+  end
+
+  def load_encoding
+    each_file_line('encoding') do |type, line|
+      pool ||= {}
+      type.instance_variable_set(:@encoding, (pool[line] ||= line))
+    end
+  end
+
+  def load_docs
+    each_file_line('docs') do |type, line|
+      type.instance_variable_set(:@docs, opt(line))
+    end
+  end
+
+  def load_preferred_extension
+    each_file_line('pext') do |type, line|
+      type.instance_variable_set(:@preferred_extension, opt(line))
+    end
+  end
+
+  def load_flags
+    each_file_line('flags') do |type, line|
+      line = line.split
+      type.instance_variable_set(:@obsolete, flag(line.shift))
+      type.instance_variable_set(:@registered, flag(line.shift))
+      type.instance_variable_set(:@signature, flag(line.shift))
+    end
+  end
+
+  def load_xrefs
+    each_file_line('xrefs') { |type, line|
+      type.instance_variable_set(:@xrefs, dict(line, array: true))
+    }
+  end
+
+  def load_friendly
+    each_file_line('friendly') { |type, line|
+      type.instance_variable_set(:@friendly, dict(line))
+    }
+  end
+
+  def load_use_instead
+    each_file_line('use_instead') do |type, line|
+      type.instance_variable_set(:@use_instead, opt(line))
+    end
+  end
+
+  def dict(line, array: false)
+    if line == '-'
+      {}
+    else
+      line.split('|').each_with_object({}) { |l, h|
+        k, v = l.split('^')
+        v = nil if v.empty?
+        h[k] = array ? Array(v) : v
+      }
+    end
+  end
+
+  def arr(line)
+    if line == '-'
+      []
+    else
+      line.split('|').flatten.compact.uniq
+    end
+  end
+
+  def opt(line)
+    line unless line == '-'
+  end
+
+  def flag(line)
+    line == '1'
+  end
+end