diff --git a/trunk/mime-types/ChangeLog b/trunk/mime-types/ChangeLog index a4c5063..1c998e8 100644 --- a/trunk/mime-types/ChangeLog +++ b/trunk/mime-types/ChangeLog @@ -1,8 +1,13 @@ -Revision history for Ruby extension MIME::Types. += MIME::Types Change Log Unless explicitly stated differently are all changes produced by Austin Ziegler . +== MIME::Types 1.15 +* Re-synchronized the MIME type list with the sources, focusing primarily on + the IANA list. +* Re-synchronized with the Perl implementation. + == MIME::Types 1.13.1 * Fixed a problem with the installer running tests. This now works. * Improved the implementation of MIME::Type.signature? @@ -75,3 +80,13 @@ Ziegler . == MIME::Types 1.003 * Initial release based on Perl MIME::Types 1.003. + +#-- +# MIME::Types for Ruby +# http://rubyforge.org/projects/mime-types/ +# Copyright 2003 - 2005 Austin Ziegler. +# Licensed under a MIT-style licence. +# +# $Id$ +#++ +# vim: sts=2 sw=2 ts=4 et ai tw=77 diff --git a/trunk/mime-types/Install b/trunk/mime-types/Install index 4b60e85..6a03272 100644 --- a/trunk/mime-types/Install +++ b/trunk/mime-types/Install @@ -1,6 +1,16 @@ Installing this package is as simple as: -% ruby install.rb + % ruby setup.rb Alternatively, you can use the RubyGem version of MIME::Types available as -mime-types-1.13.1.gem from the usual sources. +mime-types-1.15.gem from the usual sources. + +#-- +# MIME::Types for Ruby +# http://rubyforge.org/projects/mime-types/ +# Copyright 2003 - 2005 Austin Ziegler. +# Licensed under a MIT-style licence. +# +# $Id$ +#++ +# vim: sts=2 sw=2 ts=4 et ai tw=77 diff --git a/trunk/mime-types/Rakefile b/trunk/mime-types/Rakefile new file mode 100644 index 0000000..473fa53 --- /dev/null +++ b/trunk/mime-types/Rakefile @@ -0,0 +1,128 @@ +#! /usr/bin/env rake +#-- +# MIME::Types for Ruby +# http://rubyforge.org/projects/mime-types/ +# Copyright 2003 - 2005 Austin Ziegler. +# Licensed under a MIT-style licence. +# +# $Id$ +#++ +$LOAD_PATH.unshift('lib') + +require 'rubygems' +require 'rake/gempackagetask' +require 'mime/types' +require 'archive/tar/minitar' +require 'zlib' + +DISTDIR = "mime-types-#{MIME::Types::MIME_TYPES_VERSION}" +TARDIST = "../#{DISTDIR}.tar.gz" + +DATE_RE = %r<(\d{4})[./-]?(\d{2})[./-]?(\d{2})(?:[\sT]?(\d{2})[:.]?(\d{2})[:.]?(\d{2})?)?> + +if ENV['RELEASE_DATE'] + year, month, day, hour, minute, second = DATE_RE.match(ENV['RELEASE_DATE']).captures + year ||= 0 + month ||= 0 + day ||= 0 + hour ||= 0 + minute ||= 0 + second ||= 0 + ReleaseDate = Time.mktime(year, month, day, hour, minute, second) +else + ReleaseDate = nil +end + +task :test do |t| + require 'test/unit/testsuite' + require 'test/unit/ui/console/testrunner' + + runner = Test::Unit::UI::Console::TestRunner + + $LOAD_PATH.unshift('tests') + $stderr.puts "Checking for test cases:" if t.verbose + Dir['tests/tc_*.rb'].each do |testcase| + $stderr.puts "\t#{testcase}" if t.verbose + load testcase + end + + suite = Test::Unit::TestSuite.new("MIME::Types") + + ObjectSpace.each_object(Class) do |testcase| + suite << testcase.suite if testcase < Test::Unit::TestCase + end + + runner.run(suite) +end + +spec = eval(File.read("mime-types.gemspec")) +spec.version = MIME::Types::MIME_TYPES_VERSION +desc "Build the RubyGem for MIME::Types" +task :gem => [ :test ] +Rake::GemPackageTask.new(spec) do |g| + g.need_tar = false + g.need_zip = false + g.package_dir = ".." +end + +desc "Build the MIME::Types manual.pdf" +task :manual do + PDF::TechBook.run %w(-z) +end + +desc "Build a MIME::Types .tar.gz distribution." +task :tar => [ TARDIST ] +file TARDIST => [ :test ] do |t| + current = File.basename(Dir.pwd) + Dir.chdir("..") do + begin + files = %W(bin/**/* lib/**/* demo/**/* images/**/* ChangeLog README + LICENCE setup.rb pre-setup.rb metaconfig manual.pwd) + files = FileList[files.map { |file| File.join(current, file) }].to_a + files.map! do |dd| + ddnew = dd.gsub(/^#{current}/, DISTDIR) + mtime = ReleaseDate || File.stat(dd).mtime + if File.directory?(dd) + { :name => ddnew, :mode => 0755, :dir => true, :mtime => mtime } + else + if dd =~ %r{bin/} + mode = 0755 + else + mode = 0644 + end + data = File.open(dd, "rb") { |ff| ff.read } + { :name => ddnew, :mode => mode, :data => data, :size => data.size, + :mtime => mtime } + end + end + + ff = File.open(t.name.gsub(%r{^\.\./}o, ''), "wb") + gz = Zlib::GzipWriter.new(ff) + 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 + end + end +end +task TARDIST => [ :test ] + +desc "Build the RDoc documentation for MIME::Types" +task :docs do + require 'rdoc/rdoc' + rdoc_options = %w(--title MIME::Types --main README --line-numbers) + files = FileList[*%w(README LICENCE ChangeLog bin/**/*.rb lib/**/*.rb demo/**/*.rb)] + rdoc_options += files.to_a + RDoc::RDoc.new.document(rdoc_options) +end + +desc "Build everything." +task :default => [ :tar, :gem ] diff --git a/trunk/mime-types/Readme b/trunk/mime-types/Readme index f37dc3b..5582ba0 100644 --- a/trunk/mime-types/Readme +++ b/trunk/mime-types/Readme @@ -13,3 +13,13 @@ Based on prior work copyright This package is licensed under Ruby's licence, the Perl Artistic licence, or the GPL version 2 or later. + +#-- +# MIME::Types for Ruby +# http://rubyforge.org/projects/mime-types/ +# Copyright 2003 - 2005 Austin Ziegler. +# Licensed under a MIT-style licence. +# +# $Id$ +#++ +# vim: sts=2 sw=2 ts=4 et ai tw=77 diff --git a/trunk/mime-types/install.rb b/trunk/mime-types/install.rb deleted file mode 100644 index 5772e0b..0000000 --- a/trunk/mime-types/install.rb +++ /dev/null @@ -1,264 +0,0 @@ -#! /usr/bin/env ruby -#-- -# Copyright 2004 Austin Ziegler -# Install utility. Based on the original installation script for rdoc by the -# Pragmatic Programmers. -# -# This program is free software. It may be redistributed and/or modified under -# the terms of the GPL version 2 (or later) or the Ruby licence. -# -# Usage -# ----- -# In most cases, if you have a typical project layout, you will need to do -# absolutely nothing to make this work for you. This layout is: -# -# bin/ # executable files -- "commands" -# lib/ # the source of the library -# tests/ # unit tests -# -# The default behaviour: -# 1) Run all unit test files (ending in .rb) found in all directories under -# tests/. -# 2) Build Rdoc documentation from all files in bin/ (excluding .bat and .cmd), -# all .rb files in lib/, ./README, ./ChangeLog, and ./Install. -# 3) Build ri documentation from all files in bin/ (excluding .bat and .cmd), -# and all .rb files in lib/. This is disabled by default on Win32. -# 4) Install commands from bin/ into the Ruby bin directory. On Windows, if a -# if a corresponding batch file (.bat or .cmd) exists in the bin directory, -# it will be copied over as well. Otherwise, a batch file (always .bat) will -# be created to run the specified command. -# 5) Install all library files ending in .rb from lib/ into Ruby's -# site_lib/version directory. -# -# $Id$ -#++ - -require 'rbconfig' -require 'find' -require 'fileutils' -require 'rdoc/rdoc' -require 'optparse' -require 'ostruct' - -InstallOptions = OpenStruct.new - -def glob(list) - g = list.map { |i| Dir.glob(i) } - g.flatten! - g.compact! - g.reject! { |e| e =~ /CVS/ } - g -end - - # Set these values to what you want installed. -bins = glob(%w{bin/**/*}).reject { |e| e =~ /\.(bat|cmd)$/ } -rdoc = glob(%w{bin/**/* lib/**/*.rb README ChangeLog Install}).reject { |e| e=~ /\.(bat|cmd)$/ } -ri = glob(%w(bin/**/*.rb lib/**/*.rb)).reject { |e| e=~ /\.(bat|cmd)$/ } -libs = glob(%w{lib/**/*.rb}) -tests = glob(%w{tests/**/*.rb}) - -def do_bins(bins, target, strip = 'bin/') - bins.each do |bf| - obf = bf.gsub(/#{strip}/, '') - install_binfile(bf, obf, target) - end -end - -def do_libs(libs, strip = 'lib/') - libs.each do |lf| - olf = File.join(InstallOptions.site_dir, lf.gsub(/#{strip}/, '')) - op = File.dirname(olf) - File.makedirs(op, true) - File.chmod(0755, op) - File.install(lf, olf, 0755, true) - end -end - -## -# Prepare the file installation. -# -def prepare_installation - InstallOptions.rdoc = true - if RUBY_PLATFORM == "i386-mswin32" - InstallOptions.ri = false - else - InstallOptions.ri = true - end - InstallOptions.tests = true - - ARGV.options do |opts| - opts.banner = "Usage: #{File.basename($0)} [options]" - opts.separator "" - opts.on('--[no-]rdoc', 'Prevents the creation of RDoc output.', 'Default on.') do |onrdoc| - InstallOptions.rdoc = onrdoc - end - opts.on('--[no-]ri', 'Prevents the creation of RI output.', 'Default off on mswin32.') do |onri| - InstallOptions.ri = onri - end - opts.on('--[no-]tests', 'Prevents the execution of unit tests.', 'Default on.') do |ontest| - InstallOptions.tests = ontest - end - opts.on('--quick', 'Performs a quick installation. Only the', 'installation is done.') do |quick| - InstallOptions.rdoc = false - InstallOptions.ri = false - InstallOptions.tests = false - end - opts.on('--full', 'Performs a full installation. All', 'optional installation steps are run.') do |full| - InstallOptions.rdoc = true - InstallOptions.ri = true - InstallOptions.tests = true - end - opts.separator("") - opts.on_tail('--help', "Shows this help text.") do - $stderr.puts opts - exit - end - - opts.parse! - end - - bds = [".", ENV['TMP'], ENV['TEMP']] - - version = [Config::CONFIG["MAJOR"], Config::CONFIG["MINOR"]].join(".") - ld = File.join(Config::CONFIG["libdir"], "ruby", version) - - sd = Config::CONFIG["sitelibdir"] - if sd.nil? - sd = $:.find { |x| x =~ /site_ruby/ } - if sd.nil? - sd = File.join(ld, "site_ruby") - elsif sd !~ Regexp.quote(version) - sd = File.join(sd, version) - end - end - - if (destdir = ENV['DESTDIR']) - bd = "#{destdir}#{Config::CONFIG['bindir']}" - sd = "#{destdir}#{sd}" - bds << bd - - FileUtils.makedirs(bd) - FileUtils.makedirs(sd) - else - bds << Config::CONFIG['bindir'] - end - - InstallOptions.bin_dirs = bds.compact - InstallOptions.site_dir = sd - InstallOptions.bin_dir = bd - InstallOptions.lib_dir = ld -end - -## -# Build the rdoc documentation. Also, try to build the RI documentation. -# -def build_rdoc(files) - r = RDoc::RDoc.new - r.document(["--main", "README", "--title", "Diff::LCS -- A Diff Algorithm", - "--line-numbers"] + files) - -rescue RDoc::RDocError => e - $stderr.puts e.message -rescue Exception => e - $stderr.puts "Couldn't build RDoc documentation\n#{e.message}" -end - -def build_ri(files) - ri = RDoc::RDoc.new - ri.document(["--ri-site", "--merge"] + files) -rescue RDoc::RDocError => e - $stderr.puts e.message -rescue Exception => e - $stderr.puts "Couldn't build Ri documentation\n#{e.message}" -end - -def run_tests(test_list) - require 'test/unit/ui/console/testrunner' - $:.unshift "lib" - test_list.each do |test| - next if File.directory?(test) - require test - end - - tests = [] - ObjectSpace.each_object { |o| tests << o if o.kind_of?(Class) } - tests.delete_if { |o| !o.ancestors.include?(Test::Unit::TestCase) } - tests.delete_if { |o| o == Test::Unit::TestCase } - - tests.each { |test| Test::Unit::UI::Console::TestRunner.run(test) } - $:.shift -end - -## -# Install file(s) from ./bin to Config::CONFIG['bindir']. Patch it on the way -# to insert a #! line; on a Unix install, the command is named as expected -# (e.g., bin/rdoc becomes rdoc); the shebang line handles running it. Under -# windows, we add an '.rb' extension and let file associations do their stuff. -def install_binfile(from, op_file, target) - tmp_dir = nil - InstallOptions.bin_dirs.each do |t| - if File.directory?(t) and File.writable?(t) - tmp_dir = t - break - end - end - - fail "Cannot find a temporary directory" unless tmp_dir - tmp_file = File.join(tmp_dir, '_tmp') - ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name']) - - File.open(from) do |ip| - File.open(tmp_file, "w") do |op| - ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name']) - op.puts "#!#{ruby}" - op.write ip.read - end - end - - if Config::CONFIG["target_os"] =~ /win/io - installed_wrapper = false - - if File.exists?("#{from}.bat") - FileUtils.install("#{from}.bat", File.join(target, "#{op_file}.bat"), :mode => 0755, :verbose => true) - installed_wrapper = true - end - - if File.exists?("#{from}.cmd") - FileUtils.install("#{from}.cmd", File.join(target, "#{op_file}.cmd"), :mode => 0755, :verbose => true) - installed_wrapper = true - end - - if not installed_wrapper - tmp_file2 = File.join(tmp_dir, '_tmp_wrapper') - cwn = File.join(Config::CONFIG['bindir'], op_file) - cwv = CMD_WRAPPER.gsub('', ruby.gsub(%r{/}) { "\\" }).gsub!('', cwn.gsub(%r{/}) { "\\" } ) - - File.open(tmp_file2, "wb") { |cw| cw.puts cwv } - FileUtils.install(tmp_file2, File.join(target, "#{op_file}.bat"), :mode => 0755, :verbose => true) - - File.unlink(tmp_file2) - installed_wrapper = true - end - end - FileUtils.install(tmp_file, File.join(target, op_file), :mode => 0755, :verbose => true) - File.unlink(tmp_file) -end - -CMD_WRAPPER = <<-EOS -@echo off -if "%OS%"=="Windows_NT" goto WinNT - -x "" %1 %2 %3 %4 %5 %6 %7 %8 %9 -goto done -:WinNT - -x "" %* -goto done -:done -EOS - -prepare_installation - -run_tests(tests) if InstallOptions.tests -build_rdoc(rdoc) if InstallOptions.rdoc -build_ri(ri) if InstallOptions.ri -do_bins(bins, Config::CONFIG['bindir']) -do_libs(libs) diff --git a/trunk/mime-types/lib/mime/type.rb b/trunk/mime-types/lib/mime/type.rb index daab06e..2ed7f4c 100644 --- a/trunk/mime-types/lib/mime/type.rb +++ b/trunk/mime-types/lib/mime/type.rb @@ -10,10 +10,11 @@ # # The ChangeLog contains all details on revisions. #++ -# TODO include ../../ChangeLog -module MIME #:nodoc: - # Reflects a MIME Content-Type which is in invalid format (e.g., it isn't - # in the form of type/subtype). + + # The namespace for MIME appplications and tools. +module MIME + # Reflects a MIME Content-Type which is in invalid format (e.g., it + # isn't in the form of type/subtype). class InvalidContentType < RuntimeError; end # == Summary @@ -35,7 +36,7 @@ module MIME #:nodoc: # puts MIME::Type.simplified('x-appl/x-zip') # => 'appl/zip' # class Type - VERSION = '1.13.1' #:nodoc: + VERSION = '1.15' include Comparable @@ -44,7 +45,10 @@ module MIME #:nodoc: ENCODING_RE = %r{^(?:base64|7bit|8bit|quoted\-printable)$}o #:nodoc: PLATFORM_RE = %r|#{RUBY_PLATFORM}|o #:nodoc: - SIGNATURES = %w(application/pgp-keys application/pgp application/pgp-signature application/pkcs10 application/pkcs7-mime application/pkcs7-signature text/vcard) #:nodoc: + SIGNATURES = %w(application/pgp-keys application/pgp + application/pgp-signature application/pkcs10 + application/pkcs7-mime application/pkcs7-signature + text/vcard) #:nodoc: # Returns +true+ if the simplified type matches the current def like?(other) @@ -56,8 +60,8 @@ module MIME #:nodoc: end # Compares the MIME::Type against the exact content type or the - # simplified type (the simplified type will be used if comparing against - # something that can be treated as a String with #to_s). + # simplified type (the simplified type will be used if comparing + # against something that can be treated as a String with #to_s). def <=>(other) #:nodoc: if other.respond_to?(:content_type) @content_type <=> other.content_type @@ -99,23 +103,23 @@ module MIME #:nodoc: # The MIME types main- and sub-label can both start with x-, # which indicates that it is a non-registered name. Of course, after # registration this flag can disappear, adds to the confusing - # proliferation of MIME types. The simplified string has the x- - # removed and are translated to lowercase. + # proliferation of MIME types. The simplified string has the + # x- removed and are translated to lowercase. attr_reader :simplified - # The list of extensions which are known to be used for this MIME::Type. - # Non-array values will be coerced into an array with #to_a. Array - # values will be flattened and +nil+ values removed. + # The list of extensions which are known to be used for this + # MIME::Type. Non-array values will be coerced into an array with + # #to_a. Array values will be flattened and +nil+ values removed. attr_accessor :extensions def extensions=(ext) #:nodoc: @extensions = ext.to_a.flatten.compact end # The encoding (7bit, 8bit, quoted-printable, or base64) required to - # transport the data of this content type safely across a network, which - # roughly corresponds to Content-Transfer-Encoding. A value of +nil+ or - # :default will reset the #encoding to the #default_encoding - # for the MIME::Type. Raises ArgumentError if the encoding provided is - # invalid. + # transport the data of this content type safely across a network, + # which roughly corresponds to Content-Transfer-Encoding. A value of + # +nil+ or :default will reset the #encoding to the + # #default_encoding for the MIME::Type. Raises ArgumentError if the + # encoding provided is invalid. attr_accessor :encoding def encoding=(enc) #:nodoc: if enc.nil? or enc == :default @@ -144,11 +148,11 @@ module MIME #:nodoc: end class << self - # The MIME types main- and sub-label can both start with x-, - # which indicates that it is a non-registered name. Of course, after - # registration this flag can disappear, adds to the confusing - # proliferation of MIME types. The simplified string has the - # x- removed and are translated to lowercase. + # The MIME types main- and sub-label can both start with + # x-, which indicates that it is a non-registered name. Of + # course, after registration this flag can disappear, adds to the + # confusing proliferation of MIME types. The simplified string has + # the x- removed and are translated to lowercase. def Type.simplified(content_type) matchdata = CONTENT_TYPE_RE.match(content_type) @@ -248,8 +252,8 @@ module MIME #:nodoc: # end # # === Changes - # In MIME::Types 1.07, the constructor accepted more argument types and - # called #instance_eval on the optional block provided. This is no + # In MIME::Types 1.07, the constructor accepted more argument types + # and called #instance_eval on the optional block provided. This is no # longer the case as of 1.13. The full changes are noted below. # # 1. The constructor +yield+s +self+ instead of using #instance_eval and @@ -260,7 +264,7 @@ module MIME #:nodoc: # # # 1.07 # MIME::Type.new(plaintext) - # # 1.12 + # # 1.13 # MIME::Type.from_mime_type(plaintext) # # 3. MIME::Type.new no longer accepts an Array argument. Use @@ -268,7 +272,7 @@ module MIME #:nodoc: # # # 1.07 # MIME::Type.new(["application/x-ruby", ["rb"], "8bit"]) - # # 1.12 + # # 1.13 # MIME::Type.from_array("application/x-ruby", ['rb'], '8bit') # MIME::Type.from_array(["application/x-ruby", ['rb'], '8bit']) # @@ -280,7 +284,7 @@ module MIME #:nodoc: # 'Content-Transfer-Encoding' => '8bit', # 'System' => 'linux', # 'Extensions' => ['yaml', 'yml']) - # # 1.12 + # # 1.13 # MIME::Type.from_hash('Content-Type' => 'text/x-yaml', # 'Content-Transfer-Encoding' => '8bit', # 'System' => 'linux', @@ -314,24 +318,24 @@ module MIME #:nodoc: end # MIME content-types which are not regestered by IANA nor defined in - # RFCs are required to start with x-. This counts as well for a - # new media type as well as a new sub-type of an existing media type. If - # either the media-type or the content-type begins with x-, - # this method will return +false+. + # RFCs are required to start with x-. This counts as well for + # a new media type as well as a new sub-type of an existing media + # type. If either the media-type or the content-type begins with + # x-, this method will return +false+. def registered? not (@raw_media_type =~ UNREGISTERED_RE) || (@raw_sub_type =~ UNREGISTERED_RE) end - # MIME types can be specified to be sent across a network in particular - # formats. This method returns +true+ when the MIME type encoding is set - # to base64. + # MIME types can be specified to be sent across a network in + # particular formats. This method returns +true+ when the MIME type + # encoding is set to base64. def binary? @encoding == 'base64' end - # MIME types can be specified to be sent across a network in particular - # formats. This method returns +false+ when the MIME type encoding is - # set to base64. + # MIME types can be specified to be sent across a network in + # particular formats. This method returns +false+ when the MIME type + # encoding is set to base64. def ascii? not binary? end @@ -347,8 +351,8 @@ module MIME #:nodoc: not @system.nil? end - # Returns +true+ if the MIME::Type is specific to the current operating - # system as represented by RUBY_PLATFORM. + # Returns +true+ if the MIME::Type is specific to the current + # operating system as represented by RUBY_PLATFORM. def platform? system? and (RUBY_PLATFORM =~ @system) end diff --git a/trunk/mime-types/lib/mime/types.rb b/trunk/mime-types/lib/mime/types.rb index e32d1e7..a870c57 100644 --- a/trunk/mime-types/lib/mime/types.rb +++ b/trunk/mime-types/lib/mime/types.rb @@ -68,9 +68,9 @@ module MIME #:nodoc: # module Types # The released version of Ruby MIME::Types - VERSION = '1.13.1' + MIME_TYPES_VERSION = '1.15' # The version of the data. - DATA_VERSION = '1.13' + DATA_VERSION = '1.15' TYPE_VARIANTS = Hash.new { |h, k| h[k] = [] } #:nodoc: EXTENSION_INDEX = Hash.new { |h, k| h[k] = [] } #:nodoc: diff --git a/trunk/mime-types/metaconfig b/trunk/mime-types/metaconfig new file mode 100644 index 0000000..e69de29 diff --git a/trunk/mime-types/mime-types.gemspec b/trunk/mime-types/mime-types.gemspec index 5e81224..ba2fd03 100644 --- a/trunk/mime-types/mime-types.gemspec +++ b/trunk/mime-types/mime-types.gemspec @@ -1,6 +1,6 @@ Gem::Specification.new do |s| s.name = %q{mime-types} - s.version = %q{1.13.1} + s.version = %q{1.15} s.summary = %q{Manages a MIME Content-Type that will return the Content-Type for a given filename.} s.platform = Gem::Platform::RUBY diff --git a/trunk/mime-types/pre-setup.rb b/trunk/mime-types/pre-setup.rb new file mode 100644 index 0000000..88f6938 --- /dev/null +++ b/trunk/mime-types/pre-setup.rb @@ -0,0 +1,46 @@ +require 'rdoc/rdoc' +## +# Build the rdoc documentation. Also, try to build the RI documentation. +# +def build_rdoc(options) + RDoc::RDoc.new.document(options) +rescue RDoc::RDocError => e + $stderr.puts e.message +rescue Exception => e + $stderr.puts "Couldn't build RDoc documentation\n#{e.message}" +end + +def build_ri(files) + RDoc::RDoc.new(["--ri-site", "--merge"] + files) +rescue RDoc::RDocError => e + $stderr.puts e.message +rescue Exception => e + $stderr.puts "Couldn't build Ri documentation\n#{e.message}" +end + +def run_tests(test_list) + return if test_list.empty? + + require 'test/unit/ui/console/testrunner' + $:.unshift "lib" + test_list.each do |test| + next if File.directory?(test) + require test + end + + tests = [] + ObjectSpace.each_object { |o| tests << o if o.kind_of?(Class) } + tests.delete_if { |o| !o.ancestors.include?(Test::Unit::TestCase) } + tests.delete_if { |o| o == Test::Unit::TestCase } + + tests.each { |test| Test::Unit::UI::Console::TestRunner.run(test) } + $:.shift +end + +rdoc = %w(--main README --line-numbers + --title MIME::Types) +ri = %w(--ri-site --merge) +dox = %w(README ChangeLog lib) +build_rdoc rdoc + dox +build_ri ri + dox +run_tests Dir["tests/**/*"] diff --git a/trunk/mime-types/setup.rb b/trunk/mime-types/setup.rb new file mode 100644 index 0000000..0673386 --- /dev/null +++ b/trunk/mime-types/setup.rb @@ -0,0 +1,1366 @@ +# +# setup.rb +# +# Copyright (c) 2000-2004 Minero Aoki +# +# This program is free software. +# You can distribute/modify this program under the terms of +# the GNU LGPL, Lesser General Public License version 2.1. +# + +unless Enumerable.method_defined?(:map) # Ruby 1.4.6 + module Enumerable + alias map collect + end +end + +unless File.respond_to?(:read) # Ruby 1.6 + def File.read(fname) + open(fname) {|f| + return f.read + } + end +end + +def File.binread(fname) + open(fname, 'rb') {|f| + return f.read + } +end + +# for corrupted windows stat(2) +def File.dir?(path) + File.directory?((path[-1,1] == '/') ? path : path + '/') +end + + +class SetupError < StandardError; end + +def setup_rb_error(msg) + raise SetupError, msg +end + +# +# Config +# + +if arg = ARGV.detect {|arg| /\A--rbconfig=/ =~ arg } + ARGV.delete(arg) + require arg.split(/=/, 2)[1] + $".push 'rbconfig.rb' +else + require 'rbconfig' +end + +def multipackage_install? + FileTest.directory?(File.dirname($0) + '/packages') +end + + +class ConfigItem + def initialize(name, template, default, desc) + @name = name.freeze + @template = template + @value = default + @default = default.dup.freeze + @description = desc + end + + attr_reader :name + attr_reader :description + + attr_accessor :default + alias help_default default + + def help_opt + "--#{@name}=#{@template}" + end + + def value + @value + end + + def eval(table) + @value.gsub(%r<\$([^/]+)>) { table[$1] } + end + + def set(val) + @value = check(val) + end + + private + + def check(val) + setup_rb_error "config: --#{name} requires argument" unless val + val + end +end + +class BoolItem < ConfigItem + def config_type + 'bool' + end + + def help_opt + "--#{@name}" + end + + private + + def check(val) + return 'yes' unless val + unless /\A(y(es)?|n(o)?|t(rue)?|f(alse))\z/i =~ val + setup_rb_error "config: --#{@name} accepts only yes/no for argument" + end + (/\Ay(es)?|\At(rue)/i =~ value) ? 'yes' : 'no' + end +end + +class PathItem < ConfigItem + def config_type + 'path' + end + + private + + def check(path) + setup_rb_error "config: --#{@name} requires argument" unless path + path[0,1] == '$' ? path : File.expand_path(path) + end +end + +class ProgramItem < ConfigItem + def config_type + 'program' + end +end + +class SelectItem < ConfigItem + def initialize(name, template, default, desc) + super + @ok = template.split('/') + end + + def config_type + 'select' + end + + private + + def check(val) + unless @ok.include?(val.strip) + setup_rb_error "config: use --#{@name}=#{@template} (#{val})" + end + val.strip + end +end + +class PackageSelectionItem < ConfigItem + def initialize(name, template, default, help_default, desc) + super name, template, default, desc + @help_default = help_default + end + + attr_reader :help_default + + def config_type + 'package' + end + + private + + def check(val) + unless File.dir?("packages/#{val}") + setup_rb_error "config: no such package: #{val}" + end + val + end +end + +class ConfigTable_class + + def initialize(items) + @items = items + @table = {} + items.each do |i| + @table[i.name] = i + end + ALIASES.each do |ali, name| + @table[ali] = @table[name] + end + @script_extensions = ['rb'] + end + + attr_accessor :script_extensions + + include Enumerable + + def each(&block) + @items.each(&block) + end + + def key?(name) + @table.key?(name) + end + + def lookup(name) + @table[name] or raise ArgumentError, "no such config item: #{name}" + end + + def add(item) + @items.push item + @table[item.name] = item + end + + def remove(name) + item = lookup(name) + @items.delete_if {|i| i.name == name } + @table.delete_if {|name, i| i.name == name } + item + end + + def new + dup() + end + + def savefile + '.config' + end + + def load + begin + t = dup() + File.foreach(savefile()) do |line| + k, v = *line.split(/=/, 2) + t[k] = v.strip + end + t + rescue Errno::ENOENT + setup_rb_error $!.message + "#{File.basename($0)} config first" + end + end + + def save + @items.each {|i| i.value } + File.open(savefile(), 'w') {|f| + @items.each do |i| + f.printf "%s=%s\n", i.name, i.value if i.value + end + } + end + + def [](key) + lookup(key).eval(self) + end + + def []=(key, val) + lookup(key).set val + end + +end + +c = ::Config::CONFIG + +rubypath = c['bindir'] + '/' + c['ruby_install_name'] + +major = c['MAJOR'].to_i +minor = c['MINOR'].to_i +teeny = c['TEENY'].to_i +version = "#{major}.#{minor}" + +# ruby ver. >= 1.4.4? +newpath_p = ((major >= 2) or + ((major == 1) and + ((minor >= 5) or + ((minor == 4) and (teeny >= 4))))) + +if c['rubylibdir'] + # V < 1.6.3 + _stdruby = c['rubylibdir'] + _siteruby = c['sitedir'] + _siterubyver = c['sitelibdir'] + _siterubyverarch = c['sitearchdir'] +elsif newpath_p + # 1.4.4 <= V <= 1.6.3 + _stdruby = "$prefix/lib/ruby/#{version}" + _siteruby = c['sitedir'] + _siterubyver = "$siteruby/#{version}" + _siterubyverarch = "$siterubyver/#{c['arch']}" +else + # V < 1.4.4 + _stdruby = "$prefix/lib/ruby/#{version}" + _siteruby = "$prefix/lib/ruby/#{version}/site_ruby" + _siterubyver = _siteruby + _siterubyverarch = "$siterubyver/#{c['arch']}" +end +libdir = '-* dummy libdir *-' +stdruby = '-* dummy rubylibdir *-' +siteruby = '-* dummy site_ruby *-' +siterubyver = '-* dummy site_ruby version *-' +parameterize = lambda {|path| + path.sub(/\A#{Regexp.quote(c['prefix'])}/, '$prefix')\ + .sub(/\A#{Regexp.quote(libdir)}/, '$libdir')\ + .sub(/\A#{Regexp.quote(stdruby)}/, '$stdruby')\ + .sub(/\A#{Regexp.quote(siteruby)}/, '$siteruby')\ + .sub(/\A#{Regexp.quote(siterubyver)}/, '$siterubyver') +} +libdir = parameterize.call(c['libdir']) +stdruby = parameterize.call(_stdruby) +siteruby = parameterize.call(_siteruby) +siterubyver = parameterize.call(_siterubyver) +siterubyverarch = parameterize.call(_siterubyverarch) + +if arg = c['configure_args'].split.detect {|arg| /--with-make-prog=/ =~ arg } + makeprog = arg.sub(/'/, '').split(/=/, 2)[1] +else + makeprog = 'make' +end + +common_conf = [ + PathItem.new('prefix', 'path', c['prefix'], + 'path prefix of target environment'), + PathItem.new('bindir', 'path', parameterize.call(c['bindir']), + 'the directory for commands'), + PathItem.new('libdir', 'path', libdir, + 'the directory for libraries'), + PathItem.new('datadir', 'path', parameterize.call(c['datadir']), + 'the directory for shared data'), + PathItem.new('mandir', 'path', parameterize.call(c['mandir']), + 'the directory for man pages'), + PathItem.new('sysconfdir', 'path', parameterize.call(c['sysconfdir']), + 'the directory for man pages'), + PathItem.new('stdruby', 'path', stdruby, + 'the directory for standard ruby libraries'), + PathItem.new('siteruby', 'path', siteruby, + 'the directory for version-independent aux ruby libraries'), + PathItem.new('siterubyver', 'path', siterubyver, + 'the directory for aux ruby libraries'), + PathItem.new('siterubyverarch', 'path', siterubyverarch, + 'the directory for aux ruby binaries'), + PathItem.new('rbdir', 'path', '$siterubyver', + 'the directory for ruby scripts'), + PathItem.new('sodir', 'path', '$siterubyverarch', + 'the directory for ruby extentions'), + PathItem.new('rubypath', 'path', rubypath, + 'the path to set to #! line'), + ProgramItem.new('rubyprog', 'name', rubypath, + 'the ruby program using for installation'), + ProgramItem.new('makeprog', 'name', makeprog, + 'the make program to compile ruby extentions'), + SelectItem.new('shebang', 'all/ruby/never', 'ruby', + 'shebang line (#!) editing mode'), + BoolItem.new('without-ext', 'yes/no', 'no', + 'does not compile/install ruby extentions') +] +class ConfigTable_class # open again + ALIASES = { + 'std-ruby' => 'stdruby', + 'site-ruby-common' => 'siteruby', # For backward compatibility + 'site-ruby' => 'siterubyver', # For backward compatibility + 'bin-dir' => 'bindir', + 'bin-dir' => 'bindir', + 'rb-dir' => 'rbdir', + 'so-dir' => 'sodir', + 'data-dir' => 'datadir', + 'ruby-path' => 'rubypath', + 'ruby-prog' => 'rubyprog', + 'ruby' => 'rubyprog', + 'make-prog' => 'makeprog', + 'make' => 'makeprog' + } +end +multipackage_conf = [ + PackageSelectionItem.new('with', 'name,name...', '', 'ALL', + 'package names that you want to install'), + PackageSelectionItem.new('without', 'name,name...', '', 'NONE', + 'package names that you do not want to install') +] +if multipackage_install? + ConfigTable = ConfigTable_class.new(common_conf + multipackage_conf) +else + ConfigTable = ConfigTable_class.new(common_conf) +end + + +module MetaConfigAPI + + def eval_file_ifexist(fname) + instance_eval File.read(fname), fname, 1 if File.file?(fname) + end + + def config_names + ConfigTable.map {|i| i.name } + end + + def config?(name) + ConfigTable.key?(name) + end + + def bool_config?(name) + ConfigTable.lookup(name).config_type == 'bool' + end + + def path_config?(name) + ConfigTable.lookup(name).config_type == 'path' + end + + def value_config?(name) + case ConfigTable.lookup(name).config_type + when 'bool', 'path' + true + else + false + end + end + + def add_config(item) + ConfigTable.add item + end + + def add_bool_config(name, default, desc) + ConfigTable.add BoolItem.new(name, 'yes/no', default ? 'yes' : 'no', desc) + end + + def add_path_config(name, default, desc) + ConfigTable.add PathItem.new(name, 'path', default, desc) + end + + def set_config_default(name, default) + ConfigTable.lookup(name).default = default + end + + def remove_config(name) + ConfigTable.remove(name) + end + + def add_script_extension(ext) + ConfigTable.script_extensions << ext + end +end + + +# +# File Operations +# + +module FileOperations + + def mkdir_p(dirname, prefix = nil) + dirname = prefix + File.expand_path(dirname) if prefix + $stderr.puts "mkdir -p #{dirname}" if verbose? + return if no_harm? + + # does not check '/'... it's too abnormal case + dirs = File.expand_path(dirname).split(%r<(?=/)>) + if /\A[a-z]:\z/i =~ dirs[0] + disk = dirs.shift + dirs[0] = disk + dirs[0] + end + dirs.each_index do |idx| + path = dirs[0..idx].join('') + Dir.mkdir path unless File.dir?(path) + end + end + + def rm_f(fname) + $stderr.puts "rm -f #{fname}" if verbose? + return if no_harm? + + if File.exist?(fname) or File.symlink?(fname) + File.chmod 0777, fname + File.unlink fname + end + end + + def rm_rf(dn) + $stderr.puts "rm -rf #{dn}" if verbose? + return if no_harm? + + Dir.chdir dn + Dir.foreach('.') do |fn| + next if fn == '.' + next if fn == '..' + if File.dir?(fn) + verbose_off { + rm_rf fn + } + else + verbose_off { + rm_f fn + } + end + end + Dir.chdir '..' + Dir.rmdir dn + end + + def move_file(src, dest) + File.unlink dest if File.exist?(dest) + begin + File.rename src, dest + rescue + File.open(dest, 'wb') {|f| f.write File.binread(src) } + File.chmod File.stat(src).mode, dest + File.unlink src + end + end + + def install(from, dest, mode, prefix = nil) + $stderr.puts "install #{from} #{dest}" if verbose? + return if no_harm? + + realdest = prefix ? prefix + File.expand_path(dest) : dest + realdest = File.join(realdest, File.basename(from)) if File.dir?(realdest) + str = File.binread(from) + if diff?(str, realdest) + verbose_off { + rm_f realdest if File.exist?(realdest) + } + File.open(realdest, 'wb') {|f| + f.write str + } + File.chmod mode, realdest + + File.open("#{objdir_root()}/InstalledFiles", 'a') {|f| + if prefix + f.puts realdest.sub(prefix, '') + else + f.puts realdest + end + } + end + end + + def diff?(new_content, path) + return true unless File.exist?(path) + new_content != File.binread(path) + end + + def command(str) + $stderr.puts str if verbose? + system str or raise RuntimeError, "'system #{str}' failed" + end + + def ruby(str) + command config('rubyprog') + ' ' + str + end + + def make(task = '') + command config('makeprog') + ' ' + task + end + + def extdir?(dir) + File.exist?(dir + '/MANIFEST') + end + + def all_files_in(dirname) + Dir.open(dirname) {|d| + return d.select {|ent| File.file?("#{dirname}/#{ent}") } + } + end + + REJECT_DIRS = %w( + CVS SCCS RCS CVS.adm .svn + ) + + def all_dirs_in(dirname) + Dir.open(dirname) {|d| + return d.select {|n| File.dir?("#{dirname}/#{n}") } - %w(. ..) - REJECT_DIRS + } + end + +end + + +# +# Main Installer +# + +module HookUtils + + def run_hook(name) + try_run_hook "#{curr_srcdir()}/#{name}" or + try_run_hook "#{curr_srcdir()}/#{name}.rb" + end + + def try_run_hook(fname) + return false unless File.file?(fname) + begin + instance_eval File.read(fname), fname, 1 + rescue + setup_rb_error "hook #{fname} failed:\n" + $!.message + end + true + end + +end + + +module HookScriptAPI + + def get_config(key) + @config[key] + end + + alias config get_config + + def set_config(key, val) + @config[key] = val + end + + # + # srcdir/objdir (works only in the package directory) + # + + #abstract srcdir_root + #abstract objdir_root + #abstract relpath + + def curr_srcdir + "#{srcdir_root()}/#{relpath()}" + end + + def curr_objdir + "#{objdir_root()}/#{relpath()}" + end + + def srcfile(path) + "#{curr_srcdir()}/#{path}" + end + + def srcexist?(path) + File.exist?(srcfile(path)) + end + + def srcdirectory?(path) + File.dir?(srcfile(path)) + end + + def srcfile?(path) + File.file? srcfile(path) + end + + def srcentries(path = '.') + Dir.open("#{curr_srcdir()}/#{path}") {|d| + return d.to_a - %w(. ..) + } + end + + def srcfiles(path = '.') + srcentries(path).select {|fname| + File.file?(File.join(curr_srcdir(), path, fname)) + } + end + + def srcdirectories(path = '.') + srcentries(path).select {|fname| + File.dir?(File.join(curr_srcdir(), path, fname)) + } + end + +end + + +class ToplevelInstaller + + Version = '3.3.1' + Copyright = 'Copyright (c) 2000-2004 Minero Aoki' + + TASKS = [ + [ 'all', 'do config, setup, then install' ], + [ 'config', 'saves your configurations' ], + [ 'show', 'shows current configuration' ], + [ 'setup', 'compiles ruby extentions and others' ], + [ 'install', 'installs files' ], + [ 'clean', "does `make clean' for each extention" ], + [ 'distclean',"does `make distclean' for each extention" ] + ] + + def ToplevelInstaller.invoke + instance().invoke + end + + @singleton = nil + + def ToplevelInstaller.instance + @singleton ||= new(File.dirname($0)) + @singleton + end + + include MetaConfigAPI + + def initialize(ardir_root) + @config = nil + @options = { 'verbose' => true } + @ardir = File.expand_path(ardir_root) + end + + def inspect + "#<#{self.class} #{__id__()}>" + end + + def invoke + run_metaconfigs + case task = parsearg_global() + when nil, 'all' + @config = load_config('config') + parsearg_config + init_installers + exec_config + exec_setup + exec_install + else + @config = load_config(task) + __send__ "parsearg_#{task}" + init_installers + __send__ "exec_#{task}" + end + end + + def run_metaconfigs + eval_file_ifexist "#{@ardir}/metaconfig" + end + + def load_config(task) + case task + when 'config' + ConfigTable.new + when 'clean', 'distclean' + if File.exist?(ConfigTable.savefile) + then ConfigTable.load + else ConfigTable.new + end + else + ConfigTable.load + end + end + + def init_installers + @installer = Installer.new(@config, @options, @ardir, File.expand_path('.')) + end + + # + # Hook Script API bases + # + + def srcdir_root + @ardir + end + + def objdir_root + '.' + end + + def relpath + '.' + end + + # + # Option Parsing + # + + def parsearg_global + valid_task = /\A(?:#{TASKS.map {|task,desc| task }.join '|'})\z/ + + while arg = ARGV.shift + case arg + when /\A\w+\z/ + setup_rb_error "invalid task: #{arg}" unless valid_task =~ arg + return arg + + when '-q', '--quiet' + @options['verbose'] = false + + when '--verbose' + @options['verbose'] = true + + when '-h', '--help' + print_usage $stdout + exit 0 + + when '-v', '--version' + puts "#{File.basename($0)} version #{Version}" + exit 0 + + when '--copyright' + puts Copyright + exit 0 + + else + setup_rb_error "unknown global option '#{arg}'" + end + end + + nil + end + + + def parsearg_no_options + unless ARGV.empty? + setup_rb_error "#{task}: unknown options: #{ARGV.join ' '}" + end + end + + alias parsearg_show parsearg_no_options + alias parsearg_setup parsearg_no_options + alias parsearg_clean parsearg_no_options + alias parsearg_distclean parsearg_no_options + + def parsearg_config + re = /\A--(#{ConfigTable.map {|i| i.name }.join('|')})(?:=(.*))?\z/ + @options['config-opt'] = [] + + while i = ARGV.shift + if /\A--?\z/ =~ i + @options['config-opt'] = ARGV.dup + break + end + m = re.match(i) or setup_rb_error "config: unknown option #{i}" + name, value = *m.to_a[1,2] + @config[name] = value + end + end + + def parsearg_install + @options['no-harm'] = false + @options['install-prefix'] = '' + while a = ARGV.shift + case a + when /\A--no-harm\z/ + @options['no-harm'] = true + when /\A--prefix=(.*)\z/ + path = $1 + path = File.expand_path(path) unless path[0,1] == '/' + @options['install-prefix'] = path + else + setup_rb_error "install: unknown option #{a}" + end + end + end + + def print_usage(out) + out.puts 'Typical Installation Procedure:' + out.puts " $ ruby #{File.basename $0} config" + out.puts " $ ruby #{File.basename $0} setup" + out.puts " # ruby #{File.basename $0} install (may require root privilege)" + out.puts + out.puts 'Detailed Usage:' + out.puts " ruby #{File.basename $0} " + out.puts " ruby #{File.basename $0} [] []" + + fmt = " %-24s %s\n" + out.puts + out.puts 'Global options:' + out.printf fmt, '-q,--quiet', 'suppress message outputs' + out.printf fmt, ' --verbose', 'output messages verbosely' + out.printf fmt, '-h,--help', 'print this message' + out.printf fmt, '-v,--version', 'print version and quit' + out.printf fmt, ' --copyright', 'print copyright and quit' + out.puts + out.puts 'Tasks:' + TASKS.each do |name, desc| + out.printf fmt, name, desc + end + + fmt = " %-24s %s [%s]\n" + out.puts + out.puts 'Options for CONFIG or ALL:' + ConfigTable.each do |item| + out.printf fmt, item.help_opt, item.description, item.help_default + end + out.printf fmt, '--rbconfig=path', 'rbconfig.rb to load',"running ruby's" + out.puts + out.puts 'Options for INSTALL:' + out.printf fmt, '--no-harm', 'only display what to do if given', 'off' + out.printf fmt, '--prefix=path', 'install path prefix', '$prefix' + out.puts + end + + # + # Task Handlers + # + + def exec_config + @installer.exec_config + @config.save # must be final + end + + def exec_setup + @installer.exec_setup + end + + def exec_install + @installer.exec_install + end + + def exec_show + ConfigTable.each do |i| + printf "%-20s %s\n", i.name, i.value + end + end + + def exec_clean + @installer.exec_clean + end + + def exec_distclean + @installer.exec_distclean + end + +end + + +class ToplevelInstallerMulti < ToplevelInstaller + + include HookUtils + include HookScriptAPI + include FileOperations + + def initialize(ardir) + super + @packages = all_dirs_in("#{@ardir}/packages") + raise 'no package exists' if @packages.empty? + end + + def run_metaconfigs + eval_file_ifexist "#{@ardir}/metaconfig" + @packages.each do |name| + eval_file_ifexist "#{@ardir}/packages/#{name}/metaconfig" + end + end + + def init_installers + @installers = {} + @packages.each do |pack| + @installers[pack] = Installer.new(@config, @options, + "#{@ardir}/packages/#{pack}", + "packages/#{pack}") + end + + with = extract_selection(config('with')) + without = extract_selection(config('without')) + @selected = @installers.keys.select {|name| + (with.empty? or with.include?(name)) \ + and not without.include?(name) + } + end + + def extract_selection(list) + a = list.split(/,/) + a.each do |name| + setup_rb_error "no such package: #{name}" unless @installers.key?(name) + end + a + end + + def print_usage(f) + super + f.puts 'Inluded packages:' + f.puts ' ' + @packages.sort.join(' ') + f.puts + end + + # + # multi-package metaconfig API + # + + attr_reader :packages + + def declare_packages(list) + raise 'package list is empty' if list.empty? + list.each do |name| + raise "directory packages/#{name} does not exist"\ + unless File.dir?("#{@ardir}/packages/#{name}") + end + @packages = list + end + + # + # Task Handlers + # + + def exec_config + run_hook 'pre-config' + each_selected_installers {|inst| inst.exec_config } + run_hook 'post-config' + @config.save # must be final + end + + def exec_setup + run_hook 'pre-setup' + each_selected_installers {|inst| inst.exec_setup } + run_hook 'post-setup' + end + + def exec_install + run_hook 'pre-install' + each_selected_installers {|inst| inst.exec_install } + run_hook 'post-install' + end + + def exec_clean + rm_f ConfigTable.savefile + run_hook 'pre-clean' + each_selected_installers {|inst| inst.exec_clean } + run_hook 'post-clean' + end + + def exec_distclean + rm_f ConfigTable.savefile + run_hook 'pre-distclean' + each_selected_installers {|inst| inst.exec_distclean } + run_hook 'post-distclean' + end + + # + # lib + # + + def each_selected_installers + Dir.mkdir 'packages' unless File.dir?('packages') + @selected.each do |pack| + $stderr.puts "Processing the package `#{pack}' ..." if @options['verbose'] + Dir.mkdir "packages/#{pack}" unless File.dir?("packages/#{pack}") + Dir.chdir "packages/#{pack}" + yield @installers[pack] + Dir.chdir '../..' + end + end + + def verbose? + @options['verbose'] + end + + def no_harm? + @options['no-harm'] + end + +end + + +class Installer + + FILETYPES = %w( bin lib ext data ) + + include HookScriptAPI + include HookUtils + include FileOperations + + def initialize(config, opt, srcroot, objroot) + @config = config + @options = opt + @srcdir = File.expand_path(srcroot) + @objdir = File.expand_path(objroot) + @currdir = '.' + end + + def inspect + "#<#{self.class} #{File.basename(@srcdir)}>" + end + + # + # Hook Script API base methods + # + + def srcdir_root + @srcdir + end + + def objdir_root + @objdir + end + + def relpath + @currdir + end + + # + # configs/options + # + + def no_harm? + @options['no-harm'] + end + + def verbose? + @options['verbose'] + end + + def verbose_off + begin + save, @options['verbose'] = @options['verbose'], false + yield + ensure + @options['verbose'] = save + end + end + + # + # TASK config + # + + def exec_config + exec_task_traverse 'config' + end + + def config_dir_bin(rel) + end + + def config_dir_lib(rel) + end + + def config_dir_ext(rel) + extconf if extdir?(curr_srcdir()) + end + + def extconf + opt = @options['config-opt'].join(' ') + command "#{config('rubyprog')} #{curr_srcdir()}/extconf.rb #{opt}" + end + + def config_dir_data(rel) + end + + # + # TASK setup + # + + def exec_setup + exec_task_traverse 'setup' + end + + def setup_dir_bin(rel) + all_files_in(curr_srcdir()).each do |fname| + adjust_shebang "#{curr_srcdir()}/#{fname}" + end + end + + def adjust_shebang(path) + return if no_harm? + tmpfile = File.basename(path) + '.tmp' + begin + File.open(path, 'rb') {|r| + first = r.gets + return unless File.basename(config('rubypath')) == 'ruby' + return unless File.basename(first.sub(/\A\#!/, '').split[0]) == 'ruby' + $stderr.puts "adjusting shebang: #{File.basename(path)}" if verbose? + File.open(tmpfile, 'wb') {|w| + w.print first.sub(/\A\#!\s*\S+/, '#! ' + config('rubypath')) + w.write r.read + } + move_file tmpfile, File.basename(path) + } + ensure + File.unlink tmpfile if File.exist?(tmpfile) + end + end + + def setup_dir_lib(rel) + end + + def setup_dir_ext(rel) + make if extdir?(curr_srcdir()) + end + + def setup_dir_data(rel) + end + + # + # TASK install + # + + def exec_install + rm_f 'InstalledFiles' + exec_task_traverse 'install' + end + + def install_dir_bin(rel) + install_files collect_filenames_auto(), "#{config('bindir')}/#{rel}", 0755 + end + + def install_dir_lib(rel) + install_files ruby_scripts(), "#{config('rbdir')}/#{rel}", 0644 + end + + def install_dir_ext(rel) + return unless extdir?(curr_srcdir()) + install_files ruby_extentions('.'), + "#{config('sodir')}/#{File.dirname(rel)}", + 0555 + end + + def install_dir_data(rel) + install_files collect_filenames_auto(), "#{config('datadir')}/#{rel}", 0644 + end + + def install_files(list, dest, mode) + mkdir_p dest, @options['install-prefix'] + list.each do |fname| + install fname, dest, mode, @options['install-prefix'] + end + end + + def ruby_scripts + collect_filenames_auto().select {|n| /\.(#{ConfigTable.script_extensions.join('|')})\z/ =~ n } + end + + # picked up many entries from cvs-1.11.1/src/ignore.c + reject_patterns = %w( + core RCSLOG tags TAGS .make.state + .nse_depinfo #* .#* cvslog.* ,* .del-* *.olb + *~ *.old *.bak *.BAK *.orig *.rej _$* *$ + + *.org *.in .* + ) + mapping = { + '.' => '\.', + '$' => '\$', + '#' => '\#', + '*' => '.*' + } + REJECT_PATTERNS = Regexp.new('\A(?:' + + reject_patterns.map {|pat| + pat.gsub(/[\.\$\#\*]/) {|ch| mapping[ch] } + }.join('|') + + ')\z') + + def collect_filenames_auto + mapdir((existfiles() - hookfiles()).reject {|fname| + REJECT_PATTERNS =~ fname + }) + end + + def existfiles + all_files_in(curr_srcdir()) | all_files_in('.') + end + + def hookfiles + %w( pre-%s post-%s pre-%s.rb post-%s.rb ).map {|fmt| + %w( config setup install clean ).map {|t| sprintf(fmt, t) } + }.flatten + end + + def mapdir(filelist) + filelist.map {|fname| + if File.exist?(fname) # objdir + fname + else # srcdir + File.join(curr_srcdir(), fname) + end + } + end + + def ruby_extentions(dir) + Dir.open(dir) {|d| + ents = d.select {|fname| /\.#{::Config::CONFIG['DLEXT']}\z/ =~ fname } + if ents.empty? + setup_rb_error "no ruby extention exists: 'ruby #{$0} setup' first" + end + return ents + } + end + + # + # TASK clean + # + + def exec_clean + exec_task_traverse 'clean' + rm_f ConfigTable.savefile + rm_f 'InstalledFiles' + end + + def clean_dir_bin(rel) + end + + def clean_dir_lib(rel) + end + + def clean_dir_ext(rel) + return unless extdir?(curr_srcdir()) + make 'clean' if File.file?('Makefile') + end + + def clean_dir_data(rel) + end + + # + # TASK distclean + # + + def exec_distclean + exec_task_traverse 'distclean' + rm_f ConfigTable.savefile + rm_f 'InstalledFiles' + end + + def distclean_dir_bin(rel) + end + + def distclean_dir_lib(rel) + end + + def distclean_dir_ext(rel) + return unless extdir?(curr_srcdir()) + make 'distclean' if File.file?('Makefile') + end + + # + # lib + # + + def exec_task_traverse(task) + run_hook "pre-#{task}" + FILETYPES.each do |type| + if config('without-ext') == 'yes' and type == 'ext' + $stderr.puts 'skipping ext/* by user option' if verbose? + next + end + traverse task, type, "#{task}_dir_#{type}" + end + run_hook "post-#{task}" + end + + def traverse(task, rel, mid) + dive_into(rel) { + run_hook "pre-#{task}" + __send__ mid, rel.sub(%r[\A.*?(?:/|\z)], '') + all_dirs_in(curr_srcdir()).each do |d| + traverse task, "#{rel}/#{d}", mid + end + run_hook "post-#{task}" + } + end + + def dive_into(rel) + return unless File.dir?("#{@srcdir}/#{rel}") + + dir = File.basename(rel) + Dir.mkdir dir unless File.dir?(dir) + prevdir = Dir.pwd + Dir.chdir dir + $stderr.puts '---> ' + rel if verbose? + @currdir = rel + yield + Dir.chdir prevdir + $stderr.puts '<--- ' + rel if verbose? + @currdir = File.dirname(rel) + end + +end + + +if $0 == __FILE__ + begin + if multipackage_install? + ToplevelInstallerMulti.invoke + else + ToplevelInstaller.invoke + end + rescue SetupError + raise if $DEBUG + $stderr.puts $!.message + $stderr.puts "Try 'ruby #{$0} --help' for detailed usage." + exit 1 + end +end diff --git a/trunk/mime-types/tests/tests.rb b/trunk/mime-types/tests/tc_mime_type.rb similarity index 81% rename from trunk/mime-types/tests/tests.rb rename to trunk/mime-types/tests/tc_mime_type.rb index 0acced9..11f3b6c 100644 --- a/trunk/mime-types/tests/tests.rb +++ b/trunk/mime-types/tests/tc_mime_type.rb @@ -1,9 +1,18 @@ +#! /usr/bin/env ruby +#-- +# MIME::Types for Ruby +# http://rubyforge.org/projects/mime-types/ +# Copyright 2003 - 2005 Austin Ziegler. +# Licensed under a MIT-style licence. +# +# $Id$ +#++ $LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib") if __FILE__ == $0 -require 'mime/types' +require 'mime/type' require 'test/unit' -class TestMIME__Type < Test::Unit::TestCase #:nodoc: +class Test_MIME__Type < Test::Unit::TestCase #:nodoc: def setup @zip = MIME::Type.new('x-appl/x-zip') { |t| t.extensions = ['zip', 'zp'] } end @@ -258,67 +267,3 @@ class TestMIME__Type < Test::Unit::TestCase #:nodoc: assert_equal(MIME::Type.simplified('x-xyz/abc'), 'xyz/abc') end end - -class TestMIME__Types < Test::Unit::TestCase #:nodoc: - def test_s_AREF # singleton method '[]' - text_plain = MIME::Type.new('text/plain') do |t| - t.encoding = '8bit' - t.extensions = ['asc', 'txt', 'c', 'cc', 'h', 'hh', 'cpp', 'hpp', 'dat', 'hlp'] - end - text_plain_vms = MIME::Type.new('text/plain') do |t| - t.encoding = '8bit' - t.extensions = ['doc'] - t.system = 'vms' - end - text_vnd_fly = MIME::Type.new('text/vnd.fly') - assert_equal(MIME::Types['text/plain'].sort, - [text_plain, text_plain_vms].sort) - - assert_equal(MIME::Types[/bmp$/].sort, - [MIME::Type.from_array('image/x-bmp', ['bmp']), - MIME::Type.from_array('image/vnd.wap.wbmp', ['wbmp']), - MIME::Type.from_array('image/x-win-bmp')].sort) - assert_equal(MIME::Types[/bmp$/, { :complete => true }].sort, - [MIME::Type.from_array('image/x-bmp', ['bmp']), - MIME::Type.from_array('image/vnd.wap.wbmp', ['wbmp'])].sort) - assert_nothing_raised { MIME::Types['image/bmp'][0].system = RUBY_PLATFORM } - assert_equal(MIME::Types[/bmp$/, { :platform => true }], - [MIME::Type.from_array('image/x-bmp', ['bmp'])]) - - assert(MIME::Types['text/vnd.fly', { :complete => true }].empty?) - assert(!MIME::Types['text/plain', { :complete => true} ].empty?) - end - - def test_s_add - assert_nothing_raised do - @eruby = MIME::Type.new("application/x-eruby") do |t| - t.extensions = "rhtml" - t.encoding = "8bit" - end - - MIME::Types.add(@eruby) - end - - assert_equal(MIME::Types['application/x-eruby'], [@eruby]) - end - - def test_s_type_for - assert_equal(MIME::Types.type_for('xml'), MIME::Types['text/xml']) - assert_equal(MIME::Types.type_for('gif'), MIME::Types['image/gif']) - assert_nothing_raised do - MIME::Types['image/gif'][0].system = RUBY_PLATFORM - end - assert_equal(MIME::Types.type_for('gif', true), MIME::Types['image/gif']) - assert(MIME::Types.type_for('zzz').empty?) - end - - def test_s_of - assert_equal(MIME::Types.of('xml'), MIME::Types['text/xml']) - assert_equal(MIME::Types.of('gif'), MIME::Types['image/gif']) - assert_nothing_raised do - MIME::Types['image/gif'][0].system = RUBY_PLATFORM - end - assert_equal(MIME::Types.of('gif', true), MIME::Types['image/gif']) - assert(MIME::Types.of('zzz').empty?) - end -end diff --git a/trunk/mime-types/tests/tc_mime_types.rb b/trunk/mime-types/tests/tc_mime_types.rb new file mode 100644 index 0000000..e385e5b --- /dev/null +++ b/trunk/mime-types/tests/tc_mime_types.rb @@ -0,0 +1,77 @@ +#! /usr/bin/env ruby +#-- +# MIME::Types for Ruby +# http://rubyforge.org/projects/mime-types/ +# Copyright 2003 - 2005 Austin Ziegler. +# Licensed under a MIT-style licence. +# +# $Id$ +#++ +$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib") if __FILE__ == $0 + +require 'mime/types' +require 'test/unit' + +class TestMIME__Types < Test::Unit::TestCase #:nodoc: + def test_s_AREF # singleton method '[]' + text_plain = MIME::Type.new('text/plain') do |t| + t.encoding = '8bit' + t.extensions = ['asc', 'txt', 'c', 'cc', 'h', 'hh', 'cpp', 'hpp', 'dat', 'hlp'] + end + text_plain_vms = MIME::Type.new('text/plain') do |t| + t.encoding = '8bit' + t.extensions = ['doc'] + t.system = 'vms' + end + text_vnd_fly = MIME::Type.new('text/vnd.fly') + assert_equal(MIME::Types['text/plain'].sort, + [text_plain, text_plain_vms].sort) + + assert_equal([MIME::Type.from_array('image/x-bmp', ['bmp']), + MIME::Type.from_array('image/vnd.wap.wbmp', + ['wbmp'])].sort, MIME::Types[/bmp$/].sort) + assert_equal([MIME::Type.from_array('image/x-bmp', ['bmp']), + MIME::Type.from_array('image/vnd.wap.wbmp', + ['wbmp'])].sort, + MIME::Types[/bmp$/, { :complete => true }].sort) + assert_nothing_raised { MIME::Types['image/bmp'][0].system = RUBY_PLATFORM } + assert_equal([MIME::Type.from_array('image/x-bmp', ['bmp'])], + MIME::Types[/bmp$/, { :platform => true }]) + + assert(MIME::Types['text/vnd.fly', { :complete => true }].empty?) + assert(!MIME::Types['text/plain', { :complete => true} ].empty?) + end + + def test_s_add + assert_nothing_raised do + @eruby = MIME::Type.new("application/x-eruby") do |t| + t.extensions = "rhtml" + t.encoding = "8bit" + end + + MIME::Types.add(@eruby) + end + + assert_equal(MIME::Types['application/x-eruby'], [@eruby]) + end + + def test_s_type_for + assert_equal(MIME::Types.type_for('xml'), MIME::Types['text/xml']) + assert_equal(MIME::Types.type_for('gif'), MIME::Types['image/gif']) + assert_nothing_raised do + MIME::Types['image/gif'][0].system = RUBY_PLATFORM + end + assert_equal(MIME::Types.type_for('gif', true), MIME::Types['image/gif']) + assert(MIME::Types.type_for('zzz').empty?) + end + + def test_s_of + assert_equal(MIME::Types.of('xml'), MIME::Types['text/xml']) + assert_equal(MIME::Types.of('gif'), MIME::Types['image/gif']) + assert_nothing_raised do + MIME::Types['image/gif'][0].system = RUBY_PLATFORM + end + assert_equal(MIME::Types.of('gif', true), MIME::Types['image/gif']) + assert(MIME::Types.of('zzz').empty?) + end +end diff --git a/trunk/mime-types/tests/testall.rb b/trunk/mime-types/tests/testall.rb new file mode 100644 index 0000000..02c0765 --- /dev/null +++ b/trunk/mime-types/tests/testall.rb @@ -0,0 +1,18 @@ +#! /usr/bin/env ruby +#-- +# MIME::Types for Ruby +# http://rubyforge.org/projects/mime-types/ +# Copyright 2003 - 2005 Austin Ziegler. +# Licensed under a MIT-style licence. +# +# $Id$ +#++ + +$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib") if __FILE__ == $0 + +puts "Checking for test cases:" +Dir['tc_*.rb'].each do |testcase| + puts "\t#{testcase}" + require testcase +end +puts