mixlib-cli 1.7.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 3a5fa5c9380ff647b7d3fa3be1bff7e2103c9f94
-  data.tar.gz: d384bc4569b4577a90bc20d06d9d2f9b5564178d
+SHA256:
+  metadata.gz: eaf15af5ae6bced46dfe59d89fa37cd935573375fad4982bd1661815c1bdb9a6
+  data.tar.gz: c8ef97ee9a2236e29c3bcd7a6cafaf8564bfa5526972d582b7f4f5dc84305a83
 SHA512:
-  metadata.gz: ea74cdb6f6afc9758a24a143c0d1702423e87a3fcce4749c61e3c83da4b289967a47a1473513b8f695a9d2e66d0aad188f1fdf1f6aae91648e4ce30f5c33b6ea
-  data.tar.gz: 62421ca5582e801d8e3112bbef7e55f16cdff8bf77c5520f7539bffa36e7602644ef2ac4aaee2733dda90db95156d58e06dfd2e7d0e1ddfae6856704b5c5b323
+  metadata.gz: d5d534599c887330bff589b7909b8f89199baa33f557363742b29ffe93a5b3d6bb036efa179ef1b3a4dbfb2391115e8152115bfe48619a1ac037dc4d69532dd8
+  data.tar.gz: d17c1d596c0aec0fdf3e53b7e8f7d7380a34872a8f16ae0cd680725b712ec22b0e77607b45dfa98b9948464c5e793e34a1db43c31d6c13c8b4311bd8d3da1054

data/Gemfile

@@ -1,3 +1,28 @@
 source "https://rubygems.org"
 
 gemspec
+
+group :docs do
+  gem "yard"
+  gem "redcarpet"
+  gem "github-markup"
+end
+
+group :test do
+  gem "chefstyle", git: "https://github.com/chef/chefstyle.git", branch: "master"
+  gem "rspec", "~> 3.0"
+  gem "rake"
+end
+
+group :development do
+  gem "pry"
+  gem "pry-byebug"
+  gem "pry-stack_explorer"
+  gem "rb-readline"
+end
+
+instance_eval(ENV["GEMFILE_MOD"]) if ENV["GEMFILE_MOD"]
+
+# If you want to load debugging tools into the bundle exec sandbox,
+# add these additional dependencies into Gemfile.local
+eval_gemfile(__FILE__ + ".local") if File.exist?(__FILE__ + ".local")

data/NOTICE

