cliqr 1.2.0 → 2.0.0

data/lib/cliqr/version.rb

@@ -2,5 +2,5 @@
 
 # Versioned gem
 module Cliqr
-  VERSION = '1.2.0'
+  VERSION = '2.0.0'
 end

data/spec/config/action_config_validator_spec.rb

@@ -3,8 +3,9 @@
 require 'spec_helper'
 
 require 'fixtures/test_command'
+require 'fixtures/test_arg_printer_event_handler'
 
-describe Cliqr::CLI::Config do
+describe Cliqr::Config do
   it 'does not allow multiple actions with same name' do
     def define_interface
       Cliqr.interface do
@@ -91,7 +92,7 @@ describe Cliqr::CLI::Config do
                                                  "action \"my-action\" - invalid value for handler; fix one of - ['handler' cannot be nil]]"))
   end
 
-  it 'only accepts command handler that extend from Cliqr::CLI::Command' do
+  it 'only accepts command handler that extend from Cliqr::Command::BaseCommand' do
     def define_interface
       Cliqr.interface do
         name 'my-command'
@@ -106,7 +107,7 @@ describe Cliqr::CLI::Config do
     expect { define_interface }.to(raise_error(Cliqr::Error::ValidationError,
                                                'invalid Cliqr interface configuration - [' \
                                                  "action \"my-action\" - invalid value for handler; fix one of - [" \
-                                                   "handler of type 'Object' does not extend from 'Cliqr::CLI::Command', " \
+                                                   "handler of type 'Object' does not extend from 'Cliqr::Command::BaseCommand', " \
                                                    "handler should be a 'Proc' not 'Object']]"))
   end
 
@@ -134,13 +135,134 @@ describe Cliqr::CLI::Config do
                   'invalid Cliqr interface configuration - [' \
                     "value for 'name' must match /^[a-zA-Z0-9_\\-]+$/; actual: \"invalid-name-!@#\", " \
                     'invalid value for handler; fix one of - [' \
-                      "handler of type 'Object' does not extend from 'Cliqr::CLI::Command', " \
+                      "handler of type 'Object' does not extend from 'Cliqr::Command::BaseCommand', " \
                       "handler should be a 'Proc' not 'Object'], " \
                     "action \"my-action\" - invalid value for handler; fix one of - [" \
-                      "handler of type 'Object' does not extend from 'Cliqr::CLI::Command', " \
+                      "handler of type 'Object' does not extend from 'Cliqr::Command::BaseCommand', " \
                       "handler should be a 'Proc' not 'Object'], " \
                     "action \"my-action\" - actions[1] - 'name' cannot be nil, " \
                     "action \"my-action\" - actions[1] - invalid value for handler; fix one of - ['handler' cannot be nil], " \
                     "action \"my-action\" - action \"bla\" - invalid value for handler; fix one of - ['handler' cannot be nil]]"))
   end
