mini-cli 0.1.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b99c5619db31b2250da1515981cf62e897939e57399e72b44c3b48d22d4c9840
-  data.tar.gz: 9ea02f0d1077a03ca5284ef20619a9c38370d9bcece25ba106e0b834733660c1
+  metadata.gz: b366ee44d4b95a00a977cbfdcf3e7cc7aff2cc1d3f72c03e0df2c2858aaf22e8
+  data.tar.gz: 8a622678016ca76e554a6b80d40dbea7dd7d6db5a494b5d7dd83944e68d66921
 SHA512:
-  metadata.gz: 5877c7746653b3999ec6337e86e108276f26ba9a2142bdee0892033491cce2f788ee8dea594742cc5fb0554a1496923dfe5b80eba03409e9b6b4c4f2255d2d7d
-  data.tar.gz: 7c7d1e36a5dd1ae1f139826ad9063e68e38a864416744e383e3e308fb8d172ab6efc58c26c5e4875422884deb6e2fa820ec10cc7371d028fcdfa53b6e06523ba
+  metadata.gz: 73a9bee03f689d2f1e7334b6b927ba8cd45efb8422729c1abe93bf9062e26de47886ff0e70dc518ed01eeab7330e8777cd25a2c6fa270d6f16d32c0979de8d8d
+  data.tar.gz: cf6679d1245593b36ab18481ea4c83a14da4953cf41e6e849b92951a5dc5301c3603ef42476fe1cab0995d008b5356233f50dc2135f9f3d2530c5a61683560cd

data/gems.rb

@@ -1 +1,2 @@
+source 'https://rubygems.org'
 gemspec

data/lib/mini-cli.rb

@@ -1,162 +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,46 @@
 # frozen_string_literal: true
 
-require 'open3'
-
 module MiniCli
-  def run(*cmd)
-    opts = Hash === cmd.last ? __run_opt(cmd.last) : [: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
+
+  RUBY_CMD =
+    %w[--disable gems --disable did_you_mean --disable rubyopt].unshift(
+      RbConfig.ruby
+    ).freeze
+
+  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
 end

data/lib/mini-cli/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MiniCli
-  VERSION = '0.1.1'
+  VERSION = '0.5.0'
 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

@@ -11,21 +11,21 @@ help <<~HELP, %w[TARGET [SOURCE]]
       --opt        option without any argument
 HELP
 
-main do |cfg|
-  cfg.each_pair{ |key, value| puts("#{key}: #{value}") }
-end
+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']
-    # args['FILES'] is an array containing all surplus arguments
-    cfg.sources = args['FILES']
-    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/samples/simple.rb

@@ -9,6 +9,4 @@ help <<~HELP
   This is a very simple sample without any required parameter.
 HELP
 
-main do |args|
-  puts("given files: #{args['FILES']}")
-end
+main { |args| puts("given files: #{args['FILES']}") }

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/helper.rb

@@ -11,14 +11,15 @@ class Test < Minitest::Test
   attr_reader :subject
 
   def setup
-    @subject = Class.new do
-      include MiniCli
-      attr_reader :exit_args
+    @subject =
+      Class.new do
+        include MiniCli
+        attr_reader :exit_args
 
-      def exit(*args)
-        @exit_args = args
-      end
-    end.new
+        def exit(*args)
+          @exit_args = args
+        end
+      end.new
   end
 
   def assert_stop_with_error(code, text, &block)

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,24 +1,34 @@
+# frozen_string_literal: true
+
 require_relative '../helper'
 
 class MainTest < Test
   def test_defaults
     assert_equal('helper', subject.name)
-    assert_output("Usage: helper\n"){ subject.show_help }
+    assert(subject.show_errors?)
+    assert_output("Usage: helper\n") { subject.show_help }
   end
 
   def test_methods
-    subject = Class.new{ include MiniCli }.new
+    subject = Class.new { include MiniCli }.new
 
     expected_methods = %i[
+      after
+      before
       error
+      error_code
       help
       main
       name
       parse_argv
       run
+      run_ruby
+      run_script
+      show_errors=
+      show_errors?
       show_help
-    ].sort!
-    methods = (subject.methods - Object.new.methods).sort!
+    ]
+    methods = (subject.methods - Object.instance_methods).sort!
     assert_equal(expected_methods, methods)
   end
 
@@ -27,9 +37,14 @@ class MainTest < Test
       subject.error(42, 'some error text')
     end
 
