gli 2.9.0 → 2.20.0

data/lib/gli/commands/scaffold.rb

@@ -31,6 +31,7 @@ module GLI
           end
           puts "Created #{rvmrc}"
         end
+        init_git(root_dir, project_name)
       end
     end
 
@@ -44,7 +45,7 @@ module GLI
       puts "Created #{root_dir}/#{project_name}/README.rdoc"
       File.open("#{root_dir}/#{project_name}/#{project_name}.rdoc",'w') do |file|
         file << "= #{project_name}\n\n"
-        file << "Generate this with\n    #{project_name} rdoc\nAfter you have described your command line interface"
+        file << "Generate this with\n    #{project_name} _doc\nAfter you have described your command line interface"
       end
       puts "Created #{root_dir}/#{project_name}/#{project_name}.rdoc"
     end
@@ -55,7 +56,7 @@ module GLI
         file.puts <<EOS
 # Ensure we require the local version and not one we might have installed already
 require File.join([File.dirname(__FILE__),'lib','#{project_name}','version.rb'])
-spec = Gem::Specification.new do |s| 
+spec = Gem::Specification.new do |s|
   s.name = '#{project_name}'
   s.version = #{project_name_as_module_name(project_name)}::VERSION
   s.author = 'Your Name Here'
@@ -65,15 +66,14 @@ spec = Gem::Specification.new do |s|
   s.summary = 'A description of your project'
   s.files = `git ls-files`.split("\n")
   s.require_paths << 'lib'
-  s.has_rdoc = true
   s.extra_rdoc_files = ['README.rdoc','#{project_name}.rdoc']
   s.rdoc_options << '--title' << '#{project_name}' << '--main' << 'README.rdoc' << '-ri'
   s.bindir = 'bin'
   s.executables << '#{project_name}'
-  s.add_development_dependency('rake')
-  s.add_development_dependency('rdoc')
-  s.add_development_dependency('aruba')
-  s.add_runtime_dependency('gli','#{GLI::VERSION}')
+  s.add_development_dependency('rake','~> 0.9.2')
+  s.add_development_dependency('rdoc', '~> 4.3')
+  s.add_development_dependency('minitest', '~> 5.14')
+  s.add_runtime_dependency('gli','~> #{GLI::VERSION}')
 end
 EOS
       end
@@ -114,12 +114,6 @@ require 'rubygems'
 require 'rubygems/package_task'
 require 'rdoc/task'
 EOS
-        if create_test_dir
-          file.puts <<EOS
-require 'cucumber'
-require 'cucumber/rake/task'
-EOS
-        end
         file.puts <<EOS
 Rake::RDocTask.new do |rd|
   rd.main = "README.rdoc"
@@ -134,44 +128,19 @@ end
 EOS
         if create_test_dir
           file.puts <<EOS
-CUKE_RESULTS = 'results.html'
-CLEAN << CUKE_RESULTS
-desc 'Run features'
-Cucumber::Rake::Task.new(:features) do |t|
-  opts = "features --format html -o \#{CUKE_RESULTS} --format progress -x"
-  opts += " --tags \#{ENV['TAGS']}" if ENV['TAGS']
-  t.cucumber_opts =  opts
-  t.fork = false
-end
-
-desc 'Run features tagged as work-in-progress (@wip)'
-Cucumber::Rake::Task.new('features:wip') do |t|
-  tag_opts = ' --tags ~@pending'
-  tag_opts = ' --tags @wip'
-  t.cucumber_opts = "features --format html -o \#{CUKE_RESULTS} --format pretty -x -s\#{tag_opts}"
-  t.fork = false
-end
-
-task :cucumber => :features
-task 'cucumber:wip' => 'features:wip'
-task :wip => 'features:wip'
-EOS
-        end
-        if create_test_dir
-          file.puts <<EOS
 require 'rake/testtask'
 Rake::TestTask.new do |t|
   t.libs << "test"
   t.test_files = FileList['test/*_test.rb']
 end
 
