railties 6.0.0 → 7.1.3.2

data/lib/rails/generators/actions.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "shellwords"
+require "active_support/core_ext/kernel/reporting"
 require "active_support/core_ext/string/strip"
 
 module Rails
@@ -10,12 +12,58 @@ module Rails
         @indentation = 0
       end
 
-      # Adds an entry into +Gemfile+ for the supplied gem.
+      # Adds a +gem+ declaration to the +Gemfile+ for the specified gem.
       #
       #   gem "rspec", group: :test
       #   gem "technoweenie-restful-authentication", lib: "restful-authentication", source: "http://gems.github.com/"
       #   gem "rails", "3.0", git: "https://github.com/rails/rails"
       #   gem "RedCloth", ">= 4.1.0", "< 4.2.0"
+      #   gem "rspec", comment: "Put this comment above the gem declaration"
+      #
+      # Note that this method only adds the gem to the +Gemfile+; it does not
+      # install the gem.
+      #
+      # ==== Options
+      #
+      # [+:version+]
+      #   The version constraints for the gem, specified as a string or an
+      #   array of strings:
+      #
+      #     gem "my_gem", version: "~> 1.1"
+      #     gem "my_gem", version: [">= 1.1", "< 2.0"]
+      #
+      #   Alternatively, can be specified as one or more arguments following the
+      #   gem name:
+      #
+      #     gem "my_gem", ">= 1.1", "< 2.0"
+      #
+      # [+:comment+]
+      #   Outputs a comment above the +gem+ declaration in the +Gemfile+.
+      #
+      #     gem "my_gem", comment: "First line.\nSecond line."
+      #
+      #   Outputs:
+      #
+      #     # First line.
+      #     # Second line.
+      #     gem "my_gem"
+      #
+      # [+:group+]
+      #   The gem group in the +Gemfile+ that the gem belongs to.
+      #
+      # [+:git+]
+      #   The URL of the git repository for the gem.
+      #
+      # Any additional options passed to this method will be appended to the
+      # +gem+ declaration in the +Gemfile+. For example:
+      #
+      #   gem "my_gem", comment: "Edge my_gem", git: "https://example.com/my_gem.git", branch: "master"
+      #
+      # Outputs:
+      #
+      #   # Edge my_gem
+      #   gem "my_gem", git: "https://example.com/my_gem.git", branch: "master"
+      #
       def gem(*args)
         options = args.extract_options!
         name, *versions = args
@@ -24,6 +72,9 @@ module Rails
         # otherwise use name (version).
         parts, message = [ quote(name) ], name.dup
 
+        # Output a comment above the gem declaration.
+        comment = options.delete(:comment)
+
         if versions = versions.any? ? versions : options.delete(:version)
           _versions = Array(versions)
           _versions.each do |version|
@@ -38,10 +89,17 @@ module Rails
         parts << quote(options) unless options.empty?
 
         in_root do
-          str = "gem #{parts.join(", ")}"
-          str = indentation + str
-          str = "\n" + str
-          append_file "Gemfile", str, verbose: false
+          str = []
+          if comment
+            comment.each_line do |comment_line|
+              str << indentation
+              str << "# #{comment_line}"
+            end
+            str << "\n"
+          end
+          str << indentation
+          str << "gem #{parts.join(", ")}"
+          append_file_with_newline "Gemfile", str.join, verbose: false
         end
       end
 
@@ -58,9 +116,9 @@ module Rails
         log :gemfile, "group #{str}"
 
         in_root do
-          append_file "Gemfile", "\ngroup #{str} do", force: true
+          append_file_with_newline "Gemfile", "\ngroup #{str} do", force: true
           with_indentation(&block)
-          append_file "Gemfile", "\nend\n", force: true
+          append_file_with_newline "Gemfile", "end", force: true
         end
       end
 
@@ -71,9 +129,13 @@ module Rails
         log :github, "github #{str}"
 
         in_root do
-          append_file "Gemfile", "\n#{indentation}github #{str} do", force: true
+          if @indentation.zero?
+            append_file_with_newline "Gemfile", "\ngithub #{str} do", force: true
+          else
+            append_file_with_newline "Gemfile", "#{indentation}github #{str} do", force: true
+          end
           with_indentation(&block)
-          append_file "Gemfile", "\n#{indentation}end", force: true
+          append_file_with_newline "Gemfile", "#{indentation}end", force: true
         end
       end
 
@@ -91,27 +153,56 @@ module Rails
 
         in_root do
           if block
