railties 3.2.22.5 → 4.0.0.beta1

data/lib/rails/all.rb

@@ -4,7 +4,6 @@ require "rails"
   active_record
   action_controller
   action_mailer
-  active_resource
   rails/test_unit
   sprockets
 ).each do |framework|

data/lib/rails/app_rails_loader.rb

@@ -0,0 +1,37 @@
+require 'pathname'
+
+module Rails
+  module AppRailsLoader
+    RUBY = File.join(*RbConfig::CONFIG.values_at("bindir", "ruby_install_name")) + RbConfig::CONFIG["EXEEXT"]
+    EXECUTABLES = ['bin/rails', 'script/rails']
+
+    def self.exec_app_rails
+      cwd   = Dir.pwd
+
+      exe   = find_executable
+      exe ||= find_executable_in_parent_path
+      return unless exe
+
+      exec RUBY, exe, *ARGV if find_executable
+      Dir.chdir("..") do
+        # Recurse in a chdir block: if the search fails we want to be sure
+        # the application is generated in the original working directory.
+        exec_app_rails unless cwd == Dir.pwd
+      end
+    rescue SystemCallError
+      # could not chdir, no problem just return
+    end
+
+    def self.find_executable
+      EXECUTABLES.find do |exe|
+        File.exists?(exe) && File.read(exe) =~ /(APP|ENGINE)_PATH/
+      end
+    end
+
+    def self.find_executable_in_parent_path(path = Pathname.new(Dir.pwd))
+      EXECUTABLES.find do |exe|
+        File.exists?(File.join(path, exe)) || !path.root? && find_executable_in_parent_path(path.parent)
+      end
+    end
+  end
+end

data/lib/rails/application.rb

@@ -1,6 +1,6 @@
-require 'active_support/core_ext/hash/reverse_merge'
 require 'fileutils'
-require 'rails/plugin'
+# FIXME remove DummyKeyGenerator and this require in 4.1
+require 'active_support/key_generator'
 require 'rails/engine'
 
 module Rails
@@ -9,7 +9,7 @@ module Rails
   #
   # == Initialization
   #
-  # Rails::Application is responsible for executing all railties, engines and plugin
+  # Rails::Application is responsible for executing all railties and engines
   # initializers. It also executes some bootstrap initializers (check
   # Rails::Application::Bootstrap) and finishing initializers, after all the others
   # are executed (check Rails::Application::Finisher).
@@ -18,8 +18,8 @@ module Rails
   #
   # Besides providing the same configuration as Rails::Engine and Rails::Railtie,
   # the application object has several specific configurations, for example
-  # "allow_concurrency", "cache_classes", "consider_all_requests_local", "filter_parameters",
-  # "logger", "reload_plugins" and so forth.
+  # "cache_classes", "consider_all_requests_local", "filter_parameters",
+  # "logger" and so forth.
   #
   # Check Rails::Application::Configuration to see them all.
   #
@@ -48,14 +48,14 @@ module Rails
   #       One by one, each engine sets up its load paths, routes and runs its config/initializers/* files.
   #   9)  Custom Railtie#initializers added by railties, engines and applications are executed
   #   10) Build the middleware stack and run to_prepare callbacks
-  #   11) Run config.before_eager_load and eager_load if cache classes is true
+  #   11) Run config.before_eager_load and eager_load! if eager_load is true
   #   12) Run config.after_initialize callbacks
   #
   class Application < Engine
     autoload :Bootstrap,      'rails/application/bootstrap'
     autoload :Configuration,  'rails/application/configuration'
     autoload :Finisher,       'rails/application/finisher'
-    autoload :Railties,       'rails/application/railties'
+    autoload :Railties,       'rails/engine/railties'
     autoload :RoutesReloader, 'rails/application/routes_reloader'
 
     class << self
@@ -72,14 +72,98 @@ module Rails
     alias_method :sandbox?, :sandbox
     attr_reader :reloaders
 
-    delegate :default_url_options, :default_url_options=, :to => :routes
+    delegate :default_url_options, :default_url_options=, to: :routes
 
     def initialize
       super
-      @initialized = false
-      @reloaders   = []
+      @initialized      = false
+      @reloaders        = []
+      @routes_reloader  = nil
+      @env_config       = nil
+      @ordered_railties = nil
+      @railties         = nil
     end
 
