command_kit 0.1.0.pre2 → 0.2.1

data/spec/interactive_spec.rb

@@ -0,0 +1,415 @@
+require 'spec_helper'
+require 'command_kit/interactive'
+
+describe CommandKit::Interactive do
+  module TestInteractive
+    class TestCommand
+      include CommandKit::Interactive
+    end
+  end
+
+  let(:command_class) { TestInteractive::TestCommand }
+
+  describe "#included" do
+    subject { command_class }
+
+    it { expect(subject).to include(CommandKit::Stdio) }
+  end
+
+  let(:stdout) { StringIO.new }
+  let(:stdin)  { StringIO.new }
+  let(:stderr) { StringIO.new }
+
+  subject do
+    command_class.new(stdout: stdout, stdin: stdin, stderr: stderr)
+  end
+
+  let(:prompt) { 'Prompt' }
+
+  describe "#ask" do
+    let(:input)  { 'foo' }
+
+    it "must print a prompt, read input, and return the input" do
+      expect(stdout).to receive(:print).with("#{prompt}: ")
+      expect(stdin).to receive(:gets).and_return(input)
+
+      expect(subject.ask(prompt)).to eq(input)
+    end
+
+    it "must accept empty user input by default" do
+      expect(stdin).to receive(:gets).and_return("")
+
+      expect(subject.ask(prompt)).to eq("")
+    end
+
+    context "when Ctrl^C is entered" do
+      it "must return \"\"" do
+        expect(stdin).to receive(:gets).and_return(nil) # simulate Ctrl^C
+
+        expect(subject.ask(prompt)).to eq("")
+      end
+    end
+
+    context "when default: is given" do
+      let(:default) { 'bar' }
+
+      it "must include the default: value in the prompt" do
+        expect(stdout).to receive(:print).with("#{prompt} [#{default}]: ")
+        expect(stdin).to receive(:gets).and_return(input)
+
+        expect(subject.ask(prompt, default: default)).to eq(input)
+      end
+
+      context "and non-empty user input is given" do
+        it "must return the non-empty user input" do
+          expect(stdin).to receive(:gets).and_return(input)
+
+          expect(subject.ask(prompt, default: default)).to eq(input)
+        end
+      end
+
+      context "and empty user input is given" do
+        it "must return the default value" do
+          expect(stdin).to receive(:gets).and_return("")
+
+          expect(subject.ask(prompt, default: default)).to eq(default)
+        end
+      end
+    end
+
+    context "when required: is given" do
+      context "and empty user input is given" do
+        it "must ask for input again, until non-empty input is given" do
+          expect(stdin).to receive(:gets).and_return("")
+          expect(stdin).to receive(:gets).and_return("")
+          expect(stdin).to receive(:gets).and_return(input)
+
+          expect(subject.ask(prompt, required: true)).to eq(input)
+        end
+      end
+
+      context "and non-empty user input is given" do
+        it "must return the non-empty user input" do
+          expect(stdin).to receive(:gets).and_return(input)
+
+          expect(subject.ask(prompt, required: true)).to eq(input)
+        end
+      end
+    end
+  end
+
+  describe "#ask_yes_or_no" do
+    let(:input) { 'Y' }
+
+    it "must print a prompt indicating Y/N, and then accept input" do
+      expect(stdout).to receive(:print).with("#{prompt} (Y/N): ")
+      expect(stdin).to receive(:gets).and_return(input)
+
+      subject.ask_yes_or_no(prompt)
+    end
+
+    context "when 'Y' is entered" do
+      let(:input) { 'Y' }
+
+      it "must return true" do
+        expect(stdin).to receive(:gets).and_return(input)
+
+        expect(subject.ask_yes_or_no(prompt)).to eq(true)
+      end
+    end
+
+    context "when 'y' is entered" do
+      let(:input) { 'y' }
+
+      it "must return true" do
+        expect(stdin).to receive(:gets).and_return(input)
+
+        expect(subject.ask_yes_or_no(prompt)).to eq(true)
+      end
+    end
+
+    context "when 'YES' is entered" do
+      let(:input) { 'YES' }
+
+      it "must return true" do
+        expect(stdin).to receive(:gets).and_return(input)
+
+        expect(subject.ask_yes_or_no(prompt)).to eq(true)
+      end
+    end
+
+    context "when 'Yes' is entered" do
+      let(:input) { 'Yes' }
+
+      it "must return true" do
+        expect(stdin).to receive(:gets).and_return(input)
+
+        expect(subject.ask_yes_or_no(prompt)).to eq(true)
+      end
+    end
+
+    context "when 'yes' is entered" do
+      let(:input) { 'yes' }
+
+      it "must return true" do
+        expect(stdin).to receive(:gets).and_return(input)
+
+        expect(subject.ask_yes_or_no(prompt)).to eq(true)
+      end
+    end
+
+    context "when 'N' is entered" do
+      let(:input) { 'N' }
+
+      it "must return false" do
+        expect(stdin).to receive(:gets).and_return(input)
+
+        expect(subject.ask_yes_or_no(prompt)).to eq(false)
+      end
+    end
+
+    context "when 'n' is entered" do
+      let(:input) { 'n' }
+
+      it "must return false" do
+        expect(stdin).to receive(:gets).and_return(input)
+
+        expect(subject.ask_yes_or_no(prompt)).to eq(false)
+      end
+    end
+
+    context "when 'NO' is entered" do
+      let(:input) { 'NO' }
+
+      it "must return false" do
+        expect(stdin).to receive(:gets).and_return(input)
+
+        expect(subject.ask_yes_or_no(prompt)).to eq(false)
+      end
+    end
+
+    context "when 'No' is entered" do
+      let(:input) { 'No' }
+
+      it "must return false" do
+        expect(stdin).to receive(:gets).and_return(input)
+
+        expect(subject.ask_yes_or_no(prompt)).to eq(false)
+      end
+    end
+
+    context "when 'no' is entered" do
+      let(:input) { 'no' }
+
+      it "must return false" do
+        expect(stdin).to receive(:gets).and_return(input)
+
+        expect(subject.ask_yes_or_no(prompt)).to eq(false)
+      end
+    end
+
+    context "when input besides y/n/yes/no is entered" do
+      let(:input) { 'jflksjfls' }
+
+      it "must return false" do
+        expect(stdin).to receive(:gets).and_return(input)
+
+        expect(subject.ask_yes_or_no(prompt)).to eq(false)
+      end
+    end
+
+    context "when defualt: is given" do
+      context "and is true" do
+        let(:default) { true }
+
+        it "must include [Y] in the prompt" do
+          expect(stdout).to receive(:print).with("#{prompt} (Y/N) [Y]: ")
+          expect(stdin).to receive(:gets).and_return(input)
+
+          subject.ask_yes_or_no(prompt, default: default)
+        end
+
+        context "and empty user-input is given" do
+          let(:input) { "" }
+
+          it "must return true" do
+            expect(stdout).to receive(:print).with("#{prompt} (Y/N) [Y]: ")
+            expect(stdin).to receive(:gets).and_return(input)
+
+            expect(subject.ask_yes_or_no(prompt, default: default)).to eq(default)
+          end
+        end
+      end
+
+      context "and is false" do
+        let(:default) { false }
+
+        it "must include [N] in the prompt" do
+          expect(stdout).to receive(:print).with("#{prompt} (Y/N) [N]: ")
+          expect(stdin).to receive(:gets).and_return(input)
+
+          subject.ask_yes_or_no(prompt, default: default)
+        end
+
+        context "and empty user-input is given" do
+          let(:input) { "" }
+
+          it "must return false" do
+            expect(stdout).to receive(:print).with("#{prompt} (Y/N) [N]: ")
+            expect(stdin).to receive(:gets).and_return(input)
+
+            expect(subject.ask_yes_or_no(prompt, default: default)).to eq(default)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#ask_multiple_choice" do
+    context "when given an Array" do
+      let(:choices) do
+        [
+          "foo",
+          "bar",
+          "baz"
+        ]
+      end
+
+      let(:input) { "2" }
+
+      it "must print the numbered choices, a prompt with the choices, read input, and return the choice" do
+        expect(stdout).to receive(:puts).with("  1) #{choices[0]}")
+        expect(stdout).to receive(:puts).with("  2) #{choices[1]}")
+        expect(stdout).to receive(:puts).with("  3) #{choices[2]}")
+        expect(stdout).to receive(:puts).with(no_args)
+        expect(stdout).to receive(:print).with("#{prompt} (1, 2, 3): ")
+        expect(stdin).to receive(:gets).and_return(input)
+
+        expect(subject.ask_multiple_choice(prompt,choices)).to eq(choices[input.to_i - 1])
+      end
+
+      context "when empty user-input is given" do
+        it "must ask for input again, until non-empty input is given" do
+          expect(stdin).to receive(:gets).and_return("")
+          expect(stdin).to receive(:gets).and_return("")
+          expect(stdin).to receive(:gets).and_return(input)
+
+          expect(subject.ask_multiple_choice(prompt,choices)).to eq(choices[input.to_i - 1])
+        end
+      end
+
+      context "and default: is given" do
+        let(:default) { '3' }
+
+        it "must include the default: choice in the prompt" do
+          expect(stdout).to receive(:print).with("#{prompt} (1, 2, 3) [#{default}]: ")
+          expect(stdin).to receive(:gets).and_return(input)
+
+          subject.ask_multiple_choice(prompt,choices, default: default)
+        end
+
+        context "and empty user-input is given" do
+          it "must return the value for the default choice" do
+            expect(stdin).to receive(:gets).and_return("")
+
+            expect(subject.ask_multiple_choice(prompt,choices, default: default)).to eq(choices[default.to_i - 1])
+          end
+        end
+      end
+    end
+
+    context "when given a Hash" do
+      let(:choices) do
+        {
+          "A" => "foo",
+          "B" => "bar",
+          "C" => "baz"
+        }
+      end
+
+      let(:input) { "B" }
+
+      it "must print the labeled choices, a prompt with the choices, read input, and return the choice" do
+        expect(stdout).to receive(:puts).with("  #{choices.keys[0]}) #{choices.values[0]}")
+        expect(stdout).to receive(:puts).with("  #{choices.keys[1]}) #{choices.values[1]}")
+        expect(stdout).to receive(:puts).with("  #{choices.keys[2]}) #{choices.values[2]}")
+        expect(stdout).to receive(:puts).with(no_args)
+        expect(stdout).to receive(:print).with("#{prompt} (#{choices.keys[0]}, #{choices.keys[1]}, #{choices.keys[2]}): ")
+        expect(stdin).to receive(:gets).and_return(input)
+
+        expect(subject.ask_multiple_choice(prompt,choices)).to eq(choices[input])
+      end
+
+      context "when empty user-input is given" do
+        it "must ask for input again, until non-empty input is given" do
+          expect(stdin).to receive(:gets).and_return("")
+          expect(stdin).to receive(:gets).and_return("")
+          expect(stdin).to receive(:gets).and_return(input)
+
+          expect(subject.ask_multiple_choice(prompt,choices)).to eq(choices[input])
+        end
+      end
+
+      context "and default: is given" do
+        let(:default) { 'C' }
+
+        it "must include the default: choice in the prompt" do
+          expect(stdout).to receive(:print).with("#{prompt} (#{choices.keys[0]}, #{choices.keys[1]}, #{choices.keys[2]}) [#{default}]: ")
+          expect(stdin).to receive(:gets).and_return(input)
+
+          subject.ask_multiple_choice(prompt,choices, default: default)
+        end
+
+        context "and empty user-input is given" do
+          it "must return the value for the default choice" do
+            expect(stdin).to receive(:gets).and_return("")
+
+            expect(subject.ask_multiple_choice(prompt,choices, default: default)).to eq(choices[default])
+          end
+        end
+      end
+    end
+  end
+
+  describe "#ask_secret" do
+    let(:input) { 's3cr3t' }
+
+    context "when stdin supports to #noecho" do
+      it "must call #noecho, read input, then return the input" do
+        allow(stdin).to receive(:noecho).and_yield
+        expect(stdin).to receive(:gets).and_return(input)
+
+        expect(subject.ask_secret(prompt)).to eq(input)
+      end
+    end
+
+    context "when stdin does not support #noecho" do
+      it "must fallback to reading input" do
+        expect(stdin).to receive(:gets).and_return(input)
+
+        expect(subject.ask_secret(prompt)).to eq(input)
+      end
+    end
+
+    context "when empty user-input is given" do
+      it "must ask for input again, until non-empty input is given" do
+        expect(stdin).to receive(:gets).and_return("")
+        expect(stdin).to receive(:gets).and_return("")
+        expect(stdin).to receive(:gets).and_return("")
+        expect(stdin).to receive(:gets).and_return(input)
+
+        expect(subject.ask_secret(prompt)).to eq(input)
+      end
+    end
+
+    context "when required: is false" do
+      context "and empty user-input is given" do
+        it "must return the empty user-input" do
+          expect(stdin).to receive(:gets).and_return("")
+
+          expect(subject.ask_secret(prompt, required: false)).to eq("")
+        end
+      end
+    end
+  end
+end

