mini-cli 0.1.2 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e6c0c096fa96ac3c5687b159637ae5762c1dfa9d18201b0253476bfb96050ca
-  data.tar.gz: 21eb69f322117c7eb8cc2c810292b1b38a3a3f268356cdd9c5cd2f2d0d876a9b
+  metadata.gz: 299da5a35fccbc561453ee2dc9584f7aec510b1fe9dd34e8c7ae3221b6253dbb
+  data.tar.gz: 242f37afb8733342cafd7694d73de4247f2887a027cb4f33da210eff1dc81380
 SHA512:
-  metadata.gz: 5c975c9bff22c0841ac32ac6340d74ed908babb282f5791a7ed0951ad7f59fd0f4e9bcb3226a83f4dd1548ccfe340c2071072a94f4ac27e8937cae234fa584ac
-  data.tar.gz: c8544fba204f56ad6e2359d37ffe9e76ce9997ad34653270d1241d7c82d1153d8826e260f2f40d4840065dc70bd7133139d5cb835fbcee7394696245e825e512
+  metadata.gz: da79647fb91708e556151c22296aa0febe509c9502bbbe327e6fb10cfd3cc22b851f402cede01e25d1df6b9e42382200cc7d34c28f8dab7fc1fac9984dda6d47
+  data.tar.gz: bb7bfb271ea6cbb2e30e4a0833746a30869e484ddc4e7d13c6f1c5f44acdca10d29081f0b52fe9c045685974d6ef6c188ce0e6147cd57f331deb020d74abeacb

data/lib/mini-cli.rb

@@ -1,163 +1,243 @@
 # frozen_string_literal: true
 
 module MiniCli
-  def self.included(_)
-    return if const_defined?(:SRC)
-    const_set(:SRC, caller_locations(1, 1).first.absolute_path)
+  def self.included(mod)
+    mod.const_set(
+      :MiniCli__,
+      Instance.new(caller_locations(1, 1).first.absolute_path)
+    )
+    mod.private_constant(:MiniCli__)
   end
 
   def name(name = nil)
-    return name ? @__name = name : @__name if defined?(@__name)
-    @__name = name || File.basename(MiniCli::SRC, '.*')
+    __minicli__.name(name)
   end
 
   def help(helptext, *args)
-    @__argv_parser = ArgvParser.new(helptext, args)
+    __minicli__.help(helptext, args)
   end
 
   def show_help
-    __argv_parser.show_help(name)
-    true
+    __minicli__.show_help
   end
 
-  def error(code, message)
-    $stderr.puts("#{name}: #{message}")
-    exit(code)
+  def show_errors?
+    __minicli__.show_errors
   end
 
-  def parse_argv(argv = nil, &block)
-    return @__argv_converter = block if block
-    argv ||= ARGV.dup
+  def show_errors=(value)
+    __minicli__.show_errors = value ? true : false
+  end
+
+  def error_code
+    __minicli__.error_code
+  end
+
+  def error(code, message = nil)
+    $stderr.puts("#{name}: #{message}") if message && show_errors?
+    exit(__minicli__.error_code = code)
+  end
+
+  def parse_argv(argv = nil, &argv_converter)
+    return __minicli__.converter = argv_converter if argv_converter
+    argv = Array.new(argv || ARGV)
     exit(show_help) if argv.index('--help') || argv.index('-h')
-    args = __argv_parser.parse(argv, method(:error).to_proc)
-    defined?(@__argv_converter) ? @__argv_converter.call(args) || args : args
+    __minicli__.main(argv, method(:error).to_proc)
   end
 
-  def main(args = nil)
-    at_exit do
-      yield(args || parse_argv)
+  def main
+    __minicli__.run do
+      yield(parse_argv)
     rescue Interrupt
       error(130, 'aborted')
     end
   end
 
+  def before(&callback)
+    callback and __minicli__.before << callback
+  end
+
+  def after(&callback)
+    callback and __minicli__.after << callback
+  end
+
   private
 
-  def __argv_parser
-    @__argv_parser ||= ArgvParser.new(nil, [])
+  def __minicli__
+    self.class.const_get(:MiniCli__)
   end
 
