railties 4.0.13 → 4.1.0.beta1

data/lib/rails/commands/console.rb

@@ -94,8 +94,8 @@ module Rails
       require 'debugger'
       puts "=> Debugger enabled"
     rescue LoadError
-      puts "You're missing the 'debugger' gem. Add it to your Gemfile, bundle, and try again."
-      exit
+      puts "You're missing the 'debugger' gem. Add it to your Gemfile, bundle it and try again."
+      exit(1)
     end
   end
 end

data/lib/rails/commands/dbconsole.rb

@@ -44,7 +44,7 @@ module Rails
 
         find_cmd_and_exec(['mysql', 'mysql5'], *args)
 
-      when "postgresql", "postgres"
+      when "postgresql", "postgres", "postgis"
         ENV['PGUSER']     = config["username"] if config["username"]
         ENV['PGHOST']     = config["host"] if config["host"]
         ENV['PGPORT']     = config["port"].to_s if config["port"]

data/lib/rails/commands/plugin.rb

@@ -0,0 +1,23 @@
+if ARGV.first != "new"
+  ARGV[0] = "--help"
+else
+  ARGV.shift
+  unless ARGV.delete("--no-rc")
+    customrc = ARGV.index{ |x| x.include?("--rc=") }
+    railsrc = if customrc
+                File.expand_path(ARGV.delete_at(customrc).gsub(/--rc=/, ""))
+              else
+                File.join(File.expand_path("~"), '.railsrc')
+              end
+    if File.exist?(railsrc)
+      extra_args_string = File.read(railsrc)
+      extra_args = extra_args_string.split(/\n+/).map {|l| l.split}.flatten
+      puts "Using #{extra_args.join(" ")} from #{railsrc}"
+      ARGV.insert(1, *extra_args)
+    end
+  end
+end
+
+require 'rails/generators'
+require 'rails/generators/rails/plugin/plugin_generator'
+Rails::Generators::PluginGenerator.start

data/lib/rails/commands/runner.rb

@@ -48,7 +48,7 @@ if code_or_file.nil?
   exit 1
 elsif File.exist?(code_or_file)
   $0 = code_or_file
-  eval(File.read(code_or_file), nil, code_or_file)
+  Kernel.load code_or_file
 else
   eval(code_or_file, binding, __FILE__, __LINE__)
 end

data/lib/rails/commands/server.rb

@@ -1,6 +1,7 @@
 require 'fileutils'
 require 'optparse'
 require 'action_dispatch'
+require 'rails'
 
 module Rails
   class Server < ::Rack::Server
@@ -21,7 +22,7 @@ module Rails
           opts.on("-e", "--environment=name", String,
                   "Specifies the environment to run this server under (test/development/production).",
                   "Default: development") { |v| options[:environment] = v }