data/spec/main_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'command_kit/main'
 
-describe Main do
+describe CommandKit::Main do
   module TestMain
     class TestCommand
       include CommandKit::Main
@@ -156,16 +156,16 @@ describe Main do
   describe "#main" do
     subject { command_class.new }
 
-    it "must provide a default #main" do
-      expect(subject).to respond_to(:main)
-    end
-
     it "must return 0 by default" do
       expect(subject.main).to eq(0)
     end
 
-    it "must accept arbitrary argv" do
-      expect { subject.main([1,2,3]) }.to_not raise_error
+    it "must call #run with the given argv" do
+      argv = ["foo", "bar", "baz"]
+
+      expect(subject).to receive(:run).with(*argv)
+      
+      subject.main(argv)
     end
 
     context "when #run raises SystemExit" do

data/spec/man_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'command_kit/man'
+
+describe CommandKit::Man do
+  module TestMan
+    class TestCommand
+      include CommandKit::Man
+    end
+  end
+
+  let(:command_class) { TestMan::TestCommand }
+
+  subject { command_class.new }
+
+  describe "#man" do
+    let(:man_page) { 'foo' }
+
+    it "must call system() with the given man page" do
+      expect(subject).to receive(:system).with('man',man_page)
+
+      subject.man(man_page)
+    end
+
+    context "when given a non-String man-page argument" do
+      let(:man_page_arg) { double(:non_string_arg) }
+
+      it "must call #to_s on the man-page argument" do
+        expect(man_page_arg).to receive(:to_s).and_return(man_page)
+
+        expect(subject).to receive(:system).with('man',man_page)
+
+        subject.man(man_page_arg)
+      end
+    end
+
+    context "when given the section: keyword argument" do
+      let(:section) { 7 }
+
+      it "must call system() with the given section number and man page" do
+        expect(subject).to receive(:system).with('man',section.to_s,man_page)
+
+        subject.man(man_page, section: section)
+      end
+    end
+  end
+end

