command_kit 0.1.0.pre1

data/spec/command_kit_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'command_kit'
+
+describe CommandKit do
+  it "should have a VERSION constant" do
+    expect(subject.const_get('VERSION')).to_not be_empty
+  end
+end

data/spec/command_name_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+require 'command_kit/command_name'
+
+describe CommandName do
+  module TestCommandName
+    class ImplicitCmd
+      include CommandKit::CommandName
+    end
+  end
+
+  let(:command_class) { TestCommandName::ImplicitCmd }
+
+  describe ".command_name" do
+    subject { command_class }
+
+    context "when no command_name has been set" do
+      it "should underscore the class'es name" do
+        expect(subject.command_name).to eq('implicit_cmd')
+      end
+    end
+
+    context "when a command_name is explicitly set" do
+      module TestCommandName
+        class ExplicitCmd
+          include CommandKit::CommandName
+          command_name 'explicit'
+        end
+      end
+
+      subject { TestCommandName::ExplicitCmd }
+
+      it "must return the explicitly set command_name" do
+        expect(subject.command_name).to eq('explicit')
+      end
+    end
+
+    context "when the command class inherites from another class" do
+      module TestCommandName
+        class BaseCmd
+          include CommandKit::CommandName
+        end
+
+        class InheritedCmd < BaseCmd
+        end
+      end
+
+      subject { TestCommandName::InheritedCmd }
+
+      it "should underscore the class'es name" do
+        expect(subject.command_name).to eq('inherited_cmd')
+      end
+
+      context "when the superclass defines an explicit command_name" do
+        module TestCommandName
+          class ExplicitBaseCmd
+            include CommandKit::CommandName
+            command_name :explicit
+          end
+
+          class ImplicitInheritedCmd < ExplicitBaseCmd
+          end
+        end
+
+        let(:super_subject) { TestCommandName::ExplicitBaseCmd }
+        subject { TestCommandName::ImplicitInheritedCmd }
+
+        it "must return the subclass'es command_name, not the superclass'es" do
+          expect(subject.command_name).to eq('implicit_inherited_cmd')
+        end
+
+        it "must not change the superclass'es command_name" do
+          expect(super_subject.command_name).to eq('explicit')
+        end
+      end
+
+      context "when the subclass defines an explicit command_name" do
+        module TestCommandName
+          class ImplicitBaseCmd
+            include CommandKit::CommandName
+          end
+
+          class ExplicitInheritedCmd < ImplicitBaseCmd
+            command_name :explicit
+          end
+        end
+
+        let(:super_subject) { TestCommandName::ImplicitBaseCmd }
+        subject { TestCommandName::ExplicitInheritedCmd }
+
+        it "must return the subclass'es command_name, not the superclass'es" do
+          expect(subject.command_name).to eq('explicit')
+        end
+
+        it "must not change the superclass'es command_name" do
+          expect(super_subject.command_name).to eq('implicit_base_cmd')
+        end
+      end
+    end
+  end
+
+  describe "#initialize" do
+    context "when given no keyword arguments" do
+      subject { command_class.new }
+
+      it "must set #command_name to .command_name" do
+        expect(subject.command_name).to eq(command_class.command_name)
+      end
+    end
+
+    context "when given the command_name: keyword argument" do
+      let(:command_name) { 'foo' }
+
+      subject { command_class.new(command_name: command_name) }
+
+      it "must set #command_name to the command_name: keyword argument" do
+        expect(subject.command_name).to eq(command_name)
+      end
+    end
+  end
+
+  describe "#command_name" do
+    let(:command_name) { 'foo' }
+
+    subject { command_class.new(command_name: command_name) }
+
+    it "must return the initialized command_name: value" do
+      expect(subject.command_name).to eq(command_name)
+    end
+  end
+end

