command_kit 0.1.0.rc1 → 0.2.2

data/spec/inflector_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'command_kit/inflector'
 
-describe Inflector do
+describe CommandKit::Inflector do
   describe ".demodularize" do
     context "when given a single class or module name" do
       let(:name) { 'Foo' }
@@ -28,6 +28,10 @@ describe Inflector do
     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')
@@ -37,18 +41,48 @@ describe Inflector do
       expect(subject.underscore('camelCase')).to eq('camel_case')
     end
 
-    it "must convert Camel to camel" do
-      expect(subject.underscore('Camel')).to eq('camel')
+    it "must convert Camelcase to camelcase" do
+      expect(subject.underscore('Camelcase')).to eq('camelcase')
     end
 
-    it "must convert CAMEL to camel" do
-      expect(subject.underscore('CAMEL')).to eq('camel')
+    it "must convert CAMELCASE to camelcase" do
+      expect(subject.underscore('CAMELCASE')).to eq('camelcase')
     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
+    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
@@ -56,6 +90,20 @@ describe Inflector 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
@@ -100,5 +148,19 @@ describe Inflector 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/main_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'command_kit/main'
 
-describe Main do
+describe CommandKit::Main do
   module TestMain
     class TestCommand
       include CommandKit::Main
@@ -156,16 +156,16 @@ describe Main do
   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
+    it "must call #run with the given argv" do
+      argv = ["foo", "bar", "baz"]
+
+      expect(subject).to receive(:run).with(*argv)
+      
+      subject.main(argv)
     end
 
     context "when #run raises SystemExit" do

data/spec/man_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'command_kit/man'
+
+describe CommandKit::Man do
+  module TestMan
+    class TestCommand
+      include CommandKit::Man
+    end
+  end
+
+  let(:command_class) { TestMan::TestCommand }
+
+  subject { command_class.new }
+
+  describe "#man" do
+    let(:man_page) { 'foo' }
+
+    it "must call system() with the given man page" do
+      expect(subject).to receive(:system).with('man',man_page)
+
+      subject.man(man_page)
+    end
+
+    context "when given a non-String man-page argument" do
+      let(:man_page_arg) { double(:non_string_arg) }
+
+      it "must call #to_s on the man-page argument" do
+        expect(man_page_arg).to receive(:to_s).and_return(man_page)
+
+        expect(subject).to receive(:system).with('man',man_page)
+
+        subject.man(man_page_arg)
+      end
+    end
+
+    context "when given the section: keyword argument" do
+      let(:section) { 7 }
+
+      it "must call system() with the given section number and man page" do
+        expect(subject).to receive(:system).with('man',section.to_s,man_page)
+
+        subject.man(man_page, section: section)
+      end
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'command_kit/options/option'
 
-describe Options::Option do
+describe CommandKit::Options::Option do
   let(:name)   { :foo    }
   let(:short)  { nil     }
   let(:long)   { '--foo' }
@@ -18,12 +18,12 @@ describe 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
@@ -82,7 +82,7 @@ describe Options::Option do
         subject { described_class.new(name, value: {type: type}, desc: desc) }
 
         it "must initialize #value" do
-          expect(subject.value).to      be_kind_of(Options::OptionValue)
+          expect(subject.value).to      be_kind_of(CommandKit::Options::OptionValue)
           expect(subject.value.type).to eq(type)
         end
       end
@@ -91,7 +91,7 @@ describe Options::Option do
         subject { described_class.new(name, value: true, desc: desc) }
 
         it "must initialize #value with defaults" do
-          expect(subject.value).to           be_kind_of(Options::OptionValue)
+          expect(subject.value).to           be_kind_of(CommandKit::Options::OptionValue)
           expect(subject.value.type).to      eq(String)
           expect(subject.value.required?).to be(true)
           expect(subject.value.usage).to     eq('STR')

data/spec/options/option_value_spec.rb

@@ -1,12 +1,67 @@
 require 'spec_helper'
 require 'command_kit/options/option_value'
 
-describe Options::OptionValue do
+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 }

data/spec/options_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'command_kit/options'
 
-describe Options do
+describe CommandKit::Options do
   module TestOptions
     class ImplicitCmd
       include CommandKit::Options
@@ -133,5 +133,287 @@ describe 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
   end
 end