commandline2 0.7.2

data/lib/commandline.rb

@@ -0,0 +1,16 @@
+#  $Id: commandline.rb,v 1.2 2005/09/19 19:53:36 jdf Exp $
+#  $Source: /Users/jdf/projects/CVSROOT/devel/ruby/commandline/lib/commandline.rb,v $
+#
+#  Author: Jim Freeze
+#  Copyright (c) 2005
+#
+# =DESCRIPTION
+# Loader
+#
+# =Revision History
+#  Jim.Freeze 2005/06/17 Birthday
+#
+
+require 'commandline/kernel'
+require 'commandline/utils'
+require 'commandline/application'

data/lib/commandline/application.rb

@@ -0,0 +1,424 @@
+#  $Id: application.rb,v 1.4 2005/09/20 19:11:17 jdf Exp $
+#  $Source: /Users/jdf/projects/CVSROOT/devel/ruby/commandline/lib/commandline/application.rb,v $
+#
+#  Author: Jim Freeze
+#  Copyright (c) 2005
+#
+# =DESCRIPTION
+# Framework for commandline applications
+#
+# =Revision History
+#  Jim.Freeze 06/02/2005 Birthday - kinda
+#  Jim.Freeze 09/19/2005 fixed @arg_arity bug and copyright print bug
+
+require 'commandline/utils'
+require 'commandline/optionparser'
+
+module CommandLine
+class Application
+  class ApplicationError          < StandardError; end
+  class OptionError               < ApplicationError; end
+  class MissingMainError          < ApplicationError; end
+  class InvalidArgumentArityError < ApplicationError; end
+  class ArgumentError             < ApplicationError; end
+  class UnknownOptionError        < ApplicationError; end
+
+  param_accessor :version, :author, :copyright, :synopsis,
+                 :short_description, :long_description,
+                 :option_parser
+
+  attr_reader :args, :argv
+  
+  @no_auto_run = false
+
+  #
+  # TODO: Consolidate these with OptionParser - put in command line
+  #
+  DEFAULT_CONSOLE_WIDTH = 70
+  MIN_CONSOLE_WIDTH     = 10
+  DEFAULT_BODY_INDENT   =  4
+
+  def initialize
+    @synopsis    = ""
+    @arg_arity   = [0,0]
+    @options     = []
+    @arg_names   = []
+    @args        = []
+    @replay      = false
+    @replay_file = ".replay"
+
+    __initialize_text_formatting
+
+    # Call the child usurped initialize
+    __child_initialize if 
+      self.class.private_instance_methods(false).include?("__child_initialize")
+
+    @option_parser ||= CommandLine::OptionParser.new(@options)
+  end
+
+  def options(*opts)
+    opts.each { |opt| option(*[opt].flatten) }
+  end
+
+  def option(*args)
+    @options ||= []
+    new_list = []
+    args.each { |arg|
+      new_list << 
+      case arg
+        when :help    then __help
+        when :debug   then __debug
+        when :verbose then __verbose
+        when :version then __version
+        else arg
+      end
+    }
+    #p new_list
+    @options << CommandLine::Option.new(*new_list)
+  end
+
+  # Alternative for @option_data["<--opt>"], but with symbols
+  def opt
+    @option_data
+  end
+  
+  #
+  # expected_args tells the application how many arguments (not belonging
+  # any option) are expected to be seen on the command line
+  # The names of the args are used for describing the synopsis (or usage).
+  # If there is an indeterminant amount of arguments, they are not
+  # named, but returned in an array.
+  # expected_args takes either a list of argument names
+  #
+  # =Usage
+  #   expected_args :sym1
+  #   expected_args :sym1, :sym2, ...
+  #   expected_args n    #=> arg_arity => [n,n]
+  #   expected_args arity
+  #
+  # =Examples
+  #
+  # Many forms are valid. Some examples follow:
+  #   expected_args 0                #=> @args = []; same as not calling expected_args
+  #   synopsis: Usage: app
+
+  #   expected_args 1                #=> @args is array
+  #   synopsis: Usage: app arg
+
+  #   expected_args 2                #=> @args is array
+  #   synopsis: Usage: app arg1 arg2
+
+  #   expected_args 10               #=> @args is array
+  #   synopsis: Usage: app arg1 ... arg10
+
+  #   expected_args :file            #=> @file = <arg>
+  #   synopsis: Usage: app file
+
+  #   expected_args :file1, :file2   #=> @file1 = <arg1>, @file2 = <arg2>
+  #   synopsis: Usage: app file1 file2
+
+  #   expected_args [0,1]            #=> @args is array
+  #   synopsis: Usage: app [arg1 [arg2]]
+
+  #   expected_args [2,3]            #=> @args is array
+  #   synopsis: Usage: app arg1 arg2 [arg3]
+
+  #   expected_args [0,-1]           #=> @args is array
+  #   synopsis: Usage: app [arg1 [arg...]]
+  #
+
+  #   expected_args :cmd
+  #   Now, what to do if command line has more args than expected
+  #   app --app-option cmd --cmd-option arg-for-cmd
+  #
+  def expected_args(*exp_args)
+    @arg_names = []
+    case exp_args.size
+    when 0 then @arg_arity = [0,0]
+    when 1
+      case exp_args[0]
+      when Fixnum 
+        v = exp_args[0]
+        @arg_arity = [v,v]
+      when Symbol
+        @arg_names = exp_args
+        @arg_arity = [1,1]
+      when Array
+        v = exp_args[0]
+        __validate_arg_arity(v)
+        @arg_arity = v
+      else 
+        raise(InvalidArgumentArityError, 
+          "Args must be a Fixnum or Array: #{exp_args[0].inspect}.")
+      end
+    else
+      @arg_names = exp_args
+      size = exp_args.size
+      @arg_arity = [size, size]
+    end
+  end
+
+  def use_replay(attribs = {})
+    @replay = true
+    @replay_file = attribs[:replay_file] || @replay_file
+  end
+
+  def usage
+    " Usage: #{name} #{synopsis}"
+  end
+
+  def man
+    require 'text/format'
+    f = Text::Format.new
+    f = Text::Format.new
+    f.columns = @columns
+    f.first_indent  = 4
+    f.body_indent   = @body_indent
+    f.tag_paragraph = false
+
+    s = []
+    s << ["NAME\n"]
+
+    nm = "#{short_description}".empty? ? name : "#{name} - #{short_description}"
+    s << f.format(nm)
+
+    sn = "#{synopsis}".empty? ? "" : "#{name} #{synopsis}"
+    unless sn.empty?
+      s << "SYNOPSIS\n"
+      s << f.format(sn)
+    end
+
+    dc = "#{long_description}"
+    unless dc.empty?
+      s << "DESCRIPTION\n"
+      s << f.format(dc)
+    end
+
+    op = option_parser.to_s
+    unless op.empty?
+      s << option_parser.to_s
+    end
+
+    ar = "#{author}"
+    unless ar.empty?
+      s << "AUTHOR:  #{ar}"
+    end
+
+
+    ct = "COPYRIGHT (c) #{copyright}"
+    unless "#{copyright}".empty?
+      s << ct
+    end
+
+    s.join("\n")
+  end
+  alias :help :man
+
+  def name
+    File.basename(pathname)
+  end
+
+  def pathname
+    @@appname
+  end
+
+  def get_arg
+    CommandLine::OptionParser::GET_ARGS
+  end
+  alias :get_args :get_arg
+
+  def append_arg
+    CommandLine::OptionParser::GET_ARG_ARRAY
+  end
+
+  def required
+    CommandLine::OptionParser::OPT_NOT_FOUND_BUT_REQUIRED
+  end
+  
+  def self.run(argv=ARGV)
+    # Usurp an existing initialize so ours can be called first.
+    # We rename it __child_initialize and call it from initialize.
+    if self.private_instance_methods(false).include?("initialize")
+      $VERBOSE, verbose = nil, $VERBOSE
+      self.class_eval {
+        alias :__child_initialize :initialize
+        remove_method :initialize
+      }
+      $VERBOSE = verbose
+    end
+    obj = self.new
+    obj.__parse_command_line(argv)
+    obj.main
+
+    #alias :user_init :initialize
+    #@@child_class.new.main if ($0 == @@appname)
+    obj
+    rescue => err
+      puts "ERROR: #{err}"
+      exit(-1)
+  end
+
+  def self.inherited(child_class)
+    @@appname = caller[0][/.*:/][0..-2]
+    @@child_class = child_class
+    if @@appname == $0
+      __set_auto_run
+    end
+  end
+
+  def self.__set_auto_run
+    at_exit { @@child_class.run }
+  end
+  
+  def main
+    #raise(MissingMainError, "Method #main must be defined in class #{@@child_class}.")
+    @@child_class.class_eval %{ def main; end }
+    #self.class_eval %{ def main; end }
+  end
+
+  def __save_argv
+    return unless @replay
+
+    line = 0
+    File.open(@replay_file, "w") { |f|
+      @argv.each { |arg|
+        f.puts "\n" if arg[0] == ?- && line != 0
+        f.print " #{arg}"
+        line += 1
+      }
+    }
+  end
+  
+  def __restore_argv
+    @argv = File.read(@replay_file).gsub(/\n/, "").split
+    raise "Bad @argv" unless @argv.kind_of?(Array)
+  end
+  
+  def __parse_command_line(argv)
+    @argv = argv
+    if @replay && File.exist?(@replay_file) && !@argv.grep("-r").empty?
+      __restore_argv
+    elsif @argv.empty? && @arg_arity[0] != 0
+      puts usage
+      exit(0)
+    end
+
+    begin
+      @option_data = @option_parser.parse(@argv)
+      @args = @option_data.args
+    rescue => err
+      puts err
+      puts
+      puts usage
+      exit(-1)
+    end
+
+    __validate_args(@option_data.args)
+    @arg_names.each_with_index { |name, idx|
+      instance_variable_set("@#{name}", @option_data.args[idx])
+    }
+    
+    __save_argv
+  end
+
+  def __validate_arg_arity(arity)
+    min, max = *arity
+    raise(InvalidArgumentArityError, "Minimum argument arity '#{min}' must be "+
+      "greater than or equal to 0.") unless min >= 0
+    raise(InvalidArgumentArityError, "Maximum argument arity '#{max}' must be "+
+      "greater than or equal to -1.") if max < -1
+    raise(InvalidArgumentArityError, "Maximum argument arity '#{max}' must be "+
+      "greater than minimum arg_arity '#{min}'.") if max < min && max != -1
+  end
+
+  def __initialize_text_formatting
+    #
+    # Formatting defaults
+    #
+    console_width = ENV["COLUMNS"]
+    @columns = 
+      if console_width.nil?
+        DEFAULT_CONSOLE_WIDTH
+      elsif console_width < MIN_CONSOLE_WIDTH
+        console_width
+      else
+        console_width - DEFAULT_BODY_INDENT
+      end
+    @body_indent   = DEFAULT_BODY_INDENT
+    @tag_paragraph = false
+    @order         = :index  # | :alpha
+  end
+
+  def __validate_args(od_args)
+    size = od_args.size
+    min, max = @arg_arity
+    max = 1.0/0.0 if -1 == max
+    raise(ArgumentError,
+      "Missing expected arguments. Found #{size} but expected #{min}. "+
+      "#{od_args.inspect}\n"+
+      "#{usage}") if size < min
+    raise(ArgumentError, "Too many arguments. Found #{size} but "+
+      "expected #{max}.\n#{usage}") if size > max
+  end
+
+  def __help
+     {
+       :names           => %w(--help -h),
+       :arity           => [0,0],
+       :opt_description => "Displays help page.",
+       :arg_description => "",
+       :opt_found       => lambda { puts man; exit },
+       :opt_not_found   => false
+     }
+  end
+
+  def __verbose
+     {
+       :names           => %w(--verbose -v),
+       :arity           => [0,0],
+       :opt_description => "Sets verbosity level. Subsequent "+
+                           "flags increase verbosity level",
+       :arg_description => "",
+       :opt_found       => lambda { @verbose ||= -1; @verbose += 1 },
+       :opt_not_found   => nil
+     }
+  end
+
+  def __version
+     {
+       :names           => %w(--version -V),
+       :arity           => [0,0],
+       :opt_description => "Displays application version.",
+       :arg_description => "",
+       :opt_found       => lambda { 
+                             begin 
+                               puts "#{name} - Version: #{version}"
+                             rescue 
+                               puts "No version specified" 
+                             end; 
+                             exit 
+                           },
+       :opt_not_found   => nil
+     }
+  end
+
+  def __debug
+     {
+       :names           => %w(--debug -d),
+       :arity           => [0,0],
+       :opt_description => "Sets debug to true.",
+       :arg_description => "",
+       :opt_found       => lambda { $DEBUG = true }
+     }
+  end
+end#class Application
+
+Application_wo_AutoRun = Class.new(Application)
+class Application_wo_AutoRun
+  def self.inherited(child_class)
+    @@appname = caller[0][/.*:/][0..-2]
+    @@child_class = child_class
+  end
+end
+
+end#module CommandLine

data/lib/commandline/kernel.rb

@@ -0,0 +1,17 @@
+# This file contains additions to the Kernel module.
+# Essentially, any functions that need global access go here.
+
+module Kernel
+  
+  # This is a simple debug that takes either a description and an argument
+  # or just an argument.
+  # We may want to add more debug statements, maybe some that use pp or inspect.
+  def debug(desc, *arg)
+    return unless $DEBUG
+    if arg.empty?
+      puts "==>  #{desc}" 
+    else
+      puts "==>  #{desc}: #{arg.join(", ")}"
+    end
+  end
+end