mime-types 2.99.3 → 3.2.2

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/columnar.rb

@@ -1,88 +0,0 @@
-require 'convert'
-
-class Convert::Columnar < Convert
-  class << self
-    # Converts from YAML to Columnar format. This *always* converts to multiple
-    # files.
-    def from_yaml_to_columnar(args)
-      from_yaml(yaml_path(args.source)).
-        to_columnar(destination: columnar_path(args.destination))
-    end
-
-    private
-
-    def columnar_path(path)
-      path_or_default(path, 'data')
-    end
-  end
-
-  # Convert the data to multiple text files.
-  def to_columnar(options = {})
-    root = options[:destination] or require_destination!
-    @root = must_be_directory!(root)
-    @data = @loader.container.sort.map(&:to_h)
-
-    column_file('content_type') do |type|
-      [ type['content-type'], Array(type['extensions']).join(' ') ].
-        flatten.join(' ').strip
-    end
-
-    required_file('encoding')
-    optional_file('docs')
-    bool_file('obsolete')
-    bool_file('registered')
-    bool_file('signature')
-    dict_file('xrefs')
-    dict_file('friendly')
-    optional_file('use_instead', 'use-instead')
-  end
-
-  def column_file(name, &block)
-    File.open(File.join(@root, "mime.#{name}.column"), 'wb') do |f|
-      f.puts @data.map(&block)
-    end
-  end
-
-  def bool_file(name, *fields)
-    fields = [ name ] if fields.empty?
-    column_file(name) do |type|
-      fields.map { |field|
-        type[field] ? 1 : 0
-      }.join(' ')
-    end
-  end
-
-  def required_file(name, field = name)
-    column_file(name) { |type| type[field] }
-  end
-
-  def optional_file(name, field = name)
-    column_file(name) { |type| opt(type[field]) }
-  end
-
-  def array_file(name, field = name)
-    column_file(name) { |type| arr(type[field]) }
-  end
-
-  def dict_file(name, field = name)
-    column_file(name) { |type| dict(type[field]) }
-  end
-
-  def opt(value)
-    value || '-'
-  end
-
-  def arr(value)
-    Array(opt(value)).join('|')
-  end
-
-  def dict(value)
-    if value
-      value.sort.map { |k, v|
-        [ k, Array(v).compact.join('^') ].join('^')
-      }.join('|')
-    else
-      '-'
-    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

data/support/iana_registry.rb

@@ -1,172 +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::Types
-  def self.deprecated(*_args, &_block)
-    # We are an internal tool. Silence deprecation warnings.
-  end
-end
-
-class MIME::Type
-  public_constant :MEDIA_TYPE_RE if respond_to? :public_constant
-end
-
-class IANARegistry
-  DEFAULTS = {
-    url: %q(https://www.iana.org/assignments/media-types/media-types.xml),
-    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 IANA MIME type assignments.'
-    puts "\t#{url}"
-    xml  = Nokogiri::XML(open(url) { |f| f.read })
-
-    xml.css('registry registry').each do |registry|
-      next if registry.at_css('title').text == 'example'
-      new(registry: registry, 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     = @registry.at_css('title').text
-    @name     = "#{@type}.yaml"
-    @file     = @to.join(@name)
-    @types    = mime_types_for(@file)
-
-    yield self if block_given?
-  end
-
-  ASSIGNMENT_FILE_REF = '{%s=http://www.iana.org/assignments/media-types/%s}'
-
-  def parse
-    @registry.css('record').each do |record|
-      subtype       = record.at_css('name').text
-      obsolete      = record.at_css('obsolete').text rescue nil
-      use_instead   = record.at_css('deprecated').text rescue nil
-
-      if subtype =~ /OBSOLETE|DEPRECATE/i
-        use_instead ||= $1 if subtype =~ /in favou?r of (#{MIME::Type::MEDIA_TYPE_RE})/
-        obsolete = true
-      end
-
-      subtype, notes = subtype.split(/ /, 2)
-
-      refs, xrefs = parse_refs_and_files(
-        record.css('xref'),
-        record.css('file'),
-        subtype
-      )
-
-      xrefs['notes'] << notes if notes
-
-      content_type  = [ @type, subtype ].join('/')
-
-      types         = @types.select { |t|
-        (t.content_type.downcase == content_type.downcase)
-      }
-
-      if types.empty?
-        MIME::Type.new(content_type) do |mt|
-          mt.xrefs       = xrefs
-          mt.registered  = true
-          mt.obsolete    = obsolete if obsolete
-          mt.use_instead = use_instead if use_instead
-          @types << mt
-        end
-      else
-        types.each { |mt|
-          mt.registered  = true
-          mt.xrefs       = xrefs
-          mt.obsolete    = obsolete if obsolete
-          mt.use_instead = use_instead if use_instead
-        }
-      end
-    end
-  end
-
-  def save
-    @to.mkpath
-    File.open(@file, 'wb') { |f| f.puts @types.map.to_a.sort.uniq.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
-
-  def parse_refs_and_files(refs, files, subtype)
-    xr = MIME::Types::Container.new
-    r  = []
-
-    refs.each do |xref|
-      type = xref['type']
-      data = xref['data']
-
-      next if data.nil? || data.empty?
-
-      r << ref_from_type(type, data)
-
-      xr[type] << data
-    end
-
-    files.each do |file|
-      file_name = if file.text == subtype
-                    [ @type, subtype ].join('/')
-                  else
-                    file.text
-                  end
-
-      if file['type'] == 'template'
-        r << (ASSIGNMENT_FILE_REF % [ file_name, file_name ])
-      end
-
-      xr[file['type']] << file_name
-    end
-
-    [ r, xr ]
-  end
-
-  def ref_from_type(type, data)
-    case type
-    when 'person'
-      "[#{data}]"
-    when 'rfc'
-      data.upcase
-    when 'draft'
-      "DRAFT:#{data.sub(/^RFC-/, 'draft-')}"
-    when 'rfc-errata'
-      "{RFC Errata #{data}=http://www.rfc-editor.org/errata_search.php?eid=#{data}}"
-    when 'uri'
-      "{#{data}}"
-    else # 'text' or something else
-      data
-    end
-  end
-end