command_kit 0.3.0 → 0.4.0

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/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")

data/spec/printing/fields_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+require 'command_kit/printing/fields'
+
+describe CommandKit::Printing::Fields do
+  module TestPrintingFields
+    class TestCmd
+
+      include CommandKit::Printing::Fields
+
+    end
+  end
+
+  let(:command_class) { TestPrintingFields::TestCmd }
+  subject { command_class.new }
+  
+  let(:nl) { $/ }
+
+  describe "#print_fields" do
+    context "when given a Hash" do
+      context "and all key values are the same length" do
+        let(:name1)  { 'A'   }
+        let(:value1) { 'foo' }
+        let(:name2)  { 'B'   }
+        let(:value2) { 'bar' }
+
+        let(:hash) do
+          {
+            name1 => value1,
+            name2 => value2
+          }
+        end
+
+        it "must not left-justify the Hash keys" do
+          expect {
+            subject.print_fields(hash)
+          }.to output("#{name1}: #{value1}#{nl}#{name2}: #{value2}#{nl}").to_stdout
+        end
+      end
+
+      context "but key values have different lengths" do
+        let(:name1)  { 'A'   }
+        let(:value1) { 'foo' }
+        let(:name2)  { 'Bar' }
+        let(:value2) { 'bar' }
+
+        let(:hash) do
+          {
+            name1 => value1,
+            name2 => value2
+          }
+        end
+
+        it "must left-justify the Hash keys" do
+          expect {
+            subject.print_fields(hash)
+          }.to output("#{name1}:   #{value1}#{nl}#{name2}: #{value2}#{nl}").to_stdout
+        end
+      end
+
+      context "but the key values are not Strings" do
+        let(:name1)  { 1     }
+        let(:value1) { 'foo' }
+        let(:name2)  { 100   }
+        let(:value2) { 'bar' }
+
+        let(:hash) do
+          {
+            name1 => value1,
+            name2 => value2
+          }
+        end
+
+        it "must convert them to Strings before calculating justification" do
+          expect {
+            subject.print_fields(hash)
+          }.to output("#{name1}:   #{value1}#{nl}#{name2}: #{value2}#{nl}").to_stdout
+        end
+      end
+    end
+
+    context "when given an Array of tuples" do
+      context "and all first tuple values are the same length" do
+        let(:name1)  { 'A'   }
+        let(:value1) { 'foo' }
+        let(:name2)  { 'B'   }
+        let(:value2) { 'bar' }
+
+        let(:array) do
+          [
+            [name1, value1],
+            [name2, value2]
+          ]
+        end
+
+        it "must not left-justify the tuples" do
+          expect {
+            subject.print_fields(array)
+          }.to output("#{name1}: #{value1}#{nl}#{name2}: #{value2}#{nl}").to_stdout
+        end
+      end
+
+      context "but first tuple values have different lengths" do
+        let(:name1)  { 'A'   }
+        let(:value1) { 'foo' }
+        let(:name2)  { 'Bar' }
+        let(:value2) { 'bar' }
+
+        let(:array) do
+          [
+            [name1, value1],
+            [name2, value2]
+          ]
+        end
+
+        it "must left-justify the tuples" do
+          expect {
+            subject.print_fields(array)
+          }.to output("#{name1}:   #{value1}#{nl}#{name2}: #{value2}#{nl}").to_stdout
+        end
+      end
+
+      context "but the first tuple values are not Strings" do
+        let(:name1)  { 1     }
+        let(:value1) { 'foo' }
+        let(:name2)  { 100   }
+        let(:value2) { 'bar' }
+
+        let(:array) do
+          [
+            [name1, value1],
+            [name2, value2]
+          ]
+        end
+
+        it "must convert them to Strings before calculating justification" do
+          expect {
+            subject.print_fields(array)
+          }.to output("#{name1}:   #{value1}#{nl}#{name2}: #{value2}#{nl}").to_stdout
+        end
+      end
+    end
+
+    context "but the values contain multiple lines" do
+      let(:name1)  { 'A'   }
+      let(:value1) { 'foo' }
+      let(:name2)  { 'Bar' }
+      let(:line1)  { 'bar' }
+      let(:line2)  { 'baz' }
+      let(:value2) do
+        [line1, line2].join($/)
+      end
+
+      let(:hash) do
+        {
+          name1 => value1,
+          name2 => value2
+        }
+      end
+
+      it "must print the header with the first line and then indent the other lines" do
+        expect {
+          subject.print_fields(hash)
+        }.to output("#{name1}:   #{value1}#{nl}#{name2}: #{line1}#{nl}     #{line2}#{nl}").to_stdout
+      end
+    end
+  end
+end

