command_kit 0.1.0.pre1

data/spec/options/option_value_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'command_kit/options/option_value'
+
+describe Options::OptionValue do
+  let(:type) { Integer }
+  let(:usage)    { 'COUNT' }
+  let(:required) { true }
+  let(:default)  { 1 }
+
+  describe "#initialize" do
+    context "when the type: keyword is given" do
+      let(:type) { Integer }
+
+      subject { described_class.new(type: type) }
+
+      it "must default #type to String" do
+        expect(subject.type).to eq(type)
+      end
+    end
+
+    context "when the type: keyword is not given" do
+      subject { described_class.new }
+
+      it "must default #type to String" do
+        expect(subject.type).to eq(String)
+      end
+    end
+
+    context "when the usage: keyword is given" do
+      let(:usage) { 'FOO' }
+
+      subject { described_class.new(usage: usage) }
+
+      it "must default #usage to String" do
+        expect(subject.usage).to eq(usage)
+      end
+    end
+
+    context "when the usage: keyword is not given" do
+      subject { described_class.new }
+
+      it "must default #usage based on #type" do
+        expect(subject.usage).to eq(described_class.default_usage(subject.type))
+      end
+    end
+  end
+
+  describe "#usage" do
+    let(:usage) { 'FOO' }
+
+    context "when #optional? is true" do
+      subject { described_class.new(usage: usage, required: false) }
+
+      it "must wrap the usage within [ ] brackets" do
+        expect(subject.usage).to eq("[#{usage}]")
+      end
+    end
+
+    context "when #optional? is false" do
+      subject { described_class.new(usage: usage, required: true) }
+
+      it "should return the usage string unchanged" do
+        expect(subject.usage).to eq(usage)
+      end
+    end
+  end
+end

data/spec/options/parser_spec.rb

