command_kit 0.2.0 → 0.2.1

data/spec/options_spec.rb

@@ -133,5 +133,287 @@ describe CommandKit::Options do
     it "must initialize #options" do
       expect(subject.options).to eq({})
     end
+
+    context "when options have default values" do
+      module TestOptions
+        class TestCommandWithDefaultValues
+
+          include CommandKit::Options
+
+          option :option1, value: {
+                             required: true,
+                             type: String
+                           },
+                           desc: 'Option 1'
+
+          option :option2, value: {
+                             required: false,
+                             type: String,
+                             default: "foo"
+                           },
+                           desc: 'Option 2'
+        end
+      end
+
+      let(:command_class) { TestOptions::TestCommandWithDefaultValues }
+
+      it "must pre-populate #options with the default values" do
+        expect(subject.options).to_not have_key(:option1)
+        expect(subject.options).to have_key(:option2)
+        expect(subject.options[:option2]).to eq("foo")
+      end
+    end
+  end
+
+  module TestOptions
+    class TestCommandWithOptionsAndArguments
+
+      include CommandKit::Options
+
+      usage '[OPTIONS] ARG1 [ARG2]'
+
+      option :option1, short: '-a',
+                       value: {
+                         type: Integer,
+                         default: 1
+                       },
+                       desc: "Option 1"
+
+      option :option2, short: '-b',
+                       value: {
+                         type: String,
+                         usage: 'FILE'
+                       },
+                       desc: "Option 2"
+
+      argument :argument1, required: true,
+                           usage:    'ARG1',
+                           desc:     "Argument 1"
+
+      argument :argument2, required: false,
+                           usage:    'ARG2',
+                           desc:     "Argument 2"
+
+    end
+  end
+
+  describe "#option_parser" do
+    context "when an option does not accept a value" do
+      module TestOptions
+        class TestCommandWithOptionWithoutValue
+
+          include CommandKit::Options
+
+          option :opt, desc: "Option without a value"
+
+        end
+      end
+
+      let(:command_class) { TestOptions::TestCommandWithOptionWithoutValue }
+
+      context "but the option flag was not given" do
+        let(:argv) { [] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must not populate #options with a value" do
+          expect(subject.options).to be_empty
+        end
+      end
+
+      context "and the option flag was given" do
+        let(:argv) { %w[--opt] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must set a key in #options to true" do
+          expect(subject.options[:opt]).to be(true)
+        end
+      end
+    end
+
+    context "when an option requires a value" do
+      module TestOptions
+        class TestCommandWithOptionWithRequiredValue
+
+          include CommandKit::Options
+
+          option :opt, value: {
+                         required: true,
+                         type: String
+                       },
+                       desc: "Option without a value"
+
+        end
+      end
+
+      let(:command_class) do
+        TestOptions::TestCommandWithOptionWithRequiredValue
+      end
+
+      context "but the option flag was not given" do
+        let(:argv) { [] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must not populate #options with a value" do
+          expect(subject.options).to be_empty
+        end
+      end
+
+      context "and the option flag and value were given" do
+        let(:value) { 'foo'            }
+        let(:argv)  { ['--opt', value] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must set a key in #options to the value" do
+          expect(subject.options[:opt]).to eq(value)
+        end
+      end
+    end
+
+    context "when an option does not require a value" do
+      module TestOptions
+        class TestCommandWithOptionWithOptionalValue
+
+          include CommandKit::Options
+
+          option :opt, value: {
+                         required: false,
+                         type: String
+                       },
+                       desc: "Option without a value"
+
+        end
+      end
+
+      let(:command_class) do
+        TestOptions::TestCommandWithOptionWithOptionalValue
+      end
+
+      context "but the option flag was not given" do
+        let(:argv) { [] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must not populate #options with a value" do
+          expect(subject.options).to be_empty
+        end
+      end
+
+      context "and the option flag and value were given" do
+        let(:value) { 'foo'            }
+        let(:argv)  { ['--opt', value] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must set a key in #options to the value" do
+          expect(subject.options[:opt]).to eq(value)
+        end
+      end
+
+      context "and the option has a default value" do
+        module TestOptions
+          class TestCommandWithOptionWithOptionalValueAndDefaultValue
+
+            include CommandKit::Options
+
+            option :opt, value: {
+                           required: false,
+                           type: String,
+                           default: "bar"
+                         },
+                         desc: "Option without a value"
+
+          end
+        end
+
+        let(:command_class) do
+          TestOptions::TestCommandWithOptionWithOptionalValueAndDefaultValue
+        end
+
+        context "but the option flag was not given" do
+          let(:argv) { [] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must set a key in #options to the default value" do
+            expect(subject.options[:opt]).to eq("bar")
+          end
+        end
+
+        context "and the option flag and value were given" do
+          let(:value) { 'foo'            }
+          let(:argv)  { ['--opt', value] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must set a key in #options to the value" do
+            expect(subject.options[:opt]).to eq(value)
+          end
+        end
+
+        context "and the option flag but not the value are given" do
+          let(:argv)  { ['--opt'] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must set a key in #options to nil" do
+            expect(subject.options).to have_key(:opt)
+            expect(subject.options[:opt]).to be(nil)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#main" do
+    let(:command_class) { TestOptions::TestCommandWithOptionsAndArguments }
+
+    let(:argv) { %w[-a 42 -b foo.txt arg1 arg2] }
+
+    it "must parse options before validating the number of arguments" do
+      expect {
+        expect(subject.main(argv)).to eq(0)
+      }.to_not output.to_stderr
+    end
+
+    context "but the wrong number of arguments are given" do
+      let(:argv) { %w[-a 42 -b foo.txt] }
+
+      it "must still validate the number of arguments" do
+        expect {
+          expect(subject.main(argv)).to eq(1)
+        }.to output("#{subject.command_name}: insufficient number of arguments.#{$/}").to_stderr
+      end
+    end
+  end
+
+  describe "#help" do
+    let(:command_class) { TestOptions::TestCommandWithOptionsAndArguments }
+
+    let(:option1)   { command_class.options[:option1]     }
+    let(:option2)   { command_class.options[:option2]     }
+    let(:argument1) { command_class.arguments[:argument1] }
+    let(:argument2) { command_class.arguments[:argument2] }
+
+    it "must print the usage, options and arguments" do
+      expect { subject.help }.to output(
+        [
+          "Usage: #{subject.usage}",
+          '',
+          'Options:',
+          "    #{option1.usage.join(', ').ljust(33 - 1)} #{option1.desc}",
+          "    #{option2.usage.join(', ').ljust(33 - 1)} #{option2.desc}",
+          '    -h, --help                       Print help information',
+          '',
+          "Arguments:",
+          "    #{argument1.usage.ljust(33)}#{argument1.desc}",
+          "    #{argument2.usage.ljust(33)}#{argument2.desc}",
+          ''
+        ].join($/)
+      ).to_stdout
+    end
   end
 end

data/spec/os/linux_spec.rb

@@ -83,70 +83,80 @@ describe CommandKit::OS::Linux do
   end
 
   describe "#redhat_linux?" do
+    subject { command_class.new(linux_distro: linux_distro) }
+
     context "when #linux_distro is :redhat" do
-      subject { command_class.new(linux_distro: :redhat) }
+      let(:linux_distro) { :redhat }
 
       it { expect(subject.redhat_linux?).to be(true) }
     end
 
     context "when #linux_distro is not :redhat" do
-      subject { command_class.new(linux_distro: :debian) }
+      let(:linux_distro) { :debian }
 
       it { expect(subject.redhat_linux?).to be(false) }
     end
   end
 
   describe "#fedora_linux?" do
+    subject { command_class.new(linux_distro: linux_distro) }
+
     context "when #linux_distro is :fedora" do
-      subject { command_class.new(linux_distro: :fedora) }
+      let(:linux_distro) { :fedora }
 
       it { expect(subject.fedora_linux?).to be(true) }
     end
 
     context "when #linux_distro is not :fedora" do
-      subject { command_class.new(linux_distro: :debian) }
+      let(:linux_distro) { :debian }
 
       it { expect(subject.fedora_linux?).to be(false) }
     end
   end
 
   describe "#debian_linux?" do
+    subject { command_class.new(linux_distro: linux_distro) }
+
     context "when #linux_distro is :debian" do
-      subject { command_class.new(linux_distro: :debian) }
+      let(:linux_distro) { :debian }
 
       it { expect(subject.debian_linux?).to be(true) }
     end
 
     context "when #linux_distro is not :fedora" do
-      subject { command_class.new(linux_distro: :redhat) }
+      let(:linux_distro) { :redhat }
 
       it { expect(subject.debian_linux?).to be(false) }
     end
   end
 
   describe "#suse_linux?" do
+    subject { command_class.new(linux_distro: linux_distro) }
+
     context "when #linux_distro is :suse" do
-      subject { command_class.new(linux_distro: :suse) }
+      let(:linux_distro) { :suse }
 
       it { expect(subject.suse_linux?).to be(true) }
     end
 
     context "when #linux_distro is not :suse" do
-      subject { command_class.new(linux_distro: :debian) }
+      let(:linux_distro) { :debian }
 
       it { expect(subject.suse_linux?).to be(false) }
     end
   end
 
   describe "#arch_linux?" do
+    subject { command_class.new(linux_distro: linux_distro) }
+
     context "when #linux_distro is :arch" do
-      subject { command_class.new(linux_distro: :arch) }
+      let(:linux_distro) { :arch }
 
       it { expect(subject.arch_linux?).to be(true) }
     end
 
     context "when #linux_distro is not :arch" do
-      subject { command_class.new(linux_distro: :debian) }
+      let(:linux_distro) { :debian }
 
       it { expect(subject.arch_linux?).to be(false) }
     end

data/spec/pager_spec.rb

@@ -170,7 +170,7 @@ describe CommandKit::Pager do
 
       context "and when given a String and additional arguments" do
         let(:command)   { 'find'          }
-        let(:arguments) { %[. -name *.md] }
+        let(:arguments) { %w[. -name *.md] }
 
         let(:escaped_command) do
           Shellwords.shelljoin([command,*arguments])
@@ -192,7 +192,7 @@ describe CommandKit::Pager do
       end
 
       let(:command)   { 'find' }
-      let(:arguments) { %[. -name *.md] }
+      let(:arguments) { %w[. -name *.md] }
 
       it "must pass the command and any additional arguments to #system" do
         expect(subject).to receive(:system).with(command,*arguments)

data/spec/printing/indent_spec.rb

@@ -12,14 +12,16 @@ describe CommandKit::Printing::Indent do
   subject { command_class.new }
 
   describe "#initialize" do
-    it "must initialize @indent to 0" do
-      expect(subject.instance_variable_get('@indent')).to eq(0)
+    it "must initialize #indent to 0" do
+      expect(subject.indent).to eq(0)
     end
 
     context "when the class has a superclass" do
       module TestIndent
         class TestSuperCommand
 
+          attr_reader :var
+
           def initialize(var: 'default')
             @var = var
           end
@@ -36,11 +38,11 @@ describe CommandKit::Printing::Indent do
       let(:command_class) { TestIndent::TestSubCommand }
 
       it "must initialize @indent to 0" do
-        expect(subject.instance_variable_get('@indent')).to eq(0)
+        expect(subject.indent).to eq(0)
       end
 
       it "must call super()" do
-        expect(subject.instance_variable_get('@var')).to eq('default')
+        expect(subject.var).to eq('default')
       end
 
       context "and additional keyword arguments are given" do
@@ -49,7 +51,7 @@ describe CommandKit::Printing::Indent do
         subject { command_class.new(var: var) }
 
         it "must call super() with the additional keyword arguments" do
-          expect(subject.instance_variable_get('@var')).to eq(var)
+          expect(subject.var).to eq(var)
         end
       end
     end

data/spec/printing_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'command_kit/printing'
+require 'command_kit/command_name'
 
 require 'stringio'
 
@@ -34,11 +35,32 @@ describe CommandKit::Printing do
   describe "#print_error" do
     let(:message) { "oh no!" }
 
-    it "must print a line to stderr" do
+    it "must print the error message to stderr" do
       expect {
         subject.print_error(message)
       }.to output("#{message}#{nl}").to_stderr
     end
+
+    context "and when CommandKit::CommandName is included" do
+      module TestPrinting
+        class TestCmdWithCommandName
+
+          include CommandKit::CommandName
+          include CommandKit::Printing
+
+          command_name 'foo'
+
+        end
+      end
+
+      let(:command_class) { TestPrinting::TestCmdWithCommandName }
+
+      it "must print the command_name and the error message" do
+        expect {
+          subject.print_error(message)
+        }.to output("#{subject.command_name}: #{message}#{nl}").to_stderr
+      end
+    end
   end
 
   describe "#print_exception" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: command_kit
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Postmodern
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-31 00:00:00.000000000 Z
+date: 2021-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -153,6 +153,7 @@ metadata:
   source_code_uri: https://github.com/postmodern/command_kit.rb
   bug_tracker_uri: https://github.com/postmodern/command_kit.rb/issues
   changelog_uri: https://github.com/postmodern/command_kit.rb/blob/main/ChangeLog.md
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths: