gli 2.12.0 → 2.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e3051959ac78b44c2e6c7d8be0701aebcb375700
-  data.tar.gz: 5ef912011fd093bf0afc55b7642d7eaa85f84d4f
+  metadata.gz: 740fe97d64c94c7962a740ec92d11c677ccfde7f
+  data.tar.gz: d4d3801f9a9dab26bff27b0cb49754ae383040c1
 SHA512:
-  metadata.gz: 464e43336b07485f3824dbacdeb8fbe5f5ebce4bd41af6f2dbc06406560b6c1b2d4b6ea1dc413de364ddba2d0d37576e121dcc0bebf962fef2f4d1c57221f4d8
-  data.tar.gz: 03296c0c993306c51903bc142cd8478348cd616aa735b4799c27dfb7b53bd048e115b32434644c3462f63742bd4b46730cb227936baafbef7ceed4d0bf9ad62b
+  metadata.gz: ea0caedb0cc36eca2d59f29281bb8720615815cc10eadfdfa9b8537510a5432636ad5ef31418e8eead58d5ed578e88ae792462f3ce81850bc968c5ca527a5f14
+  data.tar.gz: 89c5d72a1bd8576518b72e70b12fc12363a14aa0c6bd539495628c5af6efbb1e81596463cab37f8640f9c0d38864a4cb8b6d1a10c56995466d5d67f44feb2995

data/.ruby-version

@@ -1 +1 @@
-2.0.0
+ruby-2.1

data/.travis.yml

@@ -6,7 +6,7 @@ rvm:
   - 1.9.3
   - 1.8.7
   - 2.0.0
-  - 2.1.0
+  - 2.1
 branches:
   only:
     - 'gli-2'

data/lib/gli/app.rb

@@ -291,9 +291,13 @@ module GLI
       @subcommand_option_handling_strategy = handling_strategy
     end
 
-    # How to handle argument validation. Either +:loose+ (which does not validate argument at all)
-    # or +:strict+ (which will validate the number of arguments).
-    # If nothing is specified, +:loose+ is assumed
+    # How to handle argument validation. 
+    #
+    # handling_strategy:: One of:
+    #                     +:loose+:: no argument validation.  Use of `arg` or `arg_name` is for documentation purposes only.  (Default)
+    #                     +:strict+:: arguments are validated according to their specification.  +action+ blocks may assume
+    #                                 the value of `arguments` matches the specification provided in `arg`.  Note that to use
+    #                                 this strategy, you must also be sure that +subcommand_option_handling+ is set.
     def arguments(handling_strategy)
       @argument_handling_strategy = handling_strategy
     end

data/lib/gli/commands/scaffold.rb

@@ -284,7 +284,7 @@ program_desc 'Describe your application here'
 
 version #{project_name_as_module_name(project_name)}::VERSION
 
-# Use argument validation
+subcommand_option_handling :normal
 arguments :strict
 
 desc 'Describe some switch here'

data/lib/gli/gli_option_parser.rb

@@ -7,6 +7,9 @@ module GLI
       @accepts              = accepts
       @subcommand_option_handling_strategy = subcommand_option_handling_strategy
       @argument_handling_strategy = argument_handling_strategy
+      if @argument_handling_strategy == :strict && @subcommand_option_handling_strategy != :normal
+        raise ArgumentError, "To use strict argument handling, you must enable normal subcommand_option_handling, e.g. subcommand_option_handling :normal"
+      end
     end
 
     # Given the command-line argument array, returns an OptionParsingResult

data/lib/gli/version.rb

@@ -1,5 +1,5 @@
 module GLI
   unless const_defined? :VERSION
-    VERSION = '2.12.0'
+    VERSION = '2.12.1'
   end
 end

data/test/tc_subcommand_parsing.rb

@@ -83,41 +83,62 @@ class TC_testSubCommandParsing < Clean::Test::TestCase
     When :run_app_with_X_arguments, 0
     Then {
       with_clue {
-        assert_equal 0, @results[:nbargs]
+        assert_equal 0, @results[:number_of_args_give_to_action]
         assert_equal 0, @exit_code
       }
     }
   end
 
