gli 2.5.6 → 2.6.0.rc1

data/.travis.yml

@@ -13,3 +13,4 @@ branches:
     - 'master'
     - 'gli-2'
     - 'quick-bugifxes'
+    - 'fully-nested-subcommands'

data/Gemfile

@@ -1,4 +1,4 @@
-source 'http://rubygems.org'
+source 'https://rubygems.org'
 
 gemspec
 

data/features/step_definitions/todo_steps.rb

@@ -1,3 +1,7 @@
+Given /^todo_legacy's bin directory is in my path/ do
+  add_to_path(File.expand_path(File.join(File.dirname(__FILE__),'..','..','test','apps','todo_legacy','bin')))
+end
+
 Given /^todo's bin directory is in my path/ do
   add_to_path(File.expand_path(File.join(File.dirname(__FILE__),'..','..','test','apps','todo','bin')))
 end

data/features/todo.feature

@@ -47,6 +47,7 @@ Feature: The todo app has a nice user interface
         initconfig    - Initialize the config file using current global options
         list          - List things, such as tasks or contexts
         ls            - LS things, such as tasks or contexts
+        make          - 
         second        - 
         third         - 
     """
@@ -59,6 +60,7 @@ Feature: The todo app has a nice user interface
     When I successfully run `todo help -c`
     Then the output should contain:
     """
+    _doc
     ch2
     chained
     chained2
@@ -68,8 +70,10 @@ Feature: The todo app has a nice user interface
     initconfig
     list
     ls
+    make
     new
     second
+    third
     """
 
   Scenario: Help completion mode for partial match
@@ -126,6 +130,7 @@ Feature: The todo app has a nice user interface
         create, new   - Create a new task or context
         list          - List things, such as tasks or contexts
         ls            - LS things, such as tasks or contexts
+        make          - 
         third         - 
         first         - 
         second        - 
@@ -346,6 +351,23 @@ Feature: The todo app has a nice user interface
         tasks    - List tasks
     """
 
+  Scenario: Access to the complex command-line options for nested subcommands
+    Given I run `todo make -l MAKE task -l TASK bug -l BUG other args`
+    Then the exit status should be 0
+    And the stdout should contain:
+    """
+    new task bug
+    other,args
+    BUG
+    
+    BUG
+    TASK
+    TASK
+
+    MAKE
+    MAKE
+
+    """
 
   Scenario: Init Config makes a reasonable config file
     Given a clean home directory

data/features/todo_legacy.feature

@@ -0,0 +1,128 @@
+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
+    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] [--flag arg] [-x arg] [tasks]
+        todo [global options] list [command options] [--otherflag arg] [-b] [-f|--foobar] contexts
+
+    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 [command options] 
+        todo [global options] create [command options]  contexts [context_name]
+        todo [global options] create [command options]  tasks task_name[, 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] [-b] [-f|--foobar] contexts
+        todo [global options] ls [command options] [-x arg] tasks
+
+    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/lib/gli.rb

@@ -1,4 +1,7 @@
+require 'gli/command_finder.rb'
+require 'gli/gli_option_block_parser.rb'
 require 'gli/option_parser_factory.rb'
+require 'gli/option_parsing_result.rb'
 require 'gli/gli_option_parser.rb'
 require 'gli/app_support.rb'
 require 'gli/app.rb'
@@ -6,7 +9,6 @@ require 'gli/command_support.rb'
 require 'gli/command.rb'
 require 'gli/command_line_token.rb'
 require 'gli/command_line_option.rb'
-require 'gli/copy_options_to_aliases.rb'
 require 'gli/exceptions.rb'
 require 'gli/flag.rb'
 require 'gli/options.rb'

data/lib/gli/app.rb

@@ -1,6 +1,5 @@
 require 'etc'
 require 'optparse'
-require 'gli/copy_options_to_aliases'
 require 'gli/dsl'
 require 'pathname'
 
@@ -9,7 +8,6 @@ module GLI
   # Git's does, in that you specify global options, a command name, command
   # specific options, and then command arguments.
   module App
