railties 3.0.0.beta → 3.0.0.beta2

data/lib/rails/commands/plugin.rb

@@ -2,7 +2,7 @@
 #
 # Installing plugins:
 #
-#   $ ./script/plugin install continuous_builder asset_timestamping
+#   $ rails plugin install continuous_builder asset_timestamping
 # 
 # Specifying revisions:
 #
@@ -319,13 +319,13 @@ module Commands
         o.separator ""
         o.separator "EXAMPLES"
         o.separator "  Install a plugin:"
-        o.separator "    #{@script_name} install continuous_builder\n"
+        o.separator "    #{@script_name} plugin install continuous_builder\n"
         o.separator "  Install a plugin from a subversion URL:"
-        o.separator "    #{@script_name} install http://dev.rubyonrails.com/svn/rails/plugins/continuous_builder\n"
+        o.separator "    #{@script_name} plugin install http://dev.rubyonrails.com/svn/rails/plugins/continuous_builder\n"
         o.separator "  Install a plugin from a git URL:"
-        o.separator "    #{@script_name} install git://github.com/SomeGuy/my_awesome_plugin.git\n"
+        o.separator "    #{@script_name} plugin install git://github.com/SomeGuy/my_awesome_plugin.git\n"
         o.separator "  Install a plugin and add a svn:externals entry to vendor/plugins"
-        o.separator "    #{@script_name} install -x continuous_builder\n"
+        o.separator "    #{@script_name} plugin install -x continuous_builder\n"
       end
     end
     
@@ -381,7 +381,7 @@ module Commands
                       "Exports the plugin, allowing you to check it into your local repository. Does not enable updates, or add an svn:externals entry.") { |v| @method = :export }
         o.on(         "-q", "--quiet",
                       "Suppresses the output from installation.",
-                      "Ignored if -v is passed (./script/plugin -v install ...)") { |v| @options[:quiet] = true }
+                      "Ignored if -v is passed (rails plugin -v install ...)") { |v| @options[:quiet] = true }
         o.on(         "-r REVISION", "--revision REVISION",
                       "Checks out the given revision from subversion or git.",
                       "Ignored if subversion/git is not used.") { |v| @options[:revision] = v }

data/lib/rails/commands/runner.rb

@@ -35,6 +35,8 @@ ARGV.delete(code_or_file)
 
 ENV["RAILS_ENV"] = options[:environment]
 
+require ENV_PATH
+
 begin
   if code_or_file.nil?
     $stderr.puts "Run '#{$0} -h' for help."

data/lib/rails/commands/server.rb

@@ -6,20 +6,21 @@ module Rails
   class Server < ::Rack::Server
     class Options
       def parse!(args)
-        options = {}
-        args    = args.dup
+        args, options = args.dup, {}
+
         opt_parser = OptionParser.new do |opts|
+          opts.banner = "Usage: rails server [options]"
           opts.on("-p", "--port=port", Integer,
-                  "Runs Rails on the specified port.", "Default: #{options[:Port]}") { |v| options[:Port] = v }
+                  "Runs Rails on the specified port.", "Default: 3000") { |v| options[:Port] = v }
           opts.on("-b", "--binding=ip", String,
-                  "Binds Rails to the specified ip.", "Default: #{options[:Host]}") { |v| options[:Host] = v }
+                  "Binds Rails to the specified ip.", "Default: 0.0.0.0") { |v| options[:Host] = v }
           opts.on("-c", "--config=file", String,
                   "Use custom rackup configuration file") { |v| options[:config] = v }
           opts.on("-d", "--daemon", "Make server run as a Daemon.") { options[:daemonize] = true }
           opts.on("-u", "--debugger", "Enable ruby-debugging for the server.") { options[:debugger] = true }
           opts.on("-e", "--environment=name", String,
                   "Specifies the environment to run this server under (test/development/production).",
-                  "Default: #{options[:environment]}") { |v| options[:environment] = v }
+                  "Default: development") { |v| options[:environment] = v }
 
           opts.separator ""
 
@@ -33,22 +34,36 @@ module Rails
       end
     end
 
+    def initialize(*)
+      super
+      set_environment
+    end
+
     def opt_parser
       Options.new
     end
 