data/spec/command_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'command_kit/command'
+
+describe Command do
+  it "must include CommandKit::Main" do
+    expect(described_class).to include(CommandKit::Main)
+  end
+
+  it "must include CommandKit::Env" do
+    expect(described_class).to include(CommandKit::Env)
+  end
+
+  it "must include CommandKit::Stdio" do
+    expect(described_class).to include(CommandKit::Stdio)
+  end
+
+  it "must include CommandKit::Printing" do
+    expect(described_class).to include(CommandKit::Printing)
+  end
+
+  it "must include CommandKit::Help" do
+    expect(described_class).to include(CommandKit::Help)
+  end
+
+  it "must include CommandKit::Usage" do
+    expect(described_class).to include(CommandKit::Usage)
+  end
+
+  it "must include CommandKit::Arguments" do
+    expect(described_class).to include(CommandKit::Arguments)
+  end
+
+  it "must include CommandKit::Options" do
+    expect(described_class).to include(CommandKit::Options)
+  end
+
+  it "must include CommandKit::Examples" do
+    expect(described_class).to include(CommandKit::Examples)
+  end
+
+  it "must include CommandKit::Description" do
+    expect(described_class).to include(CommandKit::Description)
+  end
+
+  it "must include CommandKit::ExceptionHandler" do
+    expect(described_class).to include(CommandKit::ExceptionHandler)
+  end
+
+end

data/spec/commands/auto_load/subcommand_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'command_kit/commands/auto_load/subcommand'
+
+describe Commands::AutoLoad::Subcommand do
+  let(:fixtures_dir) { File.expand_path('../../fixtures',__FILE__) }
+
+  let(:file) { 'test1.rb' }
+  let(:path) { File.join(fixtures_dir,'test_auto_load/cli/commands',file) }
+
+  let(:class_name) { 'Test1' }
+  let(:constant) { "TestAutoLoad::CLI::Commands::#{class_name}" }
+
+  subject { described_class.new(constant,path) }
+
+  describe "#initialize" do
+    it "must set #constant" do
+      expect(subject.constant).to eq(constant)
+    end
+
+    it "must set #path" do
+      expect(subject.path).to eq(path)
+    end
+
+    context "when an explicit summary: option is given" do
+      let(:summary) { 'This is a test' }
+
+      subject { described_class.new(constant,path, summary: summary) }
+
+      it "must set #summary" do
+        expect(subject.summary).to eq(summary)
+      end
+    end
+  end
+
+  describe "#require!" do
+    it "must require #path" do
+      expect($LOADED_FEATURES).to_not include(path)
+
+      subject.require!
+
+      expect($LOADED_FEATURES).to include(path)
+    end
+
+    context "when #path does not exist" do
+      let(:path) { '/does/not/exist' }
+
+      it do
+        expect { subject.require! }.to raise_error(LoadError)
+      end
+    end
+  end
+
+  describe "#const_get" do
+    before { subject.require! }
+
+    it "must resolve #constant" do
+      expect(subject.const_get).to eq(TestAutoLoad::CLI::Commands::Test1)
+    end
+
+    context "when the constant shadows a global constant" do
+      let(:constant) { 'TestAutoLoad::CLI::Commands::Object' }
+
+      it do
+        expect { subject.const_get }.to raise_error(NameError)
+      end
+    end
+
+    context "when #constant cannot be found" do
+      let(:constant) { 'Does::Not::Exist' }
+
+      it do
+        expect { subject.const_get }.to raise_error(NameError)
+      end
+    end
+  end
+
+  describe "#command" do
+    it "return the command class" do
+      expect(subject.command).to eq(TestAutoLoad::CLI::Commands::Test1)
+    end
+  end
+end

