mime-types 1.16 → 3.5.2

data/Rakefile

@@ -1,316 +1,229 @@
-#! /usr/bin/env rake
-#--
-# MIME::Types
-# A Ruby implementation of a MIME Types information library. Based in spirit
-# on the Perl MIME::Types information library by Mark Overmeer.
-# http://rubyforge.org/projects/mime-types/
-#
-# Licensed under the Ruby disjunctive licence with the GNU GPL or the Perl
-# Artistic licence. See Licence.txt for more information.
-#
-# Copyright 2003 - 2009 Austin Ziegler
-#++
-
-require 'rubygems'
-require 'hoe'
-
-$LOAD_PATH.unshift('lib')
-
-require 'mime/types'
-
-PKG_NAME    = 'mime-types'
-PKG_VERSION = MIME::Types::VERSION
-PKG_DIST    = "#{PKG_NAME}-#{PKG_VERSION}"
-PKG_TAR     = "pkg/#{PKG_DIST}.tar.gz"
-MANIFEST    = File.read("Manifest.txt").split
-
-hoe = Hoe.new PKG_NAME, PKG_VERSION do |p|
-  p.rubyforge_name  = PKG_NAME
-  # This is a lie because I will continue to use Archive::Tar::Minitar.
-  p.need_tar        = false
-  # need_zip - Should package create a zipfile? [default: false]
-
-  p.author          = [ "Austin Ziegler" ]
-  p.email           = %W(austin@rubyforge.org)
-  p.url             = "http://mime-types.rubyforge.org/"
-  p.summary         = %q{Manages a MIME Content-Type database that will return the Content-Type for a given filename.}
-  p.changes         = p.paragraphs_of("History.txt", 0..0).join("\n\n")
-  p.description     = p.paragraphs_of("README.txt", 1..1).join("\n\n")
-
-  p.extra_dev_deps  << %w(archive-tar-minitar ~>0.5)
-  p.extra_dev_deps  << %w(nokogiri ~>1.2)
-  p.extra_dev_deps  << %w(rcov ~>0.8)
-
-  p.clean_globs     << "coverage"
-
-  p.spec_extras[:extra_rdoc_files] = MANIFEST.grep(/txt$/) - ["Manifest.txt"]
+require "rubygems"
+require "hoe"
+require "rake/clean"
+
+Hoe.plugin :cov
+Hoe.plugin :doofus
+Hoe.plugin :gemspec2
+Hoe.plugin :git2
+Hoe.plugin :minitest
+Hoe.plugin :rubygems
+
+spec = Hoe.spec "mime-types" do
+  developer("Austin Ziegler", "halostatue@gmail.com")
+
+  self.history_file = "History.md"
+  self.readme_file = "README.rdoc"
+
+  license "MIT"
+
+  require_ruby_version ">= 2.0"
+
+  spec_extras[:metadata] = ->(val) { val["rubygems_mfa_required"] = "true" }
+
+  extra_deps << ["mime-types-data", "~> 3.2015"]
+
+  extra_dev_deps << ["hoe", ">= 3.0", "< 5"]
+  extra_dev_deps << ["hoe-doofus", "~> 1.0"]
+  extra_dev_deps << ["hoe-gemspec2", "~> 1.1"]
+  extra_dev_deps << ["hoe-git2", "~> 1.7"]
+  extra_dev_deps << ["hoe-rubygems", "~> 1.0"]
+  extra_dev_deps << ["minitest", "~> 5.0"]
+  extra_dev_deps << ["minitest-autotest", "~> 1.0"]
+  extra_dev_deps << ["minitest-focus", "~> 1.0"]
+  extra_dev_deps << ["minitest-hooks", "~> 1.4"]
+  extra_dev_deps << ["rake", ">= 10.0", "< 14.0"]
+  extra_dev_deps << ["standard", "~> 1.0"]
 end
 
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |t|
-    t.libs << 'test'
-    t.test_files = hoe.test_files
-    t.verbose = true
+namespace :benchmark do
+  task :support do
+    %w[lib support].each { |path|
+      $LOAD_PATH.unshift(File.join(Rake.application.original_dir, path))
+    }
   end
-rescue LoadError
-  puts "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-end
-
-=begin
-  require 'cucumber/rake/task'
-  Cucumber::Rake::Task.new(:features)
-rescue LoadError
-  puts "Cucumber is not available. In order to run features, you must: sudo gem install cucumber"
-=end
-
-desc "Build a MIME::Types .tar.gz distribution."
-task :tar => [ PKG_TAR ]
-file PKG_TAR => [ :test ] do |t|
-  require 'archive/tar/minitar'
-  require 'zlib'
-  files = MANIFEST.map { |f|
-    fn = File.join(PKG_DIST, f)
-    tm = File.stat(f).mtime
-
-    if File.directory?(f)
-      { :name => fn, :mode => 0755, :dir => true, :mtime => tm }
-    else
-      mode = if f =~ %r{^bin}
-               0755
-             else
-               0644
-             end
-      data = File.read(f)
-      { :name => fn, :mode => mode, :data => data, :size => data.size,
-        :mtime => tm }
-    end
-  }
 
