railties 4.0.13 → 4.1.0.beta1

data/lib/rails/application/configuration.rb

@@ -61,7 +61,6 @@ module Rails
         @assets.cache_store              = [ :file_store, "#{root}/tmp/cache/assets/#{Rails.env}/" ]
         @assets.js_compressor            = nil
         @assets.css_compressor           = nil
-        @assets.initialize_on_precompile = true
         @assets.logger                   = nil
       end
 
@@ -77,6 +76,7 @@ module Rails
         @paths ||= begin
           paths = super
           paths.add "config/database",    with: "config/database.yml"
+          paths.add "config/secrets",     with: "config/secrets.yml"
           paths.add "config/environment", with: "config/environment.rb"
           paths.add "lib/templates"
           paths.add "log",                with: "log/#{Rails.env}.log"
@@ -88,16 +88,6 @@ module Rails
         end
       end
 
-      def threadsafe!
-        message = "config.threadsafe! is deprecated. Rails applications " \
-                  "behave by default as thread safe in production as long as config.cache_classes and " \
-                  "config.eager_load are set to true"
-        ActiveSupport::Deprecation.warn message
-        @cache_classes = true
-        @eager_load = true
-        self
-      end
-
       # Loads and returns the configuration of the database.
       def database_configuration
         yaml = paths["config/database"].first
@@ -151,9 +141,6 @@ module Rails
         end
       end
 
-      def whiny_nils=(*)
-        ActiveSupport::Deprecation.warn "config.whiny_nils option is deprecated and no longer works"
-      end
     end
   end
 end

data/lib/rails/application/default_middleware_stack.rb

@@ -0,0 +1,99 @@
+module Rails
+  class Application
+    class DefaultMiddlewareStack
+      attr_reader :config, :paths, :app
+
+      def initialize(app, config, paths)
+        @app = app
+        @config = config
+        @paths = paths
+      end
+
+      def build_stack
+        ActionDispatch::MiddlewareStack.new.tap do |middleware|
+          if config.force_ssl
+            middleware.use ::ActionDispatch::SSL, config.ssl_options
+          end
+
+          middleware.use ::Rack::Sendfile, config.action_dispatch.x_sendfile_header
+
+          if config.serve_static_assets
+            middleware.use ::ActionDispatch::Static, paths["public"].first, config.static_cache_control
+          end
+
+          if rack_cache = load_rack_cache
+            require "action_dispatch/http/rack_cache"
+            middleware.use ::Rack::Cache, rack_cache
+          end
+
+          middleware.use ::Rack::Lock unless allow_concurrency?
+          middleware.use ::Rack::Runtime
+          middleware.use ::Rack::MethodOverride
+          middleware.use ::ActionDispatch::RequestId
+
+          # Must come after Rack::MethodOverride to properly log overridden methods
+          middleware.use ::Rails::Rack::Logger, config.log_tags
+          middleware.use ::ActionDispatch::ShowExceptions, show_exceptions_app
+          middleware.use ::ActionDispatch::DebugExceptions, app
+          middleware.use ::ActionDispatch::RemoteIp, config.action_dispatch.ip_spoofing_check, config.action_dispatch.trusted_proxies
+
+          unless config.cache_classes
+            middleware.use ::ActionDispatch::Reloader, lambda { reload_dependencies? }
+          end
+
+          middleware.use ::ActionDispatch::Callbacks
+          middleware.use ::ActionDispatch::Cookies
+
+          if config.session_store
+            if config.force_ssl && !config.session_options.key?(:secure)
+              config.session_options[:secure] = true
+            end
+            middleware.use config.session_store, config.session_options
+            middleware.use ::ActionDispatch::Flash
+          end
+
+          middleware.use ::ActionDispatch::ParamsParser
+          middleware.use ::Rack::Head
+          middleware.use ::Rack::ConditionalGet
+          middleware.use ::Rack::ETag, "no-cache"
+        end
+      end
+
+      private
+
+        def reload_dependencies?
+          config.reload_classes_only_on_change != true || app.reloaders.map(&:updated?).any?
+        end
+
+        def allow_concurrency?
+          config.allow_concurrency.nil? ? config.cache_classes : config.allow_concurrency
+        end
+
+        def load_rack_cache
+          rack_cache = config.action_dispatch.rack_cache
+          return unless rack_cache
+
+          begin
+            require 'rack/cache'
+          rescue LoadError => error
+            error.message << ' Be sure to add rack-cache to your Gemfile'
+            raise
+          end
+
+          if rack_cache == true
+            {
+              metastore: "rails:/",
+              entitystore: "rails:/",
+              verbose: false
+            }
+          else
+            rack_cache
+          end
+        end
+
+        def show_exceptions_app
+          config.exceptions_app || ActionDispatch::PublicExceptions.new(Rails.public_path)
+        end
+    end
+  end
+end