-          opts.on("-P","--pid=pid",String,
+          opts.on("-P", "--pid=pid", String,
                   "Specifies the PID file.",
                   "Default: tmp/pids/server.pid") { |v| options[:pid] = v }
 
@@ -32,7 +33,8 @@ module Rails
 
         opt_parser.parse! args
 
-        options[:server] = args.shift
+        options[:log_stdout] = options[:daemonize].blank? && (options[:environment] || Rails.env) == "development"
+        options[:server]     = args.shift
         options
       end
     end
@@ -59,27 +61,10 @@ module Rails
     end
 
     def start
-      url = "#{options[:SSLEnable] ? 'https' : 'http'}://#{options[:Host]}:#{options[:Port]}"
-      puts "=> Booting #{ActiveSupport::Inflector.demodulize(server)}"
-      puts "=> Rails #{Rails.version} application starting in #{Rails.env} on #{url}"
-      puts "=> Run `rails server -h` for more startup options"
+      print_boot_information
       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(File.join(Rails.root, 'tmp', dir_to_make))
-      end
-
-      unless options[:daemonize]
-        wrapped_app # touch the app so the logger is set up
-
-        console = ActiveSupport::Logger.new($stdout)
-        console.formatter = Rails.logger.formatter
-        console.level = Rails.logger.level
-
-        Rails.logger.extend(ActiveSupport::Logger.broadcast(console))
-      end
+      create_tmp_directories
+      log_to_stdout if options[:log_stdout]
 
       super
     ensure
@@ -90,7 +75,7 @@ module Rails
 
     def middleware
       middlewares = []
-      middlewares << [Rails::Rack::Debugger]  if options[:debugger]
+      middlewares << [Rails::Rack::Debugger] if options[:debugger]
       middlewares << [::Rack::ContentLength]
 
       # FIXME: add Rack::Lock in the case people are using webrick.
@@ -110,14 +95,45 @@ module Rails
 
     def default_options
       super.merge({
-        Port:         3000,
-        DoNotReverseLookup:  true,
-        environment:  (ENV['RAILS_ENV'] || ENV['RACK_ENV'] || "development").dup,
-        daemonize:    false,
-        debugger:     false,
-        pid:          File.expand_path("tmp/pids/server.pid"),
-        config:       File.expand_path("config.ru")
+        Port:               3000,
+        DoNotReverseLookup: true,
+        environment:        (ENV['RAILS_ENV'] || ENV['RACK_ENV'] || "development").dup,
+        daemonize:          false,
+        debugger:           false,
+        pid:                File.expand_path("tmp/pids/server.pid"),
+        config:             File.expand_path("config.ru")
       })
     end
+
+    private
+
+      def print_boot_information
+        url = "#{options[:SSLEnable] ? 'https' : 'http'}://#{options[:Host]}:#{options[:Port]}"
+        puts "=> Booting #{ActiveSupport::Inflector.demodulize(server)}"
+        puts "=> Rails #{Rails.version} application starting in #{Rails.env} on #{url}"
+        puts "=> Run `rails server -h` for more startup options"
+
+        if options[:Host].to_s.match(/0\.0\.0\.0/)
+          puts "=> Notice: server is listening on all interfaces (#{options[:Host]}). Consider using 127.0.0.1 (--binding option)"
+        end
+
+        puts "=> Ctrl-C to shutdown server" unless options[:daemonize]
+      end
+
+      def create_tmp_directories
+        %w(cache pids sessions sockets).each do |dir_to_make|
+          FileUtils.mkdir_p(File.join(Rails.root, 'tmp', dir_to_make))
+        end
+      end
+
+      def log_to_stdout
+        wrapped_app # touch the app so the logger is set up
+
+        console = ActiveSupport::Logger.new($stdout)
+        console.formatter = Rails.logger.formatter
+        console.level = Rails.logger.level
+
+        Rails.logger.extend(ActiveSupport::Logger.broadcast(console))
+      end
   end
 end

data/lib/rails/configuration.rb

@@ -1,4 +1,3 @@
-require 'active_support/deprecation'
 require 'active_support/ordered_options'
 require 'active_support/core_ext/object'
 require 'rails/paths'
@@ -60,6 +59,10 @@ module Rails
         @operations << [__method__, args, block]
       end
 
+      def unshift(*args, &block)
+        @operations << [__method__, args, block]
+      end
+
       def merge_into(other) #:nodoc:
         @operations.each do |operation, args, block|
           other.send(operation, *args, &block)

data/lib/rails/console/helpers.rb

@@ -1,9 +1,15 @@
 module Rails
   module ConsoleMethods
+    # Gets the helper methods available to the controller.
+    #
+    # This method assumes an +ApplicationController+ exists, and it extends +ActionController::Base+
     def helper
       @helper ||= ApplicationController.helpers
     end
 
+    # Gets a new instance of a controller object.
+    #
+    # This method assumes an +ApplicationController+ exists, and it extends +ActionController::Base+
     def controller
       @controller ||= ApplicationController.new
     end

data/lib/rails/engine.rb

@@ -124,7 +124,7 @@ module Rails
   #
   # Now you can mount your engine in application's routes just like that:
   #
-  #   MyRailsApp::Application.routes.draw do
+  #   Rails.application.routes.draw do
   #     mount MyEngine::Engine => "/engine"
   #   end
   #
@@ -154,7 +154,7 @@ module Rails
   # Note that now there can be more than one router in your application, and it's better to avoid
   # passing requests through many routers. Consider this situation:
   #
-  #   MyRailsApp::Application.routes.draw do
+  #   Rails.application.routes.draw do
   #     mount MyEngine::Engine => "/blog"
   #     get "/blog/omg" => "main#omg"
   #   end
@@ -164,7 +164,7 @@ module Rails
   # and if there is no such route in +Engine+'s routes, it will be dispatched to <tt>main#omg</tt>.
   # It's much better to swap that:
   #
-  #   MyRailsApp::Application.routes.draw do
+  #   Rails.application.routes.draw do
   #     get "/blog/omg" => "main#omg"
   #     mount MyEngine::Engine => "/blog"
   #   end
@@ -251,7 +251,7 @@ module Rails
   # created to allow you to do that. Consider such a scenario:
   #
   #   # config/routes.rb
-  #   MyApplication::Application.routes.draw do
+  #   Rails.application.routes.draw do
   #     mount MyEngine::Engine => "/my_engine", as: "my_engine"
   #     get "/foo" => "foo#index"
   #   end
@@ -260,7 +260,7 @@ module Rails
   #
   #   class FooController < ApplicationController
   #     def index
-  #       my_engine.root_url #=> /my_engine/
+  #       my_engine.root_url # => /my_engine/
   #     end
   #   end
   #
@@ -269,7 +269,7 @@ module Rails
   #   module MyEngine
   #     class BarController
   #       def index
-  #         main_app.foo_path #=> /foo
+  #         main_app.foo_path # => /foo
   #       end
   #     end
   #   end
@@ -351,8 +351,13 @@ module Rails
           Rails::Railtie::Configuration.eager_load_namespaces << base
 
           base.called_from = begin
-            # Remove the line number from backtraces making sure we don't leave anything behind
-            call_stack = caller.map { |p| p.sub(/:\d+.*/, '') }
+            call_stack = if Kernel.respond_to?(:caller_locations)
+              caller_locations.map(&:path)
+            else
+              # Remove the line number from backtraces making sure we don't leave anything behind
+              caller.map { |p| p.sub(/:\d+.*/, '') }
+            end
+
             File.dirname(call_stack.detect { |p| p !~ %r[railties[\w.-]*/lib/rails|rack[\w.-]*/lib/rack] })
           end
         end
@@ -447,7 +452,7 @@ module Rails
       self
     end
 
-    # Load rails generators and invoke the registered hooks.
+    # Load Rails generators and invoke the registered hooks.
     # Check <tt>Rails::Railtie.generators</tt> for more info.
     def load_generators(app=self)
       require "rails/generators"
@@ -460,7 +465,7 @@ module Rails
     # files inside eager_load paths.
     def eager_load!
       config.eager_load_paths.each do |load_path|
-        matcher = /\A#{Regexp.escape(load_path)}\/(.*)\.rb\Z/
+        matcher = /\A#{Regexp.escape(load_path.to_s)}\/(.*)\.rb\Z/
         Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
           require_dependency file.sub(matcher, '\1')
         end
@@ -564,10 +569,10 @@ module Rails
     end
 
     initializer :add_routing_paths do |app|
-      routing_paths = self.paths["config/routes.rb"].existent
+      paths = self.paths["config/routes.rb"].existent
 
-      if routes? || routing_paths.any?
-        app.routes_reloader.paths.unshift(*routing_paths)
+      if routes? || paths.any?
+        app.routes_reloader.paths.unshift(*paths)
         app.routes_reloader.route_sets << routes
       end
     end
@@ -606,7 +611,7 @@ module Rails
 
     initializer :load_config_initializers do
       config.paths["config/initializers"].existent.sort.each do |initializer|
-        load(initializer)
+        load_config_initializer(initializer)
       end
     end
 
@@ -634,17 +639,23 @@ module Rails
       end
     end
 
+    def routes? #:nodoc:
+      @routes
+    end
+
     protected
 
+    def load_config_initializer(initializer)
+      ActiveSupport::Notifications.instrument('load_config_initializer.railties', initializer: initializer) do
+        load(initializer)
+      end
+    end
+
     def run_tasks_blocks(*) #:nodoc:
       super
       paths["lib/tasks"].existent.sort.each { |ext| load(ext) }
     end
 
-    def routes? #:nodoc:
-      @routes
-    end
-
     def has_migrations? #:nodoc:
       paths["db/migrate"].existent.any?
     end

data/lib/rails/engine/commands.rb

@@ -27,7 +27,7 @@ else
   puts <<-EOT
 Usage: rails COMMAND [ARGS]
 
-The common rails commands available for engines are:
+The common Rails commands available for engines are:
  generate    Generate new code (short-cut alias: "g")
  destroy     Undo code generated with "generate" (short-cut alias: "d")
 

data/lib/rails/engine/railties.rb

@@ -9,10 +9,6 @@ module Rails
           ::Rails::Engine.subclasses.map(&:instance)
       end
 
-      def self.engines
-        @engines ||= ::Rails::Engine.subclasses.map(&:instance)
-      end
-
       def each(*args, &block)
         _all.each(*args, &block)
       end
@@ -20,10 +16,6 @@ module Rails
       def -(others)
         _all - others
       end
-
-      delegate :engines, to: "self.class"
     end
   end
 end
-
-ActiveSupport::Deprecation.deprecate_methods(Rails::Engine::Railties, :engines)

data/lib/rails/generators.rb

@@ -1,6 +1,8 @@
 activesupport_path = File.expand_path('../../../../activesupport/lib', __FILE__)
 $:.unshift(activesupport_path) if File.directory?(activesupport_path) && !$:.include?(activesupport_path)
 
+require 'thor/group'
+
 require 'active_support'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/kernel/singleton_class'
@@ -9,12 +11,11 @@ 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'
-
 module Rails
   module Generators
     autoload :Actions,         'rails/generators/actions'
     autoload :ActiveModel,     'rails/generators/active_model'
+    autoload :Base,            'rails/generators/base'
     autoload :Migration,       'rails/generators/migration'
     autoload :NamedBase,       'rails/generators/named_base'
     autoload :ResourceHelpers, 'rails/generators/resource_helpers'
@@ -225,7 +226,7 @@ module Rails
       rails = groups.delete("rails")
       rails.map! { |n| n.sub(/^rails:/, '') }
       rails.delete("app")
-      rails.delete("plugin_new")
+      rails.delete("plugin")
       print_list("rails", rails)
 
       hidden_namespaces.each { |n| groups.delete(n.to_s) }

data/lib/rails/generators/actions.rb

@@ -86,7 +86,7 @@ module Rails
       #   end
       def environment(data=nil, options={}, &block)
         sentinel = /class [a-z_:]+ < Rails::Application/i
-        env_file_sentinel = /::Application\.configure do/
+        env_file_sentinel = /Rails\.application\.configure do/
         data = block.call if !data && block_given?
 
         in_root do

data/lib/rails/generators/active_model.rb

@@ -1,5 +1,3 @@
-require 'active_support/deprecation'
-
 module Rails
   module Generators
     # ActiveModel is a class to be implemented by each ORM to allow Rails to
@@ -65,12 +63,6 @@ module Rails
         "#{name}.update(#{params})"
       end
 
-      def update_attributes(*args) # :nodoc:
-        ActiveSupport::Deprecation.warn("Calling '@orm_instance.update_attributes' " \
-          "is deprecated, please use '@orm_instance.update' instead.")
-        update(*args)
-      end
-
       # POST create
       # PATCH/PUT update
       def errors

data/lib/rails/generators/app_base.rb

@@ -1,10 +1,10 @@
 require 'digest/md5'
-require 'securerandom'
 require 'active_support/core_ext/string/strip'
 require 'rails/version' unless defined?(Rails::VERSION)
-require 'rbconfig'
 require 'open-uri'
 require 'uri'
+require 'rails/generators'
+require 'active_support/core_ext/array/extract_options'
 
 module Rails
   module Generators
@@ -18,6 +18,10 @@ module Rails
 
       argument :app_path, type: :string
 
+      def self.strict_args_position
+        false
+      end
+
       def self.add_shared_options_for(name)
         class_option :template,           type: :string, aliases: '-m',
                                           desc: "Path to some #{name} template (can be a filesystem path or URL)"
@@ -37,9 +41,15 @@ module Rails
         class_option :skip_active_record, type: :boolean, aliases: '-O', default: false,
                                           desc: 'Skip Active Record files'
 
+        class_option :skip_action_view,   type: :boolean, aliases: '-V', default: false,
+                                          desc: 'Skip Action View files'
+
         class_option :skip_sprockets,     type: :boolean, aliases: '-S', default: false,
                                           desc: 'Skip Sprockets files'
 
+        class_option :skip_spring,        type: :boolean, default: false,
+                                          desc: "Don't install Spring application preloader"
+
         class_option :database,           type: :string, aliases: '-d', default: 'sqlite3',
                                           desc: "Preconfigure for selected database (options: #{DATABASES.join('/')})"
 
@@ -69,13 +79,49 @@ module Rails
       end
 
       def initialize(*args)
-        @original_wd = Dir.pwd
+        @original_wd   = Dir.pwd
+        @gem_filter    = lambda { |gem| true }
+        @extra_entries = []
         super
         convert_database_option_for_jruby
       end
 
     protected
 
+      def gemfile_entry(name, *args)
+        options = args.extract_options!
+        version = args.first
+        github = options[:github]
+        path   = options[:path]
+
+        if github
+          @extra_entries << GemfileEntry.github(name, github)
+        elsif path
+          @extra_entries << GemfileEntry.path(name, path)
+        else
+          @extra_entries << GemfileEntry.version(name, version)
+        end
+        self
+      end
+
+      def gemfile_entries
+        [ rails_gemfile_entry,
+          database_gemfile_entry,
+          assets_gemfile_entry,
+          javascript_gemfile_entry,
+          jbuilder_gemfile_entry,
+          sdoc_gemfile_entry,
+          platform_dependent_gemfile_entry,
+          spring_gemfile_entry,
+          @extra_entries].flatten.find_all(&@gem_filter)
+      end
+
+      def add_gem_entry_filter
+        @gem_filter = lambda { |next_filter, entry|
+          yield(entry) && next_filter.call(entry)
+        }.curry[@gem_filter]
+      end
+
       def builder
         @builder ||= begin
           builder_class = get_builder_class
@@ -89,21 +135,81 @@ module Rails
       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
 
+      class TemplateRecorder < ::BasicObject # :nodoc:
+        attr_reader :gems
+
+        def initialize(target)
+          @target         = target
+          # unfortunately, instance eval has access to these ivars
+          @app_const      = target.send :app_const if target.respond_to?(:app_const, true)
+          @app_const_base = target.send :app_const_base if target.respond_to?(:app_const_base, true)
+          @app_name       = target.send :app_name if target.respond_to?(:app_name, true)
+          @commands       = []
+          @gems           = []
+        end
+
+        def gemfile_entry(*args)
+          @target.send :gemfile_entry, *args
+        end
+
+        def add_gem_entry_filter(*args, &block)
+          @target.send :add_gem_entry_filter, *args, &block
+        end
+
+        def method_missing(name, *args, &block)
+          @commands << [name, args, block]
+        end
+
+        def respond_to_missing?(method, priv = false)
+          super || @target.respond_to?(method, priv)
+        end
+
+        def replay!
+          @commands.each do |name, args, block|
+            @target.send name, *args, &block
+          end
+        end
+      end
+
       def apply_rails_template
-        apply rails_template if rails_template
+        @recorder = TemplateRecorder.new self
+
+        apply(rails_template, target: @recorder) if rails_template
       rescue Thor::Error, LoadError, Errno::ENOENT => e
         raise Error, "The template [#{rails_template}] could not be loaded. Error: #{e}"
       end
 
+      def replay_template
+        @recorder.replay! if @recorder
+      end
+
+      def apply(path, config={})
+        verbose = config.fetch(:verbose, true)
+        target  = config.fetch(:target, self)
+        is_uri  = path =~ /^https?\:\/\//
+        path    = find_in_source_paths(path) unless is_uri
+
+        say_status :apply, path, verbose
+        shell.padding += 1 if verbose
+
+        if is_uri
+          contents = open(path, "Accept" => "application/x-thor-template") {|io| io.read }
+        else
+          contents = open(path) {|io| io.read }
+        end
+
+        target.instance_eval(contents, path)
+        shell.padding -= 1 if verbose
+      end
+
       def set_default_accessors!
+        self.destination_root = File.expand_path(app_path, destination_root)
         self.rails_template = case options[:template]
           when /^https?:\/\//
             options[:template]
@@ -115,37 +221,52 @@ module Rails
       end
 
       def database_gemfile_entry
-        options[:skip_active_record] ? "" :
-          <<-GEMFILE.strip_heredoc
-            # Use #{options[:database]} as the database for Active Record
-            gem '#{gem_for_database}'
-          GEMFILE
+        return [] if options[:skip_active_record]
+        GemfileEntry.version gem_for_database, nil,
+                            "Use #{options[:database]} as the database for Active Record"
       end
 
       def include_all_railties?
-        !options[:skip_active_record] && !options[:skip_test_unit] && !options[:skip_sprockets]
+        !options[:skip_active_record] && !options[:skip_action_view] && !options[:skip_test_unit] && !options[:skip_sprockets]
       end
 
       def comment_if(value)
         options[value] ? '# ' : ''
       end
 
+      class GemfileEntry < Struct.new(:name, :version, :comment, :options, :commented_out)
+        def initialize(name, version, comment, options = {}, commented_out = false)
+          super
+        end
+
+        def self.github(name, github, comment = nil)
+          new(name, nil, comment, github: github)
+        end
+
+        def self.version(name, version, comment = nil)
+          new(name, version, comment)
+        end
+
+        def self.path(name, path, comment = nil)
+          new(name, nil, comment, path: path)
+        end
+
+        def padding(max_width)
+          ' ' * (max_width - name.length + 2)
+        end
+      end
+
       def rails_gemfile_entry
         if options.dev?
-          <<-GEMFILE.strip_heredoc
-            gem 'rails',     path: '#{Rails::Generators::RAILS_DEV_PATH}'
-            gem 'arel',      github: 'rails/arel', branch: '4-0-stable'
-          GEMFILE
+          [GemfileEntry.path('rails', Rails::Generators::RAILS_DEV_PATH),
+           GemfileEntry.github('arel', 'rails/arel')]
         elsif options.edge?
-          <<-GEMFILE.strip_heredoc
-            gem 'rails',     github: 'rails/rails', branch: '4-0-stable'
-            gem 'arel',      github: 'rails/arel', branch: '4-0-stable'
-          GEMFILE
+          [GemfileEntry.github('rails', 'rails/rails'),
+           GemfileEntry.github('arel', 'rails/arel')]
         else
-          <<-GEMFILE.strip_heredoc
-            # Bundle edge Rails instead: gem 'rails', github: 'rails/rails'
-            gem 'rails', '#{Rails::VERSION::STRING}'
-          GEMFILE
+          [GemfileEntry.version('rails',
+                            Rails::VERSION::STRING,
+                            "Bundle edge Rails instead: gem 'rails', github: 'rails/rails'")]
         end
       end
 
@@ -177,77 +298,81 @@ module Rails
       end
 
       def assets_gemfile_entry
-        return if options[:skip_sprockets]
+        return [] if options[:skip_sprockets]
 
-        gemfile = if options.dev? || options.edge?
-          <<-GEMFILE.strip_heredoc
-            # Use latest 2.1 version of sprockets-rails
-            gem 'sprockets-rails', github: 'rails/sprockets-rails', branch: "2-1-stable"
+        gems = []
+        if options.dev? || options.edge?
+          gems << GemfileEntry.github('sprockets-rails', 'rails/sprockets-rails',
+                                    'Use edge version of sprockets-rails')
+          gems << GemfileEntry.github('sass-rails', 'rails/sass-rails',
+                                    'Use SCSS for stylesheets')
+        else
+          gems << GemfileEntry.version('sass-rails',
+                                     '~> 4.0.0.rc1',
+                                     'Use SCSS for stylesheets')
+        end
 
-            # Use SCSS for stylesheets
-            gem 'sass-rails', github: 'rails/sass-rails'
+        gems << GemfileEntry.version('uglifier',
+                                   '>= 1.3.0',
+                                   'Use Uglifier as compressor for JavaScript assets')
 
-            # Use Uglifier as compressor for JavaScript assets
-            gem 'uglifier', '>= 1.3.0'
-          GEMFILE
-        else
-          <<-GEMFILE.strip_heredoc
-            # Use SCSS for stylesheets
-            gem 'sass-rails', '~> 4.0.2'
+        gems
+      end
 
-            # Use Uglifier as compressor for JavaScript assets
-            gem 'uglifier', '>= 1.3.0'
-          GEMFILE
+      def platform_dependent_gemfile_entry
+        gems = []
+        if RUBY_ENGINE == 'rbx'
+          gems << GemfileEntry.version('rubysl', nil)
         end
+        gems
+      end
 
-        if options[:skip_javascript]
-          gemfile += <<-GEMFILE
-            #{coffee_gemfile_entry}
-            #{javascript_runtime_gemfile_entry}
-          GEMFILE
-        end
+      def jbuilder_gemfile_entry
+        comment = 'Build JSON APIs with ease. Read more: https://github.com/rails/jbuilder'
+        GemfileEntry.version('jbuilder', '~> 1.2', comment)
+      end
 
-        gemfile.gsub(/^[ \t]+/, '')
+      def sdoc_gemfile_entry
+        comment = 'bundle exec rake doc:rails generates the API under doc/api.'
+        GemfileEntry.new('sdoc', nil, comment, { group: :doc, require: false })
       end
 
       def coffee_gemfile_entry
+        comment = 'Use CoffeeScript for .js.coffee assets and views'
         if options.dev? || options.edge?
-          <<-GEMFILE
-            # Use CoffeeScript for .js.coffee assets and views
-            gem 'coffee-rails', github: 'rails/coffee-rails'
-          GEMFILE
+          GemfileEntry.github 'coffee-rails', 'rails/coffee-rails', comment
         else
-          <<-GEMFILE
-            # Use CoffeeScript for .js.coffee assets and views
-            gem 'coffee-rails', '~> 4.0.0'
-          GEMFILE
+          GemfileEntry.version 'coffee-rails', '~> 4.0.0', comment
         end
       end
 
       def javascript_gemfile_entry
-        unless options[:skip_javascript]
-          <<-GEMFILE.gsub(/^[ \t]+/, '')
-            #{coffee_gemfile_entry}
-            #{javascript_runtime_gemfile_entry}
-            # Use #{options[:javascript]} as the JavaScript library
-            gem '#{options[:javascript]}-rails'
-
-            # Turbolinks makes following links in your web application faster. Read more: https://github.com/rails/turbolinks
-            gem 'turbolinks'
-          GEMFILE
+        if options[:skip_javascript]
+          []
+        else
+          gems = [coffee_gemfile_entry, javascript_runtime_gemfile_entry]
+          gems << GemfileEntry.version("#{options[:javascript]}-rails", nil,
+                                 "Use #{options[:javascript]} as the JavaScript library")
+
+          gems << GemfileEntry.version("turbolinks", nil,
+            "Turbolinks makes following links in your web application faster. Read more: https://github.com/rails/turbolinks")
+          gems
         end
       end
 
       def javascript_runtime_gemfile_entry
-        runtime = if defined?(JRUBY_VERSION)
-          "gem 'therubyrhino'"
+        comment = 'See https://github.com/sstephenson/execjs#readme for more supported runtimes'
+        if defined?(JRUBY_VERSION)
+          GemfileEntry.version 'therubyrhino', nil, comment
         else
-          "# gem 'therubyracer', platforms: :ruby"
+          GemfileEntry.new 'therubyracer', nil, comment, { platforms: :ruby }, true
         end
-        <<-GEMFILE
-          # See https://github.com/sstephenson/execjs#readme for more supported runtimes
-          #{runtime}
-        GEMFILE
+      end
+
+      def spring_gemfile_entry
+        return [] unless spring_install?
+        comment = 'Spring speeds up development by keeping your application running in the background. Read more: https://github.com/jonleighton/spring'
+        GemfileEntry.new('spring', nil, comment, group: :development)
       end
 
       def bundle_command(command)
@@ -273,8 +398,22 @@ module Rails
         end
       end
 
+      def bundle_install?
+        !(options[:skip_gemfile] || options[:skip_bundle] || options[:pretend])
+      end
+
+      def spring_install?
+        !options[:skip_spring] && Process.respond_to?(:fork)
+      end
+
       def run_bundle
-        bundle_command('install') unless options[:skip_gemfile] || options[:skip_bundle] || options[:pretend]
+        bundle_command('install') if bundle_install?
+      end
+
+      def generate_spring_binstubs
+        if bundle_install? && spring_install?
+          bundle_command("exec spring binstub --all")
+        end
       end
 
       def empty_directory_with_keep_file(destination, config = {})