command_kit 0.1.0 → 0.3.0

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

@@ -19,7 +19,6 @@ describe CommandKit::Commands do
       class Test2 < CommandKit::Command
       end
 
-      p method(:command).source_location
       command Test1
       command Test2
 
@@ -126,6 +125,32 @@ 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
+
+      command Test1
+      command Test2
+
+    end
+
   end
 
   let(:command_class) { TestCommands::TestCommands }
@@ -191,7 +216,7 @@ describe CommandKit::Commands do
       it "must contain the mapping of aliases to command names" do
       expect(subject.command_aliases).to eq({
         't1' => 'test1',
-        't2' => 'test2',
+        't2' => 'test2'
       })
       end
     end
@@ -569,7 +594,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 +607,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 +670,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 +771,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 +795,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 +822,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/exception_handler_spec.rb

@@ -73,7 +73,7 @@ describe CommandKit::ExceptionHandler do
           include CommandKit::ExceptionHandler
 
           def run
-            raise(RuntimeError.new("error"))
+            raise("error")
           end
 
         end

data/spec/file_utils_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'command_kit/file_utils'
+require 'tempfile'
+
+describe CommandKit::FileUtils do
+  module TestFileUtils
+    class Command
+      include CommandKit::FileUtils
+
+      attr_reader :var
+
+      def initialize(var: nil)
+        super()
+
+        @var = var
+      end
+
+      def test_method
+        'some method'
+      end
+    end
+  end
+
+  let(:var) { 42 }
+
+  let(:command_class) { TestFileUtils::Command }
+  subject { command_class.new(var: var) }
+
+  let(:fixtures_dir)  { File.expand_path(File.join(__dir__,'fixtures')) }
+  let(:template_path) { File.join(fixtures_dir,'template.erb') }
+
+  describe "#erb" do
+    let(:expected_result) do
+      [
+        "Raw text",
+        '',
+        "variable = #{var}",
+        '',
+        "method = #{subject.test_method}"
+      ].join($/)
+    end
+
+    context "when only given a source file argument" do
+      it "must render the erb template and return the result" do
+        expect(subject.erb(template_path)).to eq(expected_result)
+      end
+    end
+
+    context "when given an additional destination file argument" do
+      let(:dest_path) { Tempfile.new.path }
+
+      before { subject.erb(template_path,dest_path) }
+
+      it "must render the erb template and write the result to the destination" do
+        expect(File.read(dest_path)).to eq(expected_result)
+      end
+    end
+  end
+end

data/spec/fixtures/template.erb

@@ -0,0 +1,5 @@
+Raw text
+
+variable = <%= @var %>
+
+method = <%= test_method -%>

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
@@ -234,48 +250,7 @@ describe CommandKit::Help::Man do
 
   subject { command_class.new }
 
-  describe "#man" do
-    let(:man_page) { 'foo' }
-
-    it "must call system() with the given man page" do
-      expect(subject).to receive(:system).with('man',man_page)
-
-      subject.man(man_page)
-    end
-
-    context "when given a non-String man-page argument" do
-      let(:man_page_arg) { double(:non_string_arg) }
-
-      it "must call #to_s on the man-page argument" do
-        expect(man_page_arg).to receive(:to_s).and_return(man_page)
-
-        expect(subject).to receive(:system).with('man',man_page)
-
-        subject.man(man_page_arg)
-      end
-    end
-
-    context "when given the section: keyword argument" do
-      let(:section) { 7 }
-
-      it "must call system() with the given section number and man page" do
-        expect(subject).to receive(:system).with('man',section.to_s,man_page)
-
-        subject.man(man_page, section: section)
-      end
-    end
-  end
-
   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
@@ -296,6 +271,16 @@ describe CommandKit::Help::Man do
         subject.help_man(man_page)
       end
     end
+
+    context "but the man_dir is not set" do
+      let(:command_class) { TestHelpMan::TestCommandWithManDirNotSet }
+
+      it "must call the super help() mehtod" do
+        expect {
+          subject.help_man
+        }.to raise_error(NotImplementedError,"man_dir was not set in #{command_class}")
+      end
+    end
   end
 
   describe "#help" do
@@ -318,21 +303,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)
+          end
+
+          it "must call the super help() method" do
+            subject.help
 
-      context "but when the man command is not installed" do
-        before do
-          expect(subject).to receive(:help_man).and_return(nil)
+            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/inflector_spec.rb

@@ -28,6 +28,10 @@ describe CommandKit::Inflector do
     end
   end
 
+  ascii   = (0..255).map(&:chr)
+  alpha   = ('a'..'z').to_a + ('A'..'Z').to_a
+  numeric = ('0'..'9').to_a
+
   describe ".underscore" do
     it "must convert CamelCase to camel_case" do
       expect(subject.underscore('CamelCase')).to eq('camel_case')