+    # Returns true if the application is initialized.
+    def initialized?
+      @initialized
+    end
+
+    # Implements call according to the Rack API. It simply
+    # dispatches the request to the underlying middleware stack.
+    def call(env)
+      env["ORIGINAL_FULLPATH"] = build_original_fullpath(env)
+      super(env)
+    end
+
+    # Reload application routes regardless if they changed or not.
+    def reload_routes!
+      routes_reloader.reload!
+    end
+
+
+    # Return the application's KeyGenerator
+    def key_generator
+      # number of iterations selected based on consultation with the google security
+      # team. Details at https://github.com/rails/rails/pull/6952#issuecomment-7661220
+      @caching_key_generator ||= begin
+        if config.secret_key_base
+          key_generator = ActiveSupport::KeyGenerator.new(config.secret_key_base, iterations: 1000)
+          ActiveSupport::CachingKeyGenerator.new(key_generator)
+        else
+          ActiveSupport::DummyKeyGenerator.new(config.secret_token)
+        end
+      end
+    end
+
+    # Stores some of the Rails initial environment parameters which
+    # will be used by middlewares and engines to configure themselves.
+    # Currently stores:
+    #
+    #   * "action_dispatch.parameter_filter"             => config.filter_parameters
+    #   * "action_dispatch.redirect_filter"              => config.filter_redirect
+    #   * "action_dispatch.secret_token"                 => config.secret_token,
+    #   * "action_dispatch.show_exceptions"              => config.action_dispatch.show_exceptions
+    #   * "action_dispatch.show_detailed_exceptions"     => config.consider_all_requests_local
+    #   * "action_dispatch.logger"                       => Rails.logger
+    #   * "action_dispatch.backtrace_cleaner"            => Rails.backtrace_cleaner
+    #   * "action_dispatch.key_generator"                => key_generator
+    #   * "action_dispatch.http_auth_salt"               => config.action_dispatch.http_auth_salt
+    #   * "action_dispatch.signed_cookie_salt"           => config.action_dispatch.signed_cookie_salt
+    #   * "action_dispatch.encrypted_cookie_salt"        => config.action_dispatch.encrypted_cookie_salt
+    #   * "action_dispatch.encrypted_signed_cookie_salt" => config.action_dispatch.encrypted_signed_cookie_salt
+    #
+    def env_config
+      @env_config ||= begin
+        if config.secret_key_base.nil?
+          ActiveSupport::Deprecation.warn "You didn't set config.secret_key_base in config/initializers/secret_token.rb file. " +
+            "This should be used instead of the old deprecated config.secret_token in order to use the new EncryptedCookieStore. " +
+            "To convert safely to the encrypted store (without losing existing cookies and sessions), see http://guides.rubyonrails.org/upgrading_ruby_on_rails.html#action-pack"
+
+          if config.secret_token.blank?
+            raise "You must set config.secret_key_base in your app's config"
+          end
+        end
+
+        super.merge({
+          "action_dispatch.parameter_filter" => config.filter_parameters,
+          "action_dispatch.redirect_filter" => config.filter_redirect,
+          "action_dispatch.secret_token" => config.secret_token,
+          "action_dispatch.show_exceptions" => config.action_dispatch.show_exceptions,
+          "action_dispatch.show_detailed_exceptions" => config.consider_all_requests_local,
+          "action_dispatch.logger" => Rails.logger,
+          "action_dispatch.backtrace_cleaner" => Rails.backtrace_cleaner,
+          "action_dispatch.key_generator" => key_generator,
+          "action_dispatch.http_auth_salt" => config.action_dispatch.http_auth_salt,
+          "action_dispatch.signed_cookie_salt" => config.action_dispatch.signed_cookie_salt,
+          "action_dispatch.encrypted_cookie_salt" => config.action_dispatch.encrypted_cookie_salt,
+          "action_dispatch.encrypted_signed_cookie_salt" => config.action_dispatch.encrypted_signed_cookie_salt
+        })
+      end
+    end
+
+    ## Rails internal API
+
     # This method is called just after an application inherits from Rails::Application,
     # allowing the developer to load classes in lib and use them during application
     # configuration.
@@ -94,7 +178,7 @@ module Rails
     # Rails application, you will need to add lib to $LOAD_PATH on your own in case
     # you need to load files in lib/ during the application configuration as well.
     def add_lib_to_load_path! #:nodoc:
-      path = config.root.join('lib').to_s
+      path = File.join config.root, 'lib'
       $LOAD_PATH.unshift(path) if File.exists?(path)
     end
 