data/spec/commands/auto_load_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+require 'command_kit/commands/auto_load'
+
+describe Commands::AutoLoad do
+  let(:fixtures_dir) { File.expand_path('../fixtures',__FILE__) }
+
+  let(:dir)       { File.join(fixtures_dir,'test_auto_load','cli','commands') }
+  let(:namespace) { 'TestAutoLoad::CLI::Commands' }
+
+  subject { described_class.new(dir: dir, namespace: namespace) }
+
+  describe "#initialize" do
+    it "must set #dir" do
+      expect(subject.dir).to eq(dir)
+    end
+
+    it "must set #namespace" do
+      expect(subject.namespace).to eq(namespace)
+    end
+
+    it "must populate #commands based on the files within #dir" do
+      expect(subject.commands['test1']).to be_kind_of(described_class::Subcommand)
+      expect(subject.commands['test1'].constant).to eq("#{namespace}::Test1")
+      expect(subject.commands['test1'].path).to eq(File.join(dir,'test1.rb'))
+
+      expect(subject.commands['test2']).to be_kind_of(described_class::Subcommand)
+      expect(subject.commands['test2'].constant).to eq("#{namespace}::Test2")
+      expect(subject.commands['test2'].path).to eq(File.join(dir,'test2.rb'))
+    end
+
+    context "when given a block" do
+      subject do
+        described_class.new(dir: dir, namespace: namespace) do |autoload|
+          autoload.command 'test-1', 'Test1', 'test1.rb'
+          autoload.command 'test-2', 'Test2', 'test2.rb'
+        end
+      end
+
+      it "must not populate #commands based on the files within #dir" do
+        expect(subject.commands['test1']).to be(nil)
+        expect(subject.commands['test2']).to be(nil)
+      end
+
+      it "must allow explicitly initializing #commands via #command" do
+        expect(subject.commands['test-1']).to be_kind_of(described_class::Subcommand)
+        expect(subject.commands['test-1'].constant).to eq("#{namespace}::Test1")
+        expect(subject.commands['test-1'].path).to eq(File.join(dir,'test1.rb'))
+
+        expect(subject.commands['test-2']).to be_kind_of(described_class::Subcommand)
+        expect(subject.commands['test-2'].constant).to eq("#{namespace}::Test2")
+        expect(subject.commands['test-2'].path).to eq(File.join(dir,'test2.rb'))
+      end
+    end
+  end
+
+  module TestAutoLoad
+    class CLI
+      include CommandKit::Commands
+      include CommandKit::Commands::AutoLoad.new(
+        dir:       File.expand_path('../fixtures/test_auto_load/cli/commands',__FILE__),
+        namespace: "#{self}::Commands"
+      )
+    end
+  end
+
+  let(:command_class)   { TestAutoLoad::CLI }
+  let(:autoload_module) { command_class.included_modules.first }
+
+  describe "#included" do
+    subject { command_class }
+
+    it "must also include CommandKit::Commands" do
+      expect(subject).to include(CommandKit::Commands)
+    end
+
+    it "must merge the module's #commands into the class'es #commands" do
+      expect(command_class.commands).to include(autoload_module.commands)
+    end
+  end
+
+  describe "#join" do
+    let(:path) { 'foo/bar' }
+
+    it "must join the path with #dir" do
+      expect(subject.join(path)).to eq(File.join(dir,path))
+    end
+  end
+
+  describe "#files" do
+    it "must list the files within the auto-load directory" do
+      expect(subject.files).to eq(Dir["#{dir}/*.rb"])
+    end
+  end
+
+  describe "#command" do
+    let(:command_name) { 'test' }
+    let(:constant)     { 'Test' }
+    let(:file)         { 'test.rb' }
+
+    before do
+      subject.command command_name, constant, file
+    end
+
+    it "must add a Subcommand to #commands with the given command name" do
+      expect(subject.commands[command_name]).to be_kind_of(described_class::Subcommand)
+    end
+
+    it "must join the given file: value with #dir" do
+      expect(subject.commands[command_name].path).to eq(File.join(dir,file))
+    end
+
+    it "must combine the given constant: value with #namespace" do
+      expect(subject.commands[command_name].constant).to eq("#{namespace}::#{constant}")
+    end
+
+    context "when given a summary: value" do
+      let(:summary) { 'Test is a test' }
+
+      before do
+        subject.command command_name, constant, file, summary: summary
+      end
+
+      it "must set the subcommand's #summary" do
+        expect(subject.commands[command_name].summary).to eq(summary)
+      end
+    end
+  end
+end

