command_kit 0.3.0 → 0.4.1

data/spec/bug_report_spec.rb

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

data/spec/colors_spec.rb

@@ -656,6 +656,12 @@ describe CommandKit::Colors do
       it { expect(subject.ansi?).to be(false) }
     end
 
+    context "when NO_COLOR is set" do
+      subject { command_class.new(env: {'NO_COLOR' => 'true'}) }
+
+      it { expect(subject.ansi?).to be(false) }
+    end
+
     context "when stdout is a TTY" do
       let(:stdout) { StringIO.new }
       subject { command_class.new(stdout: stdout) }

data/spec/command_name_spec.rb

@@ -19,7 +19,7 @@ describe CommandKit::CommandName do
       end
     end
 
-    context "when a command_name is explicitly set" do
+    context "when a command_name has been explicitly set" do
       module TestCommandName
         class ExplicitCmd
           include CommandKit::CommandName

data/spec/commands_spec.rb

@@ -155,6 +155,32 @@ describe CommandKit::Commands do
 
   let(:command_class) { TestCommands::TestCommands }
 
+  describe ".included" do
+    subject { command_class }
+
+    it "must set .usage to '[options] [COMMAND [ARGS...]]'" do
+      expect(subject.usage).to eq('[options] [COMMAND [ARGS...]]')
+    end
+
+    it "must add a 'command' argument" do
+      expect(subject.arguments[:command]).to_not be_nil
+      expect(subject.arguments[:command].required?).to be(false)
+      expect(subject.arguments[:command].desc).to eq('The command name to run')
+    end
+
+    it "must add a 'args' argument" do
+      expect(subject.arguments[:args]).to_not be_nil
+      expect(subject.arguments[:args].required?).to be(false)
+      expect(subject.arguments[:args].repeats?).to be(true)
+      expect(subject.arguments[:args].desc).to eq('Additional arguments for the command')
+    end
+
+    it "must add a 'help' command" do
+      expect(subject.commands['help']).to_not be(nil)
+      expect(subject.commands['help'].command).to be(described_class::Help)
+    end
+  end
+
   describe ".commands" do
     subject { command_class }
 

data/spec/edit_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'command_kit/edit'
+
+describe CommandKit::Edit do
+  module TestEdit
+    class TestCommand
+      include CommandKit::Edit
+    end
+  end
+
+  let(:command_class) { TestEdit::TestCommand }
+
+  it "must also include CommandKit::Env" do
+    expect(command_class).to include(CommandKit::Env)
+  end
+
+  describe "#editor" do
+    subject { command_class.new(env: env) }
+
+    context "when env['EDITOR'] is set" do
+      let(:editor) { 'vim' }
+      let(:env) do
+        {'EDITOR' => editor}
+      end
+
+      it "must return env['EDITOR']" do
+        expect(subject.editor).to eq(env['EDITOR'])
+      end
+    end
+
+    context "when env['EDITOR'] is not set" do
+      let(:env) do
+        {}
+      end
+
+      it "must return 'nano'" do
+        expect(subject.editor).to eq('nano')
+      end
+    end
+  end
+
+  describe "#edit" do
+    subject { command_class.new(env: env) }
+
+    let(:arguments) { ['file.txt'] }
+
+    context "when env['EDITOR'] is set" do
+      let(:editor) { 'vim' }
+      let(:env) do
+        {'EDITOR' => editor}
+      end
+
+      it "must invoke system with #editor and the additional arguments" do
+        expect(subject).to receive(:system).with(subject.editor,*arguments)
+
+        subject.edit(*arguments)
+      end
+    end
+
+    context "when env['EDITOR'] is not set" do
+      let(:env) do
+        {}
+      end
+
+      it "must invoke system with 'nano' and the additional arguments" do
+        expect(subject).to receive(:system).with('nano',*arguments)
+
+        subject.edit(*arguments)
+      end
+    end
+  end
+end

data/spec/options/option_spec.rb

@@ -6,10 +6,12 @@ describe CommandKit::Options::Option do
   let(:short)  { nil     }
   let(:long)   { '--foo' }
   let(:equals) { false   }
