rubys-gorp 0.1.1

data/Manifest

@@ -0,0 +1,7 @@
+README
+Rakefile
+Manifest
+gorp.gemspec
+lib/version.rb
+lib/gorp.rb
+lib/gorp/test.rb

data/README

@@ -0,0 +1,41 @@
+Running this should only require Rails 2.2.2 or later, and the command line
+interfaces for sqlite3 and curl.  Tested on Ubuntu Linux 9.04 ("Jaunty
+Jackalope") and Mac OSX 10.5.6 ("Leopard").
+
+Installation of all necessary dependencies from a fresh install of Ubuntu 9.04:
+
+  sudo apt-get install rails git-core sqlite3 curl
+  sudo gem install rubygems-update
+  sudo /var/lib/gems/1.8/bin/update_rubygems
+  sudo gem install rails
+  sudo gem sources -a http://gems.github.com
+  sudo gem install rubys-gorp
+
+Execution instructions:
+
+  This is a library which, among other things, will interpret ARGV.  Here's
+  an example based on http://github.com/rubys/awdwr:
+
+  ruby makedepot.rb [VERSION] [restore] [RANGE]... [save]
+
+    "restore" - restore from snapshot before resuming execution
+
+    "VERSION" specifies the Rails version to test.  Examples:
+      edge
+      _2.2.2_
+      ~/git
+
+    "RANGE" specifies a set of sections to execute.  Examples:
+      6.2..6.5
+      7.1-9.5
+      16
+
+    "save" - save snapshot after execution completes
+
+Tests against the output produced (e.g., makedepot.html) can also be run
+separately:
+
+  ruby checkdepot.rb [partial]
+
+  "partial" means that tests which cover sections that are not included in
+    makedepot.html are to be omitted.

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+require File.expand_path(File.dirname(__FILE__) + "/lib/version")
+
+Echoe.new('gorp', Gorp::VERSION::STRING) do |p|
+  p.summary    = "Rails scenario testing support library"
+  p.description    = <<-EOF
+    Enables the creation of scenarios that involve creating a rails project,
+    starting and stoppping of servers, generating projects, editing files,
+    issuing http requests, running of commands, etc.  Output is captured as
+    a single HTML file that can be viewed locally or uploaded.
+
+    Additionally, there is support for verification, in the form of defining
+    assertions based on selections (typically CSS) against the generated HTML.
+  EOF
+  p.url            = "http://github.com/rubys/gorp"
+  p.author         = "Sam Ruby"
+  p.email          = "rubys@intertwingly.net"
+  p.dependencies   = %w(builder rack rack-test rake sqlite3-ruby tzinfo)
+end

data/gorp.gemspec

@@ -0,0 +1,55 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{gorp}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Sam Ruby"]
+  s.date = %q{2009-09-17}
+  s.description = %q{    Enables the creation of scenarios that involve creating a rails project,
+    starting and stoppping of servers, generating projects, editing files,
+    issuing http requests, running of commands, etc.  Output is captured as
+    a single HTML file that can be viewed locally or uploaded.
+
+    Additionally, there is support for verification, in the form of defining
+    assertions based on selections (typically CSS) against the generated HTML.
+}
+  s.email = %q{rubys@intertwingly.net}
+  s.extra_rdoc_files = ["README", "lib/version.rb", "lib/gorp.rb", "lib/gorp/test.rb"]
+  s.files = ["README", "Rakefile", "Manifest", "gorp.gemspec", "lib/version.rb", "lib/gorp.rb", "lib/gorp/test.rb"]
+  s.homepage = %q{http://github.com/rubys/gorp}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Gorp", "--main", "README"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{gorp}
+  s.rubygems_version = %q{1.3.3}
+  s.summary = %q{Rails scenario testing support library}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<builder>, [">= 0"])
+      s.add_runtime_dependency(%q<rack>, [">= 0"])
+      s.add_runtime_dependency(%q<rack-test>, [">= 0"])
+      s.add_runtime_dependency(%q<rake>, [">= 0"])
+      s.add_runtime_dependency(%q<sqlite3-ruby>, [">= 0"])
+      s.add_runtime_dependency(%q<tzinfo>, [">= 0"])
+    else
+      s.add_dependency(%q<builder>, [">= 0"])
+      s.add_dependency(%q<rack>, [">= 0"])
+      s.add_dependency(%q<rack-test>, [">= 0"])
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<sqlite3-ruby>, [">= 0"])
+      s.add_dependency(%q<tzinfo>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<builder>, [">= 0"])
+    s.add_dependency(%q<rack>, [">= 0"])
+    s.add_dependency(%q<rack-test>, [">= 0"])
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<sqlite3-ruby>, [">= 0"])
+    s.add_dependency(%q<tzinfo>, [">= 0"])
+  end
+end

