hammer_cli 0.15.1 → 0.16.0

data/test/unit/abstract_test.rb

@@ -425,14 +425,79 @@ describe HammerCLI::AbstractCommand do
     CmdOD2.output_definition.fields.length.must_equal 1
   end
 
-  it "should allow for multiple validation blocks" do
-    class CmdName1 < HammerCLI::AbstractCommand
-      validate_options do; end
-      validate_options do; end
+  describe 'validate_options' do
+    it "adds a validation block" do
+      cmd = Class.new(HammerCLI::AbstractCommand)
+      cmd.validate_options do; end
+
+      mode, target, validator = cmd.validation_blocks[0]
+
+      assert_equal :append, mode
+      assert_nil target
+      assert validator.is_a?(HammerCLI::Options::Validators::DSLBlockValidator)
+    end
+
+    it "allows for multiple validation blocks" do
+      cmd = Class.new(HammerCLI::AbstractCommand)
+      cmd.validate_options do; end
+      cmd.validate_options do; end
+
+      assert_equal 2, cmd.validation_blocks.length
     end
 
-    assert_equal 2, CmdName1.validation_blocks.length
+    it "allows relative inserts of custom validators" do
+      custom_validator = mock('Validator')
+
+      cmd = Class.new(HammerCLI::AbstractCommand)
+      cmd.validate_options(:before, 'DefaultInputs', validator: custom_validator)
+
+      mode, target, validator = cmd.validation_blocks[0]
+
+      assert_equal :before, mode
+      assert_equal 'DefaultInputs', target
+      assert validator, custom_validator
+    end
   end
 
+  describe 'add_validators' do
+    it 'is called upon the option_collector initialization' do
+      cmd = Class.new(HammerCLI::AbstractCommand)
+
+      cmd_instance = cmd.new('', {})
+      cmd_instance.expects(:add_validators).with do |sources|
+        sources.map(&:name) == ['DefaultInputs']
+      end
+      cmd_instance.send(:option_collector)
+    end
+
+    it 'inserts validators' do
+      validator1 = stub('Validator1', :name => 'Validator1')
+      validator2 = stub('Validator2', :name => 'Validator2')
+      sources = HammerCLI::Options::ProcessorList.new([
+        stub('Source1', :name => 'Source1'),
+        stub('Source2', :name => 'Source2')
+      ])
+
+      cmd = Class.new(HammerCLI::AbstractCommand)
+      cmd.validate_options(:after, 'Source1', validator: validator1)
+      cmd.validate_options(validator: validator2)
+
+      cmd_instance = cmd.new('', {})
+      result = cmd_instance.send(:add_validators, sources)
+      assert_equal ['Source1', 'Validator1', 'Source2', 'Validator2'], result.map(&:name)
+    end
+
+    it 'allows for creating inheritable validators' do
+      validator1 = stub('Validator1', :name => 'Validator1')
+      cmd = Class.new(HammerCLI::AbstractCommand)
+      cmd.send(:define_method, :add_validators) { |sources| [ validator1 ] }
+
+      sub_cmd = Class.new(cmd)
+
+      cmd_instance = sub_cmd.new('', {})
+      result = cmd_instance.send(:option_collector).option_processor
+      assert_equal ['Validator1'], result.map(&:name)
+    end
+  end
 end
 

data/test/unit/exception_handler_test.rb

@@ -30,7 +30,7 @@ describe HammerCLI::ExceptionHandler do
   end
 
   it "should handle help request" do
-    output.expects(:print_message).with(cmd.help, nil, verbosity: HammerCLI::V_QUIET)
+    output.expects(:print_message).with(cmd.help, {}, verbosity: HammerCLI::V_QUIET)
     handler.handle_exception(Clamp::HelpWanted.new(cmd), :heading => heading)
 
   end

