command_kit 0.1.0 → 0.3.0

data/spec/open_app_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+require 'command_kit/open_app'
+
+describe CommandKit::OpenApp do
+  module TestOpenApp
+    class TestCommand
+      include CommandKit::OpenApp
+    end
+  end
+
+  let(:command_class) { TestOpenApp::TestCommand }
+
+  subject { command_class.new }
+
+  describe "#initialize" do
+    context "when the OS is macOS" do
+      subject { command_class.new(os: :macos) }
+
+      it "must set @open_command to \"open\"" do
+        expect(subject.instance_variable_get("@open_command")).to eq("open")
+      end
+    end
+
+    context "when the OS is Linux" do
+      subject { command_class.new(os: :linux) }
+
+      it "must set @open_command to \"xdg-open\"" do
+        expect(subject.instance_variable_get("@open_command")).to eq("xdg-open")
+      end
+    end
+
+    context "when the OS is FreeBSD" do
+      subject { command_class.new(os: :freebsd) }
+
+      it "must set @open_command to \"xdg-open\"" do
+        expect(subject.instance_variable_get("@open_command")).to eq("xdg-open")
+      end
+    end
+
+    context "when the OS is OpenBSD" do
+      subject { command_class.new(os: :openbsd) }
+
+      it "must set @open_command to \"xdg-open\"" do
+        expect(subject.instance_variable_get("@open_command")).to eq("xdg-open")
+      end
+    end
+
+    context "when the OS is NetBSD" do
+      subject { command_class.new(os: :openbsd) }
+
+      it "must set @open_command to \"xdg-open\"" do
+        expect(subject.instance_variable_get("@open_command")).to eq("xdg-open")
+      end
+    end
+
+    context "when the OS is Windows" do
+      subject { command_class.new(os: :windows) }
+
+      it "must set @open_command to \"start\"" do
+        expect(subject.instance_variable_get("@open_command")).to eq("start")
+      end
+    end
+  end
+
+  describe "#open_app_for" do
+    context "when @open_command is set" do
+      let(:file_or_uri) { "foo" }
+      let(:status) { true }
+
+      it "must execute the @open_command with the given URI or file" do
+        expect(subject).to receive(:system).with(subject.instance_variable_get("@open_command"),file_or_uri).and_return(status)
+
+        expect(subject.open_app_for(file_or_uri)).to be(status)
+      end
+    end
+
+    context "when @open_command is not set" do
+      before do
+        subject.instance_variable_set("@open_command",nil)
+      end
+
+      it { expect(subject.open_app_for("foo")).to be(nil) }
+    end
+  end
+end

data/spec/options/option_spec.rb

@@ -18,12 +18,12 @@ describe CommandKit::Options::Option do
   end
 
   subject do
-    described_class.new name, short:  short,
+    described_class.new(name, short:  short,
                               long:   long,
                               equals: equals,
                               desc:   desc,
                               value:  value,
-                              &block
+                              &block)
   end
 
   describe "#initialize" do
@@ -145,6 +145,20 @@ describe CommandKit::Options::Option do
       end
     end
 
+    it "must default #category to nil" do
+      expect(subject.category).to be(nil)
+    end
+
+    context "when the category: keyword is given" do
+      let(:category) { 'Other Options' }
+
+      subject { described_class.new(name, desc: desc, category: category) }
+
+      it "must set #category" do
+        expect(subject.category).to eq(category)
+      end
+    end
+
     context "when a block is given" do
       subject { described_class.new(name, desc: desc, &block) }
 
@@ -293,5 +307,27 @@ describe CommandKit::Options::Option do
         expect(subject.desc).to eq("#{desc} (Default: #{default})")
       end
     end
+
+    context "when #desc was initialized with an Array" do
+      let(:desc) do
+        [
+          'Line 1',
+          'Line 2'
+        ]
+      end
+
+      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 append '(Default: ...)' to the desc Array" do
+          expect(subject.desc).to eq([*desc, "(Default: #{default})"])
+        end
+      end
+    end
   end
 end

data/spec/options/option_value_spec.rb

@@ -7,6 +7,61 @@ describe CommandKit::Options::OptionValue do
   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 }

data/spec/options/parser_spec.rb

