railties 3.0.20 → 3.1.0.beta1

data/lib/rails/engine/configuration.rb

@@ -4,41 +4,65 @@ module Rails
   class Engine
     class Configuration < ::Rails::Railtie::Configuration
       attr_reader :root
-      attr_writer :eager_load_paths, :autoload_once_paths, :autoload_paths
+      attr_writer :middleware, :eager_load_paths, :autoload_once_paths, :autoload_paths
+      attr_accessor :plugins
 
       def initialize(root=nil)
         super()
         @root = root
+        @generators = app_generators.dup
+      end
+
+      # Returns the middleware stack for the engine.
+      def middleware
+        @middleware ||= Rails::Configuration::MiddlewareStackProxy.new
+      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 #:nodoc
+        @generators ||= Rails::Configuration::Generators.new
+        yield(@generators) if block_given?
+        @generators
       end
 
       def paths
         @paths ||= begin
           paths = Rails::Paths::Root.new(@root)
-          paths.app                 "app",                 :eager_load => true, :glob => "*"
-          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.mailers         "app/mailers",         :eager_load => true
-          paths.app.views           "app/views"
-          paths.lib                 "lib",                 :load_path => true
-          paths.lib.tasks           "lib/tasks",           :glob => "**/*.rake"
-          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.add "app",                 :eager_load => true, :glob => "*"
+          paths.add "app/assets",          :glob => "*"
+          paths.add "app/controllers",     :eager_load => true
+          paths.add "app/helpers",         :eager_load => true
+          paths.add "app/models",          :eager_load => true
+          paths.add "app/mailers",         :eager_load => true
+          paths.add "app/views"
+          paths.add "lib",                 :load_path => true
+          paths.add "lib/tasks",           :glob => "**/*.rake"
+          paths.add "config"
+          paths.add "config/environments", :glob => "#{Rails.env}.rb"
+          paths.add "config/initializers", :glob => "**/*.rb"
+          paths.add "config/locales",      :glob => "*.{rb,yml}"
+          paths.add "config/routes",       :with => "config/routes.rb"
+          paths.add "db"
+          paths.add "db/migrate"
+          paths.add "db/seeds",            :with => "db/seeds.rb"
+          paths.add "vendor",              :load_path => true
+          paths.add "vendor/assets",       :glob => "*"
+          paths.add "vendor/plugins"
           paths
         end
       end
 
-      def generators #:nodoc:
-        ActiveSupport::Deprecation.warn "config.generators in Rails::Engine is deprecated. " <<
-          "Please use config.app_generators instead."
-        super
-      end
-
       def root=(value)
         @root = paths.path = Pathname.new(value).expand_path
       end
@@ -54,33 +78,6 @@ module Rails
       def autoload_paths
         @autoload_paths ||= paths.autoload_paths
       end
-
-      def load_paths
-        ActiveSupport::Deprecation.warn "config.load_paths is deprecated. Please use config.autoload_paths instead."
-        autoload_paths
-      end
-
-      def load_paths=(paths)
-        ActiveSupport::Deprecation.warn "config.load_paths= is deprecated. Please use config.autoload_paths instead."
-        self.autoload_paths = paths
-      end
-
-      # Rails 3, by default, uses bundler, which shims the Kernel#gem method so that it should
-      # behave correctly for this deprecation.
-      def gem(name, options = {})
-        super name, options[:version] || ">= 0"
-        require options[:lib] || name
-      rescue Gem::LoadError
-        msg = "config.gem is deprecated, and you tried to activate the '#{name}' gem (#{options.inspect}) using it.\n"
-
-        if File.exist?("#{Rails.root}/Gemfile")
-          msg << "Please add '#{name}' to your Gemfile."
-        else
-          msg << "Please update your application to use bundler."
-        end
-        ActiveSupport::Deprecation.warn(msg, caller)
-        exit
-      end
     end
   end
 end

data/lib/rails/engine/railties.rb

