gli 0.1.6

data/README.rdoc

@@ -0,0 +1,135 @@
+This is a command line parser for a git-like command line client.
+
+= Use
+
+The simplest way to get started is to create a scaffold project
+
+    gli init my_proj command_name other_command_name
+
+This will create a (very) basic scaffold project in <tt>./my_proj</tt>, with a bare-bones 
+main file in <tt>./my_proj/bin/my_proj</tt>.  This file demonstrates most of what you need
+to describe your command line interface
+
+== More Detail
+
+This sets you up to use the DSL that GLI defines:
+
+    #!/usr/bin/ruby
+    $: << File.expand_path(File.dirname(__FILE__) + '/../lib') 
+
+    require 'gli'
+
+    include GLI
+
+This describes a command line switch "-n" that is global to all commands and specified before
+the command name on the command line.
+
+    desc 'Dry run; don\'t change the disk'
+    switch :n
+
+
+This describes a command line flag that is global and has a default value of '<tt>.</tt>'.  It also
+specifies a short description of its argument.  This is used to print command line help.  Note that we
+have specified two different aliases for this flag.  <tt>-r</tt> (because it is listed first) is the default
+one and <tt>--root</tt> (note two-dash syntax) is also supported.  This means that <tt>-r some_dir</tt> and <tt>--root=some_dir</tt> mean
+the same thing to the application.
+
+    desc 'Root dir in which to create project'
+    default_value '.'
+    arg_name 'root_dir'
+    flag [:r,:root]
+
+Here we specify a command.  Inside the block we can use the same sorts of things as we did above to define flags
+and switches specific to the command.  These must come after the command name.  Also note that we use <tt>arg_name</tt>
+here to describe the arguments this command accepts.
+
+    desc 'Create a new GLI-based project'
+    arg_name 'project_name [command[ command]*]'
+    command [:init,:scaffold] do |c|
+
+      c.desc 'Create an ext dir'
+      c.switch [:e,:ext]
+
+      c.desc 'Overwrite/ignore existing files and directories'
+      c.switch [:force]
+
+Here we specify the actual actions to take when the command is executed.  We define a block that
+will be given the global options (as a Hash), the command-specific options (as a hash) and the command
+line arguments
+
+      c.action do |global_options,options,args|
+        if args.length < 1
+          raise(MissingArgumentException,'You must specify the name of your project')
+        end
+        Scaffold.create_scaffold(g[:r],!o[:notest],o[:e],args[0],args[1..-1],o[:force],g[:n])
+      end
+    end
+
+You can also specify some global code to run before, after and on errors:
+
+    pre do |global_options,command,options,args|
+      puts "After parsing, but before #{command.name} is run"
+      return true
+      # return false if we want to skip command execution for some reason
+    end
+
+    post do |global_options,command,options,args|
+      puts "After successful execution of #{command.name}"
+    end
+
+    on_error do |global_options,command,options,args|
+      puts "We go an error"
+      return true    # does the standard error handling code
+      # return false # this would skip standard error handling code
+    end
+
+Now, we run the program using the arguments the user provided on the command line
+
+    run(ARGV)
+
+What this gives you:
+
+* A reasonably useful help system.  <tt>your_program help</tt> will list all the global options and commands (along with command aliases) and <tt>your_program help command_name</tt> will list help for that given command.
+* Error handling when flags do not receive arguments or unknown flags or switches are given
+* Error handling when an unknown command is specified
+* Default values for flags if they are not specified by the user (switches all default to false)
+
+What this doesn't give you:
+
+* A way to indicate required flags
+* A way to indicate a require argument or required number of arguments
+* A way to do default switches to 'true' and therefore accept things like <tt>--no-force</tt>
+  
+= Interface Generated
+
+*executable* <i>global options and flags</i> *command* <i>command specific options and flags</i> `arguments`
+
+[switch]    a command line control string that takes no argument.  The <tt>-l</tt> in <tt>ls -l</tt>
+[flag]      a switch that takes an argument.  The <tt>-d' '</tt> in <tt>cut -d' ' file</tt>
+[command]   the command to execute.  The <tt>rebase</tt> in <tt>git rebase</tt>
+[arguments] Anything that's not a switch, flag, or command.  The <tt>main.c</tt> in <tt>git add main.c</tt>
+
+== Switches
+
+Switches can be specified one at a time in either a long or short format:
+
+    git add -i
+    git add --interactive
+
+Switches can also be combined in their short form:
+
+    ls -l -a    
+    ls -la
+
+== Flags
+
+Flags can be specified in long or short form, and with or without an equals:
+
+    git merge -s resolve
+    git merge --strategy=resolve
+
+== Stop Switch
+
+A <tt>--</tt> at any time stops processing and sends the rest of the argument to the command as arguments, even if
+they start with a "--"
+

