railties 5.0.7.2 → 5.1.0.beta1

data/lib/rails/commands/application.rb

@@ -1,17 +0,0 @@
-require 'rails/generators'
-require 'rails/generators/rails/app/app_generator'
-
-module Rails
-  module Generators
-    class AppGenerator # :nodoc:
-      # We want to exit on failure to be kind to other libraries
-      # This is only when accessing via CLI
-      def self.exit_on_failure?
-        true
-      end
-    end
-  end
-end
-
-args = Rails::Generators::ARGVScrubber.new(ARGV).prepare!
-Rails::Generators::AppGenerator.start args

data/lib/rails/commands/commands_tasks.rb

@@ -1,180 +0,0 @@
-require 'rails/commands/rake_proxy'
-
-module Rails
-  # This is a class which takes in a rails command and initiates the appropriate
-  # initiation sequence.
-  #
-  # Warning: This class mutates ARGV because some commands require manipulating
-  # it before they are run.
-  class CommandsTasks # :nodoc:
-    include Rails::RakeProxy
-
-    attr_reader :argv
-
-    HELP_MESSAGE = <<-EOT
-Usage: rails COMMAND [ARGS]
-
-The most common rails commands are:
- generate    Generate new code (short-cut alias: "g")
- console     Start the Rails console (short-cut alias: "c")
- server      Start the Rails server (short-cut alias: "s")
- test        Run tests (short-cut alias: "t")
- dbconsole   Start a console for the database specified in config/database.yml
-             (short-cut alias: "db")
- new         Create a new Rails application. "rails new my_app" creates a
-             new application called MyApp in "./my_app"
-
-All commands can be run with -h (or --help) for more information.
-
-In addition to those commands, there are:
-EOT
-
-    ADDITIONAL_COMMANDS = [
-      [ 'destroy', 'Undo code generated with "generate" (short-cut alias: "d")' ],
-      [ 'plugin new', 'Generates skeleton for developing a Rails plugin' ],
-      [ 'runner',
-        'Run a piece of code in the application environment (short-cut alias: "r")' ]
-    ]
-
-    COMMAND_WHITELIST = %w(plugin generate destroy console server dbconsole runner new 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 plugin
-      require_command!("plugin")
-    end
-
-    def generate
-      generate_or_destroy(:generate)
-    end
-
-    def destroy
-      generate_or_destroy(:destroy)
-    end
-
-    def console
-      require_command!("console")
-      options = Rails::Console.parse_arguments(argv)
-
-      # RAILS_ENV needs to be set before config/application is required
-      ENV['RAILS_ENV'] = options[:environment] if options[:environment]
-
-      # shift ARGV so IRB doesn't freak
-      shift_argv!
-
-      require_application_and_environment!
-      Rails::Console.start(Rails.application, options)
-    end
-
-    def server
-      set_application_directory!
-      require_command!("server")
-
-      Rails::Server.new.tap do |server|
-        # We need to require application after the server sets environment,
-        # otherwise the --environment option given to the server won't propagate.
-        require APP_PATH
-        Dir.chdir(Rails.application.root)
-        server.start
-      end
-    end
-
-    def test
-      require_command!("test")
-    end
-
-    def dbconsole
-      require_command!("dbconsole")
-      Rails::DBConsole.start
-    end
-
-    def runner
-      require_command!("runner")
-    end
-
-    def new
-      if %w(-h --help).include?(argv.first)
-        require_command!("application")
-      else
-        exit_with_initialization_warning!
-      end
-    end
-
-    def version
-      argv.unshift '--version'
-      require_command!("application")
-    end
-
-    def help
-      write_help_message
-      write_commands ADDITIONAL_COMMANDS + formatted_rake_tasks
-    end
-
-    private
-
-      def exit_with_initialization_warning!
-        puts "Can't initialize a new Rails application within the directory of another, please change to a non-Rails directory first.\n"
-        puts "Type 'rails' for help."
-        exit(1)
-      end
-
-      def shift_argv!
-        argv.shift if argv.first && argv.first[0] != '-'
-      end
-
-      def require_command!(command)
-        require "rails/commands/#{command}"
-      end
-
-      def generate_or_destroy(command)
-        require 'rails/generators'
-        require_application_and_environment!
-        Rails.application.load_generators
-        require_command!(command)
-      end
-
-      # Change to the application's path if there is no config.ru file in current directory.
-      # This allows us to run `rails server` from other directories, but still get
-      # the main config.ru and properly set the tmp directory.
-      def set_application_directory!
-        Dir.chdir(File.expand_path('../../', APP_PATH)) unless File.exist?(File.expand_path("config.ru"))
-      end
-
-      def require_application_and_environment!
-        require APP_PATH
-        Rails.application.require_environment!
-      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
-  end
-end

data/lib/rails/commands/console.rb

@@ -1,68 +0,0 @@
-require 'optparse'
-require 'irb'
-require 'irb/completion'
-require 'rails/commands/console_helper'
-
-module Rails
-  class Console
-    include ConsoleHelper
-
-    class << self
-      def parse_arguments(arguments)
-        options = {}
-
-        OptionParser.new do |opt|
-          opt.banner = "Usage: rails console [environment] [options]"
-          opt.on('-s', '--sandbox', 'Rollback database modifications on exit.') { |v| options[:sandbox] = v }
-          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)
-        end
-
-        set_options_env(arguments, options)
-      end
-    end
-
-    attr_reader :options, :app, :console
-
-    def initialize(app, options={})
-      @app     = app
-      @options = options
-
-      app.sandbox = sandbox?
-      app.load_console
-
-      @console = app.config.console || IRB
-    end
-
-    def sandbox?
-      options[:sandbox]
-    end
-
-    def environment
-      options[:environment] ||= super
-    end
-    alias_method :environment?, :environment
-
-    def set_environment!
-      Rails.env = environment
-    end
-
-    def start
-      set_environment! if environment?
-
-      if sandbox?
-        puts "Loading #{Rails.env} environment in sandbox (Rails #{Rails.version})"
-        puts "Any modifications you make will be rolled back on exit"
-      else
-        puts "Loading #{Rails.env} environment (Rails #{Rails.version})"
-      end
-
-      if defined?(console::ExtendCommandBundle)
-        console::ExtendCommandBundle.include(Rails::ConsoleMethods)
-      end
-      console.start
-    end
-  end
-end

