omg-railties 8.0.0.alpha3

data/lib/rails/commands/encrypted/encrypted_command.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "active_support"
+require "rails/command/helpers/editor"
+
+module Rails
+  module Command
+    class EncryptedCommand < Rails::Command::Base # :nodoc:
+      include Helpers::Editor
+
+      class_option :key, aliases: "-k", type: :string,
+        default: "config/master.key", desc: "The Rails.root relative path to the encryption key"
+
+      desc "edit", "Open the decrypted file in `$VISUAL` or `$EDITOR` for editing"
+      def edit(*)
+        load_environment_config!
+
+        ensure_encryption_key_has_been_added
+        ensure_encrypted_configuration_has_been_added
+
+        change_encrypted_configuration_in_system_editor
+      end
+
+      desc "show", "Show the decrypted contents of the file"
+      def show(*)
+        load_environment_config!
+
+        say encrypted_configuration.read.presence || missing_encrypted_configuration_message
+      end
+
+      private
+        def content_path
+          @content_path ||= args[0]
+        end
+
+        def key_path
+          options[:key]
+        end
+
+        def encrypted_configuration
+          @encrypted_configuration ||= Rails.application.encrypted(content_path, key_path: key_path)
+        end
+
+        def ensure_encryption_key_has_been_added
+          return if encrypted_configuration.key?
+          encryption_key_file_generator.add_key_file(key_path)
+          encryption_key_file_generator.ignore_key_file(key_path)
+        end
+
+        def ensure_encrypted_configuration_has_been_added
+          encrypted_file_generator.add_encrypted_file_silently(content_path, key_path)
+        end
+
+        def change_encrypted_configuration_in_system_editor
+          using_system_editor do
+            encrypted_configuration.change { |tmp_path| system_editor(tmp_path) }
+            say "File encrypted and saved."
+            warn_if_encrypted_configuration_is_invalid
+          end
+        rescue ActiveSupport::EncryptedFile::MissingKeyError => error
+          say error.message
+        rescue ActiveSupport::MessageEncryptor::InvalidMessage
+          say "Couldn't decrypt #{content_path}. Perhaps you passed the wrong key?"
+        end
+
+        def warn_if_encrypted_configuration_is_invalid
+          encrypted_configuration.validate!
+        rescue ActiveSupport::EncryptedConfiguration::InvalidContentError => error
+          say "WARNING: #{error.message}", :red
+          say ""
+          say "Your application will not be able to load '#{content_path}' until the error has been fixed.", :red
+        end
+
+        def encryption_key_file_generator
+          require "rails/generators"
+          require "rails/generators/rails/encryption_key_file/encryption_key_file_generator"
+
+          Rails::Generators::EncryptionKeyFileGenerator.new
+        end
+
+        def encrypted_file_generator
+          require "rails/generators"
+          require "rails/generators/rails/encrypted_file/encrypted_file_generator"
+
+          Rails::Generators::EncryptedFileGenerator.new
+        end
+
+        def missing_encrypted_configuration_message
+          if !encrypted_configuration.key?
+            "Missing '#{key_path}' to decrypt data. See `#{executable(:help)}`"
+          else
+            "File '#{content_path}' does not exist. Use `#{executable(:edit)} #{content_path}` to change that."
+          end
+        end
+    end
+  end
+end

data/lib/rails/commands/gem_help/USAGE

@@ -0,0 +1,16 @@
+Usage:
+  rails COMMAND [options]
+
+You must specify a command:
+
+  new          Create a new Rails application. "rails new my_app" creates a
+               new application called MyApp in "./my_app"
+  plugin new   Create a new Rails railtie or engine
+
+All commands can be run with -h (or --help) for more information.
+
+Inside a Rails application directory, some common commands are:
+
+  console      Start the Rails console
+  server       Start the Rails server
+  test         Run tests except system tests

data/lib/rails/commands/gem_help/gem_help_command.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class GemHelpCommand < Base # :nodoc:
+      hide_command!
+
+      def perform
+        say self.class.class_usage
+      end
+    end
+  end
+end

