gli 2.5.6 → 2.6.0.rc1

data/lib/gli/command_line_token.rb

@@ -13,10 +13,6 @@ module GLI
       @name,@aliases,@names = parse_names(names)
     end
 
-    def usage #:nodoc:
-      all_forms
-    end
-
     # Sort based on primary name
     def <=>(other)
       self.name.to_s <=> other.name.to_s

data/lib/gli/command_support.rb

@@ -50,58 +50,53 @@ module GLI
     end
 
     def flag(*names)
-      new_flag = if parent.kind_of? Command
-                   parent.flag(*names)
-                 else
-                   super(*names)
-                 end
-      new_flag.associated_command = self
-      new_flag
-    end
-
-    def switch(*names)
-      new_switch = if parent.kind_of? Command
-                     parent.switch(*names)
+      if send_declarations_to_parent?
+        new_flag = if parent.kind_of? Command
+                     super(*names)
+                     parent.flag(*names)
                    else
                      super(*names)
                    end
-      new_switch.associated_command = self
-      new_switch
+        new_flag.associated_command = self
+        new_flag
+      else
+        super(*names)
+      end
+    end
+
+    def switch(*names)
+      if send_declarations_to_parent?
+        new_switch = if parent.kind_of? Command
+                       super(*names)
+                       parent.switch(*names)
+                     else
+                       super(*names)
+                     end
+        new_switch.associated_command = self
+        new_switch
+      else
+        super(*names)
+      end
     end
 
     def desc(d)
-      parent.desc(d) if parent.kind_of? Command
+      parent.desc(d) if parent.kind_of?(Command) && send_declarations_to_parent?
       super(d)
     end
 
     def long_desc(d)
-      parent.long_desc(d) if parent.kind_of? Command
+      parent.long_desc(d) if parent.kind_of?(Command) && send_declarations_to_parent?
       super(d)
     end
 
     def arg_name(d,options=[])
-      if parent.kind_of? Command
-        parent.arg_name(d,options)
-      else
-        super(d,options)
-      end
+      parent.arg_name(d,options) if parent.kind_of?(Command) && send_declarations_to_parent?
+      super(d,options)
     end
 
     def default_value(d)
-      if parent.kind_of? Command
-        parent.default_value(d)
-      else
-        super(d)
-      end
-    end
-
-    # Get the usage string
-    # CR: This should probably not be here
-    def usage 
-      usage = name.to_s
-      usage += ' [command options]' if !flags.empty? || !switches.empty?
-      usage += ' ' + @arguments_description if @arguments_description
-      usage
+      parent.default_value(d) if parent.kind_of?(Command) && send_declarations_to_parent?
+      super(d)
     end
 
     # Return the flags as a Hash
@@ -123,12 +118,7 @@ module GLI
 
     # Executes the command
     def execute(global_options,options,arguments) 
-      subcommand,arguments = find_subcommand(arguments)
-      if subcommand
-        subcommand.execute(global_options,options,arguments)
-      else
-        get_action(arguments).call(global_options,options,arguments)
-      end
+      get_action(arguments).call(global_options,options,arguments)
     end
 
     def topmost_ancestor
@@ -151,6 +141,11 @@ module GLI
 
   private
 
+    def send_declarations_to_parent?
+      app = topmost_ancestor.parent
+      app.nil? ? true : (app.subcommand_option_handling_strategy == :legacy)
+    end
+
     def get_action(arguments)
       if @action
         @action
@@ -168,7 +163,7 @@ module GLI
             raise BadCommandLine,"Command '#{name}' requires a subcommand"
           end
         elsif have_subcommands?
-          raise BadCommandLine,"Command '#{name}' requires a subcommand"
+          raise BadCommandLine,"Command '#{name}' requires a subcommand #{self.commands.keys.join(',')}"
         else
           raise "Command '#{name}' has no action block"
         end
@@ -182,27 +177,5 @@ module GLI
     def have_subcommands?
       !self.commands.empty?
     end
-
-    def find_subcommand(arguments)
-      subcommand = find_explicit_subcommand(arguments)
-      if subcommand
-        [subcommand,arguments[1..-1]]
-      else
-        if !@default_command.nil?
-          [find_explicit_subcommand([@default_command.to_s]),arguments]
-        else 
-          [false,arguments]
-        end
-      end
-    end
-
-    def find_explicit_subcommand(arguments)
-      arguments = Array(arguments)
-      return false if arguments.empty?
-      subcommand_name = arguments.first
-      self.commands.values.find { |command|
-        [command.name,Array(command.aliases)].flatten.map(&:to_s).any? { |name| name == subcommand_name }
-      }
-    end
   end
 end

