command_kit 0.4.1 → 0.5.1

data/spec/printing_spec.rb

@@ -1,106 +0,0 @@
-require 'spec_helper'
-require 'command_kit/printing'
-require 'command_kit/command_name'
-
-require 'stringio'
-
-describe CommandKit::Printing do
-  module TestPrinting
-    class TestCmd
-
-      include CommandKit::Printing
-
-    end
-  end
-
-  let(:command_class) { TestPrinting::TestCmd }
-  subject { command_class.new }
-  
-  describe "EOL" do
-    subject { described_class::EOL }
-
-    it "must equal $/" do
-      expect(subject).to eq($/)
-    end
-  end
-
-  describe ".included" do
-    subject { command_class }
-
-    it { expect(command_class).to include(CommandKit::Stdio) }
-  end
-
-  let(:nl) { $/ }
-
-  describe "#print_error" do
-    let(:message) { "oh no!" }
-
-    it "must print the error message to stderr" do
-      expect {
-        subject.print_error(message)
-      }.to output("#{message}#{nl}").to_stderr
-    end
-
-    context "and when CommandKit::CommandName is included" do
-      module TestPrinting
-        class TestCmdWithCommandName
-
-          include CommandKit::CommandName
-          include CommandKit::Printing
-
-          command_name 'foo'
-
-        end
-      end
-
-      let(:command_class) { TestPrinting::TestCmdWithCommandName }
-
-      it "must print the command_name and the error message" do
-        expect {
-          subject.print_error(message)
-        }.to output("#{subject.command_name}: #{message}#{nl}").to_stderr
-      end
-    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

@@ -1,70 +0,0 @@
-require 'spec_helper'
-require 'command_kit/program_name'
-
-describe CommandKit::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
-
-  describe "#command_name" do
-    subject { command_class.new }
-
-    it "should be the same as #program_name" do
-      expect(subject.command_name).to eq(subject.program_name)
-    end
-  end
-
-  after do
-    $PROGRAM_NAME = @original_program_name
-  end
-end

data/spec/spec_helper.rb

@@ -1,3 +0,0 @@
-require 'rspec'
-require 'simplecov'
-SimpleCov.start

data/spec/stdio_spec.rb

