command_kit 0.1.0.pre1 → 0.2.0

data/lib/command_kit.rb

@@ -1 +1,2 @@
+require 'command_kit/command'
 require 'command_kit/version'

data/spec/arguments/argument_spec.rb

@@ -1,41 +1,21 @@
 require 'spec_helper'
 require 'command_kit/arguments/argument'
 
-describe Arguments::Argument do
+describe CommandKit::Arguments::Argument do
   let(:name)     { :foo }
-  let(:type)     { String }
   let(:usage)    { 'FOO' }
-  let(:default)  { 'foo' }
   let(:required) { true }
   let(:repeats)  { false }
   let(:desc)     { 'Foo argument' }
 
   subject do
-    described_class.new name, type:     type,
-                              usage:    usage,
-                              default:  default,
+    described_class.new name, usage:    usage,
                               required: required,
                               repeats:  repeats,
                               desc:     desc
   end
 
   describe "#initialize" do
-    context "when the type: keyword is given" do
-      subject { described_class.new(name, type: type, desc: desc) }
-
-      it "must set #type" do
-        expect(subject.type).to eq(type)
-      end
-    end
-
-    context "when the type: keyword is not given" do
-      subject { described_class.new(name, desc: desc) }
-
-      it "default #type to String" do
-        expect(subject.type).to eq(String)
-      end
-    end
-
     context "when the usage: keyword is given" do
       subject { described_class.new(name, usage: usage, desc: desc) }
 
@@ -52,22 +32,6 @@ describe Arguments::Argument do
       end
     end
 
-    context "when the default: keyword is given" do
-      subject { described_class.new(name, default: default, desc: desc) }
-
-      it "must set #default" do
-        expect(subject.default).to eq(default)
-      end
-    end
-
-    context "when the default: keyword is not given" do
-      subject { described_class.new(name, desc: desc) }
-
-      it "default #default to String" do
-        expect(subject.default).to eq(nil)
-      end
-    end
-
     context "when the required: keyword is given" do
       subject { described_class.new(name, required: required, desc: desc) }
 
@@ -88,7 +52,7 @@ describe Arguments::Argument do
       subject { described_class.new(name, repeats: repeats, desc: desc) }
 
       it "must set #repeats" do
-        expect(subject.repeats).to eq(repeats)
+        expect(subject.repeats?).to eq(repeats)
       end
     end
 
@@ -96,7 +60,7 @@ describe Arguments::Argument do
       subject { described_class.new(name, desc: desc) }
 
       it "default #repeats to String" do
-        expect(subject.repeats).to eq(false)
+        expect(subject.repeats?).to eq(false)
       end
     end
 
@@ -162,7 +126,7 @@ describe Arguments::Argument do
       let(:repeats) { false }
 
       it "must return the usage name unchanged" do
-        expect(subject.usage).to eq("#{usage}")
+        expect(subject.usage).to eq(usage)
       end
     end
   end

data/spec/arguments/argument_value_spec.rb

@@ -2,16 +2,12 @@ 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
@@ -19,26 +15,10 @@ describe CommandKit::Arguments::ArgumentValue do
   describe "#initialize" do
     it "must require a usage: keyword"do
       expect {
-        described_class.new(type: type, required: required, default: default)
+        described_class.new(required: required)
       }.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) }
 
@@ -54,22 +34,6 @@ describe CommandKit::Arguments::ArgumentValue 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
@@ -99,28 +63,4 @@ describe CommandKit::Arguments::ArgumentValue do
       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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'command_kit/arguments'
 
-describe Arguments do
+describe CommandKit::Arguments do
   module TestArguments
     class ImplicitCmd
       include CommandKit::Arguments
@@ -10,6 +10,13 @@ describe Arguments do
 
   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 }
 
@@ -185,29 +192,5 @@ describe Arguments do
 
       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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'command_kit/colors'
 
-describe Colors do
+describe CommandKit::Colors do
   module TestColors
     class TestCommand
       include CommandKit::Colors
@@ -11,10 +11,10 @@ describe Colors do
   let(:command_class) { TestColors::TestCommand }
   subject { command_class.new }
 
-  it { expect(described_class).to include(Stdio) }
-  it { expect(described_class).to include(Env) }
+  it { expect(described_class).to include(CommandKit::Stdio) }
+  it { expect(described_class).to include(CommandKit::Env) }
 
-  describe Colors::ANSI do
+  describe CommandKit::Colors::ANSI do
     subject { described_class }
 
     describe "RESET" do
