mime-types 2.99.3 → 3.3.1

data/lib/mime/types/loader_path.rb

@@ -1,15 +0,0 @@
-# -*- ruby encoding: utf-8 -*-
-
-class MIME::Types::Loader
-  # The path that will be used for loading the MIME::Types data. The default
-  # 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 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
-  # path be something like /usr/share/ruby/mime-types/.
-  PATH = File.expand_path('../../../../data', __FILE__)
-end

data/support/apache_mime_types.rb

@@ -1,108 +0,0 @@
-# -*- ruby encoding: utf-8 -*-
-
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-
-require 'open-uri'
-require 'nokogiri'
-require 'cgi'
-require 'pathname'
-require 'yaml'
-
-ENV['RUBY_MIME_TYPES_LAZY_LOAD'] = 'yes'
-require 'mime/types'
-
-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),
-    to: Pathname(__FILE__).join('../../type-lists')
-  }.freeze.each_value(&:freeze)
-
-  def self.download(options = {})
-    dest = Pathname(options[:to] || DEFAULTS[:to]).expand_path
-    url  = options.fetch(:url, DEFAULTS[:url])
-
-    puts 'Downloading Apache MIME type list.'
-    puts "\t#{url}"
-    data = open(url) { |f| f.read }.split($/)
-    data.delete_if { |line| line =~ /\A#/ }
-
-    conf = MIME::Types::Container.new
-
-    data.each do |line|
-      type = line.split(/\t+/)
-      key  = type.first.split(%r{/}).first.gsub(MIME::Type::UNREGISTERED_RE, '')
-      conf[key] << type
-    end
-
-    conf.each do |type, types|
-      next if type == 'example'
-
-      new(type: type, registry: types, to: dest) do |parser|
-        puts "Extracting #{parser.type}/*."
-        parser.parse
-        parser.save
-      end
-    end
-  end
-
-  attr_reader :type
-
-  def initialize(options = {})
-    @registry = options.fetch(:registry)
-    @to       = Pathname(options.fetch(:to)).expand_path
-    @type     = options.fetch(:type)
-    @name     = "#{@type}.yaml"
-    @file     = @to.join(@name)
-    @types    = mime_types_for(@file)
-
-    yield self if block_given?
-  end
-
-  def parse
-    @registry.each do |record|
-      content_type = record.first
-      extensions   = record.last.split(/\s+/)
-
-      types        = @types.select { |t|
-        (t.content_type.downcase == content_type.downcase)
-      }
-
-      if types.empty?
-        MIME::Type.new(content_type) do |mt|
-          mt.extensions = extensions
-          mt.registered = false
-          @types << mt
-        end
-      else
-        types.each { |mt|
-          mt.extensions  = (mt.extensions + extensions)
-        }
-      end
-    end
-  end
-
-  def save
-    @to.mkpath
-    File.open(@file, 'wb') { |f| f.puts @types.map.to_a.sort.to_yaml }
-  end
-
-  private
-
-  def mime_types_for(file)
-    if file.exist?
-      MIME::Types::Loader.load_from_yaml(file)
-    else
-      MIME::Types.new
-    end
-  end
-end

data/support/benchmarks/load.rb

@@ -1,64 +0,0 @@
-# -*- ruby encoding: utf-8 -*-
-
-require 'benchmark'
-
-module Benchmarks
-  class Load
-    def self.report(load_path, repeats)
-      new(load_path, repeats.to_i).report
-    end
-
-    def initialize(load_path, repeats = nil)
-      @cache_file = File.expand_path('../cache.mtc', __FILE__)
-      @repeats    = repeats.to_i
-      @repeats    = 50 if repeats <= 0
-      @load_path  = load_path
-    end
-
-    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}/ }
-
-        if columnar
-          require 'mime/types/columnar'
-        else
-          require 'mime/types'
-        end
-        ::MIME::Types.send(:__types__) if force_load
-      }
-    end
-
-    def report
-      remove_cache
-
-      Benchmark.bm(17) do |mark|
-        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, 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) }
-        ENV['RUBY_MIME_TYPES_LAZY_LOAD'] = 'yes'
-        mark.report('Lazy Cached:') { reload_mime_types(@repeats) }
-        mark.report('Lazy Cached Load:') { reload_mime_types(@repeats, force_load: true) }
-      end
-    ensure
-      remove_cache
-    end
-
-    def remove_cache
-      File.unlink(@cache_file) if File.exist?(@cache_file)
-    end
-  end
-end

