command_kit 0.1.0.pre1

data/spec/arguments/argument_value_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+require 'command_kit/arguments/argument_value'
+
+describe CommandKit::Arguments::ArgumentValue do
+  let(:type)     { String }
+  let(:required) { false  }
+  let(:default)  { "foo"  }
+  let(:usage)    { 'FOO'  }
+
+  subject do
+    described_class.new(
+      type:     type,
+      required: required,
+      default:  default,
+      usage:    usage
+    )
+  end
+
+  describe "#initialize" do
+    it "must require a usage: keyword"do
+      expect {
+        described_class.new(type: type, required: required, default: default)
+      }.to raise_error(ArgumentError)
+    end
+
+    context "when type: is given" do
+      subject { described_class.new(type: type, usage: usage) }
+
+      it "must set #type" do
+        expect(subject.type).to eq(type)
+      end
+    end
+
+    context "when type: is not given" do
+      subject { described_class.new(usage: usage) }
+
+      it "must default to nil" do
+        expect(subject.type).to be_nil
+      end
+    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
+
+    context "when default: is given" do
+      subject { described_class.new(default: default, usage: usage) }
+
+      it "must set #default" do
+        expect(subject.default).to eq(default)
+      end
+    end
+
+    context "when default: is not given" do
+      subject { described_class.new(usage: usage) }
+
+      it "must default to nil" do
+        expect(subject.default).to be_nil
+      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
+
+  describe "#default_value" do
+    context "when initialized with a default: that responded to #call" do
+      let(:default) do
+        ->{ [] }
+      end
+
+      it "must call the default #call method" do
+        expect(subject.default_value).to eq(default.call)
+      end
+    end
+
+    context "when initialized with a default: that it's an Object" do
+      let(:default) { "" }
+
+      it "must return the default: object" do
+        expect(subject.default_value).to eq(default)
+      end
+
+      it "must duplicate the default: object each time" do
+        expect(subject.default_value).to_not be(subject.default_value)
+      end
+    end
+  end
+end

data/spec/arguments_spec.rb

@@ -0,0 +1,213 @@
+require 'spec_helper'
+require 'command_kit/arguments'
+
+describe Arguments do
+  module TestArguments
+    class ImplicitCmd
+      include CommandKit::Arguments
+    end
+  end
+
+  let(:command_class) { TestArguments::ImplicitCmd }
+
+  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 "#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 an Array" 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
+    end
+  end
+
+  describe "#help" do
+    it "must call #help_arguments" do
+      expect(subject).to receive(:help_arguments)
+
+      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::Arguments
+        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_arguments)
+
+        subject.help
+      end
+    end
+  end
+end

data/spec/colors_spec.rb