data/lib/gli/commands/doc.rb

@@ -14,6 +14,8 @@ module GLI
               :skips_pre   => true, :skips_post => true, :skips_around => true, :hidden => true)
 
         @app = app
+        @parent = @app
+        @subcommand_option_handling_strategy = @app.subcommand_option_handling_strategy
 
         desc          'The format name of the documentation to generate or the class name to use to generate it'
         default_value 'rdoc'
@@ -171,11 +173,19 @@ module GLI
       end
 
       def command_flags(command)
-        command.topmost_ancestor.flags.values.select { |flag| flag.associated_command == command }.sort(&by_name)
+        if @subcommand_option_handling_strategy == :legacy
+          command.topmost_ancestor.flags.values.select { |flag| flag.associated_command == command }.sort(&by_name)
+        else
+          command.flags.values.sort(&by_name)
+        end
       end
 
       def command_switches(command)
-        command.topmost_ancestor.switches.values.select { |switch| switch.associated_command == command }.sort(&by_name)
+        if @subcommand_option_handling_strategy == :legacy
+          command.topmost_ancestor.switches.values.select { |switch| switch.associated_command == command }.sort(&by_name)
+        else
+          command.switches.values.sort(&by_name)
+        end
       end
 
       def document_flags_and_switches(document_listener,flags,switches)

data/lib/gli/commands/help.rb

@@ -37,9 +37,11 @@ module GLI
       # Configure help to explicitly skip or not skip the pre block when the help command runs.
       # This is here because the creation of the help command is outside of the client programmer's control
       def self.skips_pre=(skips_pre)       ; @@skips_pre = skips_pre       ; end
+
       # Configure help to explicitly skip or not skip the post block when the help command runs.
       # This is here because the creation of the help command is outside of the client programmer's control
       def self.skips_post=(skips_post)     ; @@skips_post = skips_post     ; end
+
       # Configure help to explicitly skip or not skip the around block when the help command runs.
       # This is here because the creation of the help command is outside of the client programmer's control
       def self.skips_around=(skips_around) ; @@skips_around = skips_around ; end
@@ -50,6 +52,7 @@ module GLI
               :arguments_name => 'command',
               :long_desc => 'Gets help for the application or its commands. Can also list the commands in a way helpful to creating a bash-style completion function')
         @app = app
+        @parent = app
         @sorter = SORTERS[@app.help_sort_type]
         @text_wrapping_class = WRAPPERS[@app.help_text_wrap_type]
 

data/lib/gli/commands/help_modules/command_help_format.rb

@@ -13,10 +13,10 @@ module GLI
         end
 
         def format
-          command_wrapper = @wrapper_class.new(Terminal.instance.size[0],4 + @command.name.to_s.size + 3)
-          wrapper = @wrapper_class.new(Terminal.instance.size[0],4)
-          flags_and_switches = (@command.topmost_ancestor.flags_declaration_order + @command.topmost_ancestor.switches_declaration_order).select { |option| option.associated_command == @command }
-          options_description = OptionsFormatter.new(flags_and_switches,@sorter,@wrapper_class).format
+          command_wrapper      = @wrapper_class.new(Terminal.instance.size[0],4 + @command.name.to_s.size + 3)
+          wrapper              = @wrapper_class.new(Terminal.instance.size[0],4)
+          
+          options_description  = OptionsFormatter.new(flags_and_switches(@command,@app),@sorter,@wrapper_class).format
           commands_description = format_subcommands(@command)
 
           synopses = []
@@ -61,7 +61,11 @@ COMMANDS
 
         def command_with_subcommand_usage(sub,is_default_command)
           usage = basic_usage