data/test/unit/help/definition/abstract_item_test.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), '../../test_helper')
+
+describe HammerCLI::Help::AbstractItem do
+  describe '#indent' do
+    let(:first_item) { HammerCLI::Help::Text.new('Lorem ipsum') }
+    let(:second_item) { HammerCLI::Help::Text.new(' Dolor sit amet') }
+    let(:sub_definition) { HammerCLI::Help::Definition.new([first_item, second_item]) }
+
+    it 'indents text' do
+      section = HammerCLI::Help::Section.new('Heading', sub_definition)
+      expected_result = [
+        'Heading:',
+        '  Lorem ipsum',
+        '',
+        '   Dolor sit amet',
+        ''
+      ].join("\n")
+      section.build_string.must_equal(expected_result)
+    end
+
+    it 'indents text with custom padding' do
+      section = HammerCLI::Help::Section.new('Heading', sub_definition, indentation: '**')
+      expected_result = [
+        'Heading:',
+        '**Lorem ipsum',
+        '**',
+        '** Dolor sit amet',
+        ''
+      ].join("\n")
+      section.build_string.must_equal(expected_result)
+    end
+  end
+end

data/test/unit/help/definition/list_test.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), '../../test_helper')
+
+describe HammerCLI::Help::List do
+  describe '#build_string' do
+    let(:first_item)  { [:first,   'This is first line'] }
+    let(:second_item) { [:second,  'This is second line'] }
+    let(:list) { HammerCLI::Help::List.new([first_item, second_item]) }
+
+    it 'builds string' do
+      list.build_string.must_equal [
+        'first               This is first line',
+        'second              This is second line',
+        ''
+      ].join("\n")
+    end
+  end
+end

data/test/unit/help/definition/section_test.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), '../../test_helper')
+
+describe HammerCLI::Help::Section do
+  describe '#build_string' do
+    let(:section)     { HammerCLI::Help::Section.new('section') }
+    let(:first_text)  { HammerCLI::Help::Text.new('first') }
+    let(:second_text) { HammerCLI::Help::Text.new('second') }
+
+    it 'builds string without definition' do
+      section.build_string.must_equal "section:\n\n"
+    end
+
+    it 'builds string with definition' do
+      section.definition = HammerCLI::Help::Definition.new([first_text, second_text])
+      expected_output =  [
+        'section:',
+        '  first',
+        '',
+        '  second',
+        ''
+      ].join("\n")
+      section.build_string.must_equal expected_output
+    end
+  end
+end

data/test/unit/help/definition/text_test.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), '../../test_helper')
+
+describe HammerCLI::Help::Text do
+  describe '#build_string' do
+    let(:text) { HammerCLI::Help::Text.new('text') }
+
+    it 'builds string' do
+      text.build_string.must_equal 'text'
+    end
+  end
+end

data/test/unit/help/definition_test.rb

