command_kit 0.4.1 → 0.5.0

data/spec/description_spec.rb

@@ -1,179 +0,0 @@
-require 'spec_helper'
-require 'command_kit/description'
-
-describe CommandKit::Description do
-  module TestDescription
-    class ImplicitCmd
-      include CommandKit::Description
-    end
-  end
-
-  let(:command_class) { TestDescription::ImplicitCmd }
-
-  describe ".description" do
-    subject { TestDescription::ImplicitCmd }
-
-    context "when no description have been set" do
-      it "should default to nil" do
-        expect(subject.description).to be_nil
-      end
-    end
-
-    context "when a description is explicitly set" do
-      module TestDescription
-        class ExplicitCmd
-          include CommandKit::Description
-          description "Example command"
-        end
-      end
-
-      subject { TestDescription::ExplicitCmd }
-
-      it "must return the explicitly set description" do
-        expect(subject.description).to eq("Example command")
-      end
-    end
-
-    context "when the command class inherites from another class" do
-      context "but no description is set" do
-        module TestDescription
-          class BaseCmd
-            include CommandKit::Description
-          end
-
-          class InheritedCmd < BaseCmd
-          end
-        end
-
-        subject { TestDescription::InheritedCmd }
-
-        it "must search each class then return nil "do
-          expect(subject.description).to be_nil
-        end
-      end
-
-      module TestDescription
-        class ExplicitBaseCmd
-          include CommandKit::Description
-          description "Example base command"
-        end
-      end
-
-      context "when the superclass defines an explicit description" do
-        module TestDescription
-          class ImplicitInheritedCmd < ExplicitBaseCmd
-          end
-        end
-
-        let(:super_subject) { TestDescription::ExplicitBaseCmd }
-        subject { TestDescription::ImplicitInheritedCmd }
-
-        it "must inherit the superclass'es description" do
-          expect(subject.description).to eq(super_subject.description)
-        end
-
-        it "must not change the superclass'es description" do
-          expect(super_subject.description).to eq("Example base command")
-        end
-      end
-
-      context "when the subclass defines an explicit description" do
-        module TestDescription
-          class ImplicitBaseCmd
-            include CommandKit::Description
-          end
-
-          class ExplicitInheritedCmd < ImplicitBaseCmd
-            description "Example inherited command"
-          end
-        end
-
-        let(:super_subject) { TestDescription::ImplicitBaseCmd }
-        subject { TestDescription::ExplicitInheritedCmd }
-
-        it "must return the subclass'es description" do
-          expect(subject.description).to eq("Example inherited command")
-        end
-
-        it "must not change the superclass'es description" do
-          expect(super_subject.description).to be_nil
-        end
-      end
-
-      context "when both the subclass overrides the superclass's descriptions" do
-        module TestDescription
-          class ExplicitOverridingInheritedCmd < ExplicitBaseCmd
-            description "Example overrided description"
-          end
-        end
-
-        let(:super_subject) { TestDescription::ExplicitBaseCmd }
-        subject { TestDescription::ExplicitOverridingInheritedCmd }
-
-        it "must return the subclass'es description" do
-          expect(subject.description).to eq("Example overrided description")
-        end
-
-        it "must not change the superclass'es description" do
-          expect(super_subject.description).to eq("Example base command")
-        end
-      end
-    end
-  end
-
-  subject { command_class.new }
-
-  describe "#description" do
-    it "must be the same as .description" do
-      expect(subject.description).to eq(command_class.description)
-    end
-  end
-
-  describe "#help_description" do
-    context "when #description returns nil" do
-      module TestDescription
-        class NoDescription
-          include CommandKit::Description
-        end
-      end
-
-      let(:command_class) { TestDescription::NoDescription }
-      subject { command_class.new }
-
-      it "must print out the description" do
-        expect { subject.help_description }.to_not output.to_stdout
-      end
-    end
-
-    context "when #description returns a String" do
-      module TestDescription
-        class DefinesDescription
-          include CommandKit::Description
-
-          description "Example command"
-        end
-      end
-
-      let(:command_class) { TestDescription::DefinesDescription }
-      subject { command_class.new }
-
-      it "must print out the description" do
-        expect { subject.help_description }.to output(
-          [
-            '',
-            subject.description,
-            ''
-          ].join($/)
-        ).to_stdout
-      end
-    end
-  end
-
-  describe "#help" do
-    it "must call #help_description" do
-      expect(subject).to receive(:help_description)
-
-      subject.help
-    end
-  end
-end