@@ -103,23 +187,16 @@ module Rails
       require environment if environment
     end
 
-    # Reload application routes regardless if they changed or not.
-    def reload_routes!
-      routes_reloader.reload!
-    end
-
     def routes_reloader #:nodoc:
       @routes_reloader ||= RoutesReloader.new
     end
 
-    # Returns an array of file paths appended with a hash of directories-extensions
-    # suitable for ActiveSupport::FileUpdateChecker API.
-    def watchable_args
-      files = []
-      files.concat config.watchable_files
+    # Returns an array of file paths appended with a hash of
+    # directories-extensions suitable for ActiveSupport::FileUpdateChecker
+    # API.
+    def watchable_args #:nodoc:
+      files, dirs = config.watchable_files.dup, config.watchable_dirs.dup
 
-      dirs = {}
-      dirs.merge! config.watchable_dirs
       ActiveSupport::Dependencies.autoload_paths.each do |path|
         dirs[path.to_s] = [:rb]
       end
@@ -138,51 +215,52 @@ module Rails
       self
     end
 
-    # Load the application and its railties tasks and invoke the registered hooks.
-    # Check <tt>Rails::Railtie.rake_tasks</tt> for more info.
-    def load_tasks(app=self)
-      initialize_tasks
-      super
+    def initializers #:nodoc:
+      Bootstrap.initializers_for(self) +
+      railties_initializers(super) +
+      Finisher.initializers_for(self)
+    end
+
+    def config #:nodoc:
+      @config ||= Application::Configuration.new(find_root_with_flag("config.ru", Dir.pwd))
+    end
+
+    def to_app #:nodoc:
       self
     end
 
-    # Load the application console and invoke the registered hooks.
-    # Check <tt>Rails::Railtie.console</tt> for more info.
-    def load_console(app=self)
-      initialize_console
+    def helpers_paths #:nodoc:
+      config.helpers_paths
+    end
+
+  protected
+
+    alias :build_middleware_stack :app
+
+    def run_tasks_blocks(app) #:nodoc:
+      railties.each { |r| r.run_tasks_blocks(app) }
       super
-      self
+      require "rails/tasks"
+      config = self.config
+      task :environment do
+        config.eager_load = false
+        require_environment!
+      end
     end
 
-    # Load the application runner and invoke the registered hooks.
-    # Check <tt>Rails::Railtie.runner</tt> for more info.
-    def load_runner(app=self)
-      initialize_runner
+    def run_generators_blocks(app) #:nodoc:
+      railties.each { |r| r.run_generators_blocks(app) }
       super
-      self
     end
 
-    # Rails.application.env_config stores some of the Rails initial environment parameters.
-    # Currently stores:
-    #
-    #   * "action_dispatch.parameter_filter"         => config.filter_parameters,
-    #   * "action_dispatch.secret_token"             => config.secret_token,
-    #   * "action_dispatch.show_exceptions"          => config.action_dispatch.show_exceptions,
-    #   * "action_dispatch.show_detailed_exceptions" => config.consider_all_requests_local,
-    #   * "action_dispatch.logger"                   => Rails.logger,
-    #   * "action_dispatch.backtrace_cleaner"        => Rails.backtrace_cleaner
-    #
-    # These parameters will be used by middlewares and engines to configure themselves.
-    #
-    def env_config
-      @app_env_config ||= super.merge({
-        "action_dispatch.parameter_filter" => config.filter_parameters,
-        "action_dispatch.secret_token" => config.secret_token,
-        "action_dispatch.show_exceptions" => config.action_dispatch.show_exceptions,
-        "action_dispatch.show_detailed_exceptions" => config.consider_all_requests_local,
-        "action_dispatch.logger" => Rails.logger,
-        "action_dispatch.backtrace_cleaner" => Rails.backtrace_cleaner
-      })
+    def run_runner_blocks(app) #:nodoc:
+      railties.each { |r| r.run_runner_blocks(app) }
+      super
+    end
+
+    def run_console_blocks(app) #:nodoc:
+      railties.each { |r| r.run_console_blocks(app) }
+      super
     end
 
     # Returns the ordered railties for this application considering railties_order.
@@ -198,7 +276,7 @@ module Rails
           end
         end
 
-        all = (railties.all - order)
+        all = (railties - order)
         all.push(self)   unless (all + order).include?(self)
         order.push(:all) unless order.include?(:all)
 
@@ -208,70 +286,67 @@ module Rails
       end
     end
 