data/support/benchmarks/load_allocations.rb

@@ -1,83 +0,0 @@
-# -*- 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

@@ -1,41 +0,0 @@
-# -*- 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

data/support/convert.rb

@@ -1,158 +0,0 @@
-# -*- ruby encoding: utf-8 -*-
-
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-ENV['RUBY_MIME_TYPES_LAZY_LOAD'] = 'true'
-require 'mime/types'
-require 'fileutils'
-require 'json'
-
-class MIME::Types
-  def self.deprecated(*_args, &_block)
-    # We are an internal tool. Silence deprecation warnings.
-  end
-end
-
-class Convert
-  class << self
-    # Create a Convert instance that converts from YAML.
-    def from_yaml(path = nil)
-      new(path: path, from: :yaml)
-    end
-
-    # Create a Convert instance that converts from JSON.
-    def from_json(path = nil)
-      new(path: path, from: :json)
-    end
-
-    # Create a Convert instance that converts from the mime-types 1.x file
-    # format.
-    def from_v1(path = nil)
-      new(path: path, from: :v1)
-    end
-
-    # Converts from YAML to JSON. Defaults to converting to a single file.
-    def from_yaml_to_json(args)
-      from_yaml(yaml_path(args.source)).
-        to_json(
-          destination:    json_path(args.destination),
-          multiple_files: multiple_files(args.multiple_files || 'single')
-        )
-    end
-
-    # Converts from JSON to YAML. Defaults to converting to multiple files.
-    def from_json_to_yaml(args)
-      from_json(json_path(args.source)).
-        to_yaml(
-          destination:    yaml_path(args.destination),
-          multiple_files: multiple_files(args.multiple_files || 'multiple')
-        )
-    end
-
-    private :new
-
-    private
-
-    def yaml_path(path)
-      path_or_default(path, 'type-lists'.freeze)
-    end
-
-    def json_path(path)
-      path_or_default(path, 'data'.freeze)
-    end
-
-    def path_or_default(path, default)
-      if path.nil? or path.empty?
-        default
-      else
-        path
-      end
-    end
-
-    def multiple_files(flag)
-      case flag.to_s.downcase
-      when 'true', 'yes', 'multiple'
-        true
-      else
-        false
-      end
-    end
-  end
-
-  def initialize(options = {})
-    if options[:path].nil? or options[:path].empty?
-      fail ArgumentError, ':path is required'
-    elsif options[:from].nil? or options[:from].empty?
-      fail ArgumentError, ':from is required'
-    end
-
-    @loader = MIME::Types::Loader.new(options[:path])
-    load_from(options[:from])
-  end
-
-  # Convert the data to JSON.
-  def to_json(options = {})
-    options[:destination] or require_destination!
-    write_types(options.merge(format: :json))
-  end
-
-  # Convert the data to YAML.
-  def to_yaml(options = {})
-    options[:destination] or require_destination!
-    write_types(options.merge(format: :yaml))
-  end
-
-  private
-
-  def load_from(source_type)
-    method = :"load_#{source_type}"
-    @loader.send(method)
-  end
-
-  def write_types(options)
-    if options[:multiple_files]
-      write_multiple_files(options)
-    else
-      write_one_file(options)
-    end
-  end
-
-  def write_one_file(options)
-    d = options[:destination]
-    d = File.join(d, "mime-types.#{options[:format]}") if File.directory?(d)
-
-    File.open(d, 'wb') { |f|
-      f.puts convert(@loader.container.map.sort, options[:format])
-    }
-  end
-
-  def write_multiple_files(options)
-    d = options[:destination]
-    must_be_directory!(d)
-
-    media_types = MIME::Types.map(&:media_type).uniq
-    media_types.each { |media_type|
-      n = File.join(d, "#{media_type}.#{options[:format]}")
-      t = @loader.container.select { |e| e.media_type == media_type }
-      File.open(n, 'wb') { |f|
-        f.puts convert(t.sort, options[:format])
-      }
-    }
-  end
-
-  def convert(data, format)
-    data.send(:"to_#{format}")
-  end
-
-  def require_destination!
-    fail ArgumentError, 'Destination path is required.'
-  end
-
-  def must_be_directory!(path)
-    if File.exist?(path) and !File.directory?(path)
-      fail ArgumentError, 'Cannot write multiple files to a file.'
-    end
-
-    FileUtils.mkdir_p(path) unless File.exist?(path)
-    path
-  end
-end