railties 3.0.20 → 3.1.0.beta1

data/lib/rails.rb

@@ -8,7 +8,6 @@ require 'active_support/core_ext/logger'
 
 require 'rails/application'
 require 'rails/version'
-require 'rails/deprecation'
 
 require 'active_support/railtie'
 require 'action_dispatch/railtie'
@@ -93,12 +92,7 @@ module Rails
     end
 
     def public_path
-      application && application.paths.public.to_a.first
-    end
-
-    def public_path=(path)
-      ActiveSupport::Deprecation.warn "Setting Rails.public_path= is deprecated. " <<
-        "Please set paths.public = in config/application.rb instead.", caller
+      application && application.paths["public"].first
     end
   end
 end

data/lib/rails/application.rb

@@ -35,30 +35,12 @@ module Rails
   #
   class Application < Engine
     autoload :Bootstrap,      'rails/application/bootstrap'
-    autoload :Configurable,   'rails/application/configurable'
     autoload :Configuration,  'rails/application/configuration'
     autoload :Finisher,       'rails/application/finisher'
     autoload :Railties,       'rails/application/railties'
+    autoload :RoutesReloader, 'rails/application/routes_reloader'
 
     class << self
-      private :new
-
-      def configure(&block)
-        class_eval(&block)
-      end
-
-      def instance
-        if self == Rails::Application
-          if Rails.application
-            ActiveSupport::Deprecation.warn "Calling a method in Rails::Application is deprecated, " <<
-              "please call it directly in your application constant #{Rails.application.class.name}.", caller
-          end
-          Rails.application
-        else
-          @@instance ||= new
-        end
-      end
-
       def inherited(base)
         raise "You cannot have more than one Rails::Application" if Rails.application
         super
@@ -66,19 +48,10 @@ module Rails
         Rails.application.add_lib_to_load_path!
         ActiveSupport.run_load_hooks(:before_configuration, base.instance)
       end
-
-      def respond_to?(*args)
-        super || instance.respond_to?(*args)
-      end
-
-    protected
-
-      def method_missing(*args, &block)
-        instance.send(*args, &block)
-      end
     end
 
-    delegate :middleware, :to => :config
+    attr_accessor :assets
+    delegate :default_url_options, :default_url_options=, :to => :routes
 
     # 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
@@ -99,7 +72,7 @@ module Rails
     end
 
     def require_environment! #:nodoc:
-      environment = paths.config.environment.to_a.first
+      environment = paths["config/environment"].existent.first
       require environment if environment
     end
 
@@ -108,30 +81,18 @@ module Rails
       super
     end
 
-    def routes
-      @routes ||= ActionDispatch::Routing::RouteSet.new
-    end
-
-    def railties
-      @railties ||= Railties.new(config)
+    def reload_routes!
+      routes_reloader.reload!
     end
 
     def routes_reloader
-      @routes_reloader ||= ActiveSupport::FileUpdateChecker.new([]){ reload_routes! }
-    end
-
-    def reload_routes!
-      _routes = self.routes
-      _routes.disable_clear_and_finalize = true
-      _routes.clear!
-      routes_reloader.paths.each { |path| load(path) }
-      ActiveSupport.on_load(:action_controller) { _routes.finalize! }
-    ensure
-      _routes.disable_clear_and_finalize = false
+      @routes_reloader ||= RoutesReloader.new
     end
 
     def initialize!
+      raise "Application has been already initialized." if @initialized
       run_initializers(self)
+      @initialized = true
       self
     end
 
@@ -151,51 +112,57 @@ module Rails
 
     def load_console(sandbox=false)
       initialize_console(sandbox)
-      railties.all { |r| r.load_console }
+      railties.all { |r| r.load_console(sandbox) }
       super()
       self
     end
 