data/spec/open_app_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+require 'command_kit/open_app'
+
+describe CommandKit::OpenApp do
+  module TestOpenApp
+    class TestCommand
+      include CommandKit::OpenApp
+    end
+  end
+
+  let(:command_class) { TestOpenApp::TestCommand }
+
+  subject { command_class.new }
+
+  describe "#initialize" do
+    context "when the OS is macOS" do
+      subject { command_class.new(os: :macos) }
+
+      it "must set @open_command to \"open\"" do
+        expect(subject.instance_variable_get("@open_command")).to eq("open")
+      end
+    end
+
+    context "when the OS is Linux" do
+      subject { command_class.new(os: :linux) }
+
+      it "must set @open_command to \"xdg-open\"" do
+        expect(subject.instance_variable_get("@open_command")).to eq("xdg-open")
+      end
+    end
+
+    context "when the OS is FreeBSD" do
+      subject { command_class.new(os: :freebsd) }
+
+      it "must set @open_command to \"xdg-open\"" do
+        expect(subject.instance_variable_get("@open_command")).to eq("xdg-open")
+      end
+    end
+
+    context "when the OS is OpenBSD" do
+      subject { command_class.new(os: :openbsd) }
+
+      it "must set @open_command to \"xdg-open\"" do
+        expect(subject.instance_variable_get("@open_command")).to eq("xdg-open")
+      end
+    end
+
+    context "when the OS is NetBSD" do
+      subject { command_class.new(os: :openbsd) }
+
+      it "must set @open_command to \"xdg-open\"" do
+        expect(subject.instance_variable_get("@open_command")).to eq("xdg-open")
+      end
+    end
+
+    context "when the OS is Windows" do
+      subject { command_class.new(os: :windows) }
+
+      it "must set @open_command to \"start\"" do
+        expect(subject.instance_variable_get("@open_command")).to eq("start")
+      end
+    end
+  end
+
+  describe "#open_app_for" do
+    context "when @open_command is set" do
+      let(:file_or_uri) { "foo" }
+      let(:status) { true }
+
+      it "must execute the @open_command with the given URI or file" do
+        expect(subject).to receive(:system).with(subject.instance_variable_get("@open_command"),file_or_uri).and_return(status)
+
+        expect(subject.open_app_for(file_or_uri)).to be(status)
+      end
+    end
+
+    context "when @open_command is not set" do
+      before do
+        subject.instance_variable_set("@open_command",nil)
+      end
+
+      it { expect(subject.open_app_for("foo")).to be(nil) }
+    end
+  end
+end