@@ -37,18 +41,48 @@ describe CommandKit::Inflector do
       expect(subject.underscore('camelCase')).to eq('camel_case')
     end
 
-    it "must convert Camel to camel" do
-      expect(subject.underscore('Camel')).to eq('camel')
+    it "must convert Camelcase to camelcase" do
+      expect(subject.underscore('Camelcase')).to eq('camelcase')
     end
 
-    it "must convert CAMEL to camel" do
-      expect(subject.underscore('CAMEL')).to eq('camel')
+    it "must convert CAMELCASE to camelcase" do
+      expect(subject.underscore('CAMELCASE')).to eq('camelcase')
     end
 
-    context "when given a String containing '/' characters" do
-      it "must replace dashes with underscores" do
-        expect(subject.underscore('foo-bar')).to eq('foo_bar')
-      end
+    it "must convert CAMELCase to camel_case" do
+      expect(subject.underscore('CAMELCase')).to eq('camel_case')
+    end
+
+    it "must convert CamelCASE to camel_case" do
+      expect(subject.underscore('CAMELCase')).to eq('camel_case')
+    end
+
+    it "must convert FooBARBaz to foo_bar_baz" do
+      expect(subject.underscore('FooBARBaz')).to eq('foo_bar_baz')
+    end
+
+    it "must convert foo_bar_baz to foo_bar_baz" do
+      expect(subject.underscore('foo_bar_baz')).to eq('foo_bar_baz')
+    end
+
+    it "must convert foo___bar___baz to foo___bar___baz" do
+      expect(subject.underscore('foo___bar___baz')).to eq('foo___bar___baz')
+    end
+
+    it "must convert foo-bar-baz to foo_bar_baz" do
+      expect(subject.underscore('foo-bar-baz')).to eq('foo_bar_baz')
+    end
+
+    it "must convert foo---bar---baz to foo___bar___baz" do
+      expect(subject.underscore('foo---bar---baz')).to eq('foo___bar___baz')
+    end
+
+    it "must convert foo_BAR_baz to foo_bar_baz" do
+      expect(subject.underscore('foo_BAR_baz')).to eq('foo_bar_baz')
+    end
+
+    it "must convert foo-BAR-baz to foo_bar_baz" do
+      expect(subject.underscore('foo-BAR-baz')).to eq('foo_bar_baz')
     end
 
     context "when given a non-String" do
@@ -56,6 +90,20 @@ describe CommandKit::Inflector do
         expect(subject.underscore(:CamelCase)).to eq('camel_case')
       end
     end
+
+    separators = %w[_ -]
+
+    (ascii - alpha - numeric - separators).each do |char|
+      context "when the given String contains a #{char.inspect} character" do
+        let(:string) { "Foo#{char}Bar" }
+
+        it do
+          expect {
+            subject.underscore(string)
+          }.to raise_error(ArgumentError,"cannot convert string to underscored: #{string.inspect}")
+        end
+      end
+    end
   end
 
   describe ".dasherize" do
@@ -100,5 +148,19 @@ describe CommandKit::Inflector do
         expect(subject.camelize(:foo_bar)).to eq('FooBar')
       end
     end
+
+    separators = %w[_ - /]
+
+    (ascii - alpha - numeric - separators).each do |char|
+      context "when the given String contains a #{char.inspect} character" do
+        let(:string) { "foo#{char}bar" }
+
+        it do
+          expect {
+            subject.camelize(string)
+          }.to raise_error(ArgumentError,"cannot convert string to CamelCase: #{string.inspect}")
+        end
+      end
+    end
   end
 end

data/spec/man_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'command_kit/man'
+
+describe CommandKit::Man do
+  module TestMan
+    class TestCommand
+      include CommandKit::Man
+    end
+  end
+
+  let(:command_class) { TestMan::TestCommand }
+
+  subject { command_class.new }
+
+  describe "#man" do
+    let(:man_page) { 'foo' }
+
+    it "must call system() with the given man page" do
+      expect(subject).to receive(:system).with('man',man_page)
+
+      subject.man(man_page)
+    end
+
+    context "when given a non-String man-page argument" do
+      let(:man_page_arg) { double(:non_string_arg) }
+
+      it "must call #to_s on the man-page argument" do
+        expect(man_page_arg).to receive(:to_s).and_return(man_page)
+
+        expect(subject).to receive(:system).with('man',man_page)
+
+        subject.man(man_page_arg)
+      end
+    end
+
+    context "when given the section: keyword argument" do
+      let(:section) { 7 }
+
+      it "must call system() with the given section number and man page" do
+        expect(subject).to receive(:system).with('man',section.to_s,man_page)
+
+        subject.man(man_page, section: section)
+      end
+    end
+  end
+end