data/bin/gli

@@ -0,0 +1,61 @@
+#!/usr/bin/ruby
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib') 
+
+require 'gli'
+require 'support/scaffold'
+
+include GLI
+desc 'Be verbose'
+switch :v
+
+desc 'Print version'
+switch :version
+
+desc 'Dry run; don\'t change the disk'
+switch :n
+
+desc 'Root dir of project'
+default_value '.'
+flag [:r,:root]
+
+desc 'Create a new GLI-based project'
+arg_name 'project_name [command[ command]*]'
+command [:init,:scaffold] do |c|
+
+  c.desc 'Create an ext dir'
+  c.switch [:e,:ext]
+
+  c.desc 'Do not create a test dir'
+  c.switch [:notest]
+
+  c.desc 'Overwrite/ignore existing files and directories'
+  c.switch [:force]
+
+  c.action do |g,o,args|
+    if args.length < 1
+      raise(MissingArgumentException,'You must specify the name of your project')
+    end
+    Scaffold.create_scaffold(g[:r],!o[:notest],o[:e],args[0],args[1..-1],o[:force],g[:n])
+  end
+end
+
+pre do |global,command,options,args|
+  if (!command || command.name == :help) && global[:version]
+    puts "#{$0} v#{GLI::VERSION}"
+    false
+  else
+    puts "Executing #{command.name}" if global[:v]
+    true
+  end
+end
+
+post do |global,command,options,args|
+  puts "Executed #{command.name}" if global[:v]
+end
+
+#on_error do |global,command,options,args|
+#  puts "Got an error" if global[:v]
+#  true
+#end
+
+run(ARGV)

data/lib/gli.rb

