mime-types 2.99.3 → 3.0

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/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/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/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