gli 2.19.2 → 2.20.0

data/features/todo_legacy.feature

@@ -1,130 +0,0 @@
-Feature: The todo app is backwards compatible with legacy subcommand parsing
-  As a user of GLI
-  My apps with subcommands should support the old, legacy way, by default
-
-  Background:
-    Given I have GLI installed
-      And GLI's libs are in my path
-      And my terminal size is "80x24"
-      And todo_legacy's bin directory is in my path
-
-  Scenario: Help completion mode for subcommands
-    When I successfully run `todo help -c list`
-    Then the output should contain:
-    """
-    contexts
-    tasks
-    """
-
-  Scenario: Help completion mode partial match for subcommands
-    When I successfully run `todo help -c list con`
-    Then the output should contain:
-    """
-    contexts
-    """
-
-  Scenario Outline: Getting Help for a top level command of todo
-    # No idea why I have to do this again.
-    Given todo_legacy's bin directory is in my path
-    When I successfully run `todo <help_invocation>`
-    Then the output should contain:
-    """
-    NAME
-        list - List things, such as tasks or contexts
-
-    SYNOPSIS
-        todo [global options] list [command options] [tasks] [--flag arg] [-x arg]
-        todo [global options] list [command options] contexts [--otherflag arg] [-b] [-f|--foobar]
-
-    DESCRIPTION
-        List a whole lot of things that you might be keeping track of in your
-        overall todo list.
-
-        This is your go-to place or finding all of the things that you might have
-        stored in your todo databases. 
-
-    COMMAND OPTIONS
-        -l, --[no-]long - Show long form
-
-    COMMANDS
-        contexts - List contexts
-        tasks    - List tasks (default)
-    """
-
-    Examples:
-      | help_invocation |
-      | help list       |
-      | list -h         |
-      | list --help     |
-
-
-  Scenario: Getting Help for a sub command of todo list
-    When I successfully run `todo help list tasks`
-    Then the output should contain:
-    """
-    NAME
-        tasks - List tasks
-
-    SYNOPSIS
-        todo [global options] list tasks [command options] 
-        todo [global options] list tasks [command options] open
-
-    DESCRIPTION
-        Lists all of your tasks that you have, in varying orders, and all that
-        stuff. Yes, this is long, but I need a long description. 
-
-    COMMAND OPTIONS
-        --flag=arg - (default: none)
-        -x arg     - blah blah crud x whatever (default: none)
-    
-    COMMANDS
-        <default> - list all tasks
-        open      - list open tasks
-    """
-
-  Scenario: Getting Help for a sub command with no command options
-    When I successfully run `todo help new`
-    Then the output should contain:
-    """
-    NAME
-        create - Create a new task or context
-
-    SYNOPSIS
-        todo [global options] create 
-        todo [global options] create contexts [context_name]
-        todo [global options] create tasks task_name...
-
-    COMMANDS
-        <default> - Makes a new task
-        contexts  - Make a new context
-        tasks     - Make a new task
-    """
-    And the output should not contain "COMMAND OPTIONS"
-
-  Scenario: Running ls w/out subcommand shows help and an error
-    When I run `todo ls`
-    Then the exit status should not be 0
-    And the stderr should contain "error: Command 'ls' requires a subcommand"
-    And the stdout should contain:
-    """
-    NAME
-        ls - LS things, such as tasks or contexts
-
-    SYNOPSIS
-        todo [global options] ls [command options] contexts [-b] [-f|--foobar]
-        todo [global options] ls [command options] tasks [-x arg]
-
-    DESCRIPTION
-        List a whole lot of things that you might be keeping track of in your
-        overall todo list.
-
-        This is your go-to place or finding all of the things that you might have
-        stored in your todo databases. 
-
-    COMMAND OPTIONS
-        -l, --[no-]long - Show long form
-
-    COMMANDS
-        contexts - List contexts
-        tasks    - List tasks
-    """

data/test/option_test_helper.rb

