command_kit 0.1.0.pre1 → 0.2.0

data/spec/help_spec.rb

@@ -90,30 +90,5 @@ describe CommandKit::Help do
         subject.help()
       end
     end
-
-    context "when the superclass defines it's own #help method" do
-      module TestHelp
-        class SuperclassWithHelp
-
-          def help
-            puts 'superclass'
-          end
-
-        end
-
-        class SubclassOfSuperclassWithHelp < SuperclassWithHelp
-          include CommandKit::Help
-        end
-      end
-
-      let(:command_superclass) { TestHelp::SuperclassWithHelp }
-      let(:command_class)      { TestHelp::SubclassOfSuperclassWithHelp }
-
-      it "must call the superclass'es #help" do
-        expect_any_instance_of(command_superclass).to receive(:help)
-
-        subject.help()
-      end
-    end
   end
 end

data/spec/inflector_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'command_kit/inflector'
 
-describe Inflector do
+describe CommandKit::Inflector do
   describe ".demodularize" do
     context "when given a single class or module name" do
       let(:name) { 'Foo' }
@@ -28,6 +28,10 @@ describe Inflector do
     end
   end
 
+  ascii   = (0..255).map(&:chr)
+  alpha   = ('a'..'z').to_a + ('A'..'Z').to_a
+  numeric = ('0'..'9').to_a
+
   describe ".underscore" do
     it "must convert CamelCase to camel_case" do
       expect(subject.underscore('CamelCase')).to eq('camel_case')
@@ -37,18 +41,48 @@ describe Inflector do
       expect(subject.underscore('camelCase')).to eq('camel_case')
     end
 
-    it "must convert Camel to camel" do
-      expect(subject.underscore('Camel')).to eq('camel')
+    it "must convert Camelcase to camelcase" do
+      expect(subject.underscore('Camelcase')).to eq('camelcase')
     end
 
-    it "must convert CAMEL to camel" do
-      expect(subject.underscore('CAMEL')).to eq('camel')
+    it "must convert CAMELCASE to camelcase" do
+      expect(subject.underscore('CAMELCASE')).to eq('camelcase')
     end
 
-    context "when given a String containing '/' characters" do
-      it "must replace dashes with underscores" do
-        expect(subject.underscore('foo-bar')).to eq('foo_bar')
-      end
+    it "must convert CAMELCase to camel_case" do
+      expect(subject.underscore('CAMELCase')).to eq('camel_case')
+    end
+
+    it "must convert CamelCASE to camel_case" do
+      expect(subject.underscore('CAMELCase')).to eq('camel_case')
+    end
+
+    it "must convert FooBARBaz to foo_bar_baz" do
+      expect(subject.underscore('FooBARBaz')).to eq('foo_bar_baz')
+    end
+
+    it "must convert foo_bar_baz to foo_bar_baz" do
+      expect(subject.underscore('foo_bar_baz')).to eq('foo_bar_baz')
+    end
+
+    it "must convert foo___bar___baz to foo___bar___baz" do
+      expect(subject.underscore('foo___bar___baz')).to eq('foo___bar___baz')
+    end
+
+    it "must convert foo-bar-baz to foo_bar_baz" do
+      expect(subject.underscore('foo-bar-baz')).to eq('foo_bar_baz')
+    end
+
+    it "must convert foo---bar---baz to foo___bar___baz" do
+      expect(subject.underscore('foo---bar---baz')).to eq('foo___bar___baz')
+    end
+
+    it "must convert foo_BAR_baz to foo_bar_baz" do
+      expect(subject.underscore('foo_BAR_baz')).to eq('foo_bar_baz')
+    end
+
+    it "must convert foo-BAR-baz to foo_bar_baz" do
+      expect(subject.underscore('foo-BAR-baz')).to eq('foo_bar_baz')
     end
 
     context "when given a non-String" do
@@ -56,6 +90,20 @@ describe Inflector do
         expect(subject.underscore(:CamelCase)).to eq('camel_case')
       end
     end
+
+    separators = %w[_ -]
+
+    (ascii - alpha - numeric - separators).each do |char|
+      context "when the given String contains a #{char.inspect} character" do
+        let(:string) { "Foo#{char}Bar" }
+
+        it do
+          expect {
+            subject.underscore(string)
+          }.to raise_error(ArgumentError,"cannot convert string to underscored: #{string.inspect}")
+        end
+      end
+    end
   end
 
   describe ".dasherize" do
@@ -100,5 +148,19 @@ describe Inflector do
         expect(subject.camelize(:foo_bar)).to eq('FooBar')
       end
     end
+
+    separators = %w[_ - /]
+
+    (ascii - alpha - numeric - separators).each do |char|
+      context "when the given String contains a #{char.inspect} character" do
+        let(:string) { "foo#{char}bar" }
+
+        it do
+          expect {
+            subject.camelize(string)
+          }.to raise_error(ArgumentError,"cannot convert string to CamelCase: #{string.inspect}")
+        end
+      end
+    end
   end
 end

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