+  let(:value_usage)    { 'FOO' }
+  let(:value_required) { true  }
   let(:value) do
     {
-      usage:    'FOO',
-      required: true
+      usage:    value_usage,
+      required: value_required
     }
   end
   let(:desc)  { 'Foo option' }
@@ -228,6 +230,14 @@ describe CommandKit::Options::Option do
         it "must return '--option=USAGE'" do
           expect(subject.usage.last).to eq("#{long}=#{subject.value.usage}")
         end
+
+        context "but the #value is also optional?" do
+          let(:value_required) { false }
+
+          it "must return '--option[=USAGE]'" do
+            expect(subject.usage.last).to eq("#{long}[=#{subject.value.usage}]")
+          end
+        end
       end
     end
 

data/spec/options/parser_spec.rb

@@ -19,6 +19,25 @@ describe CommandKit::Options::Parser do
     it { expect(subject).to include(CommandKit::Main) }
     it { expect(subject).to include(CommandKit::Usage) }
     it { expect(subject.usage).to eq('[options]') }
+
+    context "when the command class already defines a usage string" do
+      module TestOptionParser
+        class TestCommandWithUsage
+          include CommandKit::Usage
+
+          usage '[options] ARGS...'
+
+          include CommandKit::Options::Parser
+        end
+      end
+
+      let(:command_class) { TestOptionParser::TestCommandWithUsage }
+      subject { command_class }
+
+      it "must not override the usage" do
+        expect(subject.usage).to eq('[options] ARGS...')
+      end
+    end
   end
 
   subject { command_class.new }

data/spec/options/quiet_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'command_kit/options/quiet'
+
+describe CommandKit::Options::Quiet do
+  module TestOptionsQuiet
+    class TestCommand
+      include CommandKit::Options::Quiet
+    end
+  end
+
+  let(:command_class) { TestOptionsQuiet::TestCommand }
+
+  describe ".included" do
+    subject { command_class }
+
+    it "must include CommandKit::Options" do
+      expect(subject).to include(CommandKit::Options)
+    end
+
+    it "must define a quiet option" do
+      expect(subject.options[:quiet]).to_not be(nil)
+      expect(subject.options[:quiet].short).to eq('-q')
+      expect(subject.options[:quiet].long).to eq('--quiet')
+      expect(subject.options[:quiet].desc).to eq('Enables quiet output')
+    end
+  end
+
+  subject { command_class.new }
+
+  describe "#quiet?" do
+    context "when @quiet is true" do
+      before do
+        subject.instance_variable_set('@quiet',true)
+      end
+
+      it "must return true" do
+        expect(subject.quiet?).to be(true)
+      end
+    end
+
+    context "when @quiet is false" do
+      before do
+        subject.instance_variable_set('@quiet',false)
+      end
+
+      it "must return false" do
+        expect(subject.quiet?).to be(false)
+      end
+    end
+  end
+end

data/spec/options/verbose_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'command_kit/options/verbose'
+
+describe CommandKit::Options::Verbose do
+  module TestOptionsVerbose
+    class TestCommand
+      include CommandKit::Options::Verbose
+    end
+  end
+
+  let(:command_class) { TestOptionsVerbose::TestCommand }
+
+  describe ".included" do
+    subject { command_class }
+
+    it "must include CommandKit::Options" do
+      expect(subject).to include(CommandKit::Options)
+    end
+
+    it "must define a verbose option" do
+      expect(subject.options[:verbose]).to_not be(nil)
+      expect(subject.options[:verbose].short).to eq('-v')
+      expect(subject.options[:verbose].long).to eq('--verbose')
+      expect(subject.options[:verbose].desc).to eq('Enables verbose output')
+    end
+  end
+
+  subject { command_class.new }
+
+  describe "#verbose?" do
+    context "when @verbose is true" do
+      before do
+        subject.instance_variable_set('@verbose',true)
+      end
+
+      it "must return true" do
+        expect(subject.verbose?).to be(true)
+      end
+    end
+
+    context "when @verbose is false" do
+      before do
+        subject.instance_variable_set('@verbose',false)
+      end
+
+      it "must return false" do
+        expect(subject.verbose?).to be(false)
+      end
+    end
+  end
+end