data/lib/rails/application/finisher.rb

@@ -22,6 +22,8 @@ module Rails
       initializer :add_builtin_route do |app|
         if Rails.env.development?
           app.routes.append do
+            get '/rails/mailers'         => "rails/mailers#index"
+            get '/rails/mailers/*path'   => "rails/mailers#preview"
             get '/rails/info/properties' => "rails/info#properties"
             get '/rails/info/routes'     => "rails/info#routes"
             get '/rails/info'            => "rails/info#index"

data/lib/rails/application_controller.rb

@@ -0,0 +1,16 @@
+class Rails::ApplicationController < ActionController::Base # :nodoc:
+  self.view_paths = File.expand_path('../templates', __FILE__)
+  layout 'application'
+
+  protected
+
+  def require_local!
+    unless local_request?
+      render text: '<p>For security purposes, this information is only available to local requests.</p>', status: :forbidden
+    end
+  end
+
+  def local_request?
+    Rails.application.config.consider_all_requests_local || request.local?
+  end
+end

data/lib/rails/cli.rb

@@ -1,4 +1,3 @@
-require 'rbconfig'
 require 'rails/app_rails_loader'
 
 # If we are inside a Rails application this method performs an exec and thus
@@ -10,7 +9,7 @@ Signal.trap("INT") { puts; exit(1) }
 
 if ARGV.first == 'plugin'
   ARGV.shift
-  require 'rails/commands/plugin_new'
+  require 'rails/commands/plugin'
 else
   require 'rails/commands/application'
 end

data/lib/rails/commands.rb

@@ -9,101 +9,9 @@ aliases = {
   "r"  => "runner"
 }
 
-help_message = <<-EOT
-Usage: rails COMMAND [ARGS]
-
-The most common rails commands are:
- generate    Generate new code (short-cut alias: "g")
- console     Start the Rails console (short-cut alias: "c")
- server      Start the Rails server (short-cut alias: "s")
- dbconsole   Start a console for the database specified in config/database.yml
-             (short-cut alias: "db")
- new         Create a new Rails application. "rails new my_app" creates a
-             new application called MyApp in "./my_app"
-
-In addition to those, there are:
- application  Generate the Rails application code
- destroy      Undo code generated with "generate" (short-cut alias: "d")
- plugin new   Generates skeleton for developing a Rails plugin
- runner       Run a piece of code in the application environment (short-cut alias: "r")
-
-All commands can be run with -h (or --help) for more information.
-EOT
-
-
 command = ARGV.shift
 command = aliases[command] || command
 
