railties 5.0.7.2 → 5.1.0.beta1

data/lib/rails/commands/rake/rake_command.rb

@@ -0,0 +1,49 @@
+module Rails
+  module Command
+    class RakeCommand < Base # :nodoc:
+      extend Rails::Command::Actions
+
+      namespace "rake"
+
+      class << self
+        def printing_commands
+          formatted_rake_tasks.map(&:first)
+        end
+
+        def perform(task, *)
+          require_rake
+
+          ARGV.unshift(task) # Prepend the task, 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
+
+        private
+          def rake_tasks
+            require_rake
+
+            return @rake_tasks if defined?(@rake_tasks)
+
+            require_application_and_environment!
+
+            Rake::TaskManager.record_task_metadata = true
+            Rake.application.instance_variable_set(:@name, "rails")
+            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
+
+          def require_rake
+            require "rake" # Defer booting Rake until we know it's needed.
+          end
+      end
+    end
+  end
+end

data/lib/rails/commands/runner/USAGE

@@ -0,0 +1,17 @@
+Examples:
+
+Run `puts Rails.env` after loading the app:
+
+  <%= executable %> 'puts Rails.env'
+
+Run the Ruby file located at `path/to/filename.rb` after loading the app:
+
+  <%= executable %> path/to/filename.rb
+
+<% unless Gem.win_platform? %>
+You can also use the runner command as a shebang line for your executables:
+
+  #!/usr/bin/env <%= File.expand_path(executable) %>
+
+  Product.all.each { |p| p.price *= 2 ; p.save! }
+<% end %>

data/lib/rails/commands/runner/runner_command.rb

@@ -0,0 +1,46 @@
+module Rails
+  module Command
+    class RunnerCommand < Base # :nodoc:
+      class_option :environment, aliases: "-e", type: :string,
+        default: Rails::Command.environment.dup,
+        desc: "The environment for the runner to operate under (test/development/production)"
+
+      def help
+        super
+        puts self.class.desc
+      end
+
+      def self.banner(*)
+        "#{super} [<'Some.ruby(code)'> | <filename.rb>]"
+      end
+
+      def perform(code_or_file = nil, *file_argv)
+        unless code_or_file
+          help
+          exit 1
+        end
+
+        ENV["RAILS_ENV"] = options[:environment]
+
+        require_application_and_environment!
+        Rails.application.load_runner
+
+        if File.exist?(code_or_file)
+          $0 = code_or_file
+          ARGV.replace(file_argv)
+          Kernel.load code_or_file
+        else
+          begin
+            eval(code_or_file, binding, __FILE__, __LINE__)
+          rescue SyntaxError, NameError => error
+            $stderr.puts "Please specify a valid ruby command or the path of a script to run."
+            $stderr.puts "Run '#{self.class.executable} -h' for help."
+            $stderr.puts
+            $stderr.puts error
+            exit 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/commands/secrets/USAGE

@@ -0,0 +1,52 @@
+=== Storing Encrypted Secrets in Source Control
+
+The Rails `secrets` commands helps encrypting secrets to slim a production
+environment's `ENV` hash. It's also useful for atomic deploys: no need to
+coordinate key changes to get everything working as the keys are shipped
+with the code.
+
+=== Setup
+
+Run `bin/rails secrets:setup` to opt in and generate the `config/secrets.yml.key`
+and `config/secrets.yml.enc` files.
+
+The latter contains all the keys to be encrypted while the former holds the
+encryption key.
+
+Don't lose the key! Put it in a password manager your team can access.
+Should you lose it no one, including you, will be able to access any encrypted
+secrets.
+Don't commit the key! Add `config/secrets.yml.key` to your source control's
+ignore file. If you use Git, Rails handles this for you.
+
+Rails also looks for the key in `ENV["RAILS_MASTER_KEY"]` if that's easier to
+manage.
+
+You could prepend that to your server's start command like this:
+
+   RAILS_MASTER_KEY="im-the-master-now-hahaha" server.start
+
+
+The `config/secrets.yml.enc` has much the same format as `config/secrets.yml`:
+
+   production:
+     secret_key_base: so-secret-very-hidden-wow
+     payment_processing_gateway_key: much-safe-very-gaedwey-wow
+
+But that's where the similarities between `secrets.yml` and `secrets.yml.enc`
+end, e.g. no keys from `secrets.yml` will be moved to `secrets.yml.enc` and
+be encrypted.
+
+A `shared:` top level key is also supported such that any keys there is merged
+into the other environments.
+
+=== Editing Secrets
+
+After `bin/rails secrets:setup`, run `bin/rails secrets:edit`.
+
+That command opens a temporary file in `$EDITOR` with the decrypted contents of
+`config/secrets.yml.enc` to edit the encrypted secrets.
+
+When the temporary file is next saved the contents are encrypted and written to
+`config/secrets.yml.enc` while the file itself is destroyed to prevent secrets
+from leaking.

