cuprum-cli 0.1.0 → 0.2.0

data/lib/cuprum/cli/rspec/deferred/registry_examples.rb

@@ -96,60 +96,76 @@ module Cuprum::Cli::RSpec::Deferred
         it { expect(subject.commands).to be_frozen }
 
         wrap_deferred 'when the registry has many commands' do
-          it { expect(subject.commands).to be == commands }
+          it { expect(subject.commands).to eq(commands) }
         end
       end
 
       describe '#register' do
-        deferred_examples 'should configure the command' do
+        deferred_examples 'should register command' do |command_class, **config|
           context 'when the command is registered' do
+            let(:expected_command) do
+              expected = command_class
+              expected = instance_exec(&expected)   if expected.is_a?(Proc)
+              expected = Object.const_get(expected) if expected.is_a?(String)
+
+              expected
+            end
             let(:expected_arguments) do
               config.fetch(:arguments, [])
             end
             let(:expected_description) do
-              config.fetch(:description, command.description)
+              config
+                .fetch(:description, expected_command.description)
+                .then do |value|
+                  value.is_a?(Proc) ? instance_exec(&value) : value
+                end
             end
             let(:expected_full_description) do
-              config.fetch(:full_description) do
-                config.fetch(:description, command.full_description)
-              end
+              config
+                .fetch(:full_description) do
+                  config.fetch(:description, expected_command.full_description)
+                end # rubocop:disable Style/MultilineBlockChain
+                .then do |value|
+                  value.is_a?(Proc) ? instance_exec(&value) : value
+                end
             end
             let(:expected_full_name) do
-              config.fetch(:full_name, command.full_name)
+              config.fetch(:full_name, expected_command.full_name)
             end
             let(:expected_options) do
               config.fetch(:options, {})
             end
+            let(:registered) do
+              registry.commands[expected_full_name]
+            end
 
-            before(:example) { registry.register(command, **config) }
+            before(:example) { register_commands }
 
-            it { expect(registered).to be_a(Class).and(be < command) }
+            it { expect(registered).to be_a(Class).and(be <= expected_command) }
 
-            it 'should configure the command argument values' do
-              expect(registered.argument_values).to be == expected_arguments
+            it 'should configure the command arguments' do
+              expect(registered.argument_values).to eq(expected_arguments)
             end
 
             it 'should configure the command description' do
-              expect(registered.description).to be == expected_description
+              expect(registered.description).to eq(expected_description)
             end
 
             it 'should configure the command full description' do
               expect(registered.full_description)
-                .to be == expected_full_description
+                .to eq(expected_full_description)
             end
 
             it 'should configure the command full name' do
-              expect(registered.full_name).to be == expected_full_name
+              expect(registered.full_name).to eq(expected_full_name)
             end
 
-            it 'should configure the command option values' do
-              expect(registered.option_values).to be == expected_options
+            it 'should configure the command options' do
+              expect(registered.option_values).to eq(expected_options)
             end
           end
         end
 
-        let(:command) { Spec::CustomCommand }
-        let(:config)  { {} }
         let(:expected_keywords) do
           %i[
             arguments
@@ -159,10 +175,12 @@ module Cuprum::Cli::RSpec::Deferred
             options
           ]
         end
-        let(:registered) do
-          name = config.fetch(:full_name, command.full_name)
+        let(:commands) { [Spec::CustomCommand] }
+        let(:config)   { {} }
+        let(:block)    { nil }
 
-          registry.commands[name]
+        define_method :register_commands do
+          registry.register(*commands, **config, &block)
         end
 
         example_class 'Spec::CustomCommand', Cuprum::Cli::Command do |klass|
@@ -173,7 +191,9 @@ module Cuprum::Cli::RSpec::Deferred
           expect(subject)
             .to respond_to(:register)
             .with(1).argument
+            .and_unlimited_arguments
             .and_keywords(*expected_keywords)
+            .and_a_block
         end
 
         it 'should alias the method as #add' do
@@ -182,6 +202,18 @@ module Cuprum::Cli::RSpec::Deferred
             .as(:add)
         end
 
+        describe 'with no commands' do
+          let(:commands) { [] }
+          let(:error_message) do
+            tools.assertions.error_message_for('presence', as: 'commands')
+          end
+
+          it 'should raise an exception' do
+            expect { register_commands }
+              .to raise_error ArgumentError, error_message
+          end
+        end
+
         describe 'with command: nil' do
           let(:error_message) do
             tools.assertions.error_message_for('class', as: 'command')
