rails 0.13.1 → 0.14.1

data/lib/rails_version.rb

@@ -0,0 +1,9 @@
+module Rails
+  module Version #:nodoc:
+    MAJOR = 0
+    MINOR = 14
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/railties_path.rb

@@ -0,0 +1 @@
+RAILTIES_PATH = File.expand_path(File.dirname(__FILE__))

data/lib/rubyprof_ext.rb

@@ -1,6 +1,6 @@
 require 'prof'
 
-module Prof
+module Prof #:nodoc:
   # Adapted from Shugo Maeda's unprof.rb
   def self.print_profile(results, io = $stderr)
     total = results.detect { |i|

data/lib/tasks/databases.rake

@@ -0,0 +1,152 @@
+desc "Migrate the database according to the migrate scripts in db/migrate (only supported on PG/MySQL). A specific version can be targetted with VERSION=x"
+task :migrate => :environment do
+  ActiveRecord::Migrator.migrate("db/migrate/", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+  Rake::Task[:db_schema_dump].invoke if ActiveRecord::Base.schema_format == :ruby
+end
+
+desc "Load fixtures into the current environment's database"
+task :load_fixtures => :environment do
+  require 'active_record/fixtures'
+  ActiveRecord::Base.establish_connection(RAILS_ENV.to_sym)
+  Dir.glob(File.join(RAILS_ROOT, 'test', 'fixtures', '*.yml')).each do |fixture_file|
+    Fixtures.create_fixtures('test/fixtures', File.basename(fixture_file, '.*'))
+  end
+end
+
+desc "Create a db/schema.rb file that can be portably used against any DB supported by AR."
+task :db_schema_dump => :environment do
+  require 'active_record/schema_dumper'
+  File.open("db/schema.rb", "w") do |file|
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
+  end
+end
+
+desc "Import a schema.rb file into the database."
+task :db_schema_import => :environment do
+  file = ENV['SCHEMA'] || "db/schema.rb"
+  load file
+end
+
+desc "Recreate the test database from the current environment's database schema."
+task :clone_schema_to_test => :db_schema_dump do
+  ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
+  Rake::Task[:db_schema_import].invoke
+end
+
+desc "Dump the database structure to a SQL file"
+task :db_structure_dump => :environment do
+  abcs = ActiveRecord::Base.configurations
+  case abcs[RAILS_ENV]["adapter"] 
+    when "mysql", "oci"
+      ActiveRecord::Base.establish_connection(abcs[RAILS_ENV])
+      File.open("db/#{RAILS_ENV}_structure.sql", "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
+    when "postgresql"
+      ENV['PGHOST']     = abcs[RAILS_ENV]["host"] if abcs[RAILS_ENV]["host"]
+      ENV['PGPORT']     = abcs[RAILS_ENV]["port"].to_s if abcs[RAILS_ENV]["port"]
+      ENV['PGPASSWORD'] = abcs[RAILS_ENV]["password"].to_s if abcs[RAILS_ENV]["password"]
+      `pg_dump -U "#{abcs[RAILS_ENV]["username"]}" -s -x -O -f db/#{RAILS_ENV}_structure.sql #{abcs[RAILS_ENV]["database"]}`
+    when "sqlite", "sqlite3"
+      `#{abcs[RAILS_ENV]["adapter"]} #{abcs[RAILS_ENV]["dbfile"]} .schema > db/#{RAILS_ENV}_structure.sql`
+    when "sqlserver"
+      `scptxfr /s #{abcs[RAILS_ENV]["host"]} /d #{abcs[RAILS_ENV]["database"]} /I /f db\\#{RAILS_ENV}_structure.sql /q /A /r`
+      `scptxfr /s #{abcs[RAILS_ENV]["host"]} /d #{abcs[RAILS_ENV]["database"]} /I /F db\ /q /A /r`
+    else 
+      raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+  end
+  
+  if ActiveRecord::Base.connection.supports_migrations?
+    File.open("db/#{RAILS_ENV}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
+  end
+end
+
+desc "Recreate the test databases from the development structure"
+task :clone_structure_to_test => [ :db_structure_dump, :purge_test_database ] do
+  abcs = ActiveRecord::Base.configurations
+  case abcs["test"]["adapter"]
+    when  "mysql"
+      ActiveRecord::Base.establish_connection(:test)
+      ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
+      IO.readlines("db/#{RAILS_ENV}_structure.sql").join.split("\n\n").each do |table|
+        ActiveRecord::Base.connection.execute(table)
+      end
+    when "postgresql"
+      ENV['PGHOST']     = abcs["test"]["host"] if abcs["test"]["host"]
+      ENV['PGPORT']     = abcs["test"]["port"].to_s if abcs["test"]["port"]
+      ENV['PGPASSWORD'] = abcs["test"]["password"].to_s if abcs["test"]["password"]
+      `psql -U "#{abcs["test"]["username"]}" -f db/#{RAILS_ENV}_structure.sql #{abcs["test"]["database"]}`
+    when "sqlite", "sqlite3"
+      `#{abcs["test"]["adapter"]} #{abcs["test"]["dbfile"]} < db/#{RAILS_ENV}_structure.sql`
+    when "sqlserver"
+      `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{RAILS_ENV}_structure.sql`
+    when "oci", 
+      ActiveRecord::Base.establish_connection(:test)
+      IO.readlines("db/#{RAILS_ENV}_structure.sql").join.split(";\n\n").each do |ddl|
+        ActiveRecord::Base.connection.execute(ddl)
+      end
+    else 
+      raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+  end
+end
+
+desc "Empty the test database"
+task :purge_test_database => :environment do
+  abcs = ActiveRecord::Base.configurations
+  case abcs["test"]["adapter"]
+    when "mysql"
+      ActiveRecord::Base.establish_connection(:test)
+      ActiveRecord::Base.connection.recreate_database(abcs["test"]["database"])
+    when "postgresql"
+      ENV['PGHOST']     = abcs["test"]["host"] if abcs["test"]["host"]
+      ENV['PGPORT']     = abcs["test"]["port"].to_s if abcs["test"]["port"]
+      ENV['PGPASSWORD'] = abcs["test"]["password"].to_s if abcs["test"]["password"]
+      `dropdb -U "#{abcs["test"]["username"]}" #{abcs["test"]["database"]}`
+      `createdb -T template0 -U "#{abcs["test"]["username"]}" #{abcs["test"]["database"]}`
+    when "sqlite","sqlite3"
+      File.delete(abcs["test"]["dbfile"]) if File.exist?(abcs["test"]["dbfile"])
+    when "sqlserver"
+      dropfkscript = "#{abcs["test"]["host"]}.#{abcs["test"]["database"]}.DP1".gsub(/\\/,'-')
+      `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{dropfkscript}`
+      `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{RAILS_ENV}_structure.sql`
+    when "oci"
+      ActiveRecord::Base.establish_connection(:test)
+      ActiveRecord::Base.connection.structure_drop.split(";\n\n").each do |ddl|
+        ActiveRecord::Base.connection.execute(ddl)
+      end
+    else
+      raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+  end
+end
+
+def prepare_test_database_task
+  {:sql  => :clone_structure_to_test, 
+   :ruby => :clone_schema_to_test}[ActiveRecord::Base.schema_format]
+end
+
+desc 'Prepare the test database and load the schema'
+task :prepare_test_database => :environment do
+  Rake::Task[prepare_test_database_task].invoke
+end
+
+desc "Creates a sessions table for use with CGI::Session::ActiveRecordStore"
+task :create_sessions_table => :environment do
+  raise "Task unavailable to this database (no migration support)" unless ActiveRecord::Base.connection.supports_migrations?
+
+  ActiveRecord::Base.connection.create_table :sessions do |t|
+    t.column :session_id, :string
+    t.column :data, :text
+    t.column :updated_at, :datetime
+  end
+  
+  ActiveRecord::Base.connection.add_index :sessions, :session_id
+end
+
+desc "Drop the sessions table"
+task :drop_sessions_table => :environment do
+  raise "Task unavailable to this database (no migration support)" unless ActiveRecord::Base.connection.supports_migrations?
+  
+  ActiveRecord::Base.connection.drop_table :sessions
+end
+
+desc "Drop and recreate the session table (much faster than 'DELETE * FROM sessions')"
+task :purge_sessions_table => [ :drop_sessions_table, :create_sessions_table ] do
+end

data/lib/tasks/documentation.rake

@@ -0,0 +1,44 @@
+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.template = "#{ENV['template']}.rb" if ENV['template']
+  rdoc.title    = "Rails Framework Documentation"
+  rdoc.options << '--line-numbers --inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('CHANGELOG')
+  rdoc.rdoc_files.include('vendor/rails/railties/CHANGELOG')
+  rdoc.rdoc_files.include('vendor/rails/railties/MIT-LICENSE')
+  rdoc.rdoc_files.include('vendor/rails/activerecord/README')
+  rdoc.rdoc_files.include('vendor/rails/activerecord/CHANGELOG')
+  rdoc.rdoc_files.include('vendor/rails/activerecord/lib/active_record/**/*.rb')
+  rdoc.rdoc_files.exclude('vendor/rails/activerecord/lib/active_record/vendor/*')
+  rdoc.rdoc_files.include('vendor/rails/actionpack/README')
+  rdoc.rdoc_files.include('vendor/rails/actionpack/CHANGELOG')
+  rdoc.rdoc_files.include('vendor/rails/actionpack/lib/action_controller/**/*.rb')
+  rdoc.rdoc_files.include('vendor/rails/actionpack/lib/action_view/**/*.rb')
+  rdoc.rdoc_files.include('vendor/rails/actionmailer/README')
+  rdoc.rdoc_files.include('vendor/rails/actionmailer/CHANGELOG')
+  rdoc.rdoc_files.include('vendor/rails/actionmailer/lib/action_mailer/base.rb')
+  rdoc.rdoc_files.include('vendor/rails/actionwebservice/README')
+  rdoc.rdoc_files.include('vendor/rails/actionwebservice/CHANGELOG')
+  rdoc.rdoc_files.include('vendor/rails/actionwebservice/lib/action_web_service.rb')
+  rdoc.rdoc_files.include('vendor/rails/actionwebservice/lib/action_web_service/*.rb')
+  rdoc.rdoc_files.include('vendor/rails/actionwebservice/lib/action_web_service/api/*.rb')
+  rdoc.rdoc_files.include('vendor/rails/actionwebservice/lib/action_web_service/client/*.rb')
+  rdoc.rdoc_files.include('vendor/rails/actionwebservice/lib/action_web_service/container/*.rb')
+  rdoc.rdoc_files.include('vendor/rails/actionwebservice/lib/action_web_service/dispatcher/*.rb')
+  rdoc.rdoc_files.include('vendor/rails/actionwebservice/lib/action_web_service/protocol/*.rb')
+  rdoc.rdoc_files.include('vendor/rails/actionwebservice/lib/action_web_service/support/*.rb')
+  rdoc.rdoc_files.include('vendor/rails/activesupport/README')
+  rdoc.rdoc_files.include('vendor/rails/activesupport/CHANGELOG')
+  rdoc.rdoc_files.include('vendor/rails/activesupport/lib/active_support/**/*.rb')
+}

data/lib/tasks/framework.rake

@@ -0,0 +1,33 @@
+desc "Lock this application to the current gems (by unpacking them into vendor/rails)"
+task :freeze_gems do
+  rm_rf   "vendor/rails"
+  mkdir_p "vendor/rails"
+  
+  for gem in %w( actionpack activerecord actionmailer activesupport actionwebservice )
+    system "cd vendor/rails; gem unpack #{gem}"
+    FileUtils.mv(Dir.glob("vendor/rails/#{gem}*").first, "vendor/rails/#{gem}")
+  end
+  
+  system "cd vendor/rails; gem unpack rails"
+  FileUtils.mv(Dir.glob("vendor/rails/rails*").first, "vendor/rails/railties")
+end
+
+desc "Lock this application to the Edge Rails (by exporting from Subversion)"
+task :freeze_edge do
+  $stderr.close
+  svn_available = `svn --version`.size > 0
+  raise "Subversion is not installed" unless svn_available
+
+  rm_rf   "vendor/rails"
+  mkdir_p "vendor/rails"
+  
+  for framework in %w( railties actionpack activerecord actionmailer activesupport actionwebservice )
+    mkdir_p "vendor/rails/#{framework}"
+    system  "svn export http://dev.rubyonrails.org/svn/rails/trunk/#{framework}/lib vendor/rails/#{framework}/lib"
+  end
+end
+
+desc "Unlock this application from freeze of gems or edge and return to a fluid use of system gems"
+task :unfreeze_rails do
+  rm_rf "vendor/rails"
+end

data/lib/tasks/javascripts.rake

@@ -0,0 +1,6 @@
+
+desc "Update your javascripts from your current rails install."
+task :update_javascripts do 
+  require 'railties_path'  
+  FileUtils.cp(Dir[RAILTIES_PATH + '/../html/javascripts/*.js'], RAILS_ROOT + '/public/javascripts/')
+end

data/lib/tasks/misc.rake

@@ -0,0 +1,15 @@
+desc "Run all the tests on a fresh test database"
+task :default => [ :test_units, :test_functional ]
+
+task :environment do
+  require(File.join(RAILS_ROOT, 'config', 'environment'))
+end
+
+
+desc "Clears all *.log files in log/"
+task :clear_logs do
+  FileList["log/*.log"].each do |log_file|
+    f = File.open(log_file, "w")
+    f.close
+  end
+end

data/lib/tasks/rails.rb

@@ -0,0 +1,7 @@
+$VERBOSE = nil
+
+# Load Rails rakefile extensions
+Dir["#{File.dirname(__FILE__)}/*.rake"].each { |ext| load ext }
+
+# Load any custom rakefile extensions
+Dir["./lib/tasks/**/*.rake"].each { |ext| load ext }

data/lib/tasks/statistics.rake

@@ -0,0 +1,16 @@
+STATS_DIRECTORIES = [
+  %w(Helpers           app/helpers), 
+  %w(Controllers       app/controllers), 
+  %w(APIs              app/apis),
+  %w(Components        components),
+  %w(Functional\ tests test/functional),
+  %w(Models            app/models),
+  %w(Unit\ tests       test/unit),
+  %w(Libraries         lib/)
+].collect { |name, dir| [ name, "#{RAILS_ROOT}/#{dir}" ] }.select { |name, dir| File.directory?(dir) }
+
+desc "Report code statistics (KLOCs, etc) from the application"
+task :stats do
+  require 'code_statistics'
+  CodeStatistics.new(*STATS_DIRECTORIES).to_s
+end

data/lib/tasks/testing.rake

@@ -0,0 +1,37 @@
+TEST_CHANGES_SINCE = Time.now - 600
+
+# Look up tests for recently modified sources.
+def recent_tests(source_pattern, test_path, touched_since = 10.minutes.ago)
+  FileList[source_pattern].map do |path|
+    if File.mtime(path) > touched_since
+      test = "#{test_path}/#{File.basename(path, '.rb')}_test.rb"
+      test if File.exists?(test)
+    end
+  end.compact
+end
+
+desc 'Test recent changes'
+Rake::TestTask.new(:recent => [ :prepare_test_database ]) do |t|
+  since = TEST_CHANGES_SINCE
+  touched = FileList['test/**/*_test.rb'].select { |path| File.mtime(path) > since } +
+    recent_tests('app/models/*.rb', 'test/unit', since) +
+    recent_tests('app/controllers/*.rb', 'test/functional', since)
+
+  t.libs << 'test'
+  t.verbose = true
+  t.test_files = touched.uniq
+end
+
+desc "Run the unit tests in test/unit"
+Rake::TestTask.new(:test_units => [ :prepare_test_database ]) do |t|
+  t.libs << "test"
+  t.pattern = 'test/unit/**/*_test.rb'
+  t.verbose = true
+end
+
+desc "Run the functional tests in test/functional"
+Rake::TestTask.new(:test_functional => [ :prepare_test_database ]) do |t|
+  t.libs << "test"
+  t.pattern = 'test/functional/**/*_test.rb'
+  t.verbose = true
+end

data/lib/test_help.rb

@@ -0,0 +1,13 @@
+require 'application'
+
+require 'test/unit'
+require 'active_record/fixtures'
+require 'action_controller/test_process'
+require 'action_web_service/test_invoke'
+require 'breakpoint'
+
+Test::Unit::TestCase.fixture_path = RAILS_ROOT + "/test/fixtures/"
+
+def create_fixtures(*table_names)
+  Fixtures.create_fixtures(RAILS_ROOT + "/test/fixtures", table_names)
+end

data/lib/webrick_server.rb

@@ -10,7 +10,7 @@ ABSOLUTE_RAILS_ROOT = File.expand_path(RAILS_ROOT)
 
 ActiveRecord::Base.threaded_connections = false
 
-class CGI
+class CGI #:nodoc:
   def stdinput
     @stdin || $stdin
   end
@@ -40,13 +40,25 @@ class CGI
   end
 end
 
+# A custom dispatch servlet for use with WEBrick. It dispatches requests
+# (using the Rails Dispatcher) to the appropriate controller/action. By default,
+# it restricts WEBrick to a managing a single Rails request at a time, but you
+# can change this behavior by setting ActionController::Base.allow_concurrency
+# to true.
 class DispatchServlet < WEBrick::HTTPServlet::AbstractServlet
   REQUEST_MUTEX = Mutex.new
 
+  # Start the WEBrick server with the given options, mounting the
+  # DispatchServlet at <tt>/</tt>.
   def self.dispatch(options = {})
     Socket.do_not_reverse_lookup = true # patch for OS X
 
-    server = WEBrick::HTTPServer.new(:Port => options[:port].to_i, :ServerType => options[:server_type], :BindAddress => options[:ip])
+    params = { :Port        => options[:port].to_i,
+               :ServerType  => options[:server_type],
+               :BindAddress => options[:ip] }
+    params[:MimeTypes] = options[:mime_types] if options[:mime_types]
+
+    server = WEBrick::HTTPServer.new(params)
     server.mount('/', DispatchServlet, options)
 
     trap("INT") { server.shutdown }
@@ -57,14 +69,14 @@ class DispatchServlet < WEBrick::HTTPServlet::AbstractServlet
     server.start
   end
 
-  def initialize(server, options)
+  def initialize(server, options) #:nodoc:
     @server_options = options
     @file_handler = WEBrick::HTTPServlet::FileHandler.new(server, options[:server_root])
     Dir.chdir(ABSOLUTE_RAILS_ROOT)
     super
   end
 
-  def service(req, res)
+  def service(req, res) #:nodoc:
     begin
       unless handle_file(req, res)
         REQUEST_MUTEX.lock unless ActionController::Base.allow_concurrency
@@ -79,7 +91,7 @@ class DispatchServlet < WEBrick::HTTPServlet::AbstractServlet
     end
   end
 
-  def handle_file(req, res)
+  def handle_file(req, res) #:nodoc:
     begin
       req = req.dup
       path = req.path.dup
@@ -89,8 +101,8 @@ class DispatchServlet < WEBrick::HTTPServlet::AbstractServlet
       path.gsub!('+', ' ') # Unescape + since FileHandler doesn't do so.
 
       req.instance_variable_set(:@path_info, path) # Set the modified path...
-      
-      @file_handler.send(:service, req, res)
+
+      @file_handler.send(:service, req, res)      
       return true
     rescue HTTPStatus::PartialContent, HTTPStatus::NotModified => err
       res.set_error(err)
@@ -100,7 +112,7 @@ class DispatchServlet < WEBrick::HTTPServlet::AbstractServlet
     end
   end
 
-  def handle_dispatch(req, res, origin = nil)    
+  def handle_dispatch(req, res, origin = nil) #:nodoc:
     data = StringIO.new
     Dispatcher.dispatch(
       CGI.new("query", create_env_table(req, origin), StringIO.new(req.body || "")), 
@@ -109,8 +121,10 @@ class DispatchServlet < WEBrick::HTTPServlet::AbstractServlet
     )
 
     header, body = extract_header_and_body(data)
+
+    set_charset(header)
     assign_status(res, header)
-    res.cookies.concat(header.delete('set-cookie'))
+    res.cookies.concat(header.delete('set-cookie') || [])
     header.each { |key, val| res[key] = val.join(", ") }
     
     res.body = body
@@ -138,6 +152,14 @@ class DispatchServlet < WEBrick::HTTPServlet::AbstractServlet
       
       return header, body
     end
+    
+    def set_charset(header)
+      ct = header["content-type"]
+      if ct.any? { |x| x =~ /^text\// } && ! ct.any? { |x| x =~ /charset=/ }
+        ch = @server_options[:charset] || "UTF-8"
+        ct.find { |x| x =~ /^text\// } << ("; charset=" + ch)
+      end
+    end
 
     def assign_status(res, header)
       if /^(\d+)/ =~ header['status'][0]