data/spec/edit_spec.rb

@@ -1,72 +0,0 @@
-require 'spec_helper'
-require 'command_kit/edit'
-
-describe CommandKit::Edit do
-  module TestEdit
-    class TestCommand
-      include CommandKit::Edit
-    end
-  end
-
-  let(:command_class) { TestEdit::TestCommand }
-
-  it "must also include CommandKit::Env" do
-    expect(command_class).to include(CommandKit::Env)
-  end
-
-  describe "#editor" do
-    subject { command_class.new(env: env) }
-
-    context "when env['EDITOR'] is set" do
-      let(:editor) { 'vim' }
-      let(:env) do
-        {'EDITOR' => editor}
-      end
-
-      it "must return env['EDITOR']" do
-        expect(subject.editor).to eq(env['EDITOR'])
-      end
-    end
-
-    context "when env['EDITOR'] is not set" do
-      let(:env) do
-        {}
-      end
-
-      it "must return 'nano'" do
-        expect(subject.editor).to eq('nano')
-      end
-    end
-  end
-
-  describe "#edit" do
-    subject { command_class.new(env: env) }
-
-    let(:arguments) { ['file.txt'] }
-
-    context "when env['EDITOR'] is set" do
-      let(:editor) { 'vim' }
-      let(:env) do
-        {'EDITOR' => editor}
-      end
-
-      it "must invoke system with #editor and the additional arguments" do
-        expect(subject).to receive(:system).with(subject.editor,*arguments)
-
-        subject.edit(*arguments)
-      end
-    end
-
-    context "when env['EDITOR'] is not set" do
-      let(:env) do
-        {}
-      end
-
-      it "must invoke system with 'nano' and the additional arguments" do
-        expect(subject).to receive(:system).with('nano',*arguments)
-
-        subject.edit(*arguments)
-      end
-    end
-  end
-end

data/spec/env/home_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-require 'command_kit/env/home'
-
-describe CommandKit::Env::Home do
-  module TestEnvHome
-    class TestCommand
-      include CommandKit::Env::Home
-    end
-  end
-
-  let(:command_class) { TestEnvHome::TestCommand }
-
-  describe ".included" do
-    it "must include CommandKit::Env" do
-      expect(command_class).to be_include(CommandKit::Env)
-    end
-  end
-
-  describe ".home_dir" do
-    subject { command_class }
-
-    it "must return Gem.user_home" do
-      expect(subject.home_dir).to eq(Gem.user_home)
-    end
-  end
-
-  describe "#home_dir" do
-    context "when env['HOME'] is set" do
-      let(:home_dir) { '/path/to/home_dir' }
-
-      subject { command_class.new(env: {'HOME' => home_dir}) }
-
-      it "must return the env['HOME'] value" do
-        expect(subject.home_dir).to eq(home_dir)
-      end
-    end
-
-    context "when env['HOME'] is not set" do
-      subject { command_class.new(env: {}) }
-
-      it "must return .home_dir" do
-        expect(subject.home_dir).to eq(subject.class.home_dir)
-      end
-    end
-  end
-end

