command_kit 0.1.0.pre1 → 0.2.0

data/spec/main_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'command_kit/main'
 
-describe Main do
+describe CommandKit::Main do
   module TestMain
     class TestCommand
       include CommandKit::Main
@@ -156,16 +156,16 @@ describe Main do
   describe "#main" do
     subject { command_class.new }
 
-    it "must provide a default #main" do
-      expect(subject).to respond_to(:main)
-    end
-
     it "must return 0 by default" do
       expect(subject.main).to eq(0)
     end
 
-    it "must accept arbitrary argv" do
-      expect { subject.main([1,2,3]) }.to_not raise_error
+    it "must call #run with the given argv" do
+      argv = ["foo", "bar", "baz"]
+
+      expect(subject).to receive(:run).with(*argv)
+      
+      subject.main(argv)
     end
 
     context "when #run raises SystemExit" do

data/spec/man_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'command_kit/man'
+
+describe CommandKit::Man do
+  module TestMan
+    class TestCommand
+      include CommandKit::Man
+    end
+  end
+
+  let(:command_class) { TestMan::TestCommand }
+
+  subject { command_class.new }
+
+  describe "#man" do
+    let(:man_page) { 'foo' }
+
+    it "must call system() with the given man page" do
+      expect(subject).to receive(:system).with('man',man_page)
+
+      subject.man(man_page)
+    end
+
+    context "when given a non-String man-page argument" do
+      let(:man_page_arg) { double(:non_string_arg) }
+
+      it "must call #to_s on the man-page argument" do
+        expect(man_page_arg).to receive(:to_s).and_return(man_page)
+
+        expect(subject).to receive(:system).with('man',man_page)
+
+        subject.man(man_page_arg)
+      end
+    end
+
+    context "when given the section: keyword argument" do
+      let(:section) { 7 }
+
+      it "must call system() with the given section number and man page" do
+        expect(subject).to receive(:system).with('man',section.to_s,man_page)
+
+        subject.man(man_page, section: section)
+      end
+    end
+  end
+end

data/spec/open_app_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+require 'command_kit/open_app'
+
+describe CommandKit::OpenApp do
+  module TestOpenApp
+    class TestCommand
+      include CommandKit::OpenApp
+    end
+  end
+
+  let(:command_class) { TestOpenApp::TestCommand }
+
+  subject { command_class.new }
+
+  describe "#initialize" do
+    context "when the OS is macOS" do
+      subject { command_class.new(os: :macos) }
+
+      it "must set @open_command to \"open\"" do
+        expect(subject.instance_variable_get("@open_command")).to eq("open")
+      end
+    end
+
+    context "when the OS is Linux" do
+      subject { command_class.new(os: :linux) }
+
+      it "must set @open_command to \"xdg-open\"" do
+        expect(subject.instance_variable_get("@open_command")).to eq("xdg-open")
+      end
+    end
+
+    context "when the OS is FreeBSD" do
+      subject { command_class.new(os: :freebsd) }
+
+      it "must set @open_command to \"xdg-open\"" do
+        expect(subject.instance_variable_get("@open_command")).to eq("xdg-open")
+      end
+    end
+
+    context "when the OS is OpenBSD" do
+      subject { command_class.new(os: :openbsd) }
+
+      it "must set @open_command to \"xdg-open\"" do
+        expect(subject.instance_variable_get("@open_command")).to eq("xdg-open")
+      end
+    end
+
+    context "when the OS is NetBSD" do
+      subject { command_class.new(os: :openbsd) }
+
+      it "must set @open_command to \"xdg-open\"" do
+        expect(subject.instance_variable_get("@open_command")).to eq("xdg-open")
+      end
+    end
+
+    context "when the OS is Windows" do
+      subject { command_class.new(os: :windows) }
+
+      it "must set @open_command to \"start\"" do
+        expect(subject.instance_variable_get("@open_command")).to eq("start")
+      end
+    end
+  end
+
+  describe "#open_app_for" do
+    context "when @open_command is set" do
+      let(:file_or_uri) { "foo" }
+      let(:status) { true }
+
+      it "must execute the @open_command with the given URI or file" do
+        expect(subject).to receive(:system).with(subject.instance_variable_get("@open_command"),file_or_uri).and_return(status)
+
+        expect(subject.open_app_for(file_or_uri)).to be(status)
+      end
+    end
+
+    context "when @open_command is not set" do
+      before do
+        subject.instance_variable_set("@open_command",nil)
+      end
+
+      it { expect(subject.open_app_for("foo")).to be(nil) }
+    end
+  end
+end

data/spec/options/option_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'command_kit/options/option'
 
-describe Options::Option do
+describe CommandKit::Options::Option do
   let(:name)   { :foo    }
   let(:short)  { nil     }
   let(:long)   { '--foo' }
@@ -18,12 +18,12 @@ describe Options::Option do
   end
 
   subject do
