command_kit 0.2.0 → 0.2.1

data/spec/command_spec.rb

@@ -26,14 +26,14 @@ describe CommandKit::Command do
     expect(described_class).to include(CommandKit::Usage)
   end
 
-  it "must include CommandKit::Arguments" do
-    expect(described_class).to include(CommandKit::Arguments)
-  end
-
   it "must include CommandKit::Options" do
     expect(described_class).to include(CommandKit::Options)
   end
 
+  it "must include CommandKit::Arguments" do
+    expect(described_class).to include(CommandKit::Arguments)
+  end
+
   it "must include CommandKit::Examples" do
     expect(described_class).to include(CommandKit::Examples)
   end
@@ -49,4 +49,75 @@ describe CommandKit::Command do
   it "must include FileUtils" do
     expect(described_class).to include(FileUtils)
   end
+
+  module TestCommandClass
+    class TestCommand < CommandKit::Command
+
+      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"
+
+      examples [
+        '-a 42 foo/bar/baz',
+        '-a 42 -b bar.txt baz qux'
+      ]
+
+      description 'Example command'
+
+    end
+  end
+
+  let(:command_class) { TestCommandClass::TestCommand }
+  subject { command_class.new }
+
+  describe "#help" do
+    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, arguments, examples, and description" 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}",
+          '',
+          "Examples:",
+          "    #{subject.command_name} #{command_class.examples[0]}",
+          "    #{subject.command_name} #{command_class.examples[1]}",
+          '',
+          command_class.description,
+          ''
+        ].join($/)
+      ).to_stdout
+    end
+  end
 end

data/spec/commands/auto_load_spec.rb

@@ -54,16 +54,27 @@ describe CommandKit::Commands::AutoLoad do
   end
 
   module TestAutoLoad
-    class CLI
+    class TestCommand
       include CommandKit::Commands
       include CommandKit::Commands::AutoLoad.new(
         dir:       File.expand_path('../fixtures/test_auto_load/cli/commands',__FILE__),
         namespace: "#{self}::Commands"
       )
     end
+
+    class TestCommandWithBlock
+      include CommandKit::Commands
+      include(CommandKit::Commands::AutoLoad.new(
+        dir:       File.expand_path('../fixtures/test_auto_load/cli/commands',__FILE__),
+        namespace: "#{self}::Commands"
+      ) { |autoload|
+        autoload.command 'test-1', 'Test1', 'test1.rb', aliases: %w[test_1]
+        autoload.command 'test-2', 'Test2', 'test2.rb', aliases: %w[test_2]
+      })
+    end
   end
 
-  let(:command_class)   { TestAutoLoad::CLI }
+  let(:command_class)   { TestAutoLoad::TestCommand }
   let(:autoload_module) { command_class.included_modules.first }
 
   describe "#included" do
@@ -76,6 +87,26 @@ describe CommandKit::Commands::AutoLoad do
     it "must merge the module's #commands into the class'es #commands" do
       expect(command_class.commands).to include(autoload_module.commands)
     end
+
+    context "when CommandKit::Commands::AutoLoad has an explicit mapping" do
+      let(:command_class) { TestAutoLoad::TestCommandWithBlock }
+
+      it "must merge the module's #commands into the class'es #commands" do
+        expect(command_class.commands).to include(autoload_module.commands)
+      end
+
+      it "must also merge the any aliases into the class'es #command_aliases" do
+        expected_command_aliases = {}
+
+        autoload_module.commands.each do |name,subcommand|
+          subcommand.aliases.each do |alias_name|
+            expected_command_aliases[alias_name] = name
+          end
+        end
+
+        expect(command_class.command_aliases).to include(expected_command_aliases)
+      end
+    end
   end
 
   describe "#join" do

data/spec/commands_spec.rb

@@ -126,6 +126,33 @@ describe CommandKit::Commands do
       command Test2
 
     end
+
+    class TestCommandsWithCommandArguments
+
+      include CommandKit::Commands
+
+      class Test1 < CommandKit::Command
+        argument :arg1, required: false,
+                        desc: 'Argument 1'
+
+        argument :arg2, required: false,
+                        desc: 'Argument 2'
+      end
+
+      class Test2 < CommandKit::Command
+        argument :arg1, required: false,
+                        desc: 'Argument 1'
+
+        argument :arg2, required: false,
+                        desc: 'Argument 2'
+      end
+
+      p method(:command).source_location
+      command Test1
+      command Test2
+
+    end
+
   end
 
   let(:command_class) { TestCommands::TestCommands }
