command_kit 0.4.1 → 0.5.0

data/spec/arguments/argument_value_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-require 'command_kit/arguments/argument_value'
-
-describe CommandKit::Arguments::ArgumentValue do
-  let(:required) { false  }
-  let(:usage)    { 'FOO'  }
-
-  subject do
-    described_class.new(
-      required: required,
-      usage:    usage
-    )
-  end
-
-  describe "#initialize" do
-    it "must require a usage: keyword"do
-      expect {
-        described_class.new(required: required)
-      }.to raise_error(ArgumentError)
-    end
-
-    context "when required: is given" do
-      subject { described_class.new(required: required, usage: usage) }
-
-      it "must set #required" do
-        expect(subject.required).to eq(required)
-      end
-    end
-
-    context "when required: is not given" do
-      subject { described_class.new(usage: usage) }
-
-      it "must default to true" do
-        expect(subject.required).to be(true)
-      end
-    end
-  end
-
-  describe "#required?" do
-    context "when required: is initialized with true" do
-      let(:required) { true }
-
-      it { expect(subject.required?).to be(true) }
-    end
-
-    context "when required: is initialized with false" do
-      let(:required) { false }
-
-      it { expect(subject.required?).to be(false) }
-    end
-  end
-
-  describe "#optional?" do
-    context "when required: is initialized with true" do
-      let(:required) { true }
-
-      it { expect(subject.optional?).to be(false) }
-    end
-
-    context "when required: is initialized with false" do
-      let(:required) { false }
-
-      it { expect(subject.optional?).to be(true) }
-    end
-  end
-end

data/spec/arguments_spec.rb

