rake-commander 0.1.4 → 0.2.0

data/lib/rake-commander/options.rb

@@ -1,5 +1,8 @@
 require_relative 'options/name'
+require_relative 'options/description'
 require_relative 'options/arguments'
+require_relative 'options/result'
+require_relative 'options/error'
 require_relative 'option'
 
 class RakeCommander
@@ -8,160 +11,234 @@ class RakeCommander
       def included(base)
         super(base)
         base.extend RakeCommander::Base::ClassHelpers
+        base.extend RakeCommander::Base::ClassInheritable
         base.extend ClassMethods
-        base.inheritable_attrs :banner, :options_hash, :results_with_all_defaults
-        base.extend RakeCommander::Options::Arguments
+        base.attr_inheritable :banner, :options_hash
+        base.class_resolver :option_class, RakeCommander::Option
+        base.send :include, RakeCommander::Options::Result
+        base.send :include, RakeCommander::Options::Error
+        base.send :include, RakeCommander::Options::Arguments
       end
     end
 
     module ClassMethods
-      def options_hash
-        @options_hash ||= {}
-      end
-
-      def options
-        options_hash.values.uniq
+      # Overrides the auto-generated banner
+      def banner(desc = :not_used)
+        return @banner = desc unless desc == :not_used
+        return @banner if @banner
+        return task_options_banner if respond_to?(:task_options_banner, true)
       end
 
-      def options?
-        !options.empty?
+      # Defines a new option or opens for edition an existing one if `reopen: true` is used.
+      # @note
+      #   - If override is `true`, it will with a Warning when same `short` or `name` clashes.
+      def option(*args, override: true, reopen: false, **kargs, &block)
+        return option_reopen(*args, override: override, **kargs, &block) if reopen
+        opt = option_class.new(*args, **kargs, &block)
+        add_to_options(opt, override: override)
       end
 
-      def clear_options!
-        @options_hash = {}
+      # It re-opens an option for edition. If it does not exist, it **upserts** it.
+      # @note
+      #   1. If `override` is `false, it will fail to change the `name` or the `short`
+      #     when they are already taken by some other option.
+      #   2. It will have the effect of overriding existing options
+      # @note when `short` and `name` are provided, `name` takes precedence over `short`
+      #   in the lookup (to identify the existing option)
+      def option_reopen(*args, override: false, **kargs, &block)
+        aux = option_class.new(*args, **kargs, sample: true, &block)
+        opt = options_hash.values_at(aux.name, aux.short).compact.first
+        return option(*args, **kargs, &block) unless opt
+        replace_in_options(opt, opt.merge(aux), override: override)
+      end
+
+      # Removes options with short or name `keys` from options
+      def option_remove(*keys)
+        keys.map do |key|
+          aux = option_class.new(key, sample: true)
+          opt = options_hash.values_at(aux.name, aux.short).compact.first
+          delete_from_options(opt) if opt
+        end
       end
 
       # Allows to use a set of options
+      # @note it does a deep dup of each option.
+      # @param override [Boolean] wheter existing options with same option name
+      #   should be overriden, may they clash
       # @param options [Enumerable<RakeCommander::Option>]
-      def use_options(options)
-        options = options.values if options.is_a?(Hash)
-        options.each do |opt|
-          add_to_options(opt)
+      def options_use(opts, override: true)
+        raise "Could not obtain list of RakeCommander::Option from #{opts.class}" unless opts = to_options(opts)
+        opts.each do |opt|
+          add_to_options(opt.deep_dup, override: override)
         end
         self
       end
 
-      # Defines a new option
-      # @note
-      #   - It will override with a Warning options with same `short` or `name`
-      def option(*args, **kargs, &block)
-        opt = RakeCommander::Option.new(*args, **kargs, &block)
-        add_to_options(opt)
-        self
+      # It builds the `OptionParser` injecting the `middleware` block and parses `argv`
+      # @note this method is extended in via the following modules:
+      #   1. `RakeCommander::Options::Result`: makes the method to return a `Hash` with results,
+      #     as well as captures/moves the **leftovers** to their own keyed argument.
+      #   2. `RakeCommander::Options:Error`: adds error handling (i.e. forward to rake commander errors)
+      # @param argv [Array<String>] the command line arguments to be parsed.
+      # @param method [Symbol] the parsing method (default is `:parse`; others: `:order`)
+      # @return [Array<String>] the **leftovers** of the `OptionParser#parse` call.
+      def parse_options(argv = ARGV, method: :parse, &middleware)
+        RakeCommander.rake_comm_debug "(#{name})  P A R S E   O P T I O N S !", "\n", num: 5, pid: true
+        RakeCommander.rake_comm_debug "  ---> ARGV: [#{argv.map {|a| a.nil?? "nil" : "'#{a}'"}.join(', ')}]"
+        options_parser(&middleware).send(method, argv)
       end
 
