mime-types 2.5 → 2.6

data/lib/mime/types/deprecations.rb

@@ -0,0 +1,53 @@
+# -*- ruby encoding: utf-8 -*-
+
+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
+              when Class, Module
+                '.'
+              else
+                klass = klass.class
+                '#'
+              end
+      message = case message
+                when :private, :protected
+                  "and will be #{message}"
+                when nil
+                  '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
+
+    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/loader.rb

@@ -1,5 +1,8 @@
 # -*- ruby encoding: utf-8 -*-
 
+module MIME; end
+class MIME::Types; end
+
 require 'mime/types/loader_path'
 
 # This class is responsible for initializing the MIME::Types registry from
@@ -23,10 +26,13 @@ class MIME::Types::Loader
   # Creates a Loader object that can be used to load MIME::Types registries
   # into memory, using YAML, JSON, or v1 registry format loaders.
   def initialize(path = nil, container = nil)
-    path       = path || ENV['RUBY_MIME_TYPES_DATA'] ||
-      MIME::Types::Loader::PATH
-    @path      = File.expand_path(File.join(path, '**'))
+    path = path || ENV['RUBY_MIME_TYPES_DATA'] || MIME::Types::Loader::PATH
     @container = container || MIME::Types.new
+    @path = File.expand_path(path)
+    # begin
+    #   require 'mime/lazy_types'
+    #   @container.extend(MIME::LazyTypes)
+    # end
   end
 
   # Loads a MIME::Types registry from YAML files (<tt>*.yml</tt> or
@@ -52,8 +58,6 @@ class MIME::Types::Loader
   # It is expected that the JSON objects will be an array of hash objects.
   # The JSON format is the registry format for the MIME types registry
   # shipped with the mime-types library.
-  #
-  # This method is aliased to #load.
   def load_json
     Dir[json_path].sort.each do |f|
       types = self.class.load_from_json(f)
@@ -61,29 +65,52 @@ class MIME::Types::Loader
     end
     container
   end
-  alias_method :load, :load_json
+
+  # Loads a MIME::Types registry from columnar files recursively found in
+  # +path+.
+  def load_columnar
+    require 'mime/types/columnar'
+    container.extend(MIME::Types::Columnar)
+    container.load_base_data(path)
+
+    container
+  end
+
+  # Loads a MIME::Types registry. Loads from JSON files by default
+  # (#load_json).
+  #
+  # This will load from columnar files (#load_columnar) if <tt>columnar:
+  # true</tt> is provided in +options+ and there are columnar files in +path+.
+  def load(options = { columnar: false })
+    if options[:columnar] && !Dir[columnar_path].empty?
+      load_columnar
+    else
+      load_json
+    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.
+  # This method has been deprecated and will be removed from mime-types 3.0.
   def load_v1
-    MIME.deprecated(self.class, __method__)
+    MIME::Types.deprecated(self.class, __method__)
     Dir[v1_path].sort.each do |f|
-      next if f =~ /\.ya?ml$|\.json$/
-      container.add(self.class.load_from_v1(f), true)
+      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.
+  # 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
-      new.load
+    def load(options = { columnar: false })
+      new.load(options)
     end
 
     # Build the type list from a file in the format:
@@ -122,8 +149,10 @@ class MIME::Types::Loader
     # 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.
-    def load_from_v1(filename)
-      MIME.deprecated(self.class, __method__)
+    #
+    # 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|
@@ -133,11 +162,11 @@ class MIME::Types::Loader
         m = V1_FORMAT.match(item)
 
         unless m
-          warn <<-EOS
+          MIME::Types.logger.warn <<-EOS
 #{filename}:#{index + 1}: Parsing error in v1 MIME type definition.
 => #{line}
           EOS
-          raise BadV1Format, line
+          fail BadV1Format, line
         end
 
         unregistered, obsolete, platform, mediatype, subtype, extensions,
@@ -151,8 +180,8 @@ class MIME::Types::Loader
         if docs.nil?
           use_instead = nil
         else
-          use_instead = docs.scan(%r{use-instead:(\S+)}).flatten
-          docs = docs.gsub(%r{use-instead:\S+}, "").squeeze(" \t")
+          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|
@@ -163,7 +192,10 @@ class MIME::Types::Loader
           t.registered  = false if unregistered
           t.use_instead = use_instead
           t.docs        = docs
-          t.references  = urls
+
+          # This is being removed. Cheat to silence it for now.
+          t.instance_variable_set :@references,
+                                  Array(urls).flatten.compact.uniq
         end
 
         mime.add_type(mime_type, true)
