cond 0.2.1 → 0.3.0

data/CHANGES.rdoc

@@ -0,0 +1,12 @@
+
+= Cond ChangeLog
+
+== Version 0.3.0
+
+* require 'cond/dsl' to get the DSL; no more 'include Cond'
+* internal cleanup
+
+== Version 0.2.1
+
+* initial release
+

data/MANIFEST

@@ -0,0 +1,39 @@
+CHANGES.rdoc
+MANIFEST
+README.rdoc
+Rakefile
+devel/jumpstart.rb
+install.rb
+lib/cond.rb
+lib/cond/code_section.rb
+lib/cond/cond.rb
+lib/cond/defaults.rb
+lib/cond/dsl.rb
+lib/cond/dsl_definition.rb
+lib/cond/error.rb
+lib/cond/handler.rb
+lib/cond/handling_section.rb
+lib/cond/kernel_raise.rb
+lib/cond/message_proc.rb
+lib/cond/restart.rb
+lib/cond/restartable_section.rb
+lib/cond/symbol_generator.rb
+lib/cond/thread_local.rb
+lib/cond/wrapping.rb
+readmes/restarts.rb
+readmes/seibel_pcl.rb
+spec/bad_spec.rb
+spec/basic_spec.rb
+spec/calc_spec.rb
+spec/cond_spec_base.rb
+spec/error_spec.rb
+spec/leave_again_spec.rb
+spec/matching_spec.rb
+spec/raise_spec.rb
+spec/readme_spec.rb
+spec/reraise_spec.rb
+spec/restarts_spec.rb
+spec/seibel_spec.rb
+spec/symbols_spec.rb
+spec/thread_local_spec.rb
+spec/wrapping_spec.rb

data/{README → README.rdoc}

@@ -1,14 +1,13 @@
 
 = Cond
 
-== Description
+== Summary
 
 Resolve errors without unwinding the stack.
 
 == Synopsis
 
-  require 'cond'
-  include Cond
+  require 'cond/dsl'
   
   def divide(x, y)
     restartable do
@@ -36,7 +35,7 @@ Resolve errors without unwinding the stack.
 or
   % ruby install.rb [--uninstall]
 
-== Overview
+== Description
 
 Cond allows errors to be handled near the place where they occur,
 before the stack unwinds.  It offers several advantages over
@@ -84,9 +83,8 @@ propagate in the usual unwinding fashion, as if the handler was never
 called.
 
 Cond is 100% compatible with the built-in exception-handling system.
-We may imagine that Ruby had this handler/restart functionality from
-the very beginning, but everyone had forgotten to write restarts.  And
-since no restarts were available, no handlers were written.
+We may imagine that Ruby had always had this handler+restart
+functionality but nobody remembered to use it.
 
 == Background
 
@@ -105,6 +103,8 @@ http://www.gigamonkeys.com/book/beyond-exception-handling-conditions-and-restart
 See readmes/seibel_pcl.rb for a Ruby translation.
 
 == Synopsis 2.0
+
+  require 'cond/dsl'
   
   x, y = 7, 0
   
@@ -134,14 +134,10 @@ arbitrarily.
 for repetitive catch blocks and prevent symbol collisions for nested
 catch labels.
 
-A default handler is provided which runs a simple choose-a-restart
-input loop when +raise+ is called, as the next example demonstrates.
-
 == Restart Example
 
   require 'pp'
-  require 'cond'
-  include Cond
+  require 'cond/dsl'
   
   class RestartableFetchError < RuntimeError
   end
@@ -228,25 +224,24 @@ Cond has been tested on MRI 1.8.6, 1.8.7, 1.9, and the latest jruby.
 Each thread keeps its own list of handlers, restarts, and other data.
 All operations are fully thread-safe.
 
-It is not required to <tt>include Cond</tt>.  The includable methods
-of +Cond+ are <tt>module_function</tt>s and are thus callable via e.g.
-<tt>Cond.handling</tt>.
-
-+Cond+ nests private modules and classes inside Cond::CondPrivate in
-order to improve the hygiene of <tt>include Cond</tt> and encourage
-its use.
-
 Except for the redefinition +raise+, Cond does not silently modify any
-of the standard classes
+of the standard classes.
 
 The essential implementation is small and simple: it consists of two
 per-thread stacks of hashes (handlers and restarts) with merge-push