+
+  it 'does not allow event without handler' do
+    def define_interface
+      Cliqr.interface do
+        name 'my-command'
+        description 'a command used to test cliqr'
+        on :some_event
+
+        action 'my-action' do
+          on :deep_event
+        end
+      end
+    end
+    expect { define_interface }.to(raise_error(Cliqr::Error::ValidationError,
+                                               'invalid Cliqr interface configuration - [' \
+                                               "event \"some_event\" - invalid value for handler; fix one of - ['handler' cannot be nil], " \
+                                               "action \"my-action\" - event \"deep_event\" - invalid value for handler; fix one of - ['handler' cannot be nil]]"))
+  end
+
+  it 'does not allow event with invalid name' do
+    def define_interface
+      Cliqr.interface do
+        name 'my-command'
+        description 'a command used to test cliqr'
+        on '!@#', TestArgPrinterEventHandler
+      end
+    end
+    expect { define_interface }.to(raise_error(Cliqr::Error::ValidationError,
+                                               'invalid Cliqr interface configuration - [' \
+                                                 "event \"!@#\" - value for 'name' must match /^[a-zA-Z0-9_\\-]+$/; actual: \"!@#\"]"))
+  end
+
+  it 'does not allow event handler class and handler proc at the same time' do
+    def define_interface
+      Cliqr.interface do
+        name 'my-command'
+        description 'a command used to test cliqr'
+        on :some_event, TestArgPrinterEventHandler do
+        end
+      end
+    end
+    expect { define_interface }.to(raise_error(Cliqr::Error::ValidationError,
+                                               'only one of event_class or event_block are allowed'))
+  end
+
+  it 'does not allow event without name' do
+    def define_interface
+      Cliqr.interface do
+        name 'my-command'
+        description 'a command used to test cliqr'
+        on TestArgPrinterEventHandler
+
+        action 'my-action' do
+          on TestArgPrinterEventHandler
+        end
+      end
+    end
+    expect { define_interface }.to(raise_error(Cliqr::Error::ValidationError,
+                                               'invalid Cliqr interface configuration - [' \
+                                                 "events[1] - 'name' cannot be empty, " \
+                                                 "events[1] - invalid value for handler; fix one of - ['handler' cannot be nil], " \
+                                                 "action \"my-action\" - events[1] - 'name' cannot be empty, " \
+                                                 "action \"my-action\" - events[1] - invalid value for handler; fix one of - ['handler' cannot be nil]]"))
+  end
+
+  it 'does not allow event handler of any type other than string or symbol' do
+    def define_interface
+      Cliqr.interface do
+        name 'my-command'
+        description 'a command used to test cliqr'
+        on :base, Object
+
+        action 'my-action' do
+          on :third, []
+        end
+      end
+    end
+    expect { define_interface }.to(raise_error(Cliqr::Error::ValidationError,
+                                               'invalid Cliqr interface configuration - [' \
+                                                 "event \"base\" - invalid value for handler; fix one of - [" \
+                                                   "handler should be a 'Cliqr::Events::Handler' not 'Class', " \
+                                                   "handler should be a 'Proc' not 'Class'], " \
+                                                 "action \"my-action\" - event \"third\" - invalid value for handler; fix one of - [" \
+                                                   "handler should be a 'Cliqr::Events::Handler' not 'Array', " \
+                                                   "handler should be a 'Proc' not 'Array']]"))
+  end
+
+  it 'does not allow invalid name for shell config' do
+    def define_interface
+      Cliqr.interface do
+        name 'my-command'
+
+        shell do
+          name Object
+        end
+      end
+    end
+    expect { define_interface }.to(raise_error(Cliqr::Error::ValidationError,
+                                               'invalid Cliqr interface configuration - [' \
+                                                 "shell - value for 'name' must match /^[a-zA-Z0-9_\\-]+$/; actual: Object]"))
+  end
+
+  it 'validates events inside shell config' do
+    def define_interface
+      Cliqr.interface do
+        name 'test-command'
+
+        shell do
+          on :third, []
+          on TestArgPrinterEventHandler
+        end
+      end
+    end
+    expect { define_interface }.to(raise_error(Cliqr::Error::ValidationError,
+                                               'invalid Cliqr interface configuration - [' \
+                                                 "shell - event \"third\" - invalid value for handler; fix one of - [" \
+                                                   "handler should be a 'Cliqr::Events::Handler' not 'Array', " \
+                                                   "handler should be a 'Proc' not 'Array'], " \
+                                                 "shell - events[2] - 'name' cannot be empty, " \
+                                                 "shell - events[2] - invalid value for handler; fix one of - ['handler' cannot be nil]]"))
+  end
 end

data/spec/config/config_finalize_spec.rb

@@ -2,13 +2,13 @@
 
 require 'spec_helper'
 
-describe Cliqr::CLI::Config do
+describe Cliqr::Config do
   it 'sets proper defaults for unset values' do
-    config = Cliqr::CLI::Config.new
+    config = Cliqr::Config::Command.new
     config.finalize
     expect(config.name).to eq('')
     expect(config.description).to eq('')
     expect(config.handler).to eq(nil)
-    expect(config.options).to eq([])
+    expect(config.options).to eq({})
   end
 end

data/spec/config/config_validator_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 
 require 'fixtures/test_command'
 
-describe Cliqr::CLI::Config do
+describe Cliqr::Config do
   it 'does not allow empty name' do
     expect do
       Cliqr.interface do
@@ -47,40 +47,143 @@ describe Cliqr::CLI::Config do
                                                  "invalid value for handler; fix one of - ['handler' cannot be nil]]"))
   end
 
-  it 'only accepts command handler that extend from Cliqr::CLI::Command' do
-    expect do
+  it 'only accepts command handler that extend from Cliqr::Command::BaseCommand' do
+    def define_interface
       Cliqr.interface do
         name 'my-command'
         handler Object
       end
-    end.to(raise_error(Cliqr::Error::ValidationError,
-                       'invalid Cliqr interface configuration - [' \
-                         'invalid value for handler; fix one of - [' \
-                           "handler of type 'Object' does not extend from 'Cliqr::CLI::Command', " \
-                           "handler should be a 'Proc' not 'Object']]"))
+    end
+
+    expect { define_interface }.to(raise_error(Cliqr::Error::ValidationError,
+                                               'invalid Cliqr interface configuration - [' \
+                                                 'invalid value for handler; fix one of - [' \
+                                                   "handler of type 'Object' does not extend from 'Cliqr::Command::BaseCommand', " \
+                                                   "handler should be a 'Proc' not 'Object']]"))
   end
 
   it 'expects that config options should not be nil' do
-    config = Cliqr::CLI::Config.new
+    config = Cliqr::Config::Command.new
     config.name = 'my-command'
     config.handler = TestCommand
     config.options = nil
     config.finalize