data/lib/gorp/test.rb

@@ -0,0 +1,162 @@
+require 'test/unit'
+require 'builder'
+
+begin
+  # installed Rails (2.3.3 ish)
+  require 'active_support'
+  $:.unshift 'work/depot/vendor/rails/activesupport/lib'
+  require 'active_support/version'
+  $:.shift
+rescue LoadError
+  # testing Rails (3.0 ish)
+  $:.unshift 'work/depot/vendor/rails/activesupport/lib'
+  require 'active_support'
+  require 'active_support/version'
+end
+
+require 'active_support/test_case'
+
+module Book
+end
+
+class Book::TestCase < ActiveSupport::TestCase
+  # just enough infrastructure to get 'assert_select' to work
+  begin
+    # installed Rails (2.3.3 ish)
+    require 'action_controller'
+    require 'action_controller/assertions/selector_assertions'
+    include ActionController::Assertions::SelectorAssertions
+  rescue LoadError
+    # testing Rails (3.0 ish)
+    $:.unshift 'work/depot/vendor/rails/actionpack/lib'
+    require 'action_controller'
+    require 'action_dispatch/testing/assertions'
+    require 'action_dispatch/testing/assertions/selector'
+    include ActionDispatch::Assertions::SelectorAssertions
+    $:.shift
+  end
+
+  # micro DSL allowing the definition of optional tests
+  def self.section number, title, &tests
+    number = (sprintf "%f", number).sub(/0+$/,'') if number.kind_of? Float
+    return if ARGV.include? 'partial' and !@@sections.has_key? number.to_s
+    test "#{number} #{title}" do
+      instance_eval {select number}
+      instance_eval &tests
+    end
+  end
+
+  # read and pre-process $input.html (only done once, and cached)
+  def self.input filename
+    # read $input output; remove front matter and footer
+    input = open("#{filename}.html").read
+    head, body, tail = input.split /<body>\s+|\s+<\/body>/m
+
+    # split into sections
+    @@sections = body.split(/<a class="toc" name="section-(.*?)">/)
+
+    # convert to a Hash
+    @@sections = Hash[*@@sections.unshift(:contents)]
+    @@sections[:head] = head
+    @@sections[:tail] = tail
+
+    # reattach anchors
+    @@sections.each do |key,value|
+      next unless key =~ /^\d/
+      @@sections[key] = "<a class=\"toc\" name=\"section-#{key}\">#{value}"
+    end
+
+    # report version
+    body =~ /rails .*?-v<\/pre>\s+.*?>(.*)<\/pre>/
+    @@version = $1
+    @@version += ' (git)' if body =~ /ln -s.*vendor.rails/
+    @@version += ' (edge)' if body =~ /rails:freeze:edge/
+    STDERR.puts @@version
+  end
+
+  def self.output filename
+    $output = filename
+    at_exit { HTMLRunner.run(self) }
+  end
+
+  # select an individual section from the HTML
+  def select number
+    raise "Section #{number} not found" unless @@sections.has_key? number.to_s
+    @selected = HTML::Document.new(@@sections[number.to_s]).root.children
+    assert @@sections[number.to_s] !~
+      /<pre class="traceback">\s+#&lt;IndexError: regexp not matched&gt;/,
+      "edit failed"
+  end
+
+  def collect_stdout
+    css_select('.stdout').map do |tag|
+      tag.children.join.gsub('&lt;','<').gsub('&gt;','>')
+    end
+  end
+
+  def sort_hash line
+    line.sub(/^(=> )?\{.*\}$/) do |match|
+      "#{$1}{#{match.scan(/:?"?\w+"?=>[^\[].*?(?=, |\})/).sort.join(', ')}}"
+    end
+  end
+
+  def self.sections
+    @@sections
+  end
+end
+
+# insert failure indicators into #{output}.html
+require 'test/unit/ui/console/testrunner'
+class HTMLRunner < Test::Unit::UI::Console::TestRunner
+  def self.run suite
+    @@sections = suite.sections
+    super
+  end
+
+  def attach_to_mediator
+    super
+    @html_tests = []
+    @mediator.add_listener(Test::Unit::TestResult::FAULT,
+      &method(:html_fault))
+    @mediator.add_listener(Test::Unit::UI::TestRunnerMediator::FINISHED,
+      &method(:html_summary))
+  end
+
+  def html_fault fault
+    if fault.test_name =~ /^test_([\d.]+)_.*\(\w+\)$/
+      name = $1
+      sections = @@sections
+      return unless sections.has_key? name
+
+      # indicate failure in the toc
+      sections[:contents][/<a href="#section-#{name}"()>/,1] = 
+        ' style="color:red; font-weight:bold"'
+
+      # provide details in the section itself
+      x = Builder::XmlMarkup.new(:indent => 2)
+      if fault.respond_to? :location
+        x.pre fault.message.sub(".\n<false> is not true",'') +
+          "\n\nTraceback:\n  " + fault.location.join("\n  "),
+          :class=>'traceback'
+      else
+        x.pre fault.message, :class=>'traceback'
+      end
+      sections[name][/<\/a>()/,1] = x.target!
+    end
+  end
+
+  def html_summary elapsed
+    open("#{$output}.html",'w') do |output|
+      sections = @@sections
+      output.write(sections.delete(:head))
+      output.write("<body>\n    ")
+      output.write(sections.delete(:contents))
+      tail = sections.delete(:tail)
+      sections.keys.sort_by {|key| key.split('.').map {|n| n.to_i}}.each do |n|
+        output.write(sections[n])
+      end
+      output.write("\n  </body>")
+      output.write(tail)
+    end
+  end
+end

