gli 2.11.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

@@ -50,7 +50,7 @@ module GLI
     #     command :pack do ...
     #
     # Produces the synopsis:
-    #     app.rb [global options] pack output input[, input]*
+    #     app.rb [global options] pack output input...
     def arg(name, options=[])
       @next_arguments ||= []
       @next_arguments << Argument.new(name, Array(options).flatten)
@@ -75,6 +75,7 @@ module GLI
     #           +:arg_name+:: the arg name, instead of using #arg_name
     #           +: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:
     #

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,7 +45,7 @@ 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
@@ -43,6 +58,38 @@ module GLI
       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
+
+        # 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.
@@ -65,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
@@ -84,7 +131,7 @@ 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, command, parsed_command_options[command])
@@ -121,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)
@@ -136,7 +187,7 @@ 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, parsing_result.command_options)
@@ -144,7 +195,7 @@ module GLI
 
     private
 
-      def find_subcommand(command,arguments)
+      def find_subcommand(command,arguments,autocomplete)
         arguments = Array(arguments)
         command_name = if arguments.empty?
                          nil
@@ -153,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

data/lib/gli/option_parser_factory.rb

@@ -58,8 +58,15 @@ module GLI
       tokens.each do |ignore,token|
         opts.on(*token.arguments_for_option_parser) do |arg|
           token.names_and_aliases.each do |name|
-            options[name] = arg
-            options[name.to_sym] = arg
+            if token.kind_of?(Flag) && token.multiple?
+              options[name] ||= []
+              options[name.to_sym] ||= []
+              options[name] << arg
+              options[name.to_sym] << arg
+            else
+              options[name] = arg
+              options[name.to_sym] = arg
+            end
           end
         end
       end

data/lib/gli/options.rb

@@ -7,12 +7,12 @@ module GLI
 
     # Return the value of an attribute
     def[](k)
-      @table[k.to_sym]
+      self.send(k.to_sym)
     end
 
     # Set the value of an attribute
     def[]=(k, v)
-      @table[k.to_sym] = v
+      self.send("#{k.to_sym}=",v)
     end
 
     def map(&block)

data/lib/gli/switch.rb

@@ -31,5 +31,9 @@ module GLI
     def negatable?
       @negatable
     end
+
+    def required?
+      false
+    end
   end
 end

data/lib/gli/terminal.rb

@@ -43,7 +43,7 @@ module GLI
     #
     # +command+:: The command, as a String, to check for, without any path information.
     def self.command_exists?(command)
-      ENV['PATH'].split(File::PATH_SEPARATOR).any? {|dir| File.exists? File.join(dir, command) }
+      ENV['PATH'].split(File::PATH_SEPARATOR).any? {|dir| File.exist? File.join(dir, command) }
     end
 
     def command_exists?(command)
@@ -78,7 +78,11 @@ module GLI
     #
     # Returns an Array of size two Ints representing the terminal width and height
     def size
-      SIZE_DETERMINERS.select { |(predicate,ignore)| predicate.call }.first[1].call
+      SIZE_DETERMINERS.each do |predicate, get_size|
+        next unless predicate.call
+        size = get_size.call
+        return size unless size == [0, 0]
+      end
     rescue Exception => ex
       raise ex if @unsafe
       Terminal.default_size

data/lib/gli/version.rb

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

data/lib/gli.rb

@@ -24,6 +24,7 @@ require 'gli/commands/doc'
 
 module GLI
   include GLI::App
+
   def self.included(klass)
     warn "You should include GLI::App instead"
   end

data/object-model.dot

@@ -0,0 +1,29 @@
+digraph G {
+
+  rankdir="BT"
+  nodesep=0.5
+
+  node[shape=record fontname=courier fontsize=18]
+  edge[fontname=avenir fontsize=12]
+
+  CommandLineToken  [ label="{ CommandLineToken | #name\l | #description\l | #long_description\l | #aliases\l}"]
+  CommandLineOption [ label="{ CommandLineOption | #default_value \l }"]
+  DSL
+  Command
+  Flag              [ label="{ Flag | #argument_name\l }"]
+  Switch
+  App
+  TopLevel          [ label="top level?" shape=diamond fontname=avenir fontsize=12]
+
+  Command           -> DSL               [ arrowhead=oarrow   label="  includes" minlen=3]
+  Command           -> CommandLineToken  [ arrowhead=oarrow   label="inherits"]
+  CommandLineOption -> CommandLineToken  [ arrowhead=oarrow   label="inherits"]
+  Flag              -> CommandLineOption [ arrowhead=oarrow   label="inherits"]
+  Switch            -> CommandLineOption [ arrowhead=oarrow   label="inherits"]
+  Command           -> TopLevel          [ arrowhead=none     label="parent" style=dotted]
+  TopLevel          -> App               [ arrowhead=odiamond label="YES"    style=dotted ]
+  TopLevel          -> Command           [ arrowhead=odiamond label="NO"     style=dotted ]
+  CommandLineOption -> Command           [ arrowhead=odiamond style=dotted label="associated_command"]
+
+  { rank=same; DSL; App }
+}