data/lib/rails/commands/secrets/secrets_command.rb

@@ -0,0 +1,36 @@
+require "active_support"
+require "rails/secrets"
+
+module Rails
+  module Command
+    class SecretsCommand < Rails::Command::Base # :nodoc:
+      def help
+        say "Usage:\n  #{self.class.banner}"
+        say ""
+        say self.class.desc
+      end
+
+      def setup
+        require "rails/generators"
+        require "rails/generators/rails/encrypted_secrets/encrypted_secrets_generator"
+
+        Rails::Generators::EncryptedSecretsGenerator.start
+      end
+
+      def edit
+        require_application_and_environment!
+
+        Rails::Secrets.read_for_editing do |tmp_path|
+          puts "Waiting for secrets file to be saved. Abort with Ctrl-C."
+          system("\$EDITOR #{tmp_path}")
+        end
+
+        puts "New secrets encrypted and saved."
+      rescue Interrupt
+        puts "Aborted changing encrypted secrets: nothing saved."
+      rescue Rails::Secrets::MissingKeyError => error
+        say error.message
+      end
+    end
+  end
+end

data/lib/rails/commands/server/server_command.rb

@@ -0,0 +1,177 @@
+require "fileutils"
+require "optparse"
+require "action_dispatch"
+require "rails"
+require "rails/dev_caching"
+
+module Rails
+  class Server < ::Rack::Server
+    class Options
+      def parse!(args)
+        Rails::Command::ServerCommand.new([], args).server_options
+      end
+    end
+
+    def initialize(options = nil)
+      @default_options = options || {}
+      super(@default_options)
+      set_environment
+    end
+
+    # TODO: this is no longer required but we keep it for the moment to support older config.ru files.
+    def app
+      @app ||= begin
+        app = super
+        app.respond_to?(:to_app) ? app.to_app : app
+      end
+    end
+
+    def opt_parser
+      Options.new
+    end
+
+    def set_environment
+      ENV["RAILS_ENV"] ||= options[:environment]
+    end
+
+    def start
+      print_boot_information
+      trap(:INT) { exit }
+      create_tmp_directories
+      setup_dev_caching
+      log_to_stdout if options[:log_stdout]
+
+      super
+    ensure
+      # 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
+      Hash.new([])
+    end
+
+    def default_options
+      super.merge(@default_options)
+    end
+
+    private
+      def setup_dev_caching
+        if options[:environment] == "development"
+          Rails::DevCaching.enable_by_argument(options[:caching])
+        end
+      end
+
+      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"
+      end
+
+      def create_tmp_directories
+        %w(cache pids 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
+
+        unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDOUT)
+          Rails.logger.extend(ActiveSupport::Logger.broadcast(console))
+        end
+      end
+
+      def restart_command
+        "bin/rails server #{ARGV.join(' ')}"
+      end
+  end
+
+  module Command
+    class ServerCommand < Base # :nodoc:
+      DEFAULT_PID_PATH = "tmp/pids/server.pid".freeze
+
+      class_option :port, aliases: "-p", type: :numeric,
+        desc: "Runs Rails on the specified port.", banner: :port, default: 3000
+      class_option :binding, aliases: "-b", type: :string, default: "localhost",
+        desc: "Binds Rails to the specified IP.", banner: :IP
+      class_option :config, aliases: "-c", type: :string, default: "config.ru",
+        desc: "Uses a custom rackup configuration.", banner: :file
+      class_option :daemon, aliases: "-d", type: :boolean, default: false,
+        desc: "Runs server as a Daemon."
+      class_option :environment, aliases: "-e", type: :string,
+        desc: "Specifies the environment to run this server under (development/test/production).", banner: :name
+      class_option :pid, aliases: "-P", type: :string, default: DEFAULT_PID_PATH,
+        desc: "Specifies the PID file."
+      class_option "dev-caching", aliases: "-C", type: :boolean, default: nil,
+        desc: "Specifies whether to perform caching in development."
+
+      def initialize(args = [], local_options = {}, config = {})
+        @original_options = local_options
+        super
+        @server = self.args.shift
+        @log_stdout = options[:daemon].blank? && (options[:environment] || Rails.env) == "development"
+      end
+
+      def perform
+        set_application_directory!
+        Rails::Server.new(server_options).tap do |server|
+          # Require application after server sets environment to propagate
+          # the --environment option.
+          require APP_PATH
+          Dir.chdir(Rails.application.root)
+          server.start
+        end
+      end
+
+      no_commands do
+        def server_options
+          {
+            server:             @server,
+            log_stdout:         @log_stdout,
+            Port:               port,
+            Host:               host,
+            DoNotReverseLookup: true,
+            config:             options[:config],
+            environment:        environment,
+            daemonize:          options[:daemon],
+            pid:                pid,
+            caching:            options["dev-caching"],
+            restart_cmd:        restart_command
+          }
+        end
+      end
+
+      private
+        def port
+          ENV.fetch("PORT", options[:port]).to_i
+        end
+
+        def host
+          ENV.fetch("HOST", options[:binding])
+        end
+
+        def environment
+          options[:environment] || Rails::Command.environment
+        end
+
+        def restart_command
+          "bin/rails server #{@server} #{@original_options.join(" ")}"
+        end
+
+        def pid
+          File.expand_path(options[:pid])
+        end
+
+        def self.banner(*)
+          "rails server [puma, thin etc] [options]"
+        end
+    end
+  end
+end