-  class ArgvParser
-    def initialize(helptext, args)
-      @helptext = helptext.to_s
-      @args = args.flatten.map!(&:to_s).uniq
-      @options = nil
+  class Instance
+    attr_reader :source
+    attr_writer :converter
+    attr_accessor :show_errors, :before, :after, :error_code
+
+    def initialize(source)
+      @source = source
+      @name = File.basename(source, '.*')
+      @parser = @converter = @main_proc = nil
+      @before, @after = [], []
+      @show_errors = true
+      @before_ok = false
+      @error_code = 0
+      init_main
     end
 
-    def show_help(name)
-      parse_help! unless @options
-      print("Usage: #{name}")
-      print(' [OPTIONS]') unless @options.empty?
-      print(' ', @args.join(' ')) unless @args.empty?
-      puts
-      puts(nil, 'Valid Options:') unless @options.empty?
-      puts(@helptext) unless @helptext.empty?
+    def name(name = nil)
+      name ? @name = name.to_s : @name
     end
 
-    def parse(argv, error)
-      @error = error
-      parse_help! unless @options
-      @result, arguments = {}, []
-      loop do
-        case arg = argv.shift
-        when nil
-          break
-        when '--'
-          arguments += argv
-          break
-        when /\A--([[[:alnum:]]-]+)\z/
-          handle_option(Regexp.last_match[1], argv)
-        when /\A-([[:alnum:]]+)\z/
-          parse_options(Regexp.last_match[1], argv)
-        else
-          arguments << arg
-        end
-      end
-      process(arguments)
+    def help(helptext, args)
+      @parser = ArgvParser.new(helptext, args)
+    end
+
+    def show_help
+      parser.show_help(@name)
+      true
+    end
+
+    def run(&main_proc)
+      @main_proc = main_proc
+    end
+
+    def main(argv, error)
+      @before.each(&:call)
+      @before_ok = true
+      args = parser.parse(argv, error)
+      @converter ? @converter.call(args) || args : args
     end
 
     private
 
-    def error(msg)
-      @error.call(1, msg)
+    def init_main
+      at_exit do
+        next if $! and not ($!.kind_of?(SystemExit) and $!.success?)
+        shutdown unless @after.empty?
+        @main_proc&.call
+      end
     end
 
-    def process(arguments)
-      @args.each do |arg|
-        next if arg.index('..')
-        value = arguments.shift
+    def shutdown(pid = Process.pid)
+      at_exit do
+        next if Process.pid != pid
+        @after.reverse_each(&:call) if @before_ok
+        exit(@error_code)
+      end
+    end
+
+    def parser
+      @parser ||= ArgvParser.new(nil, [])
+    end
+
+    class ArgvParser
+      def initialize(helptext, args)
+        @helptext = helptext.to_s
+        @args = args.flatten.map!(&:to_s).uniq
+        @options = nil
+      end
+
+      def show_help(name)
+        parse_help! unless @options
+        print("Usage: #{name}")
+        print(' [OPTIONS]') unless @options.empty?
+        print(' ', @args.join(' ')) unless @args.empty?
+        puts
+        puts(nil, 'Options:') unless @options.empty?
+        puts(@helptext) unless @helptext.empty?
+      end
+
+      def parse(argv, error)
+        @error, @result = error, {}
+        parse_help! unless @options
+        process(parse_argv(argv))
+      end
+
+      private
+
+      def parse_argv(argv)
+        arguments = []
+        while (arg = argv.shift)
+          case arg
+          when '--'
+            break arguments += argv
+          when /\A--([[[:alnum:]]-]+)\z/
+            handle_option(Regexp.last_match[1], argv)
+          when /\A-([[:alnum:]]+)\z/
+            parse_options(Regexp.last_match[1], argv)
+          else
+            arguments << arg
+          end
+        end
+        arguments
+      end
 
+      def error(msg)
+        @error[1, msg]
+      end
+
+      def process(arguments)
+        @args.each do |arg|
+          process_arg(arg, arguments.shift) unless arg.index('..')
+        end
+        arguments.unshift(@result['FILES']) if @result.key?('FILES')
+        @result['FILES'] = arguments
+        @result
+      end
+
+      def process_arg(arg, value)
         if arg.start_with?('[')
           @result[arg[1..-2]] = value if value
         else
           @result[arg] = value || error("parameter expected - #{arg}")
         end
       end
