railties 4.2.11.3 → 5.0.0.beta1

data/lib/rails/commands/console_helper.rb

@@ -0,0 +1,34 @@
+require 'active_support/concern'
+
+module Rails
+  module ConsoleHelper # :nodoc:
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def start(*args)
+        new(*args).start
+      end
+      
+      private
+        def set_options_env(arguments, options)
+          if arguments.first && arguments.first[0] != '-'
+            env = arguments.first
+            if available_environments.include? env
+              options[:environment] = env
+            else
+              options[:environment] = %w(production development test).detect { |e| e =~ /^#{env}/ } || env
+            end
+          end
+          options
+        end
+
+        def available_environments
+          Dir['config/environments/*.rb'].map { |fname| File.basename(fname, '.*') }
+        end  
+    end
+
+    def environment
+      ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+    end
+  end
+end

data/lib/rails/commands/dbconsole.rb

@@ -1,14 +1,49 @@
 require 'erb'
 require 'yaml'
 require 'optparse'
-require 'rbconfig'
+require 'rails/commands/console_helper'
 
 module Rails
   class DBConsole
+    include ConsoleHelper
+
     attr_reader :arguments
 
-    def self.start
-      new.start
+    class << self
+      def parse_arguments(arguments)
+        options = {}
+
+        OptionParser.new do |opt|
+          opt.banner = "Usage: rails dbconsole [environment] [options]"
+          opt.on("-p", "--include-password", "Automatically provide the password from database.yml") do |v|
+            options['include_password'] = true
+          end
+
+          opt.on("--mode [MODE]", ['html', 'list', 'line', 'column'],
+            "Automatically put the sqlite3 database in the specified mode (html, list, line, column).") do |mode|
+              options['mode'] = mode
+          end
+
+          opt.on("--header") do |h|
+            options['header'] = h
+          end
+
+          opt.on("-h", "--help", "Show this help message.") do
+            puts opt
+            exit
+          end
+
+          opt.on("-e", "--environment=name", String,
+            "Specifies the environment to run this console under (test/development/production).",
+            "Default: development"
+          ) { |v| options[:environment] = v.strip }
+
+          opt.parse!(arguments)
+          abort opt.to_s unless (0..1).include?(arguments.size)
+        end
+
+        set_options_env(arguments, options)
+      end
     end
 
     def initialize(arguments = ARGV)
@@ -16,7 +51,7 @@ module Rails
     end
 
     def start
-      options = parse_arguments(arguments)
+      options = self.class.parse_arguments(arguments)
       ENV['RAILS_ENV'] = options[:environment] || environment
 
       case config["adapter"]
@@ -51,9 +86,6 @@ module Rails
         ENV['PGPASSWORD'] = config["password"].to_s if config["password"] && options['include_password']
         find_cmd_and_exec('psql', config["database"])
 
-      when "sqlite"
-        find_cmd_and_exec('sqlite', config["database"])
-
       when "sqlite3"
         args = []
 
@@ -105,88 +137,37 @@ module Rails
     end
 
     def environment
-      if Rails.respond_to?(:env)
-        Rails.env
-      else
-        ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
-      end
+      Rails.respond_to?(:env) ? Rails.env : super
     end
 
     protected
+      def configurations
+        require APP_PATH
+        ActiveRecord::Base.configurations = Rails.application.config.database_configuration
+        ActiveRecord::Base.configurations
+      end
 
-    def configurations
-      require APP_PATH
-      ActiveRecord::Base.configurations = Rails.application.config.database_configuration
-      ActiveRecord::Base.configurations
-    end
-
-    def parse_arguments(arguments)
-      options = {}
-
-      OptionParser.new do |opt|
-        opt.banner = "Usage: rails dbconsole [environment] [options]"
-        opt.on("-p", "--include-password", "Automatically provide the password from database.yml") do |v|
-          options['include_password'] = true
-        end
-
-        opt.on("--mode [MODE]", ['html', 'list', 'line', 'column'],
-          "Automatically put the sqlite3 database in the specified mode (html, list, line, column).") do |mode|
-            options['mode'] = mode
-        end
+      def find_cmd_and_exec(commands, *args)
+        commands = Array(commands)
 
-        opt.on("--header") do |h|
-          options['header'] = h
+        dirs_on_path = ENV['PATH'].to_s.split(File::PATH_SEPARATOR)
+        unless (ext = RbConfig::CONFIG['EXEEXT']).empty?
+          commands = commands.map{|cmd| "#{cmd}#{ext}"}
         end
 
-        opt.on("-h", "--help", "Show this help message.") do
-          puts opt
-          exit
+        full_path_command = nil
+        found = commands.detect do |cmd|
+          dirs_on_path.detect do |path|
+            full_path_command = File.join(path, cmd)
+            File.file?(full_path_command) && File.executable?(full_path_command)
+          end
         end
 
-        opt.on("-e", "--environment=name", String,
-          "Specifies the environment to run this console under (test/development/production).",
-          "Default: development"
-        ) { |v| options[:environment] = v.strip }
-
-        opt.parse!(arguments)
-        abort opt.to_s unless (0..1).include?(arguments.size)
-      end
-
-      if arguments.first && arguments.first[0] != '-'
-        env = arguments.first
-        if available_environments.include? env
-          options[:environment] = env
+        if found
+          exec full_path_command, *args
         else
-          options[:environment] = %w(production development test).detect {|e| e =~ /^#{env}/} || env
+          abort("Couldn't find database client: #{commands.join(', ')}. Check your $PATH and try again.")
         end
       end
-
-      options
-    end
-
-    def available_environments
-      Dir['config/environments/*.rb'].map { |fname| File.basename(fname, '.*') }
-    end
-
-    def find_cmd_and_exec(commands, *args)
-      commands = Array(commands)
-
-      dirs_on_path = ENV['PATH'].to_s.split(File::PATH_SEPARATOR)
-      commands += commands.map{|cmd| "#{cmd}.exe"} if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
-
-      full_path_command = nil
-      found = commands.detect do |cmd|
-        dirs_on_path.detect do |path|
-          full_path_command = File.join(path, cmd)
-          File.file?(full_path_command) && File.executable?(full_path_command)
-        end
-      end
-
-      if found
-        exec full_path_command, *args
-      else
-        abort("Couldn't find database client: #{commands.join(', ')}. Check your $PATH and try again.")
-      end
-    end
   end
 end

data/lib/rails/commands/dev_cache.rb

@@ -0,0 +1,21 @@
+require 'rails/command'
+
+module Rails
+  module Commands
+    # This is a wrapper around the Rails dev:cache command
+    class DevCache < Command
+      set_banner :dev_cache, 'Toggle development mode caching on/off'
+      def dev_cache
+        if File.exist? 'tmp/caching-dev.txt'
+          File.delete 'tmp/caching-dev.txt'
+          puts 'Development mode is no longer being cached.'
+        else
+          FileUtils.touch 'tmp/caching-dev.txt'
+          puts 'Development mode is now being cached.'
+        end
+
+        FileUtils.touch 'tmp/restart.txt'
+      end
+    end
+  end
+end

data/lib/rails/commands/plugin.rb

@@ -11,7 +11,7 @@ else
               end
     if File.exist?(railsrc)
       extra_args_string = File.read(railsrc)
-      extra_args = extra_args_string.split(/\n+/).flat_map {|l| l.split}
+      extra_args = extra_args_string.split(/\n+/).flat_map(&:split)
       puts "Using #{extra_args.join(" ")} from #{railsrc}"
       ARGV.insert(1, *extra_args)
     end

data/lib/rails/commands/rake_proxy.rb

@@ -0,0 +1,34 @@
+require 'rake'
+require 'active_support'
+
+module Rails
+  module RakeProxy #:nodoc:
+    private
+      def run_rake_task(command)
+        ARGV.unshift(command) # Prepend the command, so Rake knows how to run it.
+
+        Rake.application.standard_exception_handling do
+          Rake.application.init('rails')
+          Rake.application.load_rakefile
+          Rake.application.top_level
+        end
+      end
+
+      def rake_tasks
+        return @rake_tasks if defined?(@rake_tasks)
+
+        ActiveSupport::Deprecation.silence do
+          require_application_and_environment!
+        end
+
+        Rake::TaskManager.record_task_metadata = true
+        Rake.application.instance_variable_set(:@name, 'rails')
+        Rails.application.load_tasks
+        @rake_tasks = Rake.application.tasks.select(&:comment)
+      end
+
+      def formatted_rake_tasks
+        rake_tasks.map { |t| [ t.name_with_args, t.comment ] }
+      end
+  end
+end

data/lib/rails/commands/runner.rb

@@ -1,5 +1,4 @@
 require 'optparse'
-require 'rbconfig'
 
 options = { environment: (ENV['RAILS_ENV'] || ENV['RACK_ENV'] || "development").dup }
 code_or_file = nil

data/lib/rails/commands/server.rb

@@ -28,20 +28,15 @@ module Rails
           opts.on("-c", "--config=file", String,
                   "Uses a custom rackup configuration.") { |v| options[:config] = v }
           opts.on("-d", "--daemon", "Runs server as a Daemon.") { options[:daemonize] = true }
-          opts.on("-u", "--debugger", "Enables the debugger.") do
-            if RUBY_VERSION < '2.0.0'
-              options[:debugger] = true
-            else
-              puts "=> Notice: debugger option is ignored since Ruby 2.0 and " \
-                   "it will be removed in future versions."
-            end
-          end
           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,
                   "Specifies the PID file.",
                   "Default: tmp/pids/server.pid") { |v| options[:pid] = v }
+          opts.on("-C", "--[no-]dev-caching",
+                  "Specifies whether to perform caching in development.",
+                  "true or false") { |v| options[:caching] = v }
 
           opts.separator ""
 
@@ -75,6 +70,7 @@ module Rails
       print_boot_information
       trap(:INT) { exit }
       create_tmp_directories
+      setup_dev_caching
       log_to_stdout if options[:log_stdout]
 
       super
@@ -85,41 +81,32 @@ module Rails
     end
 
     def middleware
-      middlewares = []
-      if RUBY_VERSION < '2.0.0'
-        middlewares << [Rails::Rack::Debugger] if options[:debugger]
-      end
-      middlewares << [::Rack::ContentLength]
-
-      # FIXME: add Rack::Lock in the case people are using webrick.
-      # This is to remain backwards compatible for those who are
-      # running webrick in production. We should consider removing this
-      # in development.
-      if server.name == 'Rack::Handler::WEBrick'
-        middlewares << [::Rack::Lock]
-      end
-
-      Hash.new(middlewares)
-    end
-
-    def log_path
-      "log/#{options[:environment]}.log"
+      Hash.new([])
     end
 
     def default_options
       super.merge({
-        Port:               3000,
+        Port:               ENV.fetch('PORT', 3000).to_i,
         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")
+        caching:            false,
+        pid:                File.expand_path("tmp/pids/server.pid")
       })
     end
 
     private
 
+      def setup_dev_caching
+        return unless options[:environment] == "development"
+
+        if options[:caching] == false
+          delete_cache_file
+        elsif options[:caching]
+          create_cache_file
+        end
+      end
+
       def print_boot_information
         url = "#{options[:SSLEnable] ? 'https' : 'http'}://#{options[:Host]}:#{options[:Port]}"
         puts "=> Booting #{ActiveSupport::Inflector.demodulize(server)}"
@@ -129,8 +116,16 @@ module Rails
         puts "=> Ctrl-C to shutdown server" unless options[:daemonize]
       end
 
+      def create_cache_file
+        FileUtils.touch("tmp/caching-dev.txt")
+      end
+
+      def delete_cache_file
+        FileUtils.rm("tmp/caching-dev.txt") if File.exist?("tmp/caching-dev.txt")
+      end
+
       def create_tmp_directories
-        %w(cache pids sessions sockets).each do |dir_to_make|
+        %w(cache pids sockets).each do |dir_to_make|
           FileUtils.mkdir_p(File.join(Rails.root, 'tmp', dir_to_make))
         end
       end
@@ -138,13 +133,11 @@ module Rails
       def log_to_stdout
         wrapped_app # touch the app so the logger is set up
 
-        console = ActiveSupport::Logger.new(STDOUT)
+        console = ActiveSupport::Logger.new($stdout)
         console.formatter = Rails.logger.formatter
         console.level = Rails.logger.level
 
-        unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDOUT)
-          Rails.logger.extend(ActiveSupport::Logger.broadcast(console))
-        end
+        Rails.logger.extend(ActiveSupport::Logger.broadcast(console))
       end
   end
 end

