cliqr 1.1.0 → 1.2.0

data/spec/fixtures/action_reader_command.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+# A command that echoes the actions and options back
+class ActionReaderCommand < Cliqr.command
+  def execute(context)
+    puts "command = #{context.command}\n\n"
+    puts "executing action = #{context.action_name}" if context.action?
+    context.options.each do |option|
+      puts "[option] #{option.name} => #{option.value}"
+    end
+  end
+end

data/spec/fixtures/csv_argument_operator.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+# A argument operator that splits the value by ','
+class CSVArgumentOperator < Cliqr.operator
+  def operate(value)
+    value.split(',')
+  end
+end

data/spec/fixtures/test_option_type_checker_command.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+# A command that echoes the value for option named 'test-option'
+class TestOptionTypeCheckerCommand < Cliqr.command
+  def execute(context)
+    puts "test-option is of type #{context.option('test-option').value.class}"
+  end
+end

data/spec/parser/action_argument_parser_spec.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+
+require 'argument_parser_spec_helper'
+
+describe Cliqr::Parser do
+  it 'can parse a command with an action' do
+    cli = Cliqr.interface do
+      name 'my-command'
+      handler TestCommand
+
+      action 'my-action' do
+        handler TestCommand
+      end
+    end
+    config = cli.config
+    parsed_input = Cliqr::Parser::ParsedInput.new(:command => 'my-command',
+                                                  :options => [])
+    assert_results(config, ['my-action'], parsed_input, config.action('my-action'))
+  end
+
+  it 'can parse a command with a nested action' do
+    cli = Cliqr.interface do
+      name 'my-command'
+      handler TestCommand
+
+      action 'my-action-1' do
+        handler TestCommand
+
+        action 'my-action-2' do
+          handler TestCommand
+
+          action 'my-action-3' do
+            handler TestCommand
+          end
+        end
+      end
+    end
+    config = cli.config
+    parsed_input = Cliqr::Parser::ParsedInput.new(:command => 'my-command',
+                                                  :options => [])
+    assert_results(config, %w(my-action-1 my-action-2 my-action-3), parsed_input,
+                   config.action('my-action-1').action('my-action-2').action('my-action-3'))
+  end
+
+  it 'can parse a command with an action and options' do
+    cli = Cliqr.interface do
+      name 'my-command'
+      handler TestCommand
+
+      action 'my-action' do
+        handler TestCommand
+
+        option 'test-option-1' do
+          short 't'
+        end
+
+        option 'test-option-2' do
+          short 'p'
+        end
+      end
+    end
+    config = cli.config
+    parsed_input = Cliqr::Parser::ParsedInput.new(:command => 'my-command',
+                                                  :options => [
+                                                    {
+                                                        :name => 'test-option-1',
+                                                        :value => 'abcd'
+                                                    },
+                                                    {
+                                                        :name => 'test-option-2',
+                                                        :value => 'qwe'
+                                                    }
+                                                  ])
+    assert_results(config, %w(my-action -t abcd --test-option-2 qwe), parsed_input, config.action('my-action'))
+  end
+
+  it 'can parse a command with nested action and options' do
+    cli = Cliqr.interface do
+      name 'my-command'
+      handler TestCommand
+
+      action 'my-action-1' do
+        handler TestCommand
+
+        action 'my-action-2' do
+          handler TestCommand
+
+          option 'test-option-1' do
+            short 't'
+          end
+
+          option 'test-option-2' do
+            short 'p'
+          end
+        end
+      end
+    end
+    config = cli.config
+    parsed_input = Cliqr::Parser::ParsedInput.new(:command => 'my-command',
+                                                  :options => [
+                                                    {
+                                                        :name => 'test-option-1',
+                                                        :value => 'abcd'
+                                                    },
+                                                    {
+                                                        :name => 'test-option-2',
+                                                        :value => 'qwe'
+                                                    }
+                                                  ])
+    assert_results(config, %w(my-action-1 -t abcd --test-option-2 qwe my-action-2), parsed_input,
+                   config.action('my-action-1').action('my-action-2'))
+  end
+end

data/spec/parser/argument_parser_spec.rb

@@ -1,16 +1,10 @@
 # encoding: utf-8
 
-require 'spec_helper'
-
-require 'cliqr/parser/argument_parser'
-require 'cliqr/parser/parsed_input'
-
-require 'fixtures/test_command'
-require 'fixtures/option_reader_command'
+require 'argument_parser_spec_helper'
 
 describe Cliqr::Parser do
   TEST_CLI = Cliqr.interface do
-    basename 'my-command'
+    name 'my-command'
     handler TestCommand
     arguments :disable
 
@@ -19,10 +13,9 @@ describe Cliqr::Parser do
     end
   end
   CONFIG = TEST_CLI.config
-  PARSER = Cliqr::Parser
 
   it 'can parse no argument command' do
-    expect(PARSER.parse(CONFIG, [])).to eq(Cliqr::Parser::ParsedInput.new(:command => 'my-command', :options => []))
+    assert_results(CONFIG, [], Cliqr::Parser::ParsedInput.new(:command => 'my-command', :options => []))
   end
 
   it 'can parse command with option using long name' do
@@ -33,7 +26,7 @@ describe Cliqr::Parser do
                                                         :value => 'abcd'
                                                     }
                                                   ])
-    expect(PARSER.parse(CONFIG, %w(--test-option abcd))).to eq(parsed_input)
+    assert_results(CONFIG, %w(--test-option abcd), parsed_input)
   end
 
   it 'can parse multiple options' do
@@ -49,13 +42,13 @@ describe Cliqr::Parser do
                                                     }
                                                   ])
     cli = Cliqr.interface do
-      basename 'my-command'
+      name 'my-command'
       handler TestCommand
 
       option 'test-option-1'
       option 'test-option-2'
     end
-    expect(Cliqr::Parser.parse(cli.config, %w(--test-option-1 abcd --test-option-2 xyz))).to eq(parsed_input)
+    assert_results(cli.config, %w(--test-option-1 abcd --test-option-2 xyz), parsed_input)
   end
 
   it 'can parse command with option using short name' do
@@ -66,36 +59,36 @@ describe Cliqr::Parser do
                                                         :value => 'abcd'
                                                     }
                                                   ])
-    expect(PARSER.parse(CONFIG, %w(-t abcd))).to eq(parsed_input)
+    assert_results(CONFIG, %w(-t abcd), parsed_input)
   end
 
   it 'cannot parse unknown options' do
