command_kit 0.1.0 → 0.3.0

data/spec/colors_spec.rb

@@ -65,6 +65,106 @@ describe CommandKit::Colors do
       it { expect(subject::WHITE).to eq("\e[37m") }
     end
 
+    describe "BRIGHT_BLACK" do
+      it { expect(subject::BRIGHT_BLACK).to eq("\e[90m") }
+    end
+
+    describe "BRIGHT_RED" do
+      it { expect(subject::BRIGHT_RED).to eq("\e[91m") }
+    end
+
+    describe "BRIGHT_GREEN" do
+      it { expect(subject::BRIGHT_GREEN).to eq("\e[92m") }
+    end
+
+    describe "BRIGHT_YELLOW" do
+      it { expect(subject::BRIGHT_YELLOW).to eq("\e[93m") }
+    end
+
+    describe "BRIGHT_BLUE" do
+      it { expect(subject::BRIGHT_BLUE).to eq("\e[94m") }
+    end
+
+    describe "BRIGHT_MAGENTA" do
+      it { expect(subject::BRIGHT_MAGENTA).to eq("\e[95m") }
+    end
+
+    describe "BRIGHT_CYAN" do
+      it { expect(subject::BRIGHT_CYAN).to eq("\e[96m") }
+    end
+
+    describe "BRIGHT_WHITE" do
+      it { expect(subject::BRIGHT_WHITE).to eq("\e[97m") }
+    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 "ON_BRIGHT_BLACK" do
+      it { expect(subject::ON_BRIGHT_BLACK).to eq("\e[100m") }
+    end
+
+    describe "ON_BRIGHT_RED" do
+      it { expect(subject::ON_BRIGHT_RED).to eq("\e[101m") }
+    end
+
+    describe "ON_BRIGHT_GREEN" do
+      it { expect(subject::ON_BRIGHT_GREEN).to eq("\e[102m") }
+    end
+
+    describe "ON_BRIGHT_YELLOW" do
+      it { expect(subject::ON_BRIGHT_YELLOW).to eq("\e[103m") }
+    end
+
+    describe "ON_BRIGHT_BLUE" do
+      it { expect(subject::ON_BRIGHT_BLUE).to eq("\e[104m") }
+    end
+
+    describe "ON_BRIGHT_MAGENTA" do
+      it { expect(subject::ON_BRIGHT_MAGENTA).to eq("\e[105m") }
+    end
+
+    describe "ON_BRIGHT_CYAN" do
+      it { expect(subject::ON_BRIGHT_CYAN).to eq("\e[106m") }
+    end
+
+    describe "ON_BRIGHT_WHITE" do
+      it { expect(subject::ON_BRIGHT_WHITE).to eq("\e[107m") }
+    end
+
+    describe "RESET_FG" do
+      it { expect(subject::RESET_FG).to eq("\e[39m") }
+    end
+
     describe "RESET_COLOR" do
       it { expect(subject::RESET_COLOR).to eq("\e[39m") }
     end
@@ -186,178 +286,365 @@ describe CommandKit::Colors do
         it { expect(subject.white).to eq("\e[37m") }
       end
     end
-  end
 
-  describe CommandKit::Colors::PlainText do
-    subject { described_class }
+    describe ".bright_black" do
+      context "when given a string" do
+        it "must wrap the string with \\e[90m and \\e[39m" do
+          expect(subject.bright_black(str)).to eq("\e[90m#{str}\e[39m")
+        end
+      end
 
-    let(:str) { 'foo' }
+      context "when given no arguments" do
+        it { expect(subject.bright_black).to eq("\e[90m") }
+      end
+    end
 
