command_kit 0.4.0 → 0.5.0

data/spec/options/option_value_spec.rb

@@ -1,171 +0,0 @@
-require 'spec_helper'
-require 'command_kit/options/option_value'
-
-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 }
-
-      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 default: keyword is given" do
-      subject { described_class.new(default: default) }
-
-      it "must set #default" do
-        expect(subject.default).to eq(default)
-      end
-    end
-
-    context "when the default: keyword is not given" do
-      subject { described_class.new() }
-
-      it "default #default to String" do
-        expect(subject.default).to eq(nil)
-      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
-
-  subject do
-    described_class.new(
-      type:     type,
-      usage:    usage,
-      required: required,
-      default:  default
-    )
-  end
-
-  describe "#usage" do
-    let(:usage) { 'FOO' }
-
-    context "when #optional? is true" do
-      let(:required) { false }
-
-      it "must wrap the usage within [ ] brackets" do
-        expect(subject.usage).to eq("[#{usage}]")
-      end
-    end
-
-    context "when #optional? is false" do
-      let(:required) { true }
-
-      it "should return the usage string unchanged" do
-        expect(subject.usage).to eq(usage)
-      end
-    end
-  end
-
-  describe "#default_value" do
-    context "when initialized with a default: that responded to #call" do
-      let(:default) do
-        ->{ [] }
-      end
-
-      it "must call the default #call method" do
-        expect(subject.default_value).to eq(default.call)
-      end
-    end
-
-    context "when initialized with a default: that it's an Object" do
-      let(:default) { "" }
-
-      it "must return the default: object" do
-        expect(subject.default_value).to eq(default)
-      end
-
-      it "must duplicate the default: object each time" do
-        expect(subject.default_value).to_not be(subject.default_value)
-      end
-    end
-  end
-end

data/spec/options/parser_spec.rb

@@ -1,255 +0,0 @@
-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 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/quiet_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-require 'command_kit/options/quiet'
-
-describe CommandKit::Options::Quiet do
-  module TestOptionsQuiet
-    class TestCommand
-      include CommandKit::Options::Quiet
-    end
-  end
-
-  let(:command_class) { TestOptionsQuiet::TestCommand }
-
-  describe ".included" do
-    subject { command_class }
-
-    it "must include CommandKit::Options" do
-      expect(subject).to include(CommandKit::Options)
-    end
-
-    it "must define a quiet option" do
-      expect(subject.options[:quiet]).to_not be(nil)
-      expect(subject.options[:quiet].short).to eq('-q')
-      expect(subject.options[:quiet].long).to eq('--quiet')
-      expect(subject.options[:quiet].desc).to eq('Enables quiet output')
-    end
-  end
-
-  subject { command_class.new }
-
-  describe "#quiet?" do
-    context "when @quiet is true" do
-      before do
-        subject.instance_variable_set('@quiet',true)
-      end
-
-      it "must return true" do
-        expect(subject.quiet?).to be(true)
-      end
-    end
-
-    context "when @quiet is false" do
-      before do
-        subject.instance_variable_set('@quiet',false)
-      end
-
-      it "must return false" do
-        expect(subject.quiet?).to be(false)
-      end
-    end
-  end
-end

data/spec/options/verbose_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-require 'command_kit/options/verbose'
-
-describe CommandKit::Options::Verbose do
-  module TestOptionsVerbose
-    class TestCommand
-      include CommandKit::Options::Verbose
-    end
-  end
-
-  let(:command_class) { TestOptionsVerbose::TestCommand }
-
-  describe ".included" do
-    subject { command_class }
-
-    it "must include CommandKit::Options" do
-      expect(subject).to include(CommandKit::Options)
-    end
-
-    it "must define a verbose option" do
-      expect(subject.options[:verbose]).to_not be(nil)
-      expect(subject.options[:verbose].short).to eq('-v')
-      expect(subject.options[:verbose].long).to eq('--verbose')
-      expect(subject.options[:verbose].desc).to eq('Enables verbose output')
-    end
-  end
-
-  subject { command_class.new }
-
-  describe "#verbose?" do
-    context "when @verbose is true" do
-      before do
-        subject.instance_variable_set('@verbose',true)
-      end
-
-      it "must return true" do
-        expect(subject.verbose?).to be(true)
-      end
-    end
-
-    context "when @verbose is false" do
-      before do
-        subject.instance_variable_set('@verbose',false)
-      end
-
-      it "must return false" do
-        expect(subject.verbose?).to be(false)
-      end
-    end
-  end
-end