-  begin
-    unless File.directory?(File.dirname(t.name))
-      require 'fileutils'
-      FileUtils.mkdir_p File.dirname(t.name)
-    end
-    tf = File.open(t.name, 'wb')
-    gz = Zlib::GzipWriter.new(tf)
-    tw = Archive::Tar::Minitar::Writer.new(gz)
-
-    files.each do |entry|
-      if entry[:dir]
-        tw.mkdir(entry[:name], entry)
-      else
-        tw.add_file_simple(entry[:name], entry) { |os|
-          os.write(entry[:data])
-        }
-      end
-    end
-  ensure
-    tw.close if tw
-    gz.close if gz
+  desc "Benchmark Load Times"
+  task :load, [:repeats] => "benchmark:support" do |_, args|
+    require "benchmarks/load"
+    Benchmarks::Load.report(
+      File.join(Rake.application.original_dir, "lib"),
+      args.repeats
+    )
   end
-end
-task :package => [ PKG_TAR ]
-
-desc "Build the manifest file from the current set of files."
-task :build_manifest do |t|
-  require 'find'
-
-  hoerc = File.join(File.dirname(__FILE__), ".hoerc")
-  hoerc = File.open(hoerc, "rb") { |f| f.read }
-  hoerc = YAML::load(hoerc)
 
-  paths = []
-  Find.find(".") do |path|
-    next if File.directory?(path) || path =~ hoerc["exclude"]
-    paths << path.sub(%r{^\./}, '')
+  desc "Allocation counts"
+  task :allocations, [:top_x, :mime_types_only] => "benchmark:support" do |_, args|
+    require "benchmarks/load_allocations"
+    Benchmarks::LoadAllocations.report(
+      top_x: args.top_x,
+      mime_types_only: args.mime_types_only
+    )
   end
 
-  paths = paths.sort.join("\n")
-
-  File.open("Manifest.txt", "w") do |f|
-    f.puts paths
+  desc "Columnar allocation counts"
+  task "allocations:columnar", [:top_x, :mime_types_only] => "benchmark:support" do |_, args|
+    require "benchmarks/load_allocations"
+    Benchmarks::LoadAllocations.report(
+      columnar: true,
+      top_x: args.top_x,
+      mime_types_only: args.mime_types_only
+    )
   end
 
-  puts paths
-end
-
-desc "Download the current MIME type registrations from IANA."
-task :iana, :save, :destination do |t, args|
-  save_type = args.save || :text
-  save_type = save_type.to_sym
-
-  case save_type
-  when :text, :both, :html
-    nil
-  else
-    raise "Unknown save type provided. Must be one of text, both, or html."
+  desc "Columnar allocation counts (full load)"
+  task "allocations:columnar:full", [:top_x, :mime_types_only] => "benchmark:support" do |_, args|
+    require "benchmarks/load_allocations"
+    Benchmarks::LoadAllocations.report(
+      columnar: true,
+      top_x: args.top_x,
+      mime_types_only: args.mime_types_only,
+      full: true
+    )
   end
 