-task :default => [:test,:features]
+task :default => :test
 EOS
           File.open("#{root_dir}/#{project_name}/test/default_test.rb",'w') do |test_file|
             test_file.puts <<EOS
-require 'test_helper'
+require_relative "test_helper"
 
-class DefaultTest < Test::Unit::TestCase
+class DefaultTest < Minitest::Test
 
   def setup
   end
@@ -188,15 +157,10 @@ EOS
           puts "Created #{root_dir}/#{project_name}/test/default_test.rb"
           File.open("#{root_dir}/#{project_name}/test/test_helper.rb",'w') do |test_file|
             test_file.puts <<EOS
-require 'test/unit'
+require "minitest/autorun"
 
 # Add test libraries you want to use here, e.g. mocha
-
-class Test::Unit::TestCase
-
-  # Add global extensions to the test case class here
-  
-end
+# Add helper classes or methods here, too
 EOS
           end
           puts "Created #{root_dir}/#{project_name}/test/test_helper.rb"
@@ -210,54 +174,6 @@ EOS
         bundler_file.puts "gemspec"
       end
       puts "Created #{root_dir}/#{project_name}/Gemfile"
-      if create_test_dir
-        features_dir = File.join(root_dir,project_name,'features')
-        FileUtils.mkdir features_dir
-        FileUtils.mkdir File.join(features_dir,"step_definitions")
-        FileUtils.mkdir File.join(features_dir,"support")
-        File.open(File.join(features_dir,"#{project_name}.feature"),'w') do |file|
-          file.puts <<EOS
-Feature: My bootstrapped app kinda works
-  In order to get going on coding my awesome app
-  I want to have aruba and cucumber setup
-  So I don't have to do it myself
-
-  Scenario: App just runs
-    When I get help for "#{project_name}"
-    Then the exit status should be 0
-EOS
-        end
-        File.open(File.join(features_dir,"step_definitions","#{project_name}_steps.rb"),'w') do |file|
-          file.puts <<EOS
-When /^I get help for "([^"]*)"$/ do |app_name|
-  @app_name = app_name
-  step %(I run `\#{app_name} help`)
-end
-
-# Add more step definitions here
-EOS
-        end
-        File.open(File.join(features_dir,"support","env.rb"),'w') do |file|
-          file.puts <<EOS
-require 'aruba/cucumber'
-
-ENV['PATH'] = "\#{File.expand_path(File.dirname(__FILE__) + '/../../bin')}\#{File::PATH_SEPARATOR}\#{ENV['PATH']}"
-LIB_DIR = File.join(File.expand_path(File.dirname(__FILE__)),'..','..','lib')
-
-Before do
-  # Using "announce" causes massive warnings on 1.9.2
-  @puts = true
-  @original_rubylib = ENV['RUBYLIB']
-  ENV['RUBYLIB'] = LIB_DIR + File::PATH_SEPARATOR + ENV['RUBYLIB'].to_s
-end
-
-After do
-  ENV['RUBYLIB'] = @original_rubylib
-end
-EOS
-        end
-        puts "Created #{features_dir}"
-      end
     end
 
     def self.mk_binfile(root_dir,create_ext_dir,force,dry_run,project_name,commands)
@@ -278,82 +194,87 @@ rescue LoadError
   exit 64
 end
 
-include GLI::App
+class App
+  extend GLI::App
+
+  program_desc 'Describe your application here'
 
-program_desc 'Describe your application here'
+  version #{project_name_as_module_name(project_name)}::VERSION
 
-version #{project_name_as_module_name(project_name)}::VERSION
+  subcommand_option_handling :normal
+  arguments :strict
 
-desc 'Describe some switch here'
-switch [:s,:switch]
+  desc 'Describe some switch here'
+  switch [:s,:switch]
 
