cli-kit 3.0.0 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88690eeba1179ef8cb31ebd13b68d978e71f5c8a
-  data.tar.gz: f63da3dc52f120f759241232fb64953deb0e0b3f
+  metadata.gz: c6c63b562d9e105af0a13a110ad973bbb56d40a4
+  data.tar.gz: f89728ea2fd0f05ed1c9b6f16dbad900c4bc5595
 SHA512:
-  metadata.gz: abd4591db97ad44a9ebdf3645181ad90b443ad70d3849b3f247cf577cc394b04638646d14ab1cc18273d05a3a55cb1cdb3022ce9052792b025a7498c6d94a309
-  data.tar.gz: 6c8571d319162adfeb0dd66c294fb225565c10e50fdcb70ab60dcd4bbd705131ec43916691c8ce160939348491ec453d5b1054a2504bc13594e76aecc20cdf01
+  metadata.gz: 7088f3a7a238311cb8aaad7e83f74611ef30f2cbe0db5bbdc393d6c7da7ca51e68d54884c73707ea9751644c9ebdec6156829f939f4cf65044b5a690b053450a
+  data.tar.gz: 19fbec7a9eaee07f188c69f1d776404227f554dc38e44ff08bd2160026a45aac0e843526703ba0a1312bbcb853d2496bd5b5bf2b41d232f1ac033353b05b83c3

data/.rubocop.yml

@@ -5,6 +5,10 @@ AllCops:
   Exclude: [ 'gen/template/**/*' ]
   TargetRubyVersion: 2.3
 
+Style/ClassAndModuleChildren:
+  Exclude:
+    - lib/cli/kit/support/test_helper.rb
+
 Style/FrozenStringLiteralComment:
   Enabled: false
 

data/.travis.yml

@@ -1,5 +1,14 @@
 sudo: false
 language: ruby
+cache: bundler
 rvm:
   - 2.3.3
-before_install: gem install bundler -v 1.15.0
+  - 2.5.0
+os:
+  - linux
+  - osx
+script:
+  - bin/testunit
+  - git clone https://github.com/Shopify/cli-ui.git
+  - DEPS=vendor bin/test_gen
+  - DEPS=bundler bin/test_gen

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cli-kit (3.0.0)
+    cli-kit (3.0.1)
       cli-ui (>= 1.1.0)
 
 GEM
@@ -11,7 +11,7 @@ GEM
     ast (2.3.0)
     builder (3.2.3)
     byebug (9.0.6)
-    cli-ui (1.1.0)
+    cli-ui (1.1.1)
     metaclass (0.0.4)
     method_source (0.8.2)
     minitest (5.10.2)
@@ -54,4 +54,4 @@ DEPENDENCIES
   rubocop
 
 BUNDLED WITH
-   1.16.0
+   1.16.1

data/README.md

