railties 3.0.0.beta

data/lib/rails/tasks/framework.rake

@@ -0,0 +1,69 @@
+namespace :rails do
+  namespace :freeze do
+    desc "The rails:freeze:gems is deprecated, please use bundle install instead"
+    task :gems do
+      puts "The rails:freeze:gems is deprecated, please use bundle install instead"
+    end
+
+    desc 'The freeze:edge command has been deprecated, specify the path setting in your app Gemfile instead and bundle install'
+    task :edge do
+      puts 'The freeze:edge command has been deprecated, specify the path setting in your app Gemfile instead and bundle install'
+    end
+  end
+
+  desc 'The unfreeze command has been deprecated, please use bundler commands instead'
+  task :unfreeze do
+    puts 'The unfreeze command has been deprecated, please use bundler commands instead'
+  end
+
+  desc "Update both configs, scripts and public/javascripts from Rails"
+  task :update => [ "update:configs", "update:javascripts", "update:scripts", "update:application_controller" ]
+
+  desc "Applies the template supplied by LOCATION=/path/to/template"
+  task :template do
+    template = ENV["LOCATION"]
+    template = File.expand_path(template) if template !~ %r{\A[A-Za-z][A-Za-z0-9+\-\.]*://}
+
+    require 'rails/generators'
+    require 'generators/rails/app/app_generator'
+    generator = Rails::Generators::AppGenerator.new [ Rails.root ], {}, :destination_root => Rails.root
+    generator.apply template, :verbose => false
+  end
+
+  namespace :update do
+    def invoke_from_app_generator(method)
+      require 'rails/generators'
+      require 'generators/rails/app/app_generator'
+
+      generator = Rails::Generators::AppGenerator.new ["rails"], { :with_dispatchers => true },
+                                                      :destination_root => Rails.root
+      generator.invoke(method)
+    end
+
+    desc "Update config/boot.rb from your current rails install"
+    task :configs do
+      invoke_from_app_generator :create_boot_file
+      invoke_from_app_generator :create_config_files
+    end
+
+    desc "Update Prototype javascripts from your current rails install"
+    task :javascripts do
+      invoke_from_app_generator :create_prototype_files
+    end
+
+    desc "Adds new scripts to the application script/ directory"
+    task :scripts do
+      invoke_from_app_generator :create_script_files
+    end
+
+    desc "Rename application.rb to application_controller.rb"
+    task :application_controller do
+      old_style = Rails.root + '/app/controllers/application.rb'
+      new_style = Rails.root + '/app/controllers/application_controller.rb'
+      if File.exists?(old_style) && !File.exists?(new_style)
+        FileUtils.mv(old_style, new_style)
+        puts "#{old_style} has been renamed to #{new_style}, update your SCM as necessary"
+      end
+    end
+  end
+end

data/lib/rails/tasks/log.rake

@@ -0,0 +1,9 @@
+namespace :log do
+  desc "Truncates all *.log files in log/ to zero bytes"
+  task :clear do
+    FileList["log/*.log"].each do |log_file|
+      f = File.open(log_file, "w")
+      f.close
+    end
+  end
+end

data/lib/rails/tasks/middleware.rake

@@ -0,0 +1,7 @@
+desc 'Prints out your Rack middleware stack'
+task :middleware => :environment do
+  Rails.configuration.middleware.active.each do |middleware|
+    puts "use #{middleware.inspect}"
+  end
+  puts "run #{Rails::Application.instance.class.name}.routes"
+end

data/lib/rails/tasks/misc.rake

@@ -0,0 +1,71 @@
+task :default => :test
+
+task :rails_env do
+  # TODO Do we really need this?
+  unless defined? RAILS_ENV
+    RAILS_ENV = ENV['RAILS_ENV'] ||= 'development'
+  end
+end
+
+desc 'Generate a crytographically secure secret key. This is typically used to generate a secret for cookie sessions.'
+task :secret do
+  require 'active_support/secure_random'
+  puts ActiveSupport::SecureRandom.hex(64)
+end
+
+desc 'Explain the current environment'
+task :about do
+  $LOAD_PATH.unshift "#{RAILTIES_PATH}/builtin/rails_info"
+  require 'rails/info'
+  puts Rails::Info
+end
+
+namespace :time do
+  namespace :zones do
+    desc 'Displays names of all time zones recognized by the Rails TimeZone class, grouped by offset. Results can be filtered with optional OFFSET parameter, e.g., OFFSET=-6'
+    task :all do
+      build_time_zone_list(:all)
+    end
+    
+    desc 'Displays names of US time zones recognized by the Rails TimeZone class, grouped by offset. Results can be filtered with optional OFFSET parameter, e.g., OFFSET=-6'
+    task :us do
+      build_time_zone_list(:us_zones)
+    end
+    
+    desc 'Displays names of time zones recognized by the Rails TimeZone class with the same offset as the system local time'
+    task :local do
+      require 'active_support'
+      require 'active_support/time'
+      jan_offset = Time.now.beginning_of_year.utc_offset
+      jul_offset = Time.now.beginning_of_year.change(:month => 7).utc_offset
+      offset = jan_offset < jul_offset ? jan_offset : jul_offset
+      build_time_zone_list(:all, offset)
+    end
+    
+    # to find UTC -06:00 zones, OFFSET can be set to either -6, -6:00 or 21600
+    def build_time_zone_list(method, offset = ENV['OFFSET'])
+      require 'active_support'
+      require 'active_support/time'
+      if offset
+        offset = if offset.to_s.match(/(\+|-)?(\d+):(\d+)/)
+          sign = $1 == '-' ? -1 : 1
+          hours, minutes = $2.to_f, $3.to_f
+          ((hours * 3600) + (minutes.to_f * 60)) * sign
+        elsif offset.to_f.abs <= 13
+          offset.to_f * 3600
+        else
+          offset.to_f
+        end
+      end
+      previous_offset = nil
+      ActiveSupport::TimeZone.__send__(method).each do |zone|
+        if offset.nil? || offset == zone.utc_offset
+          puts "\n* UTC #{zone.formatted_offset} *" unless zone.utc_offset == previous_offset
+          puts zone.name
+          previous_offset = zone.utc_offset
+        end
+      end
+      puts "\n"
+    end
+  end
+end

data/lib/rails/tasks/routes.rake

@@ -0,0 +1,17 @@
+desc 'Print out all defined routes in match order, with names. Target specific controller with CONTROLLER=x.'
+task :routes => :environment do
+  Rails::Application.reload_routes!
+  all_routes = ENV['CONTROLLER'] ? ActionController::Routing::Routes.routes.select { |route| route.defaults[:controller] == ENV['CONTROLLER'] } : ActionController::Routing::Routes.routes
+  routes = all_routes.collect do |route|
+    name = ActionController::Routing::Routes.named_routes.routes.index(route).to_s
+    reqs = route.requirements.empty? ? "" : route.requirements.inspect
+    {:name => name, :verb => route.verb.to_s, :path => route.path, :reqs => reqs}
+  end
+  routes.reject!{ |r| r[:path] == "/rails/info/properties" } # skip the route if it's internal info route
+  name_width = routes.collect {|r| r[:name]}.collect {|n| n.length}.max
+  verb_width = routes.collect {|r| r[:verb]}.collect {|v| v.length}.max
+  path_width = routes.collect {|r| r[:path]}.collect {|s| s.length}.max
+  routes.each do |r|
+    puts "#{r[:name].rjust(name_width)} #{r[:verb].ljust(verb_width)} #{r[:path].ljust(path_width)} #{r[:reqs]}"
+  end
+end

data/lib/rails/tasks/statistics.rake

@@ -0,0 +1,16 @@
+STATS_DIRECTORIES = [
+  %w(Controllers        app/controllers),
+  %w(Helpers            app/helpers),
+  %w(Models             app/models),
+  %w(Libraries          lib/),
+  %w(APIs               app/apis),
+  %w(Integration\ tests test/integration),
+  %w(Functional\ tests  test/functional),
+  %w(Unit\ tests        test/unit)
+].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 'rails/code_statistics'
+  CodeStatistics.new(*STATS_DIRECTORIES).to_s
+end

data/lib/rails/tasks/tmp.rake

@@ -0,0 +1,37 @@
+namespace :tmp do
+  desc "Clear session, cache, and socket files from tmp/"
+  task :clear => [ "tmp:sessions:clear",  "tmp:cache:clear", "tmp:sockets:clear"]
+
+  desc "Creates tmp directories for sessions, cache, sockets, and pids"
+  task :create do
+    FileUtils.mkdir_p(%w( tmp/sessions tmp/cache tmp/sockets tmp/pids ))
+  end
+
+  namespace :sessions do
+    desc "Clears all files in tmp/sessions"
+    task :clear do
+      FileUtils.rm(Dir['tmp/sessions/[^.]*'])
+    end
+  end
+
+  namespace :cache do
+    desc "Clears all files and directories in tmp/cache"
+    task :clear do
+      FileUtils.rm_rf(Dir['tmp/cache/[^.]*'])
+    end
+  end
+
+  namespace :sockets do
+    desc "Clears all files in tmp/sockets"
+    task :clear do
+      FileUtils.rm(Dir['tmp/sockets/[^.]*'])
+    end
+  end
+
+  namespace :pids do
+    desc "Clears all files in tmp/pids"
+    task :clear do
+      FileUtils.rm(Dir['tmp/pids/[^.]*'])
+    end
+  end
+end

data/lib/rails/test_help.rb

@@ -0,0 +1,30 @@
+# Make double-sure the RAILS_ENV is set to test,
+# so fixtures are loaded to the right database
+exit("Abort testing: Your Rails environment is not running in test mode!") unless Rails.env.test?
+
+require 'test/unit'
+require 'active_support/core_ext/kernel/requires'
+
+if defined?(ActiveRecord)
+  class ActiveSupport::TestCase
+    include ActiveRecord::TestFixtures
+    self.fixture_path = "#{Rails.root}/test/fixtures/"
+  end
+
+  ActionController::IntegrationTest.fixture_path = ActiveSupport::TestCase.fixture_path
+
+  def create_fixtures(*table_names, &block)
+    Fixtures.create_fixtures(ActiveSupport::TestCase.fixture_path, table_names, {}, &block)
+  end
+end
+
+begin
+  require_library_or_gem 'ruby-debug'
+  Debugger.start
+  if Debugger.respond_to?(:settings)
+    Debugger.settings[:autoeval] = true
+    Debugger.settings[:autolist] = 1
+  end
+rescue LoadError
+  # ruby-debug wasn't available so neither can the debugging be
+end

data/lib/rails/test_unit/railtie.rb

@@ -0,0 +1,17 @@
+module Rails
+  class TestUnitRailtie < Rails::Railtie
+    railtie_name :test_unit
+
+    config.generators do |c|
+      c.test_framework :test_unit, :fixture => true,
+                                   :fixture_replacement => nil
+
+      c.integration_tool :test_unit
+      c.performance_tool :test_unit
+    end
+
+    rake_tasks do
+      load "rails/test_unit/testing.rake"
+    end
+  end
+end

data/lib/rails/test_unit/testing.rake

@@ -0,0 +1,130 @@
+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
+      tests = []
+      source_dir = File.dirname(path).split("/")
+      source_file = File.basename(path, '.rb')
+
+      # Support subdirs in app/models and app/controllers
+      modified_test_path = source_dir.length > 2 ? "#{test_path}/" << source_dir[1..source_dir.length].join('/') : test_path
+
+      # For modified files in app/ run the tests for it. ex. /test/functional/account_controller.rb
+      test = "#{modified_test_path}/#{source_file}_test.rb"
+      tests.push test if File.exist?(test)
+
+      # For modified files in app, run tests in subdirs too. ex. /test/functional/account/*_test.rb
+      test = "#{modified_test_path}/#{File.basename(path, '.rb').sub("_controller","")}"
+      FileList["#{test}/*_test.rb"].each { |f| tests.push f } if File.exist?(test)
+
+      return tests
+
+    end
+  end.flatten.compact
+end
+
+
+# Recreated here from ActiveSupport because :uncommitted needs it before Rails is available
+module Kernel
+  def silence_stderr
+    old_stderr = STDERR.dup
+    STDERR.reopen(RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'NUL:' : '/dev/null')
+    STDERR.sync = true
+    yield
+  ensure
+    STDERR.reopen(old_stderr)
+  end
+end
+
+desc 'Run all unit, functional and integration tests'
+task :test do
+  errors = %w(test:units test:functionals test:integration).collect do |task|
+    begin
+      Rake::Task[task].invoke
+      nil
+    rescue => e
+      task
+    end
+  end.compact
+  abort "Errors running #{errors * ', '}!" if errors.any?
+end
+
+namespace :test do
+  Rake::TestTask.new(:recent => "db:test:prepare") 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.test_files = touched.uniq
+  end
+  Rake::Task['test:recent'].comment = "Test recent changes"
+
+  Rake::TestTask.new(:uncommitted => "db:test:prepare") do |t|
+    def t.file_list
+      if File.directory?(".svn")
+        changed_since_checkin = silence_stderr { `svn status` }.map { |path| path.chomp[7 .. -1] }
+      elsif File.directory?(".git")
+        changed_since_checkin = silence_stderr { `git ls-files --modified --others` }.map { |path| path.chomp }
+      else
+        abort "Not a Subversion or Git checkout."
+      end
+
+      models      = changed_since_checkin.select { |path| path =~ /app[\\\/]models[\\\/].*\.rb$/ }
+      controllers = changed_since_checkin.select { |path| path =~ /app[\\\/]controllers[\\\/].*\.rb$/ }
+
+      unit_tests       = models.map { |model| "test/unit/#{File.basename(model, '.rb')}_test.rb" }
+      functional_tests = controllers.map { |controller| "test/functional/#{File.basename(controller, '.rb')}_test.rb" }
+
+      unit_tests.uniq + functional_tests.uniq
+    end
+
+    t.libs << 'test'
+  end
+  Rake::Task['test:uncommitted'].comment = "Test changes since last checkin (only Subversion and Git)"
+
+  Rake::TestTask.new(:units => "db:test:prepare") do |t|
+    t.libs << "test"
+    t.pattern = 'test/unit/**/*_test.rb'
+  end
+  Rake::Task['test:units'].comment = "Run the unit tests in test/unit"
+
+  Rake::TestTask.new(:functionals => "db:test:prepare") do |t|
+    t.libs << "test"
+    t.pattern = 'test/functional/**/*_test.rb'
+  end
+  Rake::Task['test:functionals'].comment = "Run the functional tests in test/functional"
+
+  Rake::TestTask.new(:integration => "db:test:prepare") do |t|
+    t.libs << "test"
+    t.pattern = 'test/integration/**/*_test.rb'
+  end
+  Rake::Task['test:integration'].comment = "Run the integration tests in test/integration"
+
+  Rake::TestTask.new(:benchmark => 'db:test:prepare') do |t|
+    t.libs << 'test'
+    t.pattern = 'test/performance/**/*_test.rb'
+    t.options = '-- --benchmark'
+  end
+  Rake::Task['test:benchmark'].comment = 'Benchmark the performance tests'
+
+  Rake::TestTask.new(:profile => 'db:test:prepare') do |t|
+    t.libs << 'test'
+    t.pattern = 'test/performance/**/*_test.rb'
+  end
+  Rake::Task['test:profile'].comment = 'Profile the performance tests'
+
+  Rake::TestTask.new(:plugins => :environment) do |t|
+    t.libs << "test"
+
+    if ENV['PLUGIN']
+      t.pattern = "vendor/plugins/#{ENV['PLUGIN']}/test/**/*_test.rb"
+    else
+      t.pattern = 'vendor/plugins/*/**/test/**/*_test.rb'
+    end
+  end
+  Rake::Task['test:plugins'].comment = "Run the plugin tests in vendor/plugins/*/**/test (or specify with PLUGIN=name)"
+end

data/lib/rails/version.rb

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

data/lib/rails/webrick_server.rb

@@ -0,0 +1,156 @@
+# Donated by Florian Gross
+
+require 'webrick'
+require 'cgi'
+require 'stringio'
+require 'dispatcher'
+
+include WEBrick
+
+class CGI #:nodoc:
+  def stdinput
+    @stdin || $stdin
+  end
+  
+  def env_table
+    @env_table || ENV
+  end
+  
+  def initialize(type = "query", table = nil, stdin = nil)
+    @env_table, @stdin = table, stdin
+
+    if defined?(MOD_RUBY) && !ENV.key?("GATEWAY_INTERFACE")
+      Apache.request.setup_cgi_env
+    end
+
+    extend QueryExtension
+    @multipart = false
+    if defined?(CGI_PARAMS)
+      warn "do not use CGI_PARAMS and CGI_COOKIES"
+      @params = CGI_PARAMS.dup
+      @cookies = CGI_COOKIES.dup
+    else
+      initialize_query()  # set @params, @cookies
+    end
+    @output_cookies = nil
+    @output_hidden = nil
+  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
+  # 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
+
+    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 }
+    server.start
+  end
+
+  def initialize(server, options) #:nodoc:
+    @server_options = options
+    @file_handler = WEBrick::HTTPServlet::FileHandler.new(server, options[:server_root])
+    # Change to the RAILS_ROOT, since Webrick::Daemon.start does a Dir::cwd("/")
+    # OPTIONS['working_directory'] is an absolute path of the RAILS_ROOT, set in railties/lib/commands/servers/webrick.rb
+    Dir.chdir(OPTIONS['working_directory']) if defined?(OPTIONS) && File.directory?(OPTIONS['working_directory'])
+    super
+  end
+
+  def service(req, res) #:nodoc:
+    unless handle_file(req, res)
+      unless handle_dispatch(req, res)
+        raise WEBrick::HTTPStatus::NotFound, "`#{req.path}' not found."
+      end
+    end
+  end
+
+  def handle_file(req, res) #:nodoc:
+    begin
+      req = req.dup
+      path = req.path.dup
+
+      # Add .html if the last path piece has no . in it
+      path << '.html' if path != '/' && (%r{(^|/)[^./]+$} =~ path) 
+      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)      
+      return true
+    rescue HTTPStatus::PartialContent, HTTPStatus::NotModified => err
+      res.set_error(err)
+      return true
+    rescue => err
+      return false
+    end
+  end
+
+  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 || "")), 
+      ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, 
+      data
+    )
+
+    header, body = extract_header_and_body(data)
+
+    set_charset(header)
+    assign_status(res, header)
+    res.cookies.concat(header.delete('set-cookie') || [])
+    header.each { |key, val| res[key] = val.join(", ") }
+    
+    res.body = body
+    return true
+  rescue => err
+    p err, err.backtrace
+    return false
+  end
+  
+  private
+    def create_env_table(req, origin)
+      env = req.meta_vars.clone
+      env.delete "SCRIPT_NAME"
+      env["QUERY_STRING"] = req.request_uri.query
+      env["REQUEST_URI"]  = origin if origin
+      return env
+    end
+    
+    def extract_header_and_body(data)
+      data.rewind
+      data = data.read
+
+      raw_header, body = *data.split(/^[\xd\xa]{2}/on, 2)
+      header = WEBrick::HTTPUtils::parse_header(raw_header)
+      
+      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]
+        res.status = $1.to_i
+        header.delete('status')
+      end
+    end
+end