mime-types 2.99.3 → 3.0

data/lib/mime/types/columnar.rb

@@ -18,7 +18,7 @@ module MIME::Types::Columnar
   def self.extended(obj) # :nodoc:
     super
     obj.instance_variable_set(:@__mime_data__, [])
-    obj.instance_variable_set(:@__attributes__, [])
+    obj.instance_variable_set(:@__files__, Set.new)
   end
 
   # Load the first column data file (type and extensions).
@@ -26,7 +26,10 @@ module MIME::Types::Columnar
     @__root__ = path
 
     each_file_line('content_type', false) do |line|
-      content_type, *extensions = line.split
+      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
@@ -40,84 +43,81 @@ module MIME::Types::Columnar
 
   def each_file_line(name, lookup = true)
     LOAD_MUTEX.synchronize do
-      next if @__attributes__.include?(name)
+      next if @__files__.include?(name)
 
-      File.open(File.join(@__root__, "mime.#{name}.column"), 'r:UTF-8') do |f|
-        i = -1
+      i = -1
+      column = File.join(@__root__, "mime.#{name}.column")
 
-        f.each_line do |line|
-          line.chomp!
+      IO.readlines(column, encoding: 'UTF-8'.freeze).each do |line|
+        line.chomp!
 
-          if lookup
-            type = @__mime_data__[i += 1] or next
-            yield type, line
-          else
-            yield line
-          end
+        if lookup
+          type = @__mime_data__[i += 1] or next
+          yield type, line
+        else
+          yield line
         end
       end
 
-      @__attributes__ << name
+      @__files__ << name
     end
   end
 
   def load_encoding
-    pool = {}
     each_file_line('encoding') do |type, line|
+      pool ||= {}
       line.freeze
-      type.encoding = (pool[line] ||= line)
+      type.instance_variable_set(:@encoding, (pool[line] ||= line))
     end
   end
 
   def load_docs
     each_file_line('docs') do |type, line|
-      type.docs = arr(line)
+      type.instance_variable_set(:@docs, opt(line))
     end
   end
 
-  def load_obsolete
-    each_file_line('obsolete') do |type, line|
-      type.obsolete = bool(line)
+  def load_preferred_extension
+    each_file_line('pext') do |type, line|
+      type.instance_variable_set(:@preferred_extension, opt(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)
+  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.xrefs = dict(line) }
+    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|
-      v = dict(line)
-      type.friendly = v.empty? ? nil : v
+      type.instance_variable_set(:@friendly, dict(line))
     }
   end
 
   def load_use_instead
     each_file_line('use_instead') do |type, line|
-      type.use_instead = (line unless line == '-'.freeze)
+      type.instance_variable_set(:@use_instead, opt(line))
     end
   end
 
-  def dict(line)
+  def dict(line, array: false)
     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
+        v = nil if v.empty?
+        h[k] = array ? Array(v) : v
       }
     end
   end
@@ -130,19 +130,13 @@ module MIME::Types::Columnar
     end
   end
 
-  def bool(line)
-    line == '1'.freeze ? true : false
+  def opt(line)
+    line unless line == '-'.freeze
   end
-end
 
-unless MIME::Types.private_method_defined?(:load_mode)
-  class << MIME::Types
-    private
-
-    def load_mode
-      { columnar: true }
-    end
+  def flag(line)
+    line == '1'.freeze ? true : false
   end
-
-  require 'mime/types'
 end
+
+require 'mime/types' unless defined?(MIME::Types::VERSION)

data/lib/mime/types/container.rb

@@ -0,0 +1,30 @@
+require 'set'
+
+# 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 MIME::Types::Container < Hash # :nodoc:
+  def initialize
+    super
+    self.default_proc = ->(h, k) { h[k] = Set.new }
+  end
+
+  def marshal_dump
+    {}.merge(self)
+  end
+
+  def marshal_load(hash)
+    self.default_proc = ->(h, k) { h[k] = Set.new }
+    merge!(hash)
+  end
+
+  def encode_with(coder)
+    each { |k, v| coder[k] = v.to_a }
+  end
+
+  def init_with(coder)
+    self.default_proc = ->(h, k) { h[k] = Set.new }
+    coder.map.each { |k, v| self[k] = Set[*v] }
+  end
+end

data/lib/mime/types/deprecations.rb

@@ -4,6 +4,7 @@ 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:
@@ -28,26 +29,4 @@ module MIME
       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,17 @@
+##
+module MIME
+  ##
+  class Types
+    unless private_method_defined?(:load_mode)
+      class << self
+        private
+
+        def load_mode
+          { columnar: false }
+        end
+      end
+
+      require 'mime/types'
+    end
+  end
+end

data/lib/mime/types/loader.rb

@@ -1,9 +1,11 @@
 # -*- 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 +13,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,9 +26,9 @@ 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
@@ -41,8 +43,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 +90,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 +128,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 +145,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