command_kit 0.1.0.pre1

data/spec/help_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+require 'command_kit/help'
+
+describe CommandKit::Help do
+  module TestHelp
+    class DefaultCmd
+      include CommandKit::Help
+    end
+
+    class TestCommandWithInitialize
+      include CommandKit::Help
+
+      attr_reader :foo
+
+      attr_reader :bar
+
+      def initialize(foo: 'foo', bar: 'bar', **kwargs)
+        super(**kwargs)
+
+        @foo = foo
+        @bar = bar
+      end
+    end
+  end
+
+  let(:command_class) { TestHelp::TestCmd }
+
+  describe ".help" do
+    subject { command_class }
+
+    context "when no #initialize method is defined" do
+      let(:command_class) { TestHelp::DefaultCmd }
+      let(:instance) { command_class.new }
+
+      it "must initialize the command object and call #help" do
+        expect(subject).to receive(:new).with(no_args).and_return(instance)
+        expect(instance).to receive(:help).with(no_args)
+
+        subject.help()
+      end
+    end
+
+    context "when an #initialize method is defined" do
+      let(:command_class) { TestHelp::TestCommandWithInitialize }
+      let(:instance) { command_class.new }
+
+      context "and given no arguments" do
+        it "must initialize the command object and call #help" do
+          expect(subject).to receive(:new).with(no_args).and_return(instance)
+          expect(instance).to receive(:help).with(no_args)
+
+          subject.help()
+        end
+      end
+
+      context "and given keyword arguments" do
+        let(:kwargs) { {foo: 'custom foo', bar: 'custom bar'} }
+        let(:instance) { command_class.new(**kwargs) }
+
+        it "must pass the keyword arguments .new then call #help" do
+          expect(subject).to receive(:new).with(**kwargs).and_return(instance)
+          expect(instance).to receive(:help).with(no_args)
+
+          subject.help(**kwargs)
+        end
+      end
+    end
+  end
+
+  subject { command_class.new }
+
+  describe "#help" do
+    context "when there is no superclass #help method" do
+      module TestHelp
+        class SuperclassWithoutHelp
+        end
+
+        class SubclassOfSuperclassWithoutHelp < SuperclassWithoutHelp
+          include CommandKit::Help
+        end
+      end
+
+      let(:command_superclass) { TestHelp::SuperclassWithoutHelp }
+      let(:command_class)      { TestHelp::SubclassOfSuperclassWithoutHelp }
+
+      it "must not attempt to call the superclass'es #help" do
+        allow_any_instance_of(command_class).to receive(:help)
+        expect_any_instance_of(command_superclass).to_not receive(:help)
+
+        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

@@ -0,0 +1,104 @@
+require 'spec_helper'
+require 'command_kit/inflector'
+
+describe 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
+
+  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 Camel to camel" do
+      expect(subject.underscore('Camel')).to eq('camel')
+    end
+
+    it "must convert CAMEL to camel" do
+      expect(subject.underscore('CAMEL')).to eq('camel')
+    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
+    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
+  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
+  end
+end

