command_kit 0.2.2 → 0.4.0

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

data/spec/printing/tables/row_builder_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+require 'command_kit/printing/tables/row_builder'
+
+describe CommandKit::Printing::Tables::RowBuilder do
+  it { expect(described_class).to include(Enumerable) }
+
+  describe "#initialize" do
+    it "must initialize #cells to an empty Array" do
+      expect(subject.cells).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
+
+    it "must default #columns to 0" do
+      expect(subject.columns).to eq(0)
+    end
+
+    context "when given initial cells" do
+      let(:cell1) { "foo bar\nbaz qux" }
+      let(:cell2) { 'aaaa bbbb' }
+      let(:cells) { [cell1, cell2] }
+
+      subject { described_class.new(cells) }
+
+      it "must append the cells to the row" do
+        expect(subject.cells[0]).to be_kind_of(CommandKit::Printing::Tables::CellBuilder)
+        expect(subject.cells[0].lines).to eq(cell1.lines(chomp: true))
+
+        expect(subject.cells[1]).to be_kind_of(CommandKit::Printing::Tables::CellBuilder)
+        expect(subject.cells[1].lines).to eq(cell2.lines(chomp: true))
+      end
+    end
+  end
+
+  describe "#<<" do
+    context "when given a non-nil value" do
+      let(:value) { "foo bar\nbaz qux" }
+
+      it "must append a new CommandKit::Printing::Tables::CellBuilder object to #cells" do
+        subject << value
+
+        expect(subject.cells.last).to be_kind_of(CommandKit::Printing::Tables::CellBuilder)
+        expect(subject.cells.last.lines).to eq(value.lines(chomp: true))
+      end
+
+      context "when the new cell's height is greater than the row's current #height" do
+        let(:value1) { "foo" }
+        let(:value2) { "bar\nbaz\nqux" }
+
+        it "must update the row's current #height" do
+          expect(subject.height).to eq(0)
+
+          subject << value1
+          expect(subject.height).to eq(subject.cells[0].height)
+
+          subject << value2
+          expect(subject.height).to eq(subject.cells[1].height)
+        end
+      end
+
+      context "when the new cell's height is not greater than the row's current #height" do
+        let(:value1) { "bar\nbaz\nqux" }
+        let(:value2) { "foo" }
+
+        it "must not update the row's current #height" do
+          expect(subject.height).to eq(0)
+
+          subject << value1
+          expect(subject.height).to eq(subject.cells[0].height)
+
+          subject << value2
+          expect(subject.height).to eq(subject.cells[0].height)
+        end
+      end
+
+      it "must add the cell value's line width to the row's #width" do
+        value1 = "foo"
+        value1_width = CommandKit::Printing::Tables::CellBuilder.line_width(value1)
+
+        expect(subject.width).to eq(0)
+
+        subject << value1
+        expect(subject.width).to eq(value1_width)
+
+        value2 = "\e[32mbar\e[0m"
+        value2_width = CommandKit::Printing::Tables::CellBuilder.line_width(value2)
+
+        subject << value2
+        expect(subject.width).to eq(value1_width + value2_width)
+      end
+
+      it "must incrmenet #columns by 1" do
+        expect(subject.columns).to eq(0)
+
+        subject << "foo"
+        expect(subject.columns).to eq(1)
+
+        subject << "bar"
+        expect(subject.columns).to eq(2)
+      end
+
+      it "must return self" do
+        expect(subject << value).to be(subject)
+      end
+    end
+
+    context "when given a nil value" do
+      it "must append #{described_class}::EMPTY_CELL to #cells" do
+        subject << nil
+
+        expect(subject.cells.last).to be(described_class::EMPTY_CELL)
+      end
+
+      it "must return self" do
+        expect(subject << nil).to be(subject)
+      end
+    end
+  end
+
+  describe "#[]" do
+    before do
+      subject << "foo bar"
+      subject << "baz qux"
+    end
+
+    context "when the given column index is within the bounds of #cells" do
+      it "must return the cell at the given index" do
+        expect(subject[1]).to be(subject.cells[1])
+      end
+    end
+
+    context "when the given column index is not within the bounds of #cells" do
+      it "must return #{described_class}::EMPTY_CELL" do
+        expect(subject[2]).to be(described_class::EMPTY_CELL)
+      end
+    end
+  end
+
+  describe "#each" do
+    before do
+      subject << "foo bar"
+      subject << "baz qux"
+    end
+
+    context "when given a block" do
+      it "must yield each cell in #cells" do
+        expect { |b|
+          subject.each(&b)
+        }.to yield_successive_args(*subject.cells)
+      end
+    end
+
+    context "when no block is given" do
+      it "must return an Enumerator for #cells" do
+        expect(subject.each.to_a).to eq(subject.cells)
+      end
+    end
+  end
+end