-    expect { PARSER.parse(CONFIG, %w(--unknown-option abcd)) }.to(
+    expect { Cliqr::Parser.parse(CONFIG, %w(--unknown-option abcd)) }.to(
       raise_error(Cliqr::Error::UnknownCommandOption, 'unknown option "--unknown-option"'))
-    expect { PARSER.parse(CONFIG, %w(-u abcd)) }.to(
+    expect { Cliqr::Parser.parse(CONFIG, %w(-u abcd)) }.to(
       raise_error(Cliqr::Error::UnknownCommandOption, 'unknown option "-u"'))
   end
 
   it 'cannot parse invalid options' do
-    expect { PARSER.parse(CONFIG, %w(--1)) }.to(
-      raise_error(Cliqr::Error::InvalidArgumentError, 'invalid command argument "--1"'))
-    expect { PARSER.parse(CONFIG, %w(-$)) }.to(
-      raise_error(Cliqr::Error::InvalidArgumentError, 'invalid command argument "-$"'))
+    expect { Cliqr::Parser.parse(CONFIG, %w(--1)) }.to(
+      raise_error(Cliqr::Error::IllegalArgumentError, 'invalid command argument "--1"'))
+    expect { Cliqr::Parser.parse(CONFIG, %w(-$)) }.to(
+      raise_error(Cliqr::Error::IllegalArgumentError, 'invalid command argument "-$"'))
   end
 
   it 'cannot parse option without value if required' do
-    expect { PARSER.parse(CONFIG, %w(--test-option)) }.to(
+    expect { Cliqr::Parser.parse(CONFIG, %w(--test-option)) }.to(
       raise_error(Cliqr::Error::OptionValueMissing, 'a value must be defined for argument "--test-option"'))
   end
 
   it 'cannot parse option if it has multiple values' do
-    expect { PARSER.parse(CONFIG, %w(--test-option val1 --test-option val2)) }.to(
+    expect { Cliqr::Parser.parse(CONFIG, %w(--test-option val1 --test-option val2)) }.to(
       raise_error(Cliqr::Error::MultipleOptionValues, 'multiple values for option "--test-option"'))
   end
 
   it 'can parse command with arguments' do
     cli = Cliqr.interface do
-      basename 'my-command'
+      name 'my-command'
       handler TestCommand
       arguments :enable
 
@@ -106,19 +99,19 @@ describe Cliqr::Parser do
     parsed_input = Cliqr::Parser::ParsedInput.new(:command => 'my-command',
                                                   :options => {},
                                                   :arguments => ['value1'])
-    expect(PARSER.parse(cli.config, %w(value1))).to eq(parsed_input)
+    assert_results(cli.config, ['value1'], parsed_input)
   end
 
   it 'can parse command with one option and one argument' do
     parsed_input = Cliqr::Parser::ParsedInput.new(:command => 'my-command',
                                                   :options => [
-                                                      {
-                                                          :name => 'test-option',
-                                                          :value => 'abcd'
-                                                      }],
+                                                    {
+                                                        :name => 'test-option',
+                                                        :value => 'abcd'
+                                                    }],
                                                   :arguments => ['value1'])
     cli = Cliqr.interface do
-      basename 'my-command'
+      name 'my-command'
       handler TestCommand
       arguments :enable
 
@@ -127,13 +120,13 @@ describe Cliqr::Parser do
       end
     end
 
-    expect(PARSER.parse(cli.config, %w(-t abcd value1))).to eq(parsed_input)
-    expect(PARSER.parse(cli.config, %w(value1 -t abcd))).to eq(parsed_input)
+    assert_results(cli.config, %w(-t abcd value1), parsed_input)
+    assert_results(cli.config, %w(value1 -t abcd), parsed_input)
   end
 
   it 'can parse command with a mix of options and arguments' do
     cli = Cliqr.interface do
-      basename 'my-command'
+      name 'my-command'
       handler TestCommand
       arguments :enable
 
@@ -149,17 +142,17 @@ describe Cliqr::Parser do
     parsed_input = Cliqr::Parser::ParsedInput.new(:command => 'my-command',
                                                   :arguments => %w(value1 value2),
                                                   :options => [
-                                                      {
-                                                          :name => 'test-option-1',
-                                                          :value => 'abcd'
-                                                      },
-                                                      {
-                                                          :name => 'test-option-2',
-                                                          :value => 'qwe'
-                                                      }
-                                                    ])
-    expect(PARSER.parse(config, %w(-t abcd -p qwe value1 value2))).to eq(parsed_input)
-    expect(PARSER.parse(config, %w(value1 -t abcd value2 -p qwe))).to eq(parsed_input)
-    expect(PARSER.parse(config, %w(-t abcd value1 -p qwe value2))).to eq(parsed_input)
+                                                    {
+                                                        :name => 'test-option-1',
+                                                        :value => 'abcd'
+                                                    },
+                                                    {
+                                                        :name => 'test-option-2',
+                                                        :value => 'qwe'
+                                                    }
+                                                  ])
+    assert_results(config, %w(-t abcd -p qwe value1 value2), parsed_input)
+    assert_results(config, %w(value1 -t abcd value2 -p qwe), parsed_input)
+    assert_results(config, %w(-t abcd value1 -p qwe value2), parsed_input)
   end
 end

data/spec/spec_helper.rb

@@ -17,6 +17,7 @@ end
 if ENV['COVERAGE']
   require 'simplecov'
   SimpleCov.start do
+    add_filter '/spec/'
     SimpleCov.minimum_coverage 100
   end
 end

data/spec/validation/action_argument_validator_spec.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+require 'fixtures/test_command'
+
+describe Cliqr::ArgumentValidation::Validator do
+  it 'does not allow multiple actions at the same level in the same command' do
+    cli = Cliqr.interface do
+      name 'my-command'
+      handler TestCommand
+
+      action 'my-action' do
+        handler TestCommand
+        arguments :disable
+      end
+
+      action 'another-action' do
+        handler TestCommand
+      end
+    end
+    expect { cli.execute_internal %w(my-action another-action) }.to(
+      raise_error(Cliqr::Error::IllegalArgumentError, "invalid command argument \"another-action\""))
+  end
+
+  it 'does not allow illegal nesting of actions in a command' do
+    cli = Cliqr.interface do
+      name 'my-command'
+      handler TestCommand
+
+      action 'my-action' do
+        handler TestCommand
+        option 'test-option'
+
+        action 'third-action' do
+          handler TestCommand
+          option 'third-option'
+        end
+      end
+
+      action 'another-action' do
+        handler TestCommand
+        option 'test-option'
+        arguments :disable
+      end
+    end
+    expect { cli.execute_internal %w(another-action third-action) }.to(
+      raise_error(Cliqr::Error::IllegalArgumentError, "invalid command argument \"third-action\""))
+  end
+end

data/spec/validation/{argument_validation_spec.rb → command_argument_validation_spec.rb}

@@ -10,7 +10,7 @@ require 'fixtures/test_option_reader_command'
 describe Cliqr::ArgumentValidation::Validator do
   it 'can validate numerical arguments' do
     cli = Cliqr.interface do
-      basename 'my-command'
+      name 'my-command'
       handler TestOptionReaderCommand
 
       option 'test-option' do
@@ -18,31 +18,49 @@ describe Cliqr::ArgumentValidation::Validator do
       end
     end
 
-    result = cli.execute %w(--test-option 123), output: :buffer
+    result = cli.execute_internal %w(--test-option 123), output: :buffer
     expect(result[:stdout]).to eq <<-EOS
 123
     EOS
   end
 
+  it 'does not allow string for numeric option types in action' do
+    cli = Cliqr.interface do
+      name 'my-command'
+      handler TestCommand
+
+      action :bla do
+        option 'age' do
+          type :numeric
+        end
+      end
+    end
+
+    expect do
+      cli.execute_internal %w(bla --age abcd)
+    end.to raise_error(Cliqr::Error::IllegalArgumentError,
+                       "illegal argument error - only values of type 'numeric' allowed for option 'age'")
+  end
+
   it 'does not allow string for numeric option types' do
     cli = Cliqr.interface do
-      basename 'my-command'
+      name 'my-command'
       handler TestCommand
 
-      option 'age' do
+      option :age do
         type :numeric
       end
     end
 
     expect do
-      cli.execute %w(--age abcd)
+      cli.execute_internal %w(--age abcd)
     end.to raise_error(Cliqr::Error::IllegalArgumentError,
                        "illegal argument error - only values of type 'numeric' allowed for option 'age'")
   end
 
   it 'can validate boolean option arguments' do
     cli = Cliqr.interface do
-      basename 'my-command'
+      name 'my-command'
       handler TestOptionReaderCommand
 
       option 'test-option' do
@@ -50,7 +68,7 @@ describe Cliqr::ArgumentValidation::Validator do
       end
     end
 
-    result = cli.execute %w(--test-option), output: :buffer
+    result = cli.execute_internal %w(--test-option), output: :buffer
     expect(result[:stdout]).to eq <<-EOS
 true
     EOS
@@ -58,7 +76,7 @@ true
 
   it 'can validate boolean option argumentswith short name' do
     cli = Cliqr.interface do
-      basename 'my-command'
+      name 'my-command'
       handler TestOptionReaderCommand
 
       option 'test-option' do
@@ -67,7 +85,7 @@ true
       end
     end
 
-    result = cli.execute %w(-t), output: :buffer
+    result = cli.execute_internal %w(-t), output: :buffer
     expect(result[:stdout]).to eq <<-EOS
 true
     EOS
@@ -75,7 +93,7 @@ true
 
   it 'can validate boolean option arguments for false' do
     cli = Cliqr.interface do
-      basename 'my-command'
+      name 'my-command'
       handler TestOptionReaderCommand
 
       option 'test-option' do
@@ -83,7 +101,7 @@ true
       end
     end
 
-    result = cli.execute %w(--no-test-option), output: :buffer
+    result = cli.execute_internal %w(--no-test-option), output: :buffer
     expect(result[:stdout]).to eq <<-EOS
 false
     EOS
@@ -91,7 +109,7 @@ false
 
   it 'does not allow string for boolean option types' do
     cli = Cliqr.interface do
-      basename 'my-command'
+      name 'my-command'
       handler TestCommand
       arguments :disable
 
@@ -101,14 +119,14 @@ false
     end
 
     expect do
-      cli.execute %w(--opt qwe)
-    end.to raise_error(Cliqr::Error::InvalidArgumentError,
+      cli.execute_internal %w(--opt qwe)
+    end.to raise_error(Cliqr::Error::IllegalArgumentError,
                        "invalid command argument \"qwe\"")
   end
 
   it 'allows numeric options to be optional' do
     cli = Cliqr.interface do
-      basename 'my-command'
+      name 'my-command'
       description 'this is an awesome command...try it out'
       handler TestCommand
 
@@ -117,7 +135,7 @@ false
       end
     end
 
-    result = cli.execute [], output: :buffer
+    result = cli.execute_internal [], output: :buffer
     expect(result[:stdout]).to eq <<-EOS
 test command executed
     EOS
@@ -125,7 +143,7 @@ test command executed
 
   it 'allows boolean options to be optional' do
     cli = Cliqr.interface do
-      basename 'my-command'
+      name 'my-command'
       description 'this is an awesome command...try it out'
       handler TestCommand
 
@@ -134,7 +152,7 @@ test command executed
       end
     end
 
-    result = cli.execute [], output: :buffer
+    result = cli.execute_internal [], output: :buffer
     expect(result[:stdout]).to eq <<-EOS
 test command executed
     EOS