data/lib/gorp.rb

@@ -0,0 +1,642 @@
+# The following is under the "I ain't too proud" school of programming.
+# global variables, repetition, and brute force abounds.
+#
+# You have been warned.
+
+require 'fileutils'
+require 'open3'
+require 'net/http'
+require 'builder'
+require 'stringio'
+
+require 'rbconfig'
+$ruby = File.join(Config::CONFIG["bindir"], Config::CONFIG["RUBY_INSTALL_NAME"])
+
+# Micro DSL for declaring an ordered set of book sections
+$sections = []
+def section number, title, &steps
+  number = (sprintf "%f", number).sub(/0+$/,'') if number.kind_of? Float
+  $sections << [number, title, steps]
+end
+
+# verify that port is available for testing
+if (Net::HTTP.get_response('localhost','/',3000).code == '200' rescue false)
+  STDERR.puts 'local server already running on port 3000'
+  exit
+end
+
+$BASE=File.expand_path(File.dirname(caller.last.split(':').first)) unless $BASE
+$WORK = File.join($BASE,'work')
+$DATA = File.join($BASE,'data')
+$CODE = File.join($DATA,'code')
+$x = Builder::XmlMarkup.new(:indent => 2)
+$toc = Builder::XmlMarkup.new(:indent => 2)
+$style = Builder::XmlMarkup.new(:indent => 2)
+
+FileUtils.mkdir_p $WORK
+
+class String
+  def unindent(n)
+    gsub Regexp.new("^#{' '*n}"), ''
+  end
+end
+
+def read name
+  open(File.join($DATA, name)) {|file| file.read}
+end
+
+def overview message
+  $x.p message.gsub(/(^|\n)\s+/, ' ').strip, :class=>'overview'
+end
+
+def desc message
+  $x.p message, :class=>'desc'
+end
+
+def log type, message
+  type = type.to_s.ljust(5).upcase
+  STDOUT.puts Time.now.strftime("[%Y-%m-%d %H:%M:%S] #{type} #{message}")
+end
+
+def head number, title
+  text = "#{number} #{title}"
+  log '====>', text
+
+  $x.a(:class => 'toc', :name => "section-#{number}") {$x.h2 text}
+  $toc.li {$toc.a text, :href => "#section-#{number}"}
+end
+
+def db statement, hilight=[]
+  log :db, statement
+  $x.pre "sqlite3> #{statement}", :class=>'stdin'
+  cmd = "sqlite3 --line db/development.sqlite3 #{statement.inspect}"
+  popen3 cmd, hilight
+end
+
+def ruby args
+  cmd "ruby #{args}"
+end
+
+def console script
+  cmd "echo #{script.inspect} | ruby script/console '--irb=irb -f'"
+end
+
+def cmd args, hilight=[]
+  log :cmd, args
+  $x.pre args, :class=>'stdin'
+  if args == 'rake db:migrate'
+    Dir.chdir 'db/migrate' do
+      date = '20080601000000'
+      Dir['[0-9]*'].sort_by {|file| file=~/2008/?file:'x'+file}.each do |file|
+        file =~ /^([0-9]*)_(.*)$/
+        FileUtils.mv file, "#{date}_#{$2}" unless $1 == date.next!
+        $x.pre "mv #{file} #{date}_#{$2}"  unless $1 == date
+      end
+    end
+  end
+  popen3 args, hilight
+end
+
+def popen3 args, hilight=[]
+  Open3.popen3(args) do |pin, pout, perr|
+    terr = Thread.new do
+      $x.pre perr.readline.chomp, :class=>'stderr' until perr.eof?
+    end
+    pin.close
+    until pout.eof?
+      line = pout.readline
+      if hilight.any? {|pattern| line.include? pattern}
+        outclass='hilight'
+      elsif line =~ /\x1b\[\d/
+        line.gsub! /\x1b\[1m\x1b\[3\dm(.*?)\x1b\[0m/, '\1'
+        outclass = 'logger'
+      else
+        outclass='stdout'
+      end
+
+      if line.strip.size == 0
+        $x.pre ' ', :class=>outclass
+      else
+        $x.pre line.chomp, :class=>outclass
+      end
+    end
+    terr.join
+  end
+end
+
+def irb file
+  $x.pre "irb #{file}", :class=>'stdin'
+  log :irb, file
+  cmd = "irb -f -rubygems -r config/boot --prompt-mode simple #{$CODE}/#{file}"
+  Open3.popen3(cmd) do |pin, pout, perr|
+    terr = Thread.new do
+      $x.pre perr.readline.chomp, :class=>'stderr' until perr.eof?
+    end
+    pin.close
+    prompt = nil
+    until pout.eof?
+      line = pout.readline
+      if line =~ /^([?>]>)\s*#\s*(START|END):/
+        prompt = $1
+      elsif line =~ /^([?>]>)\s+$/
+        $x.pre ' ', :class=>'irb'
+        prompt ||= $1
+      elsif line =~ /^([?>]>)(.*)\n/
+        prompt ||= $1
+        $x.pre prompt + $2, :class=>'irb'
+	prompt = nil
+      elsif line =~ /^\w+(::\w+)*: /
+        $x.pre line.chomp, :class=>'stderr'
+      elsif line =~ /^\s+from [\/.:].*:\d+:in `\w.*'\s*$/
+        $x.pre line.chomp, :class=>'stderr'
+      elsif line =~ /\x1b\[\d/
+        line.gsub! /\x1b\[4(;\d+)*m(.*?)\x1b\[0m/, '\2'
+        line.gsub! /\x1b\[0(;\d+)*m(.*?)\x1b\[0m/, '\2'
+        $x.pre line.chomp, :class=>'logger'
+      else
+        $x.pre line.chomp, :class=>'stdout'
+      end
+    end
+    terr.join
+  end
+end
+
+def edit filename, tag=nil
+  log :edit, filename
+  $x.pre "edit #{filename}", :class=>'stdin'
+
+  stale = File.mtime(filename) rescue Time.now-2
+  data = open(filename) {|file| file.read} rescue ''
+  before = data.split("\n")
+
+  begin
+    yield data
+    open(filename,'w') {|file| file.write data}
+    File.utime(stale+2, stale+2, filename) if File.mtime(filename) <= stale
+
+  rescue Exception => e
+    $x.pre :class => 'traceback' do
+      STDERR.puts e.inspect
+      $x.text! "#{e.inspect}\n"
+      e.backtrace.each {|line| $x.text! "  #{line}\n"}
+    end
+    tag = nil
+
+  ensure
+    include = tag.nil?
+    hilight = false
+    data.split("\n").each do |line|
+      if line =~ /START:(\w+)/
+        include = true if $1 == tag
+      elsif line =~ /END:(\w+)/
+        include = false if $1 == tag
+      elsif line =~ /START_HIGHLIGHT/
+        hilight = true
+      elsif line =~ /END_HIGHLIGHT/
+        hilight = false
+      elsif include
+        if hilight or ! before.include?(line)
+          outclass='hilight'
+        else
+          outclass='stdout'
+        end
+
+        if line.empty?
+          $x.pre ' ', :class=>outclass
+        else
+          $x.pre line, :class=>outclass
+        end
+      end
+    end
+  end
+end
+
+# pluggable XML parser support
+begin
+  raise LoadError if ARGV.include? 'rexml'
+  require 'nokogiri'
+  def xhtmlparse(text)
+    Nokogiri::HTML(text)
+  end
+  Comment=Nokogiri::XML::Comment
+rescue LoadError
+  require 'rexml/document'
+
+  def xhtmlparse(text)
+    REXML::Document.new(text)
+  end
+
+  class REXML::Element
+    def has_attribute? name
+      self.attributes.has_key? name
+    end
+
+    def at xpath
+      self.elements[xpath]
+    end
+
+    def search xpath
+      self.elements.to_a(xpath)
+    end
+
+    def content=(string)
+      self.text=string
+    end
+
+    def [](index)
+      if index.instance_of? String
+        self.attributes[index]
+      else
+        super(index)
+      end
+    end
+
+    def []=(index, value)
+      if index.instance_of? String
+        self.attributes[index] = value
+      else
+        super(index, value)
+      end
+    end
+  end
+
+  module REXML::Node
+    def before(node)
+      self.parent.insert_before(self, node)
+    end
+
+    def add_previous_sibling(node)
+      self.parent.insert_before(self, node)
+    end
+
+    def serialize
+      self.to_s
+    end
+  end
+
+  # monkey patch for Ruby 1.8.6
+  doc = REXML::Document.new '<doc xmlns="ns"><item name="foo"/></doc>'
+  if not doc.root.elements["item[@name='foo']"]
+    class REXML::Element
+      def attribute( name, namespace=nil )
+        prefix = nil
+        prefix = namespaces.index(namespace) if namespace
+        prefix = nil if prefix == 'xmlns'
+        attributes.get_attribute( "#{prefix ? prefix + ':' : ''}#{name}" )
+      end
+    end
+  end
+
+  Comment = REXML::Comment
+end
+
+def snap response, form={}
+  if response.content_type == 'text/plain' or response.content_type =~ /xml/
+    $x.div :class => 'body' do
+      response.body.split("\n").each do |line| 
+        $x.pre line.chomp, :class=>'stdout'
+      end
+    end
+    return
+  end
+
+  if response.body =~ /<body/
+    body = response.body
+  else
+    body = "<body>#{response.body}</body>"
+  end
+
+  begin
+    doc = xhtmlparse(body)
+  rescue
+    body.split("\n").each {|line| $x.pre line.chomp, :class=>'hilight'}
+    raise
+  end
+
+  title = doc.at('html/head/title').text rescue ''
+  body = doc.at('//body')
+  doc.search('//link[@rel="stylesheet"]').each do |sheet|
+    body.children.first.add_previous_sibling(sheet)
+  end
+
+  if ! form.empty?
+    body.search('//input[@name]').each do |input|
+      input['value'] ||= form[input['name']].to_s
+    end
+    body.search('//textarea[@name]').each do |textarea|
+      textarea.text ||= form[textarea['name']].to_s
+    end
+  end
+
+  %w{ a[@href] form[@action] }.each do |xpath|
+    name = xpath[/@(\w+)/,1]
+    body.search("//#{xpath}").each do |element|
+      next if element[name] =~ /^http:\/\//
+      element[name] = URI.join('http://localhost:3000/', element[name]).to_s
+    end
+  end
+
+  %w{ img[@src] }.each do |xpath|
+    name = xpath[/@(\w+)/,1]
+    body.search("//#{xpath}").each do |element|
+      if element[name][0] == ?/
+        element[name] = 'data' + element[name]
+      end
+    end
+  end
+
+  body.search('//textarea').each do |element|
+    element.content=''
+  end
+
+  attrs = {:class => 'body', :title => title}
+  attrs[:class] = 'traceback' if response.code == '500'
+  attrs[:id] = body['id'] if body['id']
+  $x.div(attrs) do
+    body.children.each do |child|
+      $x << child.serialize unless child.instance_of?(Comment)
+    end
+  end
+  $x.div :style => "clear: both"
+end
+
+def get path
+  post path, {}
+end
+
+def post path, form
+  $x.pre "get #{path}", :class=>'stdin'
+
+  if path.include? ':'
+    host, port, path = URI.parse(path).select(:host, :port, :path)
+  else
+    host, port = '127.0.0.1', 3000
+  end
+
+  Net::HTTP.start(host, port) do |http|
+    get = Net::HTTP::Get.new(path)
+    get['Cookie'] = $COOKIE if $COOKIE
+    response = http.request(get)
+    snap response, form
+    $COOKIE = response.response['set-cookie'] if response.response['set-cookie']
+
+    if ! form.empty?
+      body = xhtmlparse(response.body).at('//body')
+      body = xhtmlparse(response.body).root unless body
+      xform = body.at('//form[.//input[@name="commit"]]')
+      return unless xform
+      path = xform.attribute('action').to_s unless
+        xform.attribute('action').to_s.empty?
+      $x.pre "post #{path}", :class=>'stdin'
+
+      $x.ul do
+        form.each do |name, value|
+          $x.li "#{name} => #{value}"
+        end
+      end
+
+      body.search('//input[@type="hidden"]').each do |element|
+        form[element['name']] ||= element['value']
+      end
+
+      post = Net::HTTP::Post.new(path)
+      post.form_data = form
+      post['Cookie'] = $COOKIE
+      response=http.request(post)
+      snap response
+    end
+
+    if response.code == '302'
+      path = response['Location']
+      $x.pre "get #{path}", :class=>'stdin'
+      get = Net::HTTP::Get.new(path)
+      get['Cookie'] = $COOKIE if $COOKIE
+      response = http.request(get)
+      snap response
+    end
+  end
+end
+
+# select a version of Rails
+if ARGV.first =~ /^_\d[.\d]*_$/
+  $rails = "rails #{ARGV.first}"
+elsif File.directory?(ARGV.first.to_s)
+  $rails = ARGV.first
+  $rails = File.join($rails,'rails') if
+    File.directory?(File.join($rails,'rails'))
+  $rails = File.expand_path($rails)
+else
+  $rails = 'rails'
+end
+
+def which_rails rails
+  railties = File.join(rails, 'railties', 'bin', 'rails')
+  rails = railties if File.exists?(railties)
+  if File.exists?(rails)
+    firstline = open(rails) {|file| file.readlines.first}
+    rails = 'ruby ' + rails unless firstline =~ /^#!/
+  end
+  rails
+end
+
+def rails name, app=nil
+  Dir.chdir($WORK)
+  FileUtils.rm_rf name
+  log :rails, name
+
+  # determine how to invoke rails
+  rails = which_rails $rails
+
+  $x.pre "#{rails} #{name}", :class=>'stdin'
+  popen3 "#{rails} #{name}"
+
+  # make paths seem Mac OSX'ish
+  Dir["#{name}/public/dispatch.*"].each do |dispatch|
+    code = open(dispatch) {|file| file.read}
+    code.sub! /^#!.*/, '#!/opt/local/bin/ruby'
+    open(dispatch,'w') {|file| file.write code}
+  end
+
+  Dir.chdir(name)
+  FileUtils.rm_rf 'public/.htaccess'
+
+  cmd 'rake rails:freeze:edge' if ARGV.include? 'edge'
+
+  if $rails != 'rails' and File.directory?($rails)
+    cmd "ln -s #{$rails} vendor/rails"
+  end
+end
+
+def restart_server
+  log :server, 'restart'
+  if $server
+    $x.h3 'Restart the server.'
+    Process.kill "INT", $server
+    Process.wait($server)
+  else
+    $x.h3 'Start the server.'
+  end
+
+  $server = fork
+  if $server
+    # wait for server to start
+    60.times do
+      sleep 0.5
+      begin
+        status = Net::HTTP.get_response('localhost','/',3000).code
+        break if %(200 404).include? status
+      rescue Errno::ECONNREFUSED
+      end
+    end
+  else
+    begin
+      if File.exist?('config.ru')
+        require 'rack'
+        server = Rack::Builder.new {eval open('config.ru').read}
+        Rack::Handler::WEBrick.run(server, :Port => 3000)
+      else
+        # start server, redirecting stdout to a string
+        $stdout = StringIO.open('','w')
+        require './config/boot'
+        require 'commands/server'
+      end
+    rescue 
+      STDERR.puts $!
+      $!.backtrace.each {|method| STDERR.puts "\tfrom " + method}
+    ensure
+      Process.exit!
+    end
+  end
+end
+
+def secsplit section
+  section.to_s.split('.').map {|n| n.to_i}
+end
+
+at_exit do
+  $x.html :xmlns => 'http://www.w3.org/1999/xhtml' do
+    $x.header do
+      $x.title $title
+      $x.meta 'http-equiv'=>'text/html; charset=UTF-8'
+      $x.style :type => "text/css" do
+        $x.text! <<-'EOF'.unindent(2)
+          body {background-color: #F5F5DC}
+          pre {font-weight: bold; margin: 0; padding: 0}
+          pre.stdin {color: #800080; margin-top: 1em; padding: 0}
+          pre.irb {color: #800080; padding: 0}
+          pre.stdout {color: #000; padding: 0}
+          pre.logger {color: #088; padding: 0}
+          pre.hilight {color: #000; background-color: #FF0; padding: 0}
+          pre.stderr {color: #F00; padding: 0}
+          div.body {border-style: solid; border-color: #800080; padding: 0.5em}
+          .traceback {background:#FDD; border: 4px solid #F00; 
+                      font-weight: bold; margin-top: 1em; padding: 0.5em}
+          ul.toc {list-style: none}
+          ul a {text-decoration: none}
+          ul a:hover {text-decoration: underline; color: #000;
+                      background-color: #F5F5DC}
+          ul a:visited {color: #000}
+	  h2 {clear: both}
+          p.desc {font-style: italic}
+          p.overview {border-width: 2px; border-color: #000;
+            border-style: solid; border-radius: 4em;
+            background-color: #CCF; margin: 1.5em 1.5em; padding: 1em 2em; 
+            -webkit-border-radius: 4em; -moz-border-radius: 4em;}
+        EOF
+      end
+    end
+  
+    $x.body do
+      $x.h1 $title
+      $x.h2 'Table of Contents'
+      $x.ul :class => 'toc'
+  
+      $x.h2 'Development Log'
+      cmd which_rails($rails) + ' -v'
+  
+      cmd "#{$ruby} -v"
+      cmd 'gem -v'
+    
+      e = nil
+  
+      # determine which range(s) of steps are to be executed
+      ranges = ARGV.grep(/^ \d+(.\d+)? ( (-|\.\.) \d+(.\d+)? )? /x).map do |arg|
+        bounds = arg.split(/-|\.\./)
+        Range.new(secsplit(bounds.first), secsplit(bounds.last))
+      end
+      ARGV.push 'partial' unless ranges.empty?
+  
+      # optionally save a snapshot
+      if ARGV.include? 'restore'
+        log :snap, 'restore'
+        Dir.chdir $BASE
+        FileUtils.rm_rf "work"
+        FileUtils.cp_r "snapshot", "work", :preserve => true
+        Dir.chdir $WORK
+        if $autorestart and File.directory? $autorestart
+          Dir.chdir $autorestart
+          restart_server
+        end
+      end
+  
+      # run steps
+      begin
+        $sections.each do |section, title, steps|
+	  next if !ranges.empty? and 
+                  !ranges.any? {|range| range.include?(secsplit(section))}
+	  head section, title
+	  steps.call
+        end
+      rescue Exception => e
+        $x.pre :class => 'traceback' do
+	  STDERR.puts e.inspect
+	  $x.text! "#{e.inspect}\n"
+	  e.backtrace.each {|line| $x.text! "  #{line}\n"}
+        end
+      ensure
+        if e.class != SystemExit
+	  $cleanup.call if $cleanup
+  
+          # terminate server
+	  Process.kill "INT", $server if $server
+	  Process.wait($server) if $server
+  
+          # optionally save a snapshot
+          if ARGV.include? 'save'
+            log :snap, 'save'
+            Dir.chdir $BASE
+            FileUtils.rm_rf "snapshot"
+            FileUtils.cp_r "work", "snapshot", :preserve => true
+          end
+        end
+      end
+    end
+  end
+  
+  # output results as HTML, after inserting style and toc information
+  $x.target![/<style.*?>()/,1] = "\n#{$style.target!.strip.gsub(/^/,' '*6)}\n"
+  $x.target!.sub! /<ul(.*?)\/>/,
+    "<ul\\1>\n#{$toc.target!.gsub(/^/,' '*6)}    </ul>"
+  $x.target!.gsub! '<strong/>', '<strong></strong>'
+  log :WRITE, "#{$output}.html"
+  open("#{$BASE}/#{$output}.html",'w') do |file| 
+    file.write <<-EOF.unindent(4)
+      <!DOCTYPE html
+      PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+      "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+    EOF
+    file.write $x.target!
+  end
+  
+  # run tests
+  if $checker
+    log :CHECK, "#{$output}.html"
+    Dir.chdir $BASE
+    STDOUT.puts
+    if $checker =~ /^[-\w]+$/
+      require File.join($BASE,$checker)
+    else
+      require $checker
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,9 @@
+module Gorp
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end unless defined?(Gorp::VERSION)

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification 
+name: rubys-gorp
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Sam Ruby
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-17 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: builder
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: tzinfo
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Enables the creation of scenarios that involve creating a rails project, starting and stoppping of servers, generating projects, editing files, issuing http requests, running of commands, etc.  Output is captured as a single HTML file that can be viewed locally or uploaded.  Additionally, there is support for verification, in the form of defining assertions based on selections (typically CSS) against the generated HTML.
+email: rubys@intertwingly.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- lib/version.rb
+- lib/gorp.rb
+- lib/gorp/test.rb
+files: 
+- README
+- Rakefile
+- Manifest
+- gorp.gemspec
+- lib/version.rb
+- lib/gorp.rb
+- lib/gorp/test.rb
+has_rdoc: false
+homepage: http://github.com/rubys/gorp
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Gorp
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: gorp
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Rails scenario testing support library
+test_files: []
+