command_kit 0.4.0 → 0.5.0

data/spec/inflector_spec.rb

@@ -1,166 +0,0 @@
-require 'spec_helper'
-require 'command_kit/inflector'
-
-describe CommandKit::Inflector do
-  describe ".demodularize" do
-    context "when given a single class or module name" do
-      let(:name) { 'Foo' }
-
-      it "must return the class or module name unchanged" do
-        expect(subject.demodularize(name)).to eq(name)
-      end
-    end
-
-    context "when given a class or module name with a leading namespace" do
-      let(:namespace) { 'Foo::Bar' }
-      let(:constant)  { "Baz" }
-      let(:name) { "#{namespace}::#{constant}" }
-
-      it "must return the constant name, without the leading namespace" do
-        expect(subject.demodularize(name)).to eq(constant)
-      end
-    end
-
-    context "when given a non-String" do
-      it "must convert it to a String" do
-        expect(subject.demodularize(:"Foo::Bar")).to eq('Bar')
-      end
-    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')
-    end
-
-    it "must convert camelCase to camel_case" do
-      expect(subject.underscore('camelCase')).to eq('camel_case')
-    end
-
-    it "must convert Camelcase to camelcase" do
-      expect(subject.underscore('Camelcase')).to eq('camelcase')
-    end
-
-    it "must convert CAMELCASE to camelcase" do
-      expect(subject.underscore('CAMELCASE')).to eq('camelcase')
-    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
-      it "must convert it to a String" 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
-    it "must replace all underscores with dashes" do
-      expect(subject.dasherize("foo_bar")).to eq('foo-bar')
-    end
-
-    context "when given a non-String" do
-      it "must convert it to a String" do
-        expect(subject.dasherize(:foo_bar)).to eq('foo-bar')
-      end
-    end
-  end
-
-  describe ".camelize" do
-    context "when given a string with no underscores" do
-      it "must capitalize the string" do
-        expect(subject.camelize('foo')).to eq('Foo')
-      end
-    end
-
-    context "when given a string with underscores" do
-      it "must capitalize each word and remove all underscores" do
-        expect(subject.camelize('foo_bar')).to eq('FooBar')
-      end
-    end
-
-    context "when given a string with dashes" do
-      it "must capitalize each word and remove all dashes" do
-        expect(subject.camelize('foo-bar')).to eq('FooBar')
-      end
-    end
-
-    context "when given a string containing '/' characters" do
-      it "must replace the '/' characters with '::' strings" do
-        expect(subject.camelize('foo_bar/baz_quox')).to eq('FooBar::BazQuox')
-      end
-    end
-
-    context "when given a non-String" do
-      it "must convert it to a String" 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

@@ -1,415 +0,0 @@
-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