@@ -220,50 +252,55 @@ module Cuprum::Cli::RSpec::Deferred
         end
 
         describe 'with full_name: an Object' do
+          let(:config) { super().merge(full_name: Object.new.freeze) }
           let(:error_message) do
             tools.assertions.error_message_for('name', as: 'full_name')
           end
 
           it 'should raise an exception' do
-            expect { subject.register(command, full_name: Object.new.freeze) }
+            expect { register_commands }
               .to raise_error ArgumentError, error_message
           end
         end
 
         describe 'with full_name: an empty String' do
+          let(:config) { super().merge(full_name: '') }
           let(:error_message) do
             tools.assertions.error_message_for('presence', as: 'full_name')
           end
 
           it 'should raise an exception' do
-            expect { subject.register(command, full_name: '') }
+            expect { register_commands }
               .to raise_error ArgumentError, error_message
           end
         end
 
         describe 'with full_name: an invalid String' do
+          let(:config) { super().merge(full_name: 'UPPER_CASE') }
           let(:error_message) do
             'full_name does not match format category:sub_category:do_something'
           end
 
           it 'should raise an exception' do
-            expect { subject.register(command, full_name: 'UPPER_CASE') }
+            expect { register_commands }
               .to raise_error ArgumentError, error_message
           end
         end
 
         describe 'with command: an anonymous command class' do
-          let(:command) do
-            Class.new(Cuprum::Cli::Command) do
-              description 'An anonymous command.'
-            end
+          let(:commands) do
+            [
+              Class.new(Cuprum::Cli::Command) do
+                description 'An anonymous command.'
+              end
+            ]
           end
           let(:error_message) do
             tools.assertions.error_message_for('presence', as: 'full_name')
           end
 
           it 'should raise an exception' do
-            expect { subject.register(command) }
+            expect { register_commands }
               .to raise_error ArgumentError, error_message
           end
 
@@ -271,13 +308,11 @@ module Cuprum::Cli::RSpec::Deferred
             let(:full_name) { 'custom:scoped:command' }
             let(:config)    { super().merge(full_name:) }
 
-            it 'should register the command' do
-              expect { subject.register(command, full_name:) }
-                .to change(registry, :commands)
-                .to have_key(full_name)
-            end
+            it { expect(register_commands).to be registry }
 
-            include_deferred 'should configure the command'
+            include_deferred 'should register command',
+              -> { commands.first },
+              full_name: 'custom:scoped:command'
 
             context 'when the registry already defines the command' do
               let(:other_command) do
@@ -295,7 +330,7 @@ module Cuprum::Cli::RSpec::Deferred
               end
 
               it 'should raise an exception' do
-                expect { subject.register(command, full_name:) }
+                expect { register_commands }
                   .to raise_error NameError, error_message
               end
             end
@@ -303,15 +338,11 @@ module Cuprum::Cli::RSpec::Deferred
         end
 
         describe 'with command: a command class' do
-          it { expect(subject.register(command)).to be registry }
+          let(:commands) { [Spec::CustomCommand] }
 
-          it 'should register the command', :aggregate_failures do
-            expect { subject.register(command) }
-              .to change(registry, :commands)
-              .to have_key(command.full_name)
+          it { expect(register_commands).to be registry }
 
-            expect(registry.commands[command.full_name]).to be command
-          end
+          include_deferred 'should register command', 'Spec::CustomCommand'
 
           context 'when the registry already defines the command' do
             let(:other_command) do
@@ -320,31 +351,62 @@ module Cuprum::Cli::RSpec::Deferred
               end
             end
             let(:error_message) do
-              "command already registered as #{command.full_name} - " \
+              "command already registered as #{commands.first.full_name} - " \
                 'Cuprum::Cli::Command'
             end
 
             before(:example) do
-              subject.register(other_command, full_name: command.full_name)
+              subject.register(other_command, full_name: 'spec:custom')
             end
 
             it 'should raise an exception' do
-              expect { subject.register(command) }
+              expect { register_commands }
                 .to raise_error NameError, error_message
             end
           end
 