-          sub_options = @command.flags.merge(@command.switches).select { |_,o| o.associated_command == sub }
+          sub_options = if @app.subcommand_option_handling_strategy == :legacy 
+                          @command.flags.merge(@command.switches).select { |_,o| o.associated_command == sub }
+                        else
+                          sub.flags.merge(sub.switches)
+                        end
           usage << sub_options.map { |option_name,option| 
             all_names = [option.name,Array(option.aliases)].flatten
             all_names.map { |_| 
@@ -78,6 +82,19 @@ COMMANDS
           usage
         end
 
+        def flags_and_switches(command,app)
+          if app.subcommand_option_handling_strategy == :legacy
+            (
+              command.topmost_ancestor.flags_declaration_order + 
+              command.topmost_ancestor.switches_declaration_order
+            ).select { |option| option.associated_command == command }
+          else
+            (
+              command.flags_declaration_order + 
+              command.switches_declaration_order
+            )
+          end
+        end
  
         def basic_usage
           usage = @basic_invocation.dup

data/lib/gli/commands/scaffold.rb

@@ -211,7 +211,7 @@ EOS
       end
       puts "Created #{root_dir}/#{project_name}/Rakefile"
       File.open("#{root_dir}/#{project_name}/Gemfile",'w') do |bundler_file|
-        bundler_file.puts "source :rubygems"
+        bundler_file.puts "source 'https://rubygems.org'"
         bundler_file.puts "gemspec"
       end
       puts "Created #{root_dir}/#{project_name}/Gemfile"

data/lib/gli/exceptions.rb

@@ -15,20 +15,32 @@ module GLI
   class UnknownCommand < BadCommandLine
   end
 
+  # The command issued partially matches more than one command
+  class AmbiguousCommand < BadCommandLine
+  end
+
   # Indicates the bad command line was an unknown global argument
   class UnknownGlobalArgument < BadCommandLine
   end
 
-  # Indicates the bad command line was an unknown command argument
-  class UnknownCommandArgument < BadCommandLine
+  class CommandException < BadCommandLine
     # The command for which the argument was unknown
-    attr_reader :command
+    attr_reader :command_in_context
     # +message+:: the error message to show the user
     # +command+:: the command we were using to parse command-specific options
-    def initialize(message,command)
+    def initialize(message,command_in_context,exit_code=nil)
       super(message)
-      @command = command
+      @command_in_context = command_in_context
+      @exit_code = exit_code
     end
+
+    def exit_code
+      @exit_code || super
+    end
+  end
+
+  # Indicates the bad command line was an unknown command argument
+  class UnknownCommandArgument < CommandException
   end
 
   # Raise this if you want to use an exit status that isn't the default

data/lib/gli/gli_option_block_parser.rb

@@ -0,0 +1,84 @@
+module GLI
+  # An "option block" is a set of parseable options, starting from the beginning of
+  # the argument list, stopping with the first unknown command-line element.
+  # This class handles parsing that block
+  class GLIOptionBlockParser
+
+    # Create the parser using the given +OptionParser+ instance and exception handling
+    # strategy.
+    #
+    # option_parser_factory:: An +OptionParserFactory+ instance, configured to parse wherever you are on the command line
+    # exception_klass_or_block:: means of handling exceptions from +OptionParser+.  One of:
+    #                            an exception class:: will be raised on errors with a message
+    #                            lambda/block:: will be called with a single argument - the error message.
+    def initialize(option_parser_factory,exception_klass_or_block)
+      @option_parser_factory = option_parser_factory
+      @extra_error_context = nil
+      @exception_handler = if exception_klass_or_block.kind_of?(Class)
+                             lambda { |message,extra_error_context|
+                               raise exception_klass_or_block,message
+                             }
+                           else
+                             exception_klass_or_block
+                           end
+    end
+
+    # Parse the given argument list, returning the unparsed arguments and options hash of parsed arguments.
+    # Exceptions from +OptionParser+ are given to the handler configured in the constructor
+    #
+    # args:: argument list.  This will be mutated
+    #
+    # Returns unparsed args
+    def parse!(args)
+      do_parse(args)
+    rescue OptionParser::InvalidOption => ex
+      @exception_handler.call("Unknown option #{ex.args.join(' ')}",@extra_error_context)
+    rescue OptionParser::InvalidArgument => ex
+      @exception_handler.call("#{ex.reason}: #{ex.args.join(' ')}",@extra_error_context)
+    end
+
+  protected
+
+    def do_parse(args)
+      first_non_option = nil
+      @option_parser_factory.option_parser.order!(args) do |non_option|
+        first_non_option = non_option
+        break
+      end
+      args.unshift(first_non_option)
+    end
+  end
+
+  class CommandOptionBlockParser < GLIOptionBlockParser
+
+    def command=(command_being_parsed)
+      @extra_error_context = command_being_parsed
+    end
+
+  protected
+
+    def break_on_non_option?
+      true
+    end
+
+    def do_parse(args)
+      unknown_options = []
+      @option_parser_factory.option_parser.order!(args) do |non_option|
+        unknown_options << non_option
+        break if break_on_non_option?
+      end
+      unknown_options.reverse.each do |unknown_option|
+        args.unshift(unknown_option)
+      end
+      args
+    end
+  end
+
+  class LegacyCommandOptionBlockParser < CommandOptionBlockParser
+
+  protected
+    def break_on_non_option?
+      false
+    end
+  end
+end

data/lib/gli/gli_option_parser.rb

@@ -1,124 +1,144 @@
 module GLI
   # Parses the command-line options using an actual +OptionParser+
   class GLIOptionParser
-    def initialize(commands,flags,switches,accepts,default_command = nil)
-      @commands = commands
-      @flags = flags
-      @switches = switches
-      @accepts = accepts
-      @default_command = default_command
+    def initialize(commands,flags,switches,accepts,default_command = nil,subcommand_option_handling_strategy=:legacy)
+       command_finder       = CommandFinder.new(commands,default_command || "help")
+      @global_option_parser = GlobalOptionParser.new(OptionParserFactory.new(flags,switches,accepts),command_finder)
+      @accepts              = accepts
+      @subcommand_option_handling_strategy = subcommand_option_handling_strategy
     end
 
-    # Given the command-line argument array, returns and array of size 4:
-    #
-    # 0:: global options
-    # 1:: command, as a Command
-    # 2:: command-specific options
-    # 3:: unparsed arguments
+    # Given the command-line argument array, returns an OptionParsingResult
     def parse_options(args) # :nodoc:
-      args_clone = args.clone
-      global_options = {}
-      command = nil
-      command_options = {}
-      remaining_args = nil
-
-      global_options,command_name,args = parse_global_options(OptionParserFactory.new(@flags,@switches,@accepts), args)
-      @flags.each do |name,flag|
-        global_options[name] = flag.default_value unless global_options[name]
-      end
-      @switches.each do |name,switch|
-        global_options[name] = switch.default_value if global_options[name].nil?
-      end
+      option_parser_class = self.class.const_get("#{@subcommand_option_handling_strategy.to_s.capitalize}CommandOptionParser")
+      OptionParsingResult.new.tap { |parsing_result|
+        parsing_result.arguments = args
+        parsing_result = @global_option_parser.parse!(parsing_result)
+        option_parser_class.new(@accepts).parse!(parsing_result)
+      }
+    end
+
+  private
 
-      command_name ||= @default_command || :help
-      command = find_command(command_name)
-      if Array(command).empty?
-        raise UnknownCommand.new("Unknown command '#{command_name}'")
-      elsif command.kind_of? Array
-        raise UnknownCommand.new("Ambiguous command '#{command_name}'. It matches #{command.sort.join(',')}")
+    class GlobalOptionParser
+      def initialize(option_parser_factory,command_finder)
+        @option_parser_factory = option_parser_factory
+        @command_finder        = command_finder
       end
 
-      command_options,args = parse_command_options(OptionParserFactory.new(command.flags,command.switches,@accepts),
-                                                   command,
-                                                   args)
+      def parse!(parsing_result)
+        parsing_result.arguments      = GLIOptionBlockParser.new(@option_parser_factory,UnknownGlobalArgument).parse!(parsing_result.arguments)
+        command_name                  = parsing_result.arguments.shift
+        parsing_result.global_options = @option_parser_factory.options_hash_with_defaults_set!
+        parsing_result.command        = @command_finder.find_command(command_name)
+        parsing_result
+      end
+    end
 
-      command.flags.each do |name,flag|
-        command_options[name] = flag.default_value unless command_options[name]
+    class NormalCommandOptionParser
+      def initialize(accepts)
+        @accepts = accepts
       end
-      command.switches.each do |name,switch|
-        command_options[name] = switch.default_value if command_options[name].nil?
+
+      def error_handler
+        lambda { |message,extra_error_context| 
+          raise UnknownCommandArgument.new(message,extra_error_context)
+        }
       end
 
-      [global_options,command,command_options,args]
-    end
+      def parse!(parsing_result)
+        parsed_command_options = {}
+        command = parsing_result.command
+        arguments = nil
 
-  private
+        loop do
+          option_parser_factory       = OptionParserFactory.for_command(command,@accepts)
+          option_block_parser         = CommandOptionBlockParser.new(option_parser_factory, self.error_handler)
+          option_block_parser.command = command
+          arguments                   = parsing_result.arguments
+
+          arguments = option_block_parser.parse!(arguments)
 
-    def parse_command_options(option_parser_factory,command,args)
-      option_parser,command_options = option_parser_factory.option_parser
-      help_args = %w(-h --help).reject { |_| command.has_option?(_) }
-
-      unless help_args.empty?
-        option_parser.on(*help_args) do
-          # We need to raise the help exception later in the process, after
-          # the command-line has been parsed, so we know what command
-          # to show help for.  Unfortunately, we can't just call #action
-          # on the command to override what to do, so...metaprogramming.
-          class << command
-            def execute(*help_args)
-              exception = BadCommandLine.new(nil)
-              class << exception
-                def exit_code; 0; end
-              end
-              raise exception
+          parsed_command_options[command] = option_parser_factory.options_hash_with_defaults_set!
+          command_finder                  = CommandFinder.new(command.commands,command.get_default_command)
+          next_command_name               = arguments.shift
+
+          begin
+            command = command_finder.find_command(next_command_name)
+          rescue AmbiguousCommand
+            arguments.unshift(next_command_name)
+            break
+          rescue UnknownCommand
+            arguments.unshift(next_command_name)
+            # Although command finder could certainy know if it should use
+            # the default command, it has no way to put the "unknown command"
+            # back into the argument stack.  UGH.
+            unless command.get_default_command.nil?
+              command = command_finder.find_command(command.get_default_command)
             end
+            break
           end
         end
+        parsed_command_options[command] ||= {}
+        command_options = parsed_command_options[command]
+
+        this_command          = command.parent
+        child_command_options = command_options
+
+        while this_command.kind_of?(command.class)
+          this_command_options = parsed_command_options[this_command] || {}
+          child_command_options[GLI::Command::PARENT] = this_command_options
+          this_command = this_command.parent
+          child_command_options = this_command_options
+        end
+
+        parsing_result.command_options = command_options
+        parsing_result.command = command
+        parsing_result.arguments = Array(arguments.compact)
+        parsing_result
       end
-      option_parser.parse!(args)
-      [command_options,args]
-    rescue OptionParser::InvalidOption => ex
-      raise UnknownCommandArgument.new("Unknown option #{ex.args.join(' ')}",command)
-    rescue OptionParser::InvalidArgument => ex
-      raise UnknownCommandArgument.new("#{ex.reason}: #{ex.args.join(' ')}",command)
     end
 
-    def parse_global_options(option_parser_factory,args,&error_handler)
-      if error_handler.nil?
-        error_handler = lambda { |message|
-          raise UnknownGlobalArgument.new(message)
-        }
-      end
-      option_parser,global_options = option_parser_factory.option_parser
-      command = nil
-      option_parser.order!(args) do |non_option|
-        command = non_option
-        break
+    class LegacyCommandOptionParser < NormalCommandOptionParser
+      def parse!(parsing_result)
+        command                     = parsing_result.command
+        option_parser_factory       = OptionParserFactory.for_command(command,@accepts)
+        option_block_parser         = LegacyCommandOptionBlockParser.new(option_parser_factory, self.error_handler)
+        option_block_parser.command = command
+
+        parsing_result.arguments       = option_block_parser.parse!(parsing_result.arguments)
+        parsing_result.command_options = option_parser_factory.options_hash_with_defaults_set!
+
+        subcommand,args                = find_subcommand(command,parsing_result.arguments)
+        parsing_result.command         = subcommand
+        parsing_result.arguments       = args
       end
-      [global_options,command,args]
-    rescue OptionParser::InvalidOption => ex
-      error_handler.call("Unknown option #{ex.args.join(' ')}")
-    rescue OptionParser::InvalidArgument => ex
-      error_handler.call("#{ex.reason}: #{ex.args.join(' ')}")
-    end
 
-    def find_command(name) # :nodoc:
-      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
+    private
+
+      def find_subcommand(command,arguments)
+        arguments = Array(arguments)
+        command_name = if arguments.empty?
+                         nil
+                       else
+                         arguments.first
+                       end
+
+        default_command = command.get_default_command
+        finder = CommandFinder.new(command.commands,default_command.to_s)
+
+        begin
+          results = [finder.find_command(command_name),arguments[1..-1]]
+          find_subcommand(results[0],results[1])
+        rescue UnknownCommand, AmbiguousCommand
+          begin
+            results = [finder.find_command(default_command.to_s),arguments]
+            find_subcommand(results[0],results[1])
+          rescue UnknownCommand, AmbiguousCommand
+            [command,arguments]
+          end
         end
       end
-      names_to_commands.fetch(name.to_s) do |command_to_match|
-        find_command_by_partial_name(names_to_commands, command_to_match)
-      end
-    end
-
-    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