bluecloth 2.0.7 → 2.0.9

data/ext/mkdio.c

@@ -24,8 +24,10 @@ new_Document()
     Document *ret = calloc(sizeof(Document), 1);
 
     if ( ret ) {
-	if (( ret->ctx = calloc(sizeof(MMIOT), 1) ))
+	if (( ret->ctx = calloc(sizeof(MMIOT), 1) )) {
+	    ret->magic = VALID_DOCUMENT;
 	    return ret;
+	}
 	free(ret);
     }
     return 0;
@@ -217,14 +219,6 @@ markdown(Document *document, FILE *out, int flags)
 }
 
 
-void
-mkd_basename(Document *document, char *base)
-{
-    if ( document )
-	document->base = base;
-}
-
-
 /* write out a Cstring, mangled into a form suitable for `<a href=` or `<a id=`
  */
 void
@@ -301,3 +295,43 @@ mkd_generateline(char *bfr, int size, FILE *output, int flags)
     ___mkd_freemmiot(&f, 0);
     return 0;
 }
+
+
+/* set the url display callback
+ */
+void
+mkd_e_url(Document *f, mkd_callback_t edit)
+{
+    if ( f )
+	f->cb.e_url = edit;
+}
+
+
+/* set the url options callback
+ */
+void
+mkd_e_flags(Document *f, mkd_callback_t edit)
+{
+    if ( f )
+	f->cb.e_flags = edit;
+}
+
+
+/* set the url display/options deallocator
+ */
+void
+mkd_e_free(Document *f, mkd_free_t dealloc)
+{
+    if ( f )
+	f->cb.e_free = dealloc;
+}
+
+
+/* set the url display/options context data field
+ */
+void
+mkd_e_data(Document *f, void *data)
+{
+    if ( f )
+	f->cb.e_data = data;
+}

data/ext/mkdio.h

@@ -48,6 +48,16 @@ int mkd_generatecss(MMIOT*,FILE*);
 int mkd_generateline(char *, int, FILE*, int);
 #define mkd_text mkd_generateline
 
+/* url generator callbacks
+ */
+typedef char * (*mkd_callback_t)(const char*, const int, void*);
+typedef void   (*mkd_free_t)(char*, void*);
+
+void mkd_e_url(void *, mkd_callback_t);
+void mkd_e_flags(void *, mkd_callback_t);
+void mkd_e_free(void *, mkd_free_t );
+void mkd_e_data(void *, void *);
+
 /* version#.
  */
 extern char markdown_version[];
@@ -64,6 +74,7 @@ extern char markdown_version[];
 #define MKD_NO_EXT	0x0040	/* don't allow pseudo-protocols */
 #define MKD_CDATA	0x0080	/* generate code for xml ![CDATA[...]] */
 #define MKD_NOTABLES	0x0400	/* disallow tables */
+#define MKD_NOSTRIKETHROUGH 0x0800/* forbid ~~strikethrough~~ */
 #define MKD_TOC		0x1000	/* do table-of-contents processing */
 #define MKD_1_COMPAT	0x2000	/* compatability with MarkdownTest_1.0 */
 #define MKD_AUTOLINK	0x4000	/* make http://foo.com link even without <>s */

data/ext/resource.c