-      arguments.unshift(@result['FILES']) if @result.key?('FILES')
-      @result['FILES'] = arguments
-      @result
-    end
 
-    def handle_option(option, argv)
-      key = @options[option] || error("unknown option - #{option}")
-      return @result[key] = true if option == key
-      @result[key] = value = argv.shift
-      return unless value.nil? || value.start_with?('-')
-      error("parameter #{key} expected - --#{option}")
-    end
-
-    def parse_options(options, argv)
-      options.each_char do |opt|
-        key = @options[opt] || error("unknown option - #{opt}")
-        next @result[key] = true if key == key.downcase
+      def handle_option(option, argv, test = ->(k) { option == k })
+        key = @options[option] || error("unknown option - #{option}")
+        @result[key] = test[key] and return
         @result[key] = value = argv.shift
-        next unless value.nil? || value.start_with?('-')
-        error("parameter #{key} expected - -#{opt}")
+        return unless value.nil? || value.start_with?('-')
+        error("parameter #{key} expected - --#{option}")
       end
-    end
 
-    def parse_help!
-      @options = {}
-      @helptext.each_line do |line|
-        case line
-        when /-([[:alnum:]]), --([[[:alnum:]]-]+) ([[:upper:]]+)\s+\S+/
-          named_option(Regexp.last_match)
-        when /--([[[:alnum:]]-]+) ([[:upper:]]+)\s+\S+/
-          named_option_short(Regexp.last_match)
-        when /-([[:alnum:]]), --([[[:alnum:]]-]+)\s+\S+/
-          option(Regexp.last_match)
-        when /--([[[:alnum:]]-]+)\s+\S+/
-          option_short(Regexp.last_match)
+      def parse_options(options, argv)
+        test = ->(k) { k == k.downcase }
+        options.each_char { |opt| handle_option(opt, argv, test) }
+      end
+
+      def parse_help!
+        @options = {}
+        @helptext.each_line do |line|
+          case line
+          when /-([[:alnum:]]), --([[[:alnum:]]-]+) ([[:upper:]]+)\s+\S+/
+            option_with_argument(Regexp.last_match)
+          when /--([[[:alnum:]]-]+) ([[:upper:]]+)\s+\S+/
+            short_option_with_argument(Regexp.last_match)
+          when /-([[:alnum:]]), --([[[:alnum:]]-]+)\s+\S+/
+            option(Regexp.last_match)
+          when /--([[[:alnum:]]-]+)\s+\S+/
+            short_option(Regexp.last_match)
+          end
         end
       end
-    end
 
-    def named_option(match)
-      @options[match[1]] = @options[match[2]] = match[3]
-    end
+      def option_with_argument(match)
+        @options[match[1]] = @options[match[2]] = match[3]
+      end
 
-    def named_option_short(match)
-      @options[match[1]] = match[2]
-    end
+      def short_option_with_argument(match)
+        @options[match[1]] = match[2]
+      end
 
-    def option(match)
-      @options[match[1]] = @options[match[2]] = match[2]
-    end
+      def option(match)
+        @options[match[1]] = @options[match[2]] = match[2]
+      end
 
-    def option_short(match)
-      @options[match[1]] = match[1]
+      def short_option(match)
+        @options[match[1]] = match[1]
+      end
     end
   end
 
-  private_constant(:ArgvParser)
+  private_constant(:Instance)
 end

data/lib/mini-cli/run.rb

@@ -1,32 +1,48 @@
 # frozen_string_literal: true
 
-require 'open3'
-
 module MiniCli
-  def run(*cmd)
-    opts = Hash === cmd.last ? __run_opt(cmd.last) : %i[stdout]
-    opts.delete(:stderr) ? __run3(opts, cmd) : __run2(opts, cmd)
-  rescue SystemCallError
+  def run(*cmd, stdin_data: nil, status: false, chdir: nil)
+    in_read, in_write = IO.pipe
+    opts = { err: %i[child out], in: in_read }
+    opts[:chdir] = chdir if chdir
+    ret = IO.popen(*cmd, opts, &__run_proc(stdin_data, in_write))
+    status ? [Process.last_status, ret] : ret
+  rescue Errno::ENOENT
     nil