@@ -569,7 +596,7 @@ describe CommandKit::Commands do
       expect(subject).to receive(:exit).with(1)
 
       expect { subject.command_not_found(unknown_command) }.to output(
-        "'#{unknown_command}' is not a #{subject.command_name} command. See `#{subject.command_name} help`" + $/
+        "#{subject.command_name}: '#{unknown_command}' is not a #{subject.command_name} command. See `#{subject.command_name} help`" + $/
       ).to_stderr
     end
   end
@@ -582,6 +609,44 @@ describe CommandKit::Commands do
     end
   end
 
+  describe "#option_parser" do
+    let(:command_name) { 'test1'     }
+    let(:command_argv) { %w[foo bar baz] }
+    let(:argv) { [command_name, *command_argv] }
+
+    it "must stop before the first non-option argument" do
+      expect(subject.option_parser.parse(argv)).to eq(
+        [command_name, *command_argv]
+      )
+    end
+
+    context "when an unknown command name is given" do
+      let(:command_argv) { %w[bar baz] }
+      let(:argv) { ['foo', command_name, *command_argv] }
+
+      it "must stop before the first non-option argument" do
+        expect(subject.option_parser.parse(argv)).to eq(argv)
+      end
+    end
+
+    context "when additional global options are defined" do
+      let(:command_class) { TestCommands::TestCommandsWithGlobalOptions }
+      let(:bar) { '2' }
+      let(:argv) do
+        ['--foo', '--bar', bar.to_s, command_name, *command_argv]
+      end
+
+      it "must parse the global options, but stop before the first non-option associated argument" do
+        expect(subject.option_parser.parse(argv)).to eq(
+          [command_name, *command_argv]
+        )
+
+        expect(subject.options[:foo]).to be(true)
+        expect(subject.options[:bar]).to eq(bar)
+      end
+    end
+  end
+
   describe "#run" do
     context "when a command name is the first argument" do
       let(:command) { 'test1' }
@@ -607,48 +672,45 @@ describe CommandKit::Commands do
     end
 
     context "when given no arguments" do
-      it "must default to calling #help" do
+      let(:exit_status) { 1 }
+
+      it "must default to calling #help and exit with 1" do
         expect(subject).to receive(:help)
+        expect(subject).to receive(:exit).with(exit_status)
 
         subject.run()
       end
     end
   end
 
-  describe "#option_parser" do
-    let(:command_name) { 'test1'     }
-    let(:command_argv) { %w[foo bar baz] }
-    let(:argv) { [command_name, *command_argv] }
+  describe "#main" do
+    let(:command_class) { TestCommands::TestCommandsWithCommandArguments }
 
-    it "must stop before the first non-option argument" do
-      expect(subject.option_parser.parse(argv)).to eq(
-        [command_name, *command_argv]
-      )
+    context "when a command name is the first argument" do
+      let(:command) { 'test1'   }
+      let(:argv)    { [command] }
+
+      it "must return 0" do
+        expect(subject.main(argv)).to eq(0)
+      end
     end
 
-    context "when an unknown command name is given" do
-      let(:command_argv) { %w[bar baz] }
-      let(:argv) { ['foo', command_name, *command_argv] }
+    context "when given additional command arguments" do
+      let(:argv) { %w[test1 arg1 arg2] }
 
-      it "must stop before the first non-option argument" do
-        expect(subject.option_parser.parse(argv)).to eq(argv)
+      it "must pass them to the command" do
+        expect(subject.main(argv)).to eq(0)
       end
     end
 
-    context "when additional global options are defined" do
-      let(:command_class) { TestCommands::TestCommandsWithGlobalOptions }
-      let(:bar) { '2' }
-      let(:argv) do
-        ['--foo', '--bar', bar.to_s, command_name, *command_argv]
-      end
+    context "when given no arguments" do
+      let(:exit_status) { 1 }
+      let(:argv)        { %w[] }
 