@@ -1,13 +0,0 @@
-module OptionTestHelper
-  def name_should_be(name)
-    lambda {
-      assert_equal(name,@cli_option.name)
-    }
-  end
-
-  def aliases_should_be(aliases)
-    lambda {
-      assert_equal(aliases,@cli_option.aliases)
-    }
-  end
-end

data/test/tc_compound_command.rb

@@ -1,22 +0,0 @@
-require 'test_helper'
-require 'tempfile'
-
-class TC_testCompounCommand < Clean::Test::TestCase
-  include TestHelper
-
-  test_that "when we create a CompoundCommand where some commands are missing, we get an exception" do
-    Given {
-      @name = any_string
-      @unknown_name = any_string
-      @existing_command = OpenStruct.new(:name => @name)
-      @base = OpenStruct.new( :commands => { @name => @existing_command })
-    }
-    When {
-      @code = lambda { GLI::Commands::CompoundCommand.new(@base,{:foo => [@name,@unknown_name]}) }
-    }
-    Then {
-      ex = assert_raises(RuntimeError,&@code)
-      assert_match /#{@unknown_name}/,ex.message
-    }
-  end
-end

data/test/tc_subcommand_parsing.rb

@@ -1,280 +0,0 @@
-require 'test_helper'
-require 'pp'
-
-class TC_testSubCommandParsing < Clean::Test::TestCase
-  include TestHelper
-
-  def setup
-    @fake_stdout = FakeStdOut.new
-    @fake_stderr = FakeStdOut.new
-
-    @original_stdout = $stdout
-    $stdout = @fake_stdout
-    @original_stderr = $stderr
-    $stderr = @fake_stderr
-
-    @app = CLIApp.new
-    @app.reset
-    @app.subcommand_option_handling :legacy
-    @app.error_device=@fake_stderr
-    ENV.delete('GLI_DEBUG')
-
-    @results = {}
-    @exit_code = 0
-  end
-
-  def teardown
-    $stdout = @original_stdout
-    $stderr = @original_stderr
-  end
-
-  test_that "commands options may clash with globals and it gets sorted out" do
-    Given :app_with_subcommands_storing_results
-    When {
-      @app.run(%w(-f global command1 -f command -s foo))
-    }
-    Then {
-      assert_equal  'command1',@results[:command_name]
-      assert_equal  'global',  @results[:global_options][:f],'global'
-      assert       !@results[:global_options][:s]
-      assert_equal  'command', @results[:command_options][:f]
-      assert        @results[:command_options][:s]
-    }
-  end
-
-  test_that "in legacy mode, subcommand options all share a namespace" do
-    Given :app_with_subcommands_storing_results
-    When {
-      @app.run(%w(-f global command1 -f command -s subcommand10 -f sub))
-    }
-    Then {
-      with_clue {
-        assert_equal  'subcommand10',@results[:command_name]
-        assert_equal  'global',      @results[:global_options][:f],'global'
-        assert       !@results[:global_options][:s]
-        assert_equal  'sub', @results[:command_options][:f]
-        assert        @results[:command_options][:s]
-        assert_nil    @results[:command_options][GLI::Command::PARENT]
-        assert_nil    @results[:command_options][GLI::Command::PARENT]
-      }
-    }
-  end
-
-  test_that "in normal mode, each subcommand has its own namespace" do
-    Given :app_with_subcommands_storing_results, :normal
-    When {
-      @app.run(%w(-f global command1 -f command -s subcommand10 -f sub))
-    }
-    Then {
-      with_clue {
-        assert_equal  'subcommand10',@results[:command_name]
-        assert_equal  'global',      @results[:global_options][:f],'global'
-        assert       !@results[:global_options][:s]
-        assert_equal  'sub', @results[:command_options][:f]
-        assert       !@results[:command_options][:s]
-        assert_equal  'command',@results[:command_options][GLI::Command::PARENT][:f]
-        assert        @results[:command_options][GLI::Command::PARENT][:s]
-      }
-    }
-  end
-
-  test_that "in loose mode with autocomplete false, it doesn't autocorrect a sub command" do
-    Given :app_with_subcommand_storing_results, :normal, false, :loose
-    When {
-      @app.run(%w(-f global command -f flag -s subcomm  -f subflag))
-    }
-    Then {
-      with_clue {
-        assert_equal "command",@results[:command_name]
-      }
-    }
-  end
-
-  test_that "in strict mode with autocomplete false, it doesn't autocorrect a sub command" do
-    Given :app_with_subcommand_storing_results, :normal, false, :strict
-    When {
-      @app.run(%w(-f global command -f flag -s subcomm  -f subflag))
-    }
-    Then {
-      with_clue {
-        assert_equal nil,@results[:command_name]
-        assert       @fake_stderr.contained?(/error: Too many arguments for command/)
-      }
-    }
-  end
-
-  test_that "in loose mode, argument validation is ignored" do
-    Given :app_with_arguments, 1, 1, false, :loose
-    When :run_app_with_X_arguments, 0
-    Then {
-      with_clue {
-        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 |number_required, number_optional, has_multiple, number_generated, status|
-    ix = ix + 1
-    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 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[: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[:number_of_args_give_to_action]
-            assert_equal 64, @exit_code
-            assert @fake_stderr.contained?(/Too many arguments for command/)
-          else
-            assert false
-          end
-        }
-      }
-    end
-  end
-private
-  def with_clue(&block)
-    block.call
-  rescue Exception
-    dump = ""
-    PP.pp "\nRESULTS---#{@results}", dump unless @results.empty?
-    PP.pp "\nSTDERR---\n#{@fake_stderr.to_s}", dump
-    PP.pp "\nSTDOUT---\n#{@fake_stdout.to_s}", dump
-    @original_stdout.puts dump
-    raise
-  end
-
-  def app_with_subcommand_storing_results(subcommand_option_handling_strategy, autocomplete, arguments_handling_strategy)
-    @app.subcommand_option_handling subcommand_option_handling_strategy
-    @app.autocomplete_commands autocomplete
-    @app.arguments arguments_handling_strategy
-    @app.flag ['f','flag']
-    @app.switch ['s','switch']
-
-    @app.command "command" do |c|
-      c.flag ['f','flag']
-      c.switch ['s','switch']
-      c.action do |global,options,args|
-        @results = {
-          :command_name => "command",
-          :global_options => global,
-          :command_options => options,
-          :args => args
-        }
-      end
-
-      c.command "subcommand" do |subcommand|
-        subcommand.flag ['f','flag']
-        subcommand.flag ['foo']
-        subcommand.switch ['s','switch']
-        subcommand.action do |global,options,args|
-          @results = {
-            :command_name => "subcommand",
-            :global_options => global,
-            :command_options => options,
-            :args => args
-          }
-        end
-      end
-    end
-  end
-
-  def app_with_subcommands_storing_results(subcommand_option_handling_strategy = :legacy)
-    @app.subcommand_option_handling subcommand_option_handling_strategy
-    @app.flag ['f','flag']
-    @app.switch ['s','switch']
-
-    2.times do |i|
-      @app.command "command#{i}" do |c|
-        c.flag ['f','flag']
-        c.switch ['s','switch']
-        c.action do |global,options,args|
-          @results = {
-            :command_name => "command#{i}",
-            :global_options => global,
-            :command_options => options,
-            :args => args
-          }
-        end
-
-        2.times do |j|
-          c.command "subcommand#{i}#{j}" do |subcommand|
-            subcommand.flag ['f','flag']
-            subcommand.flag ['foo']
-            subcommand.switch ['s','switch']
-            subcommand.action do |global,options,args|
-              @results = {
-                :command_name => "subcommand#{i}#{j}",
-                :global_options => global,
-                :command_options => options,
-                :args => args
-              }
-            end
-          end
-        end
-      end
-    end
-  end
-
-  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 subcommand_option_handling_strategy
-
-    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 = {
-          :number_of_args_give_to_action => a.size
-        }
-      end
-    end
-  end
-
-  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