data/lib/rails/commands/test/test_command.rb

@@ -0,0 +1,20 @@
+require "rails/command"
+require "rails/test_unit/minitest_plugin"
+
+module Rails
+  module Command
+    class TestCommand < Base # :nodoc:
+      def help
+        perform # Hand over help printing to minitest.
+      end
+
+      def perform(*)
+        $LOAD_PATH << Rails::Command.root.join("test")
+
+        Minitest.run_via = :rails
+
+        require "active_support/testing/autorun"
+      end
+    end
+  end
+end

data/lib/rails/commands/version/version_command.rb

@@ -0,0 +1,9 @@
+module Rails
+  module Command
+    class VersionCommand < Base # :nodoc:
+      def perform
+        Rails::Command.invoke :application, [ "--version" ]
+      end
+    end
+  end
+end

data/lib/rails/configuration.rb

@@ -1,7 +1,7 @@
-require 'active_support/ordered_options'
-require 'active_support/core_ext/object'
-require 'rails/paths'
-require 'rails/rack'
+require "active_support/ordered_options"
+require "active_support/core_ext/object"
+require "rails/paths"
+require "rails/rack"
 
 module Rails
   module Configuration
@@ -91,8 +91,8 @@ module Rails
       attr_reader :hidden_namespaces
 
       def initialize
-        @aliases = Hash.new { |h,k| h[k] = {} }
-        @options = Hash.new { |h,k| h[k] = {} }
+        @aliases = Hash.new { |h, k| h[k] = {} }
+        @options = Hash.new { |h, k| h[k] = {} }
         @fallbacks = {}
         @templates = []
         @colorize_logging = true
@@ -112,7 +112,7 @@ module Rails
       end
 
       def method_missing(method, *args)
-        method = method.to_s.sub(/=$/, '').to_sym
+        method = method.to_s.sub(/=$/, "").to_sym
 
         return @options[method] if args.empty?