@@ -0,0 +1,33 @@
+module Rails
+  class Engine < Railtie
+    class Railties
+      # TODO Write tests for this behavior extracted from Application
+      def initialize(config)
+        @config = config
+      end
+
+      def all(&block)
+        @all ||= plugins
+        @all.each(&block) if block
+        @all
+      end
+
+      def plugins
+        @plugins ||= begin
+          plugin_names = (@config.plugins || [:all]).map { |p| p.to_sym }
+          Plugin.all(plugin_names, @config.paths["vendor/plugins"].existent)
+        end
+      end
+
+      def self.railties
+        @railties ||= ::Rails::Railtie.subclasses.map(&:instance)
+      end
+
+      def self.engines
+        @engines ||= ::Rails::Engine.subclasses.map(&:instance)
+      end
+
+      delegate :railties, :engines, :to => "self.class"
+    end
+  end
+end

data/lib/rails/generators.rb

@@ -24,9 +24,12 @@ module Rails
       :rails => {
         :actions => '-a',
         :orm => '-o',
+        :javascripts => '-j',
+        :javascript_engine => '-je',
         :resource_controller => '-c',
         :scaffold_controller => '-c',
         :stylesheets => '-y',
+        :stylesheet_engine => '-se',
         :template_engine => '-e',
         :test_framework => '-t'
       },