@@ -34,16 +34,6 @@ describe CommandKit::Options::Parser 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(
         [

data/spec/options_spec.rb

@@ -133,5 +133,333 @@ describe CommandKit::Options do
     it "must initialize #options" do
       expect(subject.options).to eq({})
     end
+
+    context "when options have default values" do
+      module TestOptions
+        class TestCommandWithDefaultValues
+
+          include CommandKit::Options
+
+          option :option1, value: {
+                             required: true,
+                             type: String
+                           },
+                           desc: 'Option 1'
+
+          option :option2, value: {
+                             required: false,
+                             type: String,
+                             default: "foo"
+                           },
+                           desc: 'Option 2'
+        end
+      end
+
+      let(:command_class) { TestOptions::TestCommandWithDefaultValues }
+
+      it "must pre-populate #options with the default values" do
+        expect(subject.options).to_not have_key(:option1)
+        expect(subject.options).to have_key(:option2)
+        expect(subject.options[:option2]).to eq("foo")
+      end
+    end
+  end
+
+  module TestOptions
+    class TestCommandWithOptionsAndArguments
+
+      include CommandKit::Options
+
+      usage '[OPTIONS] ARG1 [ARG2]'
+
+      option :option1, short: '-a',
+                       value: {
+                         type: Integer,
+                         default: 1
+                       },
+                       desc: "Option 1"
+
+      option :option2, short: '-b',
+                       value: {
+                         type: String,
+                         usage: 'FILE'
+                       },
+                       desc: "Option 2"
+
+      argument :argument1, required: true,
+                           usage:    'ARG1',
+                           desc:     "Argument 1"
+
+      argument :argument2, required: false,
+                           usage:    'ARG2',
+                           desc:     "Argument 2"
+
+    end
+  end
+
+  describe "#option_parser" do
+    context "when an option does not accept a value" do
+      module TestOptions
+        class TestCommandWithOptionWithoutValue
+
+          include CommandKit::Options
+
+          option :opt, desc: "Option without a value"
+
+        end
+      end
+
+      let(:command_class) { TestOptions::TestCommandWithOptionWithoutValue }
+
+      context "but the option flag was not given" do
+        let(:argv) { [] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must not populate #options with a value" do
+          expect(subject.options).to be_empty
+        end
+      end
+
+      context "and the option flag was given" do
+        let(:argv) { %w[--opt] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must set a key in #options to true" do
+          expect(subject.options[:opt]).to be(true)
+        end
+      end
+    end
+
+    context "when an option requires a value" do
+      module TestOptions
+        class TestCommandWithOptionWithRequiredValue
+
+          include CommandKit::Options
+
+          option :opt, value: {
+                         required: true,
+                         type: String
+                       },
+                       desc: "Option without a value"
+
+        end
+      end
+
+      let(:command_class) do
+        TestOptions::TestCommandWithOptionWithRequiredValue
+      end
+
+      context "but the option flag was not given" do
+        let(:argv) { [] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must not populate #options with a value" do
+          expect(subject.options).to be_empty
+        end
+      end
+
+      context "and the option flag and value were given" do
+        let(:value) { 'foo'            }
+        let(:argv)  { ['--opt', value] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must set a key in #options to the value" do
+          expect(subject.options[:opt]).to eq(value)
+        end
+      end
+    end
+
+    context "when an option does not require a value" do
+      module TestOptions
+        class TestCommandWithOptionWithOptionalValue
+
+          include CommandKit::Options
+
+          option :opt, value: {
+                         required: false,
+                         type: String
+                       },
+                       desc: "Option without a value"
+
+        end
+      end
+
+      let(:command_class) do
+        TestOptions::TestCommandWithOptionWithOptionalValue
+      end
+
+      context "but the option flag was not given" do
+        let(:argv) { [] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must not populate #options with a value" do
+          expect(subject.options).to be_empty
+        end
+      end
+
+      context "and the option flag and value were given" do
+        let(:value) { 'foo'            }
+        let(:argv)  { ['--opt', value] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must set a key in #options to the value" do
+          expect(subject.options[:opt]).to eq(value)
+        end
+      end
+
+      context "and the option has a default value" do
+        module TestOptions
+          class TestCommandWithOptionWithOptionalValueAndDefaultValue
+
+            include CommandKit::Options
+
+            option :opt, value: {
+                           required: false,
+                           type: String,
+                           default: "bar"
+                         },
+                         desc: "Option without a value"
+
+          end
+        end
+
+        let(:command_class) do
+          TestOptions::TestCommandWithOptionWithOptionalValueAndDefaultValue
+        end
+
+        context "but the option flag was not given" do
+          let(:argv) { [] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must set a key in #options to the default value" do
+            expect(subject.options[:opt]).to eq("bar")
+          end
+        end
+
+        context "and the option flag and value were given" do
+          let(:value) { 'foo'            }
+          let(:argv)  { ['--opt', value] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must set a key in #options to the value" do
+            expect(subject.options[:opt]).to eq(value)
+          end
+        end
+
+        context "and the option flag but not the value are given" do
+          let(:argv)  { ['--opt'] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must set a key in #options to nil" do
+            expect(subject.options).to have_key(:opt)
+            expect(subject.options[:opt]).to be(nil)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#main" do
+    let(:command_class) { TestOptions::TestCommandWithOptionsAndArguments }
+
+    let(:argv) { %w[-a 42 -b foo.txt arg1 arg2] }
+
+    it "must parse options before validating the number of arguments" do
+      expect {
+        expect(subject.main(argv)).to eq(0)
+      }.to_not output.to_stderr
+    end
+
+    context "but the wrong number of arguments are given" do
+      let(:argv) { %w[-a 42 -b foo.txt] }
+
+      it "must still validate the number of arguments" do
+        expect {
+          expect(subject.main(argv)).to eq(1)
+        }.to output("#{subject.command_name}: insufficient number of arguments.#{$/}").to_stderr
+      end
+    end
+  end
+
+  describe "#help" do
+    let(:command_class) { TestOptions::TestCommandWithOptionsAndArguments }
+
+    let(:option1)   { command_class.options[:option1]     }
+    let(:option2)   { command_class.options[:option2]     }
+    let(:argument1) { command_class.arguments[:argument1] }
+    let(:argument2) { command_class.arguments[:argument2] }
+
+    it "must print the usage, options and arguments" do
+      expect { subject.help }.to output(
+        [
+          "Usage: #{subject.usage}",
+          '',
+          'Options:',
+          "    #{option1.usage.join(', ').ljust(33 - 1)} #{option1.desc}",
+          "    #{option2.usage.join(', ').ljust(33 - 1)} #{option2.desc}",
+          '    -h, --help                       Print help information',
+          '',
+          "Arguments:",
+          "    #{argument1.usage.ljust(33)}#{argument1.desc}",
+          "    #{argument2.usage.ljust(33)}#{argument2.desc}",
+          ''
+        ].join($/)
+      ).to_stdout
+    end
+
+    context "but when the options are have categories" do
+      module TestOptions
+        class TestCommandWithOptionsAndCategories
+
+          include CommandKit::Options
+
+          option :opt1, short: '-a',
+                        desc: "Option 1"
+          option :opt2, short: '-b',
+                        desc: "Option 2"
+
+          option :opt3, short:    '-c',
+                        desc:     "Option 3",
+                        category: 'Other Options'
+          option :opt4, short:    '-d',
+                        desc:     "Option 4",
+                        category: 'Other Options'
+        end
+      end
+
+      let(:command_class) { TestOptions::TestCommandWithOptionsAndCategories }
+
+      let(:option1)   { command_class.options[:opt1] }
+      let(:option2)   { command_class.options[:opt2] }
+      let(:option3)   { command_class.options[:opt3] }
+      let(:option4)   { command_class.options[:opt4] }
+
+      it "must group the options by category" do
+        expect { subject.help }.to output(
+          [
+            "Usage: #{subject.usage}",
+            '',
+            'Other Options:',
+            "    #{option3.usage.join(', ').ljust(33 - 1)} #{option3.desc}",
+            "    #{option4.usage.join(', ').ljust(33 - 1)} #{option4.desc}",
+            '',
+            'Options:',
+            "    #{option1.usage.join(', ').ljust(33 - 1)} #{option1.desc}",
+            "    #{option2.usage.join(', ').ljust(33 - 1)} #{option2.desc}",
+            '    -h, --help                       Print help information',
+            ''
+          ].join($/)
+        ).to_stdout
+      end
+    end
   end
 end