@@ -0,0 +1,236 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+
+describe HammerCLI::Help::Definition do
+  let(:definition) { HammerCLI::Help::Definition.new }
+  let(:old_text_item)  { HammerCLI::Help::Text.new('Lorem ipsum', id: :old) }
+  let(:new_text_item)  { HammerCLI::Help::Text.new('Dolor sit amet', id: :new) }
+
+  describe '#build_string' do
+    describe 'text' do
+      it 'prints text via definition' do
+        definition << HammerCLI::Help::Text.new('Lorem ipsum')
+        definition.build_string.must_equal "Lorem ipsum\n"
+      end
+
+      it 'prints multiple blocks with spaces via definition' do
+        definition << HammerCLI::Help::Text.new('Lorem ipsum')
+        definition << HammerCLI::Help::Text.new('Dolor sit amet')
+        definition.build_string.must_equal [
+          'Lorem ipsum',
+          '',
+          'Dolor sit amet',
+          ''
+        ].join("\n")
+      end
+    end
+
+    describe 'section' do
+      it 'prints section heading via definition' do
+        definition << HammerCLI::Help::Section.new('Heading')
+        definition.build_string.must_equal "Heading:\n\n"
+      end
+
+      it 'indents section content via definition' do
+        sub_definition = HammerCLI::Help::Definition.new
+        sub_definition << HammerCLI::Help::Text.new('Lorem ipsum')
+        sub_definition << HammerCLI::Help::Text.new('Dolor sit amet')
+        definition << HammerCLI::Help::Section.new('Heading', sub_definition)
+        definition.build_string.must_equal [
+          'Heading:',
+          '  Lorem ipsum',
+          '',
+          '  Dolor sit amet',
+          ''
+        ].join("\n")
+      end
+    end
+
+    describe 'list' do
+      it 'prints empty list via definition' do
+        builder = HammerCLI::Help::TextBuilder.new
+        builder.list([])
+        builder.definition.build_string.must_equal ''
+      end
+
+      it 'prints single column list' do
+        definition << HammerCLI::Help::List.new([
+          :a,
+          :bb,
+          :ccc
+        ])
+        definition.build_string.must_equal [
+          'a',
+          'bb',
+          'ccc',
+          ''
+        ].join("\n")
+      end
+
+      it 'prints two column list via definition' do
+        definition << HammerCLI::Help::List.new([
+          [:a,   'This is line A'],
+          [:bb,  'This is line B'],
+          [:ccc]
+        ])
+        definition.build_string.must_equal [
+          'a                   This is line A',
+          'bb                  This is line B',
+          'ccc',
+          ''
+        ].join("\n")
+      end
+
+      it 'handles multiple lines in the second column via definition' do
+        definition << HammerCLI::Help::List.new([
+          [:a,   "This is line A\nThis is line A part two"],
+          [:bb,  'This is line B'],
+          [:ccc, 'This is line C']
+        ])
+        definition.build_string.must_equal [
+          'a                   This is line A',
+          '                    This is line A part two',
+          'bb                  This is line B',
+          'ccc                 This is line C',
+          ''
+        ].join("\n")
+      end
+
+      it 'can adjust indentation of the second column via definition' do
+        definition << HammerCLI::Help::List.new([
+          ['a',  'This is line A'],
+          ['This line B is too long for the first column',   'This is line B'],
+          ['ccc', 'This is line C']
+        ])
+        definition.build_string.must_equal [
+          'a                                             This is line A',
+          'This line B is too long for the first column  This is line B',
+          'ccc                                           This is line C',
+          ''
+        ].join("\n")
+      end
+    end
+  end
+
+  describe '#find_item' do
+    it 'finds an item' do
+      definition << old_text_item
+      definition << new_text_item
+      definition.find_item(:new).must_equal new_text_item
+    end
+  end
+
+  describe '#insert_definition' do
+    let(:new_definition) { HammerCLI::Help::Definition.new([new_text_item, new_text_item]) }
+    let(:section_item)   { HammerCLI::Help::Section.new('section', id: :section) }
+
+    describe 'before' do
+      it 'should insert new help item before the old one' do
+        definition << old_text_item
+        definition.insert_definition(:before, :old, new_text_item.definition)
+        definition.first.id.must_equal new_text_item.id
+        definition.count.must_equal 2
+      end
+
+      it 'should insert multiple items before old item' do
+        definition << old_text_item
+        definition.insert_definition(:before, :old, new_definition)
+        definition.first.id.must_equal new_text_item.id
+        definition.count.must_equal 3
+      end
+
+      it 'should work with labels' do
+        definition << section_item
+        definition.insert_definition(:before, 'section', new_definition)
+        definition.first.id.must_equal new_text_item.id
+        definition.count.must_equal 3
+      end
+    end
+
+    describe 'after' do
+      it 'should insert new help item after the old one' do
+        definition << old_text_item
+        definition.insert_definition(:after, :old, new_text_item.definition)
+        definition[0].id.must_equal old_text_item.id
+        definition[1].id.must_equal new_text_item.id
+        definition.count.must_equal 2
+      end
+
+      it 'should insert multiple items after old item' do
+        definition << old_text_item
+        definition.insert_definition(:after, :old, new_definition)
+        definition[0].id.must_equal old_text_item.id
+        definition[1].id.must_equal new_text_item.id
+        definition[2].id.must_equal new_text_item.id
+        definition.count.must_equal 3
+      end
+
+      it 'should work with labels' do
+        definition << section_item
+        definition.insert_definition(:after, 'section', new_text_item.definition)
+        definition[1].id.must_equal new_text_item.id
+        definition.count.must_equal 2
+      end
+    end
+
+    describe 'replace' do
+      it 'should replace the old help item with new one' do
+        definition << old_text_item
+        definition.insert_definition(:replace, :old, new_text_item.definition)
+        definition.first.id.must_equal new_text_item.id
+        definition.count.must_equal 1
+      end
+
+      it 'should replace the old help item with new ones' do
+        definition << old_text_item
+        definition.insert_definition(:replace, :old, new_definition)
+        definition[0].id.must_equal new_text_item.id
+        definition[1].id.must_equal new_text_item.id
+        definition.count.must_equal 2
+      end
+
+      it 'should work with labels' do
+        definition << section_item
+        definition.insert_definition(:replace, 'section', new_text_item.definition)
+        definition.first.id.must_equal new_text_item.id
+        definition.count.must_equal 1
+      end
+    end
+  end
+
+  describe '#at' do
+    it 'should return self if path is empty' do
+      definition << old_text_item
+      definition.at([]) do |h|
+        h.definition.first.id.must_equal old_text_item.id
+      end
+    end
+
+    it 'should accept integer' do
+      definition << old_text_item
+      definition << new_text_item
+      definition.at(1) do |h|
+        h.definition.first.id.must_equal new_text_item.id
+      end
+    end
+
+    it 'should return definition of specified help item with path' do
+      sub_definition = HammerCLI::Help::Definition.new
+      sub_definition << old_text_item
+      sub_definition << new_text_item
+      definition << HammerCLI::Help::Section.new('first', sub_definition, id: :first_section)
+      definition << HammerCLI::Help::Section.new('second', sub_definition, id: :second_section)
+      definition.at(:first_section).definition << HammerCLI::Help::Section.new('nested', sub_definition, id: :nested_section)
+      definition.at([:first_section, :nested_section]).definition.first.id.must_equal old_text_item.id
+    end
+
+    it 'should work with labels' do
+      sub_definition = HammerCLI::Help::Definition.new
+      sub_definition << old_text_item
+      sub_definition << new_text_item
+      definition << HammerCLI::Help::Section.new('first', sub_definition)
+      definition << HammerCLI::Help::Section.new('second', sub_definition)
+      definition.at('first').definition << HammerCLI::Help::Section.new('nested', sub_definition)
+      definition.at(['first', 'nested']).definition.first.id.must_equal old_text_item.id
+    end
+  end
+end