-    def app
-      @app ||= begin
-        config.middleware = config.middleware.merge_into(default_middleware_stack)
-        config.middleware.build(routes)
-      end
-    end
-    alias :build_middleware_stack :app
-
-    def call(env)
-      app.call(env.reverse_merge!(env_defaults))
-    end
-
-    def env_defaults
-      @env_defaults ||= {
+    def env_config
+      @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
-      }
+      })
     end
 
     def initializers
-      initializers = Bootstrap.initializers_for(self)
-      railties.all { |r| initializers += r.initializers }
-      initializers += super
-      initializers += Finisher.initializers_for(self)
-      initializers
+      Bootstrap.initializers_for(self) +
+      super +
+      Finisher.initializers_for(self)
+    end
+
+    def config
+      @config ||= Application::Configuration.new(find_root_with_flag("config.ru", Dir.pwd))
     end
 
   protected
 
+    alias :build_middleware_stack :app
+
     def default_middleware_stack
       ActionDispatch::MiddlewareStack.new.tap do |middleware|
-        middleware.use ::ActionDispatch::Static, paths.public.to_a.first if config.serve_static_assets
-        middleware.use ::Rack::Lock if !config.allow_concurrency
+        if rack_cache = config.action_controller.perform_caching && config.action_dispatch.rack_cache
+          require "action_dispatch/http/rack_cache"
+          middleware.use ::Rack::Cache, rack_cache
+        end
+
+        if config.force_ssl
+          require "rack/ssl"
+          middleware.use ::Rack::SSL
+        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::Runtime
         middleware.use ::Rails::Rack::Logger
         middleware.use ::ActionDispatch::ShowExceptions, config.consider_all_requests_local
         middleware.use ::ActionDispatch::RemoteIp, config.action_dispatch.ip_spoofing_check, config.action_dispatch.trusted_proxies
         middleware.use ::Rack::Sendfile, config.action_dispatch.x_sendfile_header
-        middleware.use ::ActionDispatch::Callbacks, !config.cache_classes
+        middleware.use ::ActionDispatch::Reloader unless config.cache_classes
+        middleware.use ::ActionDispatch::Callbacks
         middleware.use ::ActionDispatch::Cookies
 
         if config.session_store
@@ -206,12 +173,16 @@ module Rails
         middleware.use ::ActionDispatch::ParamsParser
         middleware.use ::Rack::MethodOverride
         middleware.use ::ActionDispatch::Head
-        middleware.use ::ActionDispatch::BestStandardsSupport, config.action_dispatch.best_standards_support if config.action_dispatch.best_standards_support
+        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
-      extend Rake::DSL if defined? Rake::DSL
       require "rails/tasks"
       task :environment do
         $rails_rake_task = true
@@ -225,8 +196,7 @@ module Rails
 
     def initialize_console(sandbox=false)
       require "rails/console/app"
-      require "rails/console/sandbox" if sandbox
       require "rails/console/helpers"
     end
   end
-end
+end

data/lib/rails/application/bootstrap.rb

@@ -6,10 +6,7 @@ module Rails
     module Bootstrap
       include Initializable
 
-      initializer :load_environment_config do
-        environment = config.paths.config.environments.to_a.first
-        require environment if environment
-      end
+      initializer :load_environment_hook do end
 
       initializer :load_active_support do
         require 'active_support/dependencies'
@@ -26,7 +23,7 @@ module Rails
       # Initialize the logger early in the stack in case we need to log some deprecation.
       initializer :initialize_logger do
         Rails.logger ||= config.logger || begin
-          path = config.paths.log.to_a.first
+          path = config.paths["log"].first
           logger = ActiveSupport::BufferedLogger.new(path)
           logger.level = ActiveSupport::BufferedLogger.const_get(config.log_level.to_s.upcase)
           logger.auto_flushing = false if Rails.env.production?
@@ -54,11 +51,9 @@ module Rails
       end
 
       initializer :set_clear_dependencies_hook do
