railties 5.0.7.2 → 5.1.0.beta1

data/lib/rails/commands/destroy.rb

@@ -1,11 +0,0 @@
-require 'rails/generators'
-
-#if no argument/-h/--help is passed to rails destroy command, then
-#it generates the help associated.
-if [nil, "-h", "--help"].include?(ARGV.first)
-  Rails::Generators.help 'destroy'
-  exit
-end
-
-name = ARGV.shift
-Rails::Generators.invoke name, ARGV, behavior: :revoke, destination_root: Rails.root

data/lib/rails/commands/generate.rb

@@ -1,13 +0,0 @@
-require 'rails/generators'
-
-#if no argument/-h/--help is passed to rails generate command, then
-#it generates the help associated.
-if [nil, "-h", "--help"].include?(ARGV.first)
-  Rails::Generators.help 'generate'
-  exit
-end
-
-name = ARGV.shift
-
-root = defined?(ENGINE_ROOT) ? ENGINE_ROOT : Rails.root
-Rails::Generators.invoke name, ARGV, behavior: :invoke, destination_root: root

data/lib/rails/commands/plugin.rb

@@ -1,23 +0,0 @@
-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+/).flat_map(&:split)
-      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/rake_proxy.rb

@@ -1,41 +0,0 @@
-require 'active_support'
-
-module Rails
-  module RakeProxy #:nodoc:
-    private
-      def run_rake_task(command)
-        require_rake
-
-        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
-        require_rake
-
-        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
-
-      def require_rake
-        require "rake" # Defer booting Rake until we know it's needed.
-      end
-  end
-end

data/lib/rails/commands/runner.rb

@@ -1,71 +0,0 @@
-require 'optparse'
-
-options = { environment: (ENV['RAILS_ENV'] || ENV['RACK_ENV'] || "development").dup }
-code_or_file = nil
-command = 'bin/rails runner'
-
-if ARGV.first.nil?
-  ARGV.push "-h"
-end
-
-ARGV.clone.options do |opts|
-  opts.banner = "Usage: rails runner [options] [<'Some.ruby(code)'> | <filename.rb>]"
-
-  opts.separator ""
-
-  opts.on("-e", "--environment=name", String,
-          "Specifies the environment for the runner to operate under (test/development/production).",
-          "Default: development") { |v| options[:environment] = v }
-
-  opts.separator ""
-
-  opts.on("-h", "--help",
-          "Show this help message.") { $stdout.puts opts; exit }
-
-    opts.separator ""
-    opts.separator "Examples: "
-
-    opts.separator "    rails runner 'puts Rails.env'"
-    opts.separator "        This runs the code `puts Rails.env` after loading the app"
-    opts.separator ""
-    opts.separator "    rails runner path/to/filename.rb"
-    opts.separator "        This runs the Ruby file located at `path/to/filename.rb` after loading the app"
-
-  if RbConfig::CONFIG['host_os'] !~ /mswin|mingw/
-    opts.separator ""
-    opts.separator "You can also use runner as a shebang line for your executables:"
-    opts.separator "    -------------------------------------------------------------"
-    opts.separator "    #!/usr/bin/env #{File.expand_path(command)}"
-    opts.separator ""
-    opts.separator "    Product.all.each { |p| p.price *= 2 ; p.save! }"
-    opts.separator "    -------------------------------------------------------------"
-  end
-
-  opts.order! { |o| code_or_file ||= o } rescue retry
-end
-
-ARGV.delete(code_or_file)
-
-ENV["RAILS_ENV"] = options[:environment]
-
-require APP_PATH
-Rails.application.require_environment!
-Rails.application.load_runner
-
-if code_or_file.nil?
-  $stderr.puts "Run '#{command} -h' for help."
-  exit 1
-elsif File.exist?(code_or_file)
-  $0 = code_or_file
-  Kernel.load code_or_file
-else
-  begin
-    eval(code_or_file, binding, __FILE__, __LINE__)
-  rescue SyntaxError, NameError => e
-    $stderr.puts "Please specify a valid ruby command or the path of a script to run."
-    $stderr.puts "Run '#{command} -h' for help."
-    $stderr.puts
-    $stderr.puts e
-    exit 1
-  end
-end

data/lib/rails/commands/server.rb