-    expect { Cliqr::CLI::Interface.build(config) }.to(
+    expect { Cliqr::Interface.build(config) }.to(
       raise_error(Cliqr::Error::ValidationError, "invalid Cliqr interface configuration - ['options' cannot be nil]"))
   end
 
   it 'throws multiple errors if more than one issue exists in config' do
-    expect do
+    def define_interface
       Cliqr.interface do
         name 'invalid-name-!@#'
         handler Object
       end
-    end.to(raise_error(Cliqr::Error::ValidationError,
-                       'invalid Cliqr interface configuration - [' \
-                         "value for 'name' must match /^[a-zA-Z0-9_\\-]+$/; actual: \"invalid-name-!@#\", " \
-                         'invalid value for handler; fix one of - [' \
-                           "handler of type 'Object' does not extend from 'Cliqr::CLI::Command', " \
-                           "handler should be a 'Proc' not 'Object']]"))
+    end
+
+    expect { define_interface }.to(raise_error(Cliqr::Error::ValidationError,
+                                               'invalid Cliqr interface configuration - [' \
+                                                 "value for 'name' must match /^[a-zA-Z0-9_\\-]+$/; actual: \"invalid-name-!@#\", " \
+                                                 'invalid value for handler; fix one of - [' \
+                                                   "handler of type 'Object' does not extend from 'Cliqr::Command::BaseCommand', " \
+                                                   "handler should be a 'Proc' not 'Object']]"))
+  end
+
+  it 'expects that shell be non-nil for command config' do
+    config = Cliqr::Config::Command.new
+    config.name = 'my-command'
+    config.handler = TestCommand
+    config.shell = nil
+    config.finalize
+    expect { Cliqr::Interface.build(config) }.to(
+      raise_error(NoMethodError, "undefined method `valid?' for nil:NilClass"))
+  end
+
+  it 'validates shell enable setting' do
+    def define_interface
+      Cliqr.interface do
+        name 'test-command'
+        handler TestCommand
+        shell Object
+      end
+    end
+    expect { define_interface }.to(raise_error(Cliqr::Error::ValidationError,
+                                               "invalid Cliqr interface configuration - [shell - invalid type 'Object']"))
+  end
+
+  it 'validates shell enable and prompt setting' do
+    def define_interface
+      Cliqr.interface do
+        name 'test-command'
+        handler TestCommand
+        shell do
+          prompt Object
+        end
+      end
+    end
+    expect { define_interface }.to(raise_error(Cliqr::Error::ValidationError,
+                                               'invalid Cliqr interface configuration - [' \
+                                                 'shell - invalid value for prompt; fix one of - [' \
+                                                   "prompt of type 'Class' does not extend from 'Cliqr::Command::ShellPromptBuilder', " \
+                                                   "prompt should be a 'Proc' not 'Class', " \
+                                                   "prompt should be a 'String' not 'Class']]"))
+  end
+
+  it 'validates shell banner to be a string' do
+    def define_interface
+      Cliqr.interface do
+        name 'test-command'
+        handler TestCommand
+        shell do
+          banner Object
+        end
+      end
+    end
+    expect { define_interface }.to(raise_error(Cliqr::Error::ValidationError, \
+                                               'invalid Cliqr interface configuration - [' \
+                                                 'shell - invalid value for banner; fix one of - [' \
+                                                   "banner of type 'Class' does not extend from 'Cliqr::Command::ShellBannerBuilder', " \
+                                                   "banner should be a 'Proc' not 'Class', " \
+                                                   "banner should be a 'String' not 'Class']]"))
+  end
+
+  it 'does not allow anything except :enable or :disable for color' do
+    def define_interface
+      Cliqr.interface do
+        name 'my-command'
+        color Object
+      end
+    end
+    expect { define_interface }.to(raise_error(Cliqr::Error::ValidationError,
+                                               "invalid Cliqr interface configuration - [invalid type 'Object']"))
+  end
+
+  it 'validates options inside shell config' do
+    def define_interface
+      Cliqr.interface do
+        name 'test-command'
+        handler TestCommand
+        shell do
+          option :foo do
+            type :blah
+          end
+
+          option :bar do
+            short ''
+          end
+
+          option nil do
+            operator Object
+          end
+        end
+      end
+    end
+    expect { define_interface }.to(raise_error(Cliqr::Error::ValidationError,
+                                               'invalid Cliqr interface configuration - [' \
+                                                 "shell - option \"foo\" - invalid type 'blah', " \
+                                                 "shell - option \"bar\" - 'short' cannot be empty, " \
+                                                 "shell - options[3] - 'name' cannot be nil, " \
+                                                 'shell - options[3] - invalid value for operator; fix one of - [' \
+                                                   "operator of type 'Object' does not extend from 'Cliqr::Command::ArgumentOperator', " \
+                                                   "operator should be a 'Proc' not 'Object']]"))
   end
 end

data/spec/config/option_config_validator_spec.rb

@@ -2,7 +2,7 @@
 
 require 'fixtures/test_command'
 
-describe Cliqr::CLI::OptionConfig do
+describe Cliqr::Config::Option do
   it 'does not allow multiple options with same long name' do
     expect do
       Cliqr.interface do

data/spec/dsl/interface_spec.rb

@@ -4,10 +4,10 @@ require 'spec_helper'
 
 require 'fixtures/test_command'
 
-describe Cliqr::CLI::Interface do
+describe Cliqr::Interface do
   it 'does not allow empty config' do
     expect do
-      Cliqr::CLI::Interface.build(nil)
+      Cliqr::Interface.build(nil)
     end.to(raise_error(Cliqr::Error::ConfigNotFound, 'a valid config should be defined'))
   end
 

data/spec/dsl/usage_spec.rb

@@ -3,62 +3,88 @@
 require 'spec_helper'
 
 require 'fixtures/test_command'
-require 'fixtures/action_reader_command'
-require 'fixtures/csv_argument_operator'
-
-describe Cliqr::CLI::UsageBuilder do
-  ################ BASE COMMAND ################
-
-  it 'builds a base command with name' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      description 'a command used to test cliqr'
-      handler TestCommand
-      arguments :disable
-      help :disable
-    end
 
-    expect(cli.usage).to eq <<-EOS
+describe Cliqr::Usage::UsageBuilder do
+  describe 'base command' do
+    it 'builds a base command with name' do
+      cli = Cliqr.interface do
+        name 'my-command'
+        description 'a command used to test cliqr'
+        handler TestCommand
+        arguments :disable
+        help :disable
+        color :disable
+      end
+
+      expect(cli.usage).to eq <<-EOS
 my-command -- a command used to test cliqr
 
 USAGE:
     my-command
-    EOS
-  end
-
-  it 'only makes name and handler to be required' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      handler TestCommand
-      arguments :disable
-      help :disable
+      EOS
     end
 
-    expect(cli.usage).to eq <<-EOS
+    it 'only makes name and handler to be required' do
+      cli = Cliqr.interface do
+        name 'my-command'
+        handler TestCommand
+        arguments :disable
+        help :disable
+        color :disable
+      end
+
+      expect(cli.usage).to eq <<-EOS
 my-command
 
 USAGE:
     my-command
-    EOS
-  end
+      EOS
+    end
+
+    it 'can add version to base command' do
+      cli = Cliqr.interface do
+        name 'my-command'
+        version '1234'
+        color :disable
+      end
+      result = cli.execute_internal %w(help), output: :buffer
+      expect(result[:stdout]).to eq <<-EOS
+my-command
+
+USAGE:
+    my-command [actions] [options] [arguments]
 
-  ################ OPTION ################
+Available options:
 
-  it 'allows options for a command' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      description 'a command used to test cliqr'
-      handler TestCommand
-      arguments :disable
-      help :disable
+    --help, -h  :  Get helpful information for action "my-command" along with its usage information.
+    --version, -v  :  Get version information for command "my-command".
 
-      option 'option-1' do
-        short 'p'
-        description 'a nice option to have'
-      end
+Available actions:
+[ Type "my-command help [action-name]" to get more information about that action ]
+
+    help -- The help action for command "my-command" which provides details and usage information on how to use the command.
+    version -- Get version information for command "my-command".
+      EOS
     end
+  end
 
-    expect(cli.usage).to eq <<-EOS
+  describe 'options' do
+    it 'allows options for a command' do
+      cli = Cliqr.interface do
+        name 'my-command'
+        description 'a command used to test cliqr'
+        handler TestCommand
+        arguments :disable
+        help :disable
+        color :disable
+
+        option 'option-1' do
+          short 'p'
+          description 'a nice option to have'
+        end
+      end
+
+      expect(cli.usage).to eq <<-EOS
 my-command -- a command used to test cliqr
 
 USAGE:
@@ -67,21 +93,22 @@ USAGE:
 Available options:
 
     --option-1, -p  :  a nice option to have
-    EOS
-  end
+      EOS
+    end
 
-  it 'allows command options to optionally have description, type and short name' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      description 'a command used to test cliqr'
-      handler TestCommand
-      arguments :disable
-      help :disable
+    it 'allows command options to optionally have description, type and short name' do
+      cli = Cliqr.interface do
+        name 'my-command'
+        description 'a command used to test cliqr'
+        handler TestCommand
+        arguments :disable
+        help :disable
+        color :disable
 
-      option 'option-1'
-    end
+        option 'option-1'
+      end
 
-    expect(cli.usage).to eq <<-EOS
+      expect(cli.usage).to eq <<-EOS
 my-command -- a command used to test cliqr
 
 USAGE:
@@ -90,41 +117,41 @@ USAGE:
 Available options:
 
     --option-1
-    EOS
-  end
+      EOS
+    end
 
-  it 'has options if added during build phase' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      description 'a command used to test cliqr'
-      handler TestCommand
+    it 'has options if added during build phase' do
+      cli = Cliqr.interface do
+        name 'my-command'
+        description 'a command used to test cliqr'
+        handler TestCommand
 
-      option 'option-1' do
-        short 'p'
-        description 'a nice option to have'
+        option 'option-1' do
+          short 'p'
+          description 'a nice option to have'
+        end
       end
+      expect(cli.config.options?).to be_truthy
     end
-    expect(cli.config.options?).to be_truthy
-  end
-
-  ################ OPTION TYPES ################
 
-  it 'allows command options to have a numeric value type' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      description 'a command used to test cliqr'
-      handler TestCommand
-      arguments :disable
-      help :disable
+    describe 'types' do
+      it 'allows command options to have a numeric value type' do
+        cli = Cliqr.interface do
+          name 'my-command'
+          description 'a command used to test cliqr'
+          handler TestCommand
+          arguments :disable
+          help :disable
+          color :disable
 
-      option 'option-1' do
-        description 'a numeric option'
-        short 'p'
-        type :numeric
-      end
-    end
+          option 'option-1' do
+            description 'a numeric option'
+            short 'p'
+            type :numeric
+          end
+        end
 
-    expect(cli.usage).to eq <<-EOS
+        expect(cli.usage).to eq <<-EOS
 my-command -- a command used to test cliqr
 
 USAGE:
@@ -133,25 +160,26 @@ USAGE:
 Available options:
 
     --option-1, -p  :  <numeric> a numeric option (default => 0)
-    EOS
-  end
-
-  it 'allows command options to have a boolean value type' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      description 'a command used to test cliqr'
-      handler TestCommand
-      arguments :disable
-      help :disable
-
-      option 'option-1' do
-        description 'a boolean option'
-        short 'p'
-        type :boolean
+        EOS
       end
-    end
 
-    expect(cli.usage).to eq <<-EOS
+      it 'allows command options to have a boolean value type' do
+        cli = Cliqr.interface do
+          name 'my-command'
+          description 'a command used to test cliqr'
+          handler TestCommand
+          arguments :disable
+          help :disable
+          color :disable
+
+          option 'option-1' do
+            description 'a boolean option'
+            short 'p'
+            type :boolean
+          end
+        end
+
+        expect(cli.usage).to eq <<-EOS
 my-command -- a command used to test cliqr
 
 USAGE:
@@ -160,24 +188,25 @@ USAGE:
 Available options:
 
     --[no-]option-1, -p  :  <boolean> a boolean option (default => false)
-    EOS
-  end
-
-  it 'allows command options to have a boolean value type and no description' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      description 'a command used to test cliqr'
-      handler TestCommand
-      arguments :disable
-      help :disable
-
-      option 'option-1' do
-        short 'p'
-        type :boolean
+        EOS
       end
-    end
 
-    expect(cli.usage).to eq <<-EOS
+      it 'allows command options to have a boolean value type and no description' do
+        cli = Cliqr.interface do
+          name 'my-command'
+          description 'a command used to test cliqr'
+          handler TestCommand
+          arguments :disable
+          help :disable
+          color :disable
+
+          option 'option-1' do
+            short 'p'
+            type :boolean
+          end
+        end
+
+        expect(cli.usage).to eq <<-EOS
 my-command -- a command used to test cliqr
 
 USAGE:
@@ -186,38 +215,43 @@ USAGE:
 Available options:
 
     --[no-]option-1, -p  :  <boolean> (default => false)
-    EOS
-  end
+        EOS
+      end
+    end
 
-  ################ ARGUMENTS ################
+    describe 'default values' do
+      it 'allows options to have default value' do
+        cli = Cliqr.interface do
+          name 'my-command'
+          handler TestCommand
+          help :disable
+          color :disable
 
-  it 'allows interface to enable arbitrary argument list parsing without options' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      handler TestCommand
-      arguments :enable
-      help :disable
-    end
+          option 'test-option' do
+            default :a_symbol
+          end
 
-    expect(cli.usage).to eq <<-EOS
-my-command
+          option :another do
+            short 'a'
+            description 'another option'
+            type :numeric
+            default %w(test array default)
+          end
 
-USAGE:
-    my-command [arguments]
-    EOS
-  end
+          option 'nil-option' do
+            default nil
+          end
 
-  it 'allows interface to enable arbitrary argument list parsing' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      handler TestCommand
-      arguments :enable
-      help :disable
+          option 'string-option' do
+            default 'string'
+          end
 
-      option 'option-1'
-    end
+          option 'hash-option' do
+            default(:key => 'val')
+          end
+        end
 
-    expect(cli.usage).to eq <<-EOS
+        expect(cli.usage).to eq <<-EOS
 my-command
 
 USAGE:
@@ -225,436 +259,380 @@ USAGE:
 
 Available options:
 
-    --option-1
-    EOS
-  end
-
-  ################ ACTIONS ################
-
-  it 'allows command to have an action' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      handler TestCommand
-      help :disable
-      shell :disable
-
-      action 'my-action' do
-        handler TestCommand
-        arguments :disable
+    --test-option  :  (default => :a_symbol)
+    --another, -a  :  <numeric> another option (default => [\"test\", \"array\", \"default\"])
+    --nil-option
+    --string-option  :  (default => "string")
+    --hash-option  :  (default => {:key=>"val"})
+        EOS
       end
-    end
 
-    expect(cli.usage).to eq <<-EOS
+      it 'boolean option is false by default' do
+        cli = Cliqr.interface do
+          name 'my-command'
+          handler TestCommand
+          help :disable
+          color :disable
+
+          option :another do
+            short 'a'
+            description 'another option'
+            type :boolean
+          end
+        end
+
+        expect(cli.usage).to eq <<-EOS
 my-command
 
 USAGE:
-    my-command [actions] [arguments]
-
-Available actions:
-
-    my-action
-    EOS
-  end
+    my-command [options] [arguments]
 
-  it 'allows command to have an action with description' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      handler TestCommand
-      help :disable
-      shell :disable
+Available options:
 
-      action 'my-action' do
-        handler TestCommand
-        description 'this is a test action'
-        arguments :disable
+    --[no-]another, -a  :  <boolean> another option (default => false)
+        EOS
       end
-    end
 
-    expect(cli.usage).to eq <<-EOS
+      it 'numeric option is 0 by default' do
+        cli = Cliqr.interface do
+          name 'my-command'
+          handler TestCommand
+          help :disable
+          color :disable
+
+          option :another do
+            short 'a'
+            description 'another option'
+            type :numeric
+          end
+        end
+
+        expect(cli.usage).to eq <<-EOS
 my-command
 
 USAGE:
-    my-command [actions] [arguments]
-
-Available actions:
-
-    my-action -- this is a test action
-    EOS
-  end
+    my-command [options] [arguments]
 
-  it 'allows command to have an action and an option' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      handler TestCommand
-      help :disable
-      shell :disable
+Available options:
 
-      action 'my-action' do
-        handler TestCommand
-        description 'this is a test action'
-        arguments :disable
+    --another, -a  :  <numeric> another option (default => 0)
+        EOS
       end
 
-      option 'option-1'
-    end
+      it 'boolean option can be made default true' do
+        cli = Cliqr.interface do
+          name 'my-command'
+          handler TestCommand
+          help :disable
+          color :disable
+
+          option :another do
+            short 'a'
+            description 'another option'
+            type :boolean
+            default true
+          end
+        end
 
-    expect(cli.usage).to eq <<-EOS
+        expect(cli.usage).to eq <<-EOS
 my-command
 
 USAGE:
-    my-command [actions] [options] [arguments]
+    my-command [options] [arguments]
 
 Available options:
 
-    --option-1
-
-Available actions:
-
-    my-action -- this is a test action
-    EOS
+    --[no-]another, -a  :  <boolean> another option (default => true)
+        EOS
+      end
+    end
   end
 
-  it 'allows command to have an action with options' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      handler TestCommand
-      help :disable
-      shell :disable
-
-      action 'my-action' do
+  describe 'arguments' do
+    it 'allows interface to enable arbitrary argument list parsing without options' do
+      cli = Cliqr.interface do
+        name 'my-command'
         handler TestCommand
-        description 'this is a test action'
-
-        option 'action-option'
+        arguments :enable
+        help :disable
+        color :disable
       end
 
-      option 'option-1'
-    end
-
-    expect(cli.usage).to eq <<-EOS
+      expect(cli.usage).to eq <<-EOS
 my-command
 
 USAGE:
-    my-command [actions] [options] [arguments]
-
-Available options:
-
-    --option-1
-
-Available actions:
-
-    my-action -- this is a test action
-    EOS
-  end
-
-  it 'allows command to have multiple actions and multiple options' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      handler TestCommand
-      help :disable
-      shell :disable
-
-      option 'option-1'
+    my-command [arguments]
+      EOS
+    end
 
-      action 'my-action' do
+    it 'allows interface to enable arbitrary argument list parsing' do
+      cli = Cliqr.interface do
+        name 'my-command'
         handler TestCommand
-        description 'this is a test action'
-
-        option 'action-option'
-      end
-
-      option 'option-2'
+        arguments :enable
+        help :disable
+        color :disable
 
-      action 'another-action' do
-        handler TestCommand
-        description 'this is another test action'
-        arguments :disable
+        option 'option-1'
       end
 
-      option 'option-3'
-    end
-
-    expect(cli.usage).to eq <<-EOS
+      expect(cli.usage).to eq <<-EOS
 my-command
 
 USAGE:
-    my-command [actions] [options] [arguments]
+    my-command [options] [arguments]
 
 Available options:
 
     --option-1
-    --option-2
-    --option-3
-
-Available actions:
-
-    my-action -- this is a test action
-
-    another-action -- this is another test action
-    EOS
+      EOS
+    end
   end
 
-  it 'allows nested actions with a mix of same options and same names' do
-    def define_interface
-      Cliqr.interface do
+  describe 'actions' do
+    it 'allows command to have an action' do
+      cli = Cliqr.interface do
         name 'my-command'
         handler TestCommand
         help :disable
         shell :disable
+        color :disable
 
-        option 'test-option-1'
-        option 'test-option-2'
+        action 'my-action' do
+          arguments :disable
+        end
+      end
 
-        action 'my-action-1' do
-          handler ActionReaderCommand
+      expect(cli.usage).to eq <<-EOS
+my-command
 
-          action 'my-action-1' do
-            handler ActionReaderCommand
+USAGE:
+    my-command [actions] [arguments]
 
-            option 'test-option-1'
-            option 'test-option-2'
+Available actions:
 
-            action 'my-action-1' do
-              handler ActionReaderCommand
+    my-action
+      EOS
+    end
 
-              option 'test-option-1'
-              option 'test-option-2'
-            end
-          end
-        end
+    it 'allows command to have an action with description' do
+      cli = Cliqr.interface do
+        name 'my-command'
+        handler TestCommand
+        help :disable
+        shell :disable
+        color :disable
 
-        action 'another-action' do
-          handler ActionReaderCommand
+        action 'my-action' do
+          description 'this is a test action'
           arguments :disable
         end
       end
-    end
-    expect(define_interface.usage).to eq <<-EOS
+
+      expect(cli.usage).to eq <<-EOS
 my-command
 
 USAGE:
-    my-command [actions] [options] [arguments]
-
-Available options:
-
-    --test-option-1
-    --test-option-2
+    my-command [actions] [arguments]
 
 Available actions:
 
-    my-action-1
+    my-action -- this is a test action
+      EOS
+    end
 
-    another-action
-    EOS
-  end
+    it 'cannot add version to action' do
+      def define_interface
+        Cliqr.interface do
+          name 'my-command'
 
-  ################ DEFAULT OPTION VALUES ################
+          action :bla do
+            version '1234'
+          end
+        end
+      end
+      expect { define_interface }.to(raise_error(NoMethodError))
+    end
 
-  it 'allows options to have default value' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      handler TestCommand
-      help :disable
+    describe 'shell action' do
+      it 'adds shell action to the base command only when there are sub actions' do
+        cli = Cliqr.interface do
+          name 'my-command'
+          handler TestCommand
+          help :disable
+          color :disable
 
-      option 'test-option' do
-        default :a_symbol
-      end
+          action :bla
+        end
 
-      option :another do
-        short 'a'
-        description 'another option'
-        type :numeric
-        default %w(test array default)
+        expect(cli.usage).to eq <<-EOS
+my-command
 
-        operator CSVArgumentOperator
-      end
+USAGE:
+    my-command [actions] [arguments]
 
-      option 'nil-option' do
-        default nil
-      end
+Available actions:
 
-      option 'string-option' do
-        default 'string'
+    bla
+    shell -- Execute a shell in the context of "my-command" command.
+        EOS
       end
 
-      option 'hash-option' do
-        default(:key => 'val')
-      end
-    end
+      it 'does not add shell action to the base command if it does not have actions' do
+        cli = Cliqr.interface do
+          name 'my-command'
+          handler TestCommand
+          help :disable
+          color :disable
+        end
 
-    expect(cli.usage).to eq <<-EOS
+        expect(cli.usage).to eq <<-EOS
 my-command
 
 USAGE:
-    my-command [options] [arguments]
-
-Available options:
+    my-command [arguments]
+        EOS
+      end
 
-    --test-option  :  (default => :a_symbol)
-    --another, -a  :  <numeric> another option (default => [\"test\", \"array\", \"default\"])
-    --nil-option
-    --string-option  :  (default => "string")
-    --hash-option  :  (default => {:key=>"val"})
-    EOS
-  end
+      it 'can not add shell action to a sub-action' do
+        def define_interface
+          Cliqr.interface do
+            name 'my-command'
 
-  it 'boolean option is false by default' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      handler TestCommand
-      help :disable
+            action :bla do
+              shell :enable
+            end
+          end
+        end
+        expect { define_interface }.to(raise_error(NoMethodError))
+      end
 
-      option :another do
-        short 'a'
-        description 'another option'
-        type :boolean
+      it 'can name a shell action as something else' do
+        cli = Cliqr.interface do
+          name 'my-command'
+          handler TestCommand
+          color :disable
 
-        operator CSVArgumentOperator
-      end
-    end
+          shell do
+            name 'my-custom-shell'
+            description 'this is a custom shell implementation'
+          end
+        end
 
-    expect(cli.usage).to eq <<-EOS
+        expect(cli.usage).to eq <<-EOS
 my-command
 
 USAGE:
-    my-command [options] [arguments]
+    my-command [actions] [options] [arguments]
 
 Available options:
 
-    --[no-]another, -a  :  <boolean> another option (default => false)
-    EOS
-  end
-
-  it 'numeric option is 0 by default' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      handler TestCommand
-      help :disable
+    --help, -h  :  Get helpful information for action "my-command" along with its usage information.
 
-      option :another do
-        short 'a'
-        description 'another option'
-        type :numeric
+Available actions:
+[ Type "my-command help [action-name]" to get more information about that action ]
 
-        operator CSVArgumentOperator
+    help -- The help action for command "my-command" which provides details and usage information on how to use the command.
+    my-custom-shell -- this is a custom shell implementation
+        EOS
       end
     end
-
-    expect(cli.usage).to eq <<-EOS
-my-command
-
-USAGE:
-    my-command [options] [arguments]
-
-Available options:
-
-    --another, -a  :  <numeric> another option (default => 0)
-    EOS
   end
 
-  it 'boolean option can be made default true' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      handler TestCommand
-      help :disable
+  describe 'actions and options' do
+    it 'allows command to have an action and an option' do
+      cli = Cliqr.interface do
+        name 'my-command'
+        handler TestCommand
+        help :disable
+        shell :disable
+        color :disable
 
-      option :another do
-        short 'a'
-        description 'another option'
-        type :boolean
-        default true
+        action 'my-action' do
+          description 'this is a test action'
+          arguments :disable
+        end
 
-        operator CSVArgumentOperator
+        option 'option-1'
       end
-    end
 
-    expect(cli.usage).to eq <<-EOS
+      expect(cli.usage).to eq <<-EOS
 my-command
 
 USAGE:
-    my-command [options] [arguments]
+    my-command [actions] [options] [arguments]
 
 Available options:
 
-    --[no-]another, -a  :  <boolean> another option (default => true)
-    EOS
-  end
-
-  ################ SHELL ACTION ################
+    --option-1
 
-  it 'adds shell action to the base command only when there are sub actions' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      handler TestCommand
-      help :disable
+Available actions:
 
-      action :bla
+    my-action -- this is a test action
+      EOS
     end
 
-    expect(cli.usage).to eq <<-EOS
-my-command
-
-USAGE:
-    my-command [actions] [arguments]
-
-Available actions:
+    it 'allows command to have an action with options' do
+      cli = Cliqr.interface do
+        name 'my-command'
+        handler TestCommand
+        help :disable
+        shell :disable
+        color :disable
 
-    bla
+        action 'my-action' do
+          description 'this is a test action'
 
-    shell -- Execute a shell in the context of "my-command" command.
-    EOS
-  end
+          option 'action-option'
+        end
 
-  it 'does not add shell action to the base command if it does not have actions' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      handler TestCommand
-      help :disable
-    end
+        option 'option-1'
+      end
 
-    expect(cli.usage).to eq <<-EOS
+      expect(cli.usage).to eq <<-EOS
 my-command
 
 USAGE:
-    my-command [arguments]
-    EOS
-  end
+    my-command [actions] [options] [arguments]
+
+Available options:
 
-  it 'can add shell action to a sub-action which does not have actions' do
-    cli = Cliqr.interface do
-      name 'my-command'
+    --option-1
 
-      action :bla do
-        shell :enable
-      end
+Available actions:
+
+    my-action -- this is a test action
+      EOS
     end
-    result = cli.execute_internal %w(my-command bla), output: :buffer
-    expect(result[:stdout]).to eq <<-EOS
-my-command bla
 
-USAGE:
-    my-command bla [actions] [options] [arguments]
+    it 'allows command to have multiple actions and multiple options' do
+      cli = Cliqr.interface do
+        name 'my-command'
+        handler TestCommand
+        help :disable
+        shell :disable
+        color :disable
 
-Available options:
+        option 'option-1'
 
-    --help, -h  :  Get helpful information for action "my-command bla" along with its usage information.
+        action 'my-action' do
+          description 'this is a test action'
 
-Available actions:
-[ Type "my-command bla help [action-name]" to get more information about that action ]
+          option 'action-option'
+        end
 
-    shell -- Execute a shell in the context of "my-command bla" command.
+        option 'option-2'
 
-    help -- The help action for command "my-command bla" which provides details and usage information on how to use the command.
-    EOS
-  end
+        action 'another-action' do
+          description 'this is another test action'
+          arguments :disable
+        end
 
-  it 'can add version to base command' do
-    cli = Cliqr.interface do
-      name 'my-command'
-      version '1234'
-    end
-    result = cli.execute_internal %w(help), output: :buffer
-    expect(result[:stdout]).to eq <<-EOS
+        option 'option-3'
+      end
+
+      expect(cli.usage).to eq <<-EOS
 my-command
 
 USAGE:
@@ -662,44 +640,62 @@ USAGE:
 
 Available options:
 
-    --version, -v  :  Get version information for command "my-command".
-    --help, -h  :  Get helpful information for action "my-command" along with its usage information.
+    --option-1
+    --option-2
+    --option-3
 
 Available actions:
-[ Type "my-command help [action-name]" to get more information about that action ]
 
-    version -- Get version information for command "my-command".
+    my-action -- this is a test action
+    another-action -- this is another test action
+      EOS
+    end
 
-    help -- The help action for command "my-command" which provides details and usage information on how to use the command.
-    EOS
-  end
+    it 'allows nested actions with a mix of same options and same names' do
+      def define_interface
+        Cliqr.interface do
+          name 'my-command'
+          handler TestCommand
+          help :disable
+          shell :disable
+          color :disable
 
-  it 'can add version to any action' do
-    cli = Cliqr.interface do
-      name 'my-command'
+          option 'test-option-1'
+          option 'test-option-2'
 
-      action :bla do
-        version '1234'
+          action 'my-action-1' do
+            action 'my-action-1' do
+              option 'test-option-1'
+              option 'test-option-2'
+
+              action 'my-action-1' do
+                option 'test-option-1'
+                option 'test-option-2'
+              end
+            end
+          end
+
+          action 'another-action' do
+            arguments :disable
+          end
+        end
       end
-    end
-    result = cli.execute_internal %w(bla help), output: :buffer
-    expect(result[:stdout]).to eq <<-EOS
-my-command bla
+      expect(define_interface.usage).to eq <<-EOS
+my-command
 
 USAGE:
-    my-command bla [actions] [options] [arguments]
+    my-command [actions] [options] [arguments]
 
 Available options:
 
-    --version, -v  :  Get version information for command "my-command bla".
-    --help, -h  :  Get helpful information for action "my-command bla" along with its usage information.
+    --test-option-1
+    --test-option-2
 
 Available actions:
-[ Type "my-command bla help [action-name]" to get more information about that action ]
-
-    version -- Get version information for command "my-command bla".
 
-    help -- The help action for command "my-command bla" which provides details and usage information on how to use the command.
-    EOS
+    my-action-1
+    another-action
+      EOS
+    end
   end
 end