data/spec/options/version_spec.rb

@@ -1,146 +0,0 @@
-require 'spec_helper'
-require 'command_kit/options/version'
-
-require 'stringio'
-
-describe CommandKit::Options::Version do
-  module TestOptionsVersion
-    class TestCommandWithoutVersion
-
-      include CommandKit::Options::Version
-
-      command_name 'test'
-
-    end
-
-    class TestCommandWithVersion
-
-      include CommandKit::Options::Version
-
-      command_name 'test'
-      version '0.1.0'
-
-    end
-  end
-
-  describe ".included" do
-    subject { TestOptionsVersion::TestCommandWithVersion }
-
-    it "must include CommandKit::Options" do
-      expect(subject).to include(CommandKit::Options)
-    end
-  end
-
-  describe ".version" do
-    context "when no .version has been previously set" do
-      subject { TestOptionsVersion::TestCommandWithoutVersion }
-
-      it "must return nil" do
-        expect(subject.version).to be(nil)
-      end
-    end
-
-    context "when a .version has been set" do
-      subject { TestOptionsVersion::TestCommandWithVersion }
-
-      it "must return the set version" do
-        expect(subject.version).to eq('0.1.0')
-      end
-    end
-
-    context "when the command class inherites from another class" do
-      context "but no version are defined" do
-        module TestOptionsVersion
-          class InheritedCommandWithoutVersion < TestCommandWithoutVersion
-          end
-        end
-
-        subject { TestOptionsVersion::InheritedCommandWithoutVersion }
-
-        it "must return nil" do
-          expect(subject.version).to be(nil)
-        end
-      end
-
-      context "when the superclass defines the version" do
-        module TestOptionsVersion
-          class InheritedCommandWithInheritedVersion < TestCommandWithVersion
-          end
-        end
-
-        let(:super_class) { TestOptionsVersion::TestCommandWithVersion }
-        subject { TestOptionsVersion::InheritedCommandWithInheritedVersion }
-
-        it "must return the version defined in the superclass" do
-          expect(subject.version).to eq(super_class.version)
-        end
-      end
-
-      context "when the subclass defines the version" do
-        module TestOptionsVersion
-          class InheritedCommandWithOwnVersion < TestCommandWithoutVersion
-
-            version '0.1.0'
-
-          end
-        end
-
-        let(:super_subject) { TestOptionsVersion::TestCommandWithoutVersion }
-        subject { TestOptionsVersion::InheritedCommandWithOwnVersion }
-
-        it "must return the version set in the subclass" do
-          expect(subject.version).to eq('0.1.0')
-        end
-
-        it "must not change the superclass'es version" do
-          expect(super_subject.version).to be(nil)
-        end
-      end
-
-      context "when subclass overrides the superclass's version" do
-        module TestOptionsVersion
-          class InheritedCommandThatOverridesVersion < TestCommandWithVersion
-
-            version '0.2.0'
-
-          end
-        end
-
-        let(:super_subject) { TestOptionsVersion::TestCommandWithVersion }
-        subject { TestOptionsVersion::InheritedCommandThatOverridesVersion }
-
-        it "must return the version set in the subclass" do
-          expect(subject.version).to eq('0.2.0')
-        end
-
-        it "must not change the superclass'es version" do
-          expect(super_subject.version).to eq('0.1.0')
-        end
-      end
-    end
-  end
-
-  let(:command_class) { TestOptionsVersion::TestCommandWithVersion }
-
-  subject { command_class.new }
-
-  describe "#version" do
-    it "must return the class'es .version value" do
-      expect(subject.version).to eq(command_class.version)
-    end
-  end
-
-  describe "#print_version" do
-    let(:stdout) { StringIO.new }
-
-    subject { command_class.new(stdout: stdout) }
-
-    it "must print the #command_name and #version" do
-      subject.print_version
-
-      expect(stdout.string).to eq(
-        "#{subject.command_name} #{subject.version}#{$/}"
-      )
-    end
-  end
-end