@@ -1,163 +0,0 @@
-require 'fileutils'
-require 'optparse'
-require 'action_dispatch'
-require 'rails'
-require 'rails/dev_caching'
-
-module Rails
-  class Server < ::Rack::Server
-    class Options
-      DEFAULT_PID_PATH = File.expand_path("tmp/pids/server.pid").freeze
-
-      def parse!(args)
-        args, options = args.dup, {}
-        options[:user_supplied_options] = []
-        options[:user_supplied_options] << :Host if ENV["Host"]
-        options[:user_supplied_options] << :Port if ENV["PORT"]
-
-        option_parser(options).parse! args
-
-        options[:user_supplied_options].uniq!
-        options[:log_stdout] = options[:daemonize].blank? && (options[:environment] || Rails.env) == "development"
-        options[:server]     = args.shift
-        options
-      end
-
-      private
-
-      def option_parser(options)
-        OptionParser.new do |opts|
-          opts.banner = "Usage: rails server [mongrel, thin etc] [options]"
-          opts.on("-p", "--port=port", Integer,
-                  "Runs Rails on the specified port.", "Default: 3000") { |v|
-            options[:user_supplied_options] << :Port
-            options[:Port] = v
-          }
-          opts.on("-b", "--binding=IP", String,
-                  "Binds Rails to the specified IP.", "Default: localhost") { |v|
-            options[:user_supplied_options] << :Host
-            options[:Host] = v
-          }
-          opts.on("-c", "--config=file", String,
-                  "Uses a custom rackup configuration.") { |v|
-            options[:user_supplied_options] << :config
-            options[:config] = v
-          }
-          opts.on("-d", "--daemon", "Runs server as a Daemon.") {
-            options[:user_supplied_options] << :daemonize
-            options[:daemonize] = true
-          }
-          opts.on("-e", "--environment=name", String,
-                  "Specifies the environment to run this server under (test/development/production).",
-                  "Default: development") { |v|
-            options[:user_supplied_options] << :environment
-            options[:environment] = v
-          }
-          opts.on("-P", "--pid=pid", String,
-                  "Specifies the PID file.",
-                  "Default: tmp/pids/server.pid") { |v|
-            options[:user_supplied_options] << :pid
-            options[:pid] = v
-          }
-          opts.on("-C", "--[no-]dev-caching",
-                  "Specifies whether to perform caching in development.",
-                  "true or false") { |v|
-            options[:user_supplied_options] << :caching
-            options[:caching] = v
-          }
-
-          opts.separator ""
-
-          opts.on("-h", "--help", "Shows this help message.") { puts opts; exit }
-        end
-      end
-    end
-
-    def initialize(*)
-      super
-      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({
-        Port:               ENV.fetch('PORT', 3000).to_i,
-        DoNotReverseLookup: true,
-        environment:        (ENV['RAILS_ENV'] || ENV['RACK_ENV'] || "development").dup,
-        daemonize:          false,
-        caching:            nil,
-        pid:                Options::DEFAULT_PID_PATH,
-        restart_cmd:        restart_command
-      })
-    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
-end

data/lib/rails/commands/test.rb

@@ -1,10 +0,0 @@
-require "rails/test_unit/runner"
-
-if defined?(ENGINE_ROOT)
-  $LOAD_PATH << File.expand_path("test", ENGINE_ROOT)
-else
-  $LOAD_PATH << File.expand_path("../../test", APP_PATH)
-end
-
-Rails::TestUnit::Runner.parse_options(ARGV)
-Rails::TestUnit::Runner.run(ARGV)

data/lib/rails/engine/commands_tasks.rb

@@ -1,118 +0,0 @@
-require 'rails/commands/rake_proxy'
-
-module Rails
-  class Engine
-    class CommandsTasks # :nodoc:
-      include Rails::RakeProxy
-
-      attr_reader :argv
-
-      HELP_MESSAGE = <<-EOT
-Usage: rails COMMAND [ARGS]
-
-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")
- test        Run tests (short-cut alias: "t")
-
-All commands can be run with -h for more information.
-
-If you want to run any commands that need to be run in context
-of the application, like `rails server` or `rails console`,
-you should do it from application's directory (typically test/dummy).
-
-In addition to those commands, there are:
-  EOT
-
-      COMMAND_WHITELIST = %w(generate destroy version help test)
-
-      def initialize(argv)
-        @argv = argv
-      end
-
-      def run_command!(command)
-        command = parse_command(command)
-
-        if COMMAND_WHITELIST.include?(command)
-          send(command)
-        else
-          run_rake_task(command)
-        end
-      end
-
-      def generate
-        generate_or_destroy(:generate)
-      end
-
-      def destroy
-        generate_or_destroy(:destroy)
-      end
-
-      def test
-        require_command!("test")
-      end
-
-      def version
-        argv.unshift '--version'
-        require_command!("application")
-      end
-
-      def help
-        write_help_message
-        write_commands(formatted_rake_tasks)
-      end
-
-      private
-
-        def require_command!(command)
-          require "rails/commands/#{command}"
-        end
-
-        def generate_or_destroy(command)
-          load_generators
-          require_command!(command)
-        end
-
-        def load_generators
-          require 'rails/generators'
-          require ENGINE_PATH
-
-          engine = ::Rails::Engine.find(ENGINE_ROOT)
-          Rails::Generators.namespace = engine.railtie_namespace
-          engine.load_generators
-        end
-
-        def write_help_message
-          puts HELP_MESSAGE
-        end
-
-        def write_commands(commands)
-          width = commands.map { |name, _| name.size }.max || 10
-          commands.each { |command| printf(" %-#{width}s   %s\n", *command) }
-        end
-
-        def parse_command(command)
-          case command
-          when '--version', '-v'
-            'version'
-          when '--help', '-h'
-            'help'
-          else
-            command
-          end
-        end
-
-        def rake_tasks
-          require_rake
-
-          return @rake_tasks if defined?(@rake_tasks)
-
-          load_generators
-          Rake::TaskManager.record_task_metadata = true
-          Rake.application.init('rails')
-          Rake.application.load_rakefile
-          @rake_tasks = Rake.application.tasks.select(&:comment)
-        end
-    end
-  end
-end