data/lib/rails/commands/test.rb

@@ -0,0 +1,9 @@
+require "rails/test_unit/minitest_plugin"
+
+if defined?(ENGINE_ROOT)
+  $: << File.expand_path('test', ENGINE_ROOT)
+else
+  $: << File.expand_path('../../test', APP_PATH)
+end
+
+exit Minitest.run(ARGV)

data/lib/rails/configuration.rb

@@ -33,8 +33,9 @@ module Rails
     #     config.middleware.delete ActionDispatch::Flash
     #
     class MiddlewareStackProxy
-      def initialize
-        @operations = []
+      def initialize(operations = [], delete_operations = [])
+        @operations = operations
+        @delete_operations = delete_operations
       end
 
       def insert_before(*args, &block)
@@ -56,7 +57,7 @@ module Rails
       end
 
       def delete(*args, &block)
-        @operations << [__method__, args, block]
+        @delete_operations << [__method__, args, block]
       end
 
       def unshift(*args, &block)
@@ -64,15 +65,29 @@ module Rails
       end
 
       def merge_into(other) #:nodoc:
-        @operations.each do |operation, args, block|
+        (@operations + @delete_operations).each do |operation, args, block|
           other.send(operation, *args, &block)
         end
+
         other
       end
+
+      def +(other) # :nodoc:
+        MiddlewareStackProxy.new(@operations + other.operations, @delete_operations + other.delete_operations)
+      end
+
+      protected
+        def operations
+          @operations
+        end
+
+        def delete_operations
+          @delete_operations
+        end
     end
 
     class Generators #:nodoc:
-      attr_accessor :aliases, :options, :templates, :fallbacks, :colorize_logging
+      attr_accessor :aliases, :options, :templates, :fallbacks, :colorize_logging, :api_only
       attr_reader :hidden_namespaces
 
       def initialize
@@ -81,6 +96,7 @@ module Rails
         @fallbacks = {}
         @templates = []
         @colorize_logging = true
+        @api_only = false
         @hidden_namespaces = []
       end