@@ -0,0 +1,265 @@
+require 'spec_helper'
+require 'command_kit/options/parser'
+
+describe CommandKit::Options::Parser do
+  module TestOptionsParser
+    class TestCommand
+      include CommandKit::Options::Parser
+
+      command_name 'cmd'
+
+    end
+  end
+
+  let(:command_class) { TestOptionsParser::TestCommand }
+
+  describe ".included" do
+    subject { command_class }
+
+    it { expect(subject).to include(CommandKit::Main) }
+    it { expect(subject).to include(CommandKit::Usage) }
+    it { expect(subject.usage).to eq('[options]') }
+  end
+
+  subject { command_class.new }
+
+  describe "#initialize" do
+    it "must initialize #option_parser" do
+      expect(subject.option_parser).to be_kind_of(OptionParser)
+    end
+  end
+
+  describe "#option_parser" do
+    it "must have a default #banner" do
+      expect(subject.option_parser.banner).to eq("Usage: #{subject.usage}")
+    end
+
+    it "must include a 'Options:' separator" do
+      expect(subject.option_parser.to_s).to include(
+        [
+          '',
+          'Options:',
+          ''
+        ].join($/)
+      )
+    end
+
+    it "must define a default --help option" do
+      expect(subject.option_parser.to_s).to include(
+        [
+          '',
+          '    -h, --help                       Print help information',
+          ''
+        ].join($/)
+      )
+    end
+  end
+
+  module TestOptionsParser
+    class CommandWithOptions
+
+      include CommandKit::Options::Parser
+
+      command_name 'cmd'
+
+      attr_reader :foo
+
+      attr_reader :bar
+
+      attr_reader :argv
+
+      def initialize(**kwargs)
+        super(**kwargs)
+
+        @option_parser.on('-f','--foo','Foo option') do
+          @foo = true
+        end
+
+        @option_parser.on('-b','--bar BAR',Integer,'Bar option') do |bar|
+          @bar = bar
+        end
+      end
+
+      def run(*argv)
+        @argv = argv
+      end
+
+    end
+  end
+
+  let(:command_class) { TestOptionsParser::CommandWithOptions }
+  subject { command_class.new }
+
+  describe "#option_parser" do
+    it { expect(subject.option_parser).to be_kind_of(OptionParser) }
+  end
+
+  describe "#main" do
+    context "when --help is given as an argument" do
+      it "must call #help" do
+        expect(subject).to receive(:help)
+
+        subject.main(['--help'])
+      end
+
+      it "must return 0" do
+        allow(subject).to receive(:help)
+
+        expect(subject.main(['--help'])).to eq(0)
+      end
+
+      it "must stop parsing options" do
+        allow(subject).to receive(:help)
+        subject.main(['--help', '--foo', '1'])
+
+        expect(subject.foo).to be(nil)
+        expect(subject.argv).to be(nil)
+      end
+    end
+  end
+
+  describe "#parse_options" do
+    it "must parse options and return any additional arguments" do
+      additional_args = %w[arg1 arg2]
+      bar = 2
+      argv = ['--foo', '--bar', bar.to_s, *additional_args]
+
+      expect(subject.parse_options(argv)).to eq(additional_args)
+      expect(subject.foo).to eq(true)
+      expect(subject.bar).to eq(bar)
+    end
+
+    context "when -h,--help is passed" do
+      it "must call #help and exit with 0" do
+        expect(subject).to receive(:help)
+        expect(subject).to receive(:exit).with(0)
+
+        subject.parse_options(['--help'])
+      end
+    end
+
+    context "when an invalid option is given" do
+      it "must call #on_invalid_option" do
+        expect(subject).to receive(:on_invalid_option).with(OptionParser::InvalidOption)
+
+        subject.parse_options(['--xxx'])
+      end
+    end
+
+    context "when an invalid argument is given" do
+      it "must call #on_invalid_argument" do
+        expect(subject).to receive(:on_invalid_argument).with(OptionParser::InvalidArgument)
+
+        subject.parse_options(['--bar', 'xxx'])
+      end
+    end
+
+    context "when a required argument is missing" do
+      it "must call #on_missing_argument" do
+        expect(subject).to receive(:on_missing_argument).with(OptionParser::MissingArgument)
+
+        subject.parse_options(['--bar'])
+      end
+    end
+
+    context "when a needless argument is given" do
+      it "must call #on_needless_argument" do
+        expect(subject).to receive(:on_needless_argument).with(OptionParser::NeedlessArgument)
+
+        subject.parse_options(['--foo=xxx'])
+      end
+    end
+  end
+
+  describe "#on_parse_error" do
+    let(:error) { OptionParser::InvalidOption.new("--xxx") }
+
+    it "must print an error message and exit with 1" do
+      expect(subject).to receive(:exit).with(1)
+
+      expect { subject.on_parse_error(error) }.to output(
+        [
+          "#{subject.command_name}: #{error.message}",
+          "Try '#{subject.command_name} --help' for more information.",
+          ''
+        ].join($/)
+      ).to_stderr
+    end
+  end
+
+  describe "#on_invalid_option" do
+    let(:error) { OptionParser::InvalidOption.new('--xxx') }
+
+    it "must call #on_parse_error by default" do
+      expect(subject).to receive(:on_parse_error).with(error)
+
+      subject.on_invalid_option(error)
+    end
+  end
+
+  describe "#on_ambiguous_option" do
+    let(:error) { OptionParser::AmbiguousOption.new('--xxx') }
+
+    it "must call #on_parse_error by default" do
+      expect(subject).to receive(:on_parse_error).with(error)
+
+      subject.on_ambiguous_option(error)
+    end
+  end
+
+  describe "#on_invalid_argument" do
+    let(:error) { OptionParser::InvalidArgument.new('--xxx') }
+
+    it "must call #on_parse_error by default" do
+      expect(subject).to receive(:on_parse_error).with(error)
+
+      subject.on_invalid_argument(error)
+    end
+  end
+
+  describe "#on_missing_argument" do
+    let(:error) { OptionParser::MissingArgument.new('--xxx') }
+
+    it "must call #on_parse_error by default" do
+      expect(subject).to receive(:on_parse_error).with(error)
+
+      subject.on_missing_argument(error)
+    end
+  end
+
+  describe "#on_needless_argument" do
+    let(:error) { OptionParser::NeedlessArgument.new('--xxx') }
+
+    it "must call #on_parse_error by default" do
+      expect(subject).to receive(:on_parse_error).with(error)
+
+      subject.on_needless_argument(error)
+    end
+  end
+
+  describe "#on_ambiguous_argument" do
+    let(:error) { OptionParser::AmbiguousArgument.new('--xxx') }
+
+    it "must call #on_parse_error by default" do
+      expect(subject).to receive(:on_parse_error).with(error)
+
+      subject.on_ambiguous_argument(error)
+    end
+  end
+
+  describe "#help_options" do
+    it "must print the #option_parser" do
+      expect { subject.help_options }.to output(
+        subject.option_parser.to_s
+      ).to_stdout
+    end
+  end
+
+  describe "#help" do
+    it "must call #help_options" do
+      expect(subject).to receive(:help_options)
+
+      subject.help
+    end
+  end
+end

