command_kit 0.1.0.pre1

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rspec'
+require 'simplecov'
+SimpleCov.start
+
+require 'command_kit/version'
+include CommandKit

data/spec/stdio_spec.rb

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

@@ -0,0 +1,237 @@
+require 'spec_helper'
+require 'command_kit/usage'
+
+describe Usage do
+  module TestUsage
+    class ImplicitCmd
+      include CommandKit::Usage
+    end
+  end
+
+  let(:command_class) { TestUsage::ImplicitCmd }
+
+  describe ".included" do
+    it { expect(command_class).to include(CommandKit::CommandName) }
+    it { expect(command_class).to include(CommandKit::Help) }
+  end
+
+  describe ".usage" do
+    subject { TestUsage::ImplicitCmd }
+
+    context "when no usage has been set" do
+      it "should default to nil" do
+        expect(subject.usage).to be_nil
+      end
+    end
+
+    context "when a usage is explicitly set" do
+      module TestUsage
+        class ExplicitCmd
+          include CommandKit::Usage
+          usage 'EXPLICIT'
+        end
+      end
+
+      subject { TestUsage::ExplicitCmd }
+
+      it "must return the explicitly set usage" do
+        expect(subject.usage).to eq("EXPLICIT")
+      end
+    end
+
+    context "when the command class inherites from another class" do
+      context "but no usage is set" do
+        module TestUsage
+          class BaseCmd
+            include CommandKit::Usage
+          end
+
+          class InheritedCmd < BaseCmd
+          end
+        end
+
+        subject { TestUsage::InheritedCmd }
+
+        it "must search each class then return nil "do
+          expect(subject.usage).to be_nil
+        end
+      end
+
+      module TestUsage
+        class ExplicitBaseCmd
+          include CommandKit::Usage
+          usage 'EXPLICIT'
+        end
+      end
+
+      context "when the superclass defines an explicit usage" do
+        module TestUsage
+          class ImplicitInheritedCmd < ExplicitBaseCmd
+          end
+        end
+
+        let(:super_subject) { TestUsage::ExplicitBaseCmd }
+        subject { TestUsage::ImplicitInheritedCmd }
+
+        it "must inherit the superclass'es usage" do
+          expect(subject.usage).to eq(super_subject.usage)
+        end
+
+        it "must not change the superclass'es usage" do
+          expect(super_subject.usage).to eq("EXPLICIT")
+        end
+      end
+
+      context "when the subclass defines an explicit usage" do
+        module TestUsage
+          class ImplicitBaseCmd
+            include CommandKit::Usage
+          end
+
+          class ExplicitInheritedCmd < ImplicitBaseCmd
+            usage 'EXPLICIT'
+          end
+        end
+
+        let(:super_subject) { TestUsage::ImplicitBaseCmd }
+        subject { TestUsage::ExplicitInheritedCmd }
+
+        it "must return the subclass'es usage" do
+          expect(subject.usage).to eq("EXPLICIT")
+        end
+
+        it "must not change the superclass'es usage" do
+          expect(super_subject.usage).to be_nil
+        end
+      end
+
+      context "when both the subclass overrides the superclass's usages" do
+        module TestUsage
+          class ExplicitOverridingInheritedCmd < ExplicitBaseCmd
+            usage 'EXPLICIT_OVERRIDE'
+          end
+        end
+
+        let(:super_subject) { TestUsage::ExplicitBaseCmd }
+        subject { TestUsage::ExplicitOverridingInheritedCmd }
+
+        it "must return the subclass'es usage" do
+          expect(subject.usage).to eq("EXPLICIT_OVERRIDE")
+        end
+
+        it "must not change the superclass'es usage" do
+          expect(super_subject.usage).to eq("EXPLICIT")
+        end
+      end
+    end
+  end
+
+  module TestUsage
+    class NoUsage
+      include CommandKit::Usage
+    end
+  end
+
+  module TestUsage
+    class SingleUsage
+      include CommandKit::Usage
+
+      usage 'ONE USAGE'
+    end
+  end
+
+  module TestUsage
+    class MultipleUsage
+      include CommandKit::Usage
+
+      usage [
+        'ONE USAGE',
+        'TWO USAGE',
+        'THREE USAGE'
+      ]
+    end
+  end
+
+  subject { command_class.new }
+
+  describe "#usage" do
+    context "when .usage is nil" do
+      let(:command_class) { TestUsage::NoUsage }
+      subject { command_class.new }
+
+      it "must not print anything" do
+        expect(subject.usage).to be(nil)
+      end
+    end
+
+    context "when .usage is a String" do
+      let(:command_class) { TestUsage::SingleUsage }
+      subject { command_class.new }
+
+      it "must return .usage, but with #command_name prepended" do
+        expect(subject.usage).to eq("#{subject.command_name} #{command_class.usage}")
+      end
+    end
+
+    context "when #usage is an Array of Strings" do
+      let(:command_class) { TestUsage::MultipleUsage }
+      subject { command_class.new }
+
+      it "must return .usage, but with #command_name prepended to each element" do
+        expect(subject.usage).to eq(
+          [
+            "#{subject.command_name} #{command_class.usage[0]}",
+            "#{subject.command_name} #{command_class.usage[1]}",
+            "#{subject.command_name} #{command_class.usage[2]}",
+          ]
+        )
+      end
+    end
+  end
+
+  describe "#help_usage" do
+    context "when #usage is nil" do
+      let(:command_class) { TestUsage::NoUsage }
+      subject { command_class.new }
+
+      it "must not print anything" do
+        expect { subject.help_usage }.to_not output.to_stdout
+      end
+    end
+
+    context "when #usage is a String" do
+      let(:command_class) { TestUsage::SingleUsage }
+      subject { command_class.new }
+
+      it "must print out 'usage:' and only one usage" do
+        expect { subject.help_usage }.to output(
+          "usage: #{subject.usage}#{$/}"
+        ).to_stdout
+      end
+    end
+
+    context "when #usage is an Array of Strings" do
+      let(:command_class) { TestUsage::MultipleUsage }
+      subject { command_class.new }
+
+      it "must print out the 'usage:' and all usage Strings" do
+        expect { subject.help_usage }.to output(
+          [
+            "usage: #{subject.usage[0]}",
+            "       #{subject.usage[1]}",
+            "       #{subject.usage[2]}",
+            ''
+          ].join($/)
+        ).to_stdout
+      end
+    end
+  end
+
+  describe "#help" do
+    it "must call #help_usage" do
+      expect(subject).to receive(:help_usage)
+
+      subject.help
+    end
+  end
+end