command_kit 0.1.0.pre1

data/spec/os_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'command_kit/os'
+
+describe OS do
+  class TestOS
+    include CommandKit::OS
+  end
+
+  subject { TestOS.new }
+
+  describe "#linux?" do
+    context "when RUBY_PLATFORM contains 'linux'" do
+      before { stub_const('RUBY_PLATFORM','x86_64-linux') }
+
+      it { expect(subject.linux?).to be(true) }
+    end
+
+    context "when RUBY_PLATFORM does not contain 'linux'" do
+      before { stub_const('RUBY_PLATFORM','aarch64-darwin') }
+
+      it { expect(subject.linux?).to be(false) }
+    end
+  end
+
+  describe "#macos?" do
+    context "when RUBY_PLATFORM contains 'darwin'" do
+      before { stub_const('RUBY_PLATFORM','aarch64-darwin') }
+
+      it { expect(subject.macos?).to be(true) }
+    end
+
+    context "when RUBY_PLATFORM does not contain 'darwin'" do
+      before { stub_const('RUBY_PLATFORM','mswin') }
+
+      it { expect(subject.macos?).to be(false) }
+    end
+  end
+
+  describe "#windows?" do
+    it "must call Gem.win_platform?" do
+      expect(Gem).to receive(:win_platform?)
+
+      subject.windows?
+    end
+  end
+end

data/spec/pager_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+require 'command_kit/pager'
+
+require 'stringio'
+
+describe 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 to the PAGER env variable" do
+        expect(subject.instance_variable_get('@pager')).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['PATH']}) }
+
+        it "must search PATH for one of the pagers" do
+          expect(subject.instance_variable_get('@pager')).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 isn't initialized" do
+      before do
+        subject.instance_variable_set('@pager',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 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(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
+        skip "STDOUT is not a TTY" unless STDOUT.tty?
+
+        expect { |b|
+          subject.pager(&b)
+        }.to yield_with_args(pager_io)
+      end
+
+      context "when Errno::EPIPE is raised" do
+        it "must return gracefully" do
+          skip "STDOUT is not a TTY" unless STDOUT.tty?
+
+          expect {
+            subject.pager do
+              raise(Errno::EPIPE,"pipe broken")
+            end
+          }.to_not raise_error
+        end
+      end
+    end
+  end
+
+  describe "#print_or_page" do
+    let(:console_height) { 10 }
+
+    before do
+      expect(subject).to receive(:console_height).and_return(console_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#{$/}" * console_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'] * console_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
+end

data/spec/printing/indent_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+require 'command_kit/printing/indent'
+
+describe 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.instance_variable_get('@indent')).to eq(0)
+    end
+
+    context "when the class has a superclass" do
+      module TestIndent
+        class TestSuperCommand
+
+          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.instance_variable_get('@indent')).to eq(0)
+      end
+
+      it "must call super()" do
+        expect(subject.instance_variable_get('@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.instance_variable_get('@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_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'command_kit/printing'
+
+require 'stringio'
+
+describe Printing do
+  module TestPrinting
+    class TestCmd
+
+      include CommandKit::Printing
+
+    end
+  end
+
+  let(:command_class) { TestPrinting::TestCmd }
+  subject { command_class.new }
+
+  describe ".included" do
+    subject { command_class }
+
+    it { expect(command_class).to include(Stdio) }
+  end
+
+  let(:nl) { $/ }
+
+  describe "#print_error" do
+    let(:message) { "oh no!" }
+
+    it "must print a line to stderr" do
+      expect {
+        subject.print_error(message)
+      }.to output("#{message}#{nl}").to_stderr
+    end
+  end
+
+  describe "#print_exception" do
+    let(:message) { "error!" }
+    let(:backtrace) do
+      [
+        "/path/to/test1.rb:1 in `test1'",
+        "/path/to/test2.rb:2 in `test2'",
+        "/path/to/test3.rb:3 in `test3'",
+        "/path/to/test4.rb:4 in `test4'"
+      ]
+    end
+    let(:exception) do
+      error = RuntimeError.new(message)
+      error.set_backtrace(backtrace)
+      error
+    end
+
+    subject { command_class.new(stderr: StringIO.new) }
+
+    context "when stderr is a TTY" do
+      before { expect(subject.stderr).to receive(:tty?).and_return(true) }
+
+      it "must print a highlighted exception" do
+        subject.print_exception(exception)
+
+        expect(subject.stderr.string).to eq(
+          exception.full_message(highlight: true)
+        )
+      end
+    end
+
+    context "when stderr is not a TTY" do
+      it "must not highlight the exception" do
+        subject.print_exception(exception)
+
+        expect(subject.stderr.string).to eq(
+          exception.full_message(highlight: false)
+        )
+      end
+    end
+  end
+end

data/spec/program_name_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'command_kit/program_name'
+
+describe ProgramName do
+  module TestProgramName
+    class TestCmd
+      include CommandKit::ProgramName
+    end
+  end
+
+  let(:command_class) { TestProgramName::TestCmd }
+  let(:program_name) { 'foo' }
+
+  before do
+    @original_program_name = $PROGRAM_NAME
+    $PROGRAM_NAME = program_name
+  end
+
+  describe ".program_name" do
+    subject { command_class }
+
+    it "must return $PROGRAM_NAME" do
+      expect(subject.program_name).to eq(program_name)
+    end
+
+    context "when $PROGRAM_NAME is '-e'" do
+      let(:program_name) { '-e' }
+
+      it "must return nil" do
+        expect(subject.program_name).to be(nil)
+      end
+    end
+
+    context "when $PROGRAM_NAME is 'irb'" do
+      let(:program_name) { 'irb' }
+
+      it "must return nil" do
+        expect(subject.program_name).to be(nil)
+      end
+    end
+
+    context "when $PROGRAM_NAME is 'rspec'" do
+      let(:program_name) { 'rspec' }
+
+      it "must return nil" do
+        expect(subject.program_name).to be(nil)
+      end
+    end
+  end
+
+  describe "#program_name" do
+    subject { command_class.new }
+
+    it "should be the same as .program_name" do
+      expect(subject.program_name).to eq(command_class.program_name)
+    end
+  end
+
+  after do
+    $PROGRAM_NAME = @original_program_name
+  end
+end