-    described_class.new name, short:  short,
+    described_class.new(name, short:  short,
                               long:   long,
                               equals: equals,
                               desc:   desc,
                               value:  value,
-                              &block
+                              &block)
   end
 
   describe "#initialize" do
@@ -65,22 +65,61 @@ describe Options::Option do
       subject { described_class.new(name, equals: equals, desc: desc) }
 
       it "must set #equals" do
-        expect(subject.equals).to eq(equals)
+        expect(subject.equals?).to eq(equals)
       end
     end
 
     context "when the equals: keyword is not given" do
       subject { described_class.new(name, desc: desc) }
 
-      it { expect(subject.equals).to be(false) }
+      it { expect(subject.equals?).to be(false) }
     end
 
     context "when the values: keyword is given" do
-      let(:value) { {} }
-      subject { described_class.new(name, value: {}, desc: desc) }
+      context "and it is a Hash" do
+        let(:type) { Integer }
+
+        subject { described_class.new(name, value: {type: type}, desc: desc) }
+
+        it "must initialize #value" do
+          expect(subject.value).to      be_kind_of(CommandKit::Options::OptionValue)
+          expect(subject.value.type).to eq(type)
+        end
+      end
+
+      context "and it is true" do
+        subject { described_class.new(name, value: true, desc: desc) }
+
+        it "must initialize #value with defaults" do
+          expect(subject.value).to           be_kind_of(CommandKit::Options::OptionValue)
+          expect(subject.value.type).to      eq(String)
+          expect(subject.value.required?).to be(true)
+          expect(subject.value.usage).to     eq('STR')
+        end
+      end
 
-      it "must initialize #value" do
-        expect(subject.value).to be_kind_of(Options::OptionValue)
+      context "and it is false" do
+        subject { described_class.new(name, value: false, desc: desc) }
+
+        it "must not initialize #value" do
+          expect(subject.value).to be(nil)
+        end
+      end
+
+      context "and it is nil" do
+        subject { described_class.new(name, value: nil, desc: desc) }
+
+        it "must not initialize #value" do
+          expect(subject.value).to be(nil)
+        end
+      end
+
+      context "when it is another type" do
+        it do
+          expect {
+            described_class.new(name, value: 'foo', desc: desc)
+          }.to raise_error(TypeError)
+        end
       end
     end
 

data/spec/options/option_value_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 require 'command_kit/options/option_value'
 
-describe Options::OptionValue do
-  let(:type) { Integer }
+describe CommandKit::Options::OptionValue do
+  let(:type)     { Integer }
   let(:usage)    { 'COUNT' }
   let(:required) { true }
   let(:default)  { 1 }
@@ -26,6 +26,22 @@ describe Options::OptionValue do
       end
     end
 
+    context "when the default: keyword is given" do
+      subject { described_class.new(default: default) }
+
+      it "must set #default" do
+        expect(subject.default).to eq(default)
+      end
+    end
+
+    context "when the default: keyword is not given" do
+      subject { described_class.new() }
+
+      it "default #default to String" do
+        expect(subject.default).to eq(nil)
+      end
+    end
+
     context "when the usage: keyword is given" do
       let(:usage) { 'FOO' }
 
@@ -45,11 +61,20 @@ describe Options::OptionValue do
     end
   end
 
+  subject do
+    described_class.new(
+      type:     type,
+      usage:    usage,
+      required: required,
+      default:  default
+    )
+  end
+
   describe "#usage" do
     let(:usage) { 'FOO' }
 
     context "when #optional? is true" do
-      subject { described_class.new(usage: usage, required: false) }
+      let(:required) { false }
 
       it "must wrap the usage within [ ] brackets" do
         expect(subject.usage).to eq("[#{usage}]")
@@ -57,11 +82,35 @@ describe Options::OptionValue do
     end
 
     context "when #optional? is false" do
-      subject { described_class.new(usage: usage, required: true) }
+      let(:required) { true }
 
       it "should return the usage string unchanged" do
         expect(subject.usage).to eq(usage)
       end
     end
   end
+
+  describe "#default_value" do
+    context "when initialized with a default: that responded to #call" do
+      let(:default) do
+        ->{ [] }
+      end
+
+      it "must call the default #call method" do
+        expect(subject.default_value).to eq(default.call)
+      end
+    end
+
+    context "when initialized with a default: that it's an Object" do
+      let(:default) { "" }
+
+      it "must return the default: object" do
+        expect(subject.default_value).to eq(default)
+      end
+
+      it "must duplicate the default: object each time" do
+        expect(subject.default_value).to_not be(subject.default_value)
+      end
+    end
+  end
 end

data/spec/options_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'command_kit/options'
 
-describe Options do
+describe CommandKit::Options do
   module TestOptions
     class ImplicitCmd
       include CommandKit::Options