data/spec/options_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+require 'command_kit/options'
+
+describe Options do
+  module TestOptions
+    class ImplicitCmd
+      include CommandKit::Options
+    end
+  end
+
+  let(:command_class) { TestOptions::ImplicitCmd }
+  subject { command_class.new }
+
+  describe ".options" do
+    subject { TestOptions::ImplicitCmd }
+
+    context "when no options have been defined" do
+      it "should default to {}" do
+        expect(subject.options).to eq({})
+      end
+    end
+
+    context "when a options is explicitly set" do
+      module TestOptions
+        class ExplicitCmd
+          include CommandKit::Options
+          option :foo, desc: 'Foo option'
+          option :bar, desc: 'Bar option'
+        end
+      end
+
+      subject { TestOptions::ExplicitCmd }
+
+      it "must return the explicitly set options" do
+        expect(subject.options.keys).to eq([:foo, :bar])
+      end
+    end
+
+    context "when the command class inherites from another class" do
+      context "but no options are defined" do
+        module TestOptions
+          class BaseCmd
+            include CommandKit::Options
+          end
+
+          class InheritedCmd < BaseCmd
+          end
+        end
+
+        subject { TestOptions::InheritedCmd }
+
+        it "must search each class then return {}"do
+          expect(subject.options).to eq({})
+        end
+      end
+
+      module TestOptions
+        class ExplicitBaseCmd
+          include CommandKit::Options
+          option :foo, desc: 'Foo option'
+          option :bar, desc: 'Bar option'
+        end
+      end
+
+      context "when the superclass defines options" do
+        module TestOptions
+          class ImplicitInheritedCmd < ExplicitBaseCmd
+          end
+        end
+
+        let(:super_subject) { TestOptions::ExplicitBaseCmd }
+        subject { TestOptions::ImplicitInheritedCmd }
+
+        it "must inherit the superclass'es options" do
+          expect(subject.options).to eq(super_subject.options)
+        end
+
+        it "must not change the superclass'es options" do
+          expect(super_subject.options.keys).to eq([:foo, :bar])
+        end
+      end
+
+      context "when the subclass defines options" do
+        module TestOptions
+          class ImplicitBaseCmd
+            include CommandKit::Options
+          end
+
+          class ExplicitInheritedCmd < ImplicitBaseCmd
+            option :baz, desc: 'Baz option'
+            option :qux, desc: 'Qux option'
+          end
+        end
+
+        let(:super_subject) { TestOptions::ImplicitBaseCmd }
+        subject { TestOptions::ExplicitInheritedCmd }
+
+        it "must return the subclass'es options" do
+          expect(subject.options.keys).to eq([:baz, :qux])
+        end
+
+        it "must not change the superclass'es options" do
+          expect(super_subject.options).to eq({})
+        end
+      end
+
+      context "when subclass overrides the superclass's optionss" do
+        module TestOptions
+          class ExplicitOverridingInheritedCmd < ExplicitBaseCmd
+            option :foo, desc: "Overriden foo option"
+          end
+        end
+
+        let(:super_subject) { TestOptions::ExplicitBaseCmd }
+        subject { TestOptions::ExplicitOverridingInheritedCmd }
+
+        it "must combine the superclass'es options with the subclass'es" do
+          expect(subject.options.keys).to eq([:foo, :bar])
+          expect(subject.options[:foo].desc).to eq("Overriden foo option")
+          expect(subject.options[:bar].desc).to eq("Bar option")
+        end
+
+        it "must not change the superclass'es options" do
+          expect(super_subject.options.keys).to eq([:foo, :bar])
+          expect(super_subject.options[:foo].desc).to eq("Foo option")
+          expect(super_subject.options[:bar].desc).to eq("Bar option")
+        end
+      end
+    end
+  end
+
+  describe "#initialize" do
+    it "must initialize #options" do
+      expect(subject.options).to eq({})
+    end
+  end
+end