command_kit 0.4.1 → 0.5.1

data/spec/main_spec.rb

@@ -1,179 +0,0 @@
-require 'spec_helper'
-require 'command_kit/main'
-
-describe CommandKit::Main do
-  module TestMain
-    class TestCommand
-      include CommandKit::Main
-    end
-
-    class TestCommandWithInitialize
-      include CommandKit::Main
-
-      attr_reader :foo
-
-      attr_reader :bar
-
-      def initialize(foo: 'foo', bar: 'bar', **kwargs)
-        super(**kwargs)
-
-        @foo = foo
-        @bar = bar
-      end
-    end
-  end
-
-  let(:command_class) { TestMain::TestCommand }
-
-  describe ".start" do
-    subject { command_class }
-
-    it "must exit with 0 by default" do
-      expect(subject).to receive(:exit).with(0)
-
-      subject.start
-    end
-
-    context "when given an argv argument" do
-      let(:argv) { %w[one two three] }
-
-      it "must pass argv to .main" do
-        expect(subject).to receive(:main).with(argv)
-        allow(subject).to receive(:exit)
-
-        subject.start(argv)
-      end
-    end
-
-    context "when given keyword arguments" do
-      let(:command_class) { TestMain::TestCommandWithInitialize }
-
-      let(:kwargs) { {foo: 'custom foo', bar: 'custom bar'} }
-
-      it "must pass the keyword arguments down to .main" do
-        expect(subject).to receive(:main).with(ARGV, **kwargs)
-        allow(subject).to receive(:exit)
-
-        subject.start(**kwargs)
-      end
-    end
-
-    context "when Interrupt is raised" do
-      module TestMain
-        class TestCommandWithInterrupt
-          include CommandKit::Main
-
-          def main(*argv)
-            raise(Interrupt)
-          end
-        end
-      end
-
-      let(:command_class) { TestMain::TestCommandWithInterrupt }
-
-      it "must exit with 130" do
-        expect(command_class).to receive(:exit).with(130)
-
-        command_class.start
-      end
-    end
-
-    context "when Errno::EPIPE is raised" do
-      module TestMain
-        class TestCommandWithBrokenPipe
-          include CommandKit::Main
-
-          def main(*argv)
-            raise(Errno::EPIPE)
-          end
-        end
-      end
-
-      let(:command_class) { TestMain::TestCommandWithBrokenPipe }
-
-      it "must exit with 0" do
-        expect(command_class).to receive(:exit).with(0)
-
-        command_class.start
-      end
-    end
-  end
-
-  module TestMain
-    class TestCommandWithSystemExit
-
-      include CommandKit::Main
-
-      def run(*argv)
-        raise(SystemExit.new(-1))
-      end
-
-    end
-  end
-
-  describe ".main" do
-    subject { command_class }
-
-    it "must return 0 by default" do
-      expect(subject.main).to eq(0)
-    end
-
-    let(:command_class) { TestMain::TestCommandWithInitialize }
-
-    context "when given a custom argv" do
-      let(:instance) { command_class.new }
-      let(:argv)     { %w[one two three] }
-
-      it "must call #main with the custom argv" do
-        expect(subject).to receive(:new).with(no_args).and_return(instance)
-        expect(instance).to receive(:main).with(argv)
-
-        subject.main(argv)
-      end
-    end
-
-    context "when given keyword arguments" do
-      let(:kwargs)   { {foo: 'custom foo', bar: 'custom bar'} }
-      let(:instance) { command_class.new(**kwargs) }
-
-      it "must pass the keyword arguments .new then call #main" do
-        expect(subject).to receive(:new).with(**kwargs).and_return(instance)
-        expect(instance).to receive(:main).with([])
-
-        subject.main(**kwargs)
-      end
-    end
-
-    context "when #main raises SystemExit" do
-      let(:command_class) { TestMain::TestCommandWithSystemExit }
-
-      it "must rescue SystemExit and return the exit status code" do
-        expect(subject.main()).to eq(-1)
-      end
-    end
-  end
-
-  describe "#main" do
-    subject { command_class.new }
-
-    it "must return 0 by default" do
-      expect(subject.main).to eq(0)
-    end
-
-    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
-      let(:command_class) { TestMain::TestCommandWithSystemExit }
-
-      it "must rescue SystemExit and return the exit status code" do
-        expect(subject.main()).to eq(-1)
-      end
-    end
-  end
-end