-  destination = args.destination || "type-lists"
-
-  require 'open-uri'
-  require 'nokogiri'
-  require 'cgi'
-
-  class IANAParser
-    include Comparable
-
-    INDEX = %q(http://www.iana.org/assignments/media-types/)
-    CONTACT_PEOPLE = %r{http://www.iana.org/assignments/contact-people.html?#(.*)}
-    RFC_EDITOR = %r{http://www.rfc-editor.org/rfc/rfc(\d+).txt}
-    IETF_RFC = %r{http://www.ietf.org/rfc/rfc(\d+).txt}
-    IETF_RFC_TOOLS = %r{http://tools.ietf.org/html/rfc(\d+)}
+  desc "Memory profiler"
+  task :memory, [:top_x, :mime_types_only] => "benchmark:support" do |_, args|
+    require "benchmarks/memory_profiler"
+    Benchmarks::ProfileMemory.report(
+      mime_types_only: args.mime_types_only,
+      top_x: args.top_x
+    )
+  end
 
-    class << self
-      def load_index
-        @types ||= {}
+  desc "Columnar memory profiler"
+  task "memory:columnar", [:top_x, :mime_types_only] => "benchmark:support" do |_, args|
+    require "benchmarks/memory_profiler"
+    Benchmarks::ProfileMemory.report(
+      columnar: true,
+      mime_types_only: args.mime_types_only,
+      top_x: args.top_x
+    )
+  end
 
-        Nokogiri::HTML(open(INDEX) { |f| f.read }).xpath('//p/a').each do |tag|
-          href_match = %r{^/assignments/media-types/(.+)/$}.match(tag['href'])
-          next if href_match.nil?
-          type = href_match.captures[0]
-          @types[tag.content] = IANAParser.new(tag.content, type)
-        end
-      end
+  desc "Columnar allocation counts (full load)"
+  task "memory:columnar:full", [:top_x, :mime_types_only] => "benchmark:support" do |_, args|
+    require "benchmarks/memory_profiler"
+    Benchmarks::ProfileMemory.report(
+      columnar: true,
+      full: true,
+      top_x: args.top_x,
+      mime_types_only: args.mime_types_only
+    )
+  end
 
-      attr_reader :types
-    end
+  desc "Object counts"
+  task objects: "benchmark:support" do
+    require "benchmarks/object_counts"
+    Benchmarks::ObjectCounts.report
+  end
 
-    def initialize(name, type)
-      @name = name
-      @type = type
-      @url  = File.join(INDEX, @type)
-    end
+  desc "Columnar object counts"
+  task "objects:columnar" => "benchmark:support" do
+    require "benchmarks/object_counts"
+    Benchmarks::ObjectCounts.report(columnar: true)
+  end
 
-    attr_reader :name
-    attr_reader :type
-    attr_reader :url
-    attr_reader :html
+  desc "Columnar object counts (full load)"
+  task "objects:columnar:full" => "benchmark:support" do
+    require "benchmarks/object_counts"
+    Benchmarks::ObjectCounts.report(columnar: true, full: true)
+  end
+end
 
-    def download(name = nil)
-      @html = Nokogiri::HTML(open(name || @url) { |f| f.read })
-    end
+namespace :profile do
+  directory "tmp/profile"
+
+  CLEAN.add "tmp"
+
+  def ruby_prof(script)
+    require "pathname"
+    output = Pathname("tmp/profile").join(script)
+    output.mkpath
+    script = Pathname("support/profile").join("#{script}.rb")
+
+    args = [
+      "-W0",
+      "-Ilib",
+      "-S", "ruby-prof",
+      "-R", "mime/types",
+      "-s", "self",
+      "-p", "multi",
+      "-f", output.to_s,
+      script.to_s
+    ]
+    ruby args.join(" ")
+  end
 
-    def save_html
-      File.open("#@name.html", "wb") { |w| w.write @html }
-    end
+  task full: "tmp/profile" do
+    ruby_prof "full"
+  end
 
-    def <=>(o)
-      self.name <=> o.name
-    end
+  task columnar: :support do
+    ruby_prof "columnar"
+  end
 
-    def parse
-      nodes = html.xpath("//table//table//tr")
-
-      # How many <td> children does the first node have?
-      node_count = nodes.first.children.select { |node| node.elem? }.size
-
-      @mime_types = nodes.map do |node|
-        next if node == nodes.first
-        elems = node.children.select { |n| n.elem? }
-        next if elems.size.zero?
-        raise "size mismatch #{elems.size} != #{node_count}" if node_count != elems.size
-
-        case elems.size
-        when 3
-          subtype_index = 1
-          refnode_index = 2
-        when 4
-          subtype_index = 1
-          refnode_index = 3
-        else
-          raise "Unknown element size."
-        end
-
-        subtype   = elems[subtype_index].content.chomp.strip
-        refnodes  = elems[refnode_index].children.select { |n| n.elem? }.map { |ref|
-          case ref['href']
-          when CONTACT_PEOPLE
-            tag = CGI::unescape($1).chomp.strip
-            if tag == ref.content
-            "[#{ref.content}]"
-            else
-            "[#{ref.content}=#{tag}]"
-            end
-          when RFC_EDITOR, IETF_RFC, IETF_RFC_TOOLS
-          "RFC#$1"
-          when %r{(https?://.*)}
-          "{#{ref.content}=#$1}"
-          else
-            ref
-          end
-        }
-        refs = refnodes.join(',')
-
-      "#@type/#{subtype} 'IANA,#{refs}"
-      end.compact
-
-      @mime_types
-    end
+  task "columnar:full" => :support do
+    ruby_prof "columnar_full"
+  end
+end
 
-    def save_text
-      File.open("#@name.txt", "wb") { |w| w.write @mime_types.join("\n") }
+if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.0")
+  namespace :test do
+    desc "Run test coverage"
+    task :coverage do
+      spec.test_prelude = [
+        'require "simplecov"',
+        'SimpleCov.start("test_frameworks") { command_name "Minitest" }',
+        'gem "minitest"'
+      ].join("; ")
+      Rake::Task["test"].execute
     end
   end
+end
 
-  puts "Downloading index of MIME types from #{IANAParser::INDEX}."
-  IANAParser.load_index
+namespace :convert do
+  namespace :docs do
+    task :setup do
+      gem "rdoc"
+      require "rdoc/rdoc"
+      @doc_converter ||= RDoc::Markup::ToMarkdown.new
+    end
 
-  require 'fileutils'
-  FileUtils.mkdir_p destination
-  Dir.chdir destination do
-    IANAParser.types.values.sort.each do |parser|
-      next if parser.name == "example" or parser.name == "mime"
-      puts "Downloading #{parser.name} from #{parser.url}"
-      parser.download
+    FileList["*.rdoc"].each do |name|
+      rdoc = name
+      mark = "#{File.basename(name, ".rdoc")}.md"
 
-      if :html == save_type || :both == save_type
-        puts "Saving #{parser.name}.html"
-        parser.save_html
+      file mark => [rdoc, :setup] do |t|
+        puts "#{rdoc} => #{mark}"
+        File.binwrite(t.name, @doc_converter.convert(IO.read(t.prerequisites.first)))
       end
 
-      puts "Parsing #{parser.name} HTML"
-      parser.parse
+      CLEAN.add mark
 
-      if :text == save_type || :both == save_type
-        puts "Saving #{parser.name}.txt"
-        parser.save_text
-      end
+      task run: [mark]
     end
   end
-end
 
-desc "Shows known MIME type sources."
-task :mime_type_sources do
-  puts <<-EOS
-http://www.ltsw.se/knbase/internet/mime.htp
-http://www.webmaster-toolkit.com/mime-types.shtml
-http://plugindoc.mozdev.org/winmime.php
-http://standards.freedesktop.org/shared-mime-info-spec/shared-mime-info-spec-latest.html  
-http://www.feedforall.com/mime-types.htm
-http://www.iana.org/assignments/media-types/
-  EOS
+  desc "Convert documentation from RDoc to Markdown"
+  task docs: "convert:docs:run"
 end
 
-desc "Validate the RubyGem spec for GitHub."
-task :github_validate_spec do |t|
-  require 'yaml'
-
-  require 'rubygems/specification'
-  data = File.read("#{PKG_NAME}.gemspec")
-  spec = nil
-
-  if data !~ %r{!ruby/object:Gem::Specification}
-    code = "$SAFE = 3\n#{data}"
-    p code.split($/)[44]
-    Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
-  else
-    spec = YAML.load(data)
+namespace :deps do
+  task :top, [:number] => "benchmark:support" do |_, args|
+    require "deps"
+    Deps.run(args)
   end
+end
 
-  spec.validate
-
-  puts spec
-  puts "OK"
+task :console do
+  arguments = %w[irb]
+  arguments.push(*spec.spec.require_paths.map { |dir| "-I#{dir}" })
+  arguments.push("-r#{spec.spec.name.gsub("-", File::SEPARATOR)}")
+  unless system(*arguments)
+    error "Command failed: #{show_command}"
+    abort
+  end
 end
+
+# vim: syntax=ruby

data/lib/mime/type/columnar.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "mime/type"
+
+# A version of MIME::Type that works hand-in-hand with a MIME::Types::Columnar
+# container to load data by columns.
+#
+# When a field is has not yet been loaded, that data will be loaded for all
+# types in the container before forwarding the message to MIME::Type.
+#
+# More information can be found in MIME::Types::Columnar.
+#
+# MIME::Type::Columnar is *not* intended to be created except by
+# MIME::Types::Columnar containers.
+class MIME::Type::Columnar < MIME::Type
+  def initialize(container, content_type, extensions) # :nodoc:
+    @container = container
+    self.content_type = content_type
+    self.extensions = extensions
+  end
+
+  def self.column(*methods, file: nil) # :nodoc:
+    file ||= methods.first
+
+    file_method = :"load_#{file}"
+    methods.each do |m|
+      define_method m do |*args|
+        @container.send(file_method)
+        super(*args)
+      end
+    end
+  end
+
+  column :friendly
+  column :encoding, :encoding=
+  column :docs, :docs=
+  column :preferred_extension, :preferred_extension=
+  column :obsolete, :obsolete=, :obsolete?, :registered, :registered=, :registered?, :signature, :signature=,
+    :signature?, :provisional, :provisional=, :provisional?, file: "flags"
+  column :xrefs, :xrefs=, :xref_urls
+  column :use_instead, :use_instead=
+
+  def encode_with(coder) # :nodoc:
+    @container.send(:load_friendly)
+    @container.send(:load_encoding)
+    @container.send(:load_docs)
+    @container.send(:load_flags)
+    @container.send(:load_use_instead)
+    @container.send(:load_xrefs)
+    @container.send(:load_preferred_extension)
+    super
+  end
+
+  class << self
+    undef column
+  end
+end