@@ -0,0 +1,470 @@
+require 'spec_helper'
+require 'command_kit/colors'
+
+describe Colors do
+  module TestColors
+    class TestCommand
+      include CommandKit::Colors
+    end
+  end
+
+  let(:command_class) { TestColors::TestCommand }
+  subject { command_class.new }
+
+  it { expect(described_class).to include(Stdio) }
+  it { expect(described_class).to include(Env) }
+
+  describe Colors::ANSI do
+    subject { described_class }
+
+    describe "RESET" do
+      it { expect(subject::RESET).to eq("\e[0m") }
+    end
+
+    describe "CLEAR" do
+      it { expect(subject::CLEAR).to eq("\e[0m") }
+    end
+
+    describe "BOLD" do
+      it { expect(subject::BOLD).to eq("\e[1m") }
+    end
+
+    describe "RESET_INTENSITY" do
+      it { expect(subject::RESET_INTENSITY).to eq("\e[22m") }
+    end
+
+    describe "BLACK" do
+      it { expect(subject::BLACK).to eq("\e[30m") }
+    end
+
+    describe "RED" do
+      it { expect(subject::RED).to eq("\e[31m") }
+    end
+
+    describe "GREEN" do
+      it { expect(subject::GREEN).to eq("\e[32m") }
+    end
+
+    describe "YELLOW" do
+      it { expect(subject::YELLOW).to eq("\e[33m") }
+    end
+
+    describe "BLUE" do
+      it { expect(subject::BLUE).to eq("\e[34m") }
+    end
+
+    describe "MAGENTA" do
+      it { expect(subject::MAGENTA).to eq("\e[35m") }
+    end
+
+    describe "CYAN" do
+      it { expect(subject::CYAN).to eq("\e[36m") }
+    end
+
+    describe "WHITE" do
+      it { expect(subject::WHITE).to eq("\e[37m") }
+    end
+
+    describe "RESET_COLOR" do
+      it { expect(subject::RESET_COLOR).to eq("\e[39m") }
+    end
+
+    let(:str) { 'foo' }
+
+    describe ".reset" do
+      it { expect(subject.reset).to eq(described_class::RESET) }
+    end
+
+    describe ".clear" do
+      it { expect(subject.clear).to eq(described_class::CLEAR) }
+    end
+
+    describe ".bold" do
+      context "when given a string" do
+        it "must wrap the string with \\e[1m and \\e[22m" do
+          expect(subject.bold(str)).to eq("\e[1m#{str}\e[22m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.bold).to eq("\e[1m") }
+      end
+    end
+
+    describe ".black" do
+      context "when given a string" do
+        it "must wrap the string with \\e[30m and \\e[39m" do
+          expect(subject.black(str)).to eq("\e[30m#{str}\e[39m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.black).to eq("\e[30m") }
+      end
+    end
+
+    describe ".red" do
+      context "when given a string" do
+        it "must wrap the string with \\e[31m and \\e[39m" do
+          expect(subject.red(str)).to eq("\e[31m#{str}\e[39m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.red).to eq("\e[31m") }
+      end
+    end
+
+    describe ".green" do
+      context "when given a string" do
+        it "must wrap the string with \\e[32m and \\e[39m" do
+          expect(subject.green(str)).to eq("\e[32m#{str}\e[39m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.green).to eq("\e[32m") }
+      end
+    end
+
+    describe ".yellow" do
+      context "when given a string" do
+        it "must wrap the string with \\e[33m and \\e[39m" do
+          expect(subject.yellow(str)).to eq("\e[33m#{str}\e[39m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.yellow).to eq("\e[33m") }
+      end
+    end
+
+    describe ".blue" do
+      context "when given a string" do
+        it "must wrap the string with \\e[34m and \\e[39m" do
+          expect(subject.blue(str)).to eq("\e[34m#{str}\e[39m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.blue).to eq("\e[34m") }
+      end
+    end
+
+    describe ".magenta" do
+      context "when given a string" do
+        it "must wrap the string with \\e[35m and \\e[39m" do
+          expect(subject.magenta(str)).to eq("\e[35m#{str}\e[39m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.magenta).to eq("\e[35m") }
+      end
+    end
+
+    describe ".cyan" do
+      context "when given a string" do
+        it "must wrap the string with \\e[36m and \\e[39m" do
+          expect(subject.cyan(str)).to eq("\e[36m#{str}\e[39m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.cyan).to eq("\e[36m") }
+      end
+    end
+
+    describe ".white" do
+      context "when given a string" do
+        it "must wrap the string with \\e[37m and \\e[39m" do
+          expect(subject.white(str)).to eq("\e[37m#{str}\e[39m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.white).to eq("\e[37m") }
+      end
+    end
+  end
+
+  describe Colors::PlainText do
+    subject { described_class }
+
+    let(:str) { 'foo' }
+
+    describe "RESET" do
+      it { expect(subject::RESET).to eq('') }
+    end
+
+    describe "CLEAR" do
+      it { expect(subject::CLEAR).to eq('') }
+    end
+
+    describe "BOLD" do
+      it { expect(subject::BOLD).to eq('') }
+    end
+
+    describe "RESET_INTENSITY" do
+      it { expect(subject::RESET_INTENSITY).to eq('') }
+    end
+
+    describe "BLACK" do
+      it { expect(subject::BLACK).to eq('') }
+    end
+
+    describe "RED" do
+      it { expect(subject::RED).to eq('') }
+    end
+
+    describe "GREEN" do
+      it { expect(subject::GREEN).to eq('') }
+    end
+
+    describe "YELLOW" do
+      it { expect(subject::YELLOW).to eq('') }
+    end
+
+    describe "BLUE" do
+      it { expect(subject::BLUE).to eq('') }
+    end
+
+    describe "MAGENTA" do
+      it { expect(subject::MAGENTA).to eq('') }
+    end
+
+    describe "CYAN" do
+      it { expect(subject::CYAN).to eq('') }
+    end
+
+    describe "WHITE" do
+      it { expect(subject::WHITE).to eq('') }
+    end
+
+    describe "RESET_COLOR" do
+      it { expect(subject::RESET_COLOR).to eq('') }
+    end
+
+    describe ".reset" do
+      it { expect(subject.reset).to eq('') }
+    end
+
+    describe ".clear" do
+      it { expect(subject.clear).to eq('') }
+    end
+
+    describe ".bold" do
+      context "when given a string" do
+        it "must return that string" do
+          expect(subject.bold(str)).to eq(str)
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.bold).to eq('') }
+      end
+    end
+
+    describe ".black" do
+      context "when given a string" do
+        it "must return that string" do
+          expect(subject.black(str)).to eq(str)
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.black).to eq('') }
+      end
+    end
+
+    describe ".red" do
+      context "when given a string" do
+        it "must return that string" do
+          expect(subject.red(str)).to eq(str)
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.red).to eq('') }
+      end
+    end
+
+    describe ".green" do
+      context "when given a string" do
+        it "must return that string" do
+          expect(subject.green(str)).to eq(str)
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.green).to eq('') }
+      end
+    end
+
+    describe ".yellow" do
+      context "when given a string" do
+        it "must return that string" do
+          expect(subject.yellow(str)).to eq(str)
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.yellow).to eq('') }
+      end
+    end
+
+    describe ".blue" do
+      context "when given a string" do
+        it "must return that string" do
+          expect(subject.blue(str)).to eq(str)
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.blue).to eq('') }
+      end
+    end
+
+    describe ".magenta" do
+      context "when given a string" do
+        it "must return that string" do
+          expect(subject.magenta(str)).to eq(str)
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.magenta).to eq('') }
+      end
+    end
+
+    describe ".cyan" do
+      context "when given a string" do
+        it "must return that string" do
+          expect(subject.cyan(str)).to eq(str)
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.cyan).to eq('') }
+      end
+    end
+
+    describe ".white" do
+      context "when given a string" do
+        it "must return that string" do
+          expect(subject.white(str)).to eq(str)
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.white).to eq('') }
+      end
+    end
+  end
+
+  describe "#ansi?" do
+    context "when TERM='dumb'" do
+      subject { command_class.new(env: {'TERM' => 'dumb'}) }
+
+      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) }
+
+      before { allow(stdout).to receive(:tty?).and_return(true) }
+
+      it { expect(subject.ansi?).to be(true) }
+    end
+
+    context "when stdout is not a TTY" do
+      let(:stdout) { StringIO.new }
+      subject { command_class.new(stdout: stdout) }
+
+      it { expect(subject.ansi?).to be(false) }
+    end
+
+    context "when given an alternate stream" do
+      context "and the alternate stream is a TTY" do
+        let(:stream) { StringIO.new }
+
+        before { allow(stream).to receive(:tty?).and_return(true) }
+
+        it { expect(subject.ansi?(stream)).to be(true) }
+      end
+
+      context "but the alternate stream is not a TTY" do
+        let(:stream) { StringIO.new }
+
+        it { expect(subject.ansi?(stream)).to be(false) }
+      end
+    end
+  end
+
+  describe "#colors" do
+    context "when stdout supports ANSI" do
+      let(:stdout) { StringIO.new }
+      subject { command_class.new(stdout: stdout) }
+
+      before { allow(stdout).to receive(:tty?).and_return(true) }
+
+      it { expect(subject.colors).to be(Colors::ANSI) }
+
+      context "when a block is given" do
+        it do
+          expect { |b|
+            subject.colors(&b)
+          }.to yield_with_args(Colors::ANSI)
+        end
+      end
+    end
+
+    context "when stdout does not support ANSI" do
+      let(:stdout) { StringIO.new }
+      subject { command_class.new(stdout: stdout) }
+
+      it { expect(subject.colors).to be(Colors::PlainText) }
+
+      context "when a block is given" do
+        it do
+          expect { |b|
+            subject.colors(&b)
+          }.to yield_with_args(Colors::PlainText)
+        end
+      end
+    end
+
+    context "when given an alternate stream" do
+      context "and the alternate stream supports ANSI" do
+        let(:stream) { StringIO.new }
+
+        before { allow(stream).to receive(:tty?).and_return(true) }
+
+        it { expect(subject.colors(stream)).to be(Colors::ANSI) }
+
+        context "when a block is given" do
+          it do
+            expect { |b|
+              subject.colors(stream,&b)
+            }.to yield_with_args(Colors::ANSI)
+          end
+        end
+      end
+
+      context "but the alternate stream does not support ANSI" do
+        let(:stream) { StringIO.new }
+
+        it { expect(subject.colors(stream)).to be(Colors::PlainText) }
+
+        context "when a block is given" do
+          it do
+            expect { |b|
+              subject.colors(stream,&b)
+            }.to yield_with_args(Colors::PlainText)
+          end
+        end
+      end
+    end
+  end
+end