@@ -0,0 +1,265 @@
+require 'gli/command_line_token.rb'
+require 'gli/command.rb'
+require 'gli/switch.rb'
+require 'gli/flag.rb'
+require 'support/help.rb'
+
+# A means to define and parse a command line interface that works as
+# Git's does, in that you specify global options, a command name, command
+# specific options, and then command arguments.
+module GLI
+  extend self
+
+  VERSION = '0.1.5'
+
+  @@program_name = $0.split(/\//)[-1]
+  @@post_block = nil
+  @@pre_block = nil
+  @@error_block = nil
+
+  # Reset the GLI module internal data structures; mostly for testing
+  def reset
+    switches.clear
+    flags.clear
+    commands.clear
+    clear_nexts
+  end
+
+  # describe the next switch, flag, or command
+  def desc(description); @@next_desc = description; end
+  # describe the argument name of the next flag
+  def arg_name(name); @@next_arg_name = name; end
+  # set the default value of the next flag
+  def default_value(val); @@next_default_value = val; end
+
+  # Create a flag, which is a switch that takes an argument
+  def flag(names)
+    flag = Flag.new(names,@@next_desc,@@next_arg_name,@@next_default_value)
+    flags[flag.name] = flag
+    clear_nexts
+  end
+
+  # Create a switch
+  def switch(names)
+    switch = Switch.new(names,@@next_desc)
+    switches[switch.name] = switch
+    clear_nexts
+  end
+
+  # Define a command.
+  def command(names)
+    command = Command.new(names,@@next_desc,@@next_arg_name)
+    commands[command.name] = command
+    yield command
+    clear_nexts
+  end
+
+  # Define a block to run after command line arguments are parsed
+  # but before any command is run.  If this block raises an exception
+  # the command specified will not be executed.
+  # The block will receive the global-options,command,options, and arguments
+  # If this block evaluates to true, the program will proceed; otherwise
+  # the program will end immediately
+  def pre(&a_proc)
+    @@pre_block = a_proc
+  end
+
+  # Define a block to run after command hase been executed, only
+  # if there was not an error.
+  # The block will receive the global-options,command,options, and arguments
+  def post(&a_proc)
+    @@post_block = a_proc
+  end
+
+  # Define a block to run if an error occurs.
+  # The block will receive the exception that was caught.
+  # It should return false to avoid the built-in error handling
+  def on_error(&a_proc)
+    @@error_block = a_proc
+  end
+
+  # Runs whatever command is needed based on the arguments.
+  def run(args)
+    commands[:help] = DefaultHelpCommand.new if !commands[:help]
+    begin
+      global_options,command,options,arguments = parse_options(args)
+      proceed = true
+      proceed = @@pre_block.call(global_options,command,options,arguments) if @@pre_block 
+      if proceed
+        command = commands[:help] if !command
+        command.execute(global_options,options,arguments)
+        @@post_block.call(global_options,command,options,arguments) if @@post_block 
+      end
+    rescue UnknownCommandException, UnknownArgumentException, MissingArgumentException => ex
+      regular_error_handling = true
+      regular_error_handling = @@error_block.call(ex) if @@error_block
+
+      if regular_error_handling
+        puts "error: #{ex}"
+        puts
+        help = commands[:help]
+        help.execute({},{},[])
+      end
+    end
+  end
+
+  def program_name(override=nil)
+    if override
+      @@program_name = override
+    end
+    @@program_name
+  end
+
+  # Returns an array of four values:
+  #  * global options (as a Hash)
+  #  * Command 
+  #  * command options (as a Hash)
+  #  * arguments (as an Array)
+  def parse_options(args)
+    global_options,command,options,arguments = parse_options_helper(args.clone,Hash.new,nil,Hash.new,Array.new)
+    flags.each { |name,flag| global_options[name] = flag.default_value if !global_options[name] }
+    command.flags.each { |name,flag| options[name] = flag.default_value if !options[name] }
+    return [global_options,command,options,arguments]
+  end
+
+  # Finds the index of the first non-flag
+  # argument or -1 if there wasn't one.
+  def find_non_flag_index(args)
+    args.each_index do |i|
+      return i if args[i] =~ /^[^\-]/;
+      return i-1 if args[i] =~ /^\-\-$/;
+    end
+    -1;
+  end
+
+  alias :d :desc
+  alias :f :flag
+  alias :s :switch
+  alias :c :command
+
+  def clear_nexts
+    @@next_desc = nil
+    @@next_arg_name = nil
+    @@next_default_value = nil
+  end
+
+  clear_nexts
+
+  def flags; @@flags ||= {}; end
+  def switches; @@switches ||= {}; end
+  def commands; @@commands ||= {}; end
+
+  # Recursive helper for parsing command line options
+  # [args] the arguments that have yet to be processed
+  # [global_options] the global options hash
+  # [command] the Command that has been identified (or nil if not identified yet)
+  # [command_options] options for Command
+  # [arguments] the arguments for Command
+  #
+  # This works by finding the first non-switch/flag argument, and taking that sublist and trying to pick out
+  # flags and switches.  After this is done, one of the following is true:
+  #   * the sublist is empty - in this case, go again, as there might be more flags to parse
+  #   * the sublist has a flag left in it - unknown flag; we bail
+  #   * the sublist has a non-flag left in it - this is the command (or the start of the arguments list)
+  #
+  # This sort does the same thing in two phases; in the first phase, the command hasn't been identified, so
+  # we are looking for global switches and flags, ending when we get the command.
+  #
+  # Once the command has been found, we start looking for command-specific flags and switches.
+  # When those have been found, we know the rest of the argument list is arguments for the command
+  def parse_options_helper(args,global_options,command,command_options,arguments)
+    non_flag_i = find_non_flag_index(args)
+    all_flags = false
+    if non_flag_i == 0
+      # no flags
+      if !command
+        command_name = args.shift
+        command = find_command(command_name)
+        raise(UnknownCommandException,"Unknown command '#{command_name}'") if !command
+        return parse_options_helper(args,global_options,command,command_options,arguments)
+      else
+        return global_options,command,command_options,arguments | args
+      end
+    elsif non_flag_i == -1
+      all_flags = true
+    end
+
+    try_me = args[0..non_flag_i]
+    rest = args[(non_flag_i+1)..args.length]
+    if all_flags
+      try_me = args 
+      rest = []
+    end
+
+    # Suck up whatever options we can
+    switch_hash = switches
+    flag_hash = flags
+    options = global_options
+    if command
+      switch_hash = command.switches
+      flag_hash = command.flags
+      options = command_options
+    end
+
+    switch_hash.each do |name,switch|
+      value = switch.get_value!(try_me)
+      options[name] = value if !options[name]
+    end
+
+    flag_hash.each do |name,flag|
+      value = flag.get_value!(try_me)
+      options[name] = value if !options[name]
+    end
+
+    if try_me.empty?
+      return [global_options,command,command_options,arguments] if rest.empty?
+      # If we have no more options we've parsed them all
+      # and rest may have more
+      return parse_options_helper(rest,global_options,command,command_options,arguments)
+    else
+      if command
+        check = rest
+        check = rest | try_me if all_flags 
+        check.each() do |arg| 
+          if arg =~ /^\-\-$/
+            try_me.delete arg
+            break 
+          end
+          raise(UnknownArgumentException,"Unknown argument #{arg}") if arg =~ /^\-/ 
+        end
+        return [global_options,command,command_options,try_me | rest]
+      else
+        # Now we have our command name
+        command_name = try_me.shift
+        raise(UnknownArgumentException,"Unknown argument #{command_name}") if command_name =~ /^\-/
+
+        command = find_command(command_name)
+        raise(UnknownCommandException,"Unknown command '#{command_name}'") if !command
+
+        return parse_options_helper(rest,global_options,command,command_options,arguments)
+      end
+    end
+
+  end
+
+  def find_command(name)
+    sym = name.to_sym
+    return commands[name.to_sym] if commands[sym]
+    commands.keys.each do |command_name|
+      command = commands[command_name]
+      return command if (command.aliases && command.aliases.include?(sym))
+    end
+    nil
+  end
+
+  # Raise this if you get an argument you were not expecting
+  class UnknownArgumentException < Exception
+  end
+
+  class UnknownCommandException < Exception
+  end
+
+  # Raise this if your command doesn't get the number of arguments you were expecting
+  class MissingArgumentException < Exception
+  end
+end

data/lib/gli/command.rb

@@ -0,0 +1,71 @@
+require 'gli/command_line_token.rb'
+
+module GLI
+  # A command to be run, in context of global flags and switches
+  class Command < CommandLineToken
+
+    # Create a new command
+    #
+    # [names] the name or names of this command (symbol or Array of symbols)
+    # [description] description of this command
+    # [arguments_name] description of the arguments, or nil if this command doesn't take arguments
+    #
+    def initialize(names,description,arguments_name=nil)
+      super(names,description)
+      @arguments_description = arguments_name || ''
+      clear_nexts
+    end
+
+    def names
+      all_forms
+    end
+
+    def usage
+      usage = name.to_s
+      usage += ' [options]' if !flags.empty? || !switches.empty?
+      usage += ' ' + @arguments_description if @arguments_description
+      usage
+    end
+
+    def flags; @flags ||= {}; end
+    def switches; @switches ||= {}; end
+
+    # describe the next switch or flag
+    def desc(description); @next_desc = description; end
+    # describe the argument name of the next flag
+    def arg_name(name); @next_arg_name = name; end
+    # set the default value of the next flag
+    def default_value(val); @next_default_value = val; end
+
+    def flag(names)
+      flag = Flag.new(names,@next_desc,@next_arg_name,@next_default_value)
+      flags[flag.name] = flag
+      clear_nexts
+    end
+
+    # Create a switch
+    def switch(names)
+      switch = Switch.new(names,@next_desc)
+      switches[switch.name] = switch
+      clear_nexts
+    end
+
+    def action(&block)
+      @action = block
+    end
+
+    def self.name_as_string(name)
+      name.to_s
+    end
+
+    def clear_nexts
+      @next_desc = nil
+      @next_arg_name = nil
+      @next_default_value = nil
+    end
+
+    def execute(global_options,options,arguments)
+      @action.call(global_options,options,arguments)
+    end
+  end
+end

data/lib/gli/command_line_token.rb

@@ -0,0 +1,47 @@
+module GLI
+  # Logical element of a command line, mostly so that subclasses can have similar
+  # initialization and interface
+  class CommandLineToken
+    attr_reader :name
+    attr_reader :aliases
+    attr_reader :description
+
+    def initialize(names,description)
+      @description = description
+      @name,@aliases,@names = parse_names(names)
+    end
+
+    def usage
+      all_forms
+    end
+
+    private
+    # Returns a string of all possible forms
+    # of this flag.  Mostly intended for printing
+    # to the user.
+    def all_forms(joiner=', ')
+      forms = all_forms_a
+      forms.join(joiner)
+    end
+
+
+    # Handles dealing with the "names" param, parsing
+    # it into the primary name and aliases list
+    def parse_names(names)
+      names_hash = Hash.new
+      names = names.is_a?(Array) ? names : [names]
+      names.each { |n| names_hash[self.class.name_as_string(n)] = true }
+      name = names.shift
+      aliases = names.length > 0 ? names : nil
+      [name,aliases,names_hash]
+    end
+
+    def all_forms_a
+      forms = [self.class.name_as_string(name)]
+      if aliases
+        forms |= aliases.collect { |a| self.class.name_as_string(a) }.sort { |x,y| y.length <=> x.length }
+      end
+      forms
+    end
+  end
+end

data/lib/gli/flag.rb

@@ -0,0 +1,66 @@
+require 'gli/command_line_token.rb'
+
+module GLI
+  # Defines a flag, which is to say a switch that takes an argument
+  class Flag < Switch
+
+    attr_reader :default_value
+
+    def initialize(names,description,argument_name=nil,default=nil)
+      super(names,description)
+      @argument_name = argument_name || "arg"
+      @default_value = default
+    end
+
+    def get_value!(args)
+      args.each_index() do |index|
+        arg = args[index]
+        present,matched,value = find_me(arg)
+        if present
+          args.delete_at index
+          if !value || value == ''
+            if args[index]
+              value = args[index]
+              args.delete_at index
+              return value
+            else
+              raise(MissingArgumentException,"#{matched} requires an argument")
+            end
+          else
+            return value
+          end
+        end
+      end
+      return @default_value
+    end
+
+    def find_me(arg)
+      if @names[arg]
+        return [true,arg,nil] if arg.length == 2
+        # This means we matched the long-form, but there's no argument
+        raise(MissingArgumentException,"#{arg} requires an argument via #{arg}=argument")
+      end
+      @names.keys.each() do |name|
+        match_string = "^#{name}=(.*)$"
+        match_data = arg.match(match_string)
+        return [true,name,$1] if match_data;
+      end
+      [false,nil,nil]
+    end
+
+    # Returns a string of all possible forms
+    # of this flag.  Mostly intended for printing
+    # to the user.
+    def all_forms(joiner=', ')
+      forms = all_forms_a
+      string = forms.join(joiner)
+      if forms[-1] =~ /^\-\-/
+        string += '='
+      else
+        string += ' '
+      end
+      string += @argument_name
+      return string
+    end
+  end
+end

data/lib/gli/switch.rb

@@ -0,0 +1,56 @@
+require 'gli/command_line_token.rb'
+
+module GLI
+  # Defines a command line switch
+  class Switch < CommandLineToken
+
+    def initialize(names,description)
+      super(names,description)
+    end
+
+    # Given the argument list, scans it looking for this switch
+    # returning true if it's in the argumennt list (and removing it from the argument list)
+    def get_value!(args)
+      idx = -1
+      args.each_index do |i|
+        result = find_me(args[i])
+        if result[0]
+          if result[1]
+            args[i] = result[1]
+          else
+            args.delete_at i
+          end
+          return result[0]
+        end
+      end
+      false
+    end
+
+    # Finds the switch in the given arg, returning the arg to keep.
+    # Returns an array of size 2:
+    # [0] true or false if the arg was found
+    # [1] the remaining arg to keep in the command line or nil to remove it
+    def find_me(arg)
+      if @names[arg]
+        return [true,nil]
+      end
+      @names.keys.each() do |name|
+        if name =~ /^-(\w)$/
+          match_string = "^\\-(\\w*)#{$1}(\\w*)$"
+          match_data = arg.match(match_string)
+          if match_data
+            # Note that if [1] and [2] were both empty 
+            # we'd have returned above
+            return [true, "-" + match_data[1] + match_data[2]]
+          end
+        end
+      end
+      [false]
+    end
+
+    def self.name_as_string(name)
+      string = name.to_s
+      string.length == 1 ? "-#{string}" : "--#{string}"
+    end
+  end
+end

data/lib/support/help.rb

@@ -0,0 +1,112 @@
+require 'gli'
+require 'gli/command'
+
+module GLI
+  class DefaultHelpCommand < Command
+    def initialize
+      super(:help,'Shows list of commands or help for one command','[command]')
+    end
+
+    def execute(global_options,options,arguments)
+      if arguments.empty?
+        list_global_flags
+        list_commands
+      else
+        list_one_command_help(arguments[0])
+      end
+    end
+
+    private
+
+    def list_global_flags
+      usage = "usage: #{GLI.program_name} command"
+      all_options = GLI.switches.merge(GLI.flags)
+      if !all_options.empty?
+        usage += ' [options]'
+      end
+      puts usage
+      puts
+      puts 'Options:' if !all_options.empty?
+      output_command_tokens_for_help(all_options)
+      puts if !all_options.empty?
+    end
+
+    def list_commands
+      puts 'Commands:'
+      output_command_tokens_for_help(GLI.commands,:names)
+    end
+
+    def list_one_command_help(command_name)
+      command = GLI.find_command(command_name)
+      if command
+        puts command.usage
+        description = wrap(command.description,4)
+        puts "    #{description}"
+        all_options = command.switches.merge(command.flags)
+        if !all_options.empty?
+          puts
+          puts "Options:"
+          output_command_tokens_for_help(all_options)
+        end
+      else
+        puts "No such command #{command_name}"
+      end
+    end
+
+    def output_command_tokens_for_help(tokens,usage_name=:usage)
+      max = 0
+      tokens.values.each do |token| 
+        len = token.send(usage_name).length
+        if len > max 
+          max = len
+        end
+      end
+      names = tokens.keys.sort { |x,y| x.to_s <=> y.to_s }
+      names.each do |name|
+        token = tokens[name]
+        description = token.description || ''
+        if token.kind_of? Flag 
+          description += " (default: #{token.default_value})" if token.default_value
+        end
+        description = wrap(description,max+7)
+        printf "    %-#{max}s - %s\n",token.send(usage_name),description
+      end
+    end
+  end
+
+  private
+
+  # Wraps the line at the given column length, using the given line padding.
+  # Assumes that the first line doesn't need the padding, as its filled
+  # up with other stuff
+  def wrap(line,pad_length=0,line_length=80)
+    line_padding = sprintf("%#{pad_length}s",'')
+    words = line.split(/\s+/)
+    return line if !words || words.empty?
+    wrapped = ''
+    while wrapped.length + line_padding.length < line_length
+      wrapped += ' ' if wrapped.length > 0
+      word = words.shift
+      if (wrapped.length + line_padding.length + word.length > line_length)
+        words.unshift word
+        break;
+      end
+      wrapped += word
+      return wrapped if words.empty?
+    end
+    wrapped += "\n"
+    this_line = line_padding
+    words.each do |word|
+      if this_line.length + word.length > line_length
+        wrapped += this_line
+        wrapped += "\n"
+        this_line = line_padding + word
+      else
+        this_line += ' ' if this_line.length > line_padding.length
+        this_line += word
+      end
+    end
+    wrapped.chomp!
+    wrapped + "\n" + this_line
+  end
+end

data/lib/support/scaffold.rb

@@ -0,0 +1,127 @@
+require 'gli'
+require 'fileutils'
+
+module GLI
+  class Scaffold
+
+    def self.create_scaffold(root_dir,create_test_dir,create_ext_dir,project_name,commands,force=false,dry_run=false)
+      dirs = [File.join(root_dir,project_name,'lib')]
+      dirs << File.join(root_dir,project_name,'bin')
+      dirs << File.join(root_dir,project_name,'test') if create_test_dir
+      dirs << File.join(root_dir,project_name,'ext') if create_ext_dir
+
+      if mkdirs(dirs,force,dry_run)
+        mk_binfile(root_dir,create_ext_dir,force,dry_run,project_name,commands)
+      end
+    end
+
+    def self.mk_binfile(root_dir,create_ext_dir,force,dry_run,project_name,commands)
+      bin_file = File.join(root_dir,project_name,'bin',project_name)
+      if !File.exist?(bin_file) || force
+        if !dry_run
+          File.open(bin_file,'w') do |file|
+            file.chmod(0755)
+            file.puts '#!/usr/bin/ruby'
+            file.puts '$: << File.expand_path(File.dirname(__FILE__) + \'/../lib\')'
+            file.puts '$: << File.expand_path(File.dirname(__FILE__) + \'/../ext\')' if create_ext_dir
+            file.puts <<EOS
+require 'rubygems'
+require 'gli'
+
+include GLI
+
+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]
+EOS
+            first = true
+            commands.each do |command|
+              if first
+                file.puts <<EOS
+
+desc 'Describe #{command} here'
+arg_name 'Describe arguments to #{command} here'
+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 :s
+  c.action do |global_options,options,args|
+    # Your command logic here
+  end
+end
+EOS
+              else
+                file.puts <<EOS
+command :#{command} do |c|
+  c.action do |global_options,options,args|
+  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 abourt and not call the
+  # chosen command
+  true
+end
+
+post do |global,command,options,args|
+  # Post logic here
+end
+
+on_error do |exception|
+  # Error logic here
+  # return false to skip default error handling
+  true
+end
+
+GLI.run(ARGV)
+EOS
+            puts "Created #{bin_file}"
+          end
+        end
+      else
+        puts bin_file + " exists; use --force to override"
+        return false
+      end
+      true
+    end
+
+    def self.mkdirs(dirs,force,dry_run)
+      exists = false
+      if !force
+        dirs.each do |dir|
+          if File.exist? dir
+            puts "#{dir} exists; use --force to override"
+            exists = true
+          end
+        end
+      end
+      if !exists
+        dirs.each do |dir|
+          puts "Creating dir #{dir}..."
+          if dry_run
+            $stderr.puts "dry-run; #{dir} not created"
+          else
+            FileUtils.mkdir_p dir
+          end
+        end
+      else
+        puts "Exiting..."
+        return false
+      end
+      true
+    end
+
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: gli
+version: !ruby/object:Gem::Version 
+  version: 0.1.6
+platform: ruby
+authors: 
+- David Copeland
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-19 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: 
+email: davidcopeland@naildrivin5.com
+executables: 
+- gli
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- lib/gli/command.rb
+- lib/gli/command_line_token.rb
+- lib/gli/flag.rb
+- lib/gli/switch.rb
+- lib/gli.rb
+- lib/support/help.rb
+- lib/support/scaffold.rb
+- bin/gli
+- README.rdoc
+has_rdoc: true
+homepage: http://davetron5000.github.com/gli
+post_install_message: 
+rdoc_options: 
+- --title
+- Git Like Interface
+- --main
+- README.rdoc
+- -ri
+require_paths: 
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: gli
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: A Git Like Interface for building command line apps
+test_files: []
+