hrk 1.0.6 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af5f8cc47627b77665361e134f59b5537b13f29f
-  data.tar.gz: 312f15c94cad27d4b50d88d9b5de959f820a922a
+  metadata.gz: 2a9d0caab344b968fe75fdf67544614eee7c8510
+  data.tar.gz: f6bf197cf5943045989c0ff77f0cc5a7174cb88f
 SHA512:
-  metadata.gz: 9aecc66431b5a30bc2a4f083b67d40919a506b6bd8b165bc2ddf88ab56f0550986b84eddd969567c778e9324d076d117809478feb931b839d1f0cd491485b327
-  data.tar.gz: 27b334401d917f7b37bd47cf43af2afd239a65ff1dee66a4823714c951a7e49e971b0a268542b1a9a1f31d543899688118aea6b43275972ade6e86b744286da4
+  metadata.gz: 8ad9226be51959e0d073fe622e86e817536e5b59658451576bbc28b2a717b6b23d3caace733612939cd928aab3c4f84f9705bbbedbf7d7d15af5e2ef58387662
+  data.tar.gz: bd3fda9fe1058571c9b02f567c1440135bc0a2a54b2418d94979254c32703836af4268268b4407741c583d020fb2c6dfeea8261c86d700c35288cf95d0f5420a

data/lib/hrk/execute/ask_for_remote.rb

@@ -0,0 +1,25 @@
+module Hrk
+  module Execute
+    class AskForRemote
+      def initialize next_callee
+        @next_callee = next_callee
+      end
+
+      def call *args
+        @next_callee.call *insure_remote(args)
+      end
+
+      private
+
+      def insure_remote args
+        return args unless remoteless? args
+        puts "Please state the remote you want to run these commands on (ex: -r demo):"
+        args + STDIN.gets.split(/\s+/)
+      end
+
+      def remoteless? args
+        args.reverse.take(2).none? { |a| a =~ /\A-[ar]\Z/ }
+      end
+    end
+  end
+end

data/lib/hrk/execute/command.rb

@@ -10,26 +10,19 @@ module Hrk
       end
 
       def call *args
-        remote, command = remote_and_command args
-        if remote
-          @env.remote = remote
-          Hrk::Heroku.new(*remote).call(*command)
-        else
-          raise ArgumentError.new("No remote has been previously defined and the command does not explicitely mention a remote") unless @env.remote?
-          Hrk::Heroku.new(*@env.remote).call(*command)
-        end
+        command, remote = command_and_remote args
+        @env.remote = remote
+        Hrk::Heroku.new(*remote).call(*command)
       end
 
-      def remote_and_command args
-        args.slice_before { |arg| arg =~ ARG }.inject([nil, []]) do |r, slice|
-          if slice.first =~ ARG
-            raise ArgumentError.new('Remote option without value') if slice.length < 2
-            raise ArgumentError.new('Too many remotes mentionned') if r.first
-            [slice.take(2), r.last + slice.drop(2)]
-          else
-            [r.first, r.last + slice]
-          end
-        end
+      private
+
+      def command_and_remote args
+        command, remote, *other_remotes = ([nil] + args).slice_before(ARG).to_a
+        raise ArgumentError.new "Too many remotes or app" if other_remotes.any?
+        raise ArgumentError.new "No remote is mentionned" unless remote
+        raise ArgumentError.new "Incomplete remote option #{remote.first}" if remote.length != 2
+        [command.compact, remote]
       end
     end
   end

data/lib/hrk/execute/error_trap.rb

@@ -1,16 +1,16 @@
 module Hrk
   module Execute
     class ErrorTrap
-      def initialize callee
-        @callee = callee
+      def initialize next_callee
+        @next_callee = next_callee
       end
 
       def call *args
         if args.include? '--hrk-testing'
-          @callee.call(*(args - ['--hrk-testing']))
+          @next_callee.call(*(args - ['--hrk-testing']))
         else
           begin
-            @callee.call(*args)
+            @next_callee.call(*args)
           rescue
             puts "Error: #{$!.message}"
             false

data/lib/hrk/execute/help.rb

@@ -1,15 +1,15 @@
 module Hrk
   module Execute
     class Help
-      def initialize fallback = nil
-        @fallback = fallback
+      def initialize next_callee = nil
+        @next_callee = next_callee
       end
 
       def call *args
         if args.empty? || args.first =~ %r(\A(?:(?:(?:-)?h)|(?:(?:--)?help))\Z)
           display || true
         else
-          fallback(*args)
+          next_callee(*args)
         end
       end
 
@@ -44,9 +44,9 @@ https://github.com/Bastes/hrk
         eos
       end
 
-      def fallback *args
-        if @fallback
-          @fallback.call(*args)
+      def next_callee *args
+        if @next_callee
+          @next_callee.call(*args)
         else
           raise ArgumentError.new
         end