+  ensure
+    in_read&.close
+    in_write&.close
   end
 
-  private
-
-  def __run3(opts, cmd)
-    result = Open3.capture3(*cmd)
-    result.shift unless opts.first == :stdout
-    result.pop unless opts.last == :status
-    result.size == 1 ? result.first : result
+  def run_ruby(*cmd, **run_options)
+    require 'shellwords'
+    run(Shellwords.join(RUBY_CMD_ + cmd), **run_options)
   end
 
-  def __run2(opts, cmd)
-    result = Open3.capture2e(*cmd)
-    return result.last.success? if opts.empty?
-    return result if opts.size == 2
-    opts.first == :status ? result.last : result.first
+  def run_script(script, status: false, chdir: nil)
+    run_ruby(stdin_data: script, status: status, chdir: chdir)
   end
 
-  def __run_opt(opts)
-    %i[stdout stderr status].keep_if { |s| opts.delete(s) }
+  private
+
+  def __run_proc(stdin_data, in_write)
+    return :read unless stdin_data
+    proc do |out|
+      in_write.sync = true
+      if stdin_data.respond_to?(:readpartial)
+        IO.copy_stream(stdin_data, in_write)
+      else
+        in_write.write(stdin_data)
+      end
+      in_write.close
+      out.read
+    end
   end
+
+  RUBY_CMD_ =
+    %w[--disable gems --disable did_you_mean --disable rubyopt].unshift(
+      RbConfig.ruby
+    ).freeze
+
+  private_constant(:RUBY_CMD_)
 end

data/lib/mini-cli/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MiniCli
-  VERSION = '0.1.2'
+  VERSION = '0.5.1'
 end

data/lib/mini_cli.rb

@@ -0,0 +1 @@
+require_relative 'mini-cli'

data/mini-cli.gemspec

@@ -2,30 +2,30 @@
 
 require_relative './lib/mini-cli/version'
 
-GemSpec = Gem::Specification.new do |gem|
-  gem.name = 'mini-cli'
-  gem.version = MiniCli::VERSION
-  gem.summary = 'The lean CLI framework for Ruby'
-  gem.description = <<~DESC
+Gem::Specification.new do |spec|
+  spec.name = 'mini-cli'
+  spec.version = MiniCli::VERSION
+  spec.required_ruby_version = '>= 2.5.0'
+
+  spec.summary = 'The lean CLI framework for Ruby'
+  spec.description = <<~DESC
     This gem is a lean, easy to use CLI framework with a very small footprint.
     It provides an easy to use argument parsing, help displaying and
     minimalistic error handling.
   DESC
-  gem.author = 'Mike Blumtritt'
-  gem.homepage = 'https://github.com/mblumtritt/mini-cli'
-  gem.metadata = {
-    'source_code_uri' => 'https://github.com/mblumtritt/mini-cli',
-    'bug_tracker_uri' => 'https://github.com/mblumtritt/mini-cli/issues'
-  }
 
-  gem.required_ruby_version = '>= 2.5.0'
+  spec.author = 'Mike Blumtritt'
+  spec.homepage = 'https://github.com/mblumtritt/mini-cli'
+  spec.metadata['source_code_uri'] = 'https://github.com/mblumtritt/mini-cli'
+  spec.metadata['bug_tracker_uri'] =
+    'https://github.com/mblumtritt/mini-cli/issues'
 
-  gem.add_development_dependency 'bundler'
-  gem.add_development_dependency 'minitest'
-  gem.add_development_dependency 'rake'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'rake'
 
-  all_files = %x(git ls-files -z).split(0.chr)
-  gem.test_files = all_files.grep(%r{^(spec|test)/})
-  gem.files = all_files - gem.test_files
-  gem.extra_rdoc_files = %w[README.md]
+  all_files = Dir.chdir(__dir__) { `git ls-files -z`.split(0.chr) }
+  spec.test_files = all_files.grep(%r{^(spec|test)/})
+  spec.files = all_files - spec.test_files
+  spec.extra_rdoc_files = %w[README.md]
 end