-    assert_stop_with_error(21, 'error') do
-      subject.error(21, :error)
-    end
+    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
@@ -39,7 +54,7 @@ class MainTest < Test
       Some helptext
     EXPECTED
 
-    assert_output(expected_text){ subject.show_help }
+    assert_output(expected_text) { subject.show_help }
   end
 
   def test_help_with_args
@@ -54,7 +69,7 @@ class MainTest < Test
       here
     EXPECTED
 
-    assert_output(expected_text){ subject.show_help }
+    assert_output(expected_text) { subject.show_help }
   end
 
   def test_argument_required
@@ -64,10 +79,10 @@ class MainTest < Test
       subject.parse_argv(as_argv(''))
     end
 
-    expected = {'ARG' => 'arg', 'FILES' => []}
+    expected = { 'ARG' => 'arg', 'FILES' => [] }
     assert_equal(expected, subject.parse_argv(as_argv('arg')))
 
-    expected = {'ARG' => 'arg1', 'FILES' => %w[arg2 arg3]}
+    expected = { 'ARG' => 'arg1', 'FILES' => %w[arg2 arg3] }
     assert_equal(expected, subject.parse_argv(as_argv('arg1 arg2 arg3')))
   end
 
@@ -83,10 +98,10 @@ class MainTest < Test
       subject.parse_argv(as_argv(''))
     end
 
-    expected = {'ARG1' => 'arg1', 'ARG2' => 'arg2', 'FILES' => []}
+    expected = { 'ARG1' => 'arg1', 'ARG2' => 'arg2', 'FILES' => [] }
     assert_equal(expected, subject.parse_argv(as_argv('arg1 arg2')))
 
-    expected = {'ARG1' => 'arg', 'FILES' => []}
+    expected = { 'ARG1' => 'arg', 'FILES' => [] }
     assert_equal(expected, subject.parse_argv(as_argv('arg')))
   end
 
@@ -100,21 +115,21 @@ class MainTest < Test
       Some additional explaination can be here
     HELP
 
-    expected = {'FILES' => []}
+    expected = { 'FILES' => [] }
     assert_equal(expected, subject.parse_argv(as_argv('')))
 
-    expected = {'NAME' => 'name', 'FILES' => []}
+    expected = { 'NAME' => 'name', 'FILES' => [] }
     assert_equal(expected, subject.parse_argv(as_argv('--named name')))
     assert_equal(expected, subject.parse_argv(as_argv('-n name')))
 
-    expected = {'LNAME' => 'long', 'FILES' => []}
+    expected = { 'LNAME' => 'long', 'FILES' => [] }
     assert_equal(expected, subject.parse_argv(as_argv('--named-long long')))
 
-    expected = {'unnamed' => true, 'FILES' => []}
+    expected = { 'unnamed' => true, 'FILES' => [] }
     assert_equal(expected, subject.parse_argv(as_argv('--unnamed')))
     assert_equal(expected, subject.parse_argv(as_argv('-u')))
 
-    expected = {'un-named' => true, 'FILES' => []}
+    expected = { 'un-named' => true, 'FILES' => [] }
     assert_equal(expected, subject.parse_argv(as_argv('--un-named')))
 
     expected = {
@@ -125,23 +140,14 @@ class MainTest < Test
       'FILES' => %w[FILE1 FILE2]
     }
 
-    result = subject.parse_argv(%w[
-      --named name
-      --named-long long
-      --unnamed
-      --un-named
-      FILE1
-      FILE2
-    ])
+    result =
+      subject.parse_argv(
+        %w[--named name --named-long long --unnamed --un-named FILE1 FILE2]
+      )
     assert_equal(expected, result)
 
-    result = subject.parse_argv(%w[
-      -nu name
-      --named-long long
-      --un-named
-      FILE1
-      FILE2
-    ])
+    result =
+      subject.parse_argv(%w[-nu name --named-long long --un-named FILE1 FILE2])
     assert_equal(expected, result)
   end
 
@@ -175,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.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Mike Blumtritt
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-03-09 00:00:00.000000000 Z
+date: 2021-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -56,10 +56,11 @@ description: |
   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.
-email: 
+email:
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- README.md
 files:
 - ".gitignore"
 - README.md
@@ -67,20 +68,25 @@ 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: []
 metadata:
   source_code_uri: https://github.com/mblumtritt/mini-cli
   bug_tracker_uri: https://github.com/mblumtritt/mini-cli/issues
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -95,11 +101,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+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