rails_product 0.5

data/README

@@ -0,0 +1,195 @@
+== Welcome to the Productized Rails Application generator
+Author: Duane Johnson (canadaduane)
+Email: duane.johnson@gmail.com
+Project Website: http://inquirylabs.com/productize/
+
+= What is a 'Productized Rails Application' ?
+
+At MyTechSupport, we often have clients who pay a few thousand dollars for
+a web site, but in order to make a profit, we need to re-sell our work to
+other companies with similar business needs. For example, we are currently
+working on an adoption site (Jul 2005). Adoption sites, in general, have
+some generic needs (e.g. a "Birth Mother" login and a "Waiting Family"
+login), but our client has some particular needs as well.
+
+Using the following code, you can create a single generic application which
+uses a separate database for each client. In addition, you will have a
+hierarchical application structure wherein add-ons and tweaks for specific
+customers are possible without affecting the core "generic" site code base
+(neither will you have to copy that code base for each application). In
+this way, you can maintain a core application code base that every client
+uses, while still providing flexibility for paid add-ons or site-specific
+needs.
+
+= Installation
+
+To install the rails_product generator, simply run:
+
+$ gem install rails_product
+
+(This assumes you have the prerequisites to Rails already installed, e.g.
+Ruby 1.8.2 2004-12-25 and the 'gem' shell command from rubyforge.org).
+
+Next, you'll want to make sure you have the site generator as well:
+
+$ gem install site_generator
+
+The site generator will create a hollow directory structure for each site
+that you add to your base application.
+
+So, now that you've got the gems installed, here's how you'd create your
+very first Rails product:
+
+$ cd ~/Projects
+$ rails_product shopping_cart
+    create  
+    create  app/apis
+      <snip>
+    create  sites
+    create  Rakefile
+    create  README
+    create  CHANGELOG
+    create  app/controllers/application.rb
+    create  app/helpers/application_helper.rb
+    create  test/test_helper.rb
+    create  config/database.yml
+    create  config/routes.rb
+    create  public/.htaccess
+    create  sites/Rakefile
+      <snip>
+$ cd shopping_cart
+$ ./script/generate site my_first_cart_client
+    create  sites/my_first_cart_client/app/controllers
+    create  sites/my_first_cart_client/app/helpers
+    create  sites/my_first_cart_client/app/models
+    create  sites/my_first_cart_client/app/views/layouts
+    create  sites/my_first_cart_client/db/migrate
+    create  sites/my_first_cart_client/log
+    create  sites/my_first_cart_client/public
+    create  sites/my_first_cart_client/config
+    create  sites/my_first_cart_client/test/fixtures
+    create  sites/my_first_cart_client/test/functional
+    create  sites/my_first_cart_client/test/unit
+    create  sites/my_first_cart_client/public/.htaccess
+    create  sites/my_first_cart_client/public/dispatch.fcgi
+    create  sites/my_first_cart_client/config/routes.rb
+$ ./script/server -s my_first_cart_client
+=> Productized Rails application started on http://0.0.0.0:3000
+...
+
+At this point, assuming your application is going to be using a
+database, you'll want to go make your first site's database.  Depending on
+how you do things, you'll want to make one, two, or possibly all three of
+these databases:
+  my_first_cart_client_dev
+  my_first_cart_client_test
+  my_first_cart_client
+
+The last database in that list is the production database.
+
+
+= How Does The Directory Structure Differ From a Regular Rails Application?
+
+The directory structure of the Generic application is just like a normal
+Rails application, with one additional directory: the "sites" directory. So
+it looks something like this:
+
+RAILS_ROOT/
+  app/
+    controllers/
+    helpers/
+    models/
+    views/
+  public/
+  sites/
+    best_ever_adoptions_co_inc/   # <-- Site #1
+      app/
+        controllers/
+        helpers/
+        models/
+        views/
+      config/
+      db/
+        migrate/
+      public/
+      test/
+        fixtures/
+        functional/
+        unit/
+    yet_another_adoption_co/    # <-- Site #2
+      app/
+        controllers/
+        helpers/
+        models/
+        views/
+      (etc.)
+
+Note that although the directory structure of each individual site is
+almost identical to a regular Rails application, you need not have ANY
+files in these directories.  In fact, you can omit any directory (except
+the SITE_ROOT, e.g. sites/best_ever_adoptions_co_inc/) if it does not
+contain files.  So how does it work?
+
+Well, if you put a file called, for example, welcome_controller.rb in
+RAILS_ROOT/app/controllers, then all of your sites will access that
+controller as normal UNLESS you put a file with the same name in the
+site-specific controllers folder. In that case, the RAILS_ROOT
+welcome_controller.rb will be loaded, and then the WelcomeController class
+will be reopened (yay for Ruby!) by the site-specific welcome_controller.rb
+(say, for example, in
+RAILS_ROOT/sites/yet_another_adoption_co/app/controllers/) and modified as
+needed. For example, you could override the "index" method to do a
+redirect, or you could add a before_filter to make the controller require a
+login.
+
+Views, layouts and partials act similarly--however, they simply override
+their generic counterparts. For example, if you have an index.rhtml and a
+_title.rhtml in RAILS_ROOT/app/views/welcome/ and supposing this
+index.rhtml has a <%= render :partial => "title" %> in its code, then the
+_title partial will be rendered in place. Now, however, let's say that we
+put a _title.rhtml file in
+RAILS_ROOT/sites/yet_another_adoption_co/app/views/welcome/. In that case,
+our generic index.rhtml will load the site-specific _title partial in
+place. Hierarchical customizations in a jiffy.
+
+= Implementation Details
+
+If you would like to understand how all of the pieces work together to
+accomplish this feat, read on.
+
+Here is what the rails_product generator will do:
+
+1. Create the RAILS_ROOT directory structure as usual, with the addition
+of a /sites folder.
+
+2. Create a productize.rb file in your application's lib/ folder (open it
+and read the comments to see what it does exactly.  This is where the core
+magic happens since we can re-open the Rails classes as necessary to allow
+for our productization approach.)
+
+3. Create a slightly modified environment.rb file in your config/ folder.
+The following three lines are different from the regular environment.rb:
+
+  a. SITE = ENV['SITE'] || ENV['site']
+     Sets a constant for the rest of the application so it can know where
+     to find your site's stuff.
+
+  b. require 'productize'
+     Modifies the core Rails classes as necessary to load both the base
+     application's code and the site-specific code.
+  
+  c. File.join(SITE_ROOT, 'app', 'controllers'),
+     Lets the Dependencies::LoadingModules class know where to find site-
+     specific controllers if the base controller doesn't exist.
+
+4. Create a modified database.yml file that will dynamically load the
+correct database when the server starts up.
+
+5. Create an 'apache' directory in your config/ folder with a sample Apache
+VirtualHost configuration file.  This sample file will show you what you'll
+need to do to get Apache to behave like WEBrick below (shares resources).
+
+6. Create a modified script/server file that will let your WEBrick server
+share the resources in your base application's public folder (e.g. images,
+javascripts etc.) without having to copy them to each site's individual
+public folder (Hurray for the DRY principle!) (DRY=Don't Repeat Yourself).

data/Rakefile

@@ -0,0 +1,413 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+
+require 'date'
+require 'rbconfig'
+
+PKG_BUILD       = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+PKG_NAME        = 'rails_product'
+PKG_VERSION     = '0.5' + PKG_BUILD
+PKG_FILE_NAME   = "#{PKG_NAME}-#{PKG_VERSION}"
+PKG_DESTINATION = ENV["RAILS_PKG_DESTINATION"] || "../#{PKG_NAME}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+
+RUBY_FORGE_PROJECT = "rails"
+RUBY_FORGE_USER    = "webster132"
+
+
+# Rake::TestTask.new("test") do |t|
+#   t.libs << 'test'
+#   t.pattern = 'test/*_test.rb'
+#   t.verbose = true
+# end
+
+
+BASE_DIRS   = %w( app config/environments components db doc log lib public script script/process test vendor )
+APP_DIRS    = %w( apis models controllers helpers views views/layouts )
+PUBLIC_DIRS = %w( images javascripts stylesheets )
+TEST_DIRS   = %w( fixtures unit functional mocks mocks/development mocks/test )
+
+BASE_DIRS << "sites"
+SITE_BASE_DIRS = %w( app db db/migrate public test )
+SITE_APP_DIRS = %w( models controllers helpers views views/layouts )
+SITE_TEST_DIRS = %w( fixtures unit functional )
+
+LOG_FILES    = %w( server.log development.log test.log production.log )
+HTML_FILES   = %w( 404.html 500.html index.html robots.txt favicon.ico javascripts/prototype.js javascripts/effects.js javascripts/dragdrop.js javascripts/controls.js )
+BIN_FILES    = %w( generate destroy breakpointer console server update runner profiler benchmarker process/reaper process/spinner process/spawner )
+
+VENDOR_LIBS = %w( actionpack activerecord actionmailer activesupport actionwebservice railties )
+
+
+desc "Generates a fresh Rails package with documentation"
+task :fresh_rails => [ :clean, :make_dir_structure, :initialize_file_stubs, :copy_vendor_libraries, :copy_ties_content, :generate_documentation ]
+
+desc "Generates a fresh Rails package using GEMs with documentation"
+task :fresh_gem_rails => [ :clean, :make_dir_structure, :initialize_file_stubs, :copy_ties_content, :copy_gem_environment ]
+
+desc "Generates a fresh Rails package without documentation (faster)"
+task :fresh_rails_without_docs => [ :clean, :make_dir_structure, :initialize_file_stubs, :copy_vendor_libraries, :copy_ties_content ]
+
+desc "Generates a fresh Rails package without documentation (faster)"
+task :fresh_rails_without_docs_using_links => [ :clean, :make_dir_structure, :initialize_file_stubs, :link_vendor_libraries, :copy_ties_content ]
+
+desc "Generates minimal Rails package using symlinks"
+task :dev => [ :clean, :make_dir_structure, :initialize_file_stubs, :link_vendor_libraries, :copy_ties_content ]
+
+desc "Packages the fresh Rails package with documentation"
+task :package => [ :clean, :fresh_rails ] do
+  system %{cd ..; tar -czvf #{PKG_NAME}-#{PKG_VERSION}.tgz #{PKG_NAME}}
+  system %{cd ..; zip -r #{PKG_NAME}-#{PKG_VERSION}.zip #{PKG_NAME}}
+end
+
+task :clean do
+  rm_rf PKG_DESTINATION
+end
+
+# Get external spinoffs -------------------------------------------------------------------
+
+desc "Updates railties to the latest version of the javascript spinoffs"
+task :update_js do
+  for js in %w( prototype controls dragdrop effects )
+    rm "html/javascripts/#{js}.js"
+    cp "./../actionpack/lib/action_view/helpers/javascripts/#{js}.js", "html/javascripts"
+  end
+end
+
+# Make directory structure ----------------------------------------------------------------
+
+def make_dest_dirs(dirs, path = nil)
+  mkdir_p dirs.map { |dir| File.join(PKG_DESTINATION, path, dir) }
+end
+
+desc "Make the directory structure for the new Rails application"
+task :make_dir_structure => [ :make_base_dirs, :make_app_dirs, :make_public_dirs, :make_test_dirs ]
+
+task(:make_base_dirs)   { make_dest_dirs BASE_DIRS              }
+task(:make_app_dirs)    { make_dest_dirs APP_DIRS,    'app'     }
+task(:make_public_dirs) { make_dest_dirs PUBLIC_DIRS, 'public'  }
+task(:make_test_dirs)   { make_dest_dirs TEST_DIRS,   'test'    }
+
+
+# Initialize file stubs -------------------------------------------------------------------
+
+desc "Initialize empty file stubs (such as for logging)"
+task :initialize_file_stubs => [ :initialize_log_files ]
+
+task :initialize_log_files do
+  log_dir = File.join(PKG_DESTINATION, 'log')
+  chmod 0777, log_dir
+  LOG_FILES.each do |log_file|
+    log_path = File.join(log_dir, log_file)
+    touch log_path
+    chmod 0666, log_path
+  end
+end
+
+
+# Copy Vendors ----------------------------------------------------------------------------
+
+desc "Copy in all the Rails packages to vendor"
+task :copy_vendor_libraries do
+  mkdir File.join(PKG_DESTINATION, 'vendor', 'rails')
+  VENDOR_LIBS.each { |dir| cp_r File.join('..', dir), File.join(PKG_DESTINATION, 'vendor', 'rails', dir) }
+end
+
+desc "Link in all the Rails packages to vendor"
+task :link_vendor_libraries do
+  mkdir File.join(PKG_DESTINATION, 'vendor', 'rails')
+  VENDOR_LIBS.each { |dir| ln_s File.join('..', '..', '..', dir), File.join(PKG_DESTINATION, 'vendor', 'rails', dir) }
+end
+
+
+# Copy Ties Content -----------------------------------------------------------------------
+
+# :link_apache_config
+desc "Make copies of all the default content of ties"
+task :copy_ties_content => [ 
+  :copy_rootfiles, :copy_dispatches, :copy_html_files, :copy_application,
+  :copy_configs, :copy_binfiles, :copy_test_helpers, :copy_app_doc_readme ]
+
+task :copy_dispatches do
+  copy_with_rewritten_ruby_path("dispatches/dispatch.rb", "#{PKG_DESTINATION}/public/dispatch.rb")
+  chmod 0755, "#{PKG_DESTINATION}/public/dispatch.rb"
+
+  copy_with_rewritten_ruby_path("dispatches/dispatch.rb", "#{PKG_DESTINATION}/public/dispatch.cgi")
+  chmod 0755, "#{PKG_DESTINATION}/public/dispatch.cgi"
+
+  copy_with_rewritten_ruby_path("dispatches/dispatch.fcgi", "#{PKG_DESTINATION}/public/dispatch.fcgi")
+  chmod 0755, "#{PKG_DESTINATION}/public/dispatch.fcgi"
+
+  # copy_with_rewritten_ruby_path("dispatches/gateway.cgi", "#{PKG_DESTINATION}/public/gateway.cgi")
+  # chmod 0755, "#{PKG_DESTINATION}/public/gateway.cgi"
+end
+
+task :copy_html_files do
+  HTML_FILES.each { |file| cp File.join('html', file), File.join(PKG_DESTINATION, 'public', file) }
+end
+
+task :copy_application do
+  cp "helpers/application.rb", "#{PKG_DESTINATION}/app/controllers/application.rb"
+  cp "helpers/application_helper.rb", "#{PKG_DESTINATION}/app/helpers/application_helper.rb"
+end
+
+task :copy_configs do
+  cp "configs/database.yml", "#{PKG_DESTINATION}/config/database.yml"
+  cp "configs/routes.rb", "#{PKG_DESTINATION}/config/routes.rb"
+
+  cp "configs/apache.conf", "#{PKG_DESTINATION}/public/.htaccess"
+
+  cp "environments/environment.rb", "#{PKG_DESTINATION}/config/environment.rb"
+  cp "environments/production.rb", "#{PKG_DESTINATION}/config/environments/production.rb"
+  cp "environments/development.rb", "#{PKG_DESTINATION}/config/environments/development.rb"
+  cp "environments/test.rb", "#{PKG_DESTINATION}/config/environments/test.rb"
+end
+
+task :copy_binfiles do
+  BIN_FILES.each do |file|
+    dest_file = File.join(PKG_DESTINATION, 'script', file)
+    copy_with_rewritten_ruby_path(File.join('bin', file), dest_file)
+    chmod 0755, dest_file
+  end
+end
+
+task :copy_rootfiles do
+  cp "fresh_rakefile", "#{PKG_DESTINATION}/Rakefile"
+  cp "README", "#{PKG_DESTINATION}/README"
+  cp "CHANGELOG", "#{PKG_DESTINATION}/CHANGELOG"
+end
+
+task :copy_test_helpers do
+  cp "helpers/test_helper.rb", "#{PKG_DESTINATION}/test/test_helper.rb"
+end
+
+task :copy_app_doc_readme do
+  cp "doc/README_FOR_APP", "#{PKG_DESTINATION}/doc/README_FOR_APP"
+end
+
+task :link_apache_config do
+  chdir(File.join(PKG_DESTINATION, 'config')) {
+    ln_s "../public/.htaccess", "apache.conf"
+  }
+end
+
+def copy_with_rewritten_ruby_path(src_file, dest_file)
+  ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+
+  File.open(dest_file, 'w') do |df|
+    File.open(src_file) do |sf|
+      line = sf.gets
+      if (line =~ /#!.+ruby\s*/) != nil
+        df.puts("#!#{ruby}")
+      else
+        df.puts(line)
+      end
+      df.write(sf.read)
+    end
+  end
+end
+
+
+# Generate documentation ------------------------------------------------------------------
+
+desc "Generate documentation for the framework and for the empty application"
+task :generate_documentation => [ :generate_app_doc, :generate_rails_framework_doc ]
+
+task :generate_rails_framework_doc do
+  system %{cd #{PKG_DESTINATION}; rake apidoc}
+end
+
+task :generate_app_doc do
+  File.cp "doc/README_FOR_APP", "#{PKG_DESTINATION}/doc/README_FOR_APP"
+  system %{cd #{PKG_DESTINATION}; rake appdoc}
+end
+
+
+# Generate GEM ----------------------------------------------------------------------------
+
+task :copy_gem_environment do
+  cp "environments/environment.rb", "#{PKG_DESTINATION}/config/environment.rb"
+  dest_file = File.join(PKG_DESTINATION, 'script', 'breakpointer')
+  copy_with_rewritten_ruby_path(File.join('bin', 'breakpointer_for_gem'), dest_file)
+  chmod 0755, dest_file
+end
+
+
+PKG_FILES = FileList[
+  '[a-zA-Z]*',
+  'bin/**/*', 
+  'configs/**/*', 
+  'doc/**/*', 
+  'dispatches/**/*', 
+  'environments/**/*', 
+  'helpers/**/*', 
+  'generators/**/*', 
+  'html/**/*', 
+  'lib/**/*',
+  'sites/**/*'
+]
+
+spec = Gem::Specification.new do |s|
+  s.name = 'rails_product'
+  s.version = PKG_VERSION
+  s.summary = "Creates a ready-to-go productized Ruby on Rails application from a single command ('rails_product')."
+  s.description = <<-EOF
+    A "Productized Rails Application" is a single generic application having a hierarchical structure
+wherein add-ons and tweaks for concurrent versions of the application are possible without affecting
+the core "generic" code base.  You might use this, for example, if you want to maintain a common
+shopping cart code base that all of your clients use, while still providing flexibility for paid
+add-ons or site-specific needs.
+  EOF
+
+  s.add_dependency('rake', '>= 0.5.3')
+  s.add_dependency('activesupport',    '= 1.1.1' + PKG_BUILD)
+  s.add_dependency('activerecord',     '= 1.11.1' + PKG_BUILD)
+  s.add_dependency('actionpack',       '= 1.9.1' + PKG_BUILD)
+  s.add_dependency('actionmailer',     '= 1.0.1' + PKG_BUILD)
+  s.add_dependency('actionwebservice', '= 0.8.1' + PKG_BUILD)
+
+  s.rdoc_options << '--exclude' << '.'
+  s.has_rdoc = false
+
+  s.files = PKG_FILES.to_a.delete_if {|f| f.include?('.svn')}
+  s.require_path = 'lib'
+
+  s.bindir = "bin"                               # Use these for applications.
+  s.executables = ["rails_product"]
+  s.default_executable = "rails_product"
+
+  s.author = "Duane Johnson"
+  s.email = "duane.johnson@gmail.com"
+  s.homepage = "http://inquirylabs.com/productize/"
+  s.rubyforge_project = "rails_product"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+end
+
+
+# Publishing -------------------------------------------------------
+desc "Publish the API documentation"
+task :pgem => [:gem] do 
+  Rake::SshFilePublisher.new("davidhh@wrath.rubyonrails.org", "public_html/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
+  `ssh davidhh@wrath.rubyonrails.org './gemupdate.sh'`
+end
+
+desc "Publish the release files to RubyForge."
+task :release => [:gem] do
+  files = ["gem"].map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" }
+
+  if RUBY_FORGE_PROJECT then
+    require 'net/http'
+    require 'open-uri'
+
+    project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/"
+    project_data = open(project_uri) { |data| data.read }
+    group_id = project_data[/[?&]group_id=(\d+)/, 1]
+    raise "Couldn't get group id" unless group_id
+
+    # This echos password to shell which is a bit sucky
+    if ENV["RUBY_FORGE_PASSWORD"]
+      password = ENV["RUBY_FORGE_PASSWORD"]
+    else
+      print "#{RUBY_FORGE_USER}@rubyforge.org's password: "
+      password = STDIN.gets.chomp
+    end
+
+    login_response = Net::HTTP.start("rubyforge.org", 80) do |http|
+      data = [
+        "login=1",
+        "form_loginname=#{RUBY_FORGE_USER}",
+        "form_pw=#{password}"
+      ].join("&")
+      http.post("/account/login.php", data)
+    end
+
+    cookie = login_response["set-cookie"]
+    raise "Login failed" unless cookie
+    headers = { "Cookie" => cookie }
+
+    release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}"
+    release_data = open(release_uri, headers) { |data| data.read }
+    package_id = release_data[/[?&]package_id=(\d+)/, 1]
+    raise "Couldn't get package id" unless package_id
+
+    first_file = true
+    release_id = ""
+
+    files.each do |filename|
+      basename  = File.basename(filename)
+      file_ext  = File.extname(filename)
+      file_data = File.open(filename, "rb") { |file| file.read }
+
+      puts "Releasing #{basename}..."
+
+      release_response = Net::HTTP.start("rubyforge.org", 80) do |http|
+        release_date = Time.now.strftime("%Y-%m-%d %H:%M")
+        type_map = {
+          ".zip"    => "3000",
+          ".tgz"    => "3110",
+          ".gz"     => "3110",
+          ".gem"    => "1400"
+        }; type_map.default = "9999"
+        type = type_map[file_ext]
+        boundary = "rubyqMY6QN9bp6e4kS21H4y0zxcvoor"
+
+        query_hash = if first_file then
+          {
+            "group_id" => group_id,
+            "package_id" => package_id,
+            "release_name" => RELEASE_NAME,
+            "release_date" => release_date,
+            "type_id" => type,
+            "processor_id" => "8000", # Any
+            "release_notes" => "",
+            "release_changes" => "",
+            "preformatted" => "1",
+            "submit" => "1"
+          }
+        else
+          {
+            "group_id" => group_id,
+            "release_id" => release_id,
+            "package_id" => package_id,
+            "step2" => "1",
+            "type_id" => type,
+            "processor_id" => "8000", # Any
+            "submit" => "Add This File"
+          }
+        end
+
+        query = "?" + query_hash.map do |(name, value)|
+          [name, URI.encode(value)].join("=")
+        end.join("&")
+
+        data = [
+          "--" + boundary,
+          "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"",
+          "Content-Type: application/octet-stream",
+          "Content-Transfer-Encoding: binary",
+          "", file_data, ""
+          ].join("\x0D\x0A")
+
+        release_headers = headers.merge(
+          "Content-Type" => "multipart/form-data; boundary=#{boundary}"
+        )
+
+        target = first_file ? "/frs/admin/qrs.php" : "/frs/admin/editrelease.php"
+        http.post(target + query, data, release_headers)
+      end
+
+      if first_file then
+        release_id = release_response.body[/release_id=(\d+)/, 1]
+        raise("Couldn't get release id") unless release_id
+      end
+
+      first_file = false
+    end
+  end
+end

data/bin/benchmarker

@@ -0,0 +1,19 @@
+#!/usr/local/bin/ruby
+
+if ARGV.empty?
+  puts "Usage: benchmarker times 'Person.expensive_way' 'Person.another_expensive_way' ..."
+  exit 
+end
+
+require File.dirname(__FILE__) + '/../config/environment'
+require 'benchmark'
+include Benchmark
+
+# Don't include compilation in the benchmark
+ARGV[1..-1].each { |expression| eval(expression) }
+
+bm(6) do |x|
+  ARGV[1..-1].each_with_index do |expression, idx|
+    x.report("##{idx + 1}") { ARGV[0].to_i.times { eval(expression) } }
+  end
+end 

data/bin/breakpointer

@@ -0,0 +1,3 @@
+#!/usr/local/bin/ruby
+$LOAD_PATH << File.dirname(__FILE__) + '/../vendor/railties/lib'
+require 'breakpoint_client'

data/bin/breakpointer_for_gem

@@ -0,0 +1,4 @@
+#!/usr/local/bin/ruby
+require 'rubygems'
+require_gem 'rails'
+require 'breakpoint_client'

data/bin/console

@@ -0,0 +1,23 @@
+#!/usr/local/bin/ruby
+irb = RUBY_PLATFORM =~ /mswin32/ ? 'irb.bat' : 'irb'
+
+require 'optparse'
+options = { :sandbox => false, :irb => irb }
+OptionParser.new do |opt|
+  opt.on('-s', '--sandbox', 'Rollback database modifications on exit.') { |options[:sandbox]| }
+  opt.on("--irb=[#{irb}]", 'Invoke a different irb.') { |options[:irb]| }
+  opt.parse!(ARGV)
+end
+
+libs =  " -r irb/completion"
+libs << " -r #{File.dirname(__FILE__)}/../config/environment"
+libs << " -r console_sandbox" if options[:sandbox]
+
+ENV['RAILS_ENV'] = ARGV.first || 'development'
+if options[:sandbox]
+  puts "Loading #{ENV['RAILS_ENV']} environment in sandbox."
+  puts "Any modifications you make will be rolled back on exit."
+else
+  puts "Loading #{ENV['RAILS_ENV']} environment."
+end
+exec "#{options[:irb]} #{libs} --prompt-mode simple"

data/bin/destroy

@@ -0,0 +1,7 @@
+#!/usr/local/bin/ruby
+require File.dirname(__FILE__) + '/../config/environment'
+require 'rails_generator'
+require 'rails_generator/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+Rails::Generator::Scripts::Destroy.new.run(ARGV)

data/bin/generate

@@ -0,0 +1,7 @@
+#!/usr/local/bin/ruby
+require File.dirname(__FILE__) + '/../config/environment'
+require 'rails_generator'
+require 'rails_generator/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+Rails::Generator::Scripts::Generate.new.run(ARGV)