data/rakefile.rb

@@ -3,13 +3,11 @@
 require 'rake/testtask'
 require 'bundler/gem_tasks'
 
-STDOUT.sync = STDERR.sync = true
+$stdout.sync = $stderr.sync = true
 
-CLOBBER << 'prj'
+task(:default) { exec('rake --tasks') }
 
-task :default do
-  exec "#{$PROGRAM_NAME} --tasks"
-end
+CLOBBER << 'prj'
 
 Rake::TestTask.new(:test) do |t|
   t.ruby_opts = %w[-w]

data/samples/custom_args.rb

@@ -14,15 +14,18 @@ HELP
 main { |cfg| cfg.each_pair { |key, value| puts("#{key}: #{value}") } }
 
 parse_argv do |args|
-  Struct.new(:target, :sources, :name, :url, :switch, :opt).new.tap do |cfg|
-    cfg.target = args['TARGET']
-    cfg.sources = args['FILES'] # args['FILES'] is an array containing all surplus arguments
-    source = args['SOURCE'] || ENV['SOURCE']
-    cfg.sources.unshift(source) if source
-    cfg.sources << 'STDIN' if cfg.sources.empty?
-    cfg.name = args['NAME'] || 'default_name'
-    cfg.url = args['URL'] || 'www.url.test'
-    cfg.switch = args.key?('switch')
-    cfg.opt = args.key?('opt')
-  end
+  Struct
+    .new(:target, :sources, :name, :url, :switch, :opt)
+    .new
+    .tap do |cfg|
+      cfg.target = args['TARGET']
+      cfg.sources = args['FILES'] # args['FILES'] is an array containing all surplus arguments
+      source = args['SOURCE'] || ENV['SOURCE']
+      cfg.sources.unshift(source) if source
+      cfg.sources << 'STDIN' if cfg.sources.empty?
+      cfg.name = args['NAME'] || 'default_name'
+      cfg.url = args['URL'] || 'www.url.test'
+      cfg.switch = args.key?('switch')
+      cfg.opt = args.key?('opt')
+    end
 end

data/test/apps/noop.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+# completely empty command
+
+require_relative '../../lib/mini-cli'
+include(MiniCli)
+main {}

data/test/apps/sequence.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+# demonstrates the call sequence
+
+require_relative '../../lib/mini-cli'
+include(MiniCli)
+
+help <<~HELP
+  -x, --exit  early exit
+  -e, --error exit with error
+HELP
+
+main do |*args|
+  puts('main' + args.inspect)
+  exit if args.first['exit']
+  error(42, '!error!') if args.first['error']
+end
+
+before { |*args| puts('before_1' + args.inspect) }
+after { |*args| puts('after_1' + args.inspect) }
+before { |*args| puts('before_2' + args.inspect) }
+after { |*args| puts('after_2' + args.inspect) }
+
+parse_argv do |*args|
+  puts('parse_argv' + args.inspect)
+  args.first
+end