@@ -140,7 +140,7 @@ ___mkd_freeLineRange(Line *anchor, Line *stop)
 void
 mkd_cleanup(Document *doc)
 {
-    if ( doc ) {
+    if ( doc && (doc->magic == VALID_DOCUMENT) ) {
 	if ( doc->ctx ) {
 	    ___mkd_freemmiot(doc->ctx, 0);
 	    free(doc->ctx);

data/ext/tags.c

@@ -0,0 +1,110 @@
+/* block-level tags for passing html blocks through the blender
+ */
+#define __WITHOUT_AMALLOC 1
+#include "cstring.h"
+#include "tags.h"
+
+STRING(struct kw) blocktags;
+
+
+/* define a html block tag
+ */
+void
+mkd_define_tag(char *id, int selfclose)
+{
+    struct kw *p = &EXPAND(blocktags);
+
+    p->id = id;
+    p->size = strlen(id);
+    p->selfclose = selfclose;
+}
+
+
+/* case insensitive string sort (for qsort() and bsearch() of block tags)
+ */
+static int
+casort(struct kw *a, struct kw *b)
+{
+    if ( a->size != b->size )
+	return a->size - b->size;
+    return strncasecmp(a->id, b->id, b->size);
+}
+
+
+/* stupid cast to make gcc shut up about the function types being
+ * passed into qsort() and bsearch()
+ */
+typedef int (*stfu)(const void*,const void*);
+
+
+/* sort the list of html block tags for later searching
+ */
+void
+mkd_sort_tags()
+{
+    qsort(T(blocktags), S(blocktags), sizeof(struct kw), (stfu)casort);
+}
+
+
+
+/* look for a token in the html block tag list
+ */
+struct kw*
+mkd_search_tags(char *pat, int len)
+{
+    struct kw key;
+    
+    key.id = pat;
+    key.size = len;
+    
+    return bsearch(&key, T(blocktags), S(blocktags), sizeof key, (stfu)casort);
+}
+
+
+/* load in the standard collection of html tags that markdown supports
+ */
+void
+mkd_prepare_tags()
+{
+
+#define KW(x)	mkd_define_tag(x, 0)
+#define SC(x)	mkd_define_tag(x, 1)
+
+    static int populated = 0;
+
+    if ( populated ) return;
+    populated = 1;
+    
+    KW("STYLE");
+    KW("SCRIPT");
+    KW("ADDRESS");
+    KW("BDO");
+    KW("BLOCKQUOTE");
+    KW("CENTER");
+    KW("DFN");
+    KW("DIV");
+    KW("OBJECT");
+    KW("H1");
+    KW("H2");
+    KW("H3");
+    KW("H4");
+    KW("H5");
+    KW("H6");
+    KW("LISTING");
+    KW("NOBR");
+    KW("UL");
+    KW("P");
+    KW("OL");
+    KW("DL");
+    KW("PLAINTEXT");
+    KW("PRE");
+    KW("TABLE");
+    KW("WBR");
+    KW("XMP");
+    SC("HR");
+    SC("BR");
+    KW("IFRAME");
+    KW("MAP");
+
+    mkd_sort_tags();
+} /* mkd_prepare_tags */

data/ext/tags.h

@@ -0,0 +1,18 @@
+/* block-level tags for passing html blocks through the blender
+ */
+#ifndef _TAGS_D
+#define _TAGS_D
+
+struct kw {
+    char *id;
+    int  size;
+    int  selfclose;
+} ;
+
+
+struct kw* mkd_search_tags(char *, int);
+void mkd_prepare_tags();
+void mkd_sort_tags();
+void mkd_define_tag(char *, int);
+
+#endif

data/lib/bluecloth.rb

@@ -1,5 +1,8 @@
 #!/usr/bin/ruby
 
+require 'pathname'
+require 'rbconfig'
+
 # 
 # Bluecloth is a Ruby implementation of Markdown, a text-to-HTML conversion
 # tool.
@@ -18,7 +21,7 @@
 # 
 # == Version
 #
-#  $Id$
+#  $Id: bluecloth.rb,v 486a5a2a8cd2 2010/09/23 14:15:03 ged $
 # 
 # == License
 # 
@@ -29,7 +32,7 @@
 class BlueCloth
 
 	# Release Version
-	VERSION = '2.0.7'
+	VERSION = '2.0.9'
 
 	# The defaults for all supported options.
 	DEFAULT_OPTIONS = {
@@ -71,18 +74,20 @@ class BlueCloth
 
 		flags = 0
 
-        if   opthash[:remove_links]    then flags |= MKD_NOLINKS;  end
-        if   opthash[:remove_images]   then flags |= MKD_NOIMAGE;  end
-        if ! opthash[:smartypants]     then flags |= MKD_NOPANTS;  end
-        if ! opthash[:pseudoprotocols] then flags |= MKD_NO_EXT;   end
-        if ! opthash[:pandoc_headers]  then flags |= MKD_NOHEADER; end
-        if   opthash[:header_labels]   then flags |= MKD_TOC;      end
-        if   opthash[:mdtest_1_compat] then flags |= MKD_1_COMPAT; end
-        if   opthash[:escape_html]     then flags |= MKD_NOHTML;   end
-        if   opthash[:strict_mode]     then flags |= MKD_STRICT;   end
-        if   opthash[:tagtext_mode]    then flags |= MKD_TAGTEXT;  end
-        if   opthash[:auto_links]      then flags |= MKD_AUTOLINK; end
-        if   opthash[:safe_links]      then flags |= MKD_SAFELINK; end
+        if   opthash[:remove_links]    then flags |= MKD_NOLINKS;         end
+        if   opthash[:remove_images]   then flags |= MKD_NOIMAGE;         end
+        if ! opthash[:smartypants]     then flags |= MKD_NOPANTS;         end
+        if ! opthash[:pseudoprotocols] then flags |= MKD_NO_EXT;          end
+        if ! opthash[:pandoc_headers]  then flags |= MKD_NOHEADER;        end
+        if   opthash[:header_labels]   then flags |= MKD_TOC;             end
+        if   opthash[:mdtest_1_compat] then flags |= MKD_1_COMPAT;        end
+        if   opthash[:escape_html]     then flags |= MKD_NOHTML;          end
+        if   opthash[:strict_mode]     then flags |= MKD_STRICT;          end
+        if   opthash[:tagtext_mode]    then flags |= MKD_TAGTEXT;         end
+        if   opthash[:auto_links]      then flags |= MKD_AUTOLINK;        end
+        if   opthash[:safe_links]      then flags |= MKD_SAFELINK;        end
+        if ! opthash[:tables]          then flags |= MKD_NOTABLES;        end
+        if ! opthash[:strikethrough]   then flags |= MKD_NOSTRIKETHROUGH; end
 
 		return flags
 	end
@@ -93,18 +98,20 @@ class BlueCloth
 		flags = flags.to_i
 
 		opthash = {}
-        if  ( flags & MKD_NOLINKS  ).nonzero? then opthash[:remove_links]    = true; end
-        if  ( flags & MKD_NOIMAGE  ).nonzero? then opthash[:remove_images]   = true; end
-        if !( flags & MKD_NOPANTS  ).nonzero? then opthash[:smartypants]     = true; end
-        if !( flags & MKD_NO_EXT   ).nonzero? then opthash[:pseudoprotocols] = true; end
-        if !( flags & MKD_NOHEADER ).nonzero? then opthash[:pandoc_headers]  = true; end
-        if  ( flags & MKD_TOC      ).nonzero? then opthash[:header_labels]   = true; end
-        if  ( flags & MKD_1_COMPAT ).nonzero? then opthash[:mdtest_1_compat] = true; end
-        if  ( flags & MKD_NOHTML   ).nonzero? then opthash[:escape_html]     = true; end
-        if  ( flags & MKD_STRICT   ).nonzero? then opthash[:strict_mode]     = true; end
-        if  ( flags & MKD_TAGTEXT  ).nonzero? then opthash[:tagtext_mode]    = true; end
-        if  ( flags & MKD_AUTOLINK ).nonzero? then opthash[:auto_links]      = true; end
-        if  ( flags & MKD_SAFELINK ).nonzero? then opthash[:safe_links]      = true; end
+        if  ( flags & MKD_NOLINKS         ).nonzero? then opthash[:remove_links]    = true; end
+        if  ( flags & MKD_NOIMAGE         ).nonzero? then opthash[:remove_images]   = true; end
+        if !( flags & MKD_NOPANTS         ).nonzero? then opthash[:smartypants]     = true; end
+        if !( flags & MKD_NO_EXT          ).nonzero? then opthash[:pseudoprotocols] = true; end
+        if !( flags & MKD_NOHEADER        ).nonzero? then opthash[:pandoc_headers]  = true; end
+        if  ( flags & MKD_TOC             ).nonzero? then opthash[:header_labels]   = true; end
+        if  ( flags & MKD_1_COMPAT        ).nonzero? then opthash[:mdtest_1_compat] = true; end
+        if  ( flags & MKD_NOHTML          ).nonzero? then opthash[:escape_html]     = true; end
+        if  ( flags & MKD_STRICT          ).nonzero? then opthash[:strict_mode]     = true; end
+        if  ( flags & MKD_TAGTEXT         ).nonzero? then opthash[:tagtext_mode]    = true; end
+        if  ( flags & MKD_AUTOLINK        ).nonzero? then opthash[:auto_links]      = true; end
+        if  ( flags & MKD_SAFELINK        ).nonzero? then opthash[:safe_links]      = true; end
+        if !( flags & MKD_NOTABLES        ).nonzero? then opthash[:tables]          = true; end
+        if !( flags & MKD_NOSTRIKETHROUGH ).nonzero? then opthash[:strikethrough]   = true; end
 
 		return opthash
 	end

data/rake/documentation.rb

@@ -0,0 +1,115 @@
+# 
+# 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
+
+	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)
+				$stderr.puts "Adding comment: %p" % [ comment ]
+				visit_ns_token(:comment, comment)
+
+				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,417 +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 )
-	return nil unless ENV['PATH']
-	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