rails 0.8.0

data/bin/rails

@@ -0,0 +1,28 @@
+if ARGV[0]
+  ENV["RAILS_PKG_DESTINATION"] = File.expand_path(ARGV[0])
+  if RUBY_PLATFORM =~ /mswin32/
+    Dir.chdir File.dirname(__FILE__)
+    system %{rake.cmd fresh_gem_rails}
+  else
+    system %{ cd #{File.dirname(__FILE__)}; rake fresh_gem_rails }
+  end
+else
+  puts <<-HELP
+
+NAME
+     rails - creates a new Rails installation 
+
+SYNOPSIS
+     rails [full path]
+
+DESCRIPTION
+     This generator will create a suggested directory structure, lots of minor helper
+     files, and a default configuration for creating a new Rails application. Once the
+     generator is done, you're adviced to look at the README in the root of the folder.
+     
+EXAMPLE
+     rails ~/Code/Ruby/weblog
+     
+     This will generate a new Rails installation in the ~/Code/Ruby/weblog folder.
+HELP
+end

data/configs/apache.conf

@@ -0,0 +1,44 @@
+# General Apache options
+AddHandler fastcgi-script .fcgi
+AddHandler cgi-script .cgi
+Options +FollowSymLinks +ExecCGI
+
+
+# Remember to set RubySafeLevel 0 in httpd.conf
+<IfModule mod_ruby.c>
+  RubyRequire apache/ruby-run
+  <Files dispatch.rb>
+    SetHandler ruby-object
+    RubyHandler Apache::RubyRun.instance
+  </Files>
+</IfModule>
+
+
+# Make sure that mod_ruby.c has been added and loaded as a module with Apache
+RewriteEngine On
+
+RewriteRule ^dispatch.servlet$ / [R]
+
+# Enable this rewrite rule to point to the controller/action that should serve root.
+# RewriteRule ^$ /controller/action [R]
+
+# Force fcgi
+RewriteRule ^fcgi/([-_a-zA-Z0-9]+)/([-_a-zA-Z0-9]+)/([-_a-zA-Z0-9]+)$ /dispatch.fcgi?controller=$1&action=$2&id=$3 [QSA] [L]
+RewriteRule ^fcgi/([-_a-zA-Z0-9]+)/([-_a-zA-Z0-9]+)$ /dispatch.fcgi?controller=$1&action=$2 [QSA] [L]
+RewriteRule ^fcgi/([-_a-zA-Z0-9]+)/?$ /dispatch.fcgi?controller=$1&action=index [QSA] [L]
+
+# Force mod_ruby
+RewriteRule ^mruby/([-_a-zA-Z0-9]+)/([-_a-zA-Z0-9]+)/([-_a-zA-Z0-9]+)$ /dispatch.rb?controller=$1&action=$2&id=$3 [QSA] [L]
+RewriteRule ^mruby/([-_a-zA-Z0-9]+)/([-_a-zA-Z0-9]+)$ /dispatch.rb?controller=$1&action=$2 [QSA] [L]
+RewriteRule ^mruby/([-_a-zA-Z0-9]+)/?$ /dispatch.rb?controller=$1&action=index [QSA] [L]
+
+# Default rewriting rules. Change extension from .cgi to .fcgi to switch to FCGI and to .rb to switch to mod_ruby
+RewriteRule ^([-_a-zA-Z0-9]+)/([-_a-zA-Z0-9]+)/([-_a-zA-Z0-9]+)$ /dispatch.cgi?controller=$1&action=$2&id=$3 [QSA] [L]
+RewriteRule ^([-_a-zA-Z0-9]+)/([-_a-zA-Z0-9]+)$ /dispatch.cgi?controller=$1&action=$2 [QSA] [L]
+RewriteRule ^([-_a-zA-Z0-9]+)/$ /dispatch.cgi?controller=$1&action=index [QSA] [L]
+RewriteRule ^([-_a-zA-Z0-9]+)$ /$1/ [R]
+
+
+# You can also point these error messages to a controller/action
+ErrorDocument 500 /500.html
+ErrorDocument 404 /404.html

data/configs/database.yml

@@ -0,0 +1,13 @@
+production:
+  adapter: mysql
+  database: rails_production
+  host: localhost
+  username: root
+  password: 
+
+test:
+  adapter: mysql
+  database: rails_test
+  host: localhost
+  username: root
+  password:

data/dispatches/dispatch.fcgi

@@ -0,0 +1,7 @@
+#!/usr/local/bin/ruby
+
+require File.dirname(__FILE__) + "/../config/environments/production"
+require 'dispatcher'
+require 'fcgi'
+
+FCGI.each_cgi { |cgi| Dispatcher.dispatch(cgi, Dispatcher::DEFAULT_SESSION_OPTIONS, File.dirname(__FILE__) + "/500.html") }

data/dispatches/dispatch.rb

@@ -0,0 +1,10 @@
+#!/usr/local/bin/ruby
+
+require File.dirname(__FILE__) + "/../config/environments/production"
+
+# If you're using RubyGems and mod_ruby, this require should be changed to an absolute path one, like:
+# "/usr/local/lib/ruby/gems/1.8/gems/rails-0.8.0/lib/dispatcher" -- otherwise performance is severely impaired
+require "dispatcher"
+
+ADDITIONAL_LOAD_PATHS.each { |dir| $:.unshift "#{File.dirname(__FILE__)}/../#{dir}" }
+Dispatcher.dispatch

data/dispatches/dispatch.servlet

@@ -0,0 +1,45 @@
+#!/usr/local/bin/ruby
+
+require File.dirname(__FILE__) + "/../config/environments/production"
+require 'webrick_server'
+require 'optparse'
+
+OPTIONS = {
+  :port          => 3000,
+  :ip            => "127.0.0.1",
+  :cache_classes => false,
+  :server_root   => File.expand_path(File.dirname(__FILE__)),
+  :server_type   => SimpleServer
+}
+
+ARGV.options do |opts|
+  script_name = File.basename($0)
+  opts.banner = "Usage: ruby #{script_name} [options]"
+
+  opts.separator ""
+
+  opts.on("-p", "--port=port", Integer,
+          "Runs Rails on the specified port.",
+          "Default: 3000") { |OPTIONS[:port]| }
+  opts.on("-b", "--binding=ip", String,
+          "Binds Rails to the specified ip.",
+          "Default: 127.0.0.1") { |OPTIONS[:ip]| }
+  opts.on("-i", "--index=controller", String,
+          "Specifies an index controller that requests for root will go to (instead of congratulations screen)."
+          ) { |OPTIONS[:index_controller]| }
+  opts.on("-d", "--daemon",
+          "Make Rails run as a Daemon (only works if fork is available -- meaning on *nix)."
+          ) { OPTIONS[:server_type] = Daemon }
+  opts.on("-c", "--cache-classes",
+          "Caches class compilation which will speed up the serving of requests, but require a server restart on source changes."
+          ) { |OPTIONS[:cache_classes]| }
+
+  opts.separator ""
+
+  opts.on("-h", "--help",
+          "Show this help message.") { puts opts; exit }
+
+  opts.parse!
+end
+
+DispatchServlet.dispatch(OPTIONS)

data/doc/README_FOR_APP

@@ -0,0 +1,2 @@
+Use this README file to introduce your application and point to useful places in the API for learning more.
+Run "rake appdoc" to generate API documentation for your models and controllers.

data/doc/apache_protection

@@ -0,0 +1,3 @@
+Order Deny,Allow
+Deny from all
+Allow from 127.0.0.1

data/doc/index.html

@@ -0,0 +1,94 @@
+<html>
+<head>
+  <title>Rails: Welcome on board</title>
+  <style>
+    body { background-color: #fff; color: #333; }
+
+    body, p, ol, ul, td {
+      font-family: verdana, arial, helvetica, sans-serif;
+      font-size:   12px;
+      line-height: 18px;
+    }
+
+    li {
+      margin-bottom: 7px;
+    }
+
+    pre {
+      background-color: #eee;
+      padding: 10px;
+      font-size: 11px;
+    }
+
+    a { color: #000; }
+    a:visited { color: #666; }
+    a:hover { color: #fff; background-color:#000; }
+  </style>
+</head>
+<body>
+
+<h1>Congratulations, you're on Rails!</h1>
+
+<p>
+  <i>You've succesfully configured your wb-server to point at this Rails application.</i>
+</p>
+
+<p>Before you move on, verify that the following conditions have been meet:</p>
+
+<ol>
+  <li>The log directory and the empty log files must be writable to the web server (<code>chmod -R 777 log</code>).
+  <li>
+    The shebang line in the public/dispatch* files must reference your Ruby installation. <br/>
+    You might need to change it to <code>#!/usr/bin/env ruby</code> or point directly at the installation.
+  </li>
+  <li>
+    Rails on Apache needs to have the cgi handler and mod_rewrite enabled.  <br/>
+    Somewhere in your httpd.conf, you should have:<br/>
+    <code>AddHandler cgi-script .cgi</code><br/>
+    <code>LoadModule rewrite_module     libexec/httpd/mod_rewrite.so</code><br/>
+    <code>AddModule mod_rewrite.c</code>
+  </li>
+</ol>
+
+<p>Take the following steps to get started:</p>
+
+<ol>
+  <li>Create empty production and test databases for your application.<br/>
+      <small>Warning: Don't point your test database at your production database, it'll destroy the latter on test runs!</small>
+  <li>Edit config/database.yml with your database settings.
+  <li>Create a new controller using the <code>script/new_controller</code> generator <br/>
+      <small>Help: Run with no arguments for documentation</small>
+  <li>Create a new model using the <code>script/new_model</code> generator <br/>
+      <small>Help: Run with no arguments for documentation</small>
+  <li>See all the tests run and by running <code>rake</code>.
+  <li>Develop your Rails application!
+  <li>Setup FastCGI or mod_ruby to get production-level performance
+</ol>
+
+<p>
+  Having problems getting up and running? First try debugging it yourself by looking at the log files. <br/> Then try the friendly Rails 
+  community on IRC  (<a href="http://www.rubyonrails.org/show/IRC">howto IRC</a>). It's on FreeNET in channel #rubyonrails. 
+</p>
+
+<div style="float: left; margin-right: 20px">
+  <h2>Rails Online</h2>
+
+  <ul>
+    <li><a href="http://www.rubyonrails.org">Ruby on Rails</a></li>
+    <li><a href="http://activerecord.rubyonrails.org">Active Record</a></li>
+    <li><a href="http://actionpack.rubyonrails.org">Action Pack</a></li>
+  </ul>
+</div>
+
+<div style="float: left">
+  <h2>Beyond CGI</h2>
+
+  <ul>
+    <li><a href="http://www.fastcgi.com">FastCGI</a></li>
+    <li><a href="http://raa.ruby-lang.org/list.rhtml?name=fcgi">FastCGI bindings for Ruby</a></li>
+    <li><a href="http://modruby.net/en/">mod_ruby</a></li>
+  </ul>
+</div>
+
+</body>
+</html>

data/environments/production.rb

@@ -0,0 +1,6 @@
+require File.dirname(__FILE__) + "/shared"
+
+ActiveRecord::Base.logger = ActionController::Base.logger = ActionMailer::Base.logger =
+  Logger.new(File.dirname(__FILE__) + "/../../log/production.log")
+
+ActiveRecord::Base.establish_connection(database_configurations["production"])

data/environments/shared.rb

@@ -0,0 +1,27 @@
+ADDITIONAL_LOAD_PATHS = [ 
+  "app/models", 
+  "app/controllers", 
+  "app/helpers", 
+  "config", 
+  "lib", 
+  "vendor",
+  "vendor/railties", 
+  "vendor/railties/lib", 
+  "vendor/activerecord/lib", 
+  "vendor/actionpack/lib",
+  "vendor/actionmailer/lib"
+]
+
+ADDITIONAL_LOAD_PATHS.each { |dir| $:.unshift "#{File.dirname(__FILE__)}/../../#{dir}" }
+
+require 'active_record'
+require 'action_controller'
+require 'action_mailer'
+
+require 'yaml'
+
+ActionController::Base.template_root = ActionMailer::Base.template_root = File.dirname(__FILE__) + '/../../app/views/'
+
+def database_configurations
+  YAML::load(File.open(File.dirname(__FILE__) + "/../../config/database.yml"))
+end

data/environments/shared_for_gem.rb

@@ -0,0 +1,17 @@
+ADDITIONAL_LOAD_PATHS = [ "app/models", "app/controllers", "app/helpers", "config", "lib", "vendor" ]
+ADDITIONAL_LOAD_PATHS.each { |dir| $:.unshift "#{File.dirname(__FILE__)}/../../#{dir}" }
+
+require 'rubygems'
+
+require_gem 'activerecord'
+require_gem 'actionpack'
+require_gem 'actionmailer'
+require_gem 'rails'
+
+require 'yaml'
+
+ActionController::Base.template_root = ActionMailer::Base.template_root = File.dirname(__FILE__) + '/../../app/views/'
+
+def database_configurations
+  YAML::load(File.open(File.dirname(__FILE__) + "/../../config/database.yml"))
+end

data/environments/test.rb

@@ -0,0 +1,6 @@
+require File.dirname(__FILE__) + "/shared"
+
+ActiveRecord::Base.logger = ActionController::Base.logger = ActionMailer::Base.logger =
+  Logger.new(File.dirname(__FILE__) + "/../../log/test.log")
+
+ActiveRecord::Base.establish_connection(database_configurations["test"])

data/fresh_rakefile

@@ -0,0 +1,101 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+$VERBOSE = nil
+
+require File.dirname(__FILE__) + '/config/environments/production'
+require 'code_statistics'
+
+desc "Run all the tests on a fresh test database"
+task :default => [ :clone_production_structure_to_test, :test_units, :test_functional ]
+
+desc "Generate API documentatio, show coding stats"
+task :doc => [ :appdoc, :stats ]
+
+
+desc "Run the unit tests in test/unit"
+Rake::TestTask.new("test_units") { |t|
+  t.libs << "test"
+  t.pattern = 'test/unit/*_test.rb'
+  t.verbose = true
+}
+
+desc "Run the functional tests in test/functional"
+Rake::TestTask.new("test_functional") { |t|
+  t.libs << "test"
+  t.pattern = 'test/functional/*_test.rb'
+  t.verbose = true
+}
+
+desc "Generate documentation for the application"
+Rake::RDocTask.new("appdoc") { |rdoc|
+  rdoc.rdoc_dir = 'doc/app'
+  rdoc.title    = "Rails Application Documentation"
+  rdoc.options << '--line-numbers --inline-source'
+  rdoc.rdoc_files.include('doc/README_FOR_APP')
+  rdoc.rdoc_files.include('app/**/*.rb')
+}
+
+desc "Generate documentation for the Rails framework"
+Rake::RDocTask.new("apidoc") { |rdoc|
+  rdoc.rdoc_dir = 'doc/api'
+  rdoc.title    = "Rails Framework Documentation"
+  rdoc.options << '--line-numbers --inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('vendor/railties/CHANGELOG')
+  rdoc.rdoc_files.include('vendor/railties/MIT-LICENSE')
+  rdoc.rdoc_files.include('vendor/activerecord/README')
+  rdoc.rdoc_files.include('vendor/activerecord/CHANGELOG')
+  rdoc.rdoc_files.include('vendor/activerecord/lib/active_record/**/*.rb')
+  rdoc.rdoc_files.exclude('vendor/activerecord/lib/active_record/vendor/*')
+  rdoc.rdoc_files.include('vendor/actionpack/README')
+  rdoc.rdoc_files.include('vendor/actionpack/CHANGELOG')
+  rdoc.rdoc_files.include('vendor/actionpack/lib/action_controller/**/*.rb')
+  rdoc.rdoc_files.include('vendor/actionpack/lib/action_view/**/*.rb')
+}
+
+desc "Report code statistics (KLOCs, etc) from the application"
+task :stats do
+  CodeStatistics.new(
+    ["Controllers", "app/controllers"], 
+    ["Helpers", "app/helpers"], 
+    ["Models", "app/models"],
+    ["Units", "test/unit"],
+    ["Functionals", "test/functional"]
+  ).to_s
+end
+
+desc "Recreate the test databases from the production structure"
+task :clone_production_structure_to_test => [ :db_structure_dump, :purge_test_database ] do
+  if database_configurations["test"]["adapter"] == "mysql"
+    ActiveRecord::Base.establish_connection(database_configurations["test"])
+    ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
+    IO.readlines("db/production_structure.sql").join.split("\n\n").each do |table|
+      ActiveRecord::Base.connection.execute(table)
+    end
+  elsif database_configurations["test"]["adapter"] == "postgresql"
+    `psql -U #{database_configurations["test"]["username"]} -f db/production_structure.sql #{database_configurations["test"]["database"]}`
+  end
+end
+
+desc "Dump the database structure to a SQL file"
+task :db_structure_dump do
+  if database_configurations["test"]["adapter"] == "mysql"
+    ActiveRecord::Base.establish_connection(database_configurations["production"])
+    File.open("db/production_structure.sql", "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
+  elsif database_configurations["test"]["adapter"] == "postgresql"
+    `pg_dump -U #{database_configurations["test"]["username"]} -s -f db/production_structure.sql #{database_configurations["production"]["database"]}`
+  end
+end
+
+desc "Drop the test database and bring it back again"
+task :purge_test_database do
+  if database_configurations["test"]["adapter"] == "mysql"
+    ActiveRecord::Base.establish_connection(database_configurations["production"])
+    ActiveRecord::Base.connection.recreate_database(database_configurations["test"]["database"])
+  elsif database_configurations["test"]["adapter"] == "postgresql"
+    `dropdb -U #{database_configurations["test"]["username"]} #{database_configurations["test"]["database"]}`
+    `createdb -U #{database_configurations["test"]["username"]}  #{database_configurations["test"]["database"]}`
+  end
+end

data/generators/new_controller.rb

@@ -0,0 +1,118 @@
+#!/usr/local/bin/ruby
+
+require File.dirname(__FILE__) + '/../config/environments/production'
+
+def create_controller_class(controller_class_name, controller_file_name, show_actions)
+  File.open("app/controllers/" + controller_file_name  + "_controller.rb", "w", 0777) do |controller_file|
+    controller_file.write <<EOF
+require 'abstract_application'
+require '#{controller_file_name}_helper'
+
+class #{controller_class_name}Controller < AbstractApplicationController
+  include #{controller_class_name}Helper
+
+#{show_actions.collect { |action| "  def #{action}\n  end" }.join "\n\n" }
+end
+EOF
+  end
+end
+
+def create_helper_class(controller_class_name, controller_file_name)
+  File.open("app/helpers/" + controller_file_name  + "_helper.rb", "w", 0777) do |helper_file|
+    helper_file.write <<EOF
+module #{controller_class_name}Helper
+  def self.append_features(controller) #:nodoc:
+    controller.ancestors.include?(ActionController::Base) ? controller.add_template_helper(self) : super
+  end
+end
+EOF
+  end
+end
+
+def create_templates(controller_class_name, controller_file_name, show_actions)
+  Dir.mkdir("app/views/#{controller_file_name}") rescue nil
+  show_actions.each { |action| File.open("app/views/#{controller_file_name}/#{action}.rhtml", "w", 0777) do |template_file|
+    template_file.write <<EOF
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <title>#{controller_class_name}##{action}</title>
+</head>   
+<body>
+<h1>#{controller_class_name}##{action}</h1>
+<p>Find me in app/views/#{controller_file_name}/#{action}.rhtml</p>
+</body>
+</html>
+EOF
+  end }
+end
+
+def create_test_class(controller_class_name, controller_file_name)
+  File.open("test/functional/" + controller_file_name + "_controller_test.rb", "w", 0777) do |test_file|
+    test_file.write <<EOF
+require File.dirname(__FILE__) + '/../test_helper'
+require '#{controller_file_name}_controller'
+
+# Raise errors beyond the default web-based presentation
+class #{controller_class_name}Controller; def rescue_action(e) raise e end; end
+
+class #{controller_class_name}ControllerTest < Test::Unit::TestCase
+  def setup
+    @controller = #{controller_class_name}Controller.new
+    @request, @response = ActionController::TestRequest.new, ActionController::TestResponse.new
+  end
+
+  def test_truth
+    assert true, "Test implementation missing"
+  end
+end
+EOF
+  end
+end
+
+
+if !ARGV.empty?
+  controller_name = ARGV[0]
+  show_actions    = ARGV[1..-1]
+  
+  controller_class_name = Inflector.camelize(controller_name)
+  controller_file_name  = Inflector.underscore(controller_name)
+  
+  create_controller_class(controller_class_name, controller_file_name, show_actions)
+  create_helper_class(controller_class_name, controller_file_name)
+  create_templates(controller_class_name, controller_file_name, show_actions)
+  create_test_class(controller_class_name, controller_file_name)
+else
+  puts <<-END_HELP
+
+NAME
+     new_controller - create controller and view stub files
+
+SYNOPSIS
+     new_controller [controller_name] [view_name ...]
+
+DESCRIPTION
+     The new_controller generator takes the name of the new controller as the
+     first argument and a variable number of view names as subsequent arguments.
+     The controller name should be supplied without a "Controller" suffix. The
+     generator will add that itself.
+     
+     From the passed arguments, new_controller generates a controller file in
+     app/controllers with a render action for each of the view names passed.
+     It then creates a controller test suite in test/functional with one failing
+     test case. Finally, it creates an HTML stub for each of the view names in
+     app/views under a directory with the same name as the controller.
+     
+EXAMPLE
+     new_controller Blog list display new edit
+     
+     This will generate a BlogController class in
+     app/controllers/blog_controller.rb, a BlogHelper class in
+     app/helpers/blog_helper.rb and a BlogControllerTest in
+     test/functional/blog_controller_test.rb. It will also create list.rhtml,
+     display.rhtml, new.rhtml, and edit.rhtml in app/views/blog.
+     
+     The BlogController class will have the following methods: list, display, new, edit.
+     Each will default to render the associated template file.
+END_HELP
+end