command_kit 0.1.0.pre1

data/spec/env/path_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'command_kit/env/path'
+
+describe Env::Path do
+  module TestEnvPath
+    class TestCommand
+
+      include CommandKit::Env::Path
+
+    end
+  end
+
+  let(:command_class) { TestEnvPath::TestCommand }
+  subject { command_class.new }
+
+  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))
+    end
+
+    context "when given a custom 'PATH variable" do
+      let(:path_dirs) { %w[/bin /usr/bin] }
+      let(:path)      { path_dirs.join(File::PATH_SEPARATOR) }
+
+      subject { command_class.new(env: {'PATH' => path}) }
+
+      it "must split env['PATH'] into an Array of directories" do
+        expect(subject.path_dirs).to eq(path_dirs)
+      end
+    end
+
+    context "when given an empty 'PATH' env variable" do
+      subject { command_class.new(env: {'PATH' => ''}) }
+
+      it "must set #path_dirs to []" do
+        expect(subject.path_dirs).to eq([])
+      end
+    end
+  end
+
+  describe "#find_command" do
+    context "when given a valid command name" do
+      it "must search #path_dirs for the command" do
+        command = subject.find_command('ruby')
+
+        expect(subject.path_dirs).to include(File.dirname(command))
+      end
+
+      it "must return the path to the command" do
+        command = subject.find_command('ruby')
+
+        expect(command).to_not be(nil)
+        expect(File.file?(command)).to be(true)
+        expect(File.executable?(command)).to be(true)
+      end
+    end
+
+    context "when given an unknown command name" do
+      it "must return nil" do
+        expect(subject.find_command('does_not_exist')).to be(nil)
+      end
+    end
+  end
+
+  describe "#command_installed?" do
+    context "when given a valid command name" do
+      it do
+        expect(subject.command_installed?('ruby')).to be(true)
+      end
+    end
+
+    context "when given an unknown command name" do
+      it "must return nil" do
+        expect(subject.command_installed?('does_not_exist')).to be(false)
+      end
+    end
+  end
+end

data/spec/env_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+require 'command_kit/env'
+
+describe CommandKit::Env do
+  module TestEnv
+    class TestCommand
+      include CommandKit::Env
+    end
+  end
+
+  let(:command_class) { TestEnv::TestCommand }
+
+  describe "#initialize" do
+    module TestEnv
+      class TestCommandWithInitialize
+        include CommandKit::Env
+
+        attr_reader :var
+
+        def initialize(**kwargs)
+          super(**kwargs)
+
+          @var = 'foo'
+        end
+      end
+
+      class TestCommandWithInitializeAndKeywordArgs
+        include CommandKit::Env
+
+        attr_reader :var
+
+        def initialize(var: "foo", **kwargs)
+          super(**kwargs)
+
+          @var = var
+        end
+      end
+    end
+
+    context "when given no arguments" do
+      subject { command_class.new() }
+
+      it "must initialize #env to ENV" do
+        expect(subject.env).to be(ENV)
+      end
+
+      context "and the including class defines it's own #initialize method" do
+        let(:command_class) { TestEnv::TestCommandWithInitialize }
+
+        it "must initialize #env to ENV" do
+          expect(subject.env).to be(ENV)
+        end
+
+        it "must also call the class'es #initialize method" do
+          expect(subject.var).to eq('foo')
+        end
+
+        context "and it accepts keyword arguments" do
+          let(:command_class) { TestEnv::TestCommandWithInitializeAndKeywordArgs }
+          let(:var) { 'custom value' }
+
+          subject { command_class.new(var: var) }
+
+          it "must initialize #env to ENV" do
+            expect(subject.env).to be(ENV)
+          end
+
+          it "must also call the class'es #initialize method with any additional keyword arguments" do
+            expect(subject.var).to eq(var)
+          end
+        end
+      end
+    end
+
+    context "when given a custom env: value" do
+      let(:custom_env) { {'FOO' => 'bar'} }
+
+      subject { command_class.new(env: custom_env) }
+
+      it "must initialize #env to the env: value" do
+        expect(subject.env).to eq(custom_env)
+      end
+
+      context "and the including class defines it's own #initialize method" do
+        let(:command_class) { TestEnv::TestCommandWithInitialize }
+
+        it "must initialize #env to the env: value" do
+          expect(subject.env).to eq(custom_env)
+        end
+
+        it "must also call the class'es #initialize method" do
+          expect(subject.var).to eq('foo')
+        end
+
+        context "and it accepts keyword arguments" do
+          let(:command_class) { TestEnv::TestCommandWithInitializeAndKeywordArgs }
+          let(:var) { 'custom value' }
+
+          subject { command_class.new(env: custom_env, var: var) }
+
+          it "must initialize #env to the env: value" do
+            expect(subject.env).to eq(custom_env)
+          end
+
+          it "must also call the class'es #initialize method with any additional keyword arguments" do
+            expect(subject.var).to eq(var)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#env" do
+    let(:command_class) { TestEnv::TestCommand }
+    let(:env) { {"FOO" => "bar" } }
+
+    subject { command_class.new(env: env) }
+
+    it "must return the initialized env: value" do
+      expect(subject.env).to eq(env)
+    end
+  end
+end