-      it "must parse the global options, but stop before the first non-option associated argument" do
-        expect(subject.option_parser.parse(argv)).to eq(
-          [command_name, *command_argv]
-        )
+      it "must call #help and return 1" do
+        expect(subject).to receive(:help)
 
-        expect(subject.options[:foo]).to be(true)
-        expect(subject.options[:bar]).to eq(bar)
+        expect(subject.main(argv)).to eq(exit_status)
       end
     end
   end
@@ -711,6 +773,10 @@ describe CommandKit::Commands do
           "Options:",
           "    -h, --help                       Print help information",
           "",
+          "Arguments:",
+          "    [COMMAND]                        The command name to run",
+          "    [ARGS ...]                       Additional arguments for the command",
+          "",
           "Commands:",
           "    help",
           "    test1",
@@ -731,6 +797,10 @@ describe CommandKit::Commands do
             "Options:",
             "    -h, --help                       Print help information",
             "",
+            "Arguments:",
+            "    [COMMAND]                        The command name to run",
+            "    [ARGS ...]                       Additional arguments for the command",
+            "",
             "Commands:",
             "    help",
             "    test1, t1",
@@ -754,6 +824,10 @@ describe CommandKit::Commands do
             "    -b, --bar BAR                    Global --bar option",
             "    -h, --help                       Print help information",
             "",
+            "Arguments:",
+            "    [COMMAND]                        The command name to run",
+            "    [ARGS ...]                       Additional arguments for the command",
+            "",
             "Commands:",
             "    help",
             "    test1",

data/spec/env/path_spec.rb

@@ -13,6 +13,12 @@ describe CommandKit::Env::Path do
   let(:command_class) { TestEnvPath::TestCommand }
   subject { command_class.new }
 
+  describe ".included" do
+    it "must include CommandKit::Env" do
+      expect(command_class).to be_include(CommandKit::Env)
+    end
+  end
+
   describe "#initialize" do
     it "must split ENV['PATH'] into an Array of directories" do
       expect(subject.path_dirs).to eq(ENV['PATH'].split(File::PATH_SEPARATOR))

data/spec/help/man_spec.rb

@@ -16,7 +16,13 @@ describe CommandKit::Help::Man do
       man_page 'foo.1'
     end
 
-    class EmptyCommand
+    class TestCommandWithRelativeManDir
+      include CommandKit::Help::Man
+
+      man_dir File.join(__dir__,'..','..','..','man')
+    end
+
+    class TestCommandWithManDirNotSet
       include CommandKit::Help::Man
     end
   end
@@ -41,7 +47,7 @@ describe CommandKit::Help::Man do
 
   describe ".man_dir" do
     context "when no man_dir have been set" do
-      subject { TestHelpMan::EmptyCommand }
+      subject { TestHelpMan::TestCommandWithManDirNotSet }
 
       it "should default to nil" do
         expect(subject.man_dir).to be_nil
@@ -52,7 +58,17 @@ describe CommandKit::Help::Man do
       subject { TestHelpMan::TestCommand }
 
       it "must return the explicitly set man_dir" do
-        expect(subject.man_dir).to eq(File.expand_path('../fixtures/man',__FILE__))
+        expect(subject.man_dir).to eq(File.join(__dir__,'fixtures','man'))
+      end
+
+      context "but it's a relative path" do
+        subject { TestHelpMan::TestCommandWithRelativeManDir }
+
+        it "must expand the given man_dir path" do
+          expect(subject.man_dir).to eq(
+            File.expand_path(File.join(__dir__,'..','..','..','man'))
+          )
+        end
       end
     end
 
@@ -96,7 +112,7 @@ describe CommandKit::Help::Man do
         end
 
         it "must not change the superclass'es man_dir" do
-          expect(super_subject.man_dir).to eq('set/in/baseclass')
+          expect(super_subject.man_dir).to eq(File.expand_path('set/in/baseclass'))
         end
       end
 
@@ -115,7 +131,7 @@ describe CommandKit::Help::Man do
         subject { TestHelpMan::ExplicitInheritedCmd }
 
         it "must return the subclass'es man_dir" do