data/spec/man_spec.rb

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

@@ -1,85 +0,0 @@
-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,343 +0,0 @@
-require 'spec_helper'
-require 'command_kit/options/option'
-
-describe CommandKit::Options::Option do
-  let(:name)   { :foo    }
-  let(:short)  { nil     }
-  let(:long)   { '--foo' }
-  let(:equals) { false   }
-  let(:value_usage)    { 'FOO' }
-  let(:value_required) { true  }
-  let(:value) do
-    {
-      usage:    value_usage,
-      required: value_required
-    }
-  end
-  let(:desc)  { 'Foo option' }
-  let(:block) do
-    ->(arg) { @foo = arg }
-  end
-
-  subject do
-    described_class.new(name, short:  short,
-                              long:   long,
-                              equals: equals,
-                              desc:   desc,
-                              value:  value,
-                              &block)
-  end
-
-  describe "#initialize" do
-    context "when the short: keyword is given" do
-      subject { described_class.new(name, short: short, desc: desc) }
-
-      it "must set #short" do
-        expect(subject.short).to eq(short)
-      end
-    end
-
-    context "when the short: keyword is not given" do
-      subject { described_class.new(name, desc: desc) }
-
-      it { expect(subject.short).to be(nil) }
-    end
-
-    context "when the long: keyword is given" do
-      let(:long) { '--opt' }
-
-      subject { described_class.new(name, long: long, desc: desc) }
-
-      it "must set #long" do
-        expect(subject.long).to eq(long)
-      end
-    end
-
-    context "when the long: keyword is not given" do
-      subject { described_class.new(name, desc: desc) }
-
-      it "default #long to a '--option' flag based on #name" do
-        expect(subject.long).to eq("--#{name}")
-      end
-    end
-
-    context "when the equals: keyword is given" do
-      let(:equals) { true }
-
-      subject { described_class.new(name, equals: equals, desc: desc) }
-
-      it "must set #equals" do
-        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) }
-    end
-
-    context "when the values: keyword is given" do
-      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
-
-      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
-
-    context "when the values: keyword is not given" do
-      subject { described_class.new(name, desc: desc) }
-
-      it { expect(subject.value).to be(nil) }
-    end
-
-    context "when the desc: keyword is given" do
-      subject { described_class.new(name, desc: desc) }
-
-      it "must set #desc" do
-        expect(subject.desc).to eq(desc)
-      end
-    end
-
-    context "when the desc: keyword is not given" do
-      it do
-        expect {
-          described_class.new(name)
-        }.to raise_error(ArgumentError)
-      end
-    end
-
-    it "must default #category to nil" do
-      expect(subject.category).to be(nil)
-    end
-
-    context "when the category: keyword is given" do
-      let(:category) { 'Other Options' }
-
-      subject { described_class.new(name, desc: desc, category: category) }
-
-      it "must set #category" do
-        expect(subject.category).to eq(category)
-      end
-    end
-
-    context "when a block is given" do
-      subject { described_class.new(name, desc: desc, &block) }
-
-      it "must set #block" do
-        expect(subject.block).to eq(block)
-      end
-    end
-
-    context "when no block is given" do
-      subject { described_class.new(name, desc: desc) }
-
-      it { expect(subject.block).to be(nil) }
-    end
-  end
-
-  describe "#equals?" do
-    context "when initialized with equals: true" do
-      let(:equals) { true }
-
-      it { expect(subject.equals?).to be(true) }
-    end
-
-    context "when initialized with equals: false" do
-      let(:equals) { false }
-
-      it { expect(subject.equals?).to be(false) }
-    end
-  end
-
-  describe "#separator" do
-    context "when #value is initialized" do
-      context "and #equals? is true" do
-        let(:equals) { true }
-
-        it { expect(subject.separator).to eq('=') }
-      end
-
-      context "and #equals? is false" do
-        let(:equals) { false }
-
-        it { expect(subject.separator).to eq(' ') }
-      end
-    end
-
-    context "when #value is not initialized" do
-      let(:value) { nil }
-
-      it { expect(subject.separator).to be(nil) }
-    end
-  end
-
-  describe "#usage" do
-    let(:long) { '--foo' }
-
-    it "must start with the long '--option'" do
-      expect(subject.usage.last).to start_with(long)
-    end
-
-    context "when #value is initialized" do
-      it "must return '--option USAGE'" do
-        expect(subject.usage.last).to eq("#{long} #{subject.value.usage}")
-      end
-
-      context "and #equals? is true" do
-        let(:equals) { true }
-
-        it "must return '--option=USAGE'" do
-          expect(subject.usage.last).to eq("#{long}=#{subject.value.usage}")
-        end
-
-        context "but the #value is also optional?" do
-          let(:value_required) { false }
-
-          it "must return '--option[=USAGE]'" do
-            expect(subject.usage.last).to eq("#{long}[=#{subject.value.usage}]")
-          end
-        end
-      end
-    end
-
-    context "when #short is not nil" do
-      let(:short) { '-f' }
-
-      it "to have two elements" do
-        expect(subject.usage.length).to eq(2)
-      end
-
-      it "the first element should be the short option" do
-        expect(subject.usage[0]).to eq(short)
-      end
-    end
-  end
-
-  describe "#value?" do
-    context "when #value has been initialized" do
-      let(:value) { {} }
-
-      it { expect(subject.value?).to be(true) }
-    end
-
-    context "when #value has not been initialized" do
-      let(:value) { nil }
-
-      it { expect(subject.value?).to be(false) }
-    end
-  end
-
-  describe "#type" do
-    context "when #value has been initialized and has a #type" do
-      let(:type)  { String }
-      let(:value) { {type: type} }
-
-      it "must return the #value.type" do
-        expect(subject.type).to eq(type)
-      end
-    end
-
-    context "when #value has not been initialized" do
-      let(:value) { nil }
-
-      it { expect(subject.type).to be(nil) }
-    end
-  end
-
-  describe "#default_value" do
-    context "when #value has been initialized and has a #default" do
-      let(:default)  { "" }
-      let(:value) { {default: default} }
-
-      it "must return the #value.default_value" do
-        expect(subject.default_value).to eq(default)
-      end
-    end
-
-    context "when #value has not been initialized" do
-      let(:value) { nil }
-
-      it { expect(subject.default_value).to be(nil) }
-    end
-  end
-
-  describe "#desc" do
-    let(:desc) { 'Foo option' }
-
-    it "must return the desc: value" do
-      expect(subject.desc).to eq(desc)
-    end
-
-    context "when #value has been initialized with a default value" do
-      let(:default)  { "foo" }
-      let(:value) { {default: default} }
-
-      it "should reutrn the desc value and '(Default: ...)'" do
-        expect(subject.desc).to eq("#{desc} (Default: #{default})")
-      end
-    end
-
-    context "when #desc was initialized with an Array" do
-      let(:desc) do
-        [
-          'Line 1',
-          'Line 2'
-        ]
-      end
-
-      it "must return the desc: value" do
-        expect(subject.desc).to eq(desc)
-      end
-
-      context "when #value has been initialized with a default value" do
-        let(:default)  { "foo" }
-        let(:value) { {default: default} }
-
-        it "should append '(Default: ...)' to the desc Array" do
-          expect(subject.desc).to eq([*desc, "(Default: #{default})"])
-        end
-      end
-    end
-  end
-end