-        unless config.cache_classes
-          ActionDispatch::Callbacks.after do
-            ActiveSupport::DescendantsTracker.clear
-            ActiveSupport::Dependencies.clear
-          end
+        ActionDispatch::Reloader.to_cleanup do
+          ActiveSupport::DescendantsTracker.clear
+          ActiveSupport::Dependencies.clear
         end
       end
 
@@ -73,4 +68,4 @@ module Rails
       end
     end
   end
-end
+end

data/lib/rails/application/configuration.rb

@@ -1,33 +1,48 @@
-require 'active_support/deprecation'
 require 'active_support/core_ext/string/encoding'
 require 'rails/engine/configuration'
 
 module Rails
   class Application
     class Configuration < ::Rails::Engine::Configuration
-      include ::Rails::Configuration::Deprecated
+      attr_accessor :allow_concurrency, :asset_host, :asset_path, :assets,
+                    :cache_classes, :cache_store, :consider_all_requests_local,
+                    :dependency_loading, :encoding, :filter_parameters,
+                    :force_ssl, :helpers_paths, :logger, :preload_frameworks,
+                    :reload_plugins, :secret_token, :serve_static_assets,
+                    :static_cache_control, :session_options, :time_zone, :whiny_nils
 
-      attr_accessor :allow_concurrency, :cache_classes, :cache_store,
-                    :encoding, :consider_all_requests_local, :dependency_loading,
-                    :filter_parameters,  :log_level, :logger, :middleware,
-                    :plugins, :preload_frameworks, :reload_plugins,
-                    :secret_token, :serve_static_assets, :session_options,
-                    :time_zone, :whiny_nils
-
-      alias :generators :app_generators
+      attr_writer :log_level
 
       def initialize(*)
         super
         self.encoding = "utf-8"
-        @allow_concurrency = false
+        @allow_concurrency           = false
         @consider_all_requests_local = false
-        @filter_parameters = []
-        @dependency_loading = true
-        @serve_static_assets = true
-        @session_store = :cookie_store
-        @session_options = {}
-        @time_zone = "UTC"
-        @middleware = app_middleware
+        @filter_parameters           = []
+        @helpers_paths               = []
+        @dependency_loading          = true
+        @serve_static_assets         = true
+        @static_cache_control        = nil
+        @force_ssl                   = false
+        @session_store               = :cookie_store
+        @session_options             = {}
+        @time_zone                   = "UTC"
+        @log_level                   = nil
+        @middleware                  = app_middleware
+        @generators                  = app_generators
+
+        @assets = ActiveSupport::OrderedOptions.new
+        @assets.enabled    = false
+        @assets.paths      = []
+        @assets.precompile = [ /\w+\.(?!js|css)$/, "application.js", "application.css" ]
+        @assets.prefix     = "/assets"
+
+        @assets.js_compressor  = nil
+        @assets.css_compressor = nil
+      end
+
+      def compiled_asset_path
+        "/"
       end
 
       def encoding=(value)
@@ -47,23 +62,15 @@ module Rails
       def paths
         @paths ||= begin
           paths = super
-          paths.app.controllers << builtin_controller if builtin_controller
-          paths.config.database     "config/database.yml"
-          paths.config.environment  "config/environment.rb"
-          paths.config.environments "config/environments", :glob => "#{Rails.env}.rb"
-          paths.lib.templates       "lib/templates"
-          paths.log                 "log/#{Rails.env}.log"
-          paths.tmp                 "tmp"
-          paths.tmp.cache           "tmp/cache"
-          paths.vendor              "vendor", :load_path => true
-          paths.vendor.plugins      "vendor/plugins"
-
-          if File.exists?("#{root}/test/mocks/#{Rails.env}")
-            ActiveSupport::Deprecation.warn "\"Rails.root/test/mocks/#{Rails.env}\" won't be added " <<
-              "automatically to load paths anymore in future releases"
-            paths.mocks_path  "test/mocks", :autoload => true, :glob => Rails.env
-          end
-
+          paths.add "config/database",    :with => "config/database.yml"
+          paths.add "config/environment", :with => "config/environment.rb"
+          paths.add "lib/templates"
+          paths.add "log",                :with => "log/#{Rails.env}.log"
+          paths.add "public"
+          paths.add "public/javascripts"
+          paths.add "public/stylesheets"
+          paths.add "tmp"
+          paths.add "tmp/cache"
           paths
         end
       end
