mime-types 2.99.3 → 3.4.1

data/lib/mime/types/_columnar.rb

@@ -0,0 +1,137 @@
+# 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]) || 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))
+      type.instance_variable_set(:@provisional, 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

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
-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
+# 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 && 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.strip
+        Could not load MIME::Types cache: invalid version
+      WARNING
+      nil
     end
+  rescue => e
+    MIME::Types.logger.warn <<-WARNING.chomp.strip
+      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.is_a?(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.is_a?(Set)
+
+      container[k] = Set[*v]
+    end
+  end
+
+  EMPTY_SET = Set.new.freeze
+  private_constant :EMPTY_SET
+end

data/lib/mime/types/deprecations.rb

@@ -1,53 +1,36 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
-require 'mime/types/logger'
+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:
-      level = case klass
+      level =
+        case klass
               when Class, Module
-                '.'
+                "."
               else
                 klass = klass.class
-                '#'
-              end
-      message = case message
+                "#"
+        end
+      message =
+        case message
                 when :private, :protected
                   "and will be #{message}"
                 when nil
-                  'and will be removed'
+                  "and will be removed"
                 else
                   message
-                end
-      MIME::Types.logger.warn <<-warning.chomp
-#{caller[1]}: #{klass}#{level}#{sym} is deprecated #{message}.
-      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
+        end
+      MIME::Types.logger.warn <<-WARNING.chomp.strip
+        #{caller(2..2).first}: #{klass}#{level}#{sym} is deprecated #{message}.
+      WARNING
 
-    def warn_about_moved_constants(name)
-      MIME::Types.logger.warn <<-warning.chomp
-#{caller[1]}: MIME::#{name} is deprecated. Use MIME::Type::#{name} instead.
-      warning
+      return unless block
+      block.call
     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"