-    describe "RESET" do
-      it { expect(subject::RESET).to eq('') }
+    describe ".gray" do
+      context "when given a string" do
+        it "must wrap the string with \\e[90m and \\e[39m" do
+          expect(subject.gray(str)).to eq("\e[90m#{str}\e[39m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.gray).to eq("\e[90m") }
+      end
     end
 
-    describe "CLEAR" do
-      it { expect(subject::CLEAR).to eq('') }
+    describe ".bright_red" do
+      context "when given a string" do
+        it "must wrap the string with \\e[91m and \\e[39m" do
+          expect(subject.bright_red(str)).to eq("\e[91m#{str}\e[39m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.bright_red).to eq("\e[91m") }
+      end
     end
 
-    describe "BOLD" do
-      it { expect(subject::BOLD).to eq('') }
+    describe ".bright_green" do
+      context "when given a string" do
+        it "must wrap the string with \\e[92m and \\e[39m" do
+          expect(subject.bright_green(str)).to eq("\e[92m#{str}\e[39m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.bright_green).to eq("\e[92m") }
+      end
     end
 
-    describe "RESET_INTENSITY" do
-      it { expect(subject::RESET_INTENSITY).to eq('') }
+    describe ".bright_yellow" do
+      context "when given a string" do
+        it "must wrap the string with \\e[93m and \\e[39m" do
+          expect(subject.bright_yellow(str)).to eq("\e[93m#{str}\e[39m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.bright_yellow).to eq("\e[93m") }
+      end
     end
 
-    describe "BLACK" do
-      it { expect(subject::BLACK).to eq('') }
+    describe ".bright_blue" do
+      context "when given a string" do
+        it "must wrap the string with \\e[94m and \\e[39m" do
+          expect(subject.bright_blue(str)).to eq("\e[94m#{str}\e[39m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.bright_blue).to eq("\e[94m") }
+      end
     end
 
-    describe "RED" do
-      it { expect(subject::RED).to eq('') }
+    describe ".bright_magenta" do
+      context "when given a string" do
+        it "must wrap the string with \\e[95m and \\e[39m" do
+          expect(subject.bright_magenta(str)).to eq("\e[95m#{str}\e[39m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.bright_magenta).to eq("\e[95m") }
+      end
     end
 
-    describe "GREEN" do
-      it { expect(subject::GREEN).to eq('') }
+    describe ".bright_cyan" do
+      context "when given a string" do
+        it "must wrap the string with \\e[96m and \\e[39m" do
+          expect(subject.bright_cyan(str)).to eq("\e[96m#{str}\e[39m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.bright_cyan).to eq("\e[96m") }
+      end
     end
 
-    describe "YELLOW" do
-      it { expect(subject::YELLOW).to eq('') }
+    describe ".bright_white" do
+      context "when given a string" do
+        it "must wrap the string with \\e[97m and \\e[39m" do
+          expect(subject.bright_white(str)).to eq("\e[97m#{str}\e[39m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.bright_white).to eq("\e[97m") }
+      end
     end
 
-    describe "BLUE" do
-      it { expect(subject::BLUE).to eq('') }
+    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 "MAGENTA" do
-      it { expect(subject::MAGENTA).to eq('') }
+    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 "CYAN" do
-      it { expect(subject::CYAN).to eq('') }
+    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 "WHITE" do
-      it { expect(subject::WHITE).to eq('') }
+    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 "RESET_COLOR" do
-      it { expect(subject::RESET_COLOR).to eq('') }
+    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 ".reset" do
-      it { expect(subject.reset).to eq('') }
+    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 ".clear" do
-      it { expect(subject.clear).to eq('') }
+    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 ".bold" do
+    describe ".on_white" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.bold(str)).to eq(str)
+        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.bold).to eq('') }
+        it { expect(subject.on_white).to eq("\e[47m") }
       end
     end
 
-    describe ".black" do
+    describe ".on_bright_black" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.black(str)).to eq(str)
+        it "must wrap the string with \\e[100m and \\e[39m" do
+          expect(subject.on_bright_black(str)).to eq("\e[100m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.black).to eq('') }
+        it { expect(subject.on_bright_black).to eq("\e[100m") }
       end
     end
 
-    describe ".red" do
+    describe ".on_gray" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.red(str)).to eq(str)
+        it "must wrap the string with \\e[100m and \\e[39m" do
+          expect(subject.on_gray(str)).to eq("\e[100m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.red).to eq('') }
+        it { expect(subject.on_gray).to eq("\e[100m") }
       end
     end
 
-    describe ".green" do
+    describe ".on_bright_red" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.green(str)).to eq(str)
+        it "must wrap the string with \\e[101m and \\e[39m" do
+          expect(subject.on_bright_red(str)).to eq("\e[101m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.green).to eq('') }
+        it { expect(subject.on_bright_red).to eq("\e[101m") }
       end
     end
 
-    describe ".yellow" do
+    describe ".on_bright_green" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.yellow(str)).to eq(str)
+        it "must wrap the string with \\e[102m and \\e[39m" do
+          expect(subject.on_bright_green(str)).to eq("\e[102m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.yellow).to eq('') }
+        it { expect(subject.on_bright_green).to eq("\e[102m") }
       end
     end
 
-    describe ".blue" do
+    describe ".on_bright_yellow" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.blue(str)).to eq(str)
+        it "must wrap the string with \\e[103m and \\e[39m" do
+          expect(subject.on_bright_yellow(str)).to eq("\e[103m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.blue).to eq('') }
+        it { expect(subject.on_bright_yellow).to eq("\e[103m") }
       end
     end
 
-    describe ".magenta" do
+    describe ".on_bright_blue" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.magenta(str)).to eq(str)
+        it "must wrap the string with \\e[104m and \\e[39m" do
+          expect(subject.on_bright_blue(str)).to eq("\e[104m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.magenta).to eq('') }
+        it { expect(subject.on_bright_blue).to eq("\e[104m") }
       end
     end
 
-    describe ".cyan" do
+    describe ".on_bright_magenta" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.cyan(str)).to eq(str)
+        it "must wrap the string with \\e[105m and \\e[39m" do
+          expect(subject.on_bright_magenta(str)).to eq("\e[105m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.cyan).to eq('') }
+        it { expect(subject.on_bright_magenta).to eq("\e[105m") }
       end
     end
 
-    describe ".white" do
+    describe ".on_bright_cyan" do
+      context "when given a string" do
+        it "must wrap the string with \\e[106m and \\e[39m" do
+          expect(subject.on_bright_cyan(str)).to eq("\e[106m#{str}\e[49m")
+        end
+      end
+
+      context "when given no arguments" do
+        it { expect(subject.on_bright_cyan).to eq("\e[106m") }
+      end
+    end
+
+    describe ".on_bright_white" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.white(str)).to eq(str)
+        it "must wrap the string with \\e[107m and \\e[39m" do
+          expect(subject.on_bright_white(str)).to eq("\e[107m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.white).to eq('') }
+        it { expect(subject.on_bright_white).to eq("\e[107m") }
+      end
+    end
+  end
+
+  describe CommandKit::Colors::PlainText do
+    subject { described_class }
+
+    let(:str) { 'foo' }
+
+    [
+      :RESET, :CLEAR,
+      :BOLD, :RESET_INTENSITY,
+      :BLACK, :RED, :GREEN, :YELLOW, :BLUE, :MAGENTA, :CYAN, :WHITE,
+      :BRIGHT_BLACK, :BRIGHT_RED, :BRIGHT_GREEN, :BRIGHT_YELLOW, :BRIGHT_BLUE, :BRIGHT_MAGENTA, :BRIGHT_CYAN, :BRIGHT_WHITE,
+      :RESET_FG, :RESET_COLOR,
+      :ON_BLACK, :ON_RED, :ON_GREEN, :ON_YELLOW, :ON_BLUE, :ON_MAGENTA, :ON_CYAN, :ON_WHITE,
+      :ON_BRIGHT_BLACK, :ON_BRIGHT_RED, :ON_BRIGHT_GREEN, :ON_BRIGHT_YELLOW, :ON_BRIGHT_BLUE, :ON_BRIGHT_MAGENTA, :ON_BRIGHT_CYAN, :ON_BRIGHT_WHITE,
+      :RESET_BG
+    ].each do |const_name|
+      describe const_name.to_s do
+        it { expect(subject.const_get(const_name)).to eq('') }
+      end
+    end
+
+    describe ".reset" do
+      it { expect(subject.reset).to eq('') }
+    end
+
+    describe ".clear" do
+      it { expect(subject.clear).to eq('') }
+    end
+
+    [
+      :bold,
+      :black, :red, :green, :yellow, :blue, :magenta, :cyan, :white,
+      :bright_black, :gray, :bright_red, :bright_green, :bright_yellow, :bright_blue, :bright_magenta, :bright_cyan, :bright_white,
+      :on_black, :on_red, :on_green, :on_yellow, :on_blue, :on_magenta, :on_cyan, :on_white,
+      :on_bright_black, :on_gray, :on_bright_red, :on_bright_green, :on_bright_yellow, :on_bright_blue, :on_bright_magenta, :on_bright_cyan, :on_bright_white
+    ].each do |method_name|
+      describe ".#{method_name}" do
+        context "when given a string" do
+          it "must return that string" do
+            expect(subject.send(method_name,str)).to eq(str)
+          end
+        end
+
+        context "when given no arguments" do
+          it { expect(subject.send(method_name)).to eq('') }
+        end
       end
     end
   end

data/spec/command_spec.rb

@@ -26,14 +26,14 @@ describe CommandKit::Command do
     expect(described_class).to include(CommandKit::Usage)
   end
 
-  it "must include CommandKit::Arguments" do
-    expect(described_class).to include(CommandKit::Arguments)
-  end
-
   it "must include CommandKit::Options" do
     expect(described_class).to include(CommandKit::Options)
   end
 
+  it "must include CommandKit::Arguments" do
+    expect(described_class).to include(CommandKit::Arguments)
+  end
+
   it "must include CommandKit::Examples" do
     expect(described_class).to include(CommandKit::Examples)
   end
@@ -46,7 +46,78 @@ describe CommandKit::Command do
     expect(described_class).to include(CommandKit::ExceptionHandler)
   end
 
-  it "must include FileUtils" do
-    expect(described_class).to include(FileUtils)
+  it "must include CommandKit::FileUtils" do
+    expect(described_class).to include(CommandKit::FileUtils)
+  end
+
+  module TestCommandClass
+    class TestCommand < CommandKit::Command
+
+      usage '[OPTIONS] ARG1 [ARG2]'
+
+      option :option1, short: '-a',
+                       value: {
+                         type: Integer,
+                         default: 1
+                       },
+                       desc: "Option 1"
+
+      option :option2, short: '-b',
+                       value: {
+                         type: String,
+                         usage: 'FILE'
+                       },
+                       desc: "Option 2"
+
+      argument :argument1, required: true,
+                           usage:    'ARG1',
+                           desc:     "Argument 1"
+
+      argument :argument2, required: false,
+                           usage:    'ARG2',
+                           desc:     "Argument 2"
+
+      examples [
+        '-a 42 foo/bar/baz',
+        '-a 42 -b bar.txt baz qux'
+      ]
+
+      description 'Example command'
+
+    end
+  end
+
+  let(:command_class) { TestCommandClass::TestCommand }
+  subject { command_class.new }
+
+  describe "#help" do
+    let(:option1)   { command_class.options[:option1]     }
+    let(:option2)   { command_class.options[:option2]     }
+    let(:argument1) { command_class.arguments[:argument1] }
+    let(:argument2) { command_class.arguments[:argument2] }
+
+    it "must print the usage, options, arguments, examples, and description" do
+      expect { subject.help }.to output(
+        [
+          "Usage: #{subject.usage}",
+          '',
+          'Options:',
+          "    #{option1.usage.join(', ').ljust(33 - 1)} #{option1.desc}",
+          "    #{option2.usage.join(', ').ljust(33 - 1)} #{option2.desc}",
+          '    -h, --help                       Print help information',
+          '',
+          "Arguments:",
+          "    #{argument1.usage.ljust(33)}#{argument1.desc}",
+          "    #{argument2.usage.ljust(33)}#{argument2.desc}",
+          '',
+          "Examples:",
+          "    #{subject.command_name} #{command_class.examples[0]}",
+          "    #{subject.command_name} #{command_class.examples[1]}",
+          '',
+          command_class.description,
+          ''
+        ].join($/)
+      ).to_stdout
+    end
   end
 end