-    def start
-      ENV["RAILS_ENV"] = options[:environment]
+    def set_environment
+      ENV["RAILS_ENV"] ||= options[:environment]
+    end
 
+    def start
       puts "=> Booting #{ActiveSupport::Inflector.demodulize(server)}"
       puts "=> Rails #{Rails.version} application starting in #{Rails.env} on http://#{options[:Host]}:#{options[:Port]}"
       puts "=> Call with -d to detach" unless options[:daemonize]
       trap(:INT) { exit }
       puts "=> Ctrl-C to shutdown server" unless options[:daemonize]
 
+      #Create required tmp directories if not found
+      %w(cache pids sessions sockets).each do |dir_to_make|
+        FileUtils.mkdir_p(Rails.root.join('tmp', dir_to_make))
+      end
+
       super
     ensure
-      puts 'Exiting' unless options[:daemonize]
+      # The '-h' option calls exit before @options is set.
+      # If we call 'options' with it unset, we get double help banners.
+      puts 'Exiting' unless @options && options[:daemonize]
     end
 
     def middleware

data/lib/rails/configuration.rb

@@ -4,96 +4,14 @@ require 'rails/rack'
 
 module Rails
   module Configuration
-    module Shared
-      def middleware
-        @@default_middleware_stack ||= ActionDispatch::MiddlewareStack.new.tap do |middleware|
-          middleware.use('::ActionDispatch::Static', lambda { Rails.public_path }, :if => lambda { Rails.application.config.serve_static_assets })
-          middleware.use('::Rack::Lock', :if => lambda { !Rails.application.config.allow_concurrency })
-          middleware.use('::Rack::Runtime')
-          middleware.use('::Rails::Rack::Logger')
-          middleware.use('::ActionDispatch::ShowExceptions', lambda { Rails.application.config.consider_all_requests_local })
-          middleware.use('::ActionDispatch::Callbacks', lambda { !Rails.application.config.cache_classes })
-          middleware.use('::ActionDispatch::Cookies')
-          middleware.use(lambda { ActionController::Base.session_store }, lambda { ActionController::Base.session_options })
-          middleware.use('::ActionDispatch::Flash', :if => lambda { ActionController::Base.session_store })
-          middleware.use(lambda { Rails.application.metal_loader.build_middleware(Rails.application.config.metals) }, :if => lambda { Rails.application.metal_loader.metals.any? })
-          middleware.use('ActionDispatch::ParamsParser')
-          middleware.use('::Rack::MethodOverride')
-          middleware.use('::ActionDispatch::Head')
-        end
-      end
-
-      # Holds generators configuration:
-      #
-      #   config.generators do |g|
-      #     g.orm             :datamapper, :migration => true
-      #     g.template_engine :haml
-      #     g.test_framework  :rspec
-      #   end
-      #
-      # If you want to disable color in console, do:
-      #
-      #   config.generators.colorize_logging = false
-      #
-      def generators
-        @@generators ||= Rails::Configuration::Generators.new
-        if block_given?
-          yield @@generators
-        else
-          @@generators
-        end
-      end
-
-      def after_initialize_blocks
-        @@after_initialize_blocks ||= []
-      end
-
-      def after_initialize(&blk)
-        after_initialize_blocks << blk if blk
-      end
-
-      def to_prepare_blocks
-        @@to_prepare_blocks ||= []
-      end
-
-      def to_prepare(&blk)
-        to_prepare_blocks << blk if blk
-      end
-
-      def respond_to?(name)
-        super || name.to_s =~ config_key_regexp
-      end
-
-    private
-
-      def method_missing(name, *args, &blk)
-        if name.to_s =~ config_key_regexp
-          return $2 == '=' ? options[$1] = args.first : options[$1]
-        end
-        super
-      end
-
-      def config_key_regexp
-        bits = config_keys.map { |n| Regexp.escape(n.to_s) }.join('|')
-        /^(#{bits})(?:=)?$/
-      end
-
-      def config_keys
-        (Railtie.railtie_names + Engine.engine_names).map { |n| n.to_s }.uniq
-      end
-
-      def options
-        @@options ||= Hash.new { |h,k| h[k] = ActiveSupport::OrderedOptions.new }
-      end
-    end
-
     class Generators #:nodoc:
-      attr_accessor :aliases, :options, :fallbacks, :colorize_logging
+      attr_accessor :aliases, :options, :templates, :fallbacks, :colorize_logging
 
       def initialize
         @aliases = Hash.new { |h,k| h[k] = {} }
         @options = Hash.new { |h,k| h[k] = {} }
         @fallbacks = {}
+        @templates = []
         @colorize_logging = true
       end
 

data/lib/rails/console/app.rb

@@ -17,8 +17,8 @@ end
 # create a new session. If a block is given, the new session will be yielded
 # to the block before being returned.
 def new_session
-  app = ActionController::Dispatcher.new
-  session = ActionController::Integration::Session.new(app)
+  app = Rails.application
+  session = ActionDispatch::Integration::Session.new(app)
   yield session if block_given?
   session
 end
@@ -26,7 +26,8 @@ end
 # reloads the environment
 def reload!(print=true)
   puts "Reloading..." if print
-  ActionDispatch::Callbacks.new(lambda {}, false)
+  # This triggers the to_prepare callbacks
+  ActionDispatch::Callbacks.new(Proc.new {}, false).call({})
   true
 end
 

data/lib/rails/console/helpers.rb

@@ -2,4 +2,6 @@ def helper
   @helper ||= ApplicationController.helpers
 end
 
-@controller = ApplicationController.new
+def controller
+  @controller ||= ApplicationController.new
+end

data/lib/rails/engine.rb

@@ -1,7 +1,91 @@
-require 'active_support/core_ext/module/delegation'
 require 'rails/railtie'
+require 'active_support/core_ext/module/delegation'
+require 'pathname'
 
 module Rails
+  # Rails::Engine allows you to wrap a specific Rails application and share it accross
+  # different applications. Since Rails 3.0, every Rails::Application is nothing
+  # more than an Engine, allowing you to share it very easily.
+  #
+  # Any Rails::Engine is also a Rails::Railtie, so the same methods (like rake_tasks and
+  # generators) and configuration available in the latter can also be used in the former.
+  #
+  # == Creating an Engine
+  #
+  # In Rails versions before to 3.0, your gems automatically behaved as Engine, however
+  # this coupled Rails to Rubygems. Since Rails 3.0, if you want a gem to automatically
+  # behave as Engine, you have to specify an Engine for it somewhere inside your plugin
+  # lib folder (similar with how we spceify a Railtie):
+  #
+  #   # lib/my_engine.rb
+  #   module MyEngine
+  #     class Engine < Rails::Engine
+  #       engine_name :my_engine
+  #     end
+  #   end
+  #
+  # Then ensure that this file is loaded at the top of your config/application.rb (or in
+  # your Gemfile) and it will automatically load models, controllers, helpers and metals
+  # inside app, load routes at "config/routes.rb", load locales at "config/locales/*",
+  # load tasks at "lib/tasks/*".
+  #
+  # == Configuration
+  #
+  # Besides the Railtie configuration which is shared across the application, in a
+  # Rails::Engine you can access load_paths, eager_load_paths and load_once_paths,
+  # which differently from a Railtie, are scoped to the current Engine.
+  #
+  # Example:
+  #
+  #   class MyEngine < Rails::Engine
+  #     # config.middleware is shared configururation
+  #     config.middleware.use MyEngine::Middleware
+  #
+  #     # Add a load path for this specific Engine
+  #     config.load_paths << File.expand_path("../lib/some/path", __FILE__)
+  #   end
+  # 
+  # == Paths
+  #
+  # Since Rails 3.0, both your Application and Engines do not have hardcoded paths.
+  # This means that you are not required to place your controllers at "app/controllers",
+  # but in any place which you find convenient.
+  #
+  # For example, let's suppose you want to lay your controllers at lib/controllers, all
+  # you need to do is:
+  #
+  #   class MyEngine < Rails::Engine
+  #     paths.app.controllers = "lib/controllers"
+  #   end
+  #
+  # You can also have your controllers being loaded from both "app/controllers" and
+  # "lib/controllers":
+  #
+  #   class MyEngine < Rails::Engine
+  #     paths.app.controllers << "lib/controllers"
+  #   end
+  #
+  # The available paths in an Engine are:
+  #
+  #   class MyEngine < Rails::Engine
+  #     paths.app                 = "app"
+  #     paths.app.controllers     = "app/controllers"
+  #     paths.app.helpers         = "app/helpers"
+  #     paths.app.models          = "app/models"
+  #     paths.app.metals          = "app/metal"
+  #     paths.app.views           = "app/views"
+  #     paths.lib                 = "lib"
+  #     paths.lib.tasks           = "lib/tasks"
+  #     paths.config              = "config"
+  #     paths.config.initializers = "config/initializers"
+  #     paths.config.locales      = "config/locales"
+  #     paths.config.routes       = "config/routes.rb"
+  #   end
+  #
+  # Your Application class adds a couple more paths to this set. And as in your Application,
+  # all folders under "app" are automatically added to the load path. So if you have
+  # "app/observers", it's added by default.
+  #
   class Engine < Railtie
     autoload :Configurable,  "rails/engine/configurable"
     autoload :Configuration, "rails/engine/configuration"
@@ -9,14 +93,15 @@ module Rails
     class << self
       attr_accessor :called_from
 
-      alias :engine_name  :railtie_name
-      alias :engine_names :railtie_names
+      # TODO Remove this. It's deprecated.
+      alias :engine_name :railtie_name
 
       def inherited(base)
-        unless abstract_railtie?(base)
+        unless base.abstract_railtie?
           base.called_from = begin
-            call_stack = caller.map { |p| p.split(':').first }
-            File.dirname(call_stack.detect { |p| p !~ %r[railties/lib/rails|rack/lib/rack] })
+            # Remove the line number from backtraces making sure we don't leave anything behind
+            call_stack = caller.map { |p| p.split(':')[0..-2].join(':') }
+            File.dirname(call_stack.detect { |p| p !~ %r[railties[\w\-\.]*/lib/rails|rack[\w\-\.]*/lib/rack] })
           end
         end
 
@@ -42,7 +127,7 @@ module Rails
     delegate :middleware, :paths, :root, :to => :config
 
     def load_tasks
-      super 
+      super
       config.paths.lib.tasks.to_a.sort.each { |ext| load(ext) }
     end
 
@@ -76,10 +161,11 @@ module Rails
       end
     end
 
+    # DEPRECATED: Remove in 3.1
     initializer :add_routing_namespaces do |app|
       paths.app.controllers.to_a.each do |load_path|
         load_path = File.expand_path(load_path)
-        Dir["#{load_path}/*/*_controller.rb"].collect do |path|
+        Dir["#{load_path}/*/**/*_controller.rb"].collect do |path|
           namespace = File.dirname(path).sub(/#{load_path}\/?/, '')
           app.routes.controller_namespaces << namespace unless namespace.empty?
         end
@@ -89,19 +175,28 @@ module Rails
     # I18n load paths are a special case since the ones added
     # later have higher priority.
     initializer :add_locales do
-      config.i18n.engines_load_path.concat(paths.config.locales.to_a)
+      config.i18n.railties_load_path.concat(paths.config.locales.to_a)
     end
 
     initializer :add_view_paths do
       views = paths.app.views.to_a
-      ActionController::Base.view_paths.unshift(*views) if defined?(ActionController)
-      ActionMailer::Base.view_paths.unshift(*views)     if defined?(ActionMailer)
+      ActiveSupport.on_load(:action_controller) do
+        prepend_view_path(views)
+      end
+
+      ActiveSupport.on_load(:action_mailer) do
+        prepend_view_path(views)
+      end
     end
 
     initializer :add_metals do |app|
       app.metal_loader.paths.unshift(*paths.app.metals.to_a)
     end
 
+    initializer :add_generator_templates do |app|
+      config.generators.templates.unshift(*paths.lib.templates.to_a)
+    end
+
     initializer :load_application_initializers do
       paths.config.initializers.to_a.sort.each do |initializer|
         load(initializer)
@@ -127,4 +222,4 @@ module Rails
       app.config.reload_engines
     end
   end
-end
+end

data/lib/rails/engine/configuration.rb

@@ -7,6 +7,7 @@ module Rails
       attr_writer :eager_load_paths, :load_once_paths, :load_paths
 
       def initialize(root=nil)
+        super()
         @root = root
       end
 
@@ -17,14 +18,19 @@ module Rails
           paths.app.controllers     "app/controllers",     :eager_load => true
           paths.app.helpers         "app/helpers",         :eager_load => true
           paths.app.models          "app/models",          :eager_load => true
-          paths.app.metals          "app/metal"
-          paths.app.views           "app/views"
+          paths.app.mailers         "app/mailers",         :eager_load => true
+          paths.app.metals          "app/metal",           :eager_load => true
+          paths.app.views           "app/views",           :eager_load => true
           paths.lib                 "lib",                 :load_path => true
           paths.lib.tasks           "lib/tasks",           :glob => "**/*.rake"
+          paths.lib.templates       "lib/templates"
           paths.config              "config"
           paths.config.initializers "config/initializers", :glob => "**/*.rb"
           paths.config.locales      "config/locales",      :glob => "*.{rb,yml}"
           paths.config.routes       "config/routes.rb"
+          paths.public              "public"
+          paths.public.javascripts  "public/javascripts"
+          paths.public.stylesheets  "public/stylesheets"
           paths
         end
       end

data/lib/rails/generators.rb

@@ -3,17 +3,23 @@ $:.unshift(activesupport_path) if File.directory?(activesupport_path) && !$:.inc
 
 require 'active_support'
 require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/object/metaclass'
+require 'active_support/core_ext/object/singleton_class'
 require 'active_support/core_ext/array/extract_options'
 require 'active_support/core_ext/hash/deep_merge'
 require 'active_support/core_ext/module/attribute_accessors'
 require 'active_support/core_ext/string/inflections'
 
 require 'rails/generators/base'
-require 'rails/generators/named_base'
 
 module Rails
   module Generators
+    autoload :Actions,         'rails/generators/actions'
+    autoload :ActiveModel,     'rails/generators/active_model'
+    autoload :Migration,       'rails/generators/migration'
+    autoload :NamedBase,       'rails/generators/named_base'
+    autoload :ResourceHelpers, 'rails/generators/resource_helpers'
+    autoload :TestCase,        'rails/generators/test_case'
+
     DEFAULT_ALIASES = {
       :rails => {
         :actions => '-a',
@@ -66,6 +72,11 @@ module Rails
       aliases.deep_merge! config.aliases
       options.deep_merge! config.options
       fallbacks.merge! config.fallbacks
+      templates_path.concat config.templates
+    end
+
+    def self.templates_path
+      @templates_path ||= []
     end
 
     def self.aliases #:nodoc:
@@ -161,7 +172,7 @@ module Rails
     end
 
     # Show help message with available generators.
-    def self.help
+    def self.help(command = 'generate')
       lookup!
 
       namespaces = subclasses.map{ |k| k.namespace }
@@ -173,7 +184,7 @@ module Rails
         groups[base] << namespace
       end
 
-      puts "Usage: rails generate GENERATOR [args] [options]"
+      puts "Usage: rails #{command} GENERATOR [args] [options]"
       puts
       puts "General options:"
       puts "  -h, [--help]     # Print generators options and usage"
@@ -191,6 +202,10 @@ module Rails
       rails.delete("app")
       print_list("rails", rails)
 
+      groups.delete("active_record") if options[:rails][:orm] == :active_record
+      groups.delete("test_unit")     if options[:rails][:test_framework] == :test_unit
+      groups.delete("erb")           if options[:rails][:template_engine] == :erb
+
       groups.sort.each { |b, n| print_list(b, n) }
     end
 
@@ -227,7 +242,7 @@ module Rails
         paths = namespaces_to_paths(namespaces)
 
         paths.each do |raw_path|
-          ["rails_generators", "generators"].each do |base|
+          ["rails/generators", "generators"].each do |base|
             path = "#{base}/#{raw_path}_generator"
 
             begin
@@ -250,7 +265,7 @@ module Rails
         load_generators_from_railties!
 
         $LOAD_PATH.each do |base|
-          Dir[File.join(base, "{generators,rails_generators}", "**", "*_generator.rb")].each do |path|
+          Dir[File.join(base, "{rails/generators,generators}", "**", "*_generator.rb")].each do |path|
             begin
               require path
             rescue Exception => e
@@ -286,4 +301,4 @@ end
 
 # If the application was already defined, configure generators,
 # otherwise you have to configure it by hand.
-Rails::Generators.configure! if Rails.respond_to?(:application) && Rails.application
+Rails::Generators.configure! if Rails.respond_to?(:application) && Rails.application