command_kit 0.4.0 → 0.5.0

data/spec/pager_spec.rb

@@ -1,217 +0,0 @@
-require 'spec_helper'
-require 'command_kit/pager'
-
-require 'stringio'
-
-describe CommandKit::Pager do
-  module TestPager
-    class TestCommand
-      include CommandKit::Pager
-    end
-  end
-
-  let(:command_class) { TestPager::TestCommand }
-  subject { command_class.new }
-
-  describe "#initialize" do
-    context "when the PAGER env variable is set" do
-      let(:pager) { 'foo' }
-
-      subject { command_class.new(env: {'PAGER' => pager}) }
-
-      it "must set @pager_command to the PAGER env variable" do
-        expect(subject.instance_variable_get('@pager_command')).to eq(pager)
-      end
-    end
-
-    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.fetch('PATH')}) }
-
-        it "must search PATH for one of the pagers" do
-          expect(subject.instance_variable_get('@pager_command')).to eq("less -r")
-        end
-      end
-    end
-  end
-
-  describe "#pager" do
-    context "when stdout is not a TTY" do
-      subject { command_class.new(stdout: StringIO.new) }
-
-      it "must yield stdout" do
-        expect { |b|
-          subject.pager(&b)
-        }.to yield_with_args(subject.stdout)
-      end
-    end
-
-    context "when @pager_command isn't initialized" do
-      before do
-        subject.instance_variable_set('@pager_command',nil)
-      end
-
-      it "must yield stdout" do
-        expect { |b|
-          subject.pager(&b)
-        }.to yield_with_args(subject.stdout)
-      end
-    end
-
-    context "when stdout is a TTY and @pager_command is initialized" do
-      let(:pager) { 'less -r' }
-
-      subject { command_class.new(env: {'PAGER' => pager}) }
-
-      let(:pager_io)  { double('less') }
-      let(:pager_pid) { double('pid')  }
-
-      before do
-        expect(subject.stdout).to receive(:tty?).and_return(true)
-
-        expect(IO).to receive(:popen).with(pager,'w').and_return(pager_io)
-        expect(pager_io).to receive(:pid).and_return(pager_pid)
-
-        expect(pager_io).to receive(:close)
-        expect(Process).to receive(:waitpid).with(pager_pid)
-      end
-
-      it "must spawn a new process and yield an IO object" do
-        expect { |b|
-          subject.pager(&b)
-        }.to yield_with_args(pager_io)
-      end
-
-      context "when Errno::EPIPE is raised" do
-        it "must return gracefully" do
-          expect {
-            subject.pager do
-              raise(Errno::EPIPE,"pipe broken")
-            end
-          }.to_not raise_error
-        end
-      end
-    end
-  end
-
-  describe "#print_or_page" do
-    let(:terminal_height) { 10 }
-
-    before do
-      expect(subject).to receive(:terminal_height).and_return(terminal_height)
-    end
-
-    context "when given a String" do
-      context "and the number of lines is less than the console's height" do
-        let(:string) { "foo#{$/}bar#{$/}" }
-
-        it "must puts the String to stdout" do
-          expect(subject.stdout).to receive(:puts).with(string)
-
-          subject.print_or_page(string)
-        end
-      end
-
-      context "and the number of lines is greater than the console's height" do
-        let(:string) { "foo#{$/}bar#{$/}" * terminal_height }
-
-        it "must spawn a pager and puts the String to the pager" do
-          pager = double('pager')
-          expect(subject).to receive(:pager).and_yield(pager)
-          expect(pager).to receive(:puts).with(string)
-
-          subject.print_or_page(string)
-        end
-      end
-    end
-
-    context "when given an Array" do
-      context "and the number of lines is less than the console's height" do
-        let(:array) { ['foo', 'bar'] }
-
-        it "must puts the Array of Strings to stdout" do
-          expect(subject.stdout).to receive(:puts).with(array)
-
-          subject.print_or_page(array)
-        end
-      end
-
-      context "and the number of lines is greater than the console's height" do
-        let(:array) { ['foo', 'bar'] * terminal_height }
-
-        it "must spawn a pager and puts the Array of Strings to the pager" do
-          pager = double('pager')
-          expect(subject).to receive(:pager).and_yield(pager)
-          expect(pager).to receive(:puts).with(array)
-
-          subject.print_or_page(array)
-        end
-      end
-    end
-  end
-
-  describe "#pipe_to_pager" do
-    context "when @pager_command is initialized" do
-      let(:pager) { 'less' }
-
-      subject do
-        command_class.new(env: {'PAGER' => pager})
-      end
-
-      context "and when given a single String" do
-        let(:command) { "find ." }
-
-        it "must run the command but piped into the pager" do
-          expect(subject).to receive(:system).with("#{command} | #{pager}")
-
-          subject.pipe_to_pager(command)
-        end
-      end
-
-      context "and when given a String and additional arguments" do
-        let(:command)   { 'find'          }
-        let(:arguments) { %w[. -name *.md] }
-
-        let(:escaped_command) do
-          Shellwords.shelljoin([command,*arguments])
-        end
-
-        it "must shell escape the command and arguments" do
-          expect(subject).to receive(:system).with(
-            "#{escaped_command} | #{pager}"
-          )
-
-          subject.pipe_to_pager(command,*arguments)
-        end
-      end
-    end
-
-    context "when @pager_command is not initialized" do
-      before do
-        subject.instance_variable_set('@pager_command',nil)
-      end
-
-      let(:command)   { 'find' }
-      let(:arguments) { %w[. -name *.md] }
-
-      it "must pass the command and any additional arguments to #system" do
-        expect(subject).to receive(:system).with(command,*arguments)
-
-        subject.pipe_to_pager(command,*arguments)
-      end
-
-      context "when one of the arguments is not a String" do
-        let(:command)   { :find }
-        let(:arguments) { ['.', :"-name", "*.md"] }
-
-        it "must convert the command to a String before calling #system" do
-          expect(subject).to receive(:system).with(
-            command.to_s, *arguments.map(&:to_s)
-          )
-
-          subject.pipe_to_pager(command,*arguments)
-        end
-      end
-    end
-  end
-end