+          describe 'with arguments: value' do
+            let(:arguments) { %w[ichi ni san] }
+            let(:config)    { super().merge(arguments:) }
+
+            it { expect(register_commands).to be registry }
+
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              arguments: %w[ichi ni san]
+          end
+
+          describe 'with description: value' do
+            let(:description) { 'No one is quite sure what this does.' }
+            let(:config)      { super().merge(description:) }
+
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              description: -> { description }
+          end
+
+          describe 'with full_description: value' do
+            let(:full_description) do
+              <<~DESC
+                No one is quite sure what this does.
+
+                ...but it sure looks cool!
+              DESC
+            end
+            let(:config) { super().merge(full_description:) }
+
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              full_description: -> { full_description }
+          end
+
           describe 'with full_name: value' do
             let(:full_name) { 'custom:scoped:command' }
             let(:config)    { super().merge(full_name:) }
 
-            it 'should register the command' do
-              expect { subject.register(command, full_name:) }
-                .to change(registry, :commands)
-                .to have_key(full_name)
-            end
-
-            include_deferred 'should configure the command'
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              full_name: 'custom:scoped:command'
 
             context 'when the registry already defines the command' do
               let(:other_command) do
@@ -362,88 +424,261 @@ module Cuprum::Cli::RSpec::Deferred
               end
 
               it 'should raise an exception' do
-                expect { subject.register(command, full_name:) }
+                expect { register_commands }
                   .to raise_error NameError, error_message
               end
             end
           end
-        end
-
-        describe 'with arguments: value' do
-          let(:arguments) { %w[ichi ni san] }
-          let(:config)    { super().merge(arguments:) }
 
-          it { expect(subject.register(command)).to be registry }
+          describe 'with options: value' do
+            let(:options) { { option: 'value', other: 'other' } }
+            let(:config)  { super().merge(options:) }
 
-          it 'should register the command' do
-            expect { subject.register(command, arguments:) }
-              .to change(registry, :commands)
-              .to have_key(command.full_name)
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              options: { option: 'value', other: 'other' }
           end
 
-          include_deferred 'should configure the command'
-        end
+          describe 'with multiple config options' do
+            let(:arguments)   { %w[ichi ni san] }
+            let(:description) { 'No one is quite sure what this does.' }
+            let(:options)     { { option: 'value', other: 'other' } }
+            let(:config) do
+              super().merge(arguments:, description:, options:)
+            end
+
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              arguments:   %w[ichi ni san],
+              description: -> { description },
+              options:     { option: 'value', other: 'other' }
+          end
 
-        describe 'with description: value' do
-          let(:description) { 'No one is quite sure what this does.' }
-          let(:config)      { super().merge(description:) }
+          describe 'with a block that configures the command' do
+            let(:block) do
+              lambda do |command|
+                command.with_full_name 'spec:example_command'
+              end
+            end
 
-          it 'should register the command' do
-            expect { subject.register(command, description:) }
-              .to change(registry, :commands)
-              .to have_key(command.full_name)
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              full_name: 'spec:example_command'
           end
 
-          include_deferred 'should configure the command'
-        end
+          describe 'with a block that filters the command' do
+            let(:block) do
+              ->(_command) {}
+            end
 
-        describe 'with full_description: value' do
-          let(:full_description) do
-            <<~DESC
-              No one is quite sure what this does.
+            it { expect(register_commands).to be registry }
 
-              ...but it sure looks cool!
-            DESC
+            it 'should not register a command' do
+              expect { register_commands }.not_to change(registry, :commands)
+            end
           end
-          let(:config) { super().merge(full_description:) }
+        end
 
-          it 'should register the command' do
-            expect { subject.register(command, full_description:) }
-              .to change(registry, :commands)
-              .to have_key(command.full_name)
+        describe 'with multiple command classes' do
+          let(:commands) do
+            [
+              Class
+                .new(Spec::CustomCommand)
+                .with_full_name('spec:example:command_one'),
+              Class
+                .new(Spec::CustomCommand)
+                .with_full_name('spec:example:command_two'),
+              Class
+                .new(Spec::CustomCommand)
+                .with_full_name('spec:example:command_three')
+            ]
           end
 
-          include_deferred 'should configure the command'
-        end
+          it { expect(register_commands).to be registry }
+
+          include_deferred 'should register command',
+            'Spec::CustomCommand',
+            full_name: 'spec:example:command_one'
+
+          include_deferred 'should register command',
+            'Spec::CustomCommand',
+            full_name: 'spec:example:command_two'
+
+          include_deferred 'should register command',
+            'Spec::CustomCommand',
+            full_name: 'spec:example:command_three'
 
