rake-commander 0.2.12 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00c13e58c8b9c78ac538ca0100d714a7c3f72ca98a655ae564ebbca13cacf2f6
-  data.tar.gz: bfbf686120c4245ba541605db6fbb46e14455b77553948827946fb1417cb376b
+  metadata.gz: 3b93ede4d58a5bc19446930380b5f9a785f7bcc404a93c1db63360dff78da2fd
+  data.tar.gz: 8113a37d4d4301b7028923aaab04734dfa38c8e3979a272750d0e0b35fb649bd
 SHA512:
-  metadata.gz: 1d7941181f5ea5b4bd1210bcb3e5a1307bbedbd0a503636144af350a320a6a7ed4a5d8948d2212c81b401513bb383c37ad4645825e544cb952a73bbdf3d62110
-  data.tar.gz: 41a29e32b0536d073c4481df467ff65351bd84c5782db961398ea6ac66c73d6652d623df7d1c363e321130182f32db78368528996b7331478c16505b1b059c76
+  metadata.gz: 1255ab72c7599bc831aa08ca375c4b9c4563698c9e91223184b4348c7ace025b67f0f7b11e6c9818b83774d58099c8cb14be9173f67665b96b228c22a421ad70
+  data.tar.gz: 2bac8657f4b0b43523f5343617067fb371e1a4b5ea36d0aea32679e46b523cbf497e7a0af7ef7abaaf1b3fa02c89dd0cdd8f492df2dab5ef0e1150059b4aabd0

data/CHANGELOG.md

@@ -32,13 +32,18 @@ All notable changes to this project will be documented in this file.
   - Option to globally enable/disable the 2nd patch?
     * That would make this gem completely useless.
 
-## [0.2.13] - 2023-05-xx
+## [0.3.2] - 2023-05-xx
 
 ### Added
 ### Fixed
 ### Changed
 
-## [0.2.12] - 2023-05-xx
+## [0.3.2] - 2023-05-01
+
+### Changed
+  - Replaced the patching method, so the `Rake` application doesn't need re-launch.
+
+## [0.2.12] - 2023-05-01
 
 ### Fixed
   - `RakeCommander::Option#type_coercion` wasn't correctly captured.

data/README.md

@@ -69,6 +69,27 @@ rspec logging and results
 
 ### Syntax
 
+```ruby
+RakeCommander::Custom::Base < RakeCommander
+  include Rake::DSL
+end
+```
+  * `include Rake::DSL` for backwards compatibility
+
+```ruby
+RakeCommander::Custom::MyTask < RakeCommander::Custom::Base
+  desc "it does some stuff"
+  task :do_stuff
+
+  option :s, '--do-stuff [SOMETHING]', default: 'nothing'
+
+  def task(*_args)
+    puts "Doing #{options[:s]}" if options[:s]
+  end
+end
+```
+
+
 ### Declaring and using Task Options
 
 It supports most of options syntax of the native `OptionParser` but for a couple of exceptions perhaps:
@@ -106,10 +127,7 @@ To preserve `rake` as invocation command, though, the patch needs to relaunch th
 
 ### Patching `Rake`
 
-The two patches:
-
-  1. Rake commander does come with a neat patch to the [`Rake::Application#run` method](https://github.com/ruby/rake/blob/48e798484babf725b0562cc417986da513e5d0ae/lib/rake/application.rb#L79) to clean up the `ARGV` before the rake application starts. But it kicks in too late...
-  2. For this reason a more arguable patch has been applied to [`Rake::Application#top_level` method](https://github.com/ruby/rake/blob/48e798484babf725b0562cc417986da513e5d0ae/lib/rake/application.rb#L131), where the rake application is relaunched.
+There is only one patch onto [`Rake::Application#top_level` method](https://github.com/ruby/rake/blob/48e798484babf725b0562cc417986da513e5d0ae/lib/rake/application.rb#L131), [`collect_command_line_tasks`](https://github.com/ruby/rake/blob/48e798484babf725b0562cc417986da513e5d0ae/lib/rake/application.rb#L782) is recalled with the arguments cut (so it does not interpret task option arguments as tasks).
 
 For further details please see [`RakeCommander::Patcher`](https://github.com/rellampec/rake-commander/blob/main/lib/rake-commander/patcher).
 

data/lib/rake-commander/options.rb

@@ -88,8 +88,6 @@ class RakeCommander
       # @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
 

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

@@ -6,12 +6,7 @@ Let's say that when we invoke `rake` from the command line, `rake-commander` is
 
 ### 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)).
+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; it 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.
 
@@ -28,40 +23,8 @@ 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
@@ -69,11 +32,14 @@ Rake.application = Rake::Application.new
 Rake.application.run
 exit(0) # abort previous application run
 ```
+But this approach has been discarded (since `v 0.3.1`), as it loses task definitions loaded via `require`.
 
-## Missing tasks on reload
+### 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.
+## Re-call `collect_command_line_tasks` from `top_level` method
+
+This showed up to solve all the known problems mentioned above. It allow the application to just keep running with whatever it got.

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

@@ -0,0 +1,38 @@
+class RakeCommander
+  module Patcher
+    module Application
+      module TopLevelResume
+        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
+          # To preserve `rake` as main executable, as the `RunMethod::Patch` is applied only
+          # when `Rake::Application` requires the `Rakefile` that loads `rake-commander`,
+          # we technically only need to fix the `top_level_tasks` that have been detected.
+          def top_level
+            RakeCommander.self_load_reset
+            argv = RakeCommander.argv_rake_native_arguments(ARGV)
+            Rake.application.send(:collect_command_line_tasks, argv)
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,13 +2,11 @@ class RakeCommander
   module Patcher
     module Application
       include RakeCommander::Patcher::Base
-      require_relative 'application/run_method'
-      require_relative 'application/top_level_method'
+      require_relative 'application/top_level_resume'
 
       class << self
         def patch_include(base)
-          base.send :include, RunMethod
-          base.send :include, TopLevelMethod
+          base.send :include, TopLevelResume
         end
       end
     end

data/lib/rake-commander/version.rb

@@ -1,3 +1,3 @@
 class RakeCommander
-  VERSION = '0.2.12'.freeze
+  VERSION = '0.3.3'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rake-commander
 version: !ruby/object:Gem::Version
-  version: 0.2.12
+  version: 0.3.3
 platform: ruby
 authors:
 - Oscar Segura Samper
@@ -201,8 +201,7 @@ files:
 - lib/rake-commander/patcher.rb
 - lib/rake-commander/patcher/README.md
 - lib/rake-commander/patcher/application.rb
-- lib/rake-commander/patcher/application/run_method.rb
-- lib/rake-commander/patcher/application/top_level_method.rb
+- lib/rake-commander/patcher/application/top_level_resume.rb
 - lib/rake-commander/patcher/base.rb
 - lib/rake-commander/patcher/debug.rb
 - lib/rake-commander/patcher/helpers.rb

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

@@ -1,46 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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