@@ -4,7 +4,7 @@ Mixin::CLI NOTICE
 Developed at Chef (http://www.chef.io).
 
 
- * Copyright 2009-2016, Chef Software, Inc. <legal@chef.io>
+ * Copyright 2009-2018, Chef Software, Inc. <legal@chef.io>
 
 Mixin::CLI incorporates code from Chef.  The Chef notice file follows:
 

data/README.md

@@ -5,34 +5,33 @@
 Mixlib::CLI provides a class-based command line option parsing object, like the one used in Chef, Ohai and Relish. To use in your project:
 
 ```ruby
-require 'rubygems'
-require 'mixlib/cli'
+require "mixlib/cli"
 
 class MyCLI
   include Mixlib::CLI
 
   option :config_file,
-    :short => "-c CONFIG",
-    :long  => "--config CONFIG",
-    :default => 'config.rb',
-    :description => "The configuration file to use"
+    short: "-c CONFIG",
+    long: "--config CONFIG",
+    default: "config.rb",
+    description: "The configuration file to use"
 
   option :log_level,
-    :short => "-l LEVEL",
-    :long  => "--log_level LEVEL",
-    :description => "Set the log level (debug, info, warn, error, fatal)",
-    :required => true,
-    :in => ['debug', 'info', 'warn', 'error', 'fatal'],
-    :proc => Proc.new { |l| l.to_sym }
+    short: "-l LEVEL",
+    long: "--log_level LEVEL",
+    description: "Set the log level (debug, info, warn, error, fatal)",
+    required: true,
+    in: [:debug, :info, :warn, :error, :fatal],
+    proc: Proc.new { |l| l.to_sym }
 
   option :help,
-    :short => "-h",
-    :long => "--help",
-    :description => "Show this message",
-    :on => :tail,
-    :boolean => true,
-    :show_options => true,
-    :exit => 0
+    short: "-h",
+    long: "--help",
+    description: "Show this message",
+    on: :tail,
+    boolean: true,
+    show_options: true,
+    exit: 0
 
 end
 
@@ -54,7 +53,7 @@ class MyConfig
 end
 
 class MyCLI
-  def run(argv=ARGV)
+  def run(argv = ARGV)
     parse_options(argv)
     MyConfig.merge!(config)
   end
@@ -69,10 +68,10 @@ MyConfig[:log_level] # :debug
 Available arguments to 'option':
 
 - `:short`: The short option, just like from optparse. Example: "-l LEVEL"
-- `:long`: The long option, just like from optparse.  Example: "--level LEVEL"
+- `:long`: The long option, just like from optparse. Example: "--level LEVEL"
 - `:description`: The description for this item, just like from optparse.
 - `:default`: A default value for this option
-- `:required`: Prints a message informing the user of the missing requirement, and exits.  Default is false.
+- `:required`: Prints a message informing the user of the missing requirement, and exits. Default is false.
 - `:on`: Set to :tail to appear at the end, or `:head`: to appear at the top.
 - `:boolean:`: If this option takes no arguments, set this to true.
 - `:show_options`: If you want the option list printed when this option is called, set this to true.
@@ -89,9 +88,21 @@ cli.parse_options
 cli.cli_arguments # [ 'file1', 'file2', 'file3' ]
 ```
 
-## LICENSE:
+## Documentation
 
-- Copyright:: Copyright (c) 2008-2016 Chef Software, Inc.
+All documentation is written using YARD. You can generate a by running:
+
+```
+rake docs
+```
+
+## Contributing
+
+For information on contributing to this project please see our [Contributing Documentation](https://github.com/chef/chef/blob/master/CONTRIBUTING.md)
+
+## License & Copyright
+
+- Copyright:: Copyright (c) 2008-2018 Chef Software, Inc.
 - License:: Apache License, Version 2.0
 
 ```text

data/Rakefile

@@ -1,27 +1,15 @@
-require "bundler"
-require "rubygems"
-require "rubygems/package_task"
-require "rdoc/task"
+require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
-Bundler::GemHelper.install_tasks
+task default: [:style, :spec]
 
-task :default => :spec
+Bundler::GemHelper.install_tasks
 
 desc "Run specs"
 RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = "spec/**/*_spec.rb"
 end
 
-gem_spec = eval(File.read("mixlib-cli.gemspec"))
-
-RDoc::Task.new do |rdoc|
-  rdoc.rdoc_dir = "rdoc"
-  rdoc.title = "mixlib-cli #{gem_spec.version}"
-  rdoc.rdoc_files.include("README*")
-  rdoc.rdoc_files.include("lib/**/*.rb")
-end
-
 begin
   require "chefstyle"
   require "rubocop/rake_task"
@@ -29,5 +17,20 @@ begin
     task.options += ["--display-cop-names", "--no-color"]
   end
 rescue LoadError
-  puts "chefstyle/rubocop is not available.  gem install chefstyle to do style checking."
+  puts "chefstyle/rubocop is not available. bundle install first to make sure all dependencies are installed."
+end
+
+begin
+  require "yard"
+  YARD::Rake::YardocTask.new(:docs)
+rescue LoadError
+  puts "yard is not available. bundle install first to make sure all dependencies are installed."
+end
+
+task :console do
+  require "irb"
+  require "irb/completion"
+  require "mixlib/cli"
+  ARGV.clear
+  IRB.start
 end

data/lib/mixlib/cli.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Adam Jacob (<adam@chef.io>)
+# Copyright:: Copyright (c) 2008-2016 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -41,7 +41,7 @@ module Mixlib
 
     module InheritMethods
       def inherited(receiver)
-        receiver.options = deep_dup(self.options)
+        receiver.options = deep_dup(options)
         receiver.extend(Mixlib::CLI::InheritMethods)
       end
 
@@ -210,7 +210,7 @@ module Mixlib
         config_opts[:exit] ||= nil
         config_opts[:in] ||= nil
 
-        if config_opts.has_key?(:default)
+        if config_opts.key?(:default)
           defaults_container[config_key] = config_opts[:default]
         end
       end
@@ -231,7 +231,7 @@ module Mixlib
 
       # Deal with any required values
       options.each do |opt_key, opt_value|
-        if opt_value[:required] && !config.has_key?(opt_key)
+        if opt_value[:required] && !config.key?(opt_key)
           reqarg = opt_value[:short] || opt_value[:long]
           puts "You must supply #{reqarg}!"
           puts @opt_parser
@@ -241,7 +241,7 @@ module Mixlib
           unless opt_value[:in].kind_of?(Array)
             raise(ArgumentError, "Options config key :in must receive an Array")
           end
-          if !opt_value[:in].include?(config[opt_key])
+          if config[opt_key] && !opt_value[:in].include?(config[opt_key])
             reqarg = opt_value[:short] || opt_value[:long]
             puts "#{reqarg}: #{config[opt_key]} is not included in the list ['#{opt_value[:in].join("', '")}'] "
             puts @opt_parser
@@ -308,12 +308,13 @@ module Mixlib
     def build_option_arguments(opt_setting)
       arguments = Array.new
 
-      arguments << opt_setting[:short] if opt_setting.has_key?(:short)
-      arguments << opt_setting[:long] if opt_setting.has_key?(:long)
-      if opt_setting.has_key?(:description)
-        description = opt_setting[:description]
+      arguments << opt_setting[:short] if opt_setting.key?(:short)
+      arguments << opt_setting[:long] if opt_setting.key?(:long)
+      if opt_setting.key?(:description)
+        description = opt_setting[:description].dup
         description << " (required)" if opt_setting[:required]
         description << " (included in ['#{opt_setting[:in].join("', '")}'])" if opt_setting[:in]
+        opt_setting[:description] = description
         arguments << description
       end
 

data/lib/mixlib/cli/version.rb

@@ -1,5 +1,5 @@
 module Mixlib
   module CLI
-    VERSION = "1.7.0"
+    VERSION = "2.0.0".freeze
   end
 end

data/mixlib-cli.gemspec

@@ -4,8 +4,6 @@ require "mixlib/cli/version"
 Gem::Specification.new do |s|
   s.name = "mixlib-cli"
   s.version = Mixlib::CLI::VERSION
-  s.platform = Gem::Platform::RUBY
-  s.has_rdoc = true
   s.extra_rdoc_files = ["README.md", "LICENSE", "NOTICE"]
   s.summary = "A simple mixin for CLI interfaces, including option parsing"
   s.description = s.summary
@@ -13,13 +11,7 @@ Gem::Specification.new do |s|
   s.email = "info@chef.io"
   s.homepage = "https://www.chef.io"
   s.license = "Apache-2.0"
-
-  # Uncomment this to add a dependency
-  #s.add_dependency "mixlib-log"
-  s.add_development_dependency "rake", "< 11.0"
-  s.add_development_dependency "rspec", "~> 2.14"
-  s.add_development_dependency "rdoc"
-  s.add_development_dependency "chefstyle", "~> 0.3"
+  s.required_ruby_version = ">= 2.5"
 
   s.require_path = "lib"
   s.files = %w{LICENSE README.md Gemfile Rakefile NOTICE} + Dir.glob("*.gemspec") +

data/spec/mixlib/cli_spec.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Adam Jacob (<adam@chef.io>)
+# Copyright:: Copyright (c) 2008-2016 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -26,33 +26,33 @@ describe Mixlib::CLI do
 
   describe "class method" do
     describe "option" do
-      it "should allow you to set a config option with a hash" do
-        TestCLI.option(:config_file, :short => "-c CONFIG").should == { :short => "-c CONFIG" }
+      it "allows you to set a config option with a hash" do
+        expect(TestCLI.option(:config_file, short: "-c CONFIG")).to eql({ short: "-c CONFIG" })
       end
     end
 
     describe "options" do
-      it "should return the current options hash" do
-        TestCLI.option(:config_file, :short => "-c CONFIG")
-        TestCLI.options.should == { :config_file => { :short => "-c CONFIG" } }
+      it "returns the current options hash" do
+        TestCLI.option(:config_file, short: "-c CONFIG")
+        expect(TestCLI.options).to eql({ config_file: { short: "-c CONFIG" } })
       end
     end
 
     describe "options=" do
-      it "should allow you to set the full options with a single hash" do
-        TestCLI.options = { :config_file => { :short => "-c CONFIG" } }
-        TestCLI.options.should == { :config_file => { :short => "-c CONFIG" } }
+      it "allows you to set the full options with a single hash" do
+        TestCLI.options = { config_file: { short: "-c CONFIG" } }
+        expect(TestCLI.options).to eql({ config_file: { short: "-c CONFIG" } })
       end
     end
 
     describe "banner" do
-      it "should have a default value" do
-        TestCLI.banner.should =~ /^Usage: (.+) \(options\)$/
+      it "has a default value" do
+        expect(TestCLI.banner).to match(/^Usage: (.+) \(options\)$/)
       end
 
-      it "should allow you to set the banner" do
+      it "allows you to set the banner" do
         TestCLI.banner("Usage: foo")
-        TestCLI.banner.should == "Usage: foo"
+        expect(TestCLI.banner).to eql("Usage: foo")
       end
     end
   end
@@ -64,189 +64,209 @@ describe Mixlib::CLI do
     end
 
     describe "initialize" do
-      it "should set the banner to the class defined banner" do
-        @cli.banner.should == TestCLI.banner
+      it "sets the banner to the class defined banner" do
+        expect(@cli.banner).to eql(TestCLI.banner)
       end
 
-      it "should set the options to the class defined options, plus defaults" do
-        TestCLI.option(:config_file, :short => "-l LOG")
+      it "sets the options to the class defined options, plus defaults" do
+        TestCLI.option(:config_file, short: "-l LOG")
         cli = TestCLI.new
-        cli.options.should == {
-          :config_file => {
-            :short => "-l LOG",
-            :on => :on,
-            :boolean => false,
-            :required => false,
-            :proc => nil,
-            :show_options => false,
-            :exit => nil,
-            :in => nil,
+        expect(cli.options).to eql({
+          config_file: {
+            short: "-l LOG",
+            on: :on,
+            boolean: false,
+            required: false,
+            proc: nil,
+            show_options: false,
+            exit: nil,
+            in: nil,
           },
-        }
+        })
       end
 
-      it "should set the default config value for any options that include it" do
-        TestCLI.option(:config_file, :short => "-l LOG", :default => :debug)
+      it "sets the default config value for any options that include it" do
+        TestCLI.option(:config_file, short: "-l LOG", default: :debug)
         @cli = TestCLI.new
-        @cli.config[:config_file].should == :debug
+        expect(@cli.config[:config_file]).to eql(:debug)
       end
     end
 
     describe "opt_parser" do
 
-      it "should set the banner in opt_parse" do
-        @cli.opt_parser.banner.should == @cli.banner
+      it "sets the banner in opt_parse" do
+        expect(@cli.opt_parser.banner).to eql(@cli.banner)
       end
 
-      it "should present the arguments in the banner" do
-        TestCLI.option(:config_file, :short => "-l LOG")
+      it "presents the arguments in the banner" do
+        TestCLI.option(:config_file, short: "-l LOG")
         @cli = TestCLI.new
-        @cli.opt_parser.to_s.should =~ /-l LOG/
+        expect(@cli.opt_parser.to_s).to match(/-l LOG/)
       end
 
-      it "should honor :on => :tail options in the banner" do
-        TestCLI.option(:config_file, :short => "-l LOG")
-        TestCLI.option(:help, :short => "-h", :boolean => true, :on => :tail)
+      it "honors :on => :tail options in the banner" do
+        TestCLI.option(:config_file, short: "-l LOG")
+        TestCLI.option(:help, short: "-h", boolean: true, on: :tail)
         @cli = TestCLI.new
-        @cli.opt_parser.to_s.split("\n").last.should =~ /-h/
+        expect(@cli.opt_parser.to_s.split("\n").last).to match(/-h/)
       end
 
-      it "should honor :on => :head options in the banner" do
-        TestCLI.option(:config_file, :short => "-l LOG")
-        TestCLI.option(:help, :short => "-h", :boolean => true, :on => :head)
+      it "honors :on => :head options in the banner" do
+        TestCLI.option(:config_file, short: "-l LOG")
+        TestCLI.option(:help, short: "-h", boolean: true, on: :head)
         @cli = TestCLI.new
-        @cli.opt_parser.to_s.split("\n")[1].should =~ /-h/
+        expect(@cli.opt_parser.to_s.split("\n")[1]).to match(/-h/)
       end
 
-      it "should present the arguments in alphabetical order in the banner" do
-        TestCLI.option(:alpha, :short => "-a ALPHA")
-        TestCLI.option(:beta, :short => "-b BETA")
-        TestCLI.option(:zeta, :short => "-z ZETA")
+      it "presents the arguments in alphabetical order in the banner" do
+        TestCLI.option(:alpha, short: "-a ALPHA")
+        TestCLI.option(:beta, short: "-b BETA")
+        TestCLI.option(:zeta, short: "-z ZETA")
         @cli = TestCLI.new
         output_lines = @cli.opt_parser.to_s.split("\n")
-        output_lines[1].should =~ /-a ALPHA/
-        output_lines[2].should =~ /-b BETA/
-        output_lines[3].should =~ /-z ZETA/
+        expect(output_lines[1]).to match(/-a ALPHA/)
+        expect(output_lines[2]).to match(/-b BETA/)
+        expect(output_lines[3]).to match(/-z ZETA/)
       end
 
     end
 
     describe "parse_options" do
-      it "should set the corresponding config value for non-boolean arguments" do
-        TestCLI.option(:config_file, :short => "-c CONFIG")
+      it "sets the corresponding config value for non-boolean arguments" do
+        TestCLI.option(:config_file, short: "-c CONFIG")
         @cli = TestCLI.new
         @cli.parse_options([ "-c", "foo.rb" ])
-        @cli.config[:config_file].should == "foo.rb"
+        expect(@cli.config[:config_file]).to eql("foo.rb")
       end
 
-      it "should set the corresponding config value according to a supplied proc" do
+      it "sets the corresponding config value according to a supplied proc" do
         TestCLI.option(:number,
-          :short => "-n NUMBER",
-          :proc => Proc.new { |config| config.to_i + 2 }
+          short: "-n NUMBER",
+          proc: Proc.new { |config| config.to_i + 2 }
         )
         @cli = TestCLI.new
         @cli.parse_options([ "-n", "2" ])
-        @cli.config[:number].should == 4
+        expect(@cli.config[:number]).to eql(4)
       end
 
-      it "should pass the existing value to two-argument procs" do
+      it "passes the existing value to two-argument procs" do
         TestCLI.option(:number,
-          :short => "-n NUMBER",
-          :proc => Proc.new { |value, existing| existing ||= []; existing << value; existing }
+          short: "-n NUMBER",
+          proc: Proc.new { |value, existing| existing ||= []; existing << value; existing }
         )
         @cli = TestCLI.new
         @cli.parse_options([ "-n", "2", "-n", "3" ])
-        @cli.config[:number].should == %w{2 3}
+        expect(@cli.config[:number]).to eql(%w{2 3})
       end
 
-      it "should set the corresponding config value to true for boolean arguments" do
-        TestCLI.option(:i_am_boolean, :short => "-i", :boolean => true)
+      it "sets the corresponding config value to true for boolean arguments" do
+        TestCLI.option(:i_am_boolean, short: "-i", boolean: true)
         @cli = TestCLI.new
         @cli.parse_options([ "-i" ])
-        @cli.config[:i_am_boolean].should == true
+        expect(@cli.config[:i_am_boolean]).to be true
       end
 
-      it "should set the corresponding config value to false when a boolean is prefixed with --no" do
-        TestCLI.option(:i_am_boolean, :long => "--[no-]bool", :boolean => true)
+      it "sets the corresponding config value to false when a boolean is prefixed with --no" do
+        TestCLI.option(:i_am_boolean, long: "--[no-]bool", boolean: true)
         @cli = TestCLI.new
         @cli.parse_options([ "--no-bool" ])
-        @cli.config[:i_am_boolean].should == false
+        expect(@cli.config[:i_am_boolean]).to be false
       end
 
-      it "should exit if a config option has :exit set" do
-        TestCLI.option(:i_am_exit, :short => "-x", :boolean => true, :exit => 0)
+      it "exits if a config option has :exit set" do
+        TestCLI.option(:i_am_exit, short: "-x", boolean: true, exit: 0)
         @cli = TestCLI.new
-        lambda { @cli.parse_options(["-x"]) }.should raise_error(SystemExit)
+        expect(lambda { @cli.parse_options(["-x"]) }).to raise_error(SystemExit)
       end
 
-      it "should exit if a required option is missing" do
-        TestCLI.option(:require_me, :short => "-r", :boolean => true, :required => true)
+      it "exits if a required option is missing" do
+        TestCLI.option(:require_me, short: "-r", boolean: true, required: true)
         @cli = TestCLI.new
-        lambda { @cli.parse_options([]) }.should raise_error(SystemExit)
+        expect(lambda { @cli.parse_options([]) }).to raise_error(SystemExit)
       end
 
-      it "should exit if option is not included in the list" do
-        TestCLI.option(:inclusion, :short => "-i val", :in => %w{one two})
+      it "exits if option is not included in the list and required" do
+        TestCLI.option(:inclusion, short: "-i val", in: %w{one two}, required: true)
         @cli = TestCLI.new
-        lambda { @cli.parse_options(["-i", "three"]) }.should raise_error(SystemExit)
+        expect(lambda { @cli.parse_options(["-i", "three"]) }).to raise_error(SystemExit)
       end
 
-      it "should raise ArgumentError if options key :in is not an array" do
-        TestCLI.option(:inclusion, :short => "-i val", :in => "foo")
+      it "exits if option is not included in the list and not required" do
+        TestCLI.option(:inclusion, short: "-i val", in: %w{one two}, required: false)
         @cli = TestCLI.new
-        lambda { @cli.parse_options(["-i", "three"]) }.should raise_error(ArgumentError)
+        expect(lambda { @cli.parse_options(["-i", "three"]) }).to raise_error(SystemExit)
       end
 
-      it "should not exit if option is included in the list" do
-        TestCLI.option(:inclusion, :short => "-i val", :in => %w{one two})
+      it "doesn't exit if option is nil and not required" do
+        TestCLI.option(:inclusion, short: "-i val", in: %w{one two}, required: false)
+        @cli = TestCLI.new
+        expect do
+          expect(@cli.parse_options([])).to eql []
+        end.to_not raise_error
+      end
+
+      it "exit if option is nil and required" do
+        TestCLI.option(:inclusion, short: "-i val", in: %w{one two}, required: true)
+        @cli = TestCLI.new
+        expect(lambda { @cli.parse_options([]) }).to raise_error(SystemExit)
+      end
+
+      it "raises ArgumentError if options key :in is not an array" do
+        TestCLI.option(:inclusion, short: "-i val", in: "foo", required: true)
+        @cli = TestCLI.new
+        expect(lambda { @cli.parse_options(["-i", "three"]) }).to raise_error(ArgumentError)
+      end
+
+      it "doesn't exit if option is included in the list" do
+        TestCLI.option(:inclusion, short: "-i val", in: %w{one two}, required: true)
         @cli = TestCLI.new
         @cli.parse_options(["-i", "one"])
-        @cli.config[:inclusion].should == "one"
+        expect(@cli.config[:inclusion]).to eql("one")
       end
 
-      it "should change description if :in key is specified" do
-        TestCLI.option(:inclusion, :short => "-i val", :in => %w{one two}, :description => "desc")
+      it "changes description if :in key is specified" do
+        TestCLI.option(:inclusion, short: "-i val", in: %w{one two}, description: "desc", required: false)
         @cli = TestCLI.new
         @cli.parse_options(["-i", "one"])
-        @cli.options[:inclusion][:description].should == "desc (included in ['one', 'two'])"
+        expect(@cli.options[:inclusion][:description]).to eql("desc (included in ['one', 'two'])")
       end
 
-      it "should not exit if a required option is specified" do
-        TestCLI.option(:require_me, :short => "-r", :boolean => true, :required => true)
+      it "doesn't exit if a required option is specified" do
+        TestCLI.option(:require_me, short: "-r", boolean: true, required: true)
         @cli = TestCLI.new
         @cli.parse_options(["-r"])
-        @cli.config[:require_me].should == true
+        expect(@cli.config[:require_me]).to be true
       end
 
-      it "should not exit if a required boolean option is specified and false" do
-        TestCLI.option(:require_me, :long => "--[no-]req", :boolean => true, :required => true)
+      it "doesn't exit if a required boolean option is specified and false" do
+        TestCLI.option(:require_me, long: "--[no-]req", boolean: true, required: true)
         @cli = TestCLI.new
         @cli.parse_options(["--no-req"])
-        @cli.config[:require_me].should == false
+        expect(@cli.config[:require_me]).to be false
       end
 
-      it "should not exit if a required option is specified and empty" do
-        TestCLI.option(:require_me, :short => "-r VALUE", :required => true)
+      it "doesn't exit if a required option is specified and empty" do
+        TestCLI.option(:require_me, short: "-r VALUE", required: true)
         @cli = TestCLI.new
         @cli.parse_options(["-r", ""])
-        @cli.config[:require_me].should == ""
+        expect(@cli.config[:require_me]).to eql("")
       end
 
-      it "should preserve all of the commandline arguments, ARGV" do
-        TestCLI.option(:config_file, :short => "-c CONFIG")
+      it "preserves all of the commandline arguments, ARGV" do
+        TestCLI.option(:config_file, short: "-c CONFIG")
         @cli = TestCLI.new
         argv_old = ARGV.dup
         ARGV.replace ["-c", "foo.rb"]
         @cli.parse_options()
-        ARGV.should == ["-c", "foo.rb"]
+        expect(ARGV).to eql(["-c", "foo.rb"])
         ARGV.replace argv_old
       end
 
-      it "should preserve and return any un-parsed elements" do
-        TestCLI.option(:party, :short => "-p LOCATION")
+      it "preserves and return any un-parsed elements" do
+        TestCLI.option(:party, short: "-p LOCATION")
         @cli = TestCLI.new
-        @cli.parse_options([ "easy", "-p", "opscode", "hard" ]).should == %w{easy hard}
-        @cli.cli_arguments.should == %w{easy hard}
+        expect(@cli.parse_options([ "easy", "-p", "opscode", "hard" ])).to eql(%w{easy hard})
+        expect(@cli.cli_arguments).to eql(%w{easy hard})
       end
     end
   end
@@ -254,68 +274,68 @@ describe Mixlib::CLI do
   context "when configured to separate default options" do
     before do
       TestCLI.use_separate_default_options true
-      TestCLI.option(:defaulter, :short => "-D SOMETHING", :default => "this is the default")
+      TestCLI.option(:defaulter, short: "-D SOMETHING", default: "this is the default")
       @cli = TestCLI.new
     end
 
     it "sets default values on the `default` hash" do
       @cli.parse_options([])
-      @cli.default_config[:defaulter].should == "this is the default"
-      @cli.config[:defaulter].should be_nil
+      expect(@cli.default_config[:defaulter]).to eql("this is the default")
+      expect(@cli.config[:defaulter]).to be_nil
     end
 
     it "sets parsed values on the `config` hash" do
       @cli.parse_options(%w{-D not-default})
-      @cli.default_config[:defaulter].should == "this is the default"
-      @cli.config[:defaulter].should == "not-default"
+      expect(@cli.default_config[:defaulter]).to eql("this is the default")
+      expect(@cli.config[:defaulter]).to eql("not-default")
     end
 
   end
 
   context "when subclassed" do
     before do
-      TestCLI.options = { :arg1 => { :boolean => true } }
+      TestCLI.options = { arg1: { boolean: true } }
     end
 
-    it "should retain previously defined options from parent" do
+    it "retains previously defined options from parent" do
       class T1 < TestCLI
-        option :arg2, :boolean => true
+        option :arg2, boolean: true
       end
-      T1.options[:arg1].should be_a(Hash)
-      T1.options[:arg2].should be_a(Hash)
-      TestCLI.options[:arg2].should be_nil
+      expect(T1.options[:arg1]).to be_a(Hash)
+      expect(T1.options[:arg2]).to be_a(Hash)
+      expect(TestCLI.options[:arg2]).to be_nil
     end
 
-    it "should not be able to modify parent classes options" do
+    it "isn't able to modify parent classes options" do
       class T2 < TestCLI
-        option :arg2, :boolean => true
+        option :arg2, boolean: true
       end
       T2.options[:arg1][:boolean] = false
-      T2.options[:arg1][:boolean].should be_false
-      TestCLI.options[:arg1][:boolean].should be_true
+      expect(T2.options[:arg1][:boolean]).to be false
+      expect(TestCLI.options[:arg1][:boolean]).to be true
     end
 
-    it "should pass its options onto child" do
+    it "passes its options onto child" do
       class T3 < TestCLI
-        option :arg2, :boolean => true
+        option :arg2, boolean: true
       end
       class T4 < T3
-        option :arg3, :boolean => true
+        option :arg3, boolean: true
       end
       3.times do |i|
-        T4.options["arg#{i + 1}".to_sym].should be_a(Hash)
+        expect(T4.options["arg#{i + 1}".to_sym]).to be_a(Hash)
       end
     end
 
-    it "should also work with an option that's an array" do
+    it "also works with an option that's an array" do
       class T5 < TestCLI
-        option :arg2, :default => []
+        option :arg2, default: []
       end
 
       class T6 < T5
       end
 
-      T6.options[:arg2].should be_a(Hash)
+      expect(T6.options[:arg2]).to be_a(Hash)
     end
 
   end

data/spec/spec_helper.rb

@@ -8,8 +8,19 @@ class TestCLI
 end
 
 RSpec.configure do |config|
-  config.filter_run :focus => true
+  # Use documentation format
+  config.formatter = "doc"
+
+  # Use color in STDOUT
+  config.color = true
+
+  # Use color not only in STDOUT but also in pagers and files
+  config.tty = true
+
+  # run the examples in random order
+  config.order = :rand
+
+  config.filter_run focus: true
   config.run_all_when_everything_filtered = true
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.warnings = true
 end

metadata

@@ -1,71 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: mixlib-cli
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Chef Software, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-06 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '11.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '11.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.14'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.14'
-- !ruby/object:Gem::Dependency
-  name: rdoc
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: chefstyle
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
+date: 2019-01-04 00:00:00.000000000 Z
+dependencies: []
 description: A simple mixin for CLI interfaces, including option parsing
 email: info@chef.io
 executables: []
@@ -97,7 +41,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -105,7 +49,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: A simple mixin for CLI interfaces, including option parsing