linguistics 1.0.8 → 1.0.9

data/Rakefile

@@ -1,22 +1,24 @@
-#!rake
+#!rake -*- ruby -*-
 #
 # Linguistics rakefile
 #
 # Based on various other Rakefiles, especially one by Ben Bleything
 #
-# Copyright (c) 2007-2009 The FaerieMUD Consortium
+# Copyright (c) 2007-2011 The FaerieMUD Consortium
 #
 # Authors:
 #  * Michael Granger <ged@FaerieMUD.org>
 #
 
 BEGIN {
+	require 'rbconfig'
 	require 'pathname'
 	basedir = Pathname.new( __FILE__ ).dirname
 
 	libdir = basedir + "lib"
-	extdir = basedir + "ext"
+	extdir = libdir + Config::CONFIG['sitearch']
 
+	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
 	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
 	$LOAD_PATH.unshift( extdir.to_s ) unless $LOAD_PATH.include?( extdir.to_s )
 }
@@ -32,6 +34,15 @@ rescue LoadError
 	end
 end
 
+begin
+	require 'rubygems'
+rescue LoadError
+	module Gem
+		class Specification; end
+	end
+end
+
+require 'pathname'
 require 'rbconfig'
 require 'rake'
 require 'rake/testtask'
@@ -65,10 +76,10 @@ if VERSION_FILE.exist? && buildrev = ENV['CC_BUILD_LABEL']
 	PKG_VERSION = VERSION_FILE.read[ /VERSION\s*=\s*['"](\d+\.\d+\.\d+)['"]/, 1 ] + '.' + buildrev
 elsif VERSION_FILE.exist?
 	PKG_VERSION = VERSION_FILE.read[ /VERSION\s*=\s*['"](\d+\.\d+\.\d+)['"]/, 1 ]
-else
-	PKG_VERSION = '0.0.0'
 end
 
+PKG_VERSION = '0.0.0' unless defined?( PKG_VERSION ) && !PKG_VERSION.nil?
+
 PKG_FILE_NAME = "#{PKG_NAME.downcase}-#{PKG_VERSION}"
 GEM_FILE_NAME = "#{PKG_FILE_NAME}.gem"
 
@@ -82,7 +93,7 @@ EXTCONF       = EXTDIR + 'extconf.rb'
 
 ARTIFACTS_DIR = Pathname.new( CC_BUILD_ARTIFACTS )
 
-TEXT_FILES    = Rake::FileList.new( %w[Rakefile ChangeLog README LICENSE] )
+TEXT_FILES    = Rake::FileList.new( %w[Rakefile ChangeLog README* LICENSE] )
 BIN_FILES     = Rake::FileList.new( "#{BINDIR}/*" )
 LIB_FILES     = Rake::FileList.new( "#{LIBDIR}/**/*.rb" )
 EXT_FILES     = Rake::FileList.new( "#{EXTDIR}/**/*.{c,h,rb}" )
@@ -121,6 +132,10 @@ RELEASE_FILES = TEXT_FILES +
 
 RELEASE_FILES << LOCAL_RAKEFILE.to_s if LOCAL_RAKEFILE.exist?
 
+RELEASE_ANNOUNCE_ADDRESSES = [
+	"Ruby-Talk List <ruby-talk@tuby-lang.org>",
+]
+
 COVERAGE_MINIMUM = ENV['COVERAGE_MINIMUM'] ? Float( ENV['COVERAGE_MINIMUM'] ) : 85.0
 RCOV_EXCLUDES = 'spec,tests,/Library/Ruby,/var/lib,/usr/local/lib'
 RCOV_OPTS = [
@@ -140,7 +155,7 @@ if !RAKE_TASKDIR.exist?
 
 	if ans =~ /^y/i
 		$stderr.puts "Okay, fetching #{RAKE_TASKLIBS_URL} into #{RAKE_TASKDIR}..."
-		system 'hg', 'clone', RAKE_TASKLIBS_URL, RAKE_TASKDIR
+		system 'hg', 'clone', RAKE_TASKLIBS_URL, "./#{RAKE_TASKDIR}"
 		if ! $?.success?
 			fail "Damn. That didn't work. Giving up; maybe try manually fetching?"
 		end
@@ -153,30 +168,40 @@ if !RAKE_TASKDIR.exist?
 end
 
 require RAKE_TASKDIR + 'helpers.rb'
+include RakefileHelpers
 
-# Define some constants that depend on the 'svn' tasklib
+# Set the build ID if the mercurial executable is available
 if hg = which( 'hg' )
-	id = IO.read('|-') or exec hg.to_s, 'id', '-n'
-	PKG_BUILD = id.chomp[ /^[[:xdigit:]]+/ ]
+	id = `#{hg} id -n`.chomp
+	PKG_BUILD = (id.chomp[ /^[[:xdigit:]]+/ ] || '1')
 else
-	PKG_BUILD = 0
+	PKG_BUILD = '0'
 end
 SNAPSHOT_PKG_NAME = "#{PKG_FILE_NAME}.#{PKG_BUILD}"
 SNAPSHOT_GEM_NAME = "#{SNAPSHOT_PKG_NAME}.gem"
 
 # Documentation constants
-RDOCDIR = DOCSDIR + 'api'
+API_DOCSDIR = DOCSDIR + 'api'
+README_FILE = TEXT_FILES.find {|path| path =~ /^README/ } || 'README'
 RDOC_OPTIONS = [
-	'-w', '4',
-	'-HN',
-	'-i', '.',
-	'-m', 'README',
-	'-t', PKG_NAME,
-	'-W', 'http://deveiate.org/projects/Linguistics/browser/'
+	'--tab-width=4',
+	'--show-hash',
+	'--include', BASEDIR.to_s,
+	"--main=#{README_FILE}",
+	"--title=#{PKG_NAME}",
+  ]
+YARD_OPTIONS = [
+	'--use-cache',
+	'--protected',
+	'-r', README_FILE,
+	'--exclude', 'extconf\\.rb',
+	'--files', 'ChangeLog,LICENSE',
+	'--output-dir', API_DOCSDIR.to_s,
+	'--title', "#{PKG_NAME} #{PKG_VERSION}",
   ]
 
 # Release constants
-SMTP_HOST = 'mail.faeriemud.org'
+SMTP_HOST = "mail.faeriemud.org"
 SMTP_PORT = 465 # SMTP + SSL
 
 # Project constants
@@ -186,9 +211,7 @@ PROJECT_DOCDIR = "#{PROJECT_PUBDIR}/#{PKG_NAME}"
 PROJECT_SCPPUBURL = "#{PROJECT_HOST}:#{PROJECT_PUBDIR}"
 PROJECT_SCPDOCURL = "#{PROJECT_HOST}:#{PROJECT_DOCDIR}"
 
-# Rubyforge stuff
-RUBYFORGE_GROUP = 'deveiate'
-RUBYFORGE_PROJECT = 'linguistics'
+GEM_PUBHOST = 'rubygems.org'
 
 # Gem dependencies: gemname => version
 DEPENDENCIES = {
@@ -196,17 +219,14 @@ DEPENDENCIES = {
 
 # Developer Gem dependencies: gemname => version
 DEVELOPMENT_DEPENDENCIES = {
-	'rake'        => '>= 0.8.7',
-	'rcodetools'  => '>= 0.7.0.0',
-	'rcov'        => '>= 0.8.1.2.0',
-	'rdoc'        => '>= 2.4.3',
-	'RedCloth'    => '>= 4.0.3',
-	'rspec'       => '>= 1.2.6',
-	'rubyforge'   => '>= 0',
-	'termios'     => '>= 0',
-	'text-format' => '>= 1.0.0',
-	'tmail'       => '>= 1.2.3.1',
-	'diff-lcs'    => '>= 1.1.2',
+	'rake'          => '~> 0.8.7',
+	'rcodetools'    => '~> 0.7.0.0',
+	'rcov'          => '~> 0.8.1.2.0',
+	'RedCloth'      => '~> 4.2.3',
+	'rspec'         => '~> 1.2.6',
+	'ruby-termios'  => '~> 0.9.6',
+	'text-format'   => '~> 1.0.0',
+	'tmail'         => '~> 1.2.3.1',
 	'wordnet' => '>=0.0.5',
 	'linkparser' => '>=1.0.3',
 }
@@ -227,16 +247,14 @@ GEMSPEC   = Gem::Specification.new do |gem|
 		"contains various English-language utilities.",
   	  ].join( "\n" )
 
-	gem.authors           = "Michael Granger"
+	gem.authors           = ["Michael Granger"]
 	gem.email             = ["ged@FaerieMUD.org"]
 	gem.homepage          = 'http://deveiate.org/projects/Linguistics/'
-
-	# Apparently this isn't actually the 'project'?
-	gem.rubyforge_project = RUBYFORGE_GROUP
+	gem.licenses          = ["BSD"]
 
 	gem.has_rdoc          = true
 	gem.rdoc_options      = RDOC_OPTIONS
-	gem.extra_rdoc_files  = %w[ChangeLog README LICENSE]
+	gem.extra_rdoc_files  = TEXT_FILES - [ 'Rakefile' ]
 
 	gem.bindir            = BINDIR.relative_path_from(BASEDIR).to_s
 	gem.executables       = BIN_FILES.select {|pn| File.executable?(pn) }.
@@ -250,6 +268,13 @@ GEMSPEC   = Gem::Specification.new do |gem|
 	gem.files             = RELEASE_FILES
 	gem.test_files        = SPEC_FILES
 
+	# signing key and certificate chain
+	gem.signing_key       = '/Volumes/Keys/ged-private_gem_key.pem'
+	gem.cert_chain        = [File.expand_path('~/.gem/ged-public_gem_cert.pem')]
+
+
+	gem.required_ruby_version = '>= 1.8.7'
+
 	DEPENDENCIES.each do |name, version|
 		version = '>= 0' if version.length.zero?
 		gem.add_runtime_dependency( name, version )
@@ -290,14 +315,14 @@ import LOCAL_RAKEFILE if LOCAL_RAKEFILE.exist?
 #####################################################################
 
 ### Default task
-task :default  => [:clean, :local, :spec, :rdoc, :package]
+task :default  => [:clean, :local, :spec, :apidocs, :package]
 
 ### Task the local Rakefile can append to -- no-op by default
 task :local
 
 ### Task: clean
-CLEAN.include 'coverage'
-CLOBBER.include 'artifacts', 'coverage.info', PKGDIR
+CLEAN.include 'coverage', '**/*.orig', '**/*.rej'
+CLOBBER.include 'artifacts', 'coverage.info', 'ChangeLog', PKGDIR
 
 ### Task: changelog
 file 'ChangeLog' do |task|

data/lib/linguistics.rb

@@ -26,7 +26,7 @@ module Linguistics
 	### Class constants
 
 	# Release version
-	VERSION = '1.0.8'
+	VERSION = '1.0.9'
 
 	# Language module implementors should do something like:
 	#   Linguistics::DefaultLanguages.push( :ja ) # or whatever

data/lib/linguistics/en.rb

@@ -1366,7 +1366,7 @@ module Linguistics::EN
 
 	### Transform the given +number+ into an ordinate word.
 	def ordinate( number )
-		numwords( number ).ordinal
+		return Linguistics::EN.ordinal( Linguistics::EN.numwords(number) )
 	end
 
 

data/lib/linguistics/en/wordnet.rb

@@ -74,7 +74,7 @@ require 'linguistics/en'
 # 
 # == Version
 #
-#  $Id$
+#  $Id: wordnet.rb,v 2640c845eb5c 2009/11/17 16:59:25 ged $
 # 
 module Linguistics::EN
 

data/rake/documentation.rb

@@ -0,0 +1,123 @@
+# 
+# Documentation Rake tasks
+# 
+
+require 'rake/clean'
+
+
+# Append docs/lib to the load path if it exists for documentation
+# helpers.
+DOCSLIB = DOCSDIR + 'lib'
+$LOAD_PATH.unshift( DOCSLIB.to_s ) if DOCSLIB.exist?
+
+# Make relative string paths of all the stuff we need to generate docs for
+DOCFILES = Rake::FileList[ LIB_FILES + EXT_FILES + GEMSPEC.extra_rdoc_files ]
+
+# Documentation coverage constants
+COVERAGE_DIR    = BASEDIR + 'coverage'
+COVERAGE_REPORT = COVERAGE_DIR + 'documentation.txt'
+
+
+# Prefer YARD, fallback to RDoc
+begin
+	require 'yard'
+	require 'yard/rake/yardoc_task'
+
+	# Undo the lazy-assed monkeypatch yard/globals.rb installs and
+	# re-install them as mixins as they should have been from the
+	# start
+	# <metamonkeypatch>
+	class Object
+		remove_method :log
+		remove_method :P
+	end
+
+	module YardGlobals
+		def P(namespace, name = nil)
+			namespace, name = nil, namespace if name.nil?
+			YARD::Registry.resolve(namespace, name, false, true)
+		end
+
+		def log
+			YARD::Logger.instance
+		end
+	end
+
+	class YARD::CLI::Base; include YardGlobals; end
+	class YARD::CLI::Command; include YardGlobals; end
+	class YARD::Parser::SourceParser; extend YardGlobals; include YardGlobals; end
+	class YARD::Parser::CParser; include YardGlobals; end
+	class YARD::CodeObjects::Base; include YardGlobals; end
+	class YARD::Handlers::Base; include YardGlobals; end
+	class YARD::Handlers::Processor; include YardGlobals; end
+	class YARD::Serializers::Base; include YardGlobals; end
+	class YARD::RegistryStore; include YardGlobals; end
+	class YARD::Docstring; include YardGlobals; end
+	module YARD::Templates::Helpers::ModuleHelper; include YardGlobals; end
+	module YARD::Templates::Helpers::HtmlHelper; include YardGlobals; end
+
+	if vvec(RUBY_VERSION) >= vvec("1.9.1")
+		# Monkeypatched to allow more than two '#' characters at the beginning
+		# of the comment line.
+		# Patched from yard-0.5.8
+		require 'yard/parser/ruby/ruby_parser'
+		class YARD::Parser::Ruby::RipperParser < Ripper
+			def on_comment(comment)
+				visit_ns_token(:comment, comment)
+				case comment
+				when /\A# @group\s+(.+)\s*\Z/
+					@groups.unshift [lineno, $1]
+					return
+				when /\A# @endgroup\s*\Z/
+					@groups.unshift [lineno, nil]
+					return
+				end
+
+				comment = comment.gsub(/^\#+\s{0,1}/, '').chomp
+				append_comment = @comments[lineno - 1]
+
+				if append_comment && @comments_last_column == column
+					@comments.delete(lineno - 1)
+					comment = append_comment + "\n" + comment
+				end
+
+				@comments[lineno] = comment
+				@comments_last_column = column
+			end
+		end # class YARD::Parser::Ruby::RipperParser
+	end
+
+	# </metamonkeypatch>
+
+	YARD_OPTIONS = [] unless defined?( YARD_OPTIONS )
+
+	yardoctask = YARD::Rake::YardocTask.new( :apidocs ) do |task|
+		task.files   = DOCFILES
+		task.options = YARD_OPTIONS
+		task.options << '--debug' << '--verbose' if $trace
+	end
+	yardoctask.before = lambda {
+		trace "Calling yardoc like:",
+			"  yardoc %s" % [ quotelist(yardoctask.options + yardoctask.files).join(' ') ]
+	}
+
+	YARDOC_CACHE = BASEDIR + '.yardoc'
+	CLOBBER.include( YARDOC_CACHE.to_s )
+
+rescue LoadError
+	require 'rdoc/task'
+
+	desc "Build API documentation in #{API_DOCSDIR}"
+	RDoc::Task.new( :apidocs ) do |task|
+		task.main     = "README"
+		task.rdoc_files.include( DOCFILES )
+		task.rdoc_dir = API_DOCSDIR.to_s
+		task.options  = RDOC_OPTIONS
+	end
+end
+
+# Need the DOCFILES to exist to build the API docs
+task :apidocs => DOCFILES
+
+CLEAN.include( API_DOCSDIR.to_s )
+

data/rake/helpers.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+
 #####################################################################
 ###	G L O B A L   H E L P E R   F U N C T I O N S
 #####################################################################
@@ -6,7 +7,6 @@
 
 require 'pathname'
 require 'uri'
-require 'open3'
 
 begin
 	require 'readline'
@@ -19,416 +19,484 @@ rescue LoadError
 	end
 end
 
-# Set some ANSI escape code constants (Shamelessly stolen from Perl's
-# Term::ANSIColor by Russ Allbery <rra@stanford.edu> and Zenin <zenin@best.com>
-ANSI_ATTRIBUTES = {
-	'clear'      => 0,
-	'reset'      => 0,
-	'bold'       => 1,
-	'dark'       => 2,
-	'underline'  => 4,
-	'underscore' => 4,
-	'blink'      => 5,
-	'reverse'    => 7,
-	'concealed'  => 8,
-
-	'black'      => 30,   'on_black'   => 40, 
-	'red'        => 31,   'on_red'     => 41, 
-	'green'      => 32,   'on_green'   => 42, 
-	'yellow'     => 33,   'on_yellow'  => 43, 
-	'blue'       => 34,   'on_blue'    => 44, 
-	'magenta'    => 35,   'on_magenta' => 45, 
-	'cyan'       => 36,   'on_cyan'    => 46, 
-	'white'      => 37,   'on_white'   => 47
-}
-
-
-MULTILINE_PROMPT = <<-'EOF'
-Enter one or more values for '%s'.
-A blank line finishes input.
-EOF
-
-
-CLEAR_TO_EOL       = "\e[K"
-CLEAR_CURRENT_LINE = "\e[2K"
-
-
-### Output a logging message
-def log( *msg )
-	output = colorize( msg.flatten.join(' '), 'cyan' )
-	$stderr.puts( output )
-end
+module RakefileHelpers
+	# Set some ANSI escape code constants (Shamelessly stolen from Perl's
+	# Term::ANSIColor by Russ Allbery <rra@stanford.edu> and Zenin <zenin@best.com>
+	ANSI_ATTRIBUTES = {
+		'clear'      => 0,
+		'reset'      => 0,
+		'bold'       => 1,
+		'dark'       => 2,
+		'underline'  => 4,
+		'underscore' => 4,
+		'blink'      => 5,
+		'reverse'    => 7,
+		'concealed'  => 8,
 
+		'black'      => 30,   'on_black'   => 40, 
+		'red'        => 31,   'on_red'     => 41, 
+		'green'      => 32,   'on_green'   => 42, 
+		'yellow'     => 33,   'on_yellow'  => 43, 
+		'blue'       => 34,   'on_blue'    => 44, 
+		'magenta'    => 35,   'on_magenta' => 45, 
+		'cyan'       => 36,   'on_cyan'    => 46, 
+		'white'      => 37,   'on_white'   => 47
+	}
 
-### Output a logging message if tracing is on
-def trace( *msg )
-	return unless $trace
-	output = colorize( msg.flatten.join(' '), 'yellow' )
-	$stderr.puts( output )
-end
 
+	MULTILINE_PROMPT = <<-'EOF'
+	Enter one or more values for '%s'.
+	A blank line finishes input.
+	EOF
 
-### Return the specified args as a string, quoting any that have a space.
-def quotelist( *args )
-	return args.flatten.collect {|part| part =~ /\s/ ? part.inspect : part}
-end
 
+	CLEAR_TO_EOL       = "\e[K"
+	CLEAR_CURRENT_LINE = "\e[2K"
+
+
+	TAR_OPTS = { :compression => :gzip }
+
+
+	###############
+	module_function
+	###############
+
+	### Output a logging message
+	def log( *msg )
+		output = colorize( msg.flatten.join(' '), 'cyan' )
+		$stderr.puts( output )
+	end
+
+
+	### Output a logging message if tracing is on
+	def trace( *msg )
+		return unless $trace
+		output = colorize( msg.flatten.join(' '), 'yellow' )
+		$stderr.puts( output )
+	end
 
-### Run the specified command +cmd+ with system(), failing if the execution
-### fails.
-def run( *cmd )
-	cmd.flatten!
 
-	if cmd.length > 1
-		trace( quotelist(*cmd) )
-	else
-		trace( cmd )
+	### Return the specified args as a string, quoting any that have a space.
+	def quotelist( *args )
+		return args.flatten.collect {|part| part =~ /\s/ ? part.inspect : part}
 	end
 
-	if $dryrun
-		$stderr.puts "(dry run mode)"
-	else
-		system( *cmd )
-		unless $?.success?
-			fail "Command failed: [%s]" % [cmd.join(' ')]
+
+	### Run the specified command +cmd+ with system(), failing if the execution
+	### fails.
+	def run( *cmd )
+		cmd.flatten!
+
+		if cmd.length > 1
+			trace( quotelist(*cmd) )
+		else
+			trace( cmd )
+		end
+
+		if $dryrun
+			$stderr.puts "(dry run mode)"
+		else
+			system( *cmd )
+			unless $?.success?
+				fail "Command failed: [%s]" % [cmd.join(' ')]
+			end
 		end
 	end
-end
 
 
-### Run the given +cmd+ with the specified +args+ without interpolation by the shell and
-### return anything written to its STDOUT.
-def read_command_output( cmd, *args )
-	trace "Reading output from: %s" % [ cmd, quotelist(cmd, *args) ]
-	output = IO.read( '|-' ) or exec cmd, *args
-	return output
-end
+	### Run the given +cmd+ with the specified +args+ without interpolation by the shell and
+	### return anything written to its STDOUT.
+	def read_command_output( cmd, *args )
+		trace "Reading output from: %s" % [ cmd, quotelist(cmd, *args) ]
+		output = IO.read( '|-' ) or exec cmd, *args
+		return output
+	end
 
 
-### Run a subordinate Rake process with the same options and the specified +targets+.
-def rake( *targets )
-	opts = ARGV.select {|arg| arg[0,1] == '-' }
-	args = opts + targets.map {|t| t.to_s }
-	run 'rake', '-N', *args
-end
+	### Run a subordinate Rake process with the same options and the specified +targets+.
+	def rake( *targets )
+		opts = ARGV.select {|arg| arg[0,1] == '-' }
+		args = opts + targets.map {|t| t.to_s }
+		run 'rake', '-N', *args
+	end
 
 
-### Open a pipe to a process running the given +cmd+ and call the given block with it.
-def pipeto( *cmd )
-	$DEBUG = true
+	### Open a pipe to a process running the given +cmd+ and call the given block with it.
+	def pipeto( *cmd )
+		$DEBUG = true
 
-	cmd.flatten!
-	log( "Opening a pipe to: ", cmd.collect {|part| part =~ /\s/ ? part.inspect : part} ) 
-	if $dryrun
-		$stderr.puts "(dry run mode)"
-	else
-		open( '|-', 'w+' ) do |io|
+		cmd.flatten!
+		log( "Opening a pipe to: ", cmd.collect {|part| part =~ /\s/ ? part.inspect : part} ) 
+		if $dryrun
+			$stderr.puts "(dry run mode)"
+		else
+			open( '|-', 'w+' ) do |io|
 
-			# Parent
-			if io
-				yield( io )
+				# Parent
+				if io
+					yield( io )
 
-			# Child
-			else
-				exec( *cmd )
-				fail "Command failed: [%s]" % [cmd.join(' ')]
+				# Child
+				else
+					exec( *cmd )
+					fail "Command failed: [%s]" % [cmd.join(' ')]
+				end
 			end
 		end
 	end
-end
 
 
-### Download the file at +sourceuri+ via HTTP and write it to +targetfile+.
-def download( sourceuri, targetfile=nil )
-	oldsync = $stdout.sync
-	$stdout.sync = true
-	require 'open-uri'
+	### Download the file at +sourceuri+ via HTTP and write it to +targetfile+.
+	def download( sourceuri, targetfile=nil )
+		oldsync = $stdout.sync
+		$stdout.sync = true
+		require 'open-uri'
 
-	targetpath = Pathname.new( targetfile )
+		targetpath = Pathname.new( targetfile )
 
-	log "Downloading %s to %s" % [sourceuri, targetfile]
-	trace "  connecting..."
-	ifh = open( sourceuri ) do |ifh|
-		trace "  connected..."
-		targetpath.open( File::WRONLY|File::TRUNC|File::CREAT, 0644 ) do |ofh|
-			log "Downloading..."
-			buf = ''
+		log "Downloading %s to %s" % [sourceuri, targetfile]
+		trace "  connecting..."
+		ifh = open( sourceuri ) do |ifh|
+			trace "  connected..."
+			targetpath.open( File::WRONLY|File::TRUNC|File::CREAT, 0644 ) do |ofh|
+				log "Downloading..."
+				buf = ''
 
-			while ifh.read( 16384, buf )
-				until buf.empty?
-					bytes = ofh.write( buf )
-					buf.slice!( 0, bytes )
+				while ifh.read( 16384, buf )
+					until buf.empty?
+						bytes = ofh.write( buf )
+						buf.slice!( 0, bytes )
+					end
 				end
+
+				log "Done."
 			end
 
-			log "Done."
 		end
 
+		return targetpath
+	ensure
+		$stdout.sync = oldsync
 	end
 
-	return targetpath
-ensure
-	$stdout.sync = oldsync
-end
 
+	### Return the fully-qualified path to the specified +program+ in the PATH.
+	def which( program )
+		return nil unless ENV['PATH']
+		ENV['PATH'].split(/:/).
+			collect {|dir| Pathname.new(dir) + program }.
+			find {|path| path.exist? && path.executable? }
+	end
 
-### Return the fully-qualified path to the specified +program+ in the PATH.
-def which( program )
-	ENV['PATH'].split(/:/).
-		collect {|dir| Pathname.new(dir) + program }.
-		find {|path| path.exist? && path.executable? }
-end
 
+	### Create a string that contains the ANSI codes specified and return it
+	def ansi_code( *attributes )
+		attributes.flatten!
+		attributes.collect! {|at| at.to_s }
+		# $stderr.puts "Returning ansicode for TERM = %p: %p" %
+		# 	[ ENV['TERM'], attributes ]
+		return '' unless /(?:vt10[03]|xterm(?:-color)?|linux|screen)/i =~ ENV['TERM']
+		attributes = ANSI_ATTRIBUTES.values_at( *attributes ).compact.join(';')
 
-### Create a string that contains the ANSI codes specified and return it
-def ansi_code( *attributes )
-	attributes.flatten!
-	attributes.collect! {|at| at.to_s }
-	# $stderr.puts "Returning ansicode for TERM = %p: %p" %
-	# 	[ ENV['TERM'], attributes ]
-	return '' unless /(?:vt10[03]|xterm(?:-color)?|linux|screen)/i =~ ENV['TERM']
-	attributes = ANSI_ATTRIBUTES.values_at( *attributes ).compact.join(';')
-
-	# $stderr.puts "  attr is: %p" % [attributes]
-	if attributes.empty? 
-		return ''
-	else
-		return "\e[%sm" % attributes
+		# $stderr.puts "  attr is: %p" % [attributes]
+		if attributes.empty? 
+			return ''
+		else
+			return "\e[%sm" % attributes
+		end
 	end
-end
 
 
-### Colorize the given +string+ with the specified +attributes+ and return it, handling 
-### line-endings, color reset, etc.
-def colorize( *args )
-	string = ''
+	### Colorize the given +string+ with the specified +attributes+ and return it, handling 
+	### line-endings, color reset, etc.
+	def colorize( *args )
+		string = ''
+
+		if block_given?
+			string = yield
+		else
+			string = args.shift
+		end
+
+		ending = string[/(\s)$/] || ''
+		string = string.rstrip
 
-	if block_given?
-		string = yield
-	else
-		string = args.shift
+		return ansi_code( args.flatten ) + string + ansi_code( 'reset' ) + ending
 	end
 
-	ending = string[/(\s)$/] || ''
-	string = string.rstrip
 
-	return ansi_code( args.flatten ) + string + ansi_code( 'reset' ) + ending
-end
+	### Output the specified <tt>msg</tt> as an ANSI-colored error message
+	### (white on red).
+	def error_message( msg, details='' )
+		$stderr.puts colorize( 'bold', 'white', 'on_red' ) { msg } + details
+	end
+	alias :error :error_message
 
 
-### Output the specified <tt>msg</tt> as an ANSI-colored error message
-### (white on red).
-def error_message( msg, details='' )
-	$stderr.puts colorize( 'bold', 'white', 'on_red' ) { msg } + details
-end
-alias :error :error_message
+	### Highlight and embed a prompt control character in the given +string+ and return it.
+	def make_prompt_string( string )
+		return CLEAR_CURRENT_LINE + colorize( 'bold', 'green' ) { string + ' ' }
+	end
 
 
-### Highlight and embed a prompt control character in the given +string+ and return it.
-def make_prompt_string( string )
-	return CLEAR_CURRENT_LINE + colorize( 'bold', 'green' ) { string + ' ' }
-end
+	### Output the specified <tt>prompt_string</tt> as a prompt (in green) and
+	### return the user's input with leading and trailing spaces removed.  If a
+	### test is provided, the prompt will repeat until the test returns true.
+	### An optional failure message can also be passed in.
+	def prompt( prompt_string, failure_msg="Try again." ) # :yields: response
+		prompt_string.chomp!
+		prompt_string << ":" unless /\W$/.match( prompt_string )
+		response = nil
+
+		begin
+			prompt = make_prompt_string( prompt_string )
+			response = readline( prompt ) || ''
+			response.strip!
+			if block_given? && ! yield( response ) 
+				error_message( failure_msg + "\n\n" )
+				response = nil
+			end
+		end while response.nil?
 
+		return response
+	end
 
-### Output the specified <tt>prompt_string</tt> as a prompt (in green) and
-### return the user's input with leading and trailing spaces removed.  If a
-### test is provided, the prompt will repeat until the test returns true.
-### An optional failure message can also be passed in.
-def prompt( prompt_string, failure_msg="Try again." ) # :yields: response
-	prompt_string.chomp!
-	prompt_string << ":" unless /\W$/.match( prompt_string )
-	response = nil
-
-	begin
-		prompt = make_prompt_string( prompt_string )
-		response = readline( prompt ) || ''
-		response.strip!
-		if block_given? && ! yield( response ) 
-			error_message( failure_msg + "\n\n" )
-			response = nil
-		end
-	end while response.nil?
 
-	return response
-end
+	### Prompt the user with the given <tt>prompt_string</tt> via #prompt,
+	### substituting the given <tt>default</tt> if the user doesn't input
+	### anything.  If a test is provided, the prompt will repeat until the test
+	### returns true.  An optional failure message can also be passed in.
+	def prompt_with_default( prompt_string, default, failure_msg="Try again." )
+		response = nil
 
+		begin
+			default ||= '~'
+			response = prompt( "%s [%s]" % [ prompt_string, default ] )
+			response = default.to_s if !response.nil? && response.empty? 
 
-### Prompt the user with the given <tt>prompt_string</tt> via #prompt,
-### substituting the given <tt>default</tt> if the user doesn't input
-### anything.  If a test is provided, the prompt will repeat until the test
-### returns true.  An optional failure message can also be passed in.
-def prompt_with_default( prompt_string, default, failure_msg="Try again." )
-	response = nil
+			trace "Validating response %p" % [ response ]
 
-	begin
-		default ||= '~'
-		response = prompt( "%s [%s]" % [ prompt_string, default ] )
-		response = default.to_s if !response.nil? && response.empty? 
+			# the block is a validator.  We need to make sure that the user didn't
+			# enter '~', because if they did, it's nil and we should move on.  If
+			# they didn't, then call the block.
+			if block_given? && response != '~' && ! yield( response )
+				error_message( failure_msg + "\n\n" )
+				response = nil
+			end
+		end while response.nil?
 
-		trace "Validating response %p" % [ response ]
+		return nil if response == '~'
+		return response
+	end
 
-		# the block is a validator.  We need to make sure that the user didn't
-		# enter '~', because if they did, it's nil and we should move on.  If
-		# they didn't, then call the block.
-		if block_given? && response != '~' && ! yield( response )
-			error_message( failure_msg + "\n\n" )
-			response = nil
+
+	### Prompt for an array of values
+	def prompt_for_multiple_values( label, default=nil )
+	    $stderr.puts( MULTILINE_PROMPT % [label] )
+	    if default
+			$stderr.puts "Enter a single blank line to keep the default:\n  %p" % [ default ]
 		end
-	end while response.nil?
 
-	return nil if response == '~'
-	return response
-end
+	    results = []
+	    result = nil
 
+	    begin
+	        result = readline( make_prompt_string("> ") )
+			if result.nil? || result.empty?
+				results << default if default && results.empty?
+			else
+	        	results << result 
+			end
+	    end until result.nil? || result.empty?
 
-### Prompt for an array of values
-def prompt_for_multiple_values( label, default=nil )
-    $stderr.puts( MULTILINE_PROMPT % [label] )
-    if default
-		$stderr.puts "Enter a single blank line to keep the default:\n  %p" % [ default ]
+	    return results.flatten
 	end
 
-    results = []
-    result = nil
 
-    begin
-        result = readline( make_prompt_string("> ") )
-		if result.nil? || result.empty?
-			results << default if default && results.empty?
-		else
-        	results << result 
-		end
-    end until result.nil? || result.empty?
+	### Turn echo and masking of input on/off. 
+	def noecho( masked=false )
+		require 'termios'
 
-    return results.flatten
-end
+		rval = nil
+		term = Termios.getattr( $stdin )
 
+		begin
+			newt = term.dup
+			newt.c_lflag &= ~Termios::ECHO
+			newt.c_lflag &= ~Termios::ICANON if masked
 
-### Turn echo and masking of input on/off. 
-def noecho( masked=false )
-	require 'termios'
+			Termios.tcsetattr( $stdin, Termios::TCSANOW, newt )
 
-	rval = nil
-	term = Termios.getattr( $stdin )
+			rval = yield
+		ensure
+			Termios.tcsetattr( $stdin, Termios::TCSANOW, term )
+		end
 
-	begin
-		newt = term.dup
-		newt.c_lflag &= ~Termios::ECHO
-		newt.c_lflag &= ~Termios::ICANON if masked
+		return rval
+	end
 
-		Termios.tcsetattr( $stdin, Termios::TCSANOW, newt )
 
-		rval = yield
-	ensure
-		Termios.tcsetattr( $stdin, Termios::TCSANOW, term )
+	### Prompt the user for her password, turning off echo if the 'termios' module is
+	### available.
+	def prompt_for_password( prompt="Password: " )
+		return noecho( true ) do
+			$stderr.print( prompt )
+			($stdin.gets || '').chomp
+		end
 	end
 
-	return rval
-end
 
+	### Display a description of a potentially-dangerous task, and prompt
+	### for confirmation. If the user answers with anything that begins
+	### with 'y', yield to the block. If +abort_on_decline+ is +true+,
+	### any non-'y' answer will fail with an error message.
+	def ask_for_confirmation( description, abort_on_decline=true )
+		puts description
+
+		answer = prompt_with_default( "Continue?", 'n' ) do |input|
+			input =~ /^[yn]/i
+		end
+
+		if answer =~ /^y/i
+			return yield
+		elsif abort_on_decline
+			error "Aborted."
+			fail
+		end
 
-### Prompt the user for her password, turning off echo if the 'termios' module is
-### available.
-def prompt_for_password( prompt="Password: " )
-	return noecho( true ) do
-		$stderr.print( prompt )
-		($stdin.gets || '').chomp
+		return false
 	end
-end
+	alias :prompt_for_confirmation :ask_for_confirmation
 
 
-### Display a description of a potentially-dangerous task, and prompt
-### for confirmation. If the user answers with anything that begins
-### with 'y', yield to the block. If +abort_on_decline+ is +true+,
-### any non-'y' answer will fail with an error message.
-def ask_for_confirmation( description, abort_on_decline=true )
-	puts description
+	### Search line-by-line in the specified +file+ for the given +regexp+, returning the
+	### first match, or nil if no match was found. If the +regexp+ has any capture groups,
+	### those will be returned in an Array, else the whole matching line is returned.
+	def find_pattern_in_file( regexp, file )
+		rval = nil
 
-	answer = prompt_with_default( "Continue?", 'n' ) do |input|
-		input =~ /^[yn]/i
-	end
+		File.open( file, 'r' ).each do |line|
+			if (( match = regexp.match(line) ))
+				rval = match.captures.empty? ? match[0] : match.captures
+				break
+			end
+		end
 
-	if answer =~ /^y/i
-		return yield
-	elsif abort_on_decline
-		error "Aborted."
-		fail
+		return rval
 	end
 
-	return false
-end
-alias :prompt_for_confirmation :ask_for_confirmation
 
+	### Search line-by-line in the output of the specified +cmd+ for the given +regexp+,
+	### returning the first match, or nil if no match was found. If the +regexp+ has any 
+	### capture groups, those will be returned in an Array, else the whole matching line
+	### is returned.
+	def find_pattern_in_pipe( regexp, *cmd )
+		require 'open3'
+		output = []
 
-### Search line-by-line in the specified +file+ for the given +regexp+, returning the
-### first match, or nil if no match was found. If the +regexp+ has any capture groups,
-### those will be returned in an Array, else the whole matching line is returned.
-def find_pattern_in_file( regexp, file )
-	rval = nil
+		log( cmd.collect {|part| part =~ /\s/ ? part.inspect : part} ) 
+		Open3.popen3( *cmd ) do |stdin, stdout, stderr|
+			stdin.close
 
-	File.open( file, 'r' ).each do |line|
-		if (( match = regexp.match(line) ))
-			rval = match.captures.empty? ? match[0] : match.captures
-			break
+			output << stdout.gets until stdout.eof?
+			output << stderr.gets until stderr.eof?
 		end
-	end
 
-	return rval
-end
+		result = output.find { |line| regexp.match(line) } 
+		return $1 || result
+	end
 
 
-### Search line-by-line in the output of the specified +cmd+ for the given +regexp+,
-### returning the first match, or nil if no match was found. If the +regexp+ has any 
-### capture groups, those will be returned in an Array, else the whole matching line
-### is returned.
-def find_pattern_in_pipe( regexp, *cmd )
-	output = []
+	### Invoke the user's editor on the given +filename+ and return the exit code
+	### from doing so.
+	def edit( filename )
+		editor = ENV['EDITOR'] || ENV['VISUAL'] || DEFAULT_EDITOR
+		system editor, filename
+		unless $?.success? || editor =~ /vim/i
+			fail "Editor exited uncleanly."
+		end
+	end
 
-	log( cmd.collect {|part| part =~ /\s/ ? part.inspect : part} ) 
-	Open3.popen3( *cmd ) do |stdin, stdout, stderr|
-		stdin.close
 
-		output << stdout.gets until stdout.eof?
-		output << stderr.gets until stderr.eof?
+	### Extract all the non Rake-target arguments from ARGV and return them.
+	def get_target_args
+		args = ARGV.reject {|arg| arg =~ /^-/ || Rake::Task.task_defined?(arg) }
+		return args
 	end
 
-	result = output.find { |line| regexp.match(line) } 
-	return $1 || result
-end
 
+	### Log a subdirectory change, execute a block, and exit the subdirectory
+	def in_subdirectory( subdir )
+		block = Proc.new
 
-### Invoke the user's editor on the given +filename+ and return the exit code
-### from doing so.
-def edit( filename )
-	editor = ENV['EDITOR'] || ENV['VISUAL'] || DEFAULT_EDITOR
-	system editor, filename
-	unless $?.success? || editor =~ /vim/i
-		fail "Editor exited uncleanly."
+		log "Entering #{subdir}"
+		Dir.chdir( subdir, &block )
+		log "Leaving #{subdir}"
 	end
-end
 
 
-### Extract all the non Rake-target arguments from ARGV and return them.
-def get_target_args
-	args = ARGV.reject {|arg| arg =~ /^-/ || Rake::Task.task_defined?(arg) }
-	return args
-end
+	### Make an easily-comparable version vector out of +ver+ and return it.
+	def vvec( ver )
+		return ver.split('.').collect {|char| char.to_i }.pack('N*')
+	end
 
 
-### Log a subdirectory change, execute a block, and exit the subdirectory
-def in_subdirectory( subdir )
-	block = Proc.new
+	### Archive::Tar::Reader#extract (as of 0.9.0) is broken w.r.t.
+	### permissions, so we have to do this ourselves.
+	def untar( tarfile, targetdir )
+		require 'archive/tar'
+		targetdir = Pathname( targetdir )
+		raise "No such directory: #{targetdir}" unless targetdir.directory?
 
-	log "Entering #{subdir}"
-	Dir.chdir( subdir, &block )
-	log "Leaving #{subdir}"
-end
+		reader = Archive::Tar::Reader.new( tarfile.to_s, TAR_OPTS )
 
+		mkdir_p( targetdir )
+		reader.each( true ) do |header, body|
+			path = targetdir + header[:path]
+			# trace "Header is: %p" % [ header ]
 
-### Make an easily-comparable version vector out of +ver+ and return it.
-def vvec( ver )
-	return ver.split('.').collect {|char| char.to_i }.pack('N*')
-end
+			case header[:type]
+			when :file
+				trace "  #{path}"
+				path.open( File::WRONLY|File::EXCL|File::CREAT|File::TRUNC, header[:mode] ) do |fio|
+					bytesize = header[:size]
+					fio.write( body[0,bytesize] )
+				end
+
+			when :directory
+				trace "  #{path}"
+				path.mkpath
+
+			when :link
+				linktarget = targetdir + header[:dest]
+				trace "  #{path} => #{linktarget}"
+				path.make_link( linktarget.to_s )
+
+			when :symlink
+				linktarget = targetdir + header[:dest]
+				trace "  #{path} -> #{linktarget}" 
+				path.make_symlink( linktarget )
+			end
+		end
+
+	end
+
+
+	### Extract the contents of the specified +zipfile+ into the given +targetdir+.
+	def unzip( zipfile, targetdir, *files )
+		require 'zip/zip'
+		targetdir = Pathname( targetdir )
+		raise "No such directory: #{targetdir}" unless targetdir.directory?
+
+		Zip::ZipFile.foreach( zipfile ) do |entry|
+			# trace "  entry is: %p" % [ entry ]
+			next unless files.empty? || files.include?( entry.name )
+			target_path = targetdir + entry.name
+			# trace "  would extract to: %s" % [ target_path ]
+			entry.extract( target_path ) { true }
+		end
+	end
 
+end # module Rakefile::Helpers