data/spec/examples_spec.rb

@@ -0,0 +1,235 @@
+require 'spec_helper'
+require 'command_kit/examples'
+
+describe Examples do
+  module TestExamples
+    class ImplicitCmd
+      include CommandKit::Examples
+    end
+  end
+
+  let(:command_class) { TestExamples::ImplicitCmd }
+
+  describe ".examples" do
+    subject { TestExamples::ImplicitCmd }
+
+    context "when no examples have been set" do
+      it "should default to nil" do
+        expect(subject.examples).to be_nil
+      end
+    end
+
+    context "when a examples is explicitly set" do
+      module TestExamples
+        class ExplicitCmd
+          include CommandKit::Examples
+          examples [
+            '--example 1',
+            '--example 2'
+          ]
+        end
+      end
+
+      subject { TestExamples::ExplicitCmd }
+
+      it "must return the explicitly set examples" do
+        expect(subject.examples).to eq([
+          '--example 1',
+          '--example 2'
+        ])
+      end
+    end
+
+    context "when the command class inherites from another class" do
+      context "but no examples is set" do
+        module TestExamples
+          class BaseCmd
+            include CommandKit::Examples
+          end
+
+          class InheritedCmd < BaseCmd
+          end
+        end
+
+        subject { TestExamples::InheritedCmd }
+
+        it "must search each class then return nil "do
+          expect(subject.examples).to be_nil
+        end
+      end
+
+      module TestExamples
+        class ExplicitBaseCmd
+          include CommandKit::Examples
+          examples [
+            '--example 1',
+            '--example 2'
+          ]
+        end
+      end
+
+      context "when the superclass defines an explicit examples" do
+        module TestExamples
+          class ImplicitInheritedCmd < ExplicitBaseCmd
+          end
+        end
+
+        let(:super_subject) { TestExamples::ExplicitBaseCmd }
+        subject { TestExamples::ImplicitInheritedCmd }
+
+        it "must inherit the superclass'es examples" do
+          expect(subject.examples).to eq(super_subject.examples)
+        end
+
+        it "must not change the superclass'es examples" do
+          expect(super_subject.examples).to eq([
+            '--example 1',
+            '--example 2'
+          ])
+        end
+      end
+
+      context "when the subclass defines an explicit examples" do
+        module TestExamples
+          class ImplicitBaseCmd
+            include CommandKit::Examples
+          end
+
+          class ExplicitInheritedCmd < ImplicitBaseCmd
+            examples [
+              '--example 1',
+              '--example 2'
+            ]
+          end
+        end
+
+        let(:super_subject) { TestExamples::ImplicitBaseCmd }
+        subject { TestExamples::ExplicitInheritedCmd }
+
+        it "must return the subclass'es examples" do
+          expect(subject.examples).to eq([
+            '--example 1',
+            '--example 2'
+          ])
+        end
+
+        it "must not change the superclass'es examples" do
+          expect(super_subject.examples).to be_nil
+        end
+      end
+
+      context "when both the subclass overrides the superclass's exampless" do
+        module TestExamples
+          class ExplicitOverridingInheritedCmd < ExplicitBaseCmd
+            examples [
+              '--example override'
+            ]
+          end
+        end
+
+        let(:super_subject) { TestExamples::ExplicitBaseCmd }
+        subject { TestExamples::ExplicitOverridingInheritedCmd }
+
+        it "must return the subclass'es examples" do
+          expect(subject.examples).to eq([
+            '--example override'
+          ])
+        end
+
+        it "must not change the superclass'es examples" do
+          expect(super_subject.examples).to eq([
+            '--example 1',
+            '--example 2'
+          ])
+        end
+      end
+    end
+  end
+
+  subject { command_class.new }
+
+  describe "#examples" do
+    it "must be the same as .examples" do
+      expect(subject.examples).to eq(command_class.examples)
+    end
+  end
+
+  describe "#help_examples" do
+    context "when #examples returns nil" do
+      module TestExamples
+        class NoExamples
+          include CommandKit::Examples
+        end
+      end
+
+      let(:command_class) { TestExamples::NoExamples }
+      subject { command_class.new }
+
+      it "must print out the examples" do
+        expect { subject.help_examples }.to_not output.to_stdout
+      end
+    end
+
+    context "when #examples returns an Array" do
+      module TestExamples
+        class MultipleExamples
+          include CommandKit::Examples
+
+          examples [
+            '--example 1',
+            '--example 2',
+            '--example 3'
+          ]
+        end
+      end
+
+      let(:command_class) { TestExamples::MultipleExamples }
+      subject { command_class.new }
+
+      it "must print out the 'Examples:' section header and the examples" do
+        expect { subject.help_examples }.to output(
+          [
+            '',
+            "Examples:",
+            "    #{subject.command_name} #{subject.examples[0]}",
+            "    #{subject.command_name} #{subject.examples[1]}",
+            "    #{subject.command_name} #{subject.examples[2]}",
+            ''
+          ].join($/)
+        ).to_stdout
+      end
+    end
+  end
+
+  describe "#help" do
+    it "must call #help_examples" do
+      expect(subject).to receive(:help_examples)
+
+      subject.help
+    end
+
+    context "when the superclass defines it's own #help method" do
+      module TestDescription
+        class SuperclassHelpMethod
+          def help
+            puts 'superclass'
+          end
+        end
+
+        class InheritedHelpMethod < SuperclassHelpMethod
+          include CommandKit::Examples
+        end
+      end
+
+      let(:super_command_class) { TestDescription::SuperclassHelpMethod }
+      let(:command_class) { TestDescription::InheritedHelpMethod }
+
+      it "must call the superclass'es #help method first" do
+        expect_any_instance_of(super_command_class).to receive(:help)
+        expect(subject).to receive(:help_examples)
+
+        subject.help
+      end
+    end
+  end
+end