-and pop operations.  The syntax shown in the above examples is a thin
-layer concealing the underlying hashes.  It is equivalent to the
-following raw form.  You are free to use either form according to
-preference or circumstance.
+and pop operations.
+
+== DSL Form and Raw Form
+
+The optional <tt>require 'cond/dsl'</tt> defines some pseudo-keywords
+in the global scope which comprise a DSL for the system.  These
+methods are also available with <tt>require 'cond'</tt> through the
+Cond singleton (e.g. Cond.handling) or by including Cond::DSL into the
+class or module which uses them.
 
-=== Raw Form
+The DSL shown in the above examples is a thin layer concealing the
+underlying hashes.  It is equivalent to the following raw form.  You
+are free to use either form according to preference or circumstance.
 
   require 'cond'
   
@@ -276,10 +271,10 @@ preference or circumstance.
     puts divide(7, 0)   # => 42
   end
 
-=== Limitations
+== Limitations
 
 There must be a call to +raise+ inside Ruby code (as opposed to C
-code) for a handler to be invoked.
+code) in order for a handler to be invoked.
 
 The above synopsis gives an example: Why is there a check for division
 by zero when +ZeroDivisionError+ would be raised anyway?  Because

data/Rakefile

@@ -1,59 +1,27 @@
-
-require 'rake'
-require 'spec/rake/spectask'
-require 'rake/gempackagetask'
-require 'rake/contrib/rubyforgepublisher'
-require 'rdoc/rdoc'
-
-require 'fileutils'
-include FileUtils
-
-README = "README"
-PROJECT_NAME = "cond"
-GEMSPEC = eval(File.read("#{PROJECT_NAME}.gemspec"))
-raise unless GEMSPEC.name == PROJECT_NAME
-DOC_DIR = "html"
-
-SPEC_FILES = Dir['spec/*_spec.rb'] + Dir['examples/*_example.rb']
-SPEC_OUTPUT = "spec_output.html"
-
-######################################################################
-# default
-
-task :default => :spec
-
-######################################################################
-# spec
-
-Spec::Rake::SpecTask.new('spec') do |t|
-  t.spec_files = SPEC_FILES
-end
-
-Spec::Rake::SpecTask.new('text_spec') do |t|
-  t.spec_files = SPEC_FILES
-  t.spec_opts = ['-fs']
-end
-
-Spec::Rake::SpecTask.new('full_spec') do |t|
-  t.spec_files = SPEC_FILES
-  t.rcov = true
-  exclude_dirs = %w[readmes support examples spec]
-  t.rcov_opts = exclude_dirs.inject(Array.new) { |acc, dir|
-    acc + ["--exclude", dir]
-  }
-  t.spec_opts = ["-fh:#{SPEC_OUTPUT}"]
-end
-
-task :show_full_spec => :full_spec do
-  args = SPEC_OUTPUT, "coverage/index.html"
-  open_browser(*args)
+$LOAD_PATH.unshift "devel"
+
+require 'jumpstart'
+
+readme_file = nil
+ 
+Jumpstart.new('cond') do |s|
+  s.developer('James M. Lawrence', 'quixoticsycophant@gmail.com')
+  s.rubyforge_user = "quix"
+  s.description_sentences = 2
+  s.rdoc_files = %w[
+    lib/cond/cond.rb
+    lib/cond/dsl_definition.rb
+    lib/cond/error.rb
+    lib/cond/handler.rb
+    lib/cond/message_proc.rb
+    lib/cond/restart.rb
+    lib/cond/wrapping.rb
+  ]
+  readme_file = s.readme_file
 end
 
-######################################################################
-# readme
-
 task :readme do
-  readme = File.read(README)
+  readme = File.read(readme_file)
   restarts = File.read("readmes/restarts.rb")
   run_re = %r!\A\#  !
   update = readme.sub(%r!(= Restart Example\n)(.*?)(?=^Run)!m) {
@@ -64,132 +32,7 @@ task :readme do
     $1 + "\n" +
     restarts.lines.grep(run_re).map { |t| t.sub(run_re, "  ") }.join + "\n"
   }