@@ -85,7 +92,7 @@ module Rails
       # YAML::load.
       def database_configuration
         require 'erb'
-        YAML::load(ERB.new(IO.read(paths.config.database.to_a.first)).result)
+        YAML::load(ERB.new(IO.read(paths["config/database"].first)).result)
       end
 
       def cache_store
@@ -98,10 +105,6 @@ module Rails
         end
       end
 
-      def builtin_controller
-        File.expand_path('../info_routes', __FILE__) if Rails.env.development?
-      end
-
       def log_level
         @log_level ||= Rails.env.production? ? :info : :debug
       end

data/lib/rails/application/finisher.rb

@@ -4,7 +4,7 @@ module Rails
       include Initializable
 
       initializer :add_generator_templates do
-        config.generators.templates.unshift(*paths.lib.templates.to_a)
+        config.generators.templates.unshift(*paths["lib/templates"].existent)
       end
 
       initializer :ensure_autoload_once_paths_as_subset do
@@ -21,13 +21,15 @@ module Rails
 
       initializer :add_to_prepare_blocks do
         config.to_prepare_blocks.each do |block|
-          ActionDispatch::Callbacks.to_prepare(&block)
+          ActionDispatch::Reloader.to_prepare(&block)
         end
       end
 
       initializer :add_builtin_route do |app|
         if Rails.env.development?
-          app.routes_reloader.paths << File.expand_path('../../info_routes.rb', __FILE__)
+          app.routes.append do
+            match '/rails/info/properties' => "rails/info#properties"
+          end
         end
       end
 
@@ -35,6 +37,14 @@ module Rails
         build_middleware_stack
       end
 
+      initializer :run_prepare_callbacks do
+        ActionDispatch::Reloader.prepare!
+      end
+
+      initializer :define_main_app_helper do |app|
+        app.routes.define_mounted_helper(:main_app)
+      end
+
       initializer :eager_load! do
         if config.cache_classes && !$rails_rake_task
           ActiveSupport.run_load_hooks(:before_eager_load, self)
@@ -47,10 +57,12 @@ module Rails
       end
 
       # Force routes to be loaded just at the end and add it to to_prepare callbacks
+      # This needs to be after the finisher hook to ensure routes added in the hook
+      # are still loaded.
       initializer :set_routes_reloader do |app|
         reloader = lambda { app.routes_reloader.execute_if_updated }
         reloader.call
-        ActionDispatch::Callbacks.to_prepare(&reloader)
+        ActionDispatch::Reloader.to_prepare(&reloader)
       end
 
       # Disable dependency loading during request cycle

data/lib/rails/application/railties.rb

@@ -1,31 +1,13 @@
-module Rails
-  class Application
-    class Railties
-      # TODO Write tests for this behavior extracted from Application
-      def initialize(config)
-        @config = config
-      end
+require 'rails/engine/railties'
 
+module Rails
+  class Application < Engine
+    class Railties < Rails::Engine::Railties
       def all(&block)
-        @all ||= railties + engines + plugins
+        @all ||= railties + engines + super
         @all.each(&block) if block
         @all
       end
-
-      def railties
-        @railties ||= ::Rails::Railtie.subclasses.map(&:new)
-      end
-
-      def engines
-        @engines ||= ::Rails::Engine.subclasses.map(&:new)
-      end
-
-      def plugins
-        @plugins ||= begin
-          plugin_names = (@config.plugins || [:all]).map { |p| p.to_sym }
-          Plugin.all(plugin_names, @config.paths.vendor.plugins)
-        end
-      end
     end
   end
-end
+end