@@ -1,279 +0,0 @@
-require 'spec_helper'
-require 'command_kit/arguments'
-
-describe CommandKit::Arguments do
-  module TestArguments
-    class ImplicitCmd
-      include CommandKit::Arguments
-    end
-  end
-
-  let(:command_class) { TestArguments::ImplicitCmd }
-
-  describe ".included" do
-    subject { command_class }
-
-    it { expect(subject).to include(CommandKit::Main) }
-    it { expect(subject).to include(CommandKit::Help) }
-  end
-
-  describe ".arguments" do
-    subject { TestArguments::ImplicitCmd }
-
-    context "when no arguments have been defined" do
-      it "should default to {}" do
-        expect(subject.arguments).to eq({})
-      end
-    end
-
-    context "when a arguments is explicitly set" do
-      module TestArguments
-        class ExplicitCmd
-          include CommandKit::Arguments
-          argument :foo, desc: 'Foo option'
-          argument :bar, desc: 'Bar option'
-        end
-      end
-
-      subject { TestArguments::ExplicitCmd }
-
-      it "must return the explicitly set arguments" do
-        expect(subject.arguments.keys).to eq([:foo, :bar])
-      end
-    end
-
-    context "when the command class inherites from another class" do
-      context "but no arguments are defined" do
-        module TestArguments
-          class BaseCmd
-            include CommandKit::Arguments
-          end
-
-          class InheritedCmd < BaseCmd
-          end
-        end
-
-        subject { TestArguments::InheritedCmd }
-
-        it "must search each class then return {}"do
-          expect(subject.arguments).to eq({})
-        end
-      end
-
-      module TestArguments
-        class ExplicitBaseCmd
-          include CommandKit::Arguments
-          argument :foo, desc: 'Foo option'
-          argument :bar, desc: 'Bar option'
-        end
-      end
-
-      context "when the superclass defines arguments" do
-        module TestArguments
-          class ImplicitInheritedCmd < ExplicitBaseCmd
-          end
-        end
-
-        let(:super_subject) { TestArguments::ExplicitBaseCmd }
-        subject { TestArguments::ImplicitInheritedCmd }
-
-        it "must inherit the superclass'es arguments" do
-          expect(subject.arguments).to eq(super_subject.arguments)
-        end
-
-        it "must not change the superclass'es arguments" do
-          expect(super_subject.arguments.keys).to eq([:foo, :bar])
-        end
-      end
-
-      context "when the subclass defines arguments" do
-        module TestArguments
-          class ImplicitBaseCmd
-            include CommandKit::Arguments
-          end
-
-          class ExplicitInheritedCmd < ImplicitBaseCmd
-            argument :baz, desc: 'Baz option'
-            argument :qux, desc: 'Qux option'
-          end
-        end
-
-        let(:super_subject) { TestArguments::ImplicitBaseCmd }
-        subject { TestArguments::ExplicitInheritedCmd }
-
-        it "must return the subclass'es arguments" do
-          expect(subject.arguments.keys).to eq([:baz, :qux])
-        end
-
-        it "must not change the superclass'es arguments" do
-          expect(super_subject.arguments).to eq({})
-        end
-      end
-
-      context "when subclass overrides the superclass's argumentss" do
-        module TestArguments
-          class ExplicitOverridingInheritedCmd < ExplicitBaseCmd
-            argument :foo, desc: "Overriden foo option"
-          end
-        end
-
-        let(:super_subject) { TestArguments::ExplicitBaseCmd }
-        subject { TestArguments::ExplicitOverridingInheritedCmd }
-
-        it "must combine the superclass'es arguments with the subclass'es" do
-          expect(subject.arguments.keys).to eq([:foo, :bar])
-          expect(subject.arguments[:foo].desc).to eq("Overriden foo option")
-          expect(subject.arguments[:bar].desc).to eq("Bar option")
-        end
-
-        it "must not change the superclass'es arguments" do
-          expect(super_subject.arguments.keys).to eq([:foo, :bar])
-          expect(super_subject.arguments[:foo].desc).to eq("Foo option")
-          expect(super_subject.arguments[:bar].desc).to eq("Bar option")
-        end
-      end
-    end
-  end
-
-  subject { command_class.new }
-
-  describe "#main" do
-    module TestArguments
-      class TestCommand
-
-        include CommandKit::Arguments
-
-        argument :argument1, required: true,
-                             usage:    'ARG1',
-                             desc:     "Argument 1"
-
-        argument :argument2, required: false,
-                             usage:    'ARG2',
-                             desc:     "Argument 2"
-
-      end
-    end
-
-    let(:command_class) { TestArguments::TestCommand }
-
-    context "when given the correct number of arguments" do
-      let(:argv) { %w[arg1 arg2] }
-
-      it "must parse options before validating the number of arguments" do
-        expect {
-          expect(subject.main(argv)).to eq(0)
-        }.to_not output.to_stderr
-      end
-    end
-
-    context "when given fewer than the required number of arguments" do
-      let(:argv) { %w[] }
-
-      it "must print an error message and return 1" do
-        expect {
-          expect(subject.main(argv)).to eq(1)
-        }.to output("#{subject.command_name}: insufficient number of arguments.#{$/}").to_stderr
-      end
-    end
-
-    context "when given more than the total number of arguments" do
-      let(:argv) { %w[foo bar baz] }
-
-      it "must print an error message and return 1" do
-        expect {
-          expect(subject.main(argv)).to eq(1)
-        }.to output("#{subject.command_name}: too many arguments given.#{$/}").to_stderr
-      end
-    end
-  end
-
-  describe "#help_arguments" do
-    context "when #arguments returns {}" do
-      module TestArguments
-        class NoArguments
-          include CommandKit::Arguments
-        end
-      end
-
-      let(:command_class) { TestArguments::NoArguments }
-      subject { command_class.new }
-
-      it "must print out the arguments" do
-        expect { subject.help_arguments }.to_not output.to_stdout
-      end
-    end
-
-    context "when #arguments returns a Hash" do
-      module TestArguments
-        class MultipleArguments
-          include CommandKit::Arguments
-
-          argument :foo, desc: "Foo option"
-          argument :bar, desc: "Bar option"
-          argument :baz, desc: "Baz option"
-        end
-      end
-
-      let(:command_class) { TestArguments::MultipleArguments }
-      subject { command_class.new }
-
-      let(:foo_argument) { command_class.arguments[:foo] }
-      let(:bar_argument) { command_class.arguments[:bar] }
-      let(:baz_argument) { command_class.arguments[:baz] }
-
-      it "must print out the 'Arguments:' section header and the arguments" do
-        expect { subject.help_arguments }.to output(
-          [
-            '',
-            "Arguments:",
-            "    #{foo_argument.usage.ljust(33)}#{foo_argument.desc}",
-            "    #{bar_argument.usage.ljust(33)}#{bar_argument.desc}",
-            "    #{baz_argument.usage.ljust(33)}#{baz_argument.desc}",
-            ''
-          ].join($/)
-        ).to_stdout
-      end
-
-      context "when one the argument has an Array for a description" do
-        module TestArguments
-          class MultiLineArgumentDescription
-            include CommandKit::Arguments
-
-            argument :foo, desc: "Foo option"
-            argument :bar, desc: [
-                                   "Bar option", 
-                                   "Line 2",
-                                   "Line 3"
-                                 ]
-            argument :baz, desc: "Baz option"
-          end
-        end
-
-        let(:command_class) { TestArguments::MultiLineArgumentDescription }
-
-        it "must print out each line of a multi-line argument description" do
-          expect { subject.help_arguments }.to output(
-            [
-              '',
-              "Arguments:",
-              "    #{foo_argument.usage.ljust(33)}#{foo_argument.desc}",
-              "    #{bar_argument.usage.ljust(33)}#{bar_argument.desc[0]}",
-              "    #{' '.ljust(33)}#{bar_argument.desc[1]}",
-              "    #{' '.ljust(33)}#{bar_argument.desc[2]}",
-              "    #{baz_argument.usage.ljust(33)}#{baz_argument.desc}",
-              ''
-            ].join($/)
-          ).to_stdout
-        end
-      end
-    end
-  end
-
-  describe "#help" do
-    it "must call #help_arguments" do
-      expect(subject).to receive(:help_arguments)
-
-      subject.help
-    end
-  end
-end