-desc 'Describe some flag here'
-default_value 'the default'
-arg_name 'The name of the argument'
-flag [:f,:flagname]
+  desc 'Describe some flag here'
+  default_value 'the default'
+  arg_name 'The name of the argument'
+  flag [:f,:flagname]
 EOS
             first = true
             commands.each do |command|
               file.puts <<EOS
 
-desc 'Describe #{command} here'
-arg_name 'Describe arguments to #{command} here'
+  desc 'Describe #{command} here'
+  arg_name 'Describe arguments to #{command} here'
 EOS
               if first
                 file.puts <<EOS
-command :#{command} do |c|
-  c.desc 'Describe a switch to #{command}'
-  c.switch :s
+  command :#{command} do |c|
+    c.desc 'Describe a switch to #{command}'
+    c.switch :s
 
-  c.desc 'Describe a flag to #{command}'
-  c.default_value 'default'
-  c.flag :f
-  c.action do |global_options,options,args|
+    c.desc 'Describe a flag to #{command}'
+    c.default_value 'default'
+    c.flag :f
+    c.action do |global_options,options,args|
 
-    # Your command logic here
-     
-    # If you have any errors, just raise them
-    # raise "that command made no sense"
+      # Your command logic here
 
-    puts "#{command} command ran"
+      # If you have any errors, just raise them
+      # raise "that command made no sense"
+
+      puts "#{command} command ran"
+    end
   end
-end
 EOS
               else
                 file.puts <<EOS
-command :#{command} do |c|
-  c.action do |global_options,options,args|
-    puts "#{command} command ran"
+  command :#{command} do |c|
+    c.action do |global_options,options,args|
+      puts "#{command} command ran"
+    end
   end
-end
 EOS
               end
               first = false
             end
             file.puts <<EOS
 
-pre do |global,command,options,args|
-  # Pre logic here
-  # Return true to proceed; false to abort and not call the
-  # chosen command
-  # Use skips_pre before a command to skip this block
-  # on that command only
-  true
-end
+  pre do |global,command,options,args|
+    # Pre logic here
+    # Return true to proceed; false to abort and not call the
+    # chosen command
+    # Use skips_pre before a command to skip this block
+    # on that command only
+    true
+  end
 
-post do |global,command,options,args|
-  # Post logic here
-  # Use skips_post before a command to skip this
-  # block on that command only
-end
+  post do |global,command,options,args|
+    # Post logic here
+    # Use skips_post before a command to skip this
+    # block on that command only
+  end
 
-on_error do |exception|
-  # Error logic here
-  # return false to skip default error handling
-  true
+  on_error do |exception|
+    # Error logic here
+    # return false to skip default error handling
+    true
+  end
 end
 
-exit run(ARGV)
+exit App.run(ARGV)
 EOS
             puts "Created #{bin_file}"
           end
@@ -365,6 +286,14 @@ EOS
       true
     end
 
+    def self.init_git(root_dir, project_name)
+      project_dir = "#{root_dir}/#{project_name}"
+
+      unless system("git", "init", "--quiet", project_dir)
+        puts "There was a problem initializing Git. Your gemspec may not work until you have done a successful `git init`"
+      end
+    end
+
     def self.mkdirs(dirs,force,dry_run)
       exists = false
       if !force

data/lib/gli/dsl.rb

@@ -36,6 +36,26 @@ module GLI
       @next_arg_options = options
     end
 
+    # Describes one of the arguments of the next command
+    #
+    # +name+:: A String that *briefly* describes the argument given to the following command.
+    # +options+:: Symbol or array of symbols to annotate this argument.  This doesn't affect parsing, just
+    #             the help output.  Values recognized are:
+    #             +:optional+:: indicates this argument is optional; will format it with square brackets
+    #             +:multiple+:: indicates multiple values are accepted; will format appropriately
+    #
+    # Example:
+    #     arg :output
+    #     arg :input, :multiple
+    #     command :pack do ...
+    #
+    # Produces the synopsis:
+    #     app.rb [global options] pack output input...
+    def arg(name, options=[])
+      @next_arguments ||= []
+      @next_arguments << Argument.new(name, Array(options).flatten)
+    end
+
     # set the default value of the next flag or switch
     #
     # +val+:: The default value to be used for the following flag if the user doesn't specify one