data/spec/exception_handler_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+require 'command_kit/exception_handler'
+
+describe CommandKit::ExceptionHandler do
+  module TestExceptionHandler
+    class TestIncludedCmd
+
+      include CommandKit::Main
+      include CommandKit::ExceptionHandler
+
+    end
+  end
+
+  let(:command_class) { TestExceptionHandler::TestIncludedCmd }
+  subject { command_class.new }
+
+  describe ".included" do
+    it "must include CommandKit::Printing" do
+      expect(command_class).to be_include(CommandKit::Printing)
+    end
+  end
+
+  describe "#main" do
+    context "when the #main method rescues an Interrupt" do
+      module TestExceptionHandler
+        class RaisesInterruptCmd
+
+          include CommandKit::Main
+          include CommandKit::ExceptionHandler
+
+          def run
+            raise(Interrupt.new)
+          end
+
+        end
+      end
+
+      let(:command_class) { TestExceptionHandler::RaisesInterruptCmd }
+      subject { command_class.new }
+
+      it "must re-raise the Interrupt exception" do
+        expect { subject.main }.to raise_error(Interrupt)
+      end
+    end
+
+    context "when the #main method raises an Errno::EPIPE" do
+      module TestExceptionHandler
+        class RaisesErrnoEPIPECmd
+
+          include CommandKit::Main
+          include CommandKit::ExceptionHandler
+
+          def run
+            raise(Errno::EPIPE.new)
+          end
+
+        end
+      end
+
+      let(:command_class) { TestExceptionHandler::RaisesErrnoEPIPECmd }
+      subject { command_class.new }
+
+      it "must re-raise the Errno::EPIPE exception" do
+        expect { subject.main }.to raise_error(Errno::EPIPE)
+      end
+    end
+
+    context "when the #main method raises another Exception" do
+      module TestExceptionHandler
+        class RaisesExceptionCmd
+
+          include CommandKit::Main
+          include CommandKit::ExceptionHandler
+
+          def run
+            raise(RuntimeError.new("error"))
+          end
+
+        end
+      end
+
+      let(:command_class) { TestExceptionHandler::RaisesExceptionCmd }
+      subject { command_class.new }
+
+      it "must rescue the exception and call #on_exception" do
+        expect(subject).to receive(:on_exception).with(RuntimeError)
+
+        subject.main
+      end
+    end
+  end
+
+  describe "#on_exception" do
+    let(:error) { RuntimeError.new('error') }
+
+    it "must call #print_exception and exit with 1" do
+      expect(subject).to receive(:print_exception).with(error)
+      expect(subject).to receive(:exit).with(1)
+
+      subject.on_exception(error)
+    end
+  end
+end