command_kit 0.4.0 → 0.5.0

data/spec/command_kit_spec.rb

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

@@ -1,130 +0,0 @@
-require 'spec_helper'
-require 'command_kit/command_name'
-
-describe CommandKit::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 has been 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

@@ -1,123 +0,0 @@
-require 'spec_helper'
-require 'command_kit/command'
-
-describe CommandKit::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::Options" do
-    expect(described_class).to include(CommandKit::Options)
-  end
-
-  it "must include CommandKit::Arguments" do
-    expect(described_class).to include(CommandKit::Arguments)
-  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
-
-  it "must include CommandKit::FileUtils" do
-    expect(described_class).to include(CommandKit::FileUtils)
-  end
-
-  module TestCommandClass
-    class TestCommand < CommandKit::Command
-
-      usage '[OPTIONS] ARG1 [ARG2]'
-
-      option :option1, short: '-a',
-                       value: {
-                         type: Integer,
-                         default: 1
-                       },
-                       desc: "Option 1"
-
-      option :option2, short: '-b',
-                       value: {
-                         type: String,
-                         usage: 'FILE'
-                       },
-                       desc: "Option 2"
-
-      argument :argument1, required: true,
-                           usage:    'ARG1',
-                           desc:     "Argument 1"
-
-      argument :argument2, required: false,
-                           usage:    'ARG2',
-                           desc:     "Argument 2"
-
-      examples [
-        '-a 42 foo/bar/baz',
-        '-a 42 -b bar.txt baz qux'
-      ]
-
-      description 'Example command'
-
-    end
-  end
-
-  let(:command_class) { TestCommandClass::TestCommand }
-  subject { command_class.new }
-
-  describe "#help" do
-    let(:option1)   { command_class.options[:option1]     }
-    let(:option2)   { command_class.options[:option2]     }
-    let(:argument1) { command_class.arguments[:argument1] }
-    let(:argument2) { command_class.arguments[:argument2] }
-
-    it "must print the usage, options, arguments, examples, and description" do
-      expect { subject.help }.to output(
-        [
-          "Usage: #{subject.usage}",
-          '',
-          'Options:',
-          "    #{option1.usage.join(', ').ljust(33 - 1)} #{option1.desc}",
-          "    #{option2.usage.join(', ').ljust(33 - 1)} #{option2.desc}",
-          '    -h, --help                       Print help information',
-          '',
-          "Arguments:",
-          "    #{argument1.usage.ljust(33)}#{argument1.desc}",
-          "    #{argument2.usage.ljust(33)}#{argument2.desc}",
-          '',
-          "Examples:",
-          "    #{subject.command_name} #{command_class.examples[0]}",
-          "    #{subject.command_name} #{command_class.examples[1]}",
-          '',
-          command_class.description,
-          ''
-        ].join($/)
-      ).to_stdout
-    end
-  end
-end

data/spec/commands/auto_load/subcommand_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-require 'command_kit/commands/auto_load/subcommand'
-
-describe CommandKit::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

@@ -1,159 +0,0 @@
-require 'spec_helper'
-require 'command_kit/commands/auto_load'
-
-describe CommandKit::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 TestCommand
-      include CommandKit::Commands
-      include CommandKit::Commands::AutoLoad.new(
-        dir:       File.expand_path('../fixtures/test_auto_load/cli/commands',__FILE__),
-        namespace: "#{self}::Commands"
-      )
-    end
-
-    class TestCommandWithBlock
-      include CommandKit::Commands
-      include(CommandKit::Commands::AutoLoad.new(
-        dir:       File.expand_path('../fixtures/test_auto_load/cli/commands',__FILE__),
-        namespace: "#{self}::Commands"
-      ) { |autoload|
-        autoload.command 'test-1', 'Test1', 'test1.rb', aliases: %w[test_1]
-        autoload.command 'test-2', 'Test2', 'test2.rb', aliases: %w[test_2]
-      })
-    end
-  end
-
-  let(:command_class)   { TestAutoLoad::TestCommand }
-  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
-
-    context "when CommandKit::Commands::AutoLoad has an explicit mapping" do
-      let(:command_class) { TestAutoLoad::TestCommandWithBlock }
-
-      it "must merge the module's #commands into the class'es #commands" do
-        expect(command_class.commands).to include(autoload_module.commands)
-      end
-
-      it "must also merge the any aliases into the class'es #command_aliases" do
-        expected_command_aliases = {}
-
-        autoload_module.commands.each do |name,subcommand|
-          subcommand.aliases.each do |alias_name|
-            expected_command_aliases[alias_name] = name
-          end
-        end
-
-        expect(command_class.command_aliases).to include(expected_command_aliases)
-      end
-    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

@@ -1,142 +0,0 @@
-require 'spec_helper'
-require 'command_kit/commands/auto_require'
-
-describe CommandKit::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(CommandKit::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

data/spec/commands/fixtures/test_auto_load/cli/commands/test1.rb

@@ -1,10 +0,0 @@
-require 'command_kit/command'
-
-module TestAutoLoad
-  class CLI
-    module Commands
-      class Test1 < CommandKit::Command
-      end
-    end
-  end
-end

data/spec/commands/fixtures/test_auto_load/cli/commands/test2.rb

@@ -1,10 +0,0 @@
-require 'command_kit/command'
-
-module TestAutoLoad
-  class CLI
-    module Commands
-      class Test2 < CommandKit::Command
-      end
-    end
-  end
-end

data/spec/commands/fixtures/test_auto_require/lib/test_auto_require/cli/commands/test1.rb

@@ -1,10 +0,0 @@
-require 'command_kit/command'
-
-module TestAutoRequire
-  class CLI
-    module Commands
-      class Test1 < CommandKit::Command
-      end
-    end
-  end
-end