data/test/unit/help/text_builder_test.rb

@@ -136,5 +136,174 @@ describe HammerCLI::Help::TextBuilder do
       help.indent(text, '**').must_equal(expected_result)
     end
   end
-end
 
+  describe '#find_item' do
+    it 'finds an item' do
+      help.text('Lorem ipsum', id: :lorem)
+      help.text('Dolor sit amet', id: :dolor)
+      help.find_item(:dolor).id.must_equal :dolor
+    end
+
+    it 'finds a nested item' do
+      help.section('Heading') do |h|
+        h.text('Lorem ipsum', id: :lorem)
+        h.text('Dolor sit amet', id: :dolor)
+      end
+      help.at('Heading') do |h|
+        h.find_item(:dolor).id.must_equal :dolor
+      end
+    end
+  end
+
+  describe '#insert' do
+    describe 'before' do
+      it 'should insert new help item before the old one' do
+        help.text('old', id: :old)
+        help.insert(:before, :old) do |h|
+          h.text('new', id: :new)
+        end
+        help.definition.first.id.must_equal :new
+        help.definition.count.must_equal 2
+      end
+
+      it 'should insert multiple items before old item' do
+        help.text('old', id: :old)
+        help.insert(:before, :old) do |h|
+          h.text('new', id: :new)
+          h.text('new2', id: :new2)
+        end
+        help.definition.first.id.must_equal :new
+        help.definition.count.must_equal 3
+      end
+
+      it 'should work with labels' do
+        help.section('section') do |h|
+          h.text('text in section')
+        end
+        help.insert(:before, 'section') do |h|
+          h.text('text before section', id: :before_section)
+        end
+        help.definition.first.id.must_equal :before_section
+        help.definition.count.must_equal 2
+      end
+    end
+
+    describe 'after' do
+      it 'should insert new help item after the old one' do
+        help.text('old', id: :old)
+        help.insert(:after, :old) do |h|
+          h.text('new', id: :new)
+        end
+        help.definition[0].id.must_equal :old
+        help.definition[1].id.must_equal :new
+        help.definition.count.must_equal 2
+      end
+
+      it 'should insert multiple items after old item' do
+        help.text('old', id: :old)
+        help.insert(:after, :old) do |h|
+          h.text('new', id: :new)
+          h.text('new2', id: :new2)
+        end
+        help.definition[0].id.must_equal :old
+        help.definition[1].id.must_equal :new
+        help.definition[2].id.must_equal :new2
+        help.definition.count.must_equal 3
+      end
+
+      it 'should work with labels' do
+        help.section('section') do |h|
+          h.text('text in section')
+        end
+        help.insert(:after, 'section') do |h|
+          h.text('text before section', id: :after_section)
+        end
+        help.definition[1].id.must_equal :after_section
+        help.definition.count.must_equal 2
+      end
+    end
+
+    describe 'replace' do
+      it 'should replace the old help item with new one' do
+        help.text('old', id: :old)
+        help.insert(:replace, :old) do |h|
+          h.text('new', id: :new)
+        end
+        help.definition.first.id.must_equal :new
+        help.definition.count.must_equal 1
+      end
+
+      it 'should replace the old help item with new ones' do
+        help.text('old', id: :old)
+        help.insert(:replace, :old) do |h|
+          h.text('new', id: :new)
+          h.text('new2', id: :new2)
+        end
+        help.definition[0].id.must_equal :new
+        help.definition[1].id.must_equal :new2
+        help.definition.count.must_equal 2
+      end
+
+      it 'should work with labels' do
+        help.section('section') do |h|
+          h.text('text in section')
+        end
+        help.insert(:replace, 'section') do |h|
+          h.text('text instead of section', id: :instead_of_section)
+        end
+        help.definition.first.id.must_equal :instead_of_section
+        help.definition.count.must_equal 1
+      end
+    end
+  end
+
+  describe '#at' do
+    it 'should return self if path is empty' do
+      help.text('foo', id: :foo)
+      help.at([]) do |h|
+        h.definition.first.id.must_equal :foo
+      end
+      help.at do |h|
+        h.definition.first.id.must_equal :foo
+      end
+    end
+
+    it 'should return definition of specified help item with path' do
+      help.section('first', id: :first_section) do |h|
+        h.text('first text in the first section', id: :first_text1)
+        h.text('second text in the first section', id: :secon_text1)
+      end
+      help.section('second', id: :second_section) do |h|
+        h.text('first text in the second section', id: :first_text2)
+        h.text('second text in the second section', id: :secon_text2)
+      end
+      help.at(:first_section) do |h|
+        h.section('nested section', id: :nested_section) do |h|
+          h.text('text in nested section', id: :nested_text)
+        end
+      end
+      help.at([:first_section, :nested_section]) do |h|
+        h.definition.first.id.must_equal :nested_text
+      end
+    end
+
+    it 'should work with labels' do
+      help.section('first') do |h|
+        h.text('first text in the first section', id: :first_text1)
+        h.text('second text in the first section', id: :secon_text1)
+      end
+      help.section('second') do |h|
+        h.text('first text in the second section', id: :first_text2)
+        h.text('second text in the second section', id: :secon_text2)
+      end
+      help.at('first') do |h|
+        h.section('nested section') do |h|
+          h.text('text in nested section', id: :nested_text)
+        end
+      end
+      help.at(['first', 'nested section']) do |h|
+        h.definition.first.id.must_equal :nested_text
+      end
+    end
+  end
+end