-      # Overrides the auto-generated banner
-      def banner(desc = :not_used)
-        return @banner = desc unless desc == :not_used
-        return @banner if @banner
-        return task_options_banner if respond_to?(:task_options_banner, true)
+      # List of configured options
+      # @return [Array<RakeCommander::Option>]
+      def options
+        options_hash.values.uniq
       end
 
-      # @return [Boolean] whether results should include options defined
-      #   with a default, regarless if they are invoked
-      def results_with_all_defaults(value = nil)
-        if value.nil?
-          @results_with_all_defaults || false
-        else
-          @results_with_all_defaults = !!value
-        end
+      # @return [Boolean] are there options defined?
+      def options?
+        !options.empty?
       end
 
-      # It builds the `OptionParser` injecting the `middleware` block.
-      # @return [Hash] with `short` option as `key` and final value as `value`.
-      def parse_options(argv = ARGV, leftovers: [], &middleware)
-        options_parser_with_results(middleware) do |options_parser|
-          argv = pre_parse_arguments(argv, options: options_hash)
-          pp argv
-          leftovers.push(*options_parser.parse(argv))
-        rescue OptionParser::MissingArgument => e
-          raise RakeCommander::Options::MissingArgument, e, cause: nil
-        rescue OptionParser::InvalidArgument => e
-          error = RakeCommander::Options::InvalidArgument
-          error = error.new(e)
-          opt   = options_hash[error.option_sym]
-          msg = "missing required argument: #{opt&.name_hyphen} (#{opt&.short_hyphen})"
-          raise RakeCommander::Options::MissingArgument, msg, cause: nil if opt&.argument_required?
-          raise error, e, cause: nil
-        end.tap do |results|
-          check_required_presence!(results)
-        end
+      # Clears all the options.
+      def clear_options!
+        @options_hash = {}
+        self
       end
 
       protected
 
+      # It allows to add a middleware block that is called during the parsing phase.
       # @return [OptionParser] the built options parser.
       def options_parser(&middleware)
         new_options_parser do |opts|
           opts.banner = banner if banner
-          options.each {|opt| opt.add_switch(opts, &middleware)}
+          option_help(opts)
+          free_shorts = implicit_shorts
+
+          options.each do |opt|
+            free_short = free_shorts.key?(opt.short_implicit)
+            opt.add_switch(opts, implicit_short: free_short, &middleware)
+          end
         end
       end
 
+      # @return [OptionParser]
       def new_options_parser(&block)
         require 'optparse'
         OptionParser.new(&block)
       end
 
-      private
-
-      # Expects a block that should do the final call to `#parse`
-      def options_parser_with_results(middleware)
-        result_defaults.tap do |result|
-          results_collector = proc do |value, default, short, name|
-            middleware&.call(value, default, short, name)
-            result[short] = value.nil?? default : value
-          end
-          options_parser = options_parser(&results_collector)
-          yield(options_parser)
+      # The options indexed by the short and the name (so doubled up in the hash).
+      # @param with_implicit [Boolean] whether free implicit shorts of declared options should be included
+      #   among the keys (pointing to the specific option that has it implicit).
+      # @return [Hash] with Symbol name and shorts as keys, and `RakeCommander::Option` as values.
+      def options_hash(with_implicit: false)
+        @options_hash ||= {}
+        return @options_hash unless with_implicit
+        @options_hash.merge(implicit_shorts)
+      end
+
+      # This covers the gap where `OptionParser` auto-generates shorts out of option names.
+      # @note `OptionParser` implicitly generates a short for the option name. When defining
+      #   an option that uses this short, the short gets overriden/reused by the explicit option.
+      #   Otherwise, the short is actually available for the former option, regarldess you
+      #   specified a different short for it (i.e. both shorts, expicit and implicit, will work).
+      # @note for two options with same implicit free short, latest in order will take it, which
+      #   is what `OptionParser` will actually do.
+      # @return [Hash] with free shorts that are implicit to some option
+      def implicit_shorts
+        options.each_with_object({}) do |opt, implicit|
+          short = opt.short_implicit
+          implicit[short] = opt unless options_hash.key?(short)
         end
       end
 
