capistrano 3.4.0 → 3.17.1

data/lib/capistrano/application.rb

@@ -1,9 +1,8 @@
 module Capistrano
   class Application < Rake::Application
-
     def initialize
       super
-      @rakefiles = %w{capfile Capfile capfile.rb Capfile.rb} << capfile
+      @rakefiles = %w{capfile Capfile capfile.rb Capfile.rb}
     end
 
     def name
@@ -21,11 +20,11 @@ module Capistrano
         switch =~ /--#{Regexp.union(not_applicable_to_capistrano)}/
       end
 
-      super.push(version, dry_run, roles, hostfilter)
+      super.push(version, dry_run, roles, hostfilter, print_config_variables)
     end
 
     def handle_options
-      options.rakelib = ['rakelib']
+      options.rakelib = ["rakelib"]
       options.trace_output = $stderr
 
       OptionParser.new do |opts|
@@ -48,11 +47,10 @@ module Capistrano
         end
 
         standard_rake_options.each { |args| opts.on(*args) }
-        opts.environment('RAKEOPT')
+        opts.environment("RAKEOPT")
       end.parse!
     end
 
-
     def top_level_tasks
       if tasks_without_stage_dependency.include?(@top_level_tasks.first)
         @top_level_tasks
@@ -63,13 +61,10 @@ module Capistrano
 
     def display_error_message(ex)
       unless options.backtrace
