command_kit 0.2.2 → 0.4.0

data/spec/edit_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'command_kit/edit'
+
+describe CommandKit::Edit do
+  module TestEdit
+    class TestCommand
+      include CommandKit::Edit
+    end
+  end
+
+  let(:command_class) { TestEdit::TestCommand }
+
+  it "must also include CommandKit::Env" do
+    expect(command_class).to include(CommandKit::Env)
+  end
+
+  describe "#editor" do
+    subject { command_class.new(env: env) }
+
+    context "when env['EDITOR'] is set" do
+      let(:editor) { 'vim' }
+      let(:env) do
+        {'EDITOR' => editor}
+      end
+
+      it "must return env['EDITOR']" do
+        expect(subject.editor).to eq(env['EDITOR'])
+      end
+    end
+
+    context "when env['EDITOR'] is not set" do
+      let(:env) do
+        {}
+      end
+
+      it "must return 'nano'" do
+        expect(subject.editor).to eq('nano')
+      end
+    end
+  end
+
+  describe "#edit" do
+    subject { command_class.new(env: env) }
+
+    let(:arguments) { ['file.txt'] }
+
+    context "when env['EDITOR'] is set" do
+      let(:editor) { 'vim' }
+      let(:env) do
+        {'EDITOR' => editor}
+      end
+
+      it "must invoke system with #editor and the additional arguments" do
+        expect(subject).to receive(:system).with(subject.editor,*arguments)
+
+        subject.edit(*arguments)
+      end
+    end
+
+    context "when env['EDITOR'] is not set" do
+      let(:env) do
+        {}
+      end
+
+      it "must invoke system with 'nano' and the additional arguments" do
+        expect(subject).to receive(:system).with('nano',*arguments)
+
+        subject.edit(*arguments)
+      end
+    end
+  end
+end

data/spec/file_utils_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'command_kit/file_utils'
+require 'tempfile'
+
+describe CommandKit::FileUtils do
+  module TestFileUtils
+    class Command
+      include CommandKit::FileUtils
+
+      attr_reader :var
+
+      def initialize(var: nil)
+        super()
+
+        @var = var
+      end
+
+      def test_method
+        'some method'
+      end
+    end
+  end
+
+  let(:var) { 42 }
+
+  let(:command_class) { TestFileUtils::Command }
+  subject { command_class.new(var: var) }
+
+  let(:fixtures_dir)  { File.expand_path(File.join(__dir__,'fixtures')) }
+  let(:template_path) { File.join(fixtures_dir,'template.erb') }
+
+  describe "#erb" do
+    let(:expected_result) do
+      [
+        "Raw text",
+        '',
+        "variable = #{var}",
+        '',
+        "method = #{subject.test_method}"
+      ].join($/)
+    end
+
+    context "when only given a source file argument" do
+      it "must render the erb template and return the result" do
+        expect(subject.erb(template_path)).to eq(expected_result)
+      end
+    end
+
+    context "when given an additional destination file argument" do
+      let(:dest_path) { Tempfile.new.path }
+
+      before { subject.erb(template_path,dest_path) }
+
+      it "must render the erb template and write the result to the destination" do
+        expect(File.read(dest_path)).to eq(expected_result)
+      end
+    end
+  end
+end

data/spec/fixtures/template.erb

@@ -0,0 +1,5 @@
+Raw text
+
+variable = <%= @var %>
+
+method = <%= test_method -%>

data/spec/options/option_spec.rb

@@ -6,10 +6,12 @@ describe CommandKit::Options::Option do
   let(:short)  { nil     }
   let(:long)   { '--foo' }
   let(:equals) { false   }
+  let(:value_usage)    { 'FOO' }
+  let(:value_required) { true  }
   let(:value) do
     {
-      usage:    'FOO',
-      required: true
+      usage:    value_usage,
+      required: value_required
     }
   end
   let(:desc)  { 'Foo option' }
@@ -145,6 +147,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) }
 
@@ -214,6 +230,14 @@ describe CommandKit::Options::Option do
         it "must return '--option=USAGE'" do
           expect(subject.usage.last).to eq("#{long}=#{subject.value.usage}")
         end
+
+        context "but the #value is also optional?" do
+          let(:value_required) { false }
+
+          it "must return '--option[=USAGE]'" do
+            expect(subject.usage.last).to eq("#{long}[=#{subject.value.usage}]")
+          end
+        end
       end
     end
 
@@ -293,5 +317,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/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/quiet_spec.rb

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,146 @@
+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

data/spec/options_spec.rb

@@ -415,5 +415,51 @@ describe CommandKit::Options do
         ].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

data/spec/pager_spec.rb

@@ -26,7 +26,7 @@ describe CommandKit::Pager do
 
     context "when the PAGER env variable is not set" do
       context "but the PATH env variable is" do
-        subject { command_class.new(env: {'PATH' => ENV['PATH']}) }
+        subject { command_class.new(env: {'PATH' => ENV.fetch('PATH')}) }
 
         it "must search PATH for one of the pagers" do
           expect(subject.instance_variable_get('@pager_command')).to eq("less -r")