-      # Based on `required` options, it sets the `default`
-      def result_defaults
-        {}.tap do |res_def|
-          options.select do |opt|
-            (results_with_all_defaults && opt.default?) \
-            || (opt.required? && opt.default?)
-          end.each do |opt|
-            res_def[opt.short] = opt.default
-          end
+      private
+
+      # Explicitly installs the help of the options
+      # @note `OptionParser` already has `-h --help` as a native option.
+      # @param opts [OptionParser] where the help will be added.
+      def option_help(opts)
+        return false if options_hash.key?(:help) || options_hash.key?(:h)
+        option(:h, :help, 'Prints this help') do
+          puts opts
+          exit(0)
         end
+        self
       end
 
-      # It throws an exception if any of the required options
-      # is missing in results
-      def check_required_presence!(results)
-        missing = options.select(&:required?).reject do |opt|
-          results.key?(opt.short) || results.key?(opt.name)
+      # @return [Array<RakeCommander::Option>]
+      def to_options(value)
+        if value.is_a?(Class) && value <= self
+          value.options
+        elsif value.is_a?(self)
+          value.class.options
+        elsif value.is_a?(Array)
+          value.select {|opt| opt.is_a?(option_class)}
+        elsif value.is_a?(Hash)
+          to_options(value.values)
+        elsif value.is_a?(Enumerable) || value.respond_to?(:to_a)
+          to_options(value.to_a)
         end
-        raise RakeCommander::Options::MissingOption, missing unless missing.empty?
       end
 
-      def add_to_options(opt)
-        if prev = options_hash[opt.short]
-          puts "Warning: Overriding option with short '#{prev.short}' ('#{prev.name}')"
-          options_hash.delete(prev.short)
-          options_hash.delete(prev.name)
+      # Adds to `@options_hash` the option `opt`
+      # @todo add `exception` parameter, to trigger an exception
+      #   when `opt` name or short are taken (and override is `false`)
+      # @todo allow to specif if `:tail`, `:top` or `:base` (default)
+      # @param opt [RakeCommander::Option] the option to be added.
+      # @param override [Boolean] whether we should continue, may this action override (an)other option(s).
+      # @return [RakeCommander::Option, NilClass] the option that was added, `nil` is returned otherwise.
+      def add_to_options(opt, override: true)
+        name_ref = respond_to?(:name)? " (#{name})" : ''
+        if sprev = options_hash[opt.short]
+          return nil unless override
+          puts "Warning#{name_ref}: Overriding option '#{sprev.name}' with short '#{sprev.short}' ('#{opt.name}')"
+          delete_from_options(sprev)
         end
-        if prev = options_hash[opt.name]
-          puts "Warning: Overriding option with name '#{prev.name}' ('#{prev.short}')"
-          options_hash.delete(prev.short)
-          options_hash.delete(prev.name)
+        if nprev = options_hash[opt.name]
+          return nil unless override
+          puts "Warning#{name_ref}: Overriding option '#{nprev.short}' with name '#{nprev.name}' ('#{opt.short}')"
+          delete_from_options(nprev)
         end
         options_hash[opt.name] = options_hash[opt.short] = opt
       end
-    end
 
-    def options(argv = ARGV)
-      @options ||= self.class.parse_options(argv, leftovers: options_leftovers)
-    end
+      # Deletes an option from the `options_hash`
+      # @param opt [RakeCommander::Option] the option to be deleted.
+      # @return [RakeCommander::Option, NilClass] the option that was deleted, or `nil` otherwise.
+      def delete_from_options(opt)
+        res = options_hash.delete(opt.short)
+        options_hash.delete(opt.name) || res
+      end
+
+      # Replaces option `ref` with option `opt`.
+      # @note this method was added aiming to keep the same position for an option we override.
+      # @param ref [RakeCommander::Option] the option to be replaced.
+      # @param opt [RakeCommander::Option] the option that will replace `ref`.
+      # @param override [Boolean] whether we should continue, may there be collateral override to other options.
+      # @return [RakeCommander::Option, NilClass] `opt` if it was added, or `nil` otherwise.
+      def replace_in_options(ref, opt, override: false)
+        # Try to keep the same potition
+        options_hash[ref.short] = options_hash[ref.name] = nil
+        add_to_options(opt, override: override).tap do |added_opt|
+          # restore previous status
+          next options_hash[ref.short] = options_hash[ref.name] = ref unless added_opt
+          delete_empty_keys(options_hash)
+        end
+      end
 