data/spec/bug_report_spec.rb

@@ -1,266 +0,0 @@
-require 'spec_helper'
-require 'command_kit/bug_report'
-
-describe CommandKit::BugReport do
-  module TestBugReport
-    class CommandWithoutBugReportURLSet
-      include CommandKit::BugReport
-    end
-
-    class CommandWithBugReportURLSet
-      include CommandKit::BugReport
-
-      bug_report_url 'https://github.com/org/repo/issues/new'
-    end
-
-    class CommandWithInheritedBugReportURL < CommandWithBugReportURLSet
-    end
-  end
-
-  let(:command_class) { TestBugReport::CommandWithBugReportURLSet }
-
-  describe ".included" do
-    it { expect(command_class).to include(CommandKit::ExceptionHandler) }
-    it { expect(command_class).to include(CommandKit::Printing) }
-  end
-
-  describe ".bug_report_url" do
-    subject { TestBugReport::CommandWithoutBugReportURLSet }
-
-    context "when no bug_report_url has been set" do
-      it "should default to nil" do
-        expect(subject.bug_report_url).to be_nil
-      end
-    end
-
-    context "when a bug_report_url is explicitly set" do
-      subject { TestBugReport::CommandWithBugReportURLSet }
-
-      it "must return the explicitly set bug_report_url" do
-        expect(subject.bug_report_url).to eq("https://github.com/org/repo/issues/new")
-      end
-    end
-
-    context "when the command class inherites from another class" do
-      context "but no bug_report_url is set" do
-        module TestBugReport
-          class BaseCmd
-            include CommandKit::BugReport
-          end
-
-          class InheritedCmd < BaseCmd
-          end
-        end
-
-        subject { TestBugReport::InheritedCmd }
-
-        it "must search each class then return nil "do
-          expect(subject.bug_report_url).to be_nil
-        end
-      end
-
-      module TestBugReport
-        class ExplicitBaseCmd
-          include CommandKit::BugReport
-          bug_report_url 'https://github.com/org/repo/issues/new'
-        end
-      end
-
-      context "when the superclass defines an explicit bug_report_url" do
-        module TestBugReport
-          class ImplicitInheritedCmd < ExplicitBaseCmd
-          end
-        end
-
-        let(:super_subject) { TestBugReport::ExplicitBaseCmd }
-        subject { TestBugReport::ImplicitInheritedCmd }
-
-        it "must inherit the superclass'es bug_report_url" do
-          expect(subject.bug_report_url).to eq(super_subject.bug_report_url)
-        end
-
-        it "must not change the superclass'es bug_report_url" do
-          expect(super_subject.bug_report_url).to eq('https://github.com/org/repo/issues/new')
-        end
-      end
-
-      context "when the subclass defines an explicit bug_report_url" do
-        module TestBugReport
-          class ImplicitBaseCmd
-            include CommandKit::BugReport
-          end
-
-          class ExplicitInheritedCmd < ImplicitBaseCmd
-            bug_report_url 'https://github.com/other_org/other_repo/issues/new'
-          end
-        end
-
-        let(:super_subject) { TestBugReport::ImplicitBaseCmd }
-        subject { TestBugReport::ExplicitInheritedCmd }
-
-        it "must return the subclass'es bug_report_url" do
-          expect(subject.bug_report_url).to eq('https://github.com/other_org/other_repo/issues/new')
-        end
-
-        it "must not change the superclass'es bug_report_url" do
-          expect(super_subject.bug_report_url).to be_nil
-        end
-      end
-
-      context "when both the subclass overrides the superclass's bug_report_urls" do
-        module TestBugReport
-          class ExplicitOverridingInheritedCmd < ExplicitBaseCmd
-            bug_report_url 'https://github.com/other_org/other_repo/issues/new'
-          end
-        end
-
-        let(:super_subject) { TestBugReport::ExplicitBaseCmd }
-        subject { TestBugReport::ExplicitOverridingInheritedCmd }
-
-        it "must return the subclass'es bug_report_url" do
-          expect(subject.bug_report_url).to eq("https://github.com/other_org/other_repo/issues/new")
-        end
-
-        it "must not change the superclass'es bug_report_url" do
-          expect(super_subject.bug_report_url).to eq("https://github.com/org/repo/issues/new")
-        end
-      end
-    end
-  end
-
-  subject { command_class.new }
-
-  describe "#bug_report_url" do
-    context "when the command has bug_report_url set" do
-      let(:command_class) { TestBugReport::CommandWithBugReportURLSet }
-
-      it "must return the bug_report_url" do
-        expect(subject.bug_report_url).to eq(command_class.bug_report_url)
-      end
-    end
-
-    context "when the command does not have bug_report_url set" do
-      let(:command_class) { TestBugReport::CommandWithoutBugReportURLSet }
-
-      it "must return nil" do
-        expect(subject.bug_report_url).to be(nil)
-      end
-    end
-  end
-
-  describe "#print_bug_report" do
-    let(:message) { "error!" }
-    let(:backtrace) do
-      [
-        "/path/to/test1.rb:1 in `test1'",
-        "/path/to/test2.rb:2 in `test2'",
-        "/path/to/test3.rb:3 in `test3'",
-        "/path/to/test4.rb:4 in `test4'"
-      ]
-    end
-    let(:exception) do
-      error = RuntimeError.new(message)
-      error.set_backtrace(backtrace)
-      error
-    end
-
-    subject { command_class.new(stderr: StringIO.new) }
-
-    context "when the command has bug_report_url set" do
-      let(:command_class) { TestBugReport::CommandWithBugReportURLSet }
-
-      context "when stderr is a TTY" do
-        before { expect(subject.stderr).to receive(:tty?).and_return(true) }
-
-        it "must print a message, bug_report_url, and a highlighted exception" do
-          subject.print_bug_report(exception)
-
-          expect(subject.stderr.string).to eq(
-            [
-              '',
-              'Oops! Looks like you have found a bug. Please report it!',
-              command_class.bug_report_url,
-              '',
-              '```',
-              exception.full_message(highlight: true).chomp,
-              '```',
-              ''
-            ].join($/)
-          )
-        end
-      end
-
-      context "when stderr is not a TTY" do
-        it "must print a message, bug_report_url, and print an unhighlighted exception" do
-          subject.print_bug_report(exception)
-
-          expect(subject.stderr.string).to eq(
-            [
-              '',
-              'Oops! Looks like you have found a bug. Please report it!',
-              command_class.bug_report_url,
-              '',
-              '```',
-              exception.full_message(highlight: false).chomp,
-              '```',
-              ''
-            ].join($/)
-          )
-        end
-      end
-    end
-
-    context "when the command does not have bug_report_url set" do
-      let(:command_class) { TestBugReport::CommandWithoutBugReportURLSet }
-
-      context "when stderr is a TTY" do
-        before { expect(subject.stderr).to receive(:tty?).and_return(true) }
-
-        it "must print a message and a highlighted exception" do
-          subject.print_bug_report(exception)
-
-          expect(subject.stderr.string).to eq(
-            [
-              '',
-              'Oops! Looks like you have found a bug. Please report it!',
-              '',
-              '```',
-              exception.full_message(highlight: true).chomp,
-              '```',
-              ''
-            ].join($/)
-          )
-        end
-      end
-
-      context "when stderr is not a TTY" do
-        it "must print a message and print an unhighlighted exception" do
-          subject.print_bug_report(exception)
-
-          expect(subject.stderr.string).to eq(
-            [
-              '',
-              'Oops! Looks like you have found a bug. Please report it!',
-              '',
-              '```',
-              exception.full_message(highlight: false).chomp,
-              '```',
-              ''
-            ].join($/)
-          )
-        end
-      end
-    end
-  end
-
-  describe "#on_exception" do
-    let(:exception) { RuntimeError.new('error!') }
-
-    it "must call print_bug_report with the exception and then exit(-1)" do
-      expect(subject).to receive(:print_bug_report).with(exception)
-      expect(subject).to receive(:exit).with(-1)
-
-      subject.on_exception(exception)
-    end
-  end
-end