-        if loc = Rake.application.find_rakefile_location
-          whitelist = (@imported.dup << loc[0]).map{|f| File.absolute_path(f, loc[1])}
-          pattern = %r@^(?!#{whitelist.map{|p| Regexp.quote(p)}.join('|')})@
-          Rake.application.options.suppress_backtrace_pattern = pattern
-        end
+        Rake.application.options.suppress_backtrace_pattern = backtrace_pattern if backtrace_pattern
         trace "(Backtrace restricted to imported tasks)"
       end
+
       super
     end
 
@@ -81,60 +76,78 @@ module Capistrano
       end
     end
 
+    # allows the `cap install` task to load without a capfile
+    def find_rakefile_location
+      if (location = super).nil?
+        [capfile, Dir.pwd]
+      else
+        location
+      end
+    end
+
     private
 
+    def backtrace_pattern
+      loc = Rake.application.find_rakefile_location
+      return unless loc
+
+      whitelist = (@imported.dup << loc[0]).map { |f| File.absolute_path(f, loc[1]) }
+      /^(?!#{whitelist.map { |p| Regexp.quote(p) }.join('|')})/
+    end
+
     def load_imports
-      if options.show_tasks
-        invoke 'load:defaults'
-        set(:stage, '')
+      if options.show_tasks && Rake::Task.task_defined?("load:defaults")
+        invoke "load:defaults"
+        set(:stage, "")
         Dir[deploy_config_path].each { |f| add_import f }
       end
 
       super
     end
 
-    # allows the `cap install` task to load without a capfile
     def capfile
-      File.expand_path(File.join(File.dirname(__FILE__),'..','Capfile'))
+      File.expand_path(File.join(File.dirname(__FILE__), "..", "Capfile"))
     end
 
     def version
-      ['--version', '-V',
+      ["--version", "-V",
        "Display the program version.",
-       lambda { |value|
-         puts "Capistrano Version: #{Capistrano::VERSION} (Rake Version: #{RAKEVERSION})"
+       lambda do |_value|
+         puts "Capistrano Version: #{Capistrano::VERSION} (Rake Version: #{Rake::VERSION})"
          exit
-       }
-      ]
+       end]
     end
 
     def dry_run
-      ['--dry-run', '-n',
+      ["--dry-run", "-n",
        "Do a dry run without executing actions",
-       lambda { |value|
+       lambda do |_value|
          Configuration.env.set(:sshkit_backend, SSHKit::Backend::Printer)
-       }
-      ]
+       end]
     end
 
     def roles
-      ['--roles ROLES', '-r',
+      ["--roles ROLES", "-r",
        "Run SSH commands only on hosts matching these roles",
-       lambda { |value|
+       lambda do |value|
          Configuration.env.add_cmdline_filter(:role, value)
-       }
-      ]
+       end]
     end
 
     def hostfilter
-      ['--hosts HOSTS', '-z',
+      ["--hosts HOSTS", "-z",
        "Run SSH commands only on matching hosts",
-       lambda { |value|
+       lambda do |value|
          Configuration.env.add_cmdline_filter(:host, value)
-       }
-      ]
+       end]
     end
 
+    def print_config_variables
+      ["--print-config-variables", "-p",
+       "Display the defined config variables before starting the deployment tasks.",
+       lambda do |_value|
+         Configuration.env.set(:print_config_variables, true)
+       end]
+    end
   end
-
 end

data/lib/capistrano/configuration/empty_filter.rb

@@ -0,0 +1,9 @@
+module Capistrano
+  class Configuration
+    class EmptyFilter
+      def filter(_servers)
+        []
+      end
+    end
+  end
+end

data/lib/capistrano/configuration/filter.rb

@@ -1,55 +1,25 @@
-require 'capistrano/configuration'
+require "capistrano/configuration"
+require "capistrano/configuration/empty_filter"
+require "capistrano/configuration/host_filter"
+require "capistrano/configuration/null_filter"
+require "capistrano/configuration/role_filter"
 
 module Capistrano
   class Configuration
     class Filter
-      def initialize type, values = nil
-        raise "Invalid filter type #{type}" unless [:host,:role].include? type
-        av = Array(values).dup
-        @mode = case
-                when av.size == 0 then :none
-                when av.include?(:all) then :all
-                else type
-                end
-        @rex = case @mode
-          when :host
-            av.map!{|v| (v.is_a?(String) && v =~ /^(?<name>[-A-Za-z0-9.]+)(,\g<name>)*$/) ? v.split(',') : v }
-            av.flatten!
-            av.map! do |v|
-              case v
-              when Regexp then v
-              else
-                vs = v.to_s
-                vs =~ /^[-A-Za-z0-9.]+$/ ? vs : Regexp.new(vs)
-              end
-            end
-            Regexp.union av
-          when :role
-            av.map!{|v| v.is_a?(String) ? v.split(',') : v }
-            av.flatten!
-            av.map! do |v|
-              case v
-              when Regexp then v
-              else
-                vs = v.to_s
-                vs =~ %r{^/(.+)/$} ? Regexp.new($1) : %r{^#{vs}$}
-              end
-            end
-            Regexp.union av
-          else
-            nil
-          end
+      def initialize(type, values=nil)
+        raise "Invalid filter type #{type}" unless %i(host role).include? type
+        av = Array(values)
+        @strategy = if av.empty? then EmptyFilter.new
+                    elsif av.include?(:all) || av.include?("all") then NullFilter.new
+                    elsif type == :host then HostFilter.new(values)
+                    elsif type == :role then RoleFilter.new(values)
+                    else NullFilter.new
+                    end
       end
-      def filter servers
-        as = Array(servers)
-        case @mode
-        when :none then return []
-        when :all  then return servers
-        when :host
-          as.select {|s| @rex.match s.hostname}
-        when :role
-          as.select {|s| s.roles.any? {|r| @rex.match r} }
-        end
+
+      def filter(servers)
+        @strategy.filter servers
       end
     end
   end

data/lib/capistrano/configuration/host_filter.rb

@@ -0,0 +1,29 @@
+module Capistrano
+  class Configuration
+    class HostFilter
+      def initialize(values)
+        av = Array(values).dup
+        av = av.flat_map { |v| v.is_a?(String) && v =~ /^(?<name>[-A-Za-z0-9.]+)(,\g<name>)*$/ ? v.split(",") : v }
+        @rex = regex_matcher(av)
+      end
+
+      def filter(servers)
+        Array(servers).select { |s| @rex.match s.to_s }
+      end
+
+      private
+
+      def regex_matcher(values)
+        values.map! do |v|
+          case v
+          when Regexp then v
+          else
+            vs = v.to_s
+            vs =~ /^[-A-Za-z0-9.]+$/ ? /^#{Regexp.quote(vs)}$/ : Regexp.new(vs)
+          end
+        end
+        Regexp.union values
+      end
+    end
+  end
+end

data/lib/capistrano/configuration/null_filter.rb

@@ -0,0 +1,9 @@
+module Capistrano
+  class Configuration
+    class NullFilter
+      def filter(servers)
+        servers
+      end
+    end
+  end
+end

data/lib/capistrano/configuration/plugin_installer.rb

@@ -0,0 +1,51 @@
+# Encapsulates the logic for installing plugins into Capistrano. Plugins must
+# simply conform to a basic API; the PluginInstaller takes care of invoking the
+# API at appropriate times.
+#
+# This class is not used directly; instead it is typically accessed via the
+# `install_plugin` method of the Capistrano DSL.
+#
+module Capistrano
+  class Configuration
+    class PluginInstaller
+      # "Installs" a Plugin into Capistrano by loading its tasks, hooks, and
+      # defaults at the appropriate time. The hooks in particular can be
+      # skipped, if you want full control over when and how the plugin's tasks
+      # are executed. Simply pass `load_hooks:false` to opt out.
+      #
+      # The plugin class or instance may be provided. These are equivalent:
+      #
+      # install(Capistrano::SCM::Git)
+      # install(Capistrano::SCM::Git.new)
+      #
+      # Note that the :load_immediately flag is for internal use only and will
+      # be removed in an upcoming release.
+      #
+      def install(plugin, load_hooks: true, load_immediately: false)
+        plugin = plugin.is_a?(Class) ? plugin.new : plugin
+
+        plugin.define_tasks
+        plugin.register_hooks if load_hooks
+        @scm_installed ||= provides_scm?(plugin)
+
+        if load_immediately
+          plugin.set_defaults
+        else
+          Rake::Task.define_task("load:defaults") do
+            plugin.set_defaults
+          end
+        end
+      end
+
+      def scm_installed?
+        @scm_installed
+      end
+
+      private
+
+      def provides_scm?(plugin)
+        plugin.respond_to?(:scm?) && plugin.scm?
+      end
+    end
+  end
+end

data/lib/capistrano/configuration/question.rb

@@ -1,9 +1,10 @@
 module Capistrano
   class Configuration
     class Question
-
-      def initialize(key, default, options = {})
-        @key, @default, @options = key, default, options
+      def initialize(key, default, options={})
+        @key = key
+        @default = default
+        @options = options
       end
 
       def call
@@ -12,10 +13,12 @@ module Capistrano
       end
 
       private
+
       attr_reader :key, :default, :options
 
       def ask_question
         $stdout.print question
+        $stdout.flush
       end
 
       def value_or_default
@@ -28,27 +31,46 @@ module Capistrano
 
       def response
         return @response if defined? @response
-        
+
         @response = (gets || "").chomp
       end
-      
+
       def gets
+        return unless stdin.tty?
+
         if echo?
-          $stdin.gets
+          stdin.gets
         else
-          $stdin.noecho(&:gets).tap{ $stdout.print "\n" }
+          stdin.noecho(&:gets).tap { $stdout.print "\n" }
         end
       rescue Errno::EIO
         # when stdio gets closed
+        return
       end
-        
+
       def question
-        I18n.t(:question, key: key, default_value: default, scope: :capistrano)
+        if prompt && default.nil?
+          I18n.t(:question_prompt, key: prompt, scope: :capistrano)
+        elsif prompt
+          I18n.t(:question_prompt_default, key: prompt, default_value: default, scope: :capistrano)
+        elsif default.nil?
+          I18n.t(:question, key: key, scope: :capistrano)
+        else
+          I18n.t(:question_default, key: key, default_value: default, scope: :capistrano)
+        end
       end
 
       def echo?
         (options || {}).fetch(:echo, true)
       end
+
+      def stdin
+        (options || {}).fetch(:stdin, $stdin)
+      end
+
+      def prompt
+        (options || {}).fetch(:prompt, nil)
+      end
     end
   end
 end

data/lib/capistrano/configuration/role_filter.rb

@@ -0,0 +1,29 @@
+module Capistrano
+  class Configuration
+    class RoleFilter
+      def initialize(values)
+        av = Array(values).dup
+        av = av.flat_map { |v| v.is_a?(String) ? v.split(",") : v }
+        @rex = regex_matcher(av)
+      end
+
+      def filter(servers)
+        Array(servers).select { |s| s.is_a?(String) ? false : s.roles.any? { |r| @rex.match r } }
+      end
+
+      private
+
+      def regex_matcher(values)
+        values.map! do |v|
+          case v
+          when Regexp then v
+          else
+            vs = v.to_s
+            vs =~ %r{^/(.+)/$} ? Regexp.new($1) : /^#{Regexp.quote(vs)}$/
+          end
+        end
+        Regexp.union values
+      end
+    end
+  end
+end

data/lib/capistrano/configuration/scm_resolver.rb

@@ -0,0 +1,149 @@
+module Capistrano
+  class Configuration
+    # In earlier versions of Capistrano, users would specify the desired SCM
+    # implementation using `set :scm, :git`, for example. Capistrano would then
+    # load the matching .rb file based on this variable.
+    #
+    # Now we expect users to explicitly `require` and call `new` on the desired
+    # SCM implementation in their Capfile. The `set` technique is deprecated.
+    #
+    # This SCMResolver class takes care of managing the transition from the old
+    # to new system. It maintains the legacy behavior, but prints deprecation
+    # warnings when it is used.
+    #
+    # To maintain backwards compatibility, the resolver will load the Git SCM by
+    # if default it determines that no SCM has been explicitly specified or
+    # loaded. To force no SCM to be used at all, use `set :scm, nil`. This hack
+    # won't be necessary once backwards compatibility is removed in a future
+    # version.
+    #
+    # TODO: Remove this class entirely in Capistrano 4.0.
+    #
+    class SCMResolver
+      DEFAULT_GIT = :"default-git"
+
+      include Capistrano::DSL
+
+      def resolve
+        return if scm_name.nil?
+        set(:scm, :git) if using_default_scm?
+
+        print_deprecation_warnings_if_applicable
+
+        # Note that `scm_plugin_installed?` comes from Capistrano::DSL
+        if scm_plugin_installed?
+          delete(:scm)
+          return
+        end
+
+        if built_in_scm_name?
+          load_built_in_scm
+        else
+          # Compatibility with existing 3.x third-party SCMs
+          register_legacy_scm_hooks
+          load_legacy_scm_by_name
+        end
+      end
+
+      private
+
+      def using_default_scm?
+        return @using_default_scm if defined? @using_default_scm
+        @using_default_scm = (fetch(:scm) == DEFAULT_GIT)
+      end
+
+      def scm_name
+        fetch(:scm)
+      end
+
+      def load_built_in_scm
+        require "capistrano/scm/#{scm_name}"
+        scm_class = Object.const_get(built_in_scm_plugin_class_name)
+        # We use :load_immediately because we are initializing the SCM plugin
+        # late in the load process and therefore can't use the standard
+        # load:defaults technique.
+        install_plugin(scm_class, load_immediately: true)
+      end
+
+      def load_legacy_scm_by_name
+        load("capistrano/#{scm_name}.rb")
+      end
+
+      def third_party_scm_name?
+        !built_in_scm_name?
+      end
+
+      def built_in_scm_name?
+        %w(git hg svn).include?(scm_name.to_s.downcase)
+      end
+
+      def built_in_scm_plugin_class_name
+        "Capistrano::SCM::#{scm_name.to_s.capitalize}"
+      end
+
+      # rubocop:disable Style/GuardClause
+      def register_legacy_scm_hooks
+        if Rake::Task.task_defined?("deploy:new_release_path")
+          after "deploy:new_release_path", "#{scm_name}:create_release"
+        end
+
+        if Rake::Task.task_defined?("deploy:check")
+          before "deploy:check", "#{scm_name}:check"
+        end
+
+        if Rake::Task.task_defined?("deploy:set_current_revision")
+          before "deploy:set_current_revision",
+                 "#{scm_name}:set_current_revision"
+        end
+      end
+      # rubocop:enable Style/GuardClause
+
+      def print_deprecation_warnings_if_applicable
+        if using_default_scm?
+          warn_add_git_to_capfile unless scm_plugin_installed?
+        elsif built_in_scm_name?
+          warn_set_scm_is_deprecated
+        elsif third_party_scm_name?
+          warn_third_party_scm_must_be_upgraded
+        end
+      end
+
+      def warn_set_scm_is_deprecated
+        $stderr.puts(<<-MESSAGE)
+[Deprecation Notice] `set :scm, #{scm_name.inspect}` is deprecated.
+To ensure your project is compatible with future versions of Capistrano,
+remove the :scm setting and instead add these lines to your Capfile after
+`require "capistrano/deploy"`:
+
+    require "capistrano/scm/#{scm_name}"
+    install_plugin #{built_in_scm_plugin_class_name}
+
+MESSAGE
+      end
+
+      def warn_add_git_to_capfile
+        $stderr.puts(<<-MESSAGE)
+[Deprecation Notice] Future versions of Capistrano will not load the Git SCM
+plugin by default. To silence this deprecation warning, add the following to
+your Capfile after `require "capistrano/deploy"`:
+
+    require "capistrano/scm/git"
+    install_plugin Capistrano::SCM::Git
+
+MESSAGE
+      end
+
+      def warn_third_party_scm_must_be_upgraded
+        $stderr.puts(<<-MESSAGE)
+[Deprecation Notice] `set :scm, #{scm_name.inspect}` is deprecated.
+To ensure this custom SCM will work with future versions of Capistrano,
+please upgrade it to a version that uses the new SCM plugin mechanism
+documented here:
+
+http://capistranorb.com/documentation/advanced-features/custom-scm
+
+MESSAGE
+      end
+    end
+  end
+end