data/spec/printing/lists_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+require 'command_kit/printing/lists'
+
+describe CommandKit::Printing::Lists do
+  module TestPrintingLists
+    class TestCmd
+
+      include CommandKit::Printing::Lists
+
+    end
+  end
+
+  let(:command_class) { TestPrintingLists::TestCmd }
+  subject { command_class.new }
+  
+  describe "#print_list" do
+    let(:list) { %w[foo bar baz] }
+
+    it "must print each item in the list with a '*' bullet" do
+      expect {
+        subject.print_list(list)
+      }.to output(
+        list.map { |item| "* #{item}" }.join($/) + $/
+      ).to_stdout
+    end
+
+    context "when the list contins multi-line Strings" do
+      let(:item1) { "foo" }
+      let(:item2) do
+        [
+          "line 1",
+          "line 2",
+          "line 3"
+        ].join($/)
+      end
+      let(:item3) { "bar" }
+      let(:list)  { [item1, item2, item3] }
+
+      it "must print the bullet with the first line and then indent the other lines" do
+        expect {
+          subject.print_list(list)
+        }.to output(
+          [
+            "* #{item1}",
+            "* #{item2.lines[0].chomp}",
+            "  #{item2.lines[1].chomp}",
+            "  #{item2.lines[2].chomp}",
+            "* #{item3}",
+            ''
+          ].join($/)
+        ).to_stdout
+      end
+    end
+
+    context "when the list contains nested-lists" do
+      let(:item1)     { 'item 1'     }
+      let(:sub_item1) { 'sub-item 1' }
+      let(:sub_item2) { 'sub-item 2' }
+      let(:item2)     { 'item 2'     }
+
+      let(:list) do
+        [
+          'item 1',
+          [
+            'sub-item 1',
+            'sub-item 2'
+          ],
+          'item 2'
+        ]
+      end
+
+      it "must indent and print each sub-list" do
+        expect {
+          subject.print_list(list)
+        }.to output(
+          [
+            "* #{item1}",
+            "  * #{sub_item1}",
+            "  * #{sub_item2}",
+            "* #{item2}",
+            ''
+          ].join($/)
+        ).to_stdout
+      end
+    end
+    
+    context "when the bullet: keyowrd argument is given" do
+      let(:bullet) { '-' }
+
+      it "must print each item in the list with the bullet character" do
+        expect {
+          subject.print_list(list, bullet: bullet)
+        }.to output(
+          list.map { |item| "#{bullet} #{item}" }.join($/) + $/
+        ).to_stdout
+      end
+    end
+  end
+end

data/spec/printing/tables/border_style.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'command_kit/printing/tables/border_style'
+
+describe CommandKit::Printing::Tables::BorderStyle do
+  describe "#initialize" do
+    [
+      :top_left_corner,
+      :top_border,
+      :top_joined_border,
+      :top_right_corner,
+      :left_border,
+      :left_joined_border,
+      :horizontal_separator,
+      :vertical_separator,
+      :inner_joined_border,
+      :right_border,
+      :right_joined_border,
+      :bottom_border,
+      :bottom_left_corner,
+      :bottom_joined_border,
+      :bottom_right_corner
+    ].each do |keyword|
+      context "when #{keyword}: keyword is given" do
+        let(:keyword) { keyword }
+        let(:value)   { 'x' }
+
+        subject { described_class.new(**{keyword => value}) }
+
+        it "must set ##{keyword}" do
+          expect(subject.send(keyword)).to eq(value)
+        end
+      end
+
+      context "when #{keyword}: keyword is not given" do
+        let(:keyword) { keyword }
+
+        it "must default ##{keyword} to ' '" do
+          expect(subject.send(keyword)).to eq(' ')
+        end
+      end
+    end
+  end
+end