-  File.open(README, "w") { |f| f.print update }
-end
-
-######################################################################
-# clean
-
-task :clean => [:clobber, :clean_doc] do
-end
-
-task :clean_doc do
-  rm_rf(DOC_DIR)
-  rm_f(SPEC_OUTPUT)
-end
-
-######################################################################
-# package
-
-task :package => :clean
-
-Rake::GemPackageTask.new(GEMSPEC) { |t|
-  t.need_tar = true
-}
-
-######################################################################
-# doc
-
-task :doc => :clean_doc do 
-  files = %W[#{README} lib/cond.rb]
-
-  options = [
-    "-o", DOC_DIR,
-    "--title", "#{GEMSPEC.name}: #{GEMSPEC.summary}",
-    "--main", README
-  ]
-
-  RDoc::RDoc.new.document(files + options)
-end
-
-task :rdoc => :doc
-
-task :show_doc => :doc do
-  open_browser("#{DOC_DIR}/index.html")
-end
-
-######################################################################
-# misc
-
-def open_browser(*files)
-  if Config::CONFIG["host"] =~ %r!darwin!
-    sh("open", "/Applications/Firefox.app", *files)
-  else
-    sh("firefox", *files)
-  end
-end
-
-######################################################################
-# git
-
-def git(*args)
-  sh("git", *args)
-end
-
-######################################################################
-# publisher
-
-task :publish => :doc do
-  Rake::RubyForgePublisher.new(GEMSPEC.name, 'quix').upload
-end
-
-######################################################################
-# release
-
-unless respond_to? :tap
-  module Kernel
-    def tap
-      yield self
-      self
-    end
-  end
-end 
-
-task :prerelease => :clean do
-  rm_rf(DOC_DIR)
-  rm_rf("pkg")
-  unless `git status` =~ %r!nothing to commit \(working directory clean\)!
-    raise "Directory not clean"
-  end
-  unless `ping github.com 2 2` =~ %r!0% packet loss!i
-    raise "No ping for github.com"
-  end
-end
-
-def rubyforge(command, file)
-  sh(
-    "rubyforge",
-    command,
-    GEMSPEC.rubyforge_project,
-    GEMSPEC.rubyforge_project,
-    GEMSPEC.version.to_s,
-    file
-  )
-end
-
-task :finish_release do
-  gem, tgz = %w(gem tgz).map { |ext|
-    "pkg/#{GEMSPEC.name}-#{GEMSPEC.version}.#{ext}"
-  }
-  gem_md5, tgz_md5 = [gem, tgz].map { |file|
-    "#{file}.md5".tap { |md5|
-      sh("md5sum #{file} > #{md5}")
-    }
-  }
-
-  rubyforge("add_release", gem)
-  rubyforge("add_file", gem_md5)
-  rubyforge("add_file", tgz)
-  rubyforge("add_file", tgz_md5)
-
-  git("tag", "#{GEMSPEC.name}-" + GEMSPEC.version.to_s)
-  git(*%w(push --tags origin master))
+  File.open(readme_file, "w") { |f| f.print update }
 end
 
-task :release =>
-  [
-   :prerelease,
-   :package,
-   :publish,
-   :finish_release,
-  ]
+task :prerelease => :readme

data/devel/jumpstart.rb

@@ -0,0 +1,970 @@
+
+class Jumpstart
+  class SimpleInstaller
+    def initialize
+      require 'fileutils'
+      require 'rbconfig'
+      require 'find'
+      dest_root = Config::CONFIG["sitelibdir"]
+      sources = []
+      Find.find("./lib") { |source|
+        if install_file?(source)
+          sources << source
+        end
+      }
+      @spec = sources.inject(Array.new) { |acc, source|
+        if source == "./lib"
+          acc
+        else
+          dest = File.join(dest_root, source.sub(%r!\A\./lib!, ""))
+  
+          install = lambda {
+            if File.directory?(source)
+              unless File.directory?(dest)
+                puts "mkdir #{dest}"
+                FileUtils.mkdir(dest)
+              end
+            else
+              puts "install #{source} --> #{dest}"
+              FileUtils.install(source, dest)
+            end
+          }
+            
+          uninstall = lambda {
+            if File.directory?(source)
+              if File.directory?(dest)
+                puts "rmdir #{dest}"
+                FileUtils.rmdir(dest)
+              end
+            else
+              if File.file?(dest)
+                puts "rm #{dest}"
+                FileUtils.rm(dest)
+              end
+            end
+          }
+  
+          acc << {
+            :source => source,
+            :dest => dest,
+            :install => install,
+            :uninstall => uninstall,
+          }
+        end
+      }
+    end
+  
+    def install_file?(source)
+      File.directory?(source) or
+      (File.file?(source) and File.extname(source) == ".rb")
+    end
+
+    def install
+      @spec.each { |entry|
+        entry[:install].call
+      }
+    end
+  
+    def uninstall
+      @spec.reverse.each { |entry|
+        entry[:uninstall].call
+      }
+    end
+
+    def run(args = ARGV)
+      if args.empty?
+        install
+      elsif args.size == 1 and args.first == "--uninstall"
+        uninstall
+      else
+        raise "unrecognized arguments: #{args.inspect}"
+      end
+    end
+  end
+
+  module AttrLazy
+    def attr_lazy(name, &block)
+      AttrLazy.define_reader(class << self ; self ; end, name, &block)
+    end
+
+    def attr_lazy_accessor(name, &block)
+      attr_lazy(name, &block)
+      AttrLazy.define_writer(class << self ; self ; end, name, &block)
+    end
+
+    class << self
+      def included(mod)
+        (class << mod ; self ; end).class_eval do
+          def attr_lazy(name, &block)
+            AttrLazy.define_reader(self, name, &block)
+          end
+
+          def attr_lazy_accessor(name, &block)
+            attr_lazy(name, &block)
+            AttrLazy.define_writer(self, name, &block)
+          end
+        end
+      end
+
+      def define_evaluated_reader(instance, name, value)
+        (class << instance ; self ; end).class_eval do
+          remove_method name rescue nil
+          define_method name do
+            value
+          end
+        end
+      end
+
+      def define_reader(klass, name, &block)
+        klass.class_eval do
+          remove_method name rescue nil
+          define_method name do
+            value = instance_eval(&block)
+            AttrLazy.define_evaluated_reader(self, name, value)
+            value
+          end
+        end
+      end
+
+      def define_writer(klass, name, &block)
+        klass.class_eval do
+          writer = "#{name}="
+          remove_method writer rescue nil
+          define_method writer do |value|
+            AttrLazy.define_evaluated_reader(self, name, value)
+            value
+          end
+        end
+      end
+    end
+  end
+
+  module Ruby
+    module_function
+
+    def executable
+      require 'rbconfig'
+
+      name = File.join(
+        Config::CONFIG["bindir"],
+        Config::CONFIG["RUBY_INSTALL_NAME"]
+      )
+
+      if Config::CONFIG["host"] =~ %r!(mswin|cygwin|mingw)! and
+          File.basename(name) !~ %r!\.(exe|com|bat|cmd)\Z!i
+        name + Config::CONFIG["EXEEXT"]
+      else
+        name
+      end
+    end
+
+    def run(*args)
+      cmd = [executable, *args]
+      unless system(*cmd)
+        cmd_str = cmd.map { |t| "'#{t}'" }.join(", ")
+        raise "system(#{cmd_str}) failed with status #{$?.exitstatus}"
+      end
+    end
+
+    def run_code_and_capture(code)
+      IO.popen(%{"#{executable}"}, "r+") { |pipe|
+        pipe.print(code)
+        pipe.flush
+        pipe.close_write
+        pipe.read
+      }
+    end
+
+    def run_file_and_capture(file)
+      unless File.file? file
+        raise "file does not exist: `#{file}'"
+      end
+      IO.popen(%{"#{executable}" "#{file}"}, "r") { |pipe|
+        pipe.read
+      }
+    end
+      
+    def with_warnings(value = true)
+      previous = $VERBOSE
+      $VERBOSE = value
+      begin
+        yield
+      ensure
+        $VERBOSE = previous
+      end
+    end
+      
+    def no_warnings(&block)
+      with_warnings(nil, &block)
+    end
+  end
+
+  module Util
+    module_function
+
+    def run_ruby_on_each(*files)
+      files.each { |file|
+        Ruby.run("-w", file)
+      }
+    end
+
+    def to_camel_case(str)
+      str.split('_').map { |t| t.capitalize }.join
+    end
+
+    def write_file(file)
+      contents = yield
+      File.open(file, "wb") { |out|
+        out.print(contents)
+      }
+      contents
+    end
+
+    def replace_file(file)
+      old_contents = File.read(file)
+      new_contents = yield(old_contents)
+      if old_contents != new_contents
+        File.open(file, "wb") { |output|
+          output.print(new_contents)
+        }
+      end
+      new_contents
+    end
+  end
+
+  module InstanceEvalWithArgs
+    module_function
+
+    def with_temp_method(instance, method_name, method_block)
+      (class << instance ; self ; end).class_eval do
+        define_method(method_name, &method_block)
+        begin
+          yield method_name
+        ensure
+          remove_method(method_name)
+        end
+      end
+    end
+
+    def call_temp_method(instance, method_name, *args, &method_block)
+      with_temp_method(instance, method_name, method_block) {
+        instance.send(method_name, *args)
+      }
+    end
+
+    def instance_eval_with_args(instance, *args, &block)
+      call_temp_method(instance, :__temp_method, *args, &block)
+    end
+  end
+
+  include AttrLazy
+  include Util
+
+  def initialize(project_name)
+    $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+    $LOAD_PATH.unshift File.dirname(__FILE__)
+
+    require 'rake/gempackagetask'
+    require 'rake/clean'
+
+    @project_name = project_name
+
+    yield self
+
+    self.class.instance_methods(false).select { |t|
+      t.to_s =~ %r!\Adefine_!
+    }.each { |method_name|
+      send(method_name)
+    }
+  end
+
+  class << self
+    alias_method :attribute, :attr_lazy_accessor
+  end
+
+  attribute :name do
+    @project_name
+  end
+
+  attribute :version_constant_name do
+    "VERSION"
+  end
+
+  attribute :version do
+    require name
+    mod_name = to_camel_case(name)
+    begin
+      mod = Kernel.const_get(mod_name)
+      if mod.constants.include?(version_constant_name)
+        mod.const_get(version_constant_name)
+      else
+        raise
+      end
+    rescue
+      "0.0.0"
+    end
+  end
+  
+  attribute :rubyforge_name do
+    name.gsub('_', '')
+  end
+
+  attribute :rubyforge_user do
+    email.first[%r!^.*(?=@)!]
+  end
+  
+  attribute :readme_file do
+    "README.rdoc"
+  end
+  
+  attribute :history_file do
+    "CHANGES.rdoc"
+  end
+  
+  attribute :doc_dir do
+    "documentation"
+  end
+  
+  attribute :spec_files do
+    Dir["./spec/*_{spec,example}.rb"]
+  end
+  
+  attribute :test_files do
+    (Dir["./test/test_*.rb"] + Dir["./test/*_test.rb"]).uniq
+  end
+  
+  attribute :rcov_dir do
+    "coverage"
+  end
+  
+  attribute :spec_output_dir do
+    "rspec_output"
+  end
+
+  attribute :spec_output_file do
+    "spec.html"
+  end
+
+  attr_lazy :spec_output do
+    "#{spec_output_dir}/#{spec_output_file}"
+  end
+
+  [:gem, :tgz].each { |ext|
+    attribute ext do
+      "pkg/#{name}-#{version}.#{ext}"
+    end
+  }
+
+  attribute :rcov_options do
+    # workaround for the default rspec task
+    Dir["*"].select { |f| File.directory? f }.inject(Array.new) { |acc, dir|
+      if dir == "lib"
+        acc
+      else
+        acc + ["--exclude", dir + "/"]
+      end
+    } + ["--text-report"]
+  end
+
+  attribute :readme_file do
+    "README.rdoc"
+  end
+    
+  attribute :manifest_file do
+    "MANIFEST"
+  end
+
+  attribute :generated_files do
+    []
+  end
+
+  attribute :files do
+    if File.exist?(manifest_file)
+      File.read(manifest_file).split("\n")
+    else
+      `git ls-files`.split("\n") + [manifest_file] + generated_files
+    end
+  end
+
+  attribute :rdoc_files do
+    Dir["lib/**/*.rb"]
+  end
+    
+  attribute :extra_rdoc_files do
+    if File.exist?(readme_file)
+      [readme_file]
+    else
+      []
+    end
+  end
+
+  attribute :rdoc_options do
+    if File.exist?(readme_file)
+      ["--main", readme_file]
+    else
+      []
+    end + [
+     "--title", "#{name}: #{summary}",
+    ] + (files - rdoc_files).inject(Array.new) { |acc, file|
+      acc + ["--exclude", file]
+    }
+  end
+
+  attribute :browser do
+    require 'rbconfig'
+    if Config::CONFIG["host"] =~ %r!darwin!
+      app = %w[Firefox Safari].map { |t|
+        "/Applications/#{t}.app"
+      }.select { |t|
+        File.exist? t
+      }.first
+      if app
+        ["open", app]
+      else
+        raise "need to set `browser'"
+      end
+    else
+      "firefox"
+    end
+  end
+
+  attribute :gemspec do
+    Gem::Specification.new { |g|
+      g.has_rdoc = true
+      %w[
+        name
+        authors
+        email
+        summary
+        version
+        description
+        files
+        extra_rdoc_files
+        rdoc_options
+      ].each { |param|
+        value = send(param) and (
+          g.send("#{param}=", value)
+        )
+      }
+
+      if rubyforge_name
+        g.rubyforge_project = rubyforge_name
+      end
+
+      if url
+        g.homepage = url
+      end
+
+      extra_deps.each { |dep|
+        g.add_dependency(*dep)
+      }
+
+      extra_dev_deps.each { |dep|
+        g.add_development_dependency(*dep)
+      }
+    }
+  end
+
+  attribute :readme_contents do
+    File.read(readme_file) rescue "FIXME: readme_file"
+  end
+  
+  attribute :sections do
+    begin
+      pairs = Hash[*readme_contents.split(%r!^== (\w+).*?$!)[1..-1]].map {
+        |section, contents|
+        [section.downcase, contents.strip]
+      }
+      Hash[*pairs.flatten]
+    rescue
+      nil
+    end
+  end
+
+  attribute :description_section do
+    "description"
+  end
+
+  attribute :summary_section do
+    "summary"
+  end
+
+  attribute :description_sentences do
+    1
+  end
+
+  attribute :summary_sentences do
+    1
+  end
+  
+  [:summary, :description].each { |section|
+    attribute section do
+      begin
+        sections[send("#{section}_section")].
+        gsub("\n", " ").
+        split(%r!\.\s*!m).
+        first(send("#{section}_sentences")).
+        join(".  ") << "."
+      rescue
+        "FIXME: #{section}"
+      end
+    end
+  }
+
+  attribute :url do
+    begin
+      readme_contents.match(%r!^\*.*?(http://\S+)!)[1]
+    rescue
+      "http://#{rubyforge_name}.rubyforge.org"
+    end
+  end
+
+  attribute :extra_deps do
+    []
+  end
+
+  attribute :extra_dev_deps do
+    []
+  end
+
+  attribute :authors do
+    Array.new
+  end
+
+  attribute :email do
+    Array.new
+  end
+
+  def developer(name, email)
+    authors << name
+    self.email << email
+  end
+
+  def dependency(name, version)
+    extra_deps << [name, version]
+  end
+
+  def define_clean
+    task :clean do
+      Rake::Task[:clobber].invoke
+    end
+  end
+
+  def define_package
+    task manifest_file do
+      create_manifest
+    end
+    CLEAN.include manifest_file
+    task :package => :clean
+    Rake::GemPackageTask.new(gemspec) { |t|
+      t.need_tar = true
+    }
+  end
+
+  def define_spec
+    unless spec_files.empty?
+      require 'spec/rake/spectask'
+      
+      desc "run specs"
+      Spec::Rake::SpecTask.new('spec') do |t|
+        t.spec_files = spec_files
+      end
+    
+      desc "run specs with text output"
+      Spec::Rake::SpecTask.new('text_spec') do |t|
+        t.spec_files = spec_files
+        t.spec_opts = ['-fs']
+      end
+  
+      desc "run specs with html output"
+      Spec::Rake::SpecTask.new('full_spec') do |t|
+        t.spec_files = spec_files
+        t.rcov = true
+        t.rcov_opts = rcov_options
+        t.spec_opts = ["-fh:#{spec_output}"]
+      end
+      
+      desc "run full_spec then open browser"
+      task :show_spec => :full_spec do
+        open_browser(spec_output, rcov_dir + "/index.html")
+      end
+
+      desc "run specs individually"
+      task :spec_deps do
+        run_ruby_on_each(*spec_files)
+      end
+
+      task :prerelease => [:spec, :spec_deps]
+      task :default => :spec
+
+      CLEAN.include spec_output_dir
+    end
+  end
+
+  def define_test
+    unless test_files.empty?
+      desc "run tests"
+      task :test do
+        test_files.each { |file|
+          require file
+        }
+      end
+      
+      desc "run tests with rcov"
+      task :full_test do
+        verbose(false) {
+          sh("rcov", "-o", rcov_dir, "--text-report",
+            *(test_files + rcov_options)
+          )
+        }
+      end
+      
+      desc "run full_test then open browser"
+      task :show_test => :full_test do
+        open_browser(rcov_dir + "/index.html")
+      end
+      
+      desc "run tests individually"
+      task :test_deps do
+        run_ruby_on_each(*test_files)
+      end
+      
+      task :prerelease => [:test, :test_deps]
+      task :default => :test
+      
+      CLEAN.include rcov_dir
+    end
+  end
+
+  def define_doc
+    desc "run rdoc"
+    task :doc => :clean_doc do
+      require 'rdoc/rdoc'
+      args = (
+        gemspec.rdoc_options +
+        gemspec.require_paths.clone +
+        gemspec.extra_rdoc_files +
+        ["-o", doc_dir]
+      ).flatten.map { |t| t.to_s }
+      RDoc::RDoc.new.document args
+    end
+    
+    task :clean_doc do
+      # normally rm_rf, but mimic rake/clean output
+      rm_r(doc_dir) rescue nil
+    end
+
+    desc "run rdoc then open browser"
+    task :show_doc => :doc do
+      open_browser(doc_dir + "/index.html")
+    end
+
+    task :rdoc => :doc
+    task :clean => :clean_doc
+  end
+
+  def define_publish
+    desc "upload docs"
+    task :publish => [:clean_doc, :doc] do
+      require 'rake/contrib/sshpublisher'
+      Rake::SshDirPublisher.new(
+        "#{rubyforge_user}@rubyforge.org",
+        "/var/www/gforge-projects/#{rubyforge_name}",
+        doc_dir
+      ).upload
+    end
+  end
+
+  def define_install
+    desc "direct install (no gem)"
+    task :install do
+      SimpleInstaller.new.run([])
+    end
+
+    desc "direct uninstall (no gem)"
+    task :uninstall do
+      SimpleInstaller.new.run(["--uninstall"])
+    end
+  end
+  
+  def define_debug
+    runner = Class.new do
+      def comment_src_dst(on)
+        on ? ["", "#"] : ["#", ""]
+      end
+      
+      def comment_regions(on, contents, start)
+        src, dst = comment_src_dst(on)
+        contents.gsub(%r!^(\s+)#{src}#{start}.*?^\1#{src}(\}|end)!m) { |chunk|
+          indent = $1
+          chunk.gsub(%r!^#{indent}#{src}!, "#{indent}#{dst}")
+        }
+      end
+      
+      def comment_lines(on, contents, start)
+        src, dst = comment_src_dst(on)
+        contents.gsub(%r!^(\s*)#{src}#{start}!) { 
+          $1 + dst + start
+        }
+      end
+
+      def debug_info(enable)
+        require 'find'
+        Find.find("lib", "test") { |path|
+          if path =~ %r!\.rb\Z!
+            replace_file(path) { |contents|
+              result = comment_regions(!enable, contents, "debug")
+              comment_lines(!enable, result, "trace")
+            }
+          end
+        }
+      end
+    end
+    
+    desc "enable debug and trace calls"
+    task :debug_on do
+      runner.new.debug_info(true)
+    end
+    
+    desc "disable debug and trace calls"
+    task :debug_off do
+      runner.new.debug_info(false)
+    end
+  end
+
+  def define_columns
+    desc "check for columns > 80"
+    task :check_columns do
+      Dir["**/*.rb"].each { |file|
+        File.read(file).scan(%r!^.{81}!) { |match|
+          unless match =~ %r!http://!
+            raise "#{file} greater than 80 columns: #{match}"
+          end
+        }
+      }
+    end
+    task :prerelease => :check_columns
+  end
+
+  def define_comments
+    task :comments do
+      file = "comments.txt"
+      write_file(file) {
+        result = Array.new
+        (["Rakefile"] + Dir["**/*.{rb,rake}"]).each { |f|
+          File.read(f).scan(%r!\#[^\{].*$!) { |match|
+            result << match
+          }
+        }
+        result.join("\n")
+      }
+      CLEAN.include file
+    end
+  end
+
+  def define_check_directory
+    task :check_directory do
+      unless `git status` =~ %r!nothing to commit \(working directory clean\)!
+        raise "Directory not clean"
+      end
+    end
+  end
+
+  def define_ping
+    task :ping do
+      require 'rbconfig'
+      %w[github.com rubyforge.org].each { |server|
+        cmd = "ping " + (
+          if Config::CONFIG["host"] =~ %r!darwin!
+            "-c2 #{server}"
+          else
+            "#{server} 2 2"
+          end
+        )
+        unless `#{cmd}` =~ %r!0% packet loss!
+          raise "No ping for #{server}"
+        end
+      }
+    end
+  end
+
+  def define_update_jumpstart
+    url = ENV["RUBY_JUMPSTART"] || "git://github.com/quix/jumpstart.git"
+    task :update_jumpstart do
+      git "clone", url
+      rm_rf "devel/jumpstart"
+      Dir["jumpstart/**/*.rb"].each { |source|
+        dest = source.sub(%r!\Ajumpstart/!, "devel/")
+        dest_dir = File.dirname(dest)
+        mkdir_p(dest_dir) unless File.directory?(dest_dir)
+        cp source, dest
+      }
+      rm_r "jumpstart"
+      git "commit", "devel", "-m", "update jumpstart"
+    end
+  end
+
+  def git(*args)
+    sh("git", *args)
+  end
+
+  def create_manifest
+    write_file(manifest_file) {
+      files.sort.join("\n")
+    }
+  end
+
+  def rubyforge(mode, file, *options)
+    command = ["rubyforge", mode] + options + [
+      rubyforge_name,
+      rubyforge_name,
+      version.to_s,
+      file,
+    ]
+    sh(*command)
+  end
+
+  def define_release
+    task :prerelease => [:clean, :check_directory, :ping, history_file]
+
+    task :finish_release do
+      gem_md5, tgz_md5 = [gem, tgz].map { |file|
+        md5 = "#{file}.md5"
+        sh("md5sum #{file} > #{md5}")
+        md5
+      }
+
+      rubyforge(
+        "add_release", gem, "--release_changes", history_file, "--preformatted"
+      )
+      [gem_md5, tgz, tgz_md5].each { |file|
+        rubyforge("add_file", file)
+      }
+
+      git("tag", "#{name}-" + version.to_s)
+      git(*%w(push --tags origin master))
+    end
+
+    task :release => [:prerelease, :package, :publish, :finish_release]
+  end
+
+  def define_debug_gem
+    task :debug_gem do
+      puts gemspec.to_ruby
+    end
+  end
+  
+  def open_browser(*files)
+    sh(*([browser].flatten + files))
+  end
+
+  class << self
+    include Util
+    include InstanceEvalWithArgs
+
+    # From minitest, part of the Ruby source; by Ryan Davis.
+    def capture_io
+      require 'stringio'
+
+      orig_stdout, orig_stderr         = $stdout, $stderr
+      captured_stdout, captured_stderr = StringIO.new, StringIO.new
+      $stdout, $stderr                 = captured_stdout, captured_stderr
+
+      yield
+
+      return captured_stdout.string, captured_stderr.string
+    ensure
+      $stdout = orig_stdout
+      $stderr = orig_stderr
+    end
+
+    def run_doc_code(code, expected, index, instance, &block)
+      lib = File.expand_path(File.dirname(__FILE__) + "/../lib")
+      header = %{
+        $LOAD_PATH.unshift "#{lib}"
+        require 'rubygems'
+        begin
+      }
+      footer = %{
+        rescue Exception => __jumpstart_exception
+          puts "raises \#{__jumpstart_exception.class}"
+        end
+      }
+      final_code = header + code + footer
+
+      # Sometimes code is required to be inside a file.
+      actual = nil
+      require 'tempfile'
+      Tempfile.open("run-rdoc-code") { |temp_file|
+        temp_file.print(final_code)
+        temp_file.close
+        actual = Ruby.run_file_and_capture(temp_file.path).chomp
+      }
+
+      instance_eval_with_args(instance, expected, actual, index, &block)
+    end
+
+    def run_doc_section(file, section, instance, &block)
+      contents = File.read(file)
+      if section_contents = contents[%r!^=+[ \t]#{section}.*?\n(.*?)^=!m, 1]
+        index = 0
+        section_contents.scan(%r!^(  \S.*?)(?=(^\S|\Z))!m) { |indented, unused|
+          code_sections = indented.split(%r!^  \#\#\#\# output:\s*$!)
+          code, expected = (
+            case code_sections.size
+            when 1
+              [indented, indented.scan(%r!\# => (.*?)\n!).flatten.join("\n")]
+            when 2
+              code_sections
+            else
+              raise "parse error"
+            end
+          )
+          run_doc_code(code, expected, index, instance, &block)
+          index += 1
+        }
+      else
+        raise "couldn't find section `#{section}' of `#{file}'"
+      end
+    end
+
+    def doc_to_spec(file, *sections, &block)
+      jump = self
+      describe file do
+        sections.each { |section|
+          describe "section `#{section}'" do
+            it "should run as claimed" do
+              if block
+                jump.run_doc_section(file, section, self, &block)
+              else
+                jump.run_doc_section(file, section, self) {
+                  |expected, actual, index|
+                  actual.should == expected
+                }
+              end
+            end
+          end
+        }
+      end
+    end
+
+    def doc_to_test(file, *sections, &block)
+      jump = self
+      klass = Class.new Test::Unit::TestCase do
+        sections.each { |section|
+          define_method "test_#{file}_#{section}" do
+            if block
+              jump.run_doc_section(file, section, self, &block)
+            else
+              jump.run_doc_section(file, section, self) {
+                |expected, actual, index|
+                assert_equal expected, actual
+              }
+            end
+          end
+        }
+      end
+      Object.const_set("Test#{file}".gsub(".", ""), klass)
+    end
+  end
+end