data/spec/env/path_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-require 'command_kit/env/path'
-
-describe CommandKit::Env::Path do
-  module TestEnvPath
-    class TestCommand
-
-      include CommandKit::Env::Path
-
-    end
-  end
-
-  let(:command_class) { TestEnvPath::TestCommand }
-  subject { command_class.new }
-
-  describe ".included" do
-    it "must include CommandKit::Env" do
-      expect(command_class).to be_include(CommandKit::Env)
-    end
-  end
-
-  describe "#initialize" do
-    it "must split ENV['PATH'] into an Array of directories" do
-      expect(subject.path_dirs).to eq(ENV['PATH'].split(File::PATH_SEPARATOR))
-    end
-
-    context "when given a custom 'PATH variable" do
-      let(:path_dirs) { %w[/bin /usr/bin] }
-      let(:path)      { path_dirs.join(File::PATH_SEPARATOR) }
-
-      subject { command_class.new(env: {'PATH' => path}) }
-
-      it "must split env['PATH'] into an Array of directories" do
-        expect(subject.path_dirs).to eq(path_dirs)
-      end
-    end
-
-    context "when given an empty 'PATH' env variable" do
-      subject { command_class.new(env: {'PATH' => ''}) }
-
-      it "must set #path_dirs to []" do
-        expect(subject.path_dirs).to eq([])
-      end
-    end
-  end
-
-  describe "#find_command" do
-    context "when given a valid command name" do
-      it "must search #path_dirs for the command" do
-        command = subject.find_command('ruby')
-
-        expect(subject.path_dirs).to include(File.dirname(command))
-      end
-
-      it "must return the path to the command" do
-        command = subject.find_command('ruby')
-
-        expect(command).to_not be(nil)
-        expect(File.file?(command)).to be(true)
-        expect(File.executable?(command)).to be(true)
-      end
-    end
-
-    context "when given an unknown command name" do
-      it "must return nil" do
-        expect(subject.find_command('does_not_exist')).to be(nil)
-      end
-    end
-  end
-
-  describe "#command_installed?" do
-    context "when given a valid command name" do
-      it do
-        expect(subject.command_installed?('ruby')).to be(true)
-      end
-    end
-
-    context "when given an unknown command name" do
-      it "must return nil" do
-        expect(subject.command_installed?('does_not_exist')).to be(false)
-      end
-    end
-  end
-end

data/spec/env_spec.rb

@@ -1,123 +0,0 @@
-require 'spec_helper'
-require 'command_kit/env'
-
-describe CommandKit::Env do
-  module TestEnv
-    class TestCommand
-      include CommandKit::Env
-    end
-  end
-
-  let(:command_class) { TestEnv::TestCommand }
-
-  describe "#initialize" do
-    module TestEnv
-      class TestCommandWithInitialize
-        include CommandKit::Env
-
-        attr_reader :var
-
-        def initialize(**kwargs)
-          super(**kwargs)
-
-          @var = 'foo'
-        end
-      end
-
-      class TestCommandWithInitializeAndKeywordArgs
-        include CommandKit::Env
-
-        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 #env to ENV" do
-        expect(subject.env).to be(ENV)
-      end
-
-      context "and the including class defines it's own #initialize method" do
-        let(:command_class) { TestEnv::TestCommandWithInitialize }
-
-        it "must initialize #env to ENV" do
-          expect(subject.env).to be(ENV)
-        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) { TestEnv::TestCommandWithInitializeAndKeywordArgs }
-          let(:var) { 'custom value' }
-
-          subject { command_class.new(var: var) }
-
-          it "must initialize #env to ENV" do
-            expect(subject.env).to be(ENV)
-          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_env) { {'FOO' => 'bar'} }
-
-      subject { command_class.new(env: custom_env) }
-
-      it "must initialize #env to the env: value" do
-        expect(subject.env).to eq(custom_env)
-      end
-
-      context "and the including class defines it's own #initialize method" do
-        let(:command_class) { TestEnv::TestCommandWithInitialize }
-
-        it "must initialize #env to the env: value" do
-          expect(subject.env).to eq(custom_env)
-        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) { TestEnv::TestCommandWithInitializeAndKeywordArgs }
-          let(:var) { 'custom value' }
-
-          subject { command_class.new(env: custom_env, var: var) }
-
-          it "must initialize #env to the env: value" do
-            expect(subject.env).to eq(custom_env)
-          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 "#env" do
-    let(:command_class) { TestEnv::TestCommand }
-    let(:env) { {"FOO" => "bar" } }
-
-    subject { command_class.new(env: env) }
-
-    it "must return the initialized env: value" do
-      expect(subject.env).to eq(env)
-    end
-  end
-end

data/spec/examples_spec.rb