-            append_file "Gemfile", "\nsource #{quote(source)} do", force: true
+            append_file_with_newline "Gemfile", "\nsource #{quote(source)} do", force: true
             with_indentation(&block)
-            append_file "Gemfile", "\nend\n", force: true
+            append_file_with_newline "Gemfile", "end", force: true
           else
             prepend_file "Gemfile", "source #{quote(source)}\n", verbose: false
           end
         end
       end
 
-      # Adds a line inside the Application class for <tt>config/application.rb</tt>.
+      # Adds configuration code to a \Rails runtime environment.
       #
-      # If options <tt>:env</tt> is specified, the line is appended to the corresponding
-      # file in <tt>config/environments</tt>.
+      # By default, adds code inside the +Application+ class in
+      # +config/application.rb+ so that it applies to all environments.
+      #
+      #   environment %(config.asset_host = "cdn.provider.com")
+      #
+      # Results in:
+      #
+      #   # config/application.rb
+      #   class Application < Rails::Application
+      #     config.asset_host = "cdn.provider.com"
+      #     # ...
+      #   end
+      #
+      # If the +:env+ option is specified, the code will be added to the
+      # corresponding file in +config/environments+ instead.
+      #
+      #   environment %(config.asset_host = "localhost:3000"), env: "development"
+      #
+      # Results in:
+      #
+      #   # config/environments/development.rb
+      #   Rails.application.configure do
+      #     config.asset_host = "localhost:3000"
+      #     # ...
+      #   end
+      #
+      # +:env+ can also be an array. In which case, the code is added to each
+      # corresponding file in +config/environments+.
+      #
+      # The code can also be specified as the return value of the block:
       #
       #   environment do
-      #     "config.action_controller.asset_host = 'cdn.provider.com'"
+      #     %(config.asset_host = "cdn.provider.com")
       #   end
       #
       #   environment(nil, env: "development") do
-      #     "config.action_controller.asset_host = 'localhost:3000'"
+      #     %(config.asset_host = "localhost:3000")
       #   end
+      #
       def environment(data = nil, options = {})
         sentinel = "class Application < Rails::Application\n"
         env_file_sentinel = "Rails.application.configure do\n"
@@ -129,11 +220,20 @@ module Rails
       end
       alias :application :environment
 
-      # Run a command in git.
+      # Runs one or more git commands.
       #
       #   git :init
+      #   # => runs `git init`
+      #
       #   git add: "this.file that.rb"
-      #   git add: "onefile.rb", rm: "badfile.cxx"
+      #   # => runs `git add this.file that.rb`
+      #
+      #   git commit: "-m 'First commit'"
+      #   # => runs `git commit -m 'First commit'`
+      #
+      #   git add: "good.rb", rm: "bad.cxx"
+      #   # => runs `git add good.rb; git rm bad.cxx`
+      #
       def git(commands = {})
         if commands.is_a?(Symbol)
           run "git #{commands}"
@@ -144,119 +244,195 @@ module Rails
         end
       end
 
-      # Create a new file in the <tt>vendor/</tt> directory. Code can be specified
-      # in a block or a data string can be given.
+      # Creates a file in +vendor/+. The contents can be specified as an
+      # argument or as the return value of the block.
       #
-      #   vendor("sekrit.rb") do
-      #     sekrit_salt = "#{Time.now}--#{3.years.ago}--#{rand}--"
-      #     "salt = '#{sekrit_salt}'"
+      #   vendor "foreign.rb", <<~RUBY
+      #     # Foreign code is fun
+      #   RUBY
+      #
+      #   vendor "foreign.rb" do
+      #     "# Foreign code is fun"
       #   end
       #
-      #   vendor("foreign.rb", "# Foreign code is fun")
       def vendor(filename, data = nil)
         log :vendor, filename
         data ||= yield if block_given?
         create_file("vendor/#{filename}", optimize_indentation(data), verbose: false)
       end
 
-      # Create a new file in the <tt>lib/</tt> directory. Code can be specified
-      # in a block or a data string can be given.
+      # Creates a file in +lib/+. The contents can be specified as an argument
+      # or as the return value of the block.
+      #
+      #   lib "foreign.rb", <<~RUBY
+      #     # Foreign code is fun
+      #   RUBY
       #
-      #   lib("crypto.rb") do
-      #     "crypted_special_value = '#{rand}--#{Time.now}--#{rand(1337)}--'"
+      #   lib "foreign.rb" do
+      #     "# Foreign code is fun"
       #   end
       #