-    include CopyOptionsToAliases
     include DSL
     include AppSupport
 
@@ -261,6 +259,16 @@ module GLI
       @default_command = command.to_sym
     end
 
+    # How to handle subcommand options.  In general, you want to set this to +:normal+, which
+    # treats each subcommand as establishing its own namespace for options.  This is what
+    # the scaffolding should generate, but it is *not* what GLI 2.5.x and lower apps had as a default.
+    # To maintain backwards compatibility, the default is +:legacy+, which is that all subcommands of
+    # a particular command share a namespace for options, making it impossible for two subcommands
+    # to have options of the same name.
+    def subcommand_option_handling(handling_strategy)
+      @subcommand_option_handling_strategy = handling_strategy
+    end
+
     private
 
     def load_commands(path)

data/lib/gli/app_support.rb

@@ -27,6 +27,7 @@ module GLI
       @post_block = false
       @default_command = :help
       @around_block = nil
+      @subcommand_option_handling_strategy = :legacy
       clear_nexts
     end
 
@@ -52,25 +53,31 @@ module GLI
     # Returns a number that would be a reasonable exit code
     def run(args) #:nodoc:
       args = args.dup if @preserve_argv
-      command = nil
+      the_command = nil
       begin
         override_defaults_based_on_config(parse_config)
 
         add_help_switch_if_needed(switches)
 
-        global_options,command,options,arguments = GLIOptionParser.new(commands,flags,switches,accepts,@default_command).parse_options(args)
+        gli_option_parser = GLIOptionParser.new(commands,
+                                                flags,
+                                                switches,
+                                                accepts,
+                                                @default_command,
+                                                self.subcommand_option_handling_strategy)
 
-        copy_options_to_aliased_versions(global_options,command,options)
+        parsing_result = gli_option_parser.parse_options(args)
+        parsing_result.convert_to_openstruct! if @use_openstruct
 
-        global_options = convert_to_openstruct_if_needed(global_options)
-        options        = convert_to_openstruct_if_needed(options)
+        the_command = parsing_result.command
 
-        if proceed?(global_options,command,options,arguments)
-          call_command(command,global_options,options,arguments)
-        end
+        call_command(parsing_result) if proceed?(parsing_result)
         0
       rescue Exception => ex
-        handle_exception(ex,command)
+        if the_command.nil? && ex.respond_to?(:command_in_context)
+          the_command = ex.command_in_context
+        end
+        handle_exception(ex,the_command)
       end
     end
 
@@ -79,17 +86,9 @@ module GLI
     def config_file_name #:nodoc:
       @config_file
     end
-
     def accepts #:nodoc:
       @accepts ||= {}
-    end
 
-    # Copies all options in both global_options and options to keys for the aliases of those flags.
-    # For example, if a flag works with either -f or --flag, this will copy the value from [:f] to [:flag]
-    # to allow the user to access the options by any alias
-    def copy_options_to_aliased_versions(global_options,command,options) # :nodoc:
-      copy_options_to_aliases(global_options)
-      command.copy_options_to_aliases(options)
     end
 
     def parse_config # :nodoc:
@@ -172,8 +171,13 @@ module GLI
         next if command_name == :initconfig || command.nil?
         command_config = (config['commands'] || {})[command_name] || {}
 
-        override_default(command.topmost_ancestor.flags,command_config)
-        override_default(command.topmost_ancestor.switches,command_config)
+        if @subcommand_option_handling_strategy == :legacy
+          override_default(command.topmost_ancestor.flags,command_config)
+          override_default(command.topmost_ancestor.switches,command_config)
+        else
+          override_default(command.flags,command_config)
+          override_default(command.switches,command_config)
+        end
 
         override_command_defaults(command.commands,command_config)
       end
@@ -185,13 +189,19 @@ module GLI
       end
     end
 
+    def subcommand_option_handling_strategy
+      @subcommand_option_handling_strategy || :legacy
+    end
+
   private
 
     def handle_exception(ex,command)
       if regular_error_handling?(ex)
         output_error_message(ex)
         if ex.kind_of?(OptionParser::ParseError) || ex.kind_of?(BadCommandLine)