-    def options_leftovers
-      @options_leftovers ||= []
+      # Deletes all keys that have `nil` as value
+      def delete_empty_keys(hash)
+        hash.tap do |_h|
+          hash.dup.each do |k, v|
+            next unless v.nil?
+            hash.delete(k)
+          end
+        end
+      end
     end
   end
 end
 
-require_relative 'options/error'
 require_relative 'options/set'

data/lib/rake-commander/patcher/README.md

@@ -0,0 +1,79 @@
+# Patching `rake`
+
+## Patch Rational
+
+Let's say that when we invoke `rake` from the command line, `rake-commander` is loaded from a `Rakefile` (i.e. `require 'rake-commander'`). Looking at the `Rake::Application#run` method code, this places the patch moment, at the best, during the load of the `Rakefile`; during execution of the `load_rakefile` private method ([here is the call](https://github.com/ruby/rake/blob/48e798484babf725b0562cc417986da513e5d0ae/lib/rake/application.rb#L82)).
+
+### Challenges encountered with the `rake` executable
+
+Let's say you require/load `rake-commander` in a `Rakefile`, and invoke the [`rake` executable](https://github.com/ruby/rake/blob/master/exe/rake). By the time rake commander is loaded, `Rake` has already captured the `ARGV`, parsed its own options, and pre-parsed possible task(s) invokations.
+
+The **two main problems** to deal with are:
+
+  1. Rake has it's own `OptionsParser`. If any of your rake `task` options matches any of those, you will be unintentionally invoking `rake` functionality.
+  2. Let's say you require/load `rake-commander` in a `Rakefile`. By the time rake commander is loaded, `rake` has already collected as `top_level_tasks` the arguments of your task options; so those that do not start with dash `-` ([see private method `collect_command_line_tasks` in `Rake::Application`](https://github.com/ruby/rake/blob/48e798484babf725b0562cc417986da513e5d0ae/lib/rake/application.rb#L782)).
+
+This is also true when you invoke `rake` via _shell_ from within another task.
+
+**Example**
+
+Without the current patch, this is what was happening.
+
+```
+$ raked examples:chainer -- --chain --say "Just saying..." --with raked
+Calling --> 'rake examples:chained -- --say "Just saying..."'
+Chained task has been called!!
+Just saying...
+rake aborted!
+Don't know how to build task 'Just saying...' (See the list of available tasks with `rake --tasks`)
+```
+
+### The alternative of a `raked` executable
+
+**`raked` executable is not necessary and is not provided for prod environments. The current patch allows to start directly from `rake`**.
+
+  * This has been kept to the only purpose of documentation.
+
+The `raked` executable would be a modified version of the `rake` executable, where `rake_commander` is loaded right after requiring `rake` and before `Rake.application.run` is invoked.
+
+```ruby
+#!/usr/bin/env ruby
+
+require "rake"
+require "rake-commander"
+Rake.application.run
+```
+
+This would allow the patch to be active right at the beginning, preventing this way the patch to kick in after the `rake` application has been firstly launched (it saves to rake one loop of parsing arguments and loading rake files).
+
+```
+$ raked examples:chainer -- --chain --say "Just saying..." --with raked
+Calling --> 'bin\raked examples:chained -- --say "Just saying..."'
+Chained task has been called!!
+Just saying...
+```
+
+Using `raked` as separate namespace vs `rake` is completely optional. Most will prefer to keep on just with the main `rake` executable and  `rake-commander` as enhancement to it. This is the rational behind the second patch (explained in detail in the next section).
+
+
+## Reload `Rake` application
+
+The target is to be able to use `rake` indistinctly (rather than having to rewrite rake commands as `raked`). Unfortunately the **only way around** to the _application-has-started_ is to just **relaunch/reload the application** when the patch kicks in (wouldn't know how to and shouldn't try to reuse the current running application: i.e. task options parsed as rake option modifiers that have already done some stuff).
+
+Fortunately, the target of `rake-commander` is just to **enhance** existing syntax, which gives a very specific target when it comes to **patching**. The key factor to reach a clean patch is to design the syntax in a fixed way where there is no much flexibility but clearly stated delimiters (i.e. no fancy guessing where dependencies are introduced on defined task options).
+
+Relaunching the application to a new instance requires very little:
+
+```ruby
+Rake.application = Rake::Application.new
+Rake.application.run
+exit(0) # abort previous application run
+```
+
+## Missing tasks on reload
+
+Relaunching the `rake` application entails issues with `require` in the chain of `Rakefile` files that have already been loaded. Apparently some tasks of some gems are installed during the `require` runtime, rather than explicitly declaring them in the rake file.
+
+This is the case for `bundler/gem_tasks` (i.e. `require "bundler/gem_tasks"`), where all these `tasks` will be missing: build, build:checksum, clean, clobber, install, install:local, release, release:guard_clean, release:rubygem_push, release:source_control_push.
+
+It can potentially be looked at, if ever this shows up to new review.