@@ -11,8 +11,106 @@
 to build a number of internal developer tools, along with
 [cli-ui](https://github.com/shopify/cli-ui).
 
-## Example Usage
+## Getting Started
 
-You can see example usage [here](https://github.com/Shopify/cli-kit-example). We may one day build
-an application generator, as this framework paradigm requires a small amount of boilerplate. For
-now, the best way to get going is to use this example application as a starting point.
+To begin creating your first `cli-kit` application, run:
+```bash
+gem install cli-kit
+cli-kit new myproject
+```
+
+Where `myproject` is the name of the application you wish to create.  Then, you will be prompted to
+select how the project consumes `cli-kit` and `cli-ui`.  The available options are:
+- Vendor (faster execution, more difficult to update dependencies)
+- Bundler (slower execution, easier dependency management)
+
+You're now ready to write your very first `cli-kit` application!
+
+## How do `cli-kit` Applications Work?
+
+The executable for your `cli-kit` app is stored in the "exe" directory.  To execute the app, simply
+run:
+```bash
+./exe/myproject
+```
+
+### Folder Structure
+* `/exe/` - Location of the executables for your application.
+* `/lib/` - Location of the resources for your app (modules, classes, helpers, etc).
+    * `myproject.rb` - This file is the starting point for where to look for all other files. It
+    configures autoload and autocall for the app.
+    * `myproject/` - Stores the various commands/entry points.
+        * `entry_point.rb` - This is the file that is first called from the executable. It handles 
+        loading and commands.
+        * `commands.rb` - Registers the various commands that your application is able to handle.
+        * `commands/` - Stores Ruby files for each command (help, new, add, etc).
+
+## Adding a New Command to your App
+
+### Registering the Command
+
+Let's say that you'd like your program to be able to handle a specific task, and you'd like to
+_register_ a new handler for the command for that task, like `myproject add` to add 2 numbers, like
+in a calculator app.
+To do this, open `/lib/myproject/commands.rb`. Then, add a new line into the module, like this:
+```ruby
+register :Add, 'add', 'myproject/commands/add'
+```
+
+The format for this is `register :<CommandClass>, '<command-at-cli>', '<path/to/command.rb>'`
+
+### Creating the Command Action
+
+The action for a specific command is stored in its own Ruby file, in the `/lib/myproject/commands/`
+directory.  Here is an example of the `add` command in our previous to-do app example:
+```ruby
+require 'myproject'
+
+module Myproject
+  module Commands
+    class Add < Myproject::Command
+      def call(args, _name)
+        # command action goes here
+      end
+
+      def self.help
+        # help or instructions go here
+      end
+    end
+  end
+end
+
+```
+
+The `call(args, _name)` method is what actually runs when the `myproject add` command is executed.
+
+- **Note:** The `args` parameter represents all the arguments the user has specified.
+
+Let's say that you are trying to compute the sum of 2 numbers that the user has specified as
+arguments.  For example:
+```ruby
+def call(args, _name)
+  sum = args.map(&:to_i).inject(&:+)
+  puts sum
+end
+```
+
+### Getting Help
+
+Above, you'll notice that we also have a `self.help` method.  This method is what runs when the user
+has incorrectly used the command, or has requested help.  For example:
+```ruby
+def self.help
+  "Print the sum of 2 numbers.\nUsage: {{command:#{Myproject::TOOL_NAME} add}} 5 7"
+end
+```
+
+## User Interfaces
+
+`cli-kit` also features `cli-ui`, another gem from us here at Shopify, which allows for the use of
+powerful command-line user interface elements. For more details on how to use `cli-ui`, visit the 
+[`cli-ui`](https://github.com/Shopify/cli-ui) repo.
+
+## Examples
+
+- [A Simple To-Do App](https://github.com/Shopify/cli-kit-example)

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/test_gen

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+
+# Make sure we're in the cli kit directory
+CURR_DIR=$(dirname "$0")
+cd $CURR_DIR
+cd ../
+
+# Clean up
+function finish {
+  cd $CURR_DIR
+  cd ../../
+  rm -rf myapp
+}
+trap finish EXIT
+
+# Generate app and move up a level to be at the same level as cli-kit
+bundle exec ruby exe/cli-kit new myapp
+mv myapp ../
+cd ../myapp
+
+# Test
+bundle install
+bin/testunit
+
+if [[ $DEPS == 'vendor' ]]; then
+  git clone https://github.com/Shopify/cli-ui.git ../cli-ui
+  bin/update-deps
+fi

data/gen/lib/gen/commands/help.rb

@@ -9,7 +9,7 @@ module Gen
 
         Gen::Commands::Registry.resolved_commands.each do |name, klass|
           puts CLI::UI.fmt("{{command:#{Gen::TOOL_NAME} #{name}}}")
-          if help = klass.help
+          if klass.respond_to?(:help) && help = klass.help
             puts CLI::UI.fmt(help)
           end
           puts ""

data/gen/lib/gen/generator.rb

@@ -27,7 +27,6 @@ module Gen
     private_constant :VENDOR_TRANSLATIONS
 
     BUNDLER_TRANSLATIONS = {
-      'bin'                => false,
       'bin/update-deps'    => false,
       'exe/__app__-gems'   => 'exe/__app__',
       'exe/__app__-vendor' => false,
@@ -59,6 +58,9 @@ module Gen
     private
 
     def ask_vendor?
+      return 'vendor' if ENV['DEPS'] == 'vendor'
+      return 'bundler' if ENV['DEPS'] == 'bundler'
+
       vendor = nil
       CLI::UI::Frame.open('Configuration') do
         q = 'How would you like the application to consume {{command:cli-kit}} and {{command:cli-ui}}?'

data/gen/template/Gemfile

@@ -2,3 +2,9 @@ source 'https://rubygems.org'
 
 gem 'cli-kit', '~> __cli-kit-version__'
 gem 'cli-ui', '~> __cli-ui-version__'
+
+group :test do
+  gem 'mocha', require: false
+  gem 'minitest', '>= 5.0.0', require: false
+  gem 'minitest-reporters', require: false
+end

data/gen/template/bin/testunit

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+
+root = File.expand_path('../..', __FILE__)
+TEST_ROOT = root + '/test'
+
+$LOAD_PATH.unshift(TEST_ROOT)
+
+def test_files
+  Dir.glob(TEST_ROOT + "/**/*_test.rb")
+end
+
+if ARGV.empty?
+  test_files.each { |f| require(f) }
+  exit 0
+end
+
+# A list of files is presumed to be specified
+ARGV.each do |a|
+  require a.sub(%r{^test/}, '')
+end

data/gen/template/bin/update-deps

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby --disable-gems
+#!/usr/bin/env ruby
 
 $LOAD_PATH.unshift(File.expand_path("../../vendor/deps/cli-ui/lib", __FILE__))
 require 'open3'
@@ -39,6 +39,7 @@ deps.each do |dep|
     bail(
       "dependency is not checked out: {{yellow:#{dep}}}.\n" \
       "  This repo {{bold_blue:(github.com/shopify/#{dep})}} must be cloned at {{bold_blue:#{path}}} for this script to succeed.\n" \
+      "  Currently, SOURCE_ROOT is set to {{bold_blue:#{source_path}}}.\n" \
       "  Alternatively, you can set {{bold_blue:SOURCE_ROOT}} to a directory containing {{yellow:#{dep}}}.\n" \
       "  {{bold_blue:SOURCE_ROOT}} defaults to {{bold_blue:../}}."
     )

data/gen/template/test/example_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+module __App__
+  class ExampleTest < MiniTest::Test
+    include CLI::Kit::Support::TestHelper
+
+    def test_example
+      CLI::Kit::System.fake("ls -al", stdout: "a\nb", success: true)
+      assert_all_commands_run do
+        out, = CLI::Kit::System.capture2('ls', '-al')
+        assert_equal ['a', 'b'], out.split("\n")
+      end
+    end
+  end
+end

data/gen/template/test/test_helper.rb

@@ -0,0 +1,21 @@
+begin
+  addpath = lambda do |p|
+    path = File.expand_path("../../#{p}", __FILE__)
+    $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+  end
+  addpath.call("lib")
+end
+
+require 'cli/kit'
+
+require 'fileutils'
+require 'tmpdir'
+require 'tempfile'
+
+require 'rubygems'
+require 'bundler/setup'
+
+CLI::UI::StdoutRouter.enable
+
+require 'minitest/autorun'
+require 'mocha/mini_test'

data/lib/cli/kit.rb

@@ -12,6 +12,7 @@ module CLI
     autoload :Ini,             'cli/kit/ini'
     autoload :Levenshtein,     'cli/kit/levenshtein'
     autoload :Resolver,        'cli/kit/resolver'
+    autoload :Support,         'cli/kit/support'
     autoload :System,          'cli/kit/system'
 
     EXIT_FAILURE_BUT_NOT_BUG = 30

data/lib/cli/kit/command_registry.rb

@@ -68,7 +68,7 @@ module CLI
 
       def resolve_global_command(name)
         klass = resolve_class(commands.fetch(name, nil))
-        return nil unless klass
+        return nil unless klass && klass.defined?
         [klass, name]
       rescue NameError
         nil

data/lib/cli/kit/config.rb

@@ -43,6 +43,27 @@ module CLI
         write_config
       end
 
+      # Unsets a config value in the config file
+      #
+      # #### Parameters
+      # `section` : the section of the config you are deleting
+      # `name` : the name of the config you are deleting
+      #
+      # #### Example Usage
+      # `config.unset('section', 'name.of.config')`
+      #
+      def unset(section, name)
+        set(section, name, nil)
+      end
+
+      # Gets the hash for the entire section
+      #
+      # #### Parameters
+      # `section` : the section of the config you are getting
+      #
+      # #### Example Usage
+      # `config.get_section('section')`
+      #
       def get_section(section)
         (all_configs["[#{section}]"] || {}).dup
       end

data/lib/cli/kit/error_handler.rb

@@ -20,43 +20,37 @@ module CLI
         handle_abort(&block)
       end
 
-      private
-
-      def install!
-        at_exit { handle_final_exception(@exception || $ERROR_INFO) }
+      def handle_exception(error)
+        if notify_with = exception_for_submission(error)
+          logs = begin
+            File.read(@log_file)
+          rescue => e
+            "(#{e.class}: #{e.message})"
+          end
+          exception_reporter.report(notify_with, logs)
+        end
       end
 
-      def handle_abort
-        yield
-        CLI::Kit::EXIT_SUCCESS
-      rescue CLI::Kit::GenericAbort => e
-        is_bug    = e.is_a?(CLI::Kit::Bug) || e.is_a?(CLI::Kit::BugSilent)
-        is_silent = e.is_a?(CLI::Kit::AbortSilent) || e.is_a?(CLI::Kit::BugSilent)
-
-        print_error_message(e) unless is_silent
-        (@exception = e) if is_bug
-
-        CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG
-      rescue Interrupt
-        $stderr.puts(format_error_message("Interrupt"))
-        return CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG
-      end
+      # maybe we can get rid of this.
+      attr_writer :exception
 
-      def handle_final_exception(error)
-        notify_with = nil
+      private
 
+      def exception_for_submission(error)
         case error
         when nil         # normal, non-error termination
+          nil
         when Interrupt   # ctrl-c
+          nil
         when CLI::Kit::Abort, CLI::Kit::AbortSilent # Not a bug
+          nil
         when SignalException
           skip = %w(SIGTERM SIGHUP SIGINT)
-          unless skip.include?(error.message)
-            notify_with = error
-          end
+          skip.include?(error.message) ? nil : error
         when SystemExit # "exit N" called
           case error.status
           when CLI::Kit::EXIT_SUCCESS # submit nothing if it was `exit 0`
+            nil
           when CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG
             # if it was `exit 30`, translate the exit code to 1, and submit nothing.
             # 30 is used to signal normal failures that are not indicative of bugs.
@@ -65,20 +59,31 @@ module CLI
           else
             # A weird termination status happened. `error.exception "message"` will maintain backtrace
             # but allow us to set a message
-            notify_with = error.exception "abnormal termination status: #{error.status}"
+            error.exception("abnormal termination status: #{error.status}")
           end
         else
-          notify_with = error
+          error
         end
+      end
 
-        if notify_with
-          logs = begin
-            File.read(@log_file)
-          rescue => e
-            "(#{e.class}: #{e.message})"
-          end
-          exception_reporter.report(notify_with, logs)
-        end
+      def install!
+        at_exit { handle_exception(@exception || $ERROR_INFO) }
+      end
+
+      def handle_abort
+        yield
+        CLI::Kit::EXIT_SUCCESS
+      rescue CLI::Kit::GenericAbort => e
+        is_bug    = e.is_a?(CLI::Kit::Bug) || e.is_a?(CLI::Kit::BugSilent)
+        is_silent = e.is_a?(CLI::Kit::AbortSilent) || e.is_a?(CLI::Kit::BugSilent)
+
+        print_error_message(e) unless is_silent
+        (@exception = e) if is_bug
+
+        CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG
+      rescue Interrupt
+        $stderr.puts(format_error_message("Interrupt"))
+        return CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG
       end
 
       def exception_reporter

data/lib/cli/kit/executor.rb

@@ -28,10 +28,14 @@ module CLI
       end
 
       def twrap(signal, handler)
-        prev_handler = trap(signal, handler)
-        yield
-      ensure
-        trap(signal, prev_handler)
+        return yield unless Signal.list.key?(signal)
+
+        begin
+          prev_handler = trap(signal, handler)
+          yield
+        ensure
+          trap(signal, prev_handler)
+        end
       end
 
       def quit_handler(_sig)

data/lib/cli/kit/ini.rb

@@ -46,21 +46,26 @@ module CLI
         @ini
       end
 
+      def git_format
+        to_ini(@ini, git_format: true).flatten.join("\n")
+      end
+
       def to_s
         to_ini(@ini).flatten.join("\n")
       end
 
       private
 
-      def to_ini(h)
+      def to_ini(h, git_format: false)
+        optional_tab = git_format ? "\t" : ""
         str = []
         h.each do |k, v|
           if section_designator?(k)
-            str << "" unless str.empty?
+            str << "" unless str.empty? || git_format
             str << k
-            str << to_ini(v)
+            str << to_ini(v, git_format: git_format)
           else
-            str << "#{k} = #{v}"
+            str << "#{optional_tab}#{k} = #{v}"
           end
         end
         str

data/lib/cli/kit/support.rb

@@ -0,0 +1,9 @@
+require 'cli/kit'
+
+module CLI
+  module Kit
+    module Support
+      autoload :TestHelper, 'cli/kit/support/test_helper'
+    end
+  end
+end

data/lib/cli/kit/support/test_helper.rb

@@ -0,0 +1,226 @@
+module CLI
+  module Kit
+    module Support
+      module TestHelper
+        def setup
+          super
+          CLI::Kit::System.reset!
+        end
+
+        def assert_all_commands_run(should_raise: true)
+          errors = CLI::Kit::System.error_message
+          CLI::Kit::System.reset!
+          assert false, errors if should_raise && !errors.nil?
+          errors
+        end
+
+        def teardown
+          super
+          assert_all_commands_run
+        end
+
+        class FakeSuccess
+          def initialize(success)
+            @success = success
+          end
+
+          def success?
+            @success
+          end
+        end
+
+        module ::CLI
+          module Kit
+            module System
+              class << self
+                alias_method :original_system, :system
+                def system(*a, sudo: false, env: {}, **kwargs)
+                  expected_command = expected_command(*a, sudo: sudo, env: env)
+
+                  # In the case of an unexpected command, expected_command will be nil
+                  return FakeSuccess.new(false) if expected_command.nil?
+
+                  # Otherwise handle the command
+                  if expected_command[:allow]
+                    original_system(*a, sudo: sudo, env: env, **kwargs)
+                  else
+                    FakeSuccess.new(expected_command[:success])
+                  end
+                end
+
+                alias_method :original_capture2, :capture2
+                def capture2(*a, sudo: false, env: {}, **kwargs)
+                  expected_command = expected_command(*a, sudo: sudo, env: env)
+
+                  # In the case of an unexpected command, expected_command will be nil
+                  return [nil, FakeSuccess.new(false)] if expected_command.nil?
+
+                  # Otherwise handle the command
+                  if expected_command[:allow]
+                    original_capture2(*a, sudo: sudo, env: env, **kwargs)
+                  else
+                    [
+                      expected_command[:stdout],
+                      FakeSuccess.new(expected_command[:success]),
+                    ]
+                  end
+                end
+
+                alias_method :original_capture2e, :capture2e
+                def capture2e(*a, sudo: false, env: {}, **kwargs)
+                  expected_command = expected_command(*a, sudo: sudo, env: env)
+
+                  # In the case of an unexpected command, expected_command will be nil
+                  return [nil, FakeSuccess.new(false)] if expected_command.nil?
+
+                  # Otherwise handle the command
+                  if expected_command[:allow]
+                    original_capture2ecapture2e(*a, sudo: sudo, env: env, **kwargs)
+                  else
+                    [
+                      expected_command[:stdout],
+                      FakeSuccess.new(expected_command[:success]),
+                    ]
+                  end
+                end
+
+                alias_method :original_capture3, :capture3
+                def capture3(*a, sudo: false, env: {}, **kwargs)
+                  expected_command = expected_command(*a, sudo: sudo, env: env)
+
+                  # In the case of an unexpected command, expected_command will be nil
+                  return [nil, nil, FakeSuccess.new(false)] if expected_command.nil?
+
+                  # Otherwise handle the command
+                  if expected_command[:allow]
+                    original_capture3(*a, sudo: sudo, env: env, **kwargs)
+                  else
+                    [
+                      expected_command[:stdout],
+                      expected_command[:stderr],
+                      FakeSuccess.new(expected_command[:success]),
+                    ]
+                  end
+                end
+
+                # Sets up an expectation for a command and stubs out the call (unless allow is true)
+                #
+                # #### Parameters
+                # `*a` : the command, represented as a splat
+                # `stdout` : stdout to stub the command with (defaults to empty string)
+                # `stderr` : stderr to stub the command with (defaults to empty string)
+                # `allow` : allow determines if the command will be actually run, or stubbed. Defaults to nil (stub)
+                # `success` : success status to stub the command with (Defaults to nil)
+                # `sudo` : expectation of sudo being set or not (defaults to false)
+                # `env` : expectation of env being set or not (defaults to {})
+                #
+                # Note: Must set allow or success
+                #
+                def fake(*a, stdout: "", stderr: "", allow: nil, success: nil, sudo: false, env: {})
+                  raise ArgumentError, "success or allow must be set" if success.nil? && allow.nil?
+
+                  @delegate_open3 ||= {}
+                  @delegate_open3[a.join(' ')] = {
+                    expected: {
+                      sudo: sudo,
+                      env: env,
+                    },
+                    actual: {
+                      sudo: nil,
+                      env: nil,
+                    },
+                    stdout: stdout,
+                    stderr: stderr,
+                    allow: allow,
+                    success: success,
+                    run: false,
+                  }
+                end
+
+                # Resets the faked commands
+                #
+                def reset!
+                  @delegate_open3 = {}
+                end
+
+                # Returns the errors associated to a test run
+                #
+                # #### Returns
+                # `errors` (String) a string representing errors found on this run, nil if none
+                def error_message
+                  errors = {
+                    unexpected: [],
+                    not_run: [],
+                    other: {},
+                  }
+
+                  @delegate_open3.each do |cmd, opts|
+                    if opts[:unexpected]
+                      errors[:unexpected] << cmd
+                    elsif opts[:run]
+                      error = []
+
+                      if opts[:expected][:sudo] != opts[:actual][:sudo]
+                        error << "- sudo was supposed to be #{opts[:expected][:sudo]} but was #{opts[:actual][:sudo]}"
+                      end
+
+                      if opts[:expected][:env] != opts[:actual][:env]
+                        error << "- env was supposed to be #{opts[:expected][:env]} but was #{opts[:actual][:env]}"
+                      end
+
+                      errors[:other][cmd] = error.join("\n") unless error.empty?
+                    else
+                      errors[:not_run] << cmd
+                    end
+                  end
+
+                  final_error = []
+
+                  unless errors[:unexpected].empty?
+                    final_error << CLI::UI.fmt(<<~EOF)
+                    {{bold:Unexpected command invocations:}}
+                    {{command:#{errors[:unexpected].join("\n")}}}
+                    EOF
+                  end
+
+                  unless errors[:not_run].empty?
+                    final_error << CLI::UI.fmt(<<~EOF)
+                    {{bold:Expected commands were not run:}}
+                    {{command:#{errors[:not_run].join("\n")}}}
+                    EOF
+                  end
+
+                  unless errors[:other].empty?
+                    final_error << CLI::UI.fmt(<<~EOF)
+                    {{bold:Commands were not run as expected:}}
+                    #{errors[:other].map { |cmd, msg| "{{command:#{cmd}}}\n#{msg}" }.join("\n\n")}
+                    EOF
+                  end
+
+                  return nil if final_error.empty?
+                  "\n" + final_error.join("\n") # Initial new line for formatting reasons
+                end
+
+                private
+
+                def expected_command(*a, sudo: raise, env: raise)
+                  expected_cmd = @delegate_open3[a.join(' ')]
+
+                  if expected_cmd.nil?
+                    @delegate_open3[a.join(' ')] = { unexpected: true }
+                    return nil
+                  end
+
+                  expected_cmd[:run] = true
+                  expected_cmd[:actual][:sudo] = sudo
+                  expected_cmd[:actual][:env] = env
+                  expected_cmd
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cli/kit/version.rb

@@ -1,5 +1,5 @@
 module CLI
   module Kit
-    VERSION = "3.0.0"
+    VERSION = "3.0.1"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cli-kit
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.0.1
 platform: ruby
 authors:
 - Burke Libbey
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-02-27 00:00:00.000000000 Z
+date: 2018-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cli-ui
@@ -85,7 +85,9 @@ files:
 - Gemfile.lock
 - LICENSE.txt
 - README.md
+- Rakefile
 - bin/console
+- bin/test_gen
 - bin/testunit
 - cli-kit.gemspec
 - dev.yml
@@ -99,6 +101,7 @@ files:
 - gen/template/.gitignore
 - gen/template/Gemfile
 - gen/template/README.md
+- gen/template/bin/testunit
 - gen/template/bin/update-deps
 - gen/template/dev-gems.yml
 - gen/template/dev-vendor.yml
@@ -109,6 +112,8 @@ files:
 - gen/template/lib/__app__/commands/example.rb
 - gen/template/lib/__app__/commands/help.rb
 - gen/template/lib/__app__/entry_point.rb
+- gen/template/test/example_test.rb
+- gen/template/test/test_helper.rb
 - lib/cli/kit.rb
 - lib/cli/kit/autocall.rb
 - lib/cli/kit/base_command.rb
@@ -120,6 +125,8 @@ files:
 - lib/cli/kit/levenshtein.rb
 - lib/cli/kit/resolver.rb
 - lib/cli/kit/ruby_backports/enumerable.rb
+- lib/cli/kit/support.rb
+- lib/cli/kit/support/test_helper.rb
 - lib/cli/kit/system.rb
 - lib/cli/kit/version.rb
 homepage: https://github.com/shopify/cli-kit