@@ -201,12 +233,14 @@ class MIME::Types::Loader
     end
 
     private
+
     def read_file(filename)
       File.open(filename, 'r:UTF-8:-') { |f| f.read }
     end
   end
 
   private
+
   def yaml_path
     File.join(path, '*.y{,a}ml')
   end
@@ -215,12 +249,18 @@ class MIME::Types::Loader
     File.join(path, '*.json')
   end
 
+  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?

data/lib/mime/types/loader_path.rb

@@ -5,9 +5,8 @@ class MIME::Types::Loader
   # location is __FILE__/../../../../data, which is where the data lives
   # in the gem installation of the mime-types library.
   #
-  # The MIME::Types::Loader will load all YAML files contained in this path.
-  # By convention, there is one file for each media type (e.g.,
-  # application.yml, audio.yml, etc.).
+  # The MIME::Types::Loader will load all JSON or columnar files contained in
+  # this path.
   #
   # System repackagers note: this is the constant that you would change if
   # you repackage mime-types for your system. It is recommended that the

data/lib/mime/types/logger.rb

@@ -0,0 +1,35 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'logger'
+
+module MIME
+  class Types
+    class << self
+      # Configure the MIME::Types logger. This defaults to an instance of a
+      # logger that passes messages (unformatted) through to Kernel#warn.
+      attr_accessor :logger
+    end
+
+    class WarnLogger < ::Logger #:nodoc:
+      class WarnLogDevice < ::Logger::LogDevice #:nodoc:
+        def initialize(*)
+        end
+
+        def write(m)
+          Kernel.warn(m)
+        end
+
+        def close
+        end
+      end
+
+      def initialize(_1, _2 = nil, _3 = nil)
+        super nil
+        @logdev = WarnLogDevice.new
+        @formatter = ->(_s, _d, _p, m) { m }
+      end
+    end
+
+    self.logger = WarnLogger.new(nil)
+  end
+end

data/support/apache_mime_types.rb

@@ -15,6 +15,12 @@ class MIME::Type
   public_constant :UNREGISTERED_RE
 end
 