data/lib/rails/commands/generate/generate_command.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module Rails
+  module Command
+    class GenerateCommand < Base # :nodoc:
+      no_commands do
+        def help
+          boot_application!
+          load_generators
+
+          Rails::Generators.help self.class.command_name
+        end
+      end
+
+      def perform(*)
+        generator = args.shift
+        return help unless generator
+
+        boot_application!
+        load_generators
+
+        ARGV.replace(args) # set up ARGV for third-party libraries
+
+        Rails::Generators.invoke generator, args, behavior: :invoke, destination_root: Rails::Command.root
+      end
+    end
+  end
+end

data/lib/rails/commands/help/USAGE

@@ -0,0 +1,17 @@
+Usage:
+  bin/rails COMMAND [options]
+
+You must specify a command. The most common 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 except system tests (short-cut alias: "t")
+  test:system  Run system tests
+  dbconsole    Start a console for the database specified in config/database.yml
+               (short-cut alias: "db")
+<% unless engine? -%>
+  plugin new   Create a new Rails railtie or engine
+<% end -%>
+
+All commands can be run with -h (or --help) for more information.

data/lib/rails/commands/help/help_command.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class HelpCommand < Base # :nodoc:
+      hide_command!
+
+      def help(*)
+        say self.class.class_usage
+      end
+
+      def help_extended(*)
+        help
+
+        say ""
+        say "In addition to those commands, there are:"
+        say ""
+
+        extended_commands = printing_commands_not_in_usage.sort_by(&:first)
+        print_table(extended_commands, truncate: true)
+      end
+
+      private
+        COMMANDS_IN_USAGE = %w(generate console server test test:system dbconsole new)
+        private_constant :COMMANDS_IN_USAGE
+
+        def printing_commands_not_in_usage # :nodoc:
+          Rails::Command.printing_commands.reject do |command, _|
+            command.in?(COMMANDS_IN_USAGE)
+          end
+        end
+    end
+  end
+end

data/lib/rails/commands/initializers/initializers_command.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "rails/command/environment_argument"
+
+module Rails
+  module Command
+    class InitializersCommand < Base # :nodoc:
+      include EnvironmentArgument
+
+      desc "initializers", "Print out all defined initializers in the order they are invoked by Rails."
+      def perform
+        boot_application!
+
+        Rails.application.initializers.tsort_each do |initializer|
+          say "#{initializer.context_class}.#{initializer.name}"
+        end
+      end
+    end
+  end
+end

data/lib/rails/commands/middleware/middleware_command.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class MiddlewareCommand < Base # :nodoc:
+      desc "middleware", "Print out your Rack middleware stack"
+      def perform
+        boot_application!
+
+        Rails.configuration.middleware.each do |middleware|
+          say "use #{middleware.inspect}"
+        end
+        say "run #{Rails.application.class.name}.routes"
+      end
+    end
+  end
+end

data/lib/rails/commands/new/new_command.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class NewCommand < Base # :nodoc:
+      self.bin = "rails"
+
+      no_commands do
+        def help
+          Rails::Command.invoke :application, [ "--help" ]
+        end
+      end
+
+      def perform(*)
+        say "Can't initialize a new Rails application within the directory of another, please change to a non-Rails directory first.\n"
+        say "Type 'rails' for help."
+        exit 1
+      end
+    end
+  end
+end

data/lib/rails/commands/notes/notes_command.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "rails/source_annotation_extractor"
+
+module Rails
+  module Command
+    class NotesCommand < Base # :nodoc:
+      class_option :annotations, aliases: "-a", desc: "Filter by specific annotations, e.g. Foobar TODO", type: :array
+
+      desc "notes", "Show comments in your code annotated with FIXME, OPTIMIZE, and TODO"
+      def perform(*)
+        boot_application!
+
+        display_annotations
+      end
+
+      private
+        def display_annotations
+          annotations = options[:annotations] || Rails::SourceAnnotationExtractor::Annotation.tags
+          tag = (annotations.length > 1)
+
+          Rails::SourceAnnotationExtractor.enumerate annotations.join("|"), tag: tag, dirs: directories
+        end
+
+        def directories
+          Rails::SourceAnnotationExtractor::Annotation.directories
+        end
+    end
+  end
+end