-      #   lib("foreign.rb", "# Foreign code is fun")
       def lib(filename, data = nil)
         log :lib, filename
         data ||= yield if block_given?
         create_file("lib/#{filename}", optimize_indentation(data), verbose: false)
       end
 
-      # Create a new +Rakefile+ with the provided code (either in a block or a string).
+      # Creates a Rake tasks file in +lib/tasks/+. The code can be specified as
+      # an argument or as the return value of the block.
       #
-      #   rakefile("bootstrap.rake") do
+      #   rakefile "bootstrap.rake", <<~RUBY
+      #     task :bootstrap do
+      #       puts "Boots! Boots! Boots!"
+      #     end
+      #   RUBY
+      #
+      #   rakefile "bootstrap.rake" do
       #     project = ask("What is the UNIX name of your project?")
       #
-      #     <<-TASK
+      #     <<~RUBY
       #       namespace :#{project} do
       #         task :bootstrap do
-      #           puts "I like boots!"
+      #           puts "Boots! Boots! Boots!"
       #         end
       #       end
-      #     TASK
+      #     RUBY
       #   end
       #
-      #   rakefile('seed.rake', 'puts "Planting seeds"')
       def rakefile(filename, data = nil)
         log :rakefile, filename
         data ||= yield if block_given?
         create_file("lib/tasks/#{filename}", optimize_indentation(data), verbose: false)
       end
 
-      # Create a new initializer with the provided code (either in a block or a string).
-      #
-      #   initializer("globals.rb") do
-      #     data = ""
+      # Creates an initializer file in +config/initializers/+. The code can be
+      # specified as an argument or as the return value of the block.
       #
-      #     ['MY_WORK', 'ADMINS', 'BEST_COMPANY_EVAR'].each do |const|
-      #       data << "#{const} = :entp\n"
-      #     end
+      #   initializer "api.rb", <<~RUBY
+      #     API_KEY = "123456"
+      #   RUBY
       #
-      #     data
+      #   initializer "api.rb" do
+      #     %(API_KEY = "123456")
       #   end
       #
-      #   initializer("api.rb", "API_KEY = '123456'")
       def initializer(filename, data = nil)
         log :initializer, filename
         data ||= yield if block_given?
         create_file("config/initializers/#{filename}", optimize_indentation(data), verbose: false)
       end
 
-      # Generate something using a generator from Rails or a plugin.
-      # The second parameter is the argument string that is passed to
-      # the generator or an Array that is joined.
+      # Runs another generator.
+      #
+      #   generate "scaffold", "Post title:string body:text"
+      #   generate "scaffold", "Post", "title:string", "body:text"
       #
-      #   generate(:authenticated, "user session")
+      # The first argument is the generator name, and the remaining arguments
+      # are joined together and passed to the generator.
       def generate(what, *args)
         log :generate, what
 
         options = args.extract_options!
-        options[:without_rails_env] = true
-        argument = args.flat_map(&:to_s).join(" ")
+        options[:abort_on_failure] = !options[:inline]
 
-        execute_command :rails, "generate #{what} #{argument}", options
+        rails_command "generate #{what} #{args.join(" ")}", options
       end
 
-      # Runs the supplied rake task (invoked with 'rake ...')
+      # Runs the specified Rake task.
+      #
+      #   rake "db:migrate"
+      #   rake "db:migrate", env: "production"
+      #   rake "db:migrate", abort_on_failure: true
+      #   rake "stats", capture: true
+      #   rake "gems:install", sudo: true
+      #
+      # ==== Options
+      #
+      # [+:env+]
+      #   The \Rails environment in which to run the task. Defaults to
+      #   <tt>ENV["RAILS_ENV"] || "development"</tt>.
+      #
+      # [+:abort_on_failure+]
+      #   Whether to halt the generator if the task exits with a non-success
+      #   exit status.
       #
-      #   rake("db:migrate")
-      #   rake("db:migrate", env: "production")
-      #   rake("gems:install", sudo: true)
-      #   rake("gems:install", capture: true)
+      # [+:capture+]
+      #   Whether to capture and return the output of the task.
+      #
+      # [+:sudo+]
+      #   Whether to run the task using +sudo+.
       def rake(command, options = {})
         execute_command :rake, command, options
       end
 