@@ -1,264 +0,0 @@
-require 'spec_helper'
-require 'command_kit/stdio'
-
-describe CommandKit::Stdio do
-  module TestStdio
-    class TestCommand
-      include CommandKit::Stdio
-    end
-  end
-
-  let(:command_class) { TestStdio::TestCommand }
-
-  describe "#initialize" do
-    module TestStdio
-      class TestCommandWithInitialize
-        include CommandKit::Stdio
-
-        attr_reader :var
-
-        def initialize(**kwargs)
-          super(**kwargs)
-
-          @var = 'foo'
-        end
-      end
-
-      class TestCommandWithInitializeAndKeywordArgs
-        include CommandKit::Stdio
-
-        attr_reader :var
-
-        def initialize(var: "foo", **kwargs)
-          super(**kwargs)
-
-          @var = var
-        end
-      end
-    end
-
-    context "when given no arguments" do
-      subject { command_class.new() }
-
-      it "must initialize #stdin to $stdin" do
-        expect(subject.stdin).to be($stdin)
-      end
-
-      it "must initialize #stdout to $stdout" do
-        expect(subject.stdout).to be($stdout)
-      end
-
-      it "must initialize #stderr to $stderr" do
-        expect(subject.stderr).to be($stderr)
-      end
-
-      context "and the including class defines it's own #initialize method" do
-        let(:command_class) { TestStdio::TestCommandWithInitialize }
-
-        it "must initialize #stdin to $stdin" do
-          expect(subject.stdin).to be($stdin)
-        end
-
-        it "must initialize #stdout to $stdout" do
-          expect(subject.stdout).to be($stdout)
-        end
-
-        it "must initialize #stderr to $stderr" do
-          expect(subject.stderr).to be($stderr)
-        end
-
-        it "must also call the class'es #initialize method" do
-          expect(subject.var).to eq('foo')
-        end
-
-        context "and it accepts keyword arguments" do
-          let(:command_class) { TestStdio::TestCommandWithInitializeAndKeywordArgs }
-          let(:var) { 'custom value' }
-
-          subject { command_class.new(var: var) }
-
-          it "must initialize #stdin to $stdin" do
-            expect(subject.stdin).to be($stdin)
-          end
-
-          it "must initialize #stdout to $stdout" do
-            expect(subject.stdout).to be($stdout)
-          end
-
-          it "must initialize #stderr to $stderr" do
-            expect(subject.stderr).to be($stderr)
-          end
-
-          it "must also call the class'es #initialize method with any additional keyword arguments" do
-            expect(subject.var).to eq(var)
-          end
-        end
-      end
-    end
-
-    context "when given a custom env: value" do
-      let(:custom_stdin)  { StringIO.new }
-      let(:custom_stdout) { StringIO.new }
-      let(:custom_stderr) { StringIO.new }
-
-      subject do
-        command_class.new(
-          stdin: custom_stdin,
-          stdout: custom_stdout,
-          stderr: custom_stderr
-        )
-      end
-
-      it "must initialize #stdin to the stdin: value" do
-        expect(subject.stdin).to eq(custom_stdin)
-      end
-
-      it "must initialize #stdout to the stdout: value" do
-        expect(subject.stdout).to eq(custom_stdout)
-      end
-
-      it "must initialize #stderr to the stderr: value" do
-        expect(subject.stderr).to eq(custom_stderr)
-      end
-
-      context "and the including class defines it's own #initialize method" do
-        let(:command_class) { TestStdio::TestCommandWithInitialize }
-
-        it "must initialize #stdin to the stdin: value" do
-          expect(subject.stdin).to eq(custom_stdin)
-        end
-
-        it "must initialize #stdout to the stdout: value" do
-          expect(subject.stdout).to eq(custom_stdout)
-        end
-
-        it "must initialize #stderr to the stderr: value" do
-          expect(subject.stderr).to eq(custom_stderr)
-        end
-
-        it "must also call the class'es #initialize method" do
-          expect(subject.var).to eq('foo')
-        end
-
-        context "and it accepts keyword arguments" do
-          let(:command_class) { TestStdio::TestCommandWithInitializeAndKeywordArgs }
-          let(:var) { 'custom value' }
-
-          subject do
-            command_class.new(
-              stdin:  custom_stdin,
-              stdout: custom_stdout,
-              stderr: custom_stderr,
-              var: var
-            )
-          end
-
-          it "must initialize #stdin to the stdin: value" do
-            expect(subject.stdin).to eq(custom_stdin)
-          end
-
-          it "must initialize #stdout to the stdout: value" do
-            expect(subject.stdout).to eq(custom_stdout)
-          end
-
-          it "must initialize #stderr to the stderr: value" do
-            expect(subject.stderr).to eq(custom_stderr)
-          end
-
-          it "must also call the class'es #initialize method with any additional keyword arguments" do
-            expect(subject.var).to eq(var)
-          end
-        end
-      end
-    end
-  end
-
-  describe "#stdin" do
-    let(:command_class) { TestStdio::TestCommand }
-    let(:stdin) { StringIO.new }
-
-    subject { command_class.new(stdin: stdin) }
-
-    it "must return the initialized stdin: value" do
-      expect(subject.stdin).to eq(stdin)
-    end
-  end
-
-  describe "#stdout" do
-    let(:command_class) { TestStdio::TestCommand }
-    let(:stdout) { StringIO.new }
-
-    subject { command_class.new(stdout: stdout) }
-
-    it "must return the initialized stdout: value" do
-      expect(subject.stdout).to eq(stdout)
-    end
-  end
-
-  describe "#stderr" do
-    let(:command_class) { TestStdio::TestCommand }
-    let(:stderr) { StringIO.new }
-
-    subject { command_class.new(stderr: stderr) }
-
-    it "must return the initialized stderr: value" do
-      expect(subject.stderr).to eq(stderr)
-    end
-  end
-
-  [:gets, :readline, :readlines].each do |method|
-    describe "##{method}" do
-      let(:stdin) { StringIO.new }
-      let(:args) { [double(:arg1), double(:arg2)] }
-      let(:ret)  { double(:return_value) }
-
-      subject { command_class.new(stdin: stdin) }
-
-      it "must pass all arguments ot stdin.#{method}" do
-        expect(stdin).to receive(method).with(*args).and_return(ret)
-
-        expect(subject.send(method,*args)).to be(ret)
-      end
-    end
-  end
-
-  [:putc, :puts, :print, :printf].each do |method|
-    describe "##{method}" do
-      let(:stdout) { StringIO.new }
-      let(:args) { [double(:arg1), double(:arg2)] }
-      let(:ret)  { double(:return_value) }
-
-      subject { command_class.new(stdout: stdout) }
-
-      it "must pass all arguments ot stdout.#{method}" do
-        expect(stdout).to receive(method).with(*args).and_return(ret)
-
-        expect(subject.send(method,*args)).to be(ret)
-      end
-    end
-  end
-
-  describe "#abort" do
-    let(:stderr) { StringIO.new }
-    subject { command_class.new(stderr: stderr) }
-
-    context "when given an abort message" do
-      let(:message) { 'fail' }
-
-      it "must print the message to stderr and exit with 1" do
-        expect(subject.stderr).to receive(:puts).with(message)
-        expect(subject).to receive(:exit).with(1)
-
-        subject.abort(message)
-      end
-    end
-
-    context "when called without any arguments" do
-      it "must exit with 1" do
-        expect(subject).to receive(:exit).with(1)
-
-        subject.abort
-      end
-    end
-  end
-end

data/spec/sudo_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-require 'command_kit/sudo'
-
-describe CommandKit::Sudo do
-  module TestSudo
-    class TestCommand
-      include CommandKit::Sudo
-    end
-  end
-
-  let(:command_class) { TestSudo::TestCommand }
-  subject { command_class.new }
-
-  describe "#sudo" do
-    let(:command) { "ls" }
-    let(:arguments) { ["-la", "~root"] }
-    let(:status) { double(:status) }
-
-    context "on UNIX" do
-      context "when the UID is 0" do
-        before { allow(Process).to receive(:uid).and_return(0) }
-
-        it "must execute the command without sudo" do
-          expect(subject).to receive(:system).with(command,*arguments).and_return(status)
-
-          expect(subject.sudo(command,*arguments)).to be(status)
-        end
-      end
-
-      context "when the UID is not 0" do
-        before { allow(Process).to receive(:uid).and_return(1000) }
-
-        it "must execute the command with 'sudo ...'" do
-          expect(subject).to receive(:system).with('sudo',command,*arguments).and_return(status)
-
-          expect(subject.sudo(command,*arguments)).to be(status)
-        end
-      end
-    end
-
-    context "on Windows" do
-      subject { command_class.new(os: :windows) }
-
-      it "must execute the command with 'runas /user:administrator ...'" do
-        expect(subject).to receive(:system).with('runas','/user:administrator',command,*arguments).and_return(status)
-
-        expect(subject.sudo(command,*arguments)).to be(status)
-      end
-    end
-  end
-end