data/lib/hrk/execute/heroku_detector.rb

@@ -1,13 +1,13 @@
 module Hrk
   module Execute
     class HerokuDetector
-      def initialize callee
-        @callee = callee
+      def initialize next_callee
+        @next_callee = next_callee
       end
 
       def call *args
         if heroku_present?
-          @callee.call(*args)
+          @next_callee.call(*args)
         else
           puts <<-eos
 Error: The heroku command is missing!

data/lib/hrk/execute/remember.rb

@@ -0,0 +1,24 @@
+module Hrk
+  module Execute
+    class Remember
+      def initialize next_callee
+        @next_callee = next_callee
+      end
+
+      def call *args
+        env = Hrk::Env.new
+        if remoteless?(args) && env.remote?
+          @next_callee.call(*args, *env.remote)
+        else
+          @next_callee.call(*args)
+        end
+      end
+
+      private
+
+      def remoteless? args
+        args.reverse.take(2).none? { |a| a =~ /\A-[ar]\Z/ }
+      end
+    end
+  end
+end

data/lib/hrk/execute/remote_display.rb

@@ -1,9 +1,9 @@
 module Hrk
   module Execute
     class RemoteDisplay
-      def initialize fallback
+      def initialize next_callee
         @env = Hrk::Env.new
-        @fallback = fallback
+        @next_callee = next_callee
       end
 
       def call *args
@@ -15,7 +15,7 @@ module Hrk
             false
           end
         else
-          @fallback.call(*args)
+          @next_callee.call(*args)
         end
       end
     end

data/lib/hrk/execute/remote_last.rb

@@ -0,0 +1,26 @@
+module Hrk
+  module Execute
+    class RemoteLast
+      ARG = /\A-[ar]\Z/
+
+      def initialize next_callee
+        @next_callee = next_callee
+      end
+
+      def call *args
+        @next_callee.call(*order(args))
+      end
+
+      def order args
+        args.slice_before { |arg| arg =~ ARG }.inject([[], nil]) do |r, slice|
+          if slice.first =~ ARG
+            raise ArgumentError.new("Too many remotes mentionned") if r.last
+            [r.first + slice.drop(2), slice.take(2)]
+          else
+            [r.first + slice, r.last]
+          end
+        end.flatten.compact
+      end
+    end
+  end
+end

data/lib/hrk/execute.rb

@@ -1,17 +1,27 @@
 module Hrk
   module Execute
-    autoload :Command,        'hrk/execute/command'
-    autoload :Help,           'hrk/execute/help'
-    autoload :ErrorTrap,      'hrk/execute/error_trap'
-    autoload :HerokuDetector, 'hrk/execute/heroku_detector'
-    autoload :RemoteDisplay,  'hrk/execute/remote_display'
+    autoload :Command,        "hrk/execute/command"
+    autoload :AskForRemote,   "hrk/execute/ask_for_remote"
+    autoload :Remember,       "hrk/execute/remember"
+    autoload :RemoteLast,     "hrk/execute/remote_last"
+    autoload :Help,           "hrk/execute/help"
+    autoload :ErrorTrap,      "hrk/execute/error_trap"
+    autoload :HerokuDetector, "hrk/execute/heroku_detector"
+    autoload :RemoteDisplay,  "hrk/execute/remote_display"
 
     def self.call *args
       executer.call(*args)
     end
 
     def self.executer
-      ErrorTrap.new HerokuDetector.new RemoteDisplay.new Help.new Command.new
+      ErrorTrap.new \
+        HerokuDetector.new \
+        RemoteDisplay.new \
+        Help.new \
+        RemoteLast.new \
+        Remember.new \
+        AskForRemote.new \
+        Command.new
     end
   end
 end

data/lib/hrk/heroku.rb

@@ -6,20 +6,20 @@ module Hrk
 
     def call *command
       validate! command
-      puts "Executing `#{(['heroku'] + command + @remote).join ' '}`..."
-      exec 'heroku', *(command + @remote)
+      puts "Executing `#{(["heroku"] + command + @remote).join " "}`..."
+      exec "heroku", *(command + @remote)
     end
 
     private
 
     def validate! command
-      remote = (command.each_cons(2).detect { |(parameter, _)| parameter =~ %r{\A-[ar]\Z} }.join ' ' rescue nil)
+      remote = (command.each_cons(2).detect { |(parameter, _)| parameter =~ %r{\A-[ar]\Z} }.join " " rescue nil)
       raise ExplicitApplicationError.new, "You're calling a command on remote #{@remote.join " "} yet the command explicitly references #{remote}" if remote
     end
 
     def exec *command
       Signal.trap("INT") {}
-      Process.wait fork { Kernel.exec *command }
+      Process.wait fork { Kernel.exec(*command) }
       $?.success?.tap { Signal.trap("INT", "DEFAULT") }
     end
 