-        describe 'with options: value' do
-          let(:options) { { option: 'value', other: 'other' } }
-          let(:config)  { super().merge(options:) }
+          describe 'with configuration options' do
+            let(:config) { super().merge(options: { key: 'value' }) }
 
-          it 'should register the command' do
-            expect { subject.register(command, options:) }
-              .to change(registry, :commands)
-              .to have_key(command.full_name)
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              full_name: 'spec:example:command_one',
+              options:   { key: 'value' }
+
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              full_name: 'spec:example:command_two',
+              options:   { key: 'value' }
+
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              full_name: 'spec:example:command_three',
+              options:   { key: 'value' }
           end
 
-          include_deferred 'should configure the command'
-        end
+          describe 'with a block that configures the commands' do
+            let(:block) do
+              lambda do |command|
+                name = command.full_name.sub('example', 'custom')
+
+                command.with_full_name(name)
+              end
+            end
+
+            it { expect(register_commands).to be registry }
+
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              full_name: 'spec:custom:command_one'
 
-        describe 'with multiple config options' do
-          let(:arguments)   { %w[ichi ni san] }
-          let(:description) { 'No one is quite sure what this does.' }
-          let(:options)     { { option: 'value', other: 'other' } }
-          let(:config) do
-            super().merge(arguments:, description:, options:)
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              full_name: 'spec:custom:command_two'
+
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              full_name: 'spec:custom:command_three'
           end
 
-          it 'should register the command' do
-            expect { subject.register(command, **config) }
-              .to change(registry, :commands)
-              .to have_key(command.full_name)
+          describe 'with a block that filters the commands' do
+            let(:block) do
+              lambda do |command|
+                next if command.full_name.include?('two')
+
+                command
+              end
+            end
+
+            it { expect(register_commands).to be registry }
+
+            it 'should not register filtered commands' do
+              register_commands
+
+              expect(registry.commands)
+                .not_to have_key('spec:example:command_two')
+            end
+
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              full_name: 'spec:example:command_one'
+
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              full_name: 'spec:example:command_three'
+          end
+        end
+
+        describe 'with an Array of command classes' do
+          let(:commands) do
+            [
+              Class
+                .new(Spec::CustomCommand)
+                .with_full_name('spec:example:command_one'),
+              [
+                Class
+                  .new(Spec::CustomCommand)
+                  .with_full_name('spec:example:command_two'),
+                Class
+                  .new(Spec::CustomCommand)
+                  .with_full_name('spec:example:command_three')
+              ]
+            ]
+          end
+
+          it { expect(register_commands).to be registry }
+
+          include_deferred 'should register command',
+            'Spec::CustomCommand',
+            full_name: 'spec:example:command_one'
+
+          include_deferred 'should register command',
+            'Spec::CustomCommand',
+            full_name: 'spec:example:command_two'
+
+          include_deferred 'should register command',
+            'Spec::CustomCommand',
+            full_name: 'spec:example:command_three'
+
+          describe 'with configuration options' do
+            let(:config) { super().merge(options: { key: 'value' }) }
+
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              full_name: 'spec:example:command_one',
+              options:   { key: 'value' }
+
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              full_name: 'spec:example:command_two',
+              options:   { key: 'value' }
+
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              full_name: 'spec:example:command_three',
+              options:   { key: 'value' }
+          end
+
+          describe 'with a block that configures the commands' do
+            let(:block) do
+              lambda do |command|
+                name = command.full_name.sub('example', 'custom')
+
+                command.with_full_name(name)
+              end
+            end
+
+            it { expect(register_commands).to be registry }
+
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              full_name: 'spec:custom:command_one'
+
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              full_name: 'spec:custom:command_two'
+
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              full_name: 'spec:custom:command_three'
           end
 
-          include_deferred 'should configure the command'
+          describe 'with a block that filters the commands' do
+            let(:block) do
+              lambda do |command|
+                next if command.full_name.include?('two')
+
+                command
+              end
+            end
+
+            it { expect(register_commands).to be registry }
+
+            it 'should not register filtered commands' do
+              register_commands
+
+              expect(registry.commands)
+                .not_to have_key('spec:example:command_two')
+            end
+
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              full_name: 'spec:example:command_one'
+
+            include_deferred 'should register command',
+              'Spec::CustomCommand',
+              full_name: 'spec:example:command_three'
+          end
         end
       end
     end