data/spec/main_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+require 'command_kit/main'
+
+describe Main do
+  module TestMain
+    class TestCommand
+      include CommandKit::Main
+    end
+
+    class TestCommandWithInitialize
+      include CommandKit::Main
+
+      attr_reader :foo
+
+      attr_reader :bar
+
+      def initialize(foo: 'foo', bar: 'bar', **kwargs)
+        super(**kwargs)
+
+        @foo = foo
+        @bar = bar
+      end
+    end
+  end
+
+  let(:command_class) { TestMain::TestCommand }
+
+  describe ".start" do
+    subject { command_class }
+
+    it "must exit with 0 by default" do
+      expect(subject).to receive(:exit).with(0)
+
+      subject.start
+    end
+
+    context "when given an argv argument" do
+      let(:argv) { %w[one two three] }
+
+      it "must pass argv to .main" do
+        expect(subject).to receive(:main).with(argv)
+        allow(subject).to receive(:exit)
+
+        subject.start(argv)
+      end
+    end
+
+    context "when given keyword arguments" do
+      let(:command_class) { TestMain::TestCommandWithInitialize }
+
+      let(:kwargs) { {foo: 'custom foo', bar: 'custom bar'} }
+
+      it "must pass the keyword arguments down to .main" do
+        expect(subject).to receive(:main).with(ARGV, **kwargs)
+        allow(subject).to receive(:exit)
+
+        subject.start(**kwargs)
+      end
+    end
+
+    context "when Interrupt is raised" do
+      module TestMain
+        class TestCommandWithInterrupt
+          include CommandKit::Main
+
+          def main(*argv)
+            raise(Interrupt)
+          end
+        end
+      end
+
+      let(:command_class) { TestMain::TestCommandWithInterrupt }
+
+      it "must exit with 130" do
+        expect(command_class).to receive(:exit).with(130)
+
+        command_class.start
+      end
+    end
+
+    context "when Errno::EPIPE is raised" do
+      module TestMain
+        class TestCommandWithBrokenPipe
+          include CommandKit::Main
+
+          def main(*argv)
+            raise(Errno::EPIPE)
+          end
+        end
+      end
+
+      let(:command_class) { TestMain::TestCommandWithBrokenPipe }
+
+      it "must exit with 0" do
+        expect(command_class).to receive(:exit).with(0)
+
+        command_class.start
+      end
+    end
+  end
+
+  module TestMain
+    class TestCommandWithSystemExit
+
+      include CommandKit::Main
+
+      def run(*argv)
+        raise(SystemExit.new(-1))
+      end
+
+    end
+  end
+
+  describe ".main" do
+    subject { command_class }
+
+    it "must return 0 by default" do
+      expect(subject.main).to eq(0)
+    end
+
+    let(:command_class) { TestMain::TestCommandWithInitialize }
+
+    context "when given a custom argv" do
+      let(:instance) { command_class.new }
+      let(:argv)     { %w[one two three] }
+
+      it "must call #main with the custom argv" do
+        expect(subject).to receive(:new).with(no_args).and_return(instance)
+        expect(instance).to receive(:main).with(argv)
+
+        subject.main(argv)
+      end
+    end
+
+    context "when given keyword arguments" do
+      let(:kwargs)   { {foo: 'custom foo', bar: 'custom bar'} }
+      let(:instance) { command_class.new(**kwargs) }
+
+      it "must pass the keyword arguments .new then call #main" do
+        expect(subject).to receive(:new).with(**kwargs).and_return(instance)
+        expect(instance).to receive(:main).with([])
+
+        subject.main(**kwargs)
+      end
+    end
+
+    context "when #main raises SystemExit" do
+      let(:command_class) { TestMain::TestCommandWithSystemExit }
+
+      it "must rescue SystemExit and return the exit status code" do
+        expect(subject.main()).to eq(-1)
+      end
+    end
+  end
+
+  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
+    end
+
+    context "when #run raises SystemExit" do
+      let(:command_class) { TestMain::TestCommandWithSystemExit }
+
+      it "must rescue SystemExit and return the exit status code" do
+        expect(subject.main()).to eq(-1)
+      end
+    end
+  end
+end

data/spec/options/option_spec.rb