data/lib/rake-commander/patcher/application/run_method.rb

@@ -0,0 +1,46 @@
+class RakeCommander
+  module Patcher
+    module Application
+      module RunMethod
+        include RakeCommander::Patcher::Base
+
+        class << self
+          def target
+            Rake::Application
+          end
+
+          def patch_prepend(_invoked_by)
+            return unless target_defined?
+            Rake::Application.prepend Patch
+          end
+
+          def target_defined?
+            return true if defined?(target)
+            puts "Warning (#{self}): undefined target #{target}"
+            false
+          end
+        end
+
+        module Patch
+          include RakeCommander::Patcher::Debug
+
+          # To extend the command line syntax we need to patch `Rake`, provided that
+          # this gem's extended options are not in `argv` when `Rake` processes it.
+          # @note we define an instance variable so we can know if the patch was applied when it started.
+          # @note This patch only works fine if `Rake::Application#run` is **invoked after****
+          #   **`RakeCommander` has been required**.
+          #   * So by itself alone it allows to use `raked` executable that this gem provides.
+          def run(argv = ARGV)
+            @rake_commander_run_argv_patch = true unless instance_variable_defined?(:@rake_commander_run_argv_patch)
+            RakeCommander.self_load
+            rake_comm_debug "R U N  !", "\n", num: 1, pid: true
+            rake_comm_debug "  ---> Command: #{$PROGRAM_NAME}"
+            rake_comm_debug "  ---> ARGV: [#{argv.map {|a| "'#{a}'"}.join(', ')}]"
+            argv = RakeCommander.argv_rake_native_arguments(argv)
+            super(argv)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rake-commander/patcher/application/top_level_method.rb

@@ -0,0 +1,74 @@
+class RakeCommander
+  module Patcher
+    module Application
+      module TopLevelMethod
+        include RakeCommander::Patcher::Base
+
+        class << self
+          def target
+            Rake::Application
+          end
+
+          def patch_prepend(_invoked_by)
+            return unless target_defined?
+            Rake::Application.prepend Patch
+          end
+
+          def target_defined?
+            return true if defined?(target)
+            puts "Warning (#{self}): undefined target #{target}"
+            false
+          end
+        end
+
+        module Patch
+          include RakeCommander::Patcher::Debug
+
+          # To preserve `rake` as main executable, as the `RunMethod::Patch` is applied only
+          # when `Rake::Application` requires the `Rakefile` that loads `rake-commander`,
+          # we need to:
+          #   1. Intercept the execution on the next stage of the `Rake::Application#run` command,
+          #     [the `top_level` call](https://github.com/ruby/rake/blob/48e798484babf725b0562cc417986da513e5d0ae/lib/rake/application.rb#L82),
+          #     and **re-launch** the rake application (so it only receives the `ARGV` cut that the main patch provides)
+          #   2. Ensure that **re-launch** is done only once.
+          #   3. Ensure that it does `exit(0)` to the original running application.
+          def top_level
+            unless @rake_commander_run_argv_patch
+              @rake_commander_run_argv_patch = true
+              RakeCommander.relaunch_rake_application
+              # Should not reach this point
+            end
+            rake_comm_debug "T O P   L E V E L   ( p a t c h    a c t i v e )", "\n", num: 2, pid: true
+            rake_comm_debug "  ---> Known tasks: #{tasks.map(&:name).join(", ")}"
+            super
+          end
+        end
+
+        module ClassMethods
+          include RakeCommander::Patcher::Debug
+
+          # Reloading `Rakefile` has drawbacks around `require` only being launched once per
+          # dependency. Apparently some tasks of some gems are installed at `require` run-time.
+          # This requires to keep known tasks when we switch the application.
+          def relaunch_rake_application
+            prev_rake_app = Rake.application
+            rake_comm_debug "R A K E   R E L A U N C H   ( p a t c h    i n a c t i v e )", "\n", num: 2, pid: true
+            rake_comm_debug "  ---> Known tasks: #{prev_rake_app.tasks.map(&:name).join(", ")}"
+            Rake.application = Rake::Application.new
+            rake_comm_debug "N e w   R a k e  A p p", "\n", num: 4, pid: true
+            RakeCommander.self_load_reset
+            Rake.application.run #RakeCommander.argv_rake_native_arguments(ARGV)
+            rake_comm_debug "T e r m i n a t i n g   R U N", "\n", num: 3, pid: true
+            exit(0)
+          end
+
+          private
+
+          def rake_reparse_argv(argv = ARGV)
+            RakeCommander.argv_rake_native_arguments(argv)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rake-commander/patcher/application.rb