+class MIME::Types
+  def self.deprecated(*_args, &_block)
+    # We are an internal tool. Silence deprecation warnings.
+  end
+end
+
 class ApacheMIMETypes
   DEFAULTS = {
     url: %q(http://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types),
@@ -25,7 +31,7 @@ class ApacheMIMETypes
     dest = Pathname(options[:to] || DEFAULTS[:to]).expand_path
     url  = options.fetch(:url, DEFAULTS[:url])
 
-    puts "Downloading Apache MIME type list."
+    puts 'Downloading Apache MIME type list.'
     puts "\t#{url}"
     data = open(url) { |f| f.read }.split($/)
     data.delete_if { |line| line =~ /\A#/ }
@@ -91,6 +97,7 @@ class ApacheMIMETypes
   end
 
   private
+
   def mime_types_for(file)
     if file.exist?
       MIME::Types::Loader.load_from_yaml(file)

data/support/benchmarks/load.rb

@@ -15,11 +15,19 @@ module Benchmarks
       @load_path  = load_path
     end
 
-    def reload_mime_types(repeats = 1, force_load = false)
+    def reload_mime_types(repeats = 1, options = {})
+      force_load = options.fetch(:force_load, false)
+      columnar = options.fetch(:columnar, false)
+
       repeats.times {
         Object.send(:remove_const, :MIME) if defined? ::MIME
         $LOADED_FEATURES.delete_if { |n| n =~ /#{@load_path}/ }
-        require 'mime/types'
+
+        if columnar
+          require 'mime/types/columnar'
+        else
+          require 'mime/types'
+        end
         ::MIME::Types.send(:__types__) if force_load
       }
     end
@@ -28,21 +36,22 @@ module Benchmarks
       remove_cache
 
       Benchmark.bm(17) do |mark|
-        mark.report("Normal:") { reload_mime_types(@repeats) }
+        mark.report('Normal:') { reload_mime_types(@repeats) }
+        mark.report('Columnar:') { reload_mime_types(@repeats, columnar: true) }
 
         ENV['RUBY_MIME_TYPES_LAZY_LOAD'] = 'yes'
-        mark.report("Lazy:") { reload_mime_types(@repeats) }
-        mark.report("Lazy+Load:") { reload_mime_types(@repeats, true) }
+        mark.report('Lazy:') { reload_mime_types(@repeats) }
+        mark.report('Lazy+Load:') { reload_mime_types(@repeats, force_load: true) }
 
         ENV.delete('RUBY_MIME_TYPES_LAZY_LOAD')
 
         ENV['RUBY_MIME_TYPES_CACHE'] = @cache_file
         reload_mime_types
 
-        mark.report("Cached:") { reload_mime_types(@repeats) }
+        mark.report('Cached:') { reload_mime_types(@repeats) }
         ENV['RUBY_MIME_TYPES_LAZY_LOAD'] = 'yes'
-        mark.report("Lazy Cached:") { reload_mime_types(@repeats) }
-        mark.report("Lazy Cached Load:") { reload_mime_types(@repeats, true) }
+        mark.report('Lazy Cached:') { reload_mime_types(@repeats) }
+        mark.report('Lazy Cached Load:') { reload_mime_types(@repeats, force_load: true) }
       end
     ensure
       remove_cache

data/support/benchmarks/load_allocations.rb

@@ -0,0 +1,83 @@
+# -*- ruby encoding: utf-8 -*-
+
+if RUBY_VERSION < '2.1'
+  $stderr.puts "Cannot count allocations on #{RUBY_VERSION}."
+  exit 1
+end
+
+begin
+  require 'allocation_tracer'
+rescue LoadError
+  $stderr.puts "Allocation tracking requires the gem 'allocation_tracer'."
+  exit 1
+end
+
+module Benchmarks
+  class LoadAllocations
+    def self.report(columnar: false, top_x: nil, mime_types_only: false)
+      new(columnar: columnar, top_x: top_x, mime_types_only: mime_types_only).
+        report
+    end
+
+    def initialize(columnar: false, top_x: nil, mime_types_only: false)
+      @columnar = columnar
+      @mime_types_only = !!mime_types_only
+
+      @top_x = top_x
+
+      return unless @top_x
+      @top_x = top_x.to_i
+      @top_x = 10 if @top_x <= 0
+    end
+
+    def report
+      collect
+      report_top_x if @top_x
+      puts "TOTAL Allocations: #{@count}"
+    end
+
+    private
+
+    def report_top_x
+      table = @allocations.sort_by { |_, v| v.first }.reverse.first(@top_x)
+      table.map! { |(location, allocs)|
+        next if @mime_types_only and location.first !~ %r{mime-types/lib}
+        [ location.join(':').gsub(%r{^#{Dir.pwd}/}, ''), *allocs ]
+      }.compact!
+
+      head = (ObjectSpace::AllocationTracer.header - [ :line ]).map {|h|
+        h.to_s.split(/_/).map(&:capitalize).join(' ')
+      }
+      table.unshift head
+
+      max_widths = [].tap do |mw|
+        table.map { |row| row.lazy.map(&:to_s).map(&:length).to_a }.tap do |w|
+          w.first.each_index do |i|
+            mw << w.lazy.map { |r| r[i] }.max
+          end
+        end
+      end
+
+      pattern = [ '%%-%ds' ]
+      pattern << ([ '%% %ds' ] * (max_widths.length - 1))
+      pattern = pattern.join("\t") % max_widths
+      table.each { |row| puts pattern % row }
+      puts
+    end
+
+    def collect
+      if @columnar
+        @allocations = ObjectSpace::AllocationTracer.trace do
+          require 'mime/types/columnar'
+        end
+      else
+        @allocations = ObjectSpace::AllocationTracer.trace do
+          require 'mime/types'
+        end
+      end
+
+      @count = ObjectSpace::AllocationTracer.allocated_count_table.values.
+        inject(:+)
+    end
+  end
+end

data/support/benchmarks/object_counts.rb

@@ -0,0 +1,41 @@
+# -*- ruby encoding: utf-8 -*-
+
+module Benchmarks
+  class ObjectCounts
+    def self.report(columnar: false)
+      new(columnar: columnar).report
+    end
+
+    def initialize(columnar: false)
+      @columnar = columnar
+    end
+
+    def report
+      collect
+      @before.keys.grep(/T_/).map { |key|
+        [ key, @after[key] - @before[key] ]
+      }.sort_by { |_, delta| -delta }.each { |key, delta|
+        puts '%10s +%6d' % [ key, delta ]
+      }
+    end
+
+    private
+
+    def collect
+      @before = count_objects
+
+      if @columnar
+        require 'mime/types/columnar'
+      else
+        require 'mime/types'
+      end
+
+      @after = count_objects
+    end
+
+    def count_objects
+      GC.start
+      ObjectSpace.count_objects
+    end
+  end
+end