-case command
-when 'plugin'
-  require "rails/commands/plugin_new"
-when 'generate', 'destroy'
-  require 'rails/generators'
-
-  require APP_PATH
-  Rails.application.require_environment!
-
-  Rails.application.load_generators
-
-  require "rails/commands/#{command}"
-
-when 'console'
-  require 'rails/commands/console'
-  options = Rails::Console.parse_arguments(ARGV)
-
-  # RAILS_ENV needs to be set before config/application is required
-  ENV['RAILS_ENV'] = options[:environment] if options[:environment]
-
-  # shift ARGV so IRB doesn't freak
-  ARGV.shift if ARGV.first && ARGV.first[0] != '-'
-
-  require APP_PATH
-  Rails.application.require_environment!
-  Rails::Console.start(Rails.application, options)
-
-when 'server'
-  # Change to the application's path if there is no config.ru file in current directory.
-  # This allows us to run `rails server` from other directories, but still get
-  # the main config.ru and properly set the tmp directory.
-  Dir.chdir(File.expand_path('../../', APP_PATH)) unless File.exist?(File.expand_path("config.ru"))
-
-  require 'rails/commands/server'
-  Rails::Server.new.tap do |server|
-    # We need to require application after the server sets environment,
-    # otherwise the --environment option given to the server won't propagate.
-    require APP_PATH
-    Dir.chdir(Rails.application.root)
-    server.start
-  end
-
-when 'dbconsole'
-  require 'rails/commands/dbconsole'
-  Rails::DBConsole.start
-
-when 'application', 'runner'
-  require "rails/commands/#{command}"
-
-when 'new'
-  if %w(-h --help).include?(ARGV.first)
-    require 'rails/commands/application'
-  else
-    puts "Can't initialize a new Rails application within the directory of another, please change to a non-Rails directory first.\n"
-    puts "Type 'rails' for help."
-    exit(1)
-  end
-
-when '--version', '-v'
-  ARGV.unshift '--version'
-  require 'rails/commands/application'
-
-when '-h', '--help'
-  puts help_message
+require 'rails/commands/commands_tasks'
 