@@ -1,211 +0,0 @@
-require 'spec_helper'
-require 'command_kit/examples'
-
-describe CommandKit::Examples do
-  module TestExamples
-    class ImplicitCmd
-      include CommandKit::Examples
-    end
-  end
-
-  let(:command_class) { TestExamples::ImplicitCmd }
-
-  describe ".examples" do
-    subject { TestExamples::ImplicitCmd }
-
-    context "when no examples have been set" do
-      it "should default to nil" do
-        expect(subject.examples).to be_nil
-      end
-    end
-
-    context "when a examples is explicitly set" do
-      module TestExamples
-        class ExplicitCmd
-          include CommandKit::Examples
-          examples [
-            '--example 1',
-            '--example 2'
-          ]
-        end
-      end
-
-      subject { TestExamples::ExplicitCmd }
-
-      it "must return the explicitly set examples" do
-        expect(subject.examples).to eq([
-          '--example 1',
-          '--example 2'
-        ])
-      end
-    end
-
-    context "when the command class inherites from another class" do
-      context "but no examples is set" do
-        module TestExamples
-          class BaseCmd
-            include CommandKit::Examples
-          end
-
-          class InheritedCmd < BaseCmd
-          end
-        end
-
-        subject { TestExamples::InheritedCmd }
-
-        it "must search each class then return nil "do
-          expect(subject.examples).to be_nil
-        end
-      end
-
-      module TestExamples
-        class ExplicitBaseCmd
-          include CommandKit::Examples
-          examples [
-            '--example 1',
-            '--example 2'
-          ]
-        end
-      end
-
-      context "when the superclass defines an explicit examples" do
-        module TestExamples
-          class ImplicitInheritedCmd < ExplicitBaseCmd
-          end
-        end
-
-        let(:super_subject) { TestExamples::ExplicitBaseCmd }
-        subject { TestExamples::ImplicitInheritedCmd }
-
-        it "must inherit the superclass'es examples" do
-          expect(subject.examples).to eq(super_subject.examples)
-        end
-
-        it "must not change the superclass'es examples" do
-          expect(super_subject.examples).to eq([
-            '--example 1',
-            '--example 2'
-          ])
-        end
-      end
-
-      context "when the subclass defines an explicit examples" do
-        module TestExamples
-          class ImplicitBaseCmd
-            include CommandKit::Examples
-          end
-
-          class ExplicitInheritedCmd < ImplicitBaseCmd
-            examples [
-              '--example 1',
-              '--example 2'
-            ]
-          end
-        end
-
-        let(:super_subject) { TestExamples::ImplicitBaseCmd }
-        subject { TestExamples::ExplicitInheritedCmd }
-
-        it "must return the subclass'es examples" do
-          expect(subject.examples).to eq([
-            '--example 1',
-            '--example 2'
-          ])
-        end
-
-        it "must not change the superclass'es examples" do
-          expect(super_subject.examples).to be_nil
-        end
-      end
-
-      context "when both the subclass overrides the superclass's exampless" do
-        module TestExamples
-          class ExplicitOverridingInheritedCmd < ExplicitBaseCmd
-            examples [
-              '--example override'
-            ]
-          end
-        end
-
-        let(:super_subject) { TestExamples::ExplicitBaseCmd }
-        subject { TestExamples::ExplicitOverridingInheritedCmd }
-
-        it "must return the subclass'es examples" do
-          expect(subject.examples).to eq([
-            '--example override'
-          ])
-        end
-
-        it "must not change the superclass'es examples" do
-          expect(super_subject.examples).to eq([
-            '--example 1',
-            '--example 2'
-          ])
-        end
-      end
-    end
-  end
-
-  subject { command_class.new }
-
-  describe "#examples" do
-    it "must be the same as .examples" do
-      expect(subject.examples).to eq(command_class.examples)
-    end
-  end
-
-  describe "#help_examples" do
-    context "when #examples returns nil" do
-      module TestExamples
-        class NoExamples
-          include CommandKit::Examples
-        end
-      end
-
-      let(:command_class) { TestExamples::NoExamples }
-      subject { command_class.new }
-
-      it "must print out the examples" do
-        expect { subject.help_examples }.to_not output.to_stdout
-      end
-    end
-
-    context "when #examples returns an Array" do
-      module TestExamples
-        class MultipleExamples
-          include CommandKit::Examples
-
-          examples [
-            '--example 1',
-            '--example 2',
-            '--example 3'
-          ]
-        end
-      end
-
-      let(:command_class) { TestExamples::MultipleExamples }
-      subject { command_class.new }
-
-      it "must print out the 'Examples:' section header and the examples" do
-        expect { subject.help_examples }.to output(
-          [
-            '',
-            "Examples:",
-            "    #{subject.command_name} #{subject.examples[0]}",
-            "    #{subject.command_name} #{subject.examples[1]}",
-            "    #{subject.command_name} #{subject.examples[2]}",
-            ''
-          ].join($/)
-        ).to_stdout
-      end
-    end
-  end
-
-  describe "#help" do
-    it "must call #help_examples" do
-      expect(subject).to receive(:help_examples)
-
-      subject.help
-    end
-  end
-end