data/spec/printing/tables/cell_builer_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+require 'command_kit/printing/tables/cell_builder'
+
+describe CommandKit::Printing::Tables::CellBuilder do
+  describe "#initialize" do
+    it "must initialize #lines to an empty Array" do
+      expect(subject.lines).to eq([])
+    end
+
+    it "must default #height to 0" do
+      expect(subject.height).to eq(0)
+    end
+
+    it "must default #width to 0" do
+      expect(subject.width).to eq(0)
+    end
+
+    context "when an initial value is given" do
+     subject { described_class.new(value) }
+
+     context "and it's a String" do
+       let(:value) do
+         <<~EOS
+           foo bar
+           baz qux
+         EOS
+       end
+
+       it "must split the value into separate lines and populate #lines" do
+         expect(subject.lines).to eq(value.lines(chomp: true))
+       end
+     end
+
+     context "but it's not a String" do
+       let(:value) { 42 }
+
+       it "must convert it to a String before adding it to #lines" do
+         expect(subject.lines).to eq([value.to_s])
+       end
+     end
+    end
+  end
+
+  describe ".line_width" do
+    subject { described_class }
+
+    context "when given a plain-text String" do
+      let(:line) { "foo bar baz" }
+
+      it "must return the line length" do
+        expect(subject.line_width(line)).to eq(line.length)
+      end
+    end
+
+    context "when given a String containing ANSI control sequences" do
+      let(:line_without_ansi) { "foo bar baz" }
+      let(:line) { "\e[1m\e[32m#{line_without_ansi}\e[0m" }
+
+      it "must return the length of the line without the ANSI control sequences" do
+        expect(subject.line_width(line)).to eq(line_without_ansi.length)
+      end
+    end
+  end
+
+  describe "#<<" do
+    let(:line) { "foo bar baz" }
+
+    it "must increment #height by 1" do
+      expect(subject.height).to eq(0)
+
+      subject << line
+      expect(subject.height).to eq(1)
+
+      subject << line
+      expect(subject.height).to eq(2)
+    end
+
+    it "must append the line to #lines" do
+      subject << line
+
+      expect(subject.lines.last).to eq(line)
+    end
+
+    it "must return self" do
+      expect(subject << line).to be(subject)
+    end
+
+    context "when the line's line-width is greater than #width" do
+      let(:previous_line) { "foo" }
+
+      it "must update #width" do
+        subject << previous_line
+        expect(subject.width).to eq(previous_line.length)
+
+        subject << line
+        expect(subject.width).to eq(line.length)
+      end
+    end
+
+    context "when the line's line-width is not greater than #width" do
+      let(:previous_line) { "foo bar baz" }
+      let(:line)          { "foo" }
+
+      it "must update #width" do
+        subject << previous_line
+        expect(subject.width).to eq(previous_line.length)
+
+        subject << line
+        expect(subject.width).to eq(previous_line.length)
+      end
+    end
+  end
+
+  describe "#[]" do
+    let(:line1) { "foo bar" }
+    let(:line2) { "baz qux" }
+
+    before do
+      subject << line1
+      subject << line2
+    end
+
+    context "when the index is within the bounds of #lines" do
+      it "must return the line at the given index" do
+        expect(subject[1]).to eq(line2)
+      end
+    end
+
+    context "when the index is out of the bounds of #lines" do
+      it "must return ''" do
+        expect(subject[2]).to eq('')
+      end
+    end
+  end
+end