data/spec/commands/auto_require_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+require 'command_kit/commands/auto_require'
+
+describe Commands::AutoRequire do
+  let(:fixtures_dir) { File.expand_path('../fixtures',__FILE__) }
+  let(:lib_dir)      { File.join(fixtures_dir,'test_auto_require','lib') }
+  let(:dir)          { File.join('test_auto_require','cli','commands') }
+  let(:namespace) { 'TestAutoRequire::CLI::Commands' }
+
+  before { $LOAD_PATH.unshift(lib_dir) }
+  after  { $LOAD_PATH.delete(lib_dir)  }
+
+  describe "#initialize" do
+    subject { described_class.new(dir: dir, namespace: namespace) }
+
+    it "must set #dir" do
+      expect(subject.dir).to eq(dir)
+    end
+
+    it "must set #namespace" do
+      expect(subject.namespace).to eq(namespace)
+    end
+  end
+
+  module TestAutoRequire
+    class CLI
+      include CommandKit::Commands
+      include CommandKit::Commands::AutoRequire.new(
+        dir:       'test_auto_require/cli/commands',
+        namespace: "#{self}::Commands"
+      )
+    end
+  end
+
+  let(:command_class)       { TestAutoRequire::CLI                 }
+  let(:auto_require_module) { command_class.included_modules.first }
+
+  subject { described_class.new(dir: dir, namespace: namespace) }
+
+  describe "#join" do
+    let(:path) { 'foo/bar' }
+
+    it "must join the path with #dir" do
+      expect(subject.join(path)).to eq(File.join(dir,path))
+    end
+  end
+
+  let(:file_name) { 'test1' }
+
+  describe "#require" do
+    let(:path) { File.join(lib_dir,dir,"#{file_name}.rb") }
+
+    it "must require #path" do
+      expect($LOADED_FEATURES).to_not include(path)
+
+      subject.require(file_name)
+
+      expect($LOADED_FEATURES).to include(path)
+    end
+
+    context "when #path does not exist" do
+      let(:file_name) { 'does_not_exist' }
+
+      it do
+        expect { subject.require(file_name) }.to raise_error(LoadError)
+      end
+    end
+  end
+
+  describe "#const_get" do
+    before { subject.require(file_name) }
+
+    let(:constant) { 'Test1' }
+
+    it "must resolve the given constant within the namespace" do
+      expect(subject.const_get(constant)).to eq(TestAutoRequire::CLI::Commands::Test1)
+    end
+
+    context "when the constant shadows a global constant" do
+      let(:constant) { 'Object' }
+
+      it do
+        expect { subject.const_get(constant) }.to raise_error(NameError)
+      end
+    end
+
+    context "when #constant cannot be found" do
+      let(:constant) { 'DoesNotExist' }
+
+      it do
+        expect { subject.const_get(constant) }.to raise_error(NameError)
+      end
+    end
+  end
+
+  describe "#command" do
+    let(:command_name) { 'test1' }
+
+    it "must require the command's file and return the command class" do
+      expect(subject.command(command_name)).to eq(TestAutoRequire::CLI::Commands::Test1)
+    end
+
+    context "when command's file cannot be found" do
+      let(:command_name) { 'does_not_exist' }
+
+      it do
+        expect(subject.command(command_name)).to be(nil)
+      end
+    end
+  end
+
+  describe "#included" do
+    subject { command_class }
+
+    it "must also include CommandKit::Commands" do
+      expect(subject).to include(CommandKit::Commands)
+    end
+
+    describe ".commands" do
+      it "must set the class'es .commands.default_proc" do
+        expect(command_class.commands.default_proc).to_not be(nil)
+        expect(command_class.commands.default_proc).to be_kind_of(Proc)
+      end
+
+      let(:command_name) { 'test1' }
+
+      it "the .commands.default_proc must auto-require commands and return a Subcommand" do
+        expect(command_class.commands[command_name]).to_not be(nil)
+        expect(command_class.commands[command_name]).to be_kind_of(Commands::Subcommand)
+        expect(command_class.commands[command_name].command).to eq(TestAutoRequire::CLI::Commands::Test1)
+      end
+
+      context "when the given command_name cannot be auto-required" do
+        let(:command_name) { 'does_not_exist' }
+
+        it do
+          expect(command_class.commands[command_name]).to be(nil)
+        end
+      end
+    end
+  end
+end