@@ -0,0 +1,16 @@
+class RakeCommander
+  module Patcher
+    module Application
+      include RakeCommander::Patcher::Base
+      require_relative 'application/run_method'
+      require_relative 'application/top_level_method'
+
+      class << self
+        def patch_include(base)
+          base.send :include, RunMethod
+          base.send :include, TopLevelMethod
+        end
+      end
+    end
+  end
+end

data/lib/rake-commander/patcher/base.rb

@@ -0,0 +1,45 @@
+class RakeCommander
+  module Patcher
+    # Base of self-applied patchers.
+    # @note a patcher will be applied when it's included.
+    module Base
+      class << self
+        def included(base)
+          super(base)
+          base.extend ClassMethods
+        end
+      end
+
+      module ClassMethods
+        def included(base)
+          super(base)
+          base.extend self::ClassMethods if defined?(self::ClassMethods)
+          invoke_patch_methods!(base) unless self == RakeCommander::Patcher::Base
+        end
+
+        def invoke_patch_methods!(base)
+          raise "#{self}: no patch methods. Patching with include requires at least one." unless any_patch_method?
+          patch_prepend(base) if patch_prepend?
+          patch_include(base) if patch_include?
+          patch_extend(base)  if patch_extend?
+        end
+
+        def any_patch_method?
+          patch_prepend? || patch_include? || patch_extend?
+        end
+
+        def patch_prepend?
+          respond_to?(:patch_prepend)
+        end
+
+        def patch_include?
+          respond_to?(:patch_include)
+        end
+
+        def patch_extend?
+          respond_to?(:patch_extend)
+        end
+      end
+    end
+  end
+end

data/lib/rake-commander/patcher/debug.rb

@@ -0,0 +1,32 @@
+class RakeCommander
+  module Patcher
+    # Helpers to patch
+    module Debug
+      # Helper for debugging
+      def rake_comm_debug(msg, prefix = '', num: nil, pid: false)
+        return unless RakeCommander::Patcher.debug?
+        rake_comm_debug_random_object_id
+        num = num ? "#{num}. " : nil
+        if pid
+          meta = "(PID: #{Process.pid} ++ Thread: #{Thread.current.object_id} ++ Ruby 'main': #{rake_comm_debug_main_object_id})"
+          msg  = "#{prefix}( #{num}#{Rake.application.object_id})   #{msg}   #{meta}"
+        elsif num
+          msg  = "#{prefix}( #{num})   #{msg}   "
+        end
+        puts msg
+      end
+
+      def rake_comm_debug_main_object_id
+        eval('self.object_id', TOPLEVEL_BINDING, __FILE__, __LINE__)
+      end
+
+      def rake_comm_debug_random_object_id
+        return false if @rake_comm_debug_random_object_id
+        @rake_comm_debug_random_object_id = Array(1..20).sample.times.map do |i|
+          i.to_s.tap(&:object_id)
+        end
+        true
+      end
+    end
+  end
+end