data/spec/options/option_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'command_kit/options/option'
 
-describe Options::Option do
+describe CommandKit::Options::Option do
   let(:name)   { :foo    }
   let(:short)  { nil     }
   let(:long)   { '--foo' }
@@ -18,12 +18,12 @@ describe Options::Option do
   end
 
   subject do
-    described_class.new name, short:  short,
+    described_class.new(name, short:  short,
                               long:   long,
                               equals: equals,
                               desc:   desc,
                               value:  value,
-                              &block
+                              &block)
   end
 
   describe "#initialize" do
@@ -82,7 +82,7 @@ describe Options::Option do
         subject { described_class.new(name, value: {type: type}, desc: desc) }
 
         it "must initialize #value" do
-          expect(subject.value).to      be_kind_of(Options::OptionValue)
+          expect(subject.value).to      be_kind_of(CommandKit::Options::OptionValue)
           expect(subject.value.type).to eq(type)
         end
       end
@@ -91,7 +91,7 @@ describe Options::Option do
         subject { described_class.new(name, value: true, desc: desc) }
 
         it "must initialize #value with defaults" do
-          expect(subject.value).to           be_kind_of(Options::OptionValue)
+          expect(subject.value).to           be_kind_of(CommandKit::Options::OptionValue)
           expect(subject.value.type).to      eq(String)
           expect(subject.value.required?).to be(true)
           expect(subject.value.usage).to     eq('STR')