data/test/mini-cli/exec_test.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'shellwords'
+require_relative '../helper'
+
+class ExecTest < Minitest::Test
+  def test_noop
+    assert_empty(assert_no_err('noop.rb'))
+  end
+
+  def test_noop_help
+    assert_equal("Usage: noop\n", assert_no_err('noop.rb', '--help'))
+  end
+
+  def test_sequence
+    expected = [
+      'before_1[]',
+      'before_2[]',
+      "parse_argv[{\"FILES\"=>[]}]",
+      "main[{\"FILES\"=>[]}]",
+      'after_2[]',
+      'after_1[]'
+    ]
+    assert_equal(expected, assert_no_err('sequence.rb').split("\n"))
+  end
+
+  def test_sequence_help
+    expected = [
+      'Usage: sequence [OPTIONS]',
+      '',
+      'Options:',
+      '-x, --exit  early exit',
+      '-e, --error exit with error'
+    ]
+    assert_equal(expected, assert_no_err('sequence.rb', '--help').split("\n"))
+  end
+
+  def test_sequence_early_exit
+    expected = [
+      'before_1[]',
+      'before_2[]',
+      "parse_argv[{\"exit\"=>true, \"FILES\"=>[]}]",
+      "main[{\"exit\"=>true, \"FILES\"=>[]}]",
+      'after_2[]',
+      'after_1[]'
+    ]
+    assert_equal(expected, assert_no_err('sequence.rb', '-x').split("\n"))
+  end
+
+  def test_sequence_error
+    expected = [
+      'before_1[]',
+      'before_2[]',
+      "parse_argv[{\"error\"=>true, \"FILES\"=>[]}]",
+      "main[{\"error\"=>true, \"FILES\"=>[]}]",
+      'after_2[]',
+      'after_1[]'
+    ]
+    std, err, status = invoke('sequence.rb', '-e')
+    assert_same(42, status.exitstatus)
+    assert_equal("sequence: !error!\n", err)
+    assert_equal(expected, std.split("\n"))
+  end
+
+  def assert_no_err(...)
+    std, err = assert_success(...)
+    assert_empty(err)
+    std
+  end
+
+  def assert_success(...)
+    std, err, status = invoke(...)
+    assert(status.success?)
+    return std, err
+  end
+
+  def invoke(name, *args)
+    Open3.capture3(
+      Shellwords.join(
+        [
+          RbConfig.ruby,
+          '--disable',
+          'gems',
+          '--disable',
+          'did_you_mean',
+          '--disable',
+          'rubyopt',
+          File.expand_path("../apps/#{name}", __dir__)
+        ] + args
+      )
+    )
+  end
+end

data/test/mini-cli/main_test.rb

@@ -1,16 +1,34 @@
+# frozen_string_literal: true
+
 require_relative '../helper'
 
 class MainTest < Test
   def test_defaults
     assert_equal('helper', subject.name)
+    assert(subject.show_errors?)
     assert_output("Usage: helper\n") { subject.show_help }
   end
 
   def test_methods
     subject = Class.new { include MiniCli }.new
 
-    expected_methods = %i[error help main name parse_argv run show_help].sort!
-    methods = (subject.methods - Object.new.methods).sort!
+    expected_methods = %i[
+      after
+      before
+      error
+      error_code
+      help
+      main
+      name
+      parse_argv
+      run
+      run_ruby
+      run_script
+      show_errors=
+      show_errors?
+      show_help
+    ]
+    methods = (subject.methods - Object.instance_methods).sort!
     assert_equal(expected_methods, methods)
   end
 
@@ -22,6 +40,13 @@ class MainTest < Test
     assert_stop_with_error(21, 'error') { subject.error(21, :error) }
   end
 
+  def test_no_error
+    subject.show_errors = false
+
+    assert_output(nil, nil) { subject.error(666, 'some error text') }
+    assert_equal([666], subject.exit_args)
+  end
+
   def test_help_simple
     subject.help 'Some helptext'
     expected_text = <<~EXPECTED
@@ -156,4 +181,13 @@ class MainTest < Test
     result = subject.parse_argv(as_argv('-nup name port in out opt file'))
     assert_equal(expected, result)
   end
+
+  def test_run
+    call_sequence = []
+    subject.main { call_sequence << :main }
+    subject.before { call_sequence << :start_1 }
+    subject.after { call_sequence << :end_1 }
+    subject.before { call_sequence << :start_2 }
+    subject.after { call_sequence << :end_2 }
+  end
 end

data/test/mini-cli/ruby_run_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../helper'
+
+class RubyRunTest < Test
+  def test_simple
+    result = subject.run_script('puts("Hello World")')
+    assert_equal("Hello World\n", result)
+  end
+
+  def test_error
+    result = subject.run_script('UNDEFINED')
+    assert_match(/NameError/, result)
+  end
+
+  def test_chdir
+    home = Dir.home
+    refute(home == Dir.pwd)
+    result = subject.run_script('print Dir.pwd', chdir: home)
+    assert_equal(home, result)
+  end
+
+  def test_status
+    status, result = subject.run_script('print :Ok', status: true)
+    assert_instance_of(Process::Status, status)
+    assert(status.success?)
+    assert_equal('Ok', result)
+  end
+
+  def test_status_error
+    status, result = subject.run_script('print :Err;exit 42', status: true)
+    assert_instance_of(Process::Status, status)
+    refute(status.success?)
+    assert_same(42, status.exitstatus)
+    assert_equal('Err', result)
+  end
+
+  def test_stream
+    stream = StringIO.new('puts "Hello World"')
+    result = subject.run_script(stream)
+    assert_equal("Hello World\n", result)
+  end
+end