-else
-  puts "Error: Command '#{command}' not recognized"
-  if %x{rake #{command} --dry-run 2>&1 } && $?.success?
-    puts "Did you mean: `$ rake #{command}` ?\n\n"
-  end
-  puts help_message
-  exit(1)
-end
+Rails::CommandsTasks.new(ARGV).run_command!(command)

data/lib/rails/commands/application.rb

@@ -1,30 +1,3 @@
-require 'rails/version'
-
-if ['--version', '-v'].include?(ARGV.first)
-  puts "Rails #{Rails::VERSION::STRING}"
-  exit(0)
-end
-
-if ARGV.first != "new"
-  ARGV[0] = "--help"
-else
-  ARGV.shift
-  unless ARGV.delete("--no-rc")
-    customrc = ARGV.index{ |x| x.include?("--rc=") }
-    railsrc = if customrc
-                File.expand_path(ARGV.delete_at(customrc).gsub(/--rc=/, ""))
-              else
-                File.join(File.expand_path("~"), '.railsrc')
-              end
-    if File.exist?(railsrc)
-      extra_args_string = File.read(railsrc)
-      extra_args = extra_args_string.split(/\n+/).map {|l| l.split}.flatten
-      puts "Using #{extra_args.join(" ")} from #{railsrc}"
-      ARGV.insert(1, *extra_args)
-    end
-  end
-end
-
 require 'rails/generators'
 require 'rails/generators/rails/app/app_generator'
 
@@ -40,4 +13,5 @@ module Rails
   end
 end
 
-Rails::Generators::AppGenerator.start
+args = Rails::Generators::ARGVScrubber.new(ARGV).prepare!
+Rails::Generators::AppGenerator.start args

data/lib/rails/commands/commands_tasks.rb

@@ -0,0 +1,174 @@
+module Rails
+  # This is a class which takes in a rails command and initiates the appropriate
+  # initiation sequence.
+  #
+  # Warning: This class mutates ARGV because some commands require manipulating
+  # it before they are run.
+  class CommandsTasks # :nodoc:
+    attr_reader :argv
+
+    HELP_MESSAGE = <<-EOT
+Usage: rails COMMAND [ARGS]
+
+The most common rails commands are:
+ generate    Generate new code (short-cut alias: "g")
+ console     Start the Rails console (short-cut alias: "c")
+ server      Start the Rails server (short-cut alias: "s")
+ dbconsole   Start a console for the database specified in config/database.yml
+             (short-cut alias: "db")
+ new         Create a new Rails application. "rails new my_app" creates a
+             new application called MyApp in "./my_app"
+
+In addition to those, there are:
+ application  Generate the Rails application code
+ destroy      Undo code generated with "generate" (short-cut alias: "d")
+ plugin new   Generates skeleton for developing a Rails plugin
+ runner       Run a piece of code in the application environment (short-cut alias: "r")
+
+All commands can be run with -h (or --help) for more information.
+EOT
+
+    COMMAND_WHITELIST = %(plugin generate destroy console server dbconsole application runner new version help)
+
+    def initialize(argv)
+      @argv = argv
+    end
+
+    def run_command!(command)
+      command = parse_command(command)
+      if COMMAND_WHITELIST.include?(command)
+        send(command)
+      else
+        write_error_message(command)
+      end
+    end
+
+    def plugin
+      require_command!("plugin")
+    end
+
+    def generate
+      generate_or_destroy(:generate)
+    end
+
+    def destroy
+      generate_or_destroy(:destroy)
+    end
+
+    def console
+      require_command!("console")
+      options = Rails::Console.parse_arguments(argv)
+
+      # RAILS_ENV needs to be set before config/application is required
+      ENV['RAILS_ENV'] = options[:environment] if options[:environment]
+
+      # shift ARGV so IRB doesn't freak
+      shift_argv!
+
+      require_application_and_environment!
+      Rails::Console.start(Rails.application, options)
+    end
+
+    def server
+      set_application_directory!
+      require_command!("server")
+
+      Rails::Server.new.tap do |server|
+        # We need to require application after the server sets environment,
+        # otherwise the --environment option given to the server won't propagate.
+        require APP_PATH
+        Dir.chdir(Rails.application.root)
+        server.start
+      end
+    end
+
+    def dbconsole
+      require_command!("dbconsole")
+      Rails::DBConsole.start
+    end
+
+    def application
+      require_command!("application")
+    end
+
+    def runner
+      require_command!("runner")
+    end
+
+    def new
+      if %w(-h --help).include?(argv.first)
+        require_command!("application")
+      else
+        exit_with_initialization_warning!
+      end
+    end
+
+    def version
+      argv.unshift '--version'
+      require_command!("application")
+    end
+
+    def help
+      write_help_message
+    end
+
+    private
+
+      def exit_with_initialization_warning!
+        puts "Can't initialize a new Rails application within the directory of another, please change to a non-Rails directory first.\n"
+        puts "Type 'rails' for help."
+        exit(1)
+      end
+
+      def shift_argv!
+        argv.shift if argv.first && argv.first[0] != '-'
+      end
+
+      def require_command!(command)
+        require "rails/commands/#{command}"
+      end
+
+      def generate_or_destroy(command)
+        require 'rails/generators'
+        require_application_and_environment!
+        Rails.application.load_generators
+        require "rails/commands/#{command}"
+      end
+
+      # Change to the application's path if there is no config.ru file in current directory.
+      # This allows us to run `rails server` from other directories, but still get
+      # the main config.ru and properly set the tmp directory.
+      def set_application_directory!
+        Dir.chdir(File.expand_path('../../', APP_PATH)) unless File.exist?(File.expand_path("config.ru"))
+      end
+
+      def require_application_and_environment!
+        require APP_PATH
+        Rails.application.require_environment!
+      end
+
+      def write_help_message
+        puts HELP_MESSAGE
+      end
+
+      def write_error_message(command)
+        puts "Error: Command '#{command}' not recognized"
+        if %x{rake #{command} --dry-run 2>&1 } && $?.success?
+          puts "Did you mean: `$ rake #{command}` ?\n\n"
+        end
+        write_help_message
+        exit(1)
+      end
+
+      def parse_command(command)
+        case command
+        when '--version', '-v'
+          'version'
+        when '--help', '-h'
+          'help'
+        else
+          command
+        end
+      end
+  end
+end