data/spec/options/option_value_spec.rb

@@ -1,12 +1,67 @@
 require 'spec_helper'
 require 'command_kit/options/option_value'
 
-describe Options::OptionValue do
+describe CommandKit::Options::OptionValue do
   let(:type)     { Integer }
   let(:usage)    { 'COUNT' }
   let(:required) { true }
   let(:default)  { 1 }
 
+  describe ".default_usage" do
+    subject { described_class }
+
+    context "when given a Hash" do
+      let(:type) do
+        {'foo' => :foo, "bar" => :bar}
+      end
+
+      it "must join the Hash's keys with a '|' character" do
+        expect(subject.default_usage(type)).to eq(type.keys.join('|'))
+      end
+    end
+
+    context "when given an Array" do
+      let(:type) do
+        ['foo', 'bar', 'baz']
+      end
+
+      it "must join the Array's elements with a '|' character" do
+        expect(subject.default_usage(type)).to eq(type.join('|'))
+      end
+    end
+
+    context "when given a Regexp" do
+      let(:type) { /[0-9a-f]+/ }
+
+      it "must return the Regexp's source" do
+        expect(subject.default_usage(type)).to eq(type.source)
+      end
+    end
+
+    context "when given a Class" do
+      module TestOptionValue
+        class FooBarBaz
+        end
+      end
+
+      let(:type) { TestOptionValue::FooBarBaz }
+
+      it "must return the uppercase and underscored version of it's name" do
+        expect(subject.default_usage(type)).to eq("FOO_BAR_BAZ")
+      end
+    end
+
+    context "when given another kind of Object" do
+      let(:type) { Object.new }
+
+      it do
+        expect {
+          subject.default_usage(type)
+        }.to raise_error(TypeError,"unsupported option type: #{type.inspect}")
+      end
+    end
+  end
+
   describe "#initialize" do
     context "when the type: keyword is given" do
       let(:type) { Integer }