data/test/mini-cli/run_test.rb

@@ -1,44 +1,49 @@
+# frozen_string_literal: true
+
 require_relative '../helper'
 
 class RunTest < Test
-  def setup
-    super
-    @pwd = Dir.pwd + "\n"
+  def test_simple
+    result = subject.run('pwd')
+    assert_equal("#{Dir.pwd}\n", result)
   end
 
-  def test_std_out_only
-    out = subject.run('pwd')
-    assert_equal(@pwd, out)
+  def test_simple_error
+    result = subject.run('ls /no-valid-dir')
+    assert_match(/No such file or directory/, result)
+  end
 
-    out = subject.run('pwd', stdout: true)
-    assert_equal(@pwd, out)
+  def test_chdir
+    home = Dir.home
+    refute(home == Dir.pwd)
+    result = subject.run('pwd', chdir: home)
+    assert_equal("#{home}\n", result)
   end
 
   def test_status
-    result = subject.run('pwd', stdout: false)
-    assert_instance_of(TrueClass, result)
-
-    status = subject.run('pwd', status: true)
-    assert_instance_of(Process::Status, status)
-
-    out, status = subject.run('pwd', stdout: true, status: true)
-    assert_equal(@pwd, out)
+    status, result = subject.run('pwd', status: true)
     assert_instance_of(Process::Status, status)
     assert(status.success?)
+    assert_equal("#{Dir.pwd}\n", result)
   end
 
-  def test_std_error
-    err = subject.run('ls /no-valid-dir', stderr: true)
-    assert_match(/No such file or directory/, err)
-
-    out, err = subject.run('ls /no-valid-dir', stdout: true, stderr: true)
-    assert_empty(out)
-    assert_match(/No such file or directory/, err)
-
-    err, status = subject.run('ls /no-valid-dir', stderr: true, status: true)
-    assert_match(/No such file or directory/, err)
+  def test_status_error
+    status, result = subject.run('ls /no-valid-dir', status: true)
     assert_instance_of(Process::Status, status)
     refute(status.success?)
+    assert_match(/No such file or directory/, result)
+  end
+
+  def test_stdin
+    string = 'Hello World'
+    result = subject.run('cat', stdin_data: string)
+    assert_equal(string, result)
+  end
+
+  def test_stdin_stream
+    stream = StringIO.new('Hello World')
+    result = subject.run('cat', stdin_data: stream)
+    assert_equal(stream.string, result)
   end
 
   def test_failure

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini-cli
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.5.1
 platform: ruby
 authors:
 - Mike Blumtritt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-19 00:00:00.000000000 Z
+date: 2021-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -68,13 +68,18 @@ files:
 - lib/mini-cli.rb
 - lib/mini-cli/run.rb
 - lib/mini-cli/version.rb
+- lib/mini_cli.rb
 - mini-cli.gemspec
 - rakefile.rb
 - samples/custom_args.rb
 - samples/demo.rb
 - samples/simple.rb
+- test/apps/noop.rb
+- test/apps/sequence.rb
 - test/helper.rb
+- test/mini-cli/exec_test.rb
 - test/mini-cli/main_test.rb
+- test/mini-cli/ruby_run_test.rb
 - test/mini-cli/run_test.rb
 homepage: https://github.com/mblumtritt/mini-cli
 licenses: []
@@ -96,11 +101,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.15
 signing_key:
 specification_version: 4
 summary: The lean CLI framework for Ruby
 test_files:
+- test/apps/noop.rb
+- test/apps/sequence.rb
 - test/helper.rb
+- test/mini-cli/exec_test.rb
 - test/mini-cli/main_test.rb
+- test/mini-cli/ruby_run_test.rb
 - test/mini-cli/run_test.rb