mime-types 1.16 → 1.17

data/.hoerc

@@ -0,0 +1,12 @@
+--- 
+publish_on_announce: false
+exclude: !ruby/regexp /\.(?:svn|git)|(?:\.(?:swp|hoerc|DS_Store)|~|email.txt)$|(?:coverage|type-lists)\//
+signing_key_file: ~/.gem/gem-private_key.pem
+signing_cert_file: ~/.gem/gem-public_cert.pem
+blogs: 
+- user: user
+  url: url
+  extra_headers: 
+    mt_convert_breaks: markdown
+  blog_id: blog_id
+  password: password

data/{History.txt → History.rdoc}

@@ -1,3 +1,20 @@
+== MIME::Types 1.17 / 2011-MM-DD
+* Minor Enhancements:
+  * Implemented modern 'hoe' semantics.
+  * Switched to minitest instead of test/unit.
+  * Converted documentation from .txt to .rdoc.
+  * Removed setup.rb. (Issue #3:
+    https://github.com/halostatue/mime-types/issues/3).
+  * Should no longer complain about missing RubyGems keys (Issue #2:
+    https://github.com/halostatue/mime-types/issues/2).
+  * Added .mp4 and .mpg4 as recognized extensions for
+    {application,audio,video}/mp4 per RFC4337. (Issue #1:
+    https://github.com/halostatue/mime-types/issues/1).
+  * Added audio/x-aac and .aac per RubyForge issue #28054
+    (http://rubyforge.org/tracker/index.php?func=detail&aid=28054&group_id=293&atid=1194).
+  * Made it much easier to update MIME types from this point forward.
+  * Updated MIME types from IANA.
+
 == MIME::Types 1.16
 * Made compatible with Ruby 1.8.6, 1.8.7, and 1.9.1.
 * Switched to the 'hoe' gem system and added a lot of build-time tools.

data/Licence.rdoc

@@ -0,0 +1,10 @@
+== License
+
+This software is available under a triple disjunctive license:
+{Ruby's license}[http://www.ruby-lang.org/en/LICENSE.txt],
+the
+{Perl Artistic license}[http://www.perl.com/pub/a/language/misc/Artistic.html],
+or the {GNU GPL version 2}[http://www.gnu.org/licenses/old-licenses/gpl-2.0.html]
+(or at your option, any later verison).
+
+If you do not accept one of these licences, you may not use this software.

data/Manifest.txt

@@ -1,12 +1,42 @@
-History.txt
-Install.txt
-Licence.txt
+.hoerc
+History.rdoc
+Licence.rdoc
 Manifest.txt
-README.txt
+README.rdoc
 Rakefile
 lib/mime/types.rb
-lib/mime/types.rb.data
+lib/mime/types/application
+lib/mime/types/application.mac
+lib/mime/types/application.nonstandard
+lib/mime/types/application.obsolete
+lib/mime/types/audio
+lib/mime/types/audio.nonstandard
+lib/mime/types/audio.obsolete
+lib/mime/types/image
+lib/mime/types/image.nonstandard
+lib/mime/types/image.obsolete
+lib/mime/types/message
+lib/mime/types/message.obsolete
+lib/mime/types/model
+lib/mime/types/multipart
+lib/mime/types/multipart.nonstandard
+lib/mime/types/multipart.obsolete
+lib/mime/types/other.nonstandard
+lib/mime/types/text
+lib/mime/types/text.nonstandard
+lib/mime/types/text.obsolete
+lib/mime/types/text.vms
+lib/mime/types/video
+lib/mime/types/video.nonstandard
+lib/mime/types/video.obsolete
 mime-types.gemspec
-setup.rb
 test/test_mime_type.rb
 test/test_mime_types.rb
+type-lists/application.txt
+type-lists/audio.txt
+type-lists/image.txt
+type-lists/message.txt
+type-lists/model.txt
+type-lists/multipart.txt
+type-lists/text.txt
+type-lists/video.txt

data/README.rdoc

@@ -0,0 +1,19 @@
+= MIME::Types for Ruby
+
+== Description
+
+This library allows for the identification of a file's likely MIME content
+type. This is release 1.17. The identification of MIME content type is based
+on a file's filename extensions.
+
+MIME::Types for Ruby originally based on and synchronized with MIME::Types for
+Perl by Mark Overmeer, copyright 2001 - 2009. As of version 1.15, the data
+format for the MIME::Type list has changed and the synchronization will no
+longer happen.
+
+Homepage::  http://mime-types.rubyforge.org/
+GitHub::    http://github.com/halostatue/mime-types/
+Copyright:: 2002 - 2011, Austin Ziegler
+            Based in part on prior work copyright Mark Overmeer
+
+:include: License.rdoc

data/Rakefile

@@ -1,289 +1,191 @@
-#! /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
-#++
+# -*- ruby encoding: utf-8 -*-
 
 require 'rubygems'
 require 'hoe'
 
-$LOAD_PATH.unshift('lib')
+Hoe.plugin :doofus
+Hoe.plugin :gemspec
+Hoe.plugin :rubyforge
+Hoe.plugin :git
+Hoe.plugin :minitest
 
-require 'mime/types'
+spec = Hoe.spec 'mime-types' do
+  self.rubyforge_name = self.name
 
-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
+  developer('Austin Ziegler', 'austin@rubyforge.org')
 
-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]
+  self.url = "http://mime-types.rubyforge.org/"
+  self.remote_rdoc_dir = 'rdoc'
+  self.rsync_args << ' --exclude=statsvn/'
 
-  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")
+  self.history_file = 'History.rdoc'
+  self.readme_file = 'README.rdoc'
+  self.extra_rdoc_files = FileList["*.rdoc"].to_a
 
-  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"]
+  self.extra_dev_deps << ['nokogiri', '~> 1.5']
+  self.extra_dev_deps << ['minitest', '~> 2.0']
+  self.extra_dev_deps << ['hoe-doofus', '~> 1.0']
+  self.extra_dev_deps << ['hoe-gemspec', '~> 1.0']
+  self.extra_dev_deps << ['hoe-git', '~> 1.0']
+  self.extra_dev_deps << ['hoe-seattlerb', '~> 1.0']
 end
 
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |t|
-    t.libs << 'test'
-    t.test_files = hoe.test_files
-    t.verbose = true
-  end
-rescue LoadError
-  puts "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-end
+namespace :mime do
+  desc "Download the current MIME type registrations from IANA."
+  task :iana, :save, :destination do |t, args|
+    save_type = (args.save || :text).to_sym
 
-=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 }
+    case save_type
+    when :text, :both, :html
+      nil
     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
+      raise "Unknown save type provided. Must be one of text, both, or html."
     end
-  ensure
-    tw.close if tw
-    gz.close if gz
-  end
-end
-task :package => [ PKG_TAR ]
 
-desc "Build the manifest file from the current set of files."
-task :build_manifest do |t|
-  require 'find'
+    destination = args.destination || "type-lists"
 
-  hoerc = File.join(File.dirname(__FILE__), ".hoerc")
-  hoerc = File.open(hoerc, "rb") { |f| f.read }
-  hoerc = YAML::load(hoerc)
+    require 'open-uri'
+    require 'nokogiri'
+    require 'cgi'
 
-  paths = []
-  Find.find(".") do |path|
-    next if File.directory?(path) || path =~ hoerc["exclude"]
-    paths << path.sub(%r{^\./}, '')
-  end
+    class IANAParser
+      include Comparable
 
-  paths = paths.sort.join("\n")
+      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+)}
 
-  File.open("Manifest.txt", "w") do |f|
-    f.puts paths
-  end
-
-  puts paths
-end
+      class << self
+        def load_index
+          @types ||= {}
 
-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."
-  end
-
-  destination = args.destination || "type-lists"
+          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
 
-  require 'open-uri'
-  require 'nokogiri'
-  require 'cgi'
+        attr_reader :types
+      end
 
-  class IANAParser
-    include Comparable
+      def initialize(name, type)
+        @name = name
+        @type = type
+        @url  = File.join(INDEX, @type)
+      end
 
-    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+)}
+      attr_reader :name
+      attr_reader :type
+      attr_reader :url
+      attr_reader :html
 
-    class << self
-      def load_index
-        @types ||= {}
+      def download(name = nil)
+        @html = Nokogiri::HTML(open(name || @url) { |f| f.read })
+      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
+      def save_html
+        File.open("#@name.html", "wb") { |w| w.write @html }
       end
 
-      attr_reader :types
-    end
+      def <=>(o)
+        self.name <=> o.name
+      end
 
-    def initialize(name, type)
-      @name = name
-      @type = type
-      @url  = File.join(INDEX, @type)
-    end
+      def parse
+        nodes = html.xpath("//table//table//tr")
 
-    attr_reader :name
-    attr_reader :type
-    attr_reader :url
-    attr_reader :html
+        # How many <td> children does the first node have?
+        node_count = nodes.first.children.select { |n| n.elem? }.size
 
-    def download(name = nil)
-      @html = Nokogiri::HTML(open(name || @url) { |f| f.read })
-    end
+        if node_count == 1
+          # The title node doesn't have what we expect. Let's try it based
+          # on the first real node.
+          node_count = nodes.first.next.children.select { |n| n.elem? }.size
+        end
 
-    def save_html
-      File.open("#@name.html", "wb") { |w| w.write @html }
-    end
+        @mime_types = nodes.map do |node|
+          next if node == nodes.first
+          elems = node.children.select { |n| n.elem? }
+          next if elems.size.zero?
 
-    def <=>(o)
-      self.name <=> o.name
-    end
+          raise "size mismatch #{elems.size} != #{node_count}" if node_count != elems.size
 
-    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
+          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
+          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
+              else
             "[#{ref.content}=#{tag}]"
-            end
-          when RFC_EDITOR, IETF_RFC, IETF_RFC_TOOLS
+              end
+            when RFC_EDITOR, IETF_RFC, IETF_RFC_TOOLS
           "RFC#$1"
-          when %r{(https?://.*)}
+            when %r{(https?://.*)}
           "{#{ref.content}=#$1}"
-          else
-            ref
-          end
-        }
-        refs = refnodes.join(',')
+            else
+              ref
+            end
+          }
+          refs = refnodes.join(',')
 
       "#@type/#{subtype} 'IANA,#{refs}"
-      end.compact
+        end.compact
 
-      @mime_types
-    end
+        @mime_types
+      end
 
-    def save_text
-      File.open("#@name.txt", "wb") { |w| w.write @mime_types.join("\n") }
+      def save_text
+        File.open("#@name.txt", "wb") { |w| w.write @mime_types.join("\n") }
+      end
     end
-  end
 
-  puts "Downloading index of MIME types from #{IANAParser::INDEX}."
-  IANAParser.load_index
+    puts "Downloading index of MIME types from #{IANAParser::INDEX}."
+    IANAParser.load_index
 
-  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
+    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
 
-      if :html == save_type || :both == save_type
-        puts "Saving #{parser.name}.html"
-        parser.save_html
-      end
+        if :html == save_type || :both == save_type
+          puts "Saving #{parser.name}.html"
+          parser.save_html
+        end
 
-      puts "Parsing #{parser.name} HTML"
-      parser.parse
+        puts "Parsing #{parser.name} HTML"
+        parser.parse
 
-      if :text == save_type || :both == save_type
-        puts "Saving #{parser.name}.txt"
-        parser.save_text
+        if :text == save_type || :both == save_type
+          puts "Saving #{parser.name}.txt"
+          parser.save_text
+        end
       end
     end
   end
-end
 
-desc "Shows known MIME type sources."
-task :mime_type_sources do
-  puts <<-EOS
+  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
@@ -291,26 +193,7 @@ http://standards.freedesktop.org/shared-mime-info-spec/shared-mime-info-spec-lat
 http://www.feedforall.com/mime-types.htm
 http://www.iana.org/assignments/media-types/
   EOS
-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)
   end
-
-  spec.validate
-
-  puts spec
-  puts "OK"
 end
+
+# vim: syntax=ruby