data/lib/rails/commands/plugin/plugin_command.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class PluginCommand < Base # :nodoc:
+      hide_command!
+
+      self.bin = "rails"
+
+      def help
+        run_plugin_generator %w( --help )
+      end
+
+      def self.banner(*) # :nodoc:
+        "#{executable} new [options]"
+      end
+
+      class_option :rc, type: :string, default: File.join("~", ".railsrc"),
+        desc: "Initialize the plugin command with previous defaults. Uses .railsrc in your home directory by default."
+
+      class_option :no_rc, desc: "Skip evaluating .railsrc."
+
+      def perform(type = nil, *plugin_args)
+        plugin_args << "--help" unless type == "new"
+
+        unless options.key?("no_rc") # Thor's not so indifferent access hash.
+          railsrc = File.expand_path(options[:rc])
+
+          if File.exist?(railsrc)
+            extra_args = File.read(railsrc).split(/\n+/).flat_map(&:split)
+            say "Using #{extra_args.join(" ")} from #{railsrc}"
+            plugin_args.insert(1, *extra_args)
+          end
+        end
+
+        run_plugin_generator plugin_args
+      end
+
+      private
+        def run_plugin_generator(plugin_args)
+          require "rails/generators"
+          require "rails/generators/rails/plugin/plugin_generator"
+          Rails::Generators::PluginGenerator.start plugin_args
+        end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class RakeCommand < Base # :nodoc:
+      extend Rails::Command::Actions
+
+      namespace "rake"
+
+      class << self
+        def printing_commands
+          rake_tasks.filter_map do |task|
+            if task.comment && task.locations.any?(non_app_file_pattern)
+              [task.name_with_args, task.comment]
+            end
+          end
+        end
+
+        def perform(task, args, config)
+          with_rake(task, *args) do |rake|
+            if unrecognized_task = (rake.top_level_tasks - ["default"]).find { |task| !rake.lookup(task[/[^\[]+/]) }
+              @rake_tasks = rake.tasks
+              raise UnrecognizedCommandError.new(unrecognized_task)
+            end
+
+            rake.options.suppress_backtrace_pattern = non_app_file_pattern
+            rake.standard_exception_handling { rake.top_level }
+          end
+        end
+
+        private
+          def non_app_file_pattern
+            /\A(?!#{Regexp.quote Rails::Command.root.to_s})/
+          end
+
+          def with_rake(*args, &block)
+            require "rake"
+            Rake::TaskManager.record_task_metadata = true
+
+            result = nil
+            Rake.with_application do |rake|
+              rake.init(bin, args) unless args.empty?
+              rake.load_rakefile
+              result = block.call(rake)
+            end
+            result
+          end
+
+          def rake_tasks
+            @rake_tasks ||= with_rake(&:tasks)
+          end
+      end
+    end
+  end
+end

data/lib/rails/commands/restart/restart_command.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class RestartCommand < Base # :nodoc:
+      desc "restart", "Restart app by touching tmp/restart.txt"
+      def perform
+        require "fileutils"
+        FileUtils.mkdir_p Rails::Command.application_root.join("tmp")
+        FileUtils.touch   Rails::Command.application_root.join("tmp/restart.txt")
+      end
+    end
+  end
+end

data/lib/rails/commands/routes/routes_command.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "rails/command"
+
+module Rails
+  module Command
+    class RoutesCommand < Base # :nodoc:
+      class_option :controller, aliases: "-c", desc: "Filter by a specific controller, e.g. PostsController or Admin::PostsController."
+      class_option :grep, aliases: "-g", desc: "Grep routes by a specific pattern."
+      class_option :expanded, type: :boolean, aliases: "-E", desc: "Print routes expanded vertically with parts explained."
+      class_option :unused, type: :boolean, aliases: "-u", desc: "Print unused routes."
+
+      no_commands do
+        def invoke_command(*)
+          if options.key?("unused")
+            Rails::Command.invoke "unused_routes", ARGV
+          else
+            super
+          end
+        end
+      end
+
+      desc "routes", "List all the defined routes"
+      def perform(*)
+        boot_application!
+        require "action_dispatch/routing/inspector"
+
+        say inspector.format(formatter, routes_filter)
+      end
+
+      private
+        def inspector
+          ActionDispatch::Routing::RoutesInspector.new(Rails.application.routes.routes)
+        end
+
+        def formatter
+          if options.key?("expanded")
+            ActionDispatch::Routing::ConsoleFormatter::Expanded.new
+          else
+            ActionDispatch::Routing::ConsoleFormatter::Sheet.new
+          end
+        end
+
+        def routes_filter
+          options.symbolize_keys.slice(:controller, :grep)
+        end
+    end
+  end
+end

data/lib/rails/commands/runner/USAGE

@@ -0,0 +1,22 @@
+Description:
+    The Rails `runner` allows running Ruby code in the context of your application.
+
+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
+
+    Run the Ruby script read from stdin after loading the app:
+
+        <%= executable %> -
+<% 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,81 @@
+# frozen_string_literal: true
+
+require "rails/command/environment_argument"
+
+module Rails
+  module Command
+    class RunnerCommand < Base # :nodoc:
+      include EnvironmentArgument
+
+      class_option :skip_executor, type: :boolean, aliases: "-w", desc: "Don't wrap with Rails Executor", default: false
+
+      no_commands do
+        def help(command_name = nil, *)
+          super
+          if command_name == "runner"
+            say ""
+            say self.class.class_usage
+          end
+        end
+      end
+
+      desc "runner [<'Some.ruby(code)'> | <filename.rb> | -]",
+        "Run Ruby code in the context of your application"
+      def perform(code_or_file = nil, *command_argv)
+        unless code_or_file
+          help
+          exit 1
+        end
+
+        boot_application!
+        Rails.application.load_runner
+
+        ARGV.replace(command_argv)
+
+        wrap_with_executor = !options[:skip_executor]
+        if code_or_file == "-"
+          conditional_executor(wrap_with_executor, source: "application.runner.railties") do
+            eval($stdin.read, TOPLEVEL_BINDING, "stdin")
+          end
+        elsif File.exist?(code_or_file)
+          expanded_file_path = File.expand_path code_or_file
+          $0 = expanded_file_path
+          conditional_executor(wrap_with_executor, source: "application.runner.railties") do
+            Kernel.load expanded_file_path
+          end
+        else
+          begin
+            conditional_executor(wrap_with_executor, source: "application.runner.railties") do
+              eval(code_or_file, TOPLEVEL_BINDING, __FILE__, __LINE__)
+            end
+          rescue SyntaxError, NameError => e
+            if looks_like_a_file_path?(code_or_file)
+              error "The file #{code_or_file} could not be found, please check and try again."
+              error "Run '#{self.class.executable} -h' for help."
+            else
+              error "Please specify a valid ruby command or the path of a script to run."
+              error "Run '#{self.class.executable} -h' for help."
+              error ""
+              error e
+            end
+
+            exit 1
+          end
+        end
+      end
+
+      private
+        def conditional_executor(enabled, **args, &block)
+          if enabled
+            Rails.application.executor.wrap(**args, &block)
+          else
+            yield
+          end
+        end
+
+        def looks_like_a_file_path?(code_or_file)
+          code_or_file.ends_with?(".rb")
+        end
+    end
+  end
+end

data/lib/rails/commands/secret/secret_command.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class SecretCommand < Base # :nodoc:
+      desc "secret", "Generate a cryptographically secure secret key (this is typically used to generate a secret for cookie sessions)."
+      def perform
+        require "securerandom"
+        puts SecureRandom.hex(64)
+      end
+    end
+  end
+end