@@ -0,0 +1,258 @@
+require 'spec_helper'
+require 'command_kit/options/option'
+
+describe Options::Option do
+  let(:name)   { :foo    }
+  let(:short)  { nil     }
+  let(:long)   { '--foo' }
+  let(:equals) { false   }
+  let(:value) do
+    {
+      usage:    'FOO',
+      required: true
+    }
+  end
+  let(:desc)  { 'Foo option' }
+  let(:block) do
+    ->(arg) { @foo = arg }
+  end
+
+  subject do
+    described_class.new name, short:  short,
+                              long:   long,
+                              equals: equals,
+                              desc:   desc,
+                              value:  value,
+                              &block
+  end
+
+  describe "#initialize" do
+    context "when the short: keyword is given" do
+      subject { described_class.new(name, short: short, desc: desc) }
+
+      it "must set #short" do
+        expect(subject.short).to eq(short)
+      end
+    end
+
+    context "when the short: keyword is not given" do
+      subject { described_class.new(name, desc: desc) }
+
+      it { expect(subject.short).to be(nil) }
+    end
+
+    context "when the long: keyword is given" do
+      let(:long) { '--opt' }
+
+      subject { described_class.new(name, long: long, desc: desc) }
+
+      it "must set #long" do
+        expect(subject.long).to eq(long)
+      end
+    end
+
+    context "when the long: keyword is not given" do
+      subject { described_class.new(name, desc: desc) }
+
+      it "default #long to a '--option' flag based on #name" do
+        expect(subject.long).to eq("--#{name}")
+      end
+    end
+
+    context "when the equals: keyword is given" do
+      let(:equals) { true }
+
+      subject { described_class.new(name, equals: equals, desc: desc) }
+
+      it "must set #equals" do
+        expect(subject.equals).to eq(equals)
+      end
+    end
+
+    context "when the equals: keyword is not given" do
+      subject { described_class.new(name, desc: desc) }
+
+      it { expect(subject.equals).to be(false) }
+    end
+
+    context "when the values: keyword is given" do
+      let(:value) { {} }
+      subject { described_class.new(name, value: {}, desc: desc) }
+
+      it "must initialize #value" do
+        expect(subject.value).to be_kind_of(Options::OptionValue)
+      end
+    end
+
+    context "when the values: keyword is not given" do
+      subject { described_class.new(name, desc: desc) }
+
+      it { expect(subject.value).to be(nil) }
+    end
+
+    context "when the desc: keyword is given" do
+      subject { described_class.new(name, desc: desc) }
+
+      it "must set #desc" do
+        expect(subject.desc).to eq(desc)
+      end
+    end
+
+    context "when the desc: keyword is not given" do
+      it do
+        expect {
+          described_class.new(name)
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "when a block is given" do
+      subject { described_class.new(name, desc: desc, &block) }
+
+      it "must set #block" do
+        expect(subject.block).to eq(block)
+      end
+    end
+
+    context "when no block is given" do
+      subject { described_class.new(name, desc: desc) }
+
+      it { expect(subject.block).to be(nil) }
+    end
+  end
+
+  describe "#equals?" do
+    context "when initialized with equals: true" do
+      let(:equals) { true }
+
+      it { expect(subject.equals?).to be(true) }
+    end
+
+    context "when initialized with equals: false" do
+      let(:equals) { false }
+
+      it { expect(subject.equals?).to be(false) }
+    end
+  end
+
+  describe "#separator" do
+    context "when #value is initialized" do
+      context "and #equals? is true" do
+        let(:equals) { true }
+
+        it { expect(subject.separator).to eq('=') }
+      end
+
+      context "and #equals? is false" do
+        let(:equals) { false }
+
+        it { expect(subject.separator).to eq(' ') }
+      end
+    end
+
+    context "when #value is not initialized" do
+      let(:value) { nil }
+
+      it { expect(subject.separator).to be(nil) }
+    end
+  end
+
+  describe "#usage" do
+    let(:long) { '--foo' }
+
+    it "must start with the long '--option'" do
+      expect(subject.usage.last).to start_with(long)
+    end
+
+    context "when #value is initialized" do
+      it "must return '--option USAGE'" do
+        expect(subject.usage.last).to eq("#{long} #{subject.value.usage}")
+      end
+
+      context "and #equals? is true" do
+        let(:equals) { true }
+
+        it "must return '--option=USAGE'" do
+          expect(subject.usage.last).to eq("#{long}=#{subject.value.usage}")
+        end
+      end
+    end
+
+    context "when #short is not nil" do
+      let(:short) { '-f' }
+
+      it "to have two elements" do
+        expect(subject.usage.length).to eq(2)
+      end
+
+      it "the first element should be the short option" do
+        expect(subject.usage[0]).to eq(short)
+      end
+    end
+  end
+
+  describe "#value?" do
+    context "when #value has been initialized" do
+      let(:value) { {} }
+
+      it { expect(subject.value?).to be(true) }
+    end
+
+    context "when #value has not been initialized" do
+      let(:value) { nil }
+
+      it { expect(subject.value?).to be(false) }
+    end
+  end
+
+  describe "#type" do
+    context "when #value has been initialized and has a #type" do
+      let(:type)  { String }
+      let(:value) { {type: type} }
+
+      it "must return the #value.type" do
+        expect(subject.type).to eq(type)
+      end
+    end
+
+    context "when #value has not been initialized" do
+      let(:value) { nil }
+
+      it { expect(subject.type).to be(nil) }
+    end
+  end
+
+  describe "#default_value" do
+    context "when #value has been initialized and has a #default" do
+      let(:default)  { "" }
+      let(:value) { {default: default} }
+
+      it "must return the #value.default_value" do
+        expect(subject.default_value).to eq(default)
+      end
+    end
+
+    context "when #value has not been initialized" do
+      let(:value) { nil }
+
+      it { expect(subject.default_value).to be(nil) }
+    end
+  end
+
+  describe "#desc" do
+    let(:desc) { 'Foo option' }
+
+    it "must return the desc: value" do
+      expect(subject.desc).to eq(desc)
+    end
+
+    context "when #value has been initialized with a default value" do
+      let(:default)  { "foo" }
+      let(:value) { {default: default} }
+
+      it "should reutrn the desc value and '(Default: ...)'" do
+        expect(subject.desc).to eq("#{desc} (Default: #{default})")
+      end
+    end
+  end
+end