data/spec/printing/fields_spec.rb

@@ -1,167 +0,0 @@
-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/indent_spec.rb

@@ -1,132 +0,0 @@
-require 'spec_helper'
-require 'command_kit/printing/indent'
-
-describe CommandKit::Printing::Indent do
-  module TestIndent
-    class TestCommand
-      include CommandKit::Printing::Indent
-    end
-  end
-
-  let(:command_class) { TestIndent::TestCommand }
-  subject { command_class.new }
-
-  describe "#initialize" do
-    it "must initialize #indent to 0" do
-      expect(subject.indent).to eq(0)
-    end
-
-    context "when the class has a superclass" do
-      module TestIndent
-        class TestSuperCommand
-
-          attr_reader :var
-
-          def initialize(var: 'default')
-            @var = var
-          end
-
-        end
-
-        class TestSubCommand < TestSuperCommand
-
-          include CommandKit::Printing::Indent
-
-        end
-      end
-
-      let(:command_class) { TestIndent::TestSubCommand }
-
-      it "must initialize @indent to 0" do
-        expect(subject.indent).to eq(0)
-      end
-
-      it "must call super()" do
-        expect(subject.var).to eq('default')
-      end
-
-      context "and additional keyword arguments are given" do
-        let(:var) { 'foo' }
-
-        subject { command_class.new(var: var) }
-
-        it "must call super() with the additional keyword arguments" do
-          expect(subject.var).to eq(var)
-        end
-      end
-    end
-  end
-
-  describe "#indent" do
-    context "when no block is given" do
-      it "must return the indentation level" do
-        expect(subject.indent).to eq(0)
-      end
-    end
-
-    context "when a block is given" do
-      it do
-        expect { |b| subject.indent(&b) }.to yield_control
-      end
-
-      it "must increase the indent level by 2 then yield" do
-        expect(subject.indent).to eq(0)
-        
-        subject.indent do
-          expect(subject.indent).to eq(2)
-        end
-      end
-
-      it "must restore the indententation level to it's original value" do
-        subject.indent do
-          expect(subject.indent).to eq(2)
-        end
-
-        expect(subject.indent).to eq(0)
-      end
-
-      context "when an exception occurrs within the given block" do
-        it "must not rescue the exception" do
-          expect {
-            subject.indent do
-              raise("error")
-            end
-          }.to raise_error(RuntimeError,"error")
-        end
-
-        it "must restore the indententation level to it's original value" do
-          begin
-            subject.indent do
-              expect(subject.indent).to eq(2)
-              raise("error")
-            end
-          rescue
-          end
-
-          expect(subject.indent).to eq(0)
-        end
-      end
-    end
-  end
-
-  describe "#puts" do
-    let(:nl)   { $/ }
-    let(:text) { 'hello world' }
-
-    context "when the indententation level is 0" do
-      it "must not add leading indentation" do
-        expect { subject.puts(text) }.to output("#{text}#{nl}").to_stdout
-      end
-    end
-
-    context "when the indententation level is > 0" do
-      it "must add a number of spaces to the text" do
-        expect {
-          subject.indent do
-            subject.puts(text)
-          end
-        }.to output("  #{text}#{nl}").to_stdout
-      end
-    end
-  end
-end

data/spec/printing/lists_spec.rb

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

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