+  test_that "in strict mode, subcommand_option_handling must be normal" do
+    Given :app_with_arguments, 1, 1, false, :strict, :legacy
+    When :run_app_with_X_arguments, 1
+    Then {
+      with_clue {
+        assert_nil      @results[:number_of_args_give_to_action]
+        assert_equal 1, @exit_code
+        assert          @fake_stderr.contained?(/you must enable normal subcommand_option_handling/)
+      }
+    }
+  end
+
   ix = -1
   [
-    [1, 1, false, 0, :not_enough],   [1, 1, false, 1, :success],
-    [1, 1, false, 2, :success],      [1, 1, false, 3, :too_many],
-    [1, 1, true, 0, :not_enough],    [1, 1, true, 1, :success],
-    [1, 1, true, 2, :success],       [1, 1, true, 3, :success],
-    [1, 1, true, 30, :success],      [0, 0, false, 0, :success],
-    [0, 0, false, 1, :too_many],     [0, 1, false, 1, :success],
-    [0, 1, false, 0, :success],      [1, 0, false, 1, :success],
-    [1, 0, false, 0, :not_enough],   [0, 0, true, 0, :success],
-    [0, 0, true, 10, :success]
-  ].each do |nb_required, nb_optional, has_multiple, nb_generated, status|
+    [1 , 1 , false , 0  , :not_enough] ,
+    [1 , 1 , false , 1  , :success]    ,
+    [1 , 1 , false , 2  , :success]    ,
+    [1 , 1 , false , 3  , :too_many]   ,
+    [1 , 1 , true  , 0  , :not_enough] ,
+    [1 , 1 , true  , 1  , :success]    ,
+    [1 , 1 , true  , 2  , :success]    ,
+    [1 , 1 , true  , 3  , :success]    ,
+    [1 , 1 , true  , 30 , :success]    ,
+    [0 , 0 , false , 0  , :success]    ,
+    [0 , 0 , false , 1  , :too_many]   ,
+    [0 , 1 , false , 1  , :success]    ,
+    [0 , 1 , false , 0  , :success]    ,
+    [1 , 0 , false , 1  , :success]    ,
+    [1 , 0 , false , 0  , :not_enough] ,
+    [0 , 0 , true  , 0  , :success]    ,
+    [0 , 0 , true  , 10 , :success]
+
+  ].each do |number_required, number_optional, has_multiple, number_generated, status|
     ix = ix + 1
-    test_that "in strict mode, number of arguments is validated -- #{ix}" do
-      Given :app_with_arguments, nb_required, nb_optional, has_multiple, :strict
-      When :run_app_with_X_arguments, nb_generated
+    test_that "in strict mode, with #{number_required} required, #{number_optional} optional, #{ has_multiple ? 'multiple' : 'not multiple' } and #{number_generated} generated, it should be #{status}" do
+      Given :app_with_arguments, number_required, number_optional, has_multiple, :strict
+      When :run_app_with_X_arguments, number_generated
       Then {
         with_clue {
           if status == :success then
-            assert_equal nb_generated, @results[:nbargs]
+            assert_equal number_generated, @results[:number_of_args_give_to_action]
             assert_equal 0, @exit_code
             assert !@fake_stderr.contained?(/Not enough arguments for command/)
             assert !@fake_stderr.contained?(/Too many arguments for command/)
           elsif status == :not_enough then
-            assert_equal nil, @results[:nbargs]
+            assert_equal nil, @results[:number_of_args_give_to_action]
             assert_equal 64, @exit_code
             assert @fake_stderr.contained?(/Not enough arguments for command/)
           elsif status == :too_many then
-            assert_equal nil, @results[:nbargs]
+            assert_equal nil, @results[:number_of_args_give_to_action]
             assert_equal 64, @exit_code
             assert @fake_stderr.contained?(/Too many arguments for command/)
           else
@@ -176,24 +197,24 @@ private
     end
   end
 
-  def app_with_arguments(nb_required_arguments, nb_optional_arguments, has_argument_multiple, arguments_handling_strategy = :loose)
+  def app_with_arguments(number_required_arguments, number_optional_arguments, has_argument_multiple, arguments_handling_strategy = :loose, subcommand_option_handling_strategy = :normal)
     @app.arguments arguments_handling_strategy
-    @app.subcommand_option_handling :normal
+    @app.subcommand_option_handling subcommand_option_handling_strategy
 
-    nb_required_arguments.times { |i| @app.arg("needed#{i}") }
-    nb_optional_arguments.times { |i| @app.arg("optional#{i}", :optional) }
+    number_required_arguments.times { |i| @app.arg("needed#{i}") }
+    number_optional_arguments.times { |i| @app.arg("optional#{i}", :optional) }
     @app.arg :multiple, [:multiple, :optional] if has_argument_multiple
 
     @app.command :cmd do |c|
       c.action do |g,o,a|
         @results = {
-          :nbargs => a.size
+          :number_of_args_give_to_action => a.size
         }
       end
     end
   end
 
-  def run_app_with_X_arguments(nb_arguments)
-    @exit_code = @app.run [].tap{|args| args << "cmd"; nb_arguments.times {|i| args << "arg#{i}"}}
+  def run_app_with_X_arguments(number_arguments)
+    @exit_code = @app.run [].tap{|args| args << "cmd"; number_arguments.times {|i| args << "arg#{i}"}}
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gli
 version: !ruby/object:Gem::Version
-  version: 2.12.0
+  version: 2.12.1
 platform: ruby
 authors:
 - David Copeland
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-29 00:00:00.000000000 Z
+date: 2014-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake