command_kit 0.4.1 → 0.5.1

data/spec/commands/help_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-require 'command_kit/commands/help'
-require 'command_kit/commands'
-
-describe CommandKit::Commands::Help do
-  module TestHelpCommand
-    class CLI
-      include CommandKit::Commands
-
-      class Test < CommandKit::Command
-      end
-
-      class TestWithoutHelp
-      end
-
-      command Test
-      command 'test-without-help', TestWithoutHelp
-    end
-  end
-
-  let(:parent_command_class) { TestHelpCommand::CLI }
-  let(:parent_command) { parent_command_class.new }
-  let(:command_class) { CommandKit::Commands::Help }
-
-  subject { command_class.new(parent_command: parent_command) }
-
-  describe ".run" do
-    context "when giving no arguments" do
-      it "must call the parent command's #help method" do
-        expect(parent_command).to receive(:help).with(no_args)
-
-        subject.run
-      end
-    end
-
-    context "when given a command name" do
-      let(:command) { 'test' }
-
-      it "must lookup the command and call it's #help method" do
-        expect_any_instance_of(parent_command_class::Test).to receive(:help)
-
-        subject.run(command)
-      end
-
-      context "but the command does not define a #help method" do
-        let(:command) { 'test-without-help' }
-
-        it do
-          expect { subject.run(command) }.to raise_error(TypeError)
-        end
-      end
-
-      context "but the command name is invalid" do
-        let(:command) { 'xxx' }
-
-        it "must print an error message and exit with 1" do
-          expect(subject).to receive(:exit).with(1)
-
-          expect { subject.run(command) }.to output(
-            "#{subject.command_name}: unknown command: #{command}#{$/}"
-          ).to_stderr
-        end
-      end
-    end
-  end
-end

data/spec/commands/parent_command_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-require 'command_kit/commands'
-require 'command_kit/commands/parent_command'
-
-describe CommandKit::Commands::ParentCommand do
-  module TestParentCommand
-    class TestCommands
-
-      include CommandKit::Commands
-
-      class Test < CommandKit::Command
-        include CommandKit::Commands::ParentCommand
-      end
-
-      command Test
-
-    end
-  end
-
-  let(:parent_command_class) { TestParentCommand::TestCommands }
-  let(:command_class) { TestParentCommand::TestCommands::Test }
-
-  describe "#initialize" do
-    context "when given a parent_command: keyword argument" do
-      let(:parent_command) { parent_command_class.new }
-
-      subject { command_class.new(parent_command: parent_command) }
-
-      it "must initialize #parent_command" do
-        expect(subject.parent_command).to be(parent_command)
-      end
-    end
-
-    context "when the parent_command: keyword argument is not given" do
-      it do
-        expect { command_class.new }.to raise_error(ArgumentError)
-      end
-    end
-  end
-end

data/spec/commands/subcommand_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
-require 'command_kit/commands/subcommand'
-require 'command_kit/command'
-
-describe CommandKit::Commands::Subcommand do
-  module TestSubcommands
-    class TestCommand < CommandKit::Command
-    end
-
-    class TestCommandWithoutDescription
-    end
-
-    class TestCommandWithASentenceFragmentDescription
-      include CommandKit::Description
-
-      description "The quick brown fox"
-    end
-
-    class TestCommandWithASingleSentenceDescription
-      include CommandKit::Description
-
-      description "The quick brown fox jumps over the lazy dog."
-    end
-
-    class TestCommandWithAMultiSentenceDescription
-      include CommandKit::Description
-
-      description "The quick brown fox jumps over the lazy dog. Foo bar baz."
-    end
-  end
-
-  describe "#initialize" do
-    let(:command_class) { TestSubcommands::TestCommand }
-
-    subject { described_class.new(command_class) }
-
-    it "must initialize the subcommand with a given command class" do
-      expect(subject.command).to be(command_class)
-    end
-
-    context "when the command class has no description" do
-      it "#summary must be nil" do
-        expect(subject.summary).to be(nil)
-      end
-    end
-
-    context "when the command class have a description" do
-      let(:command_class) { TestSubcommands::TestCommandWithAMultiSentenceDescription }
-
-      it "must extract the summary using .summary" do
-        expect(subject.summary).to eq(described_class.summary(command_class))
-      end
-    end
-
-    context "when given aliases:" do
-      let(:aliases) { %w[test t] }
-
-      subject { described_class.new(command_class, aliases: aliases) }
-
-      it "must initialize #aliases" do
-        expect(subject.aliases).to eq(aliases)
-      end
-    end
-  end
-
-  describe ".summary" do
-    subject { described_class.summary(command_class) }
-
-    context "when the command class does respond_to?(:description)" do
-      let(:command_class) { TestSubcommands::TestCommandWithoutDescription }
-
-      it { expect(subject).to be(nil) }
-    end
-
-    context "when the command class has a sentence fragment description" do
-      let(:command_class) { TestSubcommands::TestCommandWithASentenceFragmentDescription }
-
-      it "must return the sentence fragment" do
-        expect(subject).to eq(command_class.description)
-      end
-    end
-
-    context "when the command class has a single sentence description" do
-      let(:command_class) { TestSubcommands::TestCommandWithASingleSentenceDescription }
-
-      it "must return the single sentence without the terminating period" do
-        expect(subject).to eq(command_class.description.chomp('.'))
-      end
-    end
-
-    context "when the command class has a multi-sentence description" do
-      let(:command_class) { TestSubcommands::TestCommandWithAMultiSentenceDescription }
-
-      it "must extract the first sentence, without the terminating period" do
-        expect(subject).to eq(command_class.description.split(/\.\s*/).first)
-      end
-    end
-  end
-end