-          commands[:help] and commands[:help].execute({},{},command.nil? ? [] : [command.name.to_s])
+          if commands[:help]
+            commands[:help].execute({},{},command.nil? ? [] : [command.name.to_s])
+          end
         end
       end
 
@@ -210,13 +220,7 @@ module GLI
 
     def no_message_given?(ex)
       ex.message == ex.class.name
-    end
 
-    # Possibly returns a copy of the passed-in Hash as an instance of GLI::Option.
-    # By default, it will *not*. However by putting <tt>use_openstruct true</tt>
-    # in your CLI definition, it will
-    def convert_to_openstruct_if_needed(options) # :nodoc:
-      @use_openstruct ? Options.new(options) : options
     end
 
     def add_help_switch_if_needed(switches)
@@ -233,11 +237,11 @@ module GLI
 
     # True if we should proceed with executing the command; this calls
     # the pre block if it's defined
-    def proceed?(global_options,command,options,arguments) #:nodoc:
-      if command && command.skips_pre
+    def proceed?(parsing_result) #:nodoc:
+      if parsing_result.command && parsing_result.command.skips_pre
         true
       else
-        pre_block.call(global_options,command,options,arguments) 
+        pre_block.call(*parsing_result)
       end
     end
 
@@ -257,8 +261,12 @@ module GLI
       "error: #{ex.message}"
     end
 
-    def call_command(command,global_options,options,arguments)
-      arguments = arguments.map { |arg| arg.dup } # unfreeze
+    def call_command(parsing_result)
+      command        = parsing_result.command
+      global_options = parsing_result.global_options
+      options        = parsing_result.command_options
+      arguments      = parsing_result.arguments.map { |arg| arg.dup } # unfreeze
+
       code = lambda { command.execute(global_options,options,arguments) }
       nested_arounds = unless command.skips_around
                          around_blocks.inject do |outer_around, inner_around|

data/lib/gli/command.rb

@@ -1,5 +1,4 @@
 require 'gli/command_line_token.rb'
-require 'gli/copy_options_to_aliases.rb'
 require 'gli/dsl.rb'
 
 module GLI
@@ -28,10 +27,12 @@ module GLI
   #     end
   #
   class Command < CommandLineToken
-    include CopyOptionsToAliases
     include DSL
     include CommandSupport
 
+    # Key in an options hash to find the parent's parsed options
+    PARENT = Object.new 
+
     # Create a new command.
     #
     # options:: Keys should be:

data/lib/gli/command_finder.rb

@@ -0,0 +1,41 @@
+module GLI
+  class CommandFinder
+    # Initialize a finder on the given list of commands, using default_command as the default if none found
+    def initialize(commands,default_command)
+      @default_command = default_command
+      @names_to_commands = {}
+      commands.each do |command_name,command|
+        @names_to_commands[command_name.to_s] = command
+        Array(command.aliases).each do |command_alias|
+          @names_to_commands[command_alias.to_s] = command
+        end
+      end
+    end
+
+    # Finds the command with the given name, allowing for partial matches.  Returns the command named by
+    # the default command if no command with +name+ matched
+    def find_command(name)
+      name ||= @default_command
+
+      raise UnknownCommand.new("No command name given nor default available") if String(name).strip == ''
+
+      command_found = @names_to_commands.fetch(name.to_s) do |command_to_match|
+        find_command_by_partial_name(@names_to_commands, command_to_match)
+      end
+      if Array(command_found).empty?
+        raise UnknownCommand.new("Unknown command '#{name}'")
+      elsif command_found.kind_of? Array
+        raise AmbiguousCommand.new("Ambiguous command '#{name}'. It matches #{command_found.sort.join(',')}")
+      end
+      command_found
+    end
+
+  private
+
+    def find_command_by_partial_name(names_to_commands, command_to_match)
+      partial_matches = names_to_commands.keys.select { |command_name| command_name =~ /^#{command_to_match}/ }
+      return names_to_commands[partial_matches[0]] if partial_matches.size == 1
+      partial_matches
+    end
+  end
+end