-      # Runs the supplied rake task (invoked with 'rails ...')
+      # Runs the specified \Rails command.
+      #
+      #   rails_command "db:migrate"
+      #   rails_command "db:migrate", env: "production"
+      #   rails_command "db:migrate", abort_on_failure: true
+      #   rails_command "stats", capture: true
+      #   rails_command "gems:install", sudo: true
+      #
+      # ==== Options
+      #
+      # [+:env+]
+      #   The \Rails environment in which to run the command. Defaults to
+      #   <tt>ENV["RAILS_ENV"] || "development"</tt>.
+      #
+      # [+:abort_on_failure+]
+      #   Whether to halt the generator if the command exits with a non-success
+      #   exit status.
       #
-      #   rails_command("db:migrate")
-      #   rails_command("db:migrate", env: "production")
-      #   rails_command("gems:install", sudo: true)
-      #   rails_command("gems:install", capture: true)
+      # [+:capture+]
+      #   Whether to capture and return the output of the command.
+      #
+      # [+:sudo+]
+      #   Whether to run the command using +sudo+.
       def rails_command(command, options = {})
-        execute_command :rails, command, options
+        if options[:inline]
+          log :rails, command
+          command, *args = Shellwords.split(command)
+          in_root do
+            silence_warnings do
+              ::Rails::Command.invoke(command, args, **options)
+            end
+          end
+        else
+          execute_command :rails, command, options
+        end
       end
 
-      # Make an entry in Rails routing file <tt>config/routes.rb</tt>
+      # Make an entry in \Rails routing file <tt>config/routes.rb</tt>
       #
       #   route "root 'welcome#index'"
-      def route(routing_code)
+      #   route "root 'admin#index'", namespace: :admin
+      def route(routing_code, namespace: nil)
+        namespace = Array(namespace)
+        namespace_pattern = route_namespace_pattern(namespace)
+        routing_code = namespace.reverse.reduce(routing_code) do |code, name|
+          "namespace :#{name} do\n#{rebase_indentation(code, 2)}end"
+        end
+
         log :route, routing_code
-        sentinel = /\.routes\.draw do\s*\n/m
 
         in_root do