data/lib/hrk/version.rb

@@ -1,3 +1,3 @@
 module Hrk
-  VERSION = '1.0.6'
+  VERSION = '1.0.7'
 end

data/spec/hrk/execute/ask_for_remote_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+RSpec.describe Hrk::Execute::AskForRemote do
+  describe "#call" do
+    let(:next_callee)  { double(Hrk::Execute::Command) }
+    let(:env)          { double(Hrk::Env) }
+
+    subject(:ask_for_remote) { Hrk::Execute::AskForRemote.new next_callee }
+
+    let(:users_remote) { [%w(-a -r).sample, "remote-#{rand(0..9)}"] }
+    let(:users_input)  { users_remote.join(" ") }
+
+    before { allow(next_callee).to receive(:call) }
+    before { allow(Hrk::Env).to receive(:new).and_return(env) }
+    before { allow(ask_for_remote).to receive(:puts) }
+    before { allow(STDIN).to receive(:gets).and_return(users_input) }
+    before { ask_for_remote.call(*command) }
+
+    context "there was no remote" do
+      let(:command)      { %w(run console) }
+
+      it { expect(ask_for_remote).to have_received(:puts) }
+      it { expect(next_callee).to have_received(:call).with(*command, *users_remote) }
+    end
+
+    context "there was a remote" do
+      let(:command) { %w(logs -t) + [%w(-a -r).sample, "remote-#{rand(0..9)}"] }
+
+      it { expect(ask_for_remote).not_to have_received(:puts) }
+      it { expect(STDIN).not_to have_received(:gets) }
+      it { expect(next_callee).to have_received(:call).with(*command) }
+    end
+  end
+end

data/spec/hrk/execute/command_spec.rb

@@ -1,7 +1,7 @@
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Hrk::Execute::Command do
-  describe '#call' do
+  describe "#call" do
     subject(:command) { Hrk::Execute::Command.new }
 
     let(:heroku) { double("Hrk::Heroku") }
@@ -10,10 +10,10 @@ RSpec.describe Hrk::Execute::Command do
 
     before { allow(command.env).to receive(:remote=) }
 
-    context 'no remote was previously memorized' do
+    context "no remote was previously memorized" do
       before { allow(command.env).to receive(:remote?).and_return(nil) }
 
-      describe 'standard case (a remote, a command)' do
+      describe "standard case (a remote, a command)" do
         let(:remote) { "remote-#{rand(1..9)}" }
         let(:args)   { %w(whatever that:may -b) }
 
@@ -23,12 +23,12 @@ RSpec.describe Hrk::Execute::Command do
               context "when the command returns #{result}" do
                 before { allow(heroku).to receive(:call).and_return(result) }
 
-                it { expect(command.call(opt, remote, *args)).to eq result }
+                it { expect(command.call(*args, opt, remote)).to eq result }
               end
             end
 
-            describe 'interactions' do
-              before { command.call(opt, remote, *args) }
+            describe "interactions" do
+              before { command.call(*args, opt, remote) }
 
               it { expect(Hrk::Heroku).to have_received(:new).with(opt, remote) }
               it { expect(heroku).to have_received(:call).with(*%w{whatever that:may -b}) }
@@ -38,103 +38,47 @@ RSpec.describe Hrk::Execute::Command do
         end
       end
 