@@ -43,14 +46,18 @@ module Rails
 
     DEFAULT_OPTIONS = {
       :rails => {
+        :assets => true,
         :force_plural => false,
         :helper => true,
-        :orm => nil,
         :integration_tool => nil,
+        :javascripts => true,
+        :javascript_engine => nil,
+        :orm => nil,
         :performance_tool => nil,
         :resource_controller => :controller,
         :scaffold_controller => :scaffold_controller,
         :stylesheets => true,
+        :stylesheet_engine => nil,
         :test_framework => nil,
         :template_engine => :erb
       },
@@ -140,10 +147,7 @@ module Rails
 
       lookup(lookups)
 
-      namespaces = subclasses.inject({}) do |hash, klass|
-        hash[klass.namespace] = klass
-        hash
-      end
+      namespaces = Hash[subclasses.map { |klass| [klass.namespace, klass] }]
 
       lookups.each do |namespace|
         klass = namespaces[namespace]
@@ -231,6 +235,7 @@ module Rails
       rails = groups.delete("rails")
       rails.map! { |n| n.sub(/^rails:/, '') }
       rails.delete("app")
+      rails.delete("plugin_new")
       print_list("rails", rails)
 
       hidden_namespaces.each {|n| groups.delete(n.to_s) }
@@ -304,6 +309,7 @@ module Rails
         $LOAD_PATH.each do |base|
           Dir[File.join(base, "{rails/generators,generators}", "**", "*_generator.rb")].each do |path|
             begin
+              path = path.sub("#{base}/", "")
               require path
             rescue Exception => e
               # No problem

data/lib/rails/generators/actions.rb

@@ -1,5 +1,4 @@
 require 'open-uri'
-require 'active_support/deprecation'
 require 'rbconfig'
 
 module Rails
@@ -53,20 +52,6 @@ module Rails
         options = args.extract_options!
         name, version = args
 
-        # Deal with deprecated options
-        { :env => :group, :only => :group,
-          :lib => :require, :require_as => :require }.each do |old, new|
-          next unless options[old]
-          options[new] = options.delete(old)
-          ActiveSupport::Deprecation.warn "#{old.inspect} option in gem is deprecated, use #{new.inspect} instead"
-        end
-
-        # Deal with deprecated source
-        if source = options.delete(:source)
-          ActiveSupport::Deprecation.warn ":source option in gem is deprecated, use add_source method instead"
-          add_source(source)
-        end
-
         # Set the message to be shown in logs. Uses the git repo if one is given,
         # otherwise use name (version).
         parts, message = [ name.inspect ], name
@@ -202,8 +187,8 @@ module Rails
       #   initializer("globals.rb") do
       #     data = ""
       #
-      #     ['MY_WORK', 'ADMINS', 'BEST_COMPANY_EVAR'].each do
-      #       data << "#{const} = :entp"
+      #     ['MY_WORK', 'ADMINS', 'BEST_COMPANY_EVAR'].each do |const|
+      #       data << "#{const} = :entp\n"
       #     end
       #
       #     data
@@ -257,16 +242,6 @@ module Rails
         in_root { run("#{extify(:capify)} .", :verbose => false) }
       end
 
-      # Add Rails to /vendor/rails
-      #
-      # ==== Example
-      #
-      #   freeze!
-      #
-      def freeze!(args={})
-        ActiveSupport::Deprecation.warn "freeze! is deprecated since your rails app now comes bundled with Rails by default, please check your Gemfile"
-      end
-
       # Make an entry in Rails routing file config/routes.rb
       #
       # === Example

data/lib/rails/generators/app_base.rb

@@ -0,0 +1,216 @@
+require 'digest/md5'
+require 'active_support/secure_random'
+require 'active_support/core_ext/string/strip'
+require 'rails/version' unless defined?(Rails::VERSION)
+require 'rbconfig'
+require 'open-uri'
+require 'uri'
+
+module Rails
+  module Generators
+    class AppBase < Base
+      DATABASES = %w( mysql oracle postgresql sqlite3 frontbase ibm_db )
+      JDBC_DATABASES = %w( jdbcmysql jdbcsqlite3 jdbcpostgresql )
+      DATABASES.concat(JDBC_DATABASES)
+
+      attr_accessor :rails_template
+      add_shebang_option!
+
+      argument :app_path,               :type => :string
+
+      def self.add_shared_options_for(name)
+        class_option :builder,            :type => :string, :aliases => "-b",
+                                          :desc => "Path to a #{name} builder (can be a filesystem path or URL)"
+
+        class_option :template,           :type => :string, :aliases => "-m",
+                                          :desc => "Path to an #{name} template (can be a filesystem path or URL)"
+
+        class_option :skip_gemfile,       :type => :boolean, :default => false,
+                                          :desc => "Don't create a Gemfile"
+
+        class_option :skip_git,           :type => :boolean, :aliases => "-G", :default => false,
+                                          :desc => "Skip Git ignores and keeps"
+
+        class_option :skip_active_record, :type => :boolean, :aliases => "-O", :default => false,
+                                          :desc => "Skip Active Record files"
+
+        class_option :database,           :type => :string, :aliases => "-d", :default => "sqlite3",
+                                          :desc => "Preconfigure for selected database (options: #{DATABASES.join('/')})"
+
+        class_option :javascript,         :type => :string, :aliases => '-j', :default => 'jquery',
+                                          :desc => 'Preconfigure for selected JavaScript library'
+
+        class_option :skip_javascript,    :type => :boolean, :aliases => "-J", :default => false,
+                                          :desc => "Skip JavaScript files"
+
+        class_option :dev,                :type => :boolean, :default => false,
+                                          :desc => "Setup the #{name} with Gemfile pointing to your Rails checkout"
+
+        class_option :edge,               :type => :boolean, :default => false,
+                                          :desc => "Setup the #{name} with Gemfile pointing to Rails repository"
+
+        class_option :skip_test_unit,     :type => :boolean, :aliases => "-T", :default => false,
+                                          :desc => "Skip Test::Unit files"
+
+        class_option :help,               :type => :boolean, :aliases => "-h", :group => :rails,
+                                          :desc => "Show this help message and quit"
+
+        class_option :old_style_hash,     :type => :boolean, :default => false,
+                                          :desc => "Force using old style hash (:foo => 'bar') on Ruby >= 1.9"
+      end
+
+      def initialize(*args)
+        @original_wd = Dir.pwd
+
+        super
+      end
+
+    protected
+
+      def builder
+        @builder ||= begin
+          if path = options[:builder]
+            if URI(path).is_a?(URI::HTTP)
+              contents = open(path, "Accept" => "application/x-thor-template") {|io| io.read }
+            else
+              contents = open(File.expand_path(path, @original_wd)) {|io| io.read }
+            end
+
+            prok = eval("proc { #{contents} }", TOPLEVEL_BINDING, path, 1)
+            instance_eval(&prok)
+          end
+
+          builder_class = get_builder_class
+          builder_class.send(:include, ActionMethods)
+          builder_class.new(self)
+        end
+      end
+
+      def build(meth, *args)
+        builder.send(meth, *args) if builder.respond_to?(meth)
+      end
+
+      def create_root
+        self.destination_root = File.expand_path(app_path, destination_root)
+        valid_const?
+
+        empty_directory '.'
+        set_default_accessors!
+        FileUtils.cd(destination_root) unless options[:pretend]
+      end
+
+      def apply_rails_template
+        apply rails_template if rails_template
+      rescue Thor::Error, LoadError, Errno::ENOENT => e
+        raise Error, "The template [#{rails_template}] could not be loaded. Error: #{e}"
+      end
+
+      def set_default_accessors!
+        self.rails_template = case options[:template]
+          when /^https?:\/\//
+            options[:template]
+          when String
+            File.expand_path(options[:template], Dir.pwd)
+          else
+            options[:template]
+        end
+      end
+
+      def database_gemfile_entry
+        entry = options[:skip_active_record] ? "" : "gem '#{gem_for_database}'"
+        if options[:database] == 'mysql'
+          if options.dev? || options.edge?
+            entry += ", :git => 'git://github.com/brianmario/mysql2.git'"
+          else
+            entry += "\n# gem 'mysql2', :git => 'git://github.com/brianmario/mysql2.git'"
+          end
+        end
+        entry + "\n"
+      end
+
+      def rails_gemfile_entry
+        if options.dev?
+          <<-GEMFILE.strip_heredoc
+            gem 'rails',     :path => '#{Rails::Generators::RAILS_DEV_PATH}'
+          GEMFILE
+        elsif options.edge?
+          <<-GEMFILE.strip_heredoc
+            gem 'rails',     :git => 'git://github.com/rails/rails.git'
+          GEMFILE
+        else
+          <<-GEMFILE.strip_heredoc
+            gem 'rails', '#{Rails::VERSION::STRING}'
+
+            # Bundle edge Rails instead:
+            # gem 'rails',     :git => 'git://github.com/rails/rails.git'
+          GEMFILE
+        end
+      end
+
+      def gem_for_database
+        # %w( mysql oracle postgresql sqlite3 frontbase ibm_db jdbcmysql jdbcsqlite3 jdbcpostgresql )
+        case options[:database]
+        when "oracle"     then "ruby-oci8"
+        when "postgresql" then "pg"
+        when "frontbase"  then "ruby-frontbase"
+        when "mysql"      then "mysql2"
+        when "jdbcmysql"  then "activerecord-jdbcmysql-adapter"
+        when "jdbcsqlite3"  then "activerecord-jdbcsqlite3-adapter"
+        when "jdbcpostgresql"  then "activerecord-jdbcpostgresql-adapter"
+        else options[:database]
+        end
+      end
+
+      def gem_for_ruby_debugger
+        if RUBY_VERSION < "1.9.2"
+          "gem 'ruby-debug'"
+        else
+          "gem 'ruby-debug19', :require => 'ruby-debug'"
+        end
+      end
+
+      def gem_for_turn
+        unless RUBY_VERSION < "1.9.2"
+          <<-GEMFILE.strip_heredoc
+            group :test do
+              # Pretty printed test output
+              gem 'turn', :require => false
+            end
+          GEMFILE
+        end
+      end
+
+      def gem_for_javascript
+        "gem '#{options[:javascript]}-rails'" unless options[:skip_javascript]
+      end
+
+      def bundle_if_dev_or_edge
+        bundle_command = File.basename(Thor::Util.ruby_command).sub(/ruby/, 'bundle')
+        run "#{bundle_command} install" if dev_or_edge?
+      end
+
+      def dev_or_edge?
+        options.dev? || options.edge?
+      end
+
+      def empty_directory_with_gitkeep(destination, config = {})
+        empty_directory(destination, config)
+        git_keep(destination)
+      end
+
+      def git_keep(destination)
+        create_file("#{destination}/.gitkeep") unless options[:skip_git]
+      end
+
+      # Returns Ruby 1.9 style key-value pair if current code is running on
+      # Ruby 1.9.x. Returns the old-style (with hash rocket) otherwise.
+      def key_value(key, value)
+        if options[:old_style_hash] || RUBY_VERSION < '1.9'
+          ":#{key} => #{value}"
+        else
+          "#{key}: #{value}"
+        end
+      end
+    end
+  end
+end