-    def initializers #:nodoc:
-      Bootstrap.initializers_for(self) +
-      super +
-      Finisher.initializers_for(self)
-    end
-
-    def config #:nodoc:
-      @config ||= Application::Configuration.new(find_root_with_flag("config.ru", Dir.pwd))
-    end
-
-    def to_app
-      self
-    end
-
-    def helpers_paths #:nodoc:
-      config.helpers_paths
-    end
-
-    def call(env)
-      env["ORIGINAL_FULLPATH"] = build_original_fullpath(env)
-      super(env)
+    def railties_initializers(current) #:nodoc:
+      initializers = []
+      ordered_railties.each do |r|
+        if r == self
+          initializers += current
+        else
+          initializers += r.initializers
+        end
+      end
+      initializers
     end
 
-  protected
-
-    alias :build_middleware_stack :app
-
-    def reload_dependencies?
+    def reload_dependencies? #:nodoc:
       config.reload_classes_only_on_change != true || reloaders.map(&:updated?).any?
     end
 
-    def default_middleware_stack
-      require 'action_controller/railtie'
-
+    def default_middleware_stack #:nodoc:
       ActionDispatch::MiddlewareStack.new.tap do |middleware|
-        if rack_cache = config.action_controller.perform_caching && config.action_dispatch.rack_cache
+        app = self
+        if rack_cache = config.action_dispatch.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
+            rack_cache = {
+              metastore: "rails:/",
+              entitystore: "rails:/",
+              verbose: false
+            }
+          end
+
           require "action_dispatch/http/rack_cache"
           middleware.use ::Rack::Cache, rack_cache
         end
 
         if config.force_ssl
-          require "rack/ssl"
-          middleware.use ::Rack::SSL, config.ssl_options
+          middleware.use ::ActionDispatch::SSL, config.ssl_options
+        end
+
+        if config.action_dispatch.x_sendfile_header.present?
+          middleware.use ::Rack::Sendfile, config.action_dispatch.x_sendfile_header
         end
 
         if config.serve_static_assets
           middleware.use ::ActionDispatch::Static, paths["public"].first, config.static_cache_control
         end
 
-        middleware.use ::Rack::Lock unless config.allow_concurrency
+        middleware.use ::Rack::Lock unless config.cache_classes
         middleware.use ::Rack::Runtime
         middleware.use ::Rack::MethodOverride
         middleware.use ::ActionDispatch::RequestId
         middleware.use ::Rails::Rack::Logger, config.log_tags # must come after Rack::MethodOverride to properly log overridden methods
         middleware.use ::ActionDispatch::ShowExceptions, config.exceptions_app || ActionDispatch::PublicExceptions.new(Rails.public_path)
-        middleware.use ::ActionDispatch::DebugExceptions
+        middleware.use ::ActionDispatch::DebugExceptions, app
         middleware.use ::ActionDispatch::RemoteIp, config.action_dispatch.ip_spoofing_check, config.action_dispatch.trusted_proxies
 
-        if config.action_dispatch.x_sendfile_header.present?
-          middleware.use ::Rack::Sendfile, config.action_dispatch.x_sendfile_header
-        end
-
         unless config.cache_classes
-          app = self
           middleware.use ::ActionDispatch::Reloader, lambda { app.reload_dependencies? }
         end
 
@@ -287,36 +362,13 @@ module Rails
         end
 
         middleware.use ::ActionDispatch::ParamsParser
-        middleware.use ::ActionDispatch::Head
+        middleware.use ::Rack::Head
         middleware.use ::Rack::ConditionalGet
         middleware.use ::Rack::ETag, "no-cache"
-
-        if config.action_dispatch.best_standards_support
-          middleware.use ::ActionDispatch::BestStandardsSupport, config.action_dispatch.best_standards_support
-        end
       end
     end
 
-    def initialize_tasks #:nodoc:
-      self.class.rake_tasks do
-        require "rails/tasks"
-        task :environment do
-          $rails_rake_task = true
-          require_environment!
-        end
-      end
-    end
-
-    def initialize_console #:nodoc:
-      require "pp"
-      require "rails/console/app"
-      require "rails/console/helpers"
-    end
-
-    def initialize_runner #:nodoc:
-    end
-
-    def build_original_fullpath(env)
+    def build_original_fullpath(env) #:nodoc:
       path_info    = env["PATH_INFO"]
       query_string = env["QUERY_STRING"]
       script_name  = env["SCRIPT_NAME"]