application.rb in railties-3.1.0.beta1

- old
+ new

@@ -33,54 +33,27 @@
   #
   # The Application is also responsible for building the middleware stack.
   #
   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
         Rails.application = base.instance
         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
     # configuration.
     #
@@ -97,43 +70,31 @@
       path = config.root.join('lib').to_s
       $LOAD_PATH.unshift(path) if File.exists?(path)
     end
 
     def require_environment! #:nodoc:
-      environment = paths.config.environment.to_a.first
+      environment = paths["config/environment"].existent.first
       require environment if environment
     end
 
     def eager_load! #:nodoc:
       railties.all(&:eager_load!)
       super
     end
 
-    def routes
-      @routes ||= ActionDispatch::Routing::RouteSet.new
+    def reload_routes!
+      routes_reloader.reload!
     end
 
-    def railties
-      @railties ||= Railties.new(config)
-    end
-
     def routes_reloader
-      @routes_reloader ||= ActiveSupport::FileUpdateChecker.new([]){ reload_routes! }
+      @routes_reloader ||= RoutesReloader.new
     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
-    end
-
     def initialize!
+      raise "Application has been already initialized." if @initialized
       run_initializers(self)
+      @initialized = true
       self
     end
 
     def load_tasks
       initialize_tasks
@@ -149,71 +110,81 @@
       self
     end
 
     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
           middleware.use config.session_store, config.session_options
           middleware.use ::ActionDispatch::Flash
         end
 
         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
         require_environment!
       end
@@ -223,10 +194,9 @@
       require "rails/generators"
     end
 
     def initialize_console(sandbox=false)
       require "rails/console/app"
-      require "rails/console/sandbox" if sandbox
       require "rails/console/helpers"
     end
   end
-end
+end
\ No newline at end of file