@@ -53,8 +73,9 @@ module GLI
     #           +:long_desc+:: the long_description, instead of using #long_desc
     #           +:default_value+:: the default value, instead of using #default_value
     #           +:arg_name+:: the arg name, instead of using #arg_name
-    #           +:must_match+:: A regexp that the flag's value must match
+    #           +:must_match+:: A regexp that the flag's value must match or an array of allowable values
     #           +:type+:: A Class (or object you passed to GLI::App#accept) to trigger type coversion
+    #           +:multiple+:: if true, flag may be used multiple times and values are stored in an array
     #
     # Example:
     #
@@ -152,10 +173,12 @@ module GLI
         :description => @next_desc,
         :arguments_name => @next_arg_name,
         :arguments_options => @next_arg_options,
+        :arguments => @next_arguments,
         :long_desc => @next_long_desc,
         :skips_pre => @skips_pre,
         :skips_post => @skips_post,
         :skips_around => @skips_around,
+        :hide_commands_without_desc => @hide_commands_without_desc,
       }
       @commands_declaration_order ||= []
       if names.first.kind_of? Hash
@@ -177,6 +200,7 @@ module GLI
         yield command
       end
       clear_nexts
+      @next_arguments = []
     end
     alias :c :command
 

data/lib/gli/exceptions.rb

@@ -5,6 +5,21 @@ module GLI
   module StandardException
     def exit_code; 1; end
   end
+
+  # Hack to request help from within a command
+  # Will *not* be rethrown when GLI_DEBUG is ON
+  class RequestHelp < StandardError
+    include StandardException
+    def exit_code; 0; end
+
+    # The command for which the argument was unknown
+    attr_reader :command_in_context
+
+    def initialize(command_in_context)
+      @command_in_context = command_in_context
+    end
+  end
+
   # Indicates that the command line invocation was bad
   class BadCommandLine < StandardError
     include StandardException
@@ -44,6 +59,17 @@ module GLI
     end
   end
 
+  class MissingRequiredArgumentsException < BadCommandLine
+    # The command for which the argument was unknown
+    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)
+      super(message)
+      @command_in_context = command
+    end
+  end
+
   # Indicates the bad command line was an unknown command argument
   class UnknownCommandArgument < CommandException
   end

data/lib/gli/flag.rb

@@ -24,17 +24,18 @@ module GLI
     #           :must_match:: a regexp that the flag's value must match
     #           :type:: a class to convert the value to
     #           :required:: if true, this flag must be specified on the command line
+    #           :multiple:: if true, flag may be used multiple times and values are stored in an array
     #           :mask:: if true, the default value of this flag will not be output in the help.
     #                   This is useful for password flags where you might not want to show it
     #                   on the command-line.
     def initialize(names,options)
       super(names,options)
       @argument_name = options[:arg_name] || "arg"
-      @default_value = options[:default_value]
       @must_match = options[:must_match]
       @type = options[:type]
       @mask = options[:mask]
       @required = options[:required]
+      @multiple = options[:multiple]
     end
 
     # True if this flag is required on the command line
@@ -42,12 +43,32 @@ module GLI
       @required
     end
 
+    # True if the flag may be used multiple times.
+    def multiple?
+      @multiple
+    end
 
     def safe_default_value
       if @mask
         "********"
       else
