command_kit 0.4.1 → 0.5.1

data/spec/exception_handler_spec.rb

@@ -1,103 +0,0 @@
-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("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

data/spec/file_utils_spec.rb

@@ -1,59 +0,0 @@
-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

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

data/spec/help/man_spec.rb

@@ -1,345 +0,0 @@
-require 'spec_helper'
-require 'command_kit/help/man'
-
-describe CommandKit::Help::Man do
-  module TestHelpMan
-    class TestCommand
-      include CommandKit::Help::Man
-
-      man_dir "#{__dir__}/fixtures/man"
-    end
-
-    class TestCommandWithManPage
-      include CommandKit::Help::Man
-
-      man_dir "#{__dir__}/fixtures/man"
-      man_page 'foo.1'
-    end
-
-    class TestCommandWithRelativeManDir
-      include CommandKit::Help::Man
-
-      man_dir File.join(__dir__,'..','..','..','man')
-    end
-
-    class TestCommandWithManDirNotSet
-      include CommandKit::Help::Man
-    end
-  end
-
-  let(:command_class) { TestHelpMan::TestCommand }
-
-  describe ".included" do
-    subject { command_class }
-
-    it "must include CommandName" do
-      expect(subject).to include(CommandKit::CommandName)
-    end
-
-    it "must include Help" do
-      expect(subject).to include(CommandKit::Help)
-    end
-
-    it "must include Stdio" do
-      expect(subject).to include(CommandKit::Stdio)
-    end
-  end
-
-  describe ".man_dir" do
-    context "when no man_dir have been set" do
-      subject { TestHelpMan::TestCommandWithManDirNotSet }
-
-      it "should default to nil" do
-        expect(subject.man_dir).to be_nil
-      end
-    end
-
-    context "when a man_dir is explicitly set" do
-      subject { TestHelpMan::TestCommand }
-
-      it "must return the explicitly set man_dir" do
-        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
-
-    context "when the command class inherites from another class" do
-      context "but no man_dir is set" do
-        module TestHelpMan
-          class BaseCmd
-            include CommandKit::Help::Man
-          end
-
-          class InheritedCmd < BaseCmd
-          end
-        end
-
-        subject { TestHelpMan::InheritedCmd }
-
-        it "must search each class then return nil "do
-          expect(subject.man_dir).to be_nil
-        end
-      end
-
-      module TestHelpMan
-        class ExplicitBaseCmd
-          include CommandKit::Help::Man
-
-          man_dir 'set/in/baseclass'
-        end
-      end
-
-      context "when the superclass defines an explicit man_dir" do
-        module TestHelpMan
-          class ImplicitInheritedCmd < ExplicitBaseCmd
-          end
-        end
-
-        let(:super_subject) { TestHelpMan::ExplicitBaseCmd }
-        subject { TestHelpMan::ImplicitInheritedCmd }
-
-        it "must inherit the superclass'es man_dir" do
-          expect(subject.man_dir).to eq(super_subject.man_dir)
-        end
-
-        it "must not change the superclass'es man_dir" do
-          expect(super_subject.man_dir).to eq(File.expand_path('set/in/baseclass'))
-        end
-      end
-
-      context "when the subclass defines an explicit man_dir" do
-        module TestHelpMan
-          class ImplicitBaseCmd
-            include CommandKit::Help::Man
-          end
-
-          class ExplicitInheritedCmd < ImplicitBaseCmd
-            man_dir 'set/in/subclass'
-          end
-        end
-
-        let(:super_subject) { TestHelpMan::ImplicitBaseCmd }
-        subject { TestHelpMan::ExplicitInheritedCmd }
-
-        it "must return the subclass'es man_dir" do
-          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 be_nil
-        end
-      end
-
-      context "when both the subclass overrides the superclass's man_dirs" do
-        module TestHelpMan
-          class ExplicitOverridingInheritedCmd < ExplicitBaseCmd
-            man_dir 'set/in/subclass'
-          end
-        end
-
-        let(:super_subject) { TestHelpMan::ExplicitBaseCmd }
-        subject { TestHelpMan::ExplicitOverridingInheritedCmd }
-
-        it "must return the subclass'es man_dir" do
-          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(File.expand_path('set/in/baseclass'))
-        end
-      end
-    end
-  end
-
-  describe ".man_page" do
-    context "when no man_page has been set" do
-      subject { TestHelpMan::TestCommand }
-
-      it "should default to \"\#{command_name}.1\"" do
-        expect(subject.man_page).to eq("#{subject.command_name}.1")
-      end
-    end
-
-    context "when a man_page is explicitly set" do
-      module TestHelpMan
-        class ExplicitCmd
-          include CommandKit::Help::Man
-          man_page 'explicit.1'
-        end
-      end
-
-      subject { TestHelpMan::ExplicitCmd }
-
-      it "must return the explicitly set man_page" do
-        expect(subject.man_page).to eq('explicit.1')
-      end
-    end
-
-    context "when the command class inherites from another class" do
-      module TestHelpMan
-        class BaseCmd
-          include CommandKit::Help::Man
-        end
-
-        class InheritedCmd < BaseCmd
-        end
-      end
-
-      subject { TestHelpMan::InheritedCmd }
-
-      it "should underscore the class'es name" do
-        expect(subject.man_page).to eq('inherited_cmd.1')
-      end
-
-      context "when the superclass defines an explicit man_page" do
-        module TestHelpMan
-          class ExplicitBaseCmd
-            include CommandKit::Help::Man
-            man_page 'explicit.1'
-          end
-
-          class ImplicitInheritedCmd < ExplicitBaseCmd
-          end
-        end
-
-        let(:super_subject) { TestHelpMan::ExplicitBaseCmd }
-        subject { TestHelpMan::ImplicitInheritedCmd }
-
-        it "must return the subclass'es man_page, not the superclass'es" do
-          expect(subject.man_page).to eq('implicit_inherited_cmd.1')
-        end
-
-        it "must not change the superclass'es man_page" do
-          expect(super_subject.man_page).to eq('explicit.1')
-        end
-      end
-
-      context "when the subclass defines an explicit man_page" do
-        module TestHelpMan
-          class ImplicitBaseCmd
-            include CommandKit::Help::Man
-          end
-
-          class ExplicitInheritedCmd < ImplicitBaseCmd
-            man_page 'explicit.1'
-          end
-        end
-
-        let(:super_subject) { TestHelpMan::ImplicitBaseCmd }
-        subject { TestHelpMan::ExplicitInheritedCmd }
-
-        it "must return the subclass'es man_page, not the superclass'es" do
-          expect(subject.man_page).to eq('explicit.1')
-        end
-
-        it "must not change the superclass'es man_page" do
-          expect(super_subject.man_page).to eq('implicit_base_cmd.1')
-        end
-      end
-    end
-  end
-
-  subject { command_class.new }
-
-  describe "#help_man" do
-    let(:man_page_path) do
-      File.join(subject.class.man_dir,subject.class.man_page)
-    end
-
-    it "must open the .man_page within the .man_dir" do
-      expect(subject).to receive(:system).with('man',man_page_path)
-
-      subject.help_man
-    end
-
-    context "when given a custom man page" do
-      let(:man_page)      { 'bar.1' }
-      let(:man_page_path) { File.join(subject.class.man_dir,man_page) }
-
-      it "must open the custom man-page within the .man_dir" do
-        expect(subject).to receive(:system).with('man',man_page_path)
-
-        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
-    let(:normal_help_output) do
-      stdout = StringIO.new
-
-      command_class.new(stdout: stdout).tap do |command|
-        command.method(:help).super_method.call
-      end
-
-      stdout.string
-    end
-
-    let(:stdout) { StringIO.new }
-
-    subject { command_class.new(stdout: stdout) }
-
-    context "when stdout is a TTY" do
-      before do
-        expect(subject.stdout).to receive(:tty?).and_return(true)
-      end
-
-      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
-
-        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() mehtod" do
-          subject.help
-
-          expect(stdout.string).to eq(normal_help_output)
-        end
-      end
-    end
-
-    context "when stdout is not a TTY" do
-      it "must call the super help() method" do
-        subject.help
-
-        expect(stdout.string).to eq(normal_help_output)
-      end
-    end
-  end
-end

data/spec/help_spec.rb

@@ -1,94 +0,0 @@
-require 'spec_helper'
-require 'command_kit/help'
-
-describe CommandKit::Help do
-  module TestHelp
-    class DefaultCmd
-      include CommandKit::Help
-    end
-
-    class TestCommandWithInitialize
-      include CommandKit::Help
-
-      attr_reader :foo
-
-      attr_reader :bar
-
-      def initialize(foo: 'foo', bar: 'bar', **kwargs)
-        super(**kwargs)
-
-        @foo = foo
-        @bar = bar
-      end
-    end
-  end
-
-  let(:command_class) { TestHelp::TestCmd }
-
-  describe ".help" do
-    subject { command_class }
-
-    context "when no #initialize method is defined" do
-      let(:command_class) { TestHelp::DefaultCmd }
-      let(:instance) { command_class.new }
-
-      it "must initialize the command object and call #help" do
-        expect(subject).to receive(:new).with(no_args).and_return(instance)
-        expect(instance).to receive(:help).with(no_args)
-
-        subject.help()
-      end
-    end
-
-    context "when an #initialize method is defined" do
-      let(:command_class) { TestHelp::TestCommandWithInitialize }
-      let(:instance) { command_class.new }
-
-      context "and given no arguments" do
-        it "must initialize the command object and call #help" do
-          expect(subject).to receive(:new).with(no_args).and_return(instance)
-          expect(instance).to receive(:help).with(no_args)
-
-          subject.help()
-        end
-      end
-
-      context "and given keyword arguments" do
-        let(:kwargs) { {foo: 'custom foo', bar: 'custom bar'} }
-        let(:instance) { command_class.new(**kwargs) }
-
-        it "must pass the keyword arguments .new then call #help" do
-          expect(subject).to receive(:new).with(**kwargs).and_return(instance)
-          expect(instance).to receive(:help).with(no_args)
-
-          subject.help(**kwargs)
-        end
-      end
-    end
-  end
-
-  subject { command_class.new }
-
-  describe "#help" do
-    context "when there is no superclass #help method" do
-      module TestHelp
-        class SuperclassWithoutHelp
-        end
-
-        class SubclassOfSuperclassWithoutHelp < SuperclassWithoutHelp
-          include CommandKit::Help
-        end
-      end
-
-      let(:command_superclass) { TestHelp::SuperclassWithoutHelp }
-      let(:command_class)      { TestHelp::SubclassOfSuperclassWithoutHelp }
-
-      it "must not attempt to call the superclass'es #help" do
-        allow_any_instance_of(command_class).to receive(:help)
-        expect_any_instance_of(command_superclass).to_not receive(:help)
-
-        subject.help()
-      end
-    end
-  end
-end