-          expect(subject.man_dir).to eq('set/in/subclass')
+          expect(subject.man_dir).to eq(File.expand_path('set/in/subclass'))
         end
 
         it "must not change the superclass'es man_dir" do
@@ -134,11 +150,11 @@ describe CommandKit::Help::Man do
         subject { TestHelpMan::ExplicitOverridingInheritedCmd }
 
         it "must return the subclass'es man_dir" do
-          expect(subject.man_dir).to eq('set/in/subclass')
+          expect(subject.man_dir).to eq(File.expand_path('set/in/subclass'))
         end
 
         it "must not change the superclass'es man_dir" do
-          expect(super_subject.man_dir).to eq('set/in/baseclass')
+          expect(super_subject.man_dir).to eq(File.expand_path('set/in/baseclass'))
         end
       end
     end
@@ -235,15 +251,6 @@ describe CommandKit::Help::Man do
   subject { command_class.new }
 
   describe "#help_man" do
-    context "when .man_dir is not set" do
-      let(:command_class) { TestHelpMan::EmptyCommand }
-      subject { command_class.new }
-
-      it do
-        expect { subject.help_man }.to raise_error(NotImplementedError)
-      end
-    end
-
     let(:man_page_path) do
       File.join(subject.class.man_dir,subject.class.man_page)
     end
@@ -286,21 +293,33 @@ describe CommandKit::Help::Man do
         expect(subject.stdout).to receive(:tty?).and_return(true)
       end
 
-      it "must open the command's man-page" do
-        expect(subject).to receive(:help_man).and_return(true)
+      context "and man_dir is set" do
+        it "must open the command's man-page" do
+          expect(subject).to receive(:help_man).and_return(true)
 
-        subject.help
-      end
+          subject.help
+        end
 
-      context "but when the man command is not installed" do
-        before do
-          expect(subject).to receive(:help_man).and_return(nil)
+        context "but when the man command is not installed" do
+          before do
+            expect(subject).to receive(:help_man).and_return(nil)
+          end
+
+          it "must call the super help() method" do
+            subject.help
+
+            expect(subject.stdout.string).to eq(normal_help_output)
+          end
         end
+      end
+
+      context "but the man_dir is not set" do
+        let(:command_class) { TestHelpMan::TestCommandWithManDirNotSet }
 
-        it "must call the super help() method" do
+        it "must call the super help() mehtod" do
           subject.help
 
-          expect(subject.stdout.string).to eq(normal_help_output)
+          expect(stdout.string).to eq(normal_help_output)
         end
       end
     end

data/spec/options/option_value_spec.rb

@@ -7,6 +7,61 @@ describe CommandKit::Options::OptionValue do
   let(:required) { true }
   let(:default)  { 1 }
 
+  describe ".default_usage" do
+    subject { described_class }
+
+    context "when given a Hash" do
+      let(:type) do
+        {'foo' => :foo, "bar" => :bar}
+      end
+
+      it "must join the Hash's keys with a '|' character" do
+        expect(subject.default_usage(type)).to eq(type.keys.join('|'))
+      end
+    end
+
+    context "when given an Array" do
+      let(:type) do
+        ['foo', 'bar', 'baz']
+      end
+
+      it "must join the Array's elements with a '|' character" do
+        expect(subject.default_usage(type)).to eq(type.join('|'))
+      end
+    end
+
+    context "when given a Regexp" do
+      let(:type) { /[0-9a-f]+/ }
+
+      it "must return the Regexp's source" do
+        expect(subject.default_usage(type)).to eq(type.source)
+      end
+    end
+
+    context "when given a Class" do
+      module TestOptionValue
+        class FooBarBaz
+        end
+      end
+
+      let(:type) { TestOptionValue::FooBarBaz }
+
+      it "must return the uppercase and underscored version of it's name" do
+        expect(subject.default_usage(type)).to eq("FOO_BAR_BAZ")
+      end
+    end
+
+    context "when given another kind of Object" do
+      let(:type) { Object.new }
+
+      it do
+        expect {
+          subject.default_usage(type)
+        }.to raise_error(TypeError,"unsupported option type: #{type.inspect}")
+      end
+    end
+  end
+
   describe "#initialize" do
     context "when the type: keyword is given" do
       let(:type) { Integer }