data/lib/rails/commands/console_helper.rb

@@ -1,34 +0,0 @@
-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,173 +0,0 @@
-require 'erb'
-require 'yaml'
-require 'optparse'
-require 'rails/commands/console_helper'
-
-module Rails
-  class DBConsole
-    include ConsoleHelper
-
-    attr_reader :arguments
-
-    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)
-      @arguments = arguments
-    end
-
-    def start
-      options = self.class.parse_arguments(arguments)
-      ENV['RAILS_ENV'] = options[:environment] || environment
-
-      case config["adapter"]
-      when /^(jdbc)?mysql/
-        args = {
-          'host'      => '--host',
-          'port'      => '--port',
-          'socket'    => '--socket',
-          'username'  => '--user',
-          'encoding'  => '--default-character-set',
-          'sslca'     => '--ssl-ca',
-          'sslcert'   => '--ssl-cert',
-          'sslcapath' => '--ssl-capath',
-          'sslcipher' => '--ssl-cipher',
-          'sslkey'    => '--ssl-key'
-        }.map { |opt, arg| "#{arg}=#{config[opt]}" if config[opt] }.compact
-
-        if config['password'] && options['include_password']
-          args << "--password=#{config['password']}"
-        elsif config['password'] && !config['password'].to_s.empty?
-          args << "-p"
-        end
-
-        args << config['database']
-
-        find_cmd_and_exec(['mysql', 'mysql5'], *args)
-
-      when /^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"]
-        ENV['PGPASSWORD'] = config["password"].to_s if config["password"] && options['include_password']
-        find_cmd_and_exec('psql', config["database"])
-
-      when "sqlite3"
-        args = []
-
-        args << "-#{options['mode']}" if options['mode']
-        args << "-header" if options['header']
-        args << File.expand_path(config['database'], Rails.respond_to?(:root) ? Rails.root : nil)
-
-        find_cmd_and_exec('sqlite3', *args)
-
-      when "oracle", "oracle_enhanced"
-        logon = ""
-
-        if config['username']
-          logon = config['username']
-          logon << "/#{config['password']}" if config['password'] && options['include_password']
-          logon << "@#{config['database']}" if config['database']
-        end
-
-        find_cmd_and_exec('sqlplus', logon)
-
-      when "sqlserver"
-        args = []
-
-        args += ["-D", "#{config['database']}"] if config['database']
-        args += ["-U", "#{config['username']}"] if config['username']
-        args += ["-P", "#{config['password']}"] if config['password']
-
-        if config['host']
-          host_arg = "#{config['host']}"
-          host_arg << ":#{config['port']}" if config['port']
-          args += ["-S", host_arg]
-        end
-
-        find_cmd_and_exec("sqsh", *args)
-
-      else
-        abort "Unknown command-line client for #{config['database']}."
-      end
-    end
-
-    def config
-      @config ||= begin
-        if configurations[environment].blank?
-          raise ActiveRecord::AdapterNotSpecified, "'#{environment}' database is not configured. Available configuration: #{configurations.inspect}"
-        else
-          configurations[environment]
-        end
-      end
-    end
-
-    def environment
-      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 find_cmd_and_exec(commands, *args)
-        commands = Array(commands)
-
-        dirs_on_path = ENV['PATH'].to_s.split(File::PATH_SEPARATOR)
-        unless (ext = RbConfig::CONFIG['EXEEXT']).empty?
-          commands = commands.map{|cmd| "#{cmd}#{ext}"}
-        end
-
-        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