@@ -65,6 +65,38 @@ describe Colors do
       it { expect(subject::WHITE).to eq("\e[37m") }
     end
 
+    describe "ON_BLACK" do
+      it { expect(subject::ON_BLACK).to eq("\e[40m") }
+    end
+
+    describe "ON_RED" do
+      it { expect(subject::ON_RED).to eq("\e[41m") }
+    end
+
+    describe "ON_GREEN" do
+      it { expect(subject::ON_GREEN).to eq("\e[42m") }
+    end
+
+    describe "ON_YELLOW" do
+      it { expect(subject::ON_YELLOW).to eq("\e[43m") }
+    end
+
+    describe "ON_BLUE" do
+      it { expect(subject::ON_BLUE).to eq("\e[44m") }
+    end
+
+    describe "ON_MAGENTA" do
+      it { expect(subject::ON_MAGENTA).to eq("\e[45m") }
+    end
+
+    describe "ON_CYAN" do
+      it { expect(subject::ON_CYAN).to eq("\e[46m") }
+    end
+
+    describe "ON_WHITE" do
+      it { expect(subject::ON_WHITE).to eq("\e[47m") }
+    end
+
     describe "RESET_COLOR" do
       it { expect(subject::RESET_COLOR).to eq("\e[39m") }
     end
@@ -186,9 +218,105 @@ describe Colors do
         it { expect(subject.white).to eq("\e[37m") }
       end
     end
+
+    describe ".on_black" do
+      context "when given a string" do
+        it "must wrap the string with \\e[40m and \\e[39m" do
+          expect(subject.on_black(str)).to eq("\e[40m#{str}\e[49m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.on_black).to eq("\e[40m") }
+      end
+    end
+
+    describe ".on_red" do
+      context "when given a string" do
+        it "must wrap the string with \\e[41m and \\e[39m" do
+          expect(subject.on_red(str)).to eq("\e[41m#{str}\e[49m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.on_red).to eq("\e[41m") }
+      end
+    end
+
+    describe ".on_green" do
+      context "when given a string" do
+        it "must wrap the string with \\e[42m and \\e[39m" do
+          expect(subject.on_green(str)).to eq("\e[42m#{str}\e[49m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.on_green).to eq("\e[42m") }
+      end
+    end
+
+    describe ".on_yellow" do
+      context "when given a string" do
+        it "must wrap the string with \\e[43m and \\e[39m" do
+          expect(subject.on_yellow(str)).to eq("\e[43m#{str}\e[49m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.on_yellow).to eq("\e[43m") }
+      end
+    end
+
+    describe ".on_blue" do
+      context "when given a string" do
+        it "must wrap the string with \\e[44m and \\e[39m" do
+          expect(subject.on_blue(str)).to eq("\e[44m#{str}\e[49m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.on_blue).to eq("\e[44m") }
+      end
+    end
+
+    describe ".on_magenta" do
+      context "when given a string" do
+        it "must wrap the string with \\e[45m and \\e[39m" do
+          expect(subject.on_magenta(str)).to eq("\e[45m#{str}\e[49m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.on_magenta).to eq("\e[45m") }
+      end
+    end
+
+    describe ".on_cyan" do
+      context "when given a string" do
+        it "must wrap the string with \\e[46m and \\e[39m" do
+          expect(subject.on_cyan(str)).to eq("\e[46m#{str}\e[49m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.on_cyan).to eq("\e[46m") }
+      end
+    end
+
+    describe ".on_white" do
+      context "when given a string" do
+        it "must wrap the string with \\e[47m and \\e[39m" do
+          expect(subject.on_white(str)).to eq("\e[47m#{str}\e[49m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.on_white).to eq("\e[47m") }
+      end
+    end
   end
 
-  describe Colors::PlainText do
+  describe CommandKit::Colors::PlainText do
     subject { described_class }
 
     let(:str) { 'foo' }
@@ -241,6 +369,38 @@ describe Colors do
       it { expect(subject::WHITE).to eq('') }
     end
 
+    describe "ON_BLACK" do
+      it { expect(subject::ON_BLACK).to eq('') }
+    end
+
+    describe "ON_RED" do
+      it { expect(subject::ON_RED).to eq('') }
+    end
+
+    describe "ON_GREEN" do
+      it { expect(subject::ON_GREEN).to eq('') }
+    end
+
+    describe "ON_YELLOW" do
+      it { expect(subject::ON_YELLOW).to eq('') }
+    end
+
+    describe "ON_BLUE" do
+      it { expect(subject::ON_BLUE).to eq('') }
+    end
+
+    describe "ON_MAGENTA" do
+      it { expect(subject::ON_MAGENTA).to eq('') }
+    end
+
+    describe "ON_CYAN" do
+      it { expect(subject::ON_CYAN).to eq('') }
+    end
+
+    describe "ON_WHITE" do
+      it { expect(subject::ON_WHITE).to eq('') }
+    end
+
     describe "RESET_COLOR" do
       it { expect(subject::RESET_COLOR).to eq('') }
     end
@@ -360,6 +520,102 @@ describe Colors do
         it { expect(subject.white).to eq('') }
       end
     end
+
+    describe ".on_black" do
+      context "when given a string" do
+        it "must return that string" do
+          expect(subject.on_black(str)).to eq(str)
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.on_black).to eq('') }
+      end
+    end
+
+    describe ".on_red" do
+      context "when given a string" do
+        it "must return that string" do
+          expect(subject.on_red(str)).to eq(str)
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.on_red).to eq('') }
+      end
+    end
+
+    describe ".on_green" do
+      context "when given a string" do
+        it "must return that string" do
+          expect(subject.on_green(str)).to eq(str)
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.on_green).to eq('') }
+      end
+    end
+
+    describe ".on_yellow" do
+      context "when given a string" do
+        it "must return that string" do
+          expect(subject.on_yellow(str)).to eq(str)
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.on_yellow).to eq('') }
+      end
+    end
+
+    describe ".on_blue" do
+      context "when given a string" do
+        it "must return that string" do
+          expect(subject.on_blue(str)).to eq(str)
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.on_blue).to eq('') }
+      end
+    end
+
+    describe ".on_magenta" do
+      context "when given a string" do
+        it "must return that string" do
+          expect(subject.on_magenta(str)).to eq(str)
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.on_magenta).to eq('') }
+      end
+    end
+
+    describe ".on_cyan" do
+      context "when given a string" do
+        it "must return that string" do
+          expect(subject.on_cyan(str)).to eq(str)
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.on_cyan).to eq('') }
+      end
+    end
+
+    describe ".on_white" do
+      context "when given a string" do
+        it "must return that string" do
+          expect(subject.on_white(str)).to eq(str)
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.on_white).to eq('') }
+      end
+    end
   end
 
   describe "#ansi?" do