-        default_value
+        # This uses @default_value instead of the `default_value` method because
+        # this method is only used for display, and for flags that may be passed
+        # multiple times, we want to display whatever is set in the code as the
+        # the default, or the string "none" rather than displaying an empty
+        # array.
+        @default_value
+      end
+    end
+
+    # The default value for this flag. Uses the value passed if one is set;
+    # otherwise uses `[]` if the flag support multiple arguments and `nil` if
+    # it does not.
+    def default_value
+      if @default_value
+        @default_value
+      elsif @multiple
+        []
       end
     end
 

data/lib/gli/gli_option_parser.rb

@@ -1,20 +1,35 @@
 module GLI
   # Parses the command-line options using an actual +OptionParser+
   class GLIOptionParser
-    def initialize(commands,flags,switches,accepts,default_command = nil,subcommand_option_handling_strategy=:legacy)
-       command_finder       = CommandFinder.new(commands,default_command || "help")
+    attr_accessor :options
+
+    DEFAULT_OPTIONS = {
+      :default_command => nil,
+      :autocomplete => true,
+      :subcommand_option_handling_strategy => :legacy,
+      :argument_handling_strategy => :loose
+    }
+
+    def initialize(commands,flags,switches,accepts, options={})
+      self.options = DEFAULT_OPTIONS.merge(options)
+
+      command_finder       = CommandFinder.new(commands,
+                                               :default_command => (options[:default_command] || :help),
+                                               :autocomplete => options[:autocomplete])
       @global_option_parser = GlobalOptionParser.new(OptionParserFactory.new(flags,switches,accepts),command_finder,flags)
       @accepts              = accepts