data/spec/options/version_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+require 'command_kit/options/version'
+
+require 'stringio'
+
+describe CommandKit::Options::Version do
+  module TestOptionsVersion
+    class TestCommandWithoutVersion
+
+      include CommandKit::Options::Version
+
+      command_name 'test'
+
+    end
+
+    class TestCommandWithVersion
+
+      include CommandKit::Options::Version
+
+      command_name 'test'
+      version '0.1.0'
+
+    end
+  end
+
+  describe ".included" do
+    subject { TestOptionsVersion::TestCommandWithVersion }
+
+    it "must include CommandKit::Options" do
+      expect(subject).to include(CommandKit::Options)
+    end
+  end
+
+  describe ".version" do
+    context "when no .version has been previously set" do
+      subject { TestOptionsVersion::TestCommandWithoutVersion }
+
+      it "must return nil" do
+        expect(subject.version).to be(nil)
+      end
+    end
+
+    context "when a .version has been set" do
+      subject { TestOptionsVersion::TestCommandWithVersion }
+
+      it "must return the set version" do
+        expect(subject.version).to eq('0.1.0')
+      end
+    end
+
+    context "when the command class inherites from another class" do
+      context "but no version are defined" do
+        module TestOptionsVersion
+          class InheritedCommandWithoutVersion < TestCommandWithoutVersion
+          end
+        end
+
+        subject { TestOptionsVersion::InheritedCommandWithoutVersion }
+
+        it "must return nil" do
+          expect(subject.version).to be(nil)
+        end
+      end
+
+      context "when the superclass defines the version" do
+        module TestOptionsVersion
+          class InheritedCommandWithInheritedVersion < TestCommandWithVersion
+          end
+        end
+
+        let(:super_class) { TestOptionsVersion::TestCommandWithVersion }
+        subject { TestOptionsVersion::InheritedCommandWithInheritedVersion }
+
+        it "must return the version defined in the superclass" do
+          expect(subject.version).to eq(super_class.version)
+        end
+      end
+
+      context "when the subclass defines the version" do
+        module TestOptionsVersion
+          class InheritedCommandWithOwnVersion < TestCommandWithoutVersion
+
+            version '0.1.0'
+
+          end
+        end
+
+        let(:super_subject) { TestOptionsVersion::TestCommandWithoutVersion }
+        subject { TestOptionsVersion::InheritedCommandWithOwnVersion }
+
+        it "must return the version set in the subclass" do
+          expect(subject.version).to eq('0.1.0')
+        end
+
+        it "must not change the superclass'es version" do
+          expect(super_subject.version).to be(nil)
+        end
+      end
+
+      context "when subclass overrides the superclass's version" do
+        module TestOptionsVersion
+          class InheritedCommandThatOverridesVersion < TestCommandWithVersion
+
+            version '0.2.0'
+
+          end
+        end
+
+        let(:super_subject) { TestOptionsVersion::TestCommandWithVersion }
+        subject { TestOptionsVersion::InheritedCommandThatOverridesVersion }
+
+        it "must return the version set in the subclass" do
+          expect(subject.version).to eq('0.2.0')
+        end
+
+        it "must not change the superclass'es version" do
+          expect(super_subject.version).to eq('0.1.0')
+        end
+      end
+    end
+  end
+
+  let(:command_class) { TestOptionsVersion::TestCommandWithVersion }
+
+  subject { command_class.new }
+
+  describe "#version" do
+    it "must return the class'es .version value" do
+      expect(subject.version).to eq(command_class.version)
+    end
+  end
+
+  describe "#print_version" do
+    let(:stdout) { StringIO.new }
+
+    subject { command_class.new(stdout: stdout) }
+
+    it "must print the #command_name and #version" do
+      subject.print_version
+
+      expect(stdout.string).to eq(
+        "#{subject.command_name} #{subject.version}#{$/}"
+      )
+    end
+  end
+end