-      describe 'edge cases (no remote, improper remote, too many remotes...)' do
-        let(:other_args) { %W(something-#{rand(1..9)} -o r --another) }
-
-        before { expect(heroku).not_to receive(:call) }
-        before { expect(command.env).not_to receive(:remote=) }
-
-        it { expect { command.call }.to raise_error ArgumentError }
-        it { expect { command.call "parameterless-remote", *other_args }.to raise_error ArgumentError }
-        it { expect { command.call(*other_args) }.to raise_error ArgumentError }
-        it { expect { command.call(*other_args, '-r') }.to raise_error ArgumentError }
-        it { expect { command.call(*other_args, '-a') }.to raise_error ArgumentError }
-        it { expect { command.call '-r', 'remote', *other_args, '-r', 'other-remote' }.to raise_error ArgumentError }
-        it { expect { command.call '-r', 'remote', *other_args, '-a', 'app' }.to raise_error ArgumentError }
-        it { expect { command.call '-a', 'app', *other_args, '-a', 'other-app' }.to raise_error ArgumentError }
-        it { expect { command.call '-r', 'something', *other_args, '-a', 'something-else' }.to raise_error ArgumentError }
-      end
-    end
+      describe "edge cases" do
+        describe "a remote, nocommand" do
+          let(:remote) { "remote-#{rand(1..9)}" }
 
-    context 'a remote was previously memorized' do
-      let(:previous_remote) { "ye-olde-remote#{rand(1..9)}" }
-      before { allow(command.env).to receive(:remote).and_return(['-r', previous_remote]) }
-      before { allow(command.env).to receive(:remote?).and_return(true) }
+          %w(-a -r).each do |opt|
+            context "using #{opt}" do
+              [true, false].each do |result|
+                context "when the command returns #{result}" do
+                  before { allow(heroku).to receive(:call).and_return(result) }
 
-      describe 'standard case (a remote, a command)' do
-        let(:remote) { "remote-#{rand(1..9)}" }
-        let(:args)   { %w(whatever that:may -b) }
+                  it { expect(command.call(opt, remote)).to eq result }
+                end
+              end
 
-        [true, false].each do |result|
-          describe "when the command returns #{result}" do
-            before { allow(heroku).to receive(:call).and_return(result) }
+              describe "interactions" do
+                before { command.call(opt, remote) }
 
-            it { expect(command.call('-r', remote, *args)).to eq result }
+                it { expect(Hrk::Heroku).to have_received(:new).with(opt, remote) }
+                it { expect(heroku).to have_received(:call).with no_args }
+                it { expect(command.env).to have_received(:remote=).with([opt, remote]) }
+              end
+            end
           end
         end
 
-        describe 'interactions' do
-          before { command.call '-r', remote, *args }
+        describe "no remote, improper remote..." do
+          let(:other_args) { %W(something-#{rand(1..9)} -o r --another) }
 
-          it { expect(Hrk::Heroku).to have_received(:new).with('-r', remote) }
-          it { expect(heroku).to have_received(:call).with(*%w{whatever that:may -b}) }
-          it { expect(command.env).to have_received(:remote=).with(['-r', remote]) }
-        end
-      end
-
-      describe 'use previous remote' do
-        let(:args)   { %w(whatever that:may -b) }
+          before { expect(heroku).not_to receive(:call) }
+          before { expect(command.env).not_to receive(:remote=) }
 
-        [true, false].each do |result|
-          describe "when the command returns #{result}" do
-            before { allow(heroku).to receive(:call).and_return(result) }
-
-            it { expect(command.call(*args)).to eq result }
-          end
-        end
-
-        describe 'interactions' do
-          before { command.call(*args) }
-
-          it { expect(Hrk::Heroku).to have_received(:new).with('-r', previous_remote) }
-          it { expect(heroku).to have_received(:call).with(*%w{whatever that:may -b}) }
+          it { expect { command.call }.to raise_error ArgumentError }
+          it { expect { command.call(*other_args) }.to raise_error ArgumentError }
+          it { expect { command.call(*other_args, "-r") }.to raise_error ArgumentError }
+          it { expect { command.call(*other_args, "-a") }.to raise_error ArgumentError }
+          it { expect { command.call(*other_args, *%w(-r demo -r prod)) }.to raise_error ArgumentError }
+          it { expect { command.call(*other_args, *%w(-a app -a other-app)) }.to raise_error ArgumentError }
+          it { expect { command.call(*other_args, *%w(-r staging -a server)) }.to raise_error ArgumentError }
+          it { expect { command.call(*other_args, *%w(-a machine -r dennis)) }.to raise_error ArgumentError }
         end
       end
-
-      describe 'edge cases (improper remote, too many remotes...)' do
-        let(:other_args) { %W(--whatever#{rand(1..9)} dude) }
-
-        before { expect(heroku).not_to receive(:call) }
-        before { expect(command.env).not_to receive(:remote=) }
-
-        it { expect { command.call(*other_args, '-r') }.to raise_error ArgumentError }
-        it { expect { command.call(*other_args, '-a') }.to raise_error ArgumentError }
-        it { expect { command.call('-r', 'remote', *other_args, '-r', 'other-remote') }.to raise_error ArgumentError }
-        it { expect { command.call('-r', 'remote', *other_args, '-a', 'app') }.to raise_error ArgumentError }
-        it { expect { command.call('-a', 'app', *other_args, '-a', 'other-app') }.to raise_error ArgumentError }
-        it { expect { command.call('-r', 'something', *other_args, '-a', 'something-else') }.to raise_error ArgumentError }
-      end
-    end
-  end
-
-  describe '#remote_and_command' do
-    subject(:command) { Hrk::Execute::Command.new }
-
-    context '(standard cases, arguments parsed)' do
-      it { expect(command.remote_and_command(%w(run rake db:migrate))).to eq [nil, %w(run rake db:migrate)] }
-      it { expect(command.remote_and_command(%w(restart))).to eq [nil, %w(restart)] }
-      it { expect(command.remote_and_command(%w(-r demo restart))).to eq [%w(-r demo), %w(restart)] }
-      it { expect(command.remote_and_command(%w(run rake db:migrate -r prod))).to eq [%w(-r prod), %w(run rake db:migrate)] }
-      it { expect(command.remote_and_command(%w(some command -r test -i dont know --about))).to eq [%w(-r test), %w(some command -i dont know --about)] }
-    end
-
-    context '(edge cases, argument errors)' do
-      it { expect { command.remote_and_command(%w(-r staging logs -t -r test)) }.to raise_error ArgumentError }
-      it { expect { command.remote_and_command(%w(-a prod run rake db:migrate -r echo)) }.to raise_error ArgumentError }
-      it { expect { command.remote_and_command(%w(run console -r demo -a app)) }.to raise_error ArgumentError }
-      it { expect { command.remote_and_command(%w(-a one -a other maintenance:on)) }.to raise_error ArgumentError }
-      it { expect { command.remote_and_command(%w(maintenance:off -a)) }.to raise_error ArgumentError }
-      it { expect { command.remote_and_command(%w(restart -r)) }.to raise_error ArgumentError }
     end
   end
 end

data/spec/hrk/execute/error_trap_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 RSpec.describe Hrk::Execute::ErrorTrap do
   describe '#call' do
-    let(:next_callee) { double }
+    let(:next_callee) { double(Hrk::Execute::Command) }
 
     subject(:error_trap) { Hrk::Execute::ErrorTrap.new(next_callee) }
 

data/spec/hrk/execute/help_spec.rb

@@ -2,27 +2,50 @@ require 'spec_helper'
 
 RSpec.describe Hrk::Execute::Help do
   describe '#call' do
-    subject(:help) { Hrk::Execute::Help.new }
+    subject(:help) { Hrk::Execute::Help.new the_next_callee_or_not }
 
     describe 'with the right arguments' do
-      before { expect(help).to receive :display }
-
-      it { expect(help.call).to eq true }
-      it { expect(help.call('h')).to eq true }
-      it { expect(help.call('-h')).to eq true }
-      it { expect(help.call('help')).to eq true }
-      it { expect(help.call('--help')).to eq true }
+      [true, false].each do |there_is_one|
+        context "and #{there_is_one ? "a" : "no"} next callee" do
+          if there_is_one
+            let(:the_next_callee_or_not) { double }
+            before { allow(the_next_callee_or_not).to receive(:call).never }
+          else
+            let(:the_next_callee_or_not) { nil }
+          end
+
+          before { expect(help).to receive :display }
+
+          it { expect(help.call).to eq true }
+          it { expect(help.call('h')).to eq true }
+          it { expect(help.call('-h')).to eq true }
+          it { expect(help.call('help')).to eq true }
+          it { expect(help.call('--help')).to eq true }
+        end
+      end
     end
 
-    describe 'with wrong arguments' do
+    describe 'with other arguments' do
       [
         %w(run rake db:migrate),
         %w(helpe),
         %w(ahelp)
       ].each do |args|
-        before { allow(help).to receive(:fallback).with(*args).and_return :fallouts }
+        context "and a next callee" do
+          let(:the_next_callee_or_not) { double }
+          before { allow(the_next_callee_or_not).to receive(:call).and_return :fallouts }
+
+          it do
+            expect(help.call(*args)).to eq :fallouts
+            expect(the_next_callee_or_not).to have_received(:call).with(*args)
+          end
+        end
 
-        it { expect(help.call(*args)).to eq :fallouts}
+        context "and no next callee" do
+          let(:the_next_callee_or_not) { nil }
+
+          it { expect { help.call(*args) }.to raise_error ArgumentError }
+        end
       end
     end
   end
@@ -35,23 +58,4 @@ RSpec.describe Hrk::Execute::Help do
 
     it { expect(help).to have_received(:puts).at_least(1).times }
   end
-
-  describe '#fallback' do
-    describe 'without a fallback command' do
-      subject(:help) { Hrk::Execute::Help.new }
-
-      it { expect { help.fallback(*%w(whatever arguments it received)) }.to raise_error ArgumentError }
-    end
-
-    describe 'with a fallback command' do
-      let(:fallback) { double }
-      before { allow(fallback).to receive :call }
-
-      subject(:help) { Hrk::Execute::Help.new fallback }
-
-      before { expect(fallback).to receive(:call).with(*%w(whatever arguments it received)).and_return(:some_result) }
-
-      it { expect(help.fallback(*%w(whatever arguments it received))).to eq :some_result }
-    end
-  end
 end

data/spec/hrk/execute/heroku_detector_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 RSpec.describe Hrk::Execute::HerokuDetector do
   describe '#call' do
-    let(:next_callee) { double }
+    let(:next_callee) { double(Hrk::Execute::Command) }
 
     subject(:heroku_detector) { Hrk::Execute::HerokuDetector.new(next_callee) }
 

data/spec/hrk/execute/remember_spec.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+
+RSpec.describe Hrk::Execute::Remember do
+  describe '#call' do
+    let(:next_callee) { double(Hrk::Execute::Command) }
+
+    subject(:remember) { Hrk::Execute::Remember.new next_callee }
+    subject(:env) { double(Hrk::Env) }
+
+    before { allow(next_callee).to receive(:call) }
+    before { allow(Hrk::Env).to receive(:new).and_return(env) }
+
+    def self.receiving args, it_should_pass_on: []
+      context "receiving #{args.join " "}" do
+        let(:what_it_should_pass_on) do
+          if it_should_pass_on.respond_to?(:call)
+            instance_exec(&it_should_pass_on)
+          else
+            it_should_pass_on
+          end
+        end
+        subject!(:result) { remember.call(*args) }
+
+        it { expect(next_callee).to have_received(:call).with(*what_it_should_pass_on) }
+      end
+    end
+
+    context "no remote memorized" do
+      before { allow(env).to receive(:remote?).and_return(false) }
+      before { allow(env).to receive(:remote).and_return(nil) }
+
+      context "a remote in the args" do
+        receiving %w(logs -t -r demo), it_should_pass_on: %w(logs -t -r demo)
+        receiving %w(run rake db:migrate -a that-one-cloud), it_should_pass_on: %w(run rake db:migrate -a that-one-cloud)
+      end
+
+      context "no remote in the args" do
+        receiving %w(run rake db:rollback), it_should_pass_on: %w(run rake db:rollback)
+        receiving %w(run console), it_should_pass_on: %w(run console)
+      end
+
+      context "part of a remote in the args" do
+        receiving %w(maintenance:off -r), it_should_pass_on: %w(maintenance:off -r)
+        receiving %w(logs -a), it_should_pass_on: %w(logs -a)
+      end
+    end
+
+    context "a remote memorized" do
+      let(:remote) { [%w(-r -a).sample, %w(demo staging prod test app).sample] }
+      before { allow(env).to receive(:remote?).and_return(true) }
+      before { allow(env).to receive(:remote).and_return(remote) }
+
+      context "a remote in the args" do
+        receiving %w(run rake some:task -r a-remote), it_should_pass_on: %w(run rake some:task -r a-remote)
+        receiving %w(maintenance:on -a another-app), it_should_pass_on: %w(maintenance:on -a another-app)
+      end
+
+      context "no remote in the args" do
+        receiving %w(restart), it_should_pass_on: -> { %w(restart) + remote }
+      end
+
+      context "part of a remote in the args" do
+        receiving %w(run console -r), it_should_pass_on: %w(run console -r)
+        receiving %w(maintenance:on -a), it_should_pass_on: %w(maintenance:on -a)
+      end
+    end
+  end
+end

data/spec/hrk/execute/remote_display_spec.rb

@@ -2,16 +2,16 @@ require 'spec_helper'
 
 RSpec.describe Hrk::Execute::RemoteDisplay do
   describe '#call' do
-    let(:fallback)          { double }
-    let(:fallback_result)   { [true, false].sample }
-    let(:remote)            { [%w(-a -r).sample, "demo#{rand(1..9)}"] }
-    let(:there_be_a_remote) { [true, false].sample }
+    let(:next_callee)        { double }
+    let(:next_callee_result) { [true, false].sample }
+    let(:remote)             { [%w(-a -r).sample, "demo#{rand(1..9)}"] }
+    let(:there_be_a_remote)  { [true, false].sample }
 
-    subject(:remote_display) { Hrk::Execute::RemoteDisplay.new(fallback) }
+    subject(:remote_display) { Hrk::Execute::RemoteDisplay.new(next_callee) }
 
     before { allow_any_instance_of(Hrk::Env).to receive(:remote?).and_return(there_be_a_remote) }
     before { allow_any_instance_of(Hrk::Env).to receive(:remote).and_return(remote) }
-    before { allow(fallback).to receive(:call).and_return(fallback_result) }
+    before { allow(next_callee).to receive(:call).and_return(next_callee_result) }
     before { allow(remote_display).to receive(:puts) }
 
     subject!(:result) { remote_display.call(*args) }
@@ -24,7 +24,7 @@ RSpec.describe Hrk::Execute::RemoteDisplay do
 
         it { expect(result).to eq true }
         it { expect(remote_display).to have_received(:puts).with(remote.join(' ')) }
-        it { expect(fallback).not_to have_received(:call) }
+        it { expect(next_callee).not_to have_received(:call) }
       end
 
       context 'and no remote' do
@@ -32,16 +32,16 @@ RSpec.describe Hrk::Execute::RemoteDisplay do
 
         it { expect(result).to eq false }
         it { expect(remote_display).not_to have_received(:puts) }
-        it { expect(fallback).not_to have_received(:call) }
+        it { expect(next_callee).not_to have_received(:call) }
       end
     end
 
     context 'there are arguments' do
       let(:args) { %W(what#{rand(1..9)} --will we --do -to -- the drunken --whaler?) }
 
-      it { expect(result).to eq fallback_result }
+      it { expect(result).to eq next_callee_result }
       it { expect(remote_display).not_to have_received(:puts) }
-      it { expect(fallback).to have_received(:call).with(*args) }
+      it { expect(next_callee).to have_received(:call).with(*args) }
     end
   end
 end

data/spec/hrk/execute/remote_last_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+
+RSpec.describe Hrk::Execute::RemoteLast do
+  describe "#call" do
+    let(:next_callee) { double(Hrk::Execute::Command) }
+
+    subject(:remote_last) { Hrk::Execute::RemoteLast.new next_callee }
+
+    before { allow(next_callee).to receive(:call) }
+
+    context "normal cases" do
+      def self.receiving args, it_should_pass_on: []
+        context "receiving #{args.join " "}" do
+          subject!(:result) { remote_last.call(*args) }
+
+          it { expect(next_callee).to have_received(:call).with(*it_should_pass_on) }
+        end
+      end
+
+      receiving %w(run console -r demo),
+        it_should_pass_on: %w(run console -r demo)
+      receiving %w(logs -t -a some-app-prod),
+        it_should_pass_on: %w(logs -t -a some-app-prod)
+      receiving %w(-r test run rake db:migrate),
+        it_should_pass_on: %w(run rake db:migrate -r test)
+      receiving %w(-a another-app-demo config),
+        it_should_pass_on: %w(config -a another-app-demo)
+      receiving %w(run -r testing rake db:migrate),
+        it_should_pass_on: %w(run rake db:migrate -r testing)
+      receiving %w(config:set -a the-main-app whatever="some_value"),
+        it_should_pass_on: %w(config:set whatever="some_value" -a the-main-app)
+      receiving %w(rake db:rollback),
+        it_should_pass_on: %w(rake db:rollback)
+      receiving %w(run console -a),
+        it_should_pass_on: %w(run console -a)
+      receiving %w(logs -t -r),
+        it_should_pass_on: %w(logs -t -r)
+    end
+
+    context "edge cases" do
+      def self.receiving args, it_should_raise: ArgumentError
+        context "receiving #{args.join " "}" do
+          subject(:the_command) { -> { remote_last.call(*args) } }
+
+          it { expect(&the_command).to raise_error it_should_raise }
+
+          context "the next callee" do
+            before { the_command.call rescue nil }
+
+            it { expect(next_callee).not_to have_received(:call) }
+          end
+        end
+      end
+
+      receiving %w(-r test run console -r demo),             it_should_raise: ArgumentError
+      receiving %w(rake -a my-way db:migrate -a my-way-tmp), it_should_raise: ArgumentError
+      receiving %w(-a super-app -r staging rake db:migrate), it_should_raise: ArgumentError
+    end
+  end
+end

data/spec/hrk/execute_spec.rb

@@ -22,13 +22,19 @@ RSpec.describe Hrk::Execute do
     let(:heroku_detector) { double(Hrk::Execute::HerokuDetector) }
     let(:remote_display)  { double(Hrk::Execute::RemoteDisplay) }
     let(:help)            { double(Hrk::Execute::Help) }
+    let(:remote_last)     { double(Hrk::Execute::RemoteLast) }
+    let(:remember)        { double(Hrk::Execute::Remember) }
+    let(:ask_for_remote)  { double(Hrk::Execute::AskForRemote) }
     let(:command)         { double(Hrk::Execute::Command) }
 
-    before { allow(Hrk::Execute::Command).to receive(:new).and_return(command) }
-    before { allow(Hrk::Execute::Help).to receive(:new).with(command).and_return(help) }
-    before { allow(Hrk::Execute::RemoteDisplay).to receive(:new).with(help).and_return(remote_display) }
+    before { allow(Hrk::Execute::Command).       to receive(:new).and_return(command) }
+    before { allow(Hrk::Execute::AskForRemote).  to receive(:new).with(command).and_return(ask_for_remote) }
+    before { allow(Hrk::Execute::Remember).      to receive(:new).with(ask_for_remote).and_return(remember) }
+    before { allow(Hrk::Execute::RemoteLast).    to receive(:new).with(remember).and_return(remote_last) }
+    before { allow(Hrk::Execute::Help).          to receive(:new).with(remote_last).and_return(help) }
+    before { allow(Hrk::Execute::RemoteDisplay). to receive(:new).with(help).and_return(remote_display) }
     before { allow(Hrk::Execute::HerokuDetector).to receive(:new).with(remote_display).and_return(heroku_detector) }
-    before { allow(Hrk::Execute::ErrorTrap).to receive(:new).with(heroku_detector).and_return(error_trap) }
+    before { allow(Hrk::Execute::ErrorTrap).     to receive(:new).with(heroku_detector).and_return(error_trap) }
 
     it { expect(Hrk::Execute.executer).to eq error_trap }
   end

data/spec/hrk/heroku_spec.rb

@@ -1,19 +1,18 @@
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Hrk::Heroku do
-  describe '#call' do
-    describe 'the exec command ran' do
-      def self.calling command, on_remote: %W(-r whatever-app), starts: [], and_outputs: ''
-        describe "calling '#{command.join ' '}' on remote '#{on_remote}', exec" do
+  describe "#call" do
+    describe "the exec command ran" do
+      def self.calling command, on_remote: %W(-r whatever-app), starts: [], and_outputs: ""
+        describe "calling `#{command.join " "}` on remote #{on_remote}" do
           subject(:heroku) { Hrk::Heroku.new(*on_remote) }
 
           before { allow(heroku).to receive(:puts) }
 
-          specify do
-            heroku.call(*command)
-            expect(heroku).to have_received(:exec).with(*starts)
-            expect(heroku).to have_received(:puts).with(and_outputs)
-          end
+          subject!(:result) { heroku.call(*command) }
+
+          it { expect(heroku).to have_received(:exec).with(*starts) }
+          it { expect(heroku).to have_received(:puts).with(and_outputs) }
         end
       end
 
@@ -44,35 +43,38 @@ RSpec.describe Hrk::Heroku do
         end
       end
 
-      describe '(edge case)' do
+      describe "(edge case)" do
         subject(:heroku) { Hrk::Heroku.new(*%w(-r some-remote)) }
 
         before { allow(heroku).to receive(:puts) }
+        before { allow(heroku).to receive(:exec) }
 
-        specify 'another remote is mentionned' do
+        specify "another remote is mentionned" do
           expect { heroku.call(*%w(run rake rake:db:migrate -r some-other-remote)) }.to raise_exception(Hrk::Heroku::ExplicitApplicationError)
           expect(heroku).not_to have_received(:puts)
+          expect(heroku).not_to have_received(:exec)
         end
-        specify 'another app is mentionned' do
+        specify "another app is mentionned" do
           expect { heroku.call(*%w(run rake rake:db:migrate -a different-app)) }.to raise_exception(Hrk::Heroku::ExplicitApplicationError)
           expect(heroku).not_to have_received(:puts)
+          expect(heroku).not_to have_received(:exec)
         end
       end
     end
 
-    describe 'the result of the command' do
+    describe "the result of the command" do
       subject(:heroku) { Hrk::Heroku.new(*%w(-r some-remote)) }
-      before { allow(heroku).to receive(:exec).with(*%W(heroku some command -r some-remote)).and_return(exec_returns) }
-      before { allow(heroku).to receive(:puts) }
+      before { expect(heroku).to receive(:exec).with(*%W(heroku some command -r some-remote)).and_return(exec_return) }
+      before { expect(heroku).to receive(:puts) }
 
-      context 'the command result is truthy' do
-        let(:exec_returns) { true }
+      context "the command result is truthy" do
+        let(:exec_return) { true }
 
         it { expect(heroku.call(*%w(some command))).to be_truthy }
       end
 
-      context 'the command result is falsy' do
-        let(:exec_returns) { false }
+      context "the command result is falsy" do
+        let(:exec_return) { false }
 
         it { expect(heroku.call(*%w(some command))).to be_falsy }
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hrk
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.0.7
 platform: ruby
 authors:
 - Michel Belleville
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-03 00:00:00.000000000 Z
+date: 2015-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -165,19 +165,25 @@ files:
 - lib/hrk.rb
 - lib/hrk/env.rb
 - lib/hrk/execute.rb
+- lib/hrk/execute/ask_for_remote.rb
 - lib/hrk/execute/command.rb
 - lib/hrk/execute/error_trap.rb
 - lib/hrk/execute/help.rb
 - lib/hrk/execute/heroku_detector.rb
+- lib/hrk/execute/remember.rb
 - lib/hrk/execute/remote_display.rb
+- lib/hrk/execute/remote_last.rb
 - lib/hrk/heroku.rb
 - lib/hrk/version.rb
 - spec/hrk/env_spec.rb
+- spec/hrk/execute/ask_for_remote_spec.rb
 - spec/hrk/execute/command_spec.rb
 - spec/hrk/execute/error_trap_spec.rb
 - spec/hrk/execute/help_spec.rb
 - spec/hrk/execute/heroku_detector_spec.rb
+- spec/hrk/execute/remember_spec.rb
 - spec/hrk/execute/remote_display_spec.rb
+- spec/hrk/execute/remote_last_spec.rb
 - spec/hrk/execute_spec.rb
 - spec/hrk/heroku_spec.rb
 - spec/spec_helper.rb