-      @subcommand_option_handling_strategy = subcommand_option_handling_strategy
+      if options[:argument_handling_strategy] == :strict && options[: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
     def parse_options(args) # :nodoc:
-      option_parser_class = self.class.const_get("#{@subcommand_option_handling_strategy.to_s.capitalize}CommandOptionParser")
+      option_parser_class = self.class.const_get("#{options[: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)
+        option_parser_class.new(@accepts).parse!(parsing_result, options[:argument_handling_strategy], options[:autocomplete])
       }
     end
 
@@ -30,30 +45,63 @@ module GLI
       def parse!(parsing_result)
         parsing_result.arguments      = GLIOptionBlockParser.new(@option_parser_factory,UnknownGlobalArgument).parse!(parsing_result.arguments)
         parsing_result.global_options = @option_parser_factory.options_hash_with_defaults_set!
-        command_name = if parsing_result.global_options[:help]
+        command_name = if parsing_result.global_options[:help] || parsing_result.global_options[:version]
                          "help"
                        else
                          parsing_result.arguments.shift
                        end
         parsing_result.command        = @command_finder.find_command(command_name)
         unless command_name == 'help'
-          verify_required_options!(@flags,parsing_result.global_options)
+          verify_required_options!(@flags, parsing_result.command, parsing_result.global_options)
         end
         parsing_result
       end
 
     protected
+      def verify_arguments!(arguments, command)
+        # Lets assume that if the user sets a 'arg_name' for the command it is for a complex scenario
+        # and we should not validate the arguments
+        return unless command.arguments_description.empty?
+
+        # Go through all declared arguments for the command, counting the min and max number
+        # of arguments
+        min_number_of_arguments = 0
+        max_number_of_arguments = 0
+        command.arguments.each do |arg|
+          if arg.optional?
+            max_number_of_arguments = max_number_of_arguments + 1
+          else
+            min_number_of_arguments = min_number_of_arguments + 1
+            max_number_of_arguments = max_number_of_arguments + 1
+          end
+
+          # Special case, as soon as we have a 'multiple' arguments, all bets are off for the
+          # maximum number of arguments !
+          if arg.multiple?
+            max_number_of_arguments = 99999
+          end
+        end
 
-      def verify_required_options!(flags,options)
+        # Now validate the number of arguments
+        if arguments.size < min_number_of_arguments
+          raise MissingRequiredArgumentsException.new("Not enough arguments for command", command)
+        end
+        if arguments.size > max_number_of_arguments
+          raise MissingRequiredArgumentsException.new("Too many arguments for command", command)
+        end
+      end
+
+      def verify_required_options!(flags, command, options)
         missing_required_options = flags.values.
           select(&:required?).
           reject { |option|
             options[option.name] != nil
         }
         unless missing_required_options.empty?
-          raise BadCommandLine, missing_required_options.map { |option|
+          missing_required_options.sort!
+          raise MissingRequiredArgumentsException.new(missing_required_options.map { |option|
             "#{option.name} is required"
-          }.join(' ')
+          }.join(', '), command)
         end
       end
     end
@@ -64,12 +112,12 @@ module GLI
       end
 
       def error_handler
-        lambda { |message,extra_error_context| 
+        lambda { |message,extra_error_context|
           raise UnknownCommandArgument.new(message,extra_error_context)
         }
       end
 
-      def parse!(parsing_result)
+      def parse!(parsing_result,argument_handling_strategy,autocomplete)
         parsed_command_options = {}
         command = parsing_result.command
         arguments = nil
@@ -83,10 +131,10 @@ module GLI
           arguments = option_block_parser.parse!(arguments)
 
           parsed_command_options[command] = option_parser_factory.options_hash_with_defaults_set!
-          command_finder                  = CommandFinder.new(command.commands,command.get_default_command)
+          command_finder                  = CommandFinder.new(command.commands, :default_command => command.get_default_command, :autocomplete => autocomplete)
           next_command_name               = arguments.shift
 
-          verify_required_options!(command.flags,parsed_command_options[command])
+          verify_required_options!(command.flags, command, parsed_command_options[command])
 
           begin
             command = command_finder.find_command(next_command_name)
@@ -120,13 +168,17 @@ module GLI
         parsing_result.command_options = command_options
         parsing_result.command = command
         parsing_result.arguments = Array(arguments.compact)
+
+        # Lets validate the arguments now that we know for sure the command that is invoked
+        verify_arguments!(parsing_result.arguments, parsing_result.command) if argument_handling_strategy == :strict
+
         parsing_result
       end
 
     end
 
     class LegacyCommandOptionParser < NormalCommandOptionParser
-      def parse!(parsing_result)
+      def parse!(parsing_result,argument_handling_strategy,autocomplete)
         command                     = parsing_result.command
         option_parser_factory       = OptionParserFactory.for_command(command,@accepts)
         option_block_parser         = LegacyCommandOptionBlockParser.new(option_parser_factory, self.error_handler)
@@ -135,15 +187,15 @@ module GLI
         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)
+        subcommand,args                = find_subcommand(command,parsing_result.arguments,autocomplete)
         parsing_result.command         = subcommand
         parsing_result.arguments       = args
-        verify_required_options!(command.flags,parsing_result.command_options)
+        verify_required_options!(command.flags, parsing_result.command, parsing_result.command_options)
       end
 
     private
 
-      def find_subcommand(command,arguments)
+      def find_subcommand(command,arguments,autocomplete)
         arguments = Array(arguments)
         command_name = if arguments.empty?
                          nil
@@ -152,15 +204,15 @@ module GLI
                        end
 
         default_command = command.get_default_command
-        finder = CommandFinder.new(command.commands,default_command.to_s)
+        finder = CommandFinder.new(command.commands, :default_command => default_command.to_s, :autocomplete => autocomplete)
 
         begin
           results = [finder.find_command(command_name),arguments[1..-1]]
-          find_subcommand(results[0],results[1])
+          find_subcommand(results[0],results[1],autocomplete)
         rescue UnknownCommand, AmbiguousCommand
           begin
             results = [finder.find_command(default_command.to_s),arguments]
-            find_subcommand(results[0],results[1])
+            find_subcommand(results[0],results[1],autocomplete)
           rescue UnknownCommand, AmbiguousCommand
             [command,arguments]
           end