data/spec/os/linux_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+require 'command_kit/os/linux'
+
+describe CommandKit::OS::Linux do
+  module TestOSLinux
+    class TestCommand
+      include CommandKit::OS::Linux
+    end
+  end
+
+  let(:command_class) { TestOSLinux::TestCommand }
+
+  describe ".linux_distro" do
+    subject { command_class }
+
+    context "and the /etc/fedora-release file exists" do
+      before do
+        expect(File).to receive(:file?).with("/etc/fedora-release").and_return(true)
+      end
+
+      it { expect(subject.linux_distro).to be(:fedora) }
+    end
+
+    context "and the /etc/redhat-release file exists" do
+      before do
+        allow(File).to receive(:file?).with("/etc/fedora-release").and_return(false)
+        expect(File).to receive(:file?).with("/etc/redhat-release").and_return(true)
+      end
+
+      it { expect(subject.linux_distro).to be(:redhat) }
+    end
+
+    context "and the /etc/debian_version file exists" do
+      before do
+        allow(File).to receive(:file?).with("/etc/fedora-release").and_return(false)
+        allow(File).to receive(:file?).with("/etc/redhat-release").and_return(false)
+        expect(File).to receive(:file?).with("/etc/debian_version").and_return(true)
+      end
+
+      it { expect(subject.linux_distro).to be(:debian) }
+    end
+
+    context "and the /etc/SuSE-release file exists" do
+      before do
+        allow(File).to receive(:file?).with("/etc/fedora-release").and_return(false)
+        allow(File).to receive(:file?).with("/etc/redhat-release").and_return(false)
+        allow(File).to receive(:file?).with("/etc/debian_version").and_return(false)
+        expect(File).to receive(:file?).with("/etc/SuSE-release").and_return(true)
+      end
+
+      it { expect(subject.linux_distro).to be(:suse) }
+    end
+
+    context "and the /etc/arch-release file exists" do
+      before do
+        allow(File).to receive(:file?).with("/etc/fedora-release").and_return(false)
+        allow(File).to receive(:file?).with("/etc/redhat-release").and_return(false)
+        allow(File).to receive(:file?).with("/etc/debian_version").and_return(false)
+        allow(File).to receive(:file?).with("/etc/SuSE-release").and_return(false)
+        expect(File).to receive(:file?).with("/etc/arch-release").and_return(true)
+      end
+
+      it { expect(subject.linux_distro).to be(:arch) }
+    end
+  end
+
+  subject { command_class.new }
+
+  describe "#initialize" do
+    it "must default #linux_distro to self.class.linux_distro" do
+      expect(subject.linux_distro).to eq(command_class.linux_distro)
+    end
+
+    context "when the linux_distro: keyword is given" do
+      let(:linux_distro) { :suse }
+
+      subject { command_class.new(linux_distro: linux_distro) }
+
+      it "must set #linux_distro" do
+        expect(subject.linux_distro).to eq(linux_distro)
+      end
+    end
+  end
+
+  describe "#redhat_linux?" do
+    context "when #linux_distro is :redhat" do
+      subject { command_class.new(linux_distro: :redhat) }
+
+      it { expect(subject.redhat_linux?).to be(true) }
+    end
+
+    context "when #linux_distro is not :redhat" do
+      subject { command_class.new(linux_distro: :debian) }
+
+      it { expect(subject.redhat_linux?).to be(false) }
+    end
+  end
+
+  describe "#fedora_linux?" do
+    context "when #linux_distro is :fedora" do
+      subject { command_class.new(linux_distro: :fedora) }
+
+      it { expect(subject.fedora_linux?).to be(true) }
+    end
+
+    context "when #linux_distro is not :fedora" do
+      subject { command_class.new(linux_distro: :debian) }
+
+      it { expect(subject.fedora_linux?).to be(false) }
+    end
+  end
+
+  describe "#debian_linux?" do
+    context "when #linux_distro is :debian" do
+      subject { command_class.new(linux_distro: :debian) }
+
+      it { expect(subject.debian_linux?).to be(true) }
+    end
+
+    context "when #linux_distro is not :fedora" do
+      subject { command_class.new(linux_distro: :redhat) }
+
+      it { expect(subject.debian_linux?).to be(false) }
+    end
+  end
+
+  describe "#suse_linux?" do
+    context "when #linux_distro is :suse" do
+      subject { command_class.new(linux_distro: :suse) }
+
+      it { expect(subject.suse_linux?).to be(true) }
+    end
+
+    context "when #linux_distro is not :suse" do
+      subject { command_class.new(linux_distro: :debian) }
+
+      it { expect(subject.suse_linux?).to be(false) }
+    end
+  end
+
+  describe "#arch_linux?" do
+    context "when #linux_distro is :arch" do
+      subject { command_class.new(linux_distro: :arch) }
+
+      it { expect(subject.arch_linux?).to be(true) }
+    end
+
+    context "when #linux_distro is not :arch" do
+      subject { command_class.new(linux_distro: :debian) }
+
+      it { expect(subject.arch_linux?).to be(false) }
+    end
+  end
+end