@@ -409,13 +665,15 @@ describe Colors do
 
       before { allow(stdout).to receive(:tty?).and_return(true) }
 
-      it { expect(subject.colors).to be(Colors::ANSI) }
+      it do
+        expect(subject.colors).to be(described_class::ANSI)
+      end
 
       context "when a block is given" do
         it do
           expect { |b|
             subject.colors(&b)
-          }.to yield_with_args(Colors::ANSI)
+          }.to yield_with_args(described_class::ANSI)
         end
       end
     end
@@ -424,13 +682,15 @@ describe Colors do
       let(:stdout) { StringIO.new }
       subject { command_class.new(stdout: stdout) }
 
-      it { expect(subject.colors).to be(Colors::PlainText) }
+      it do
+        expect(subject.colors).to be(described_class::PlainText)
+      end
 
       context "when a block is given" do
         it do
           expect { |b|
             subject.colors(&b)
-          }.to yield_with_args(Colors::PlainText)
+          }.to yield_with_args(described_class::PlainText)
         end
       end
     end
@@ -441,13 +701,15 @@ describe Colors do
 
         before { allow(stream).to receive(:tty?).and_return(true) }
 
-        it { expect(subject.colors(stream)).to be(Colors::ANSI) }
+        it do
+          expect(subject.colors(stream)).to be(described_class::ANSI)
+        end
 
         context "when a block is given" do
           it do
             expect { |b|
               subject.colors(stream,&b)
-            }.to yield_with_args(Colors::ANSI)
+            }.to yield_with_args(described_class::ANSI)
           end
         end
       end
@@ -455,13 +717,15 @@ describe Colors do
       context "but the alternate stream does not support ANSI" do
         let(:stream) { StringIO.new }
 
-        it { expect(subject.colors(stream)).to be(Colors::PlainText) }
+        it do
+          expect(subject.colors(stream)).to be(described_class::PlainText)
+        end
 
         context "when a block is given" do
           it do
             expect { |b|
               subject.colors(stream,&b)
-            }.to yield_with_args(Colors::PlainText)
+            }.to yield_with_args(described_class::PlainText)
           end
         end
       end