-          inject_into_file "config/routes.rb", optimize_indentation(routing_code, 2), after: sentinel, verbose: false, force: false
+          if namespace_match = match_file("config/routes.rb", namespace_pattern)
+            base_indent, *, existing_block_indent = namespace_match.captures.compact.map(&:length)
+            existing_line_pattern = /^[ ]{,#{existing_block_indent}}\S.+\n?/
+            routing_code = rebase_indentation(routing_code, base_indent + 2).gsub(existing_line_pattern, "")
+            namespace_pattern = /#{Regexp.escape namespace_match.to_s}/
+          end
+
+          inject_into_file "config/routes.rb", routing_code, after: namespace_pattern, verbose: false, force: false
+
+          if behavior == :revoke && namespace.any? && namespace_match
+            empty_block_pattern = /(#{namespace_pattern})((?:\s*end\n){1,#{namespace.size}})/
+            gsub_file "config/routes.rb", empty_block_pattern, verbose: false, force: true do |matched|
+              beginning, ending = empty_block_pattern.match(matched).captures
+              ending.sub!(/\A\s*end\n/, "") while !ending.empty? && beginning.sub!(/^[ ]*namespace .+ do\n\s*\z/, "")
+              beginning + ending
+            end
+          end
         end
       end
 
@@ -268,7 +444,6 @@ module Rails
       end
 
       private
-
         # Define log for backwards compatibility. If just one argument is sent,
         # invoke say, otherwise invoke say_status. Differently from say and
         # similarly to say_status, this method respects the quiet? option given.
@@ -285,28 +460,18 @@ module Rails
         # based on the executor parameter provided.
         def execute_command(executor, command, options = {}) # :doc:
           log executor, command
-          env = options[:env] || ENV["RAILS_ENV"] || "development"
-          rails_env = " RAILS_ENV=#{env}" unless options[:without_rails_env]
           sudo = options[:sudo] && !Gem.win_platform? ? "sudo " : ""
-          config = { verbose: false }
-
-          config[:capture] = options[:capture] if options[:capture]
-          config[:abort_on_failure] = options[:abort_on_failure] if options[:abort_on_failure]
-
-          in_root { run("#{sudo}#{extify(executor)} #{command}#{rails_env}", config) }
+          config = {
+            env: { "RAILS_ENV" => (options[:env] || ENV["RAILS_ENV"] || "development") },
+            verbose: false,
+            capture: options[:capture],
+            abort_on_failure: options[:abort_on_failure],
+          }
+
+          in_root { run("#{sudo}#{Shellwords.escape Gem.ruby} bin/#{executor} #{command}", config) }
         end
 
-        # Add an extension to the given name based on the platform.
-        def extify(name) # :doc:
-          if Gem.win_platform?
-            "#{name}.bat"
-          else
-            name
-          end
-        end
-
-        # Surround string with single quotes if there is no quotes.
-        # Otherwise fall back to double quotes
+        # Always returns value in double quotes.
         def quote(value) # :doc:
           if value.respond_to? :each_pair
             return value.map do |k, v|
@@ -315,23 +480,15 @@ module Rails
           end
           return value.inspect unless value.is_a? String
 
-          if value.include?("'")
-            value.inspect
-          else
-            "'#{value}'"
-          end
+          "\"#{value.tr("'", '"')}\""
         end
 
         # Returns optimized string with indentation
         def optimize_indentation(value, amount = 0) # :doc:
           return "#{value}\n" unless value.is_a?(String)
-
-          if value.lines.size > 1
-            value.strip_heredoc.indent(amount)
-          else
-            "#{value.strip.indent(amount)}\n"
-          end
+          "#{value.strip_heredoc.indent(amount).chomp}\n"
         end
+        alias rebase_indentation optimize_indentation
 
         # Indent the +Gemfile+ to the depth of @indentation
         def indentation # :doc:
@@ -345,6 +502,27 @@ module Rails
         ensure
           @indentation -= 1
         end
+
+        # Append string to a file with a newline if necessary
+        def append_file_with_newline(path, str, options = {})
+          gsub_file path, /\n?\z/, options do |match|
+            match.end_with?("\n") ? "" : "\n#{str}\n"
+          end
+        end
+
+        def match_file(path, pattern)
+          File.read(path).match(pattern) if File.exist?(path)
+        end
+
+        def route_namespace_pattern(namespace)
+          namespace.each_with_index.reverse_each.reduce(nil) do |pattern, (name, i)|
+            cummulative_margin = "\\#{i + 1}[ ]{2}"
+            blank_or_indented_line = "^[ ]*\n|^#{cummulative_margin}.*\n"
+            "(?:(?:#{blank_or_indented_line})*?^(#{cummulative_margin})namespace :#{name} do\n#{pattern})?"
+          end.then do |pattern|
+            /^([ ]*).+\.routes\.draw do[ ]*\n#{pattern}/
+          end
+        end
     end
   end
 end

data/lib/rails/generators/active_model.rb

@@ -2,7 +2,7 @@
 
 module Rails
   module Generators
-    # ActiveModel is a class to be implemented by each ORM to allow Rails to
+    # ActiveModel is a class to be implemented by each ORM to allow \Rails to
     # generate customized controller code.
     #
     # The API has the same methods as ActiveRecord, but each method returns a
@@ -32,21 +32,27 @@ module Rails
         @name = name
       end
 
-      # GET index
+      # Used for:
+      #
+      # * GET +index+
       def self.all(klass)
         "#{klass}.all"
       end
 
-      # GET show
-      # GET edit
-      # PATCH/PUT update
-      # DELETE destroy
+      # Used for:
+      #
+      # * GET +show+
+      # * GET +edit+
+      # * PATCH / PUT +update+
+      # * DELETE +destroy+
       def self.find(klass, params = nil)
         "#{klass}.find(#{params})"
       end
 
-      # GET new
-      # POST create
+      # Used for:
+      #
+      # * GET +new+
+      # * POST +create+
       def self.build(klass, params = nil)
         if params
           "#{klass}.new(#{params})"
@@ -55,25 +61,33 @@ module Rails
         end
       end
 
-      # POST create
+      # Used for:
+      #
+      # * POST +create+
       def save
         "#{name}.save"
       end
 
-      # PATCH/PUT update
+      # Used for:
+      #
+      # * PATCH / PUT +update+
       def update(params = nil)
         "#{name}.update(#{params})"
       end
 
-      # POST create
-      # PATCH/PUT update
+      # Used for:
+      #
+      # * POST +create+
+      # * PATCH / PUT +update+
       def errors
         "#{name}.errors"
       end
 
-      # DELETE destroy
+      # Used for:
+      #
+      # * DELETE +destroy+
       def destroy
-        "#{name}.destroy"
+        "#{name}.destroy!"
       end
     end
   end