opt-simple 0.7.4 → 0.7.5

data/README

@@ -37,6 +37,66 @@ It is recommended to install OptSimple using RubyGems:
 
 == Examples
 
+=== One example that shows a lot of the behavior you might use
+
+ require 'opt_simple'
+ 
+ min = 5
+ max = 15
+ 
+ options,arguments = OptSimple.new.parse_opts! do 
+   argument %w[-i --infile], "Infile, multiple allowed", "FILE" do | arg |
+     accumulate_opt arg
+   end
+ 
+   option %w[-p --pattern --glob-pattern], "glob pattern","PATTERN"
+ 
+   option %w[-n -num --num-values],"Number of val","VAL" do |arg|
+     set_opt arg.to_i
+   end
+   
+   option "--range", "range: min,max (both >0) default is #{min},#{max}" do | arg1,arg2 |
+     min = arg1.to_i
+     max = arg2.to_i    
+      
+     error "max must be greater than min" unless max > min
+     error "both must be >=0" if min < 0
+   end
+ 
+   flag %w[-v  --verbose],"Verbosity. the more you set, the more we give" do 
+     accumulate_opt
+   end
+ 
+ end
+ 
+ puts "Options"
+ puts options.inspect
+ 
+ puts "Arguments"
+ puts arguments.inspect
+
+ puts "ARGV"
+ puts ARGV
+
+It prints out an automatic usage statement:
+
+  Usage: opt_ex.rb [options]
+ 
+   MANDATORY ARGS:
+     -i, --infile FILE                           Infile, multiple allowed
+
+   OPTIONS:
+     -p, --pattern, --glob-pattern PATTERN       glob pattern
+
+     -n, -num, --num-values VAL                  Number of val
+
+         --range ARG                             range: min,max (both >0) default is 5,15
+
+     -v, --verbose                               Verbosity. the more you set, the more we give
+
+     -h, --help                                  (for this help message)
+
+
 === A very simple example with no error checking. Use at your own risk!
 
  require 'opt_simple'
@@ -46,7 +106,7 @@ It is recommended to install OptSimple using RubyGems:
  } 
  
  options,arguments = OptSimple.new(defaults).parse_opts! 
-
+ 
  puts "Options"
  puts options.inspect
  
@@ -107,46 +167,46 @@ It is recommended to install OptSimple using RubyGems:
 
 === An example that shows how to use 'accumulate_opt' on an option to create a list, and on a flag to increment a counter
 
-require 'opt_simple'
-
-verbosity = 0
-
-options,arguments = OptSimple.new.parse_opts! do 
-  option %w[-i --infile], "Infile, multiple allowed", "INFILE" do | arg |
-    accumulate_opt arg
-  end
-
-  flag %w[-v  --verbose],"Verbosity. the more you set, the more we give" do 
-    verbosity += 1
-  end
-
-  flag %w[-m --more-cow-bell], "I've got a fever" do 
-    accumulate_opt
-  end
-end
-
-puts "Options"
-puts options.inspect
-
-puts "Arguments"
-puts arguments.inspect
-
-puts "Verbosity"
-puts verbosity
-
-puts "ARGV"
-puts ARGV
-
-
-=== An example that shows that you can easily set your defaults in normal Ruby variables and provide your own help.
-
  require 'opt_simple'
  
+ verbosity = 0
+ 
+ options,arguments = OptSimple.new.parse_opts! do 
+   option %w[-i --infile], "Infile, multiple allowed", "FILE" do | arg |
+     accumulate_opt arg
+   end
+ 
+   flag %w[-v  --verbose],"Verbosity. the more you set, the more we give" do 
+     verbosity += 1
+   end
+ 
+   flag %w[-m --more-cow-bell], "I've got a fever" do 
+     accumulate_opt
+   end
+ end
+ 
+ puts "Options"
+ puts options.inspect
+ 
+ puts "Arguments"
+ puts arguments.inspect
+ 
+ puts "Verbosity"
+ puts verbosity
+ 
+ puts "ARGV"
+ puts ARGV
+ 
+ 
+=== An example that shows that you can easily set your defaults in normal Ruby variables and provide your own help.
+ 
+ require 'opt_simple'
+  
  in_file = nil
  min = 0
  max = 10
  pattern = "*"
-
+ 
  usage_string = <<-UL
  Usage: $0 [options]
  
@@ -155,12 +215,12 @@ puts ARGV
   [-p, --pattern, --glob-pattern (default #{pattern})]
   [-v (verbose)]
   [-h, --help (help)]
-
+ 
  UL
-
+ 
  OptSimple.new.parse_opts! do 
    help usage_string
-
+ 
    argument %w[-i --infile],"inFile" do |arg|
      in_file = arg
      error "inFile must exist and be readable" unless(File.readable?(in_file))
@@ -188,8 +248,56 @@ puts ARGV
  
  puts "ARGV"
  puts ARGV
+  
+=== An example showing how to register parms in multiple places before parsing the command line
+
+ require 'opt_simple'
+ 
+ min = 5
+ max = 15
+ 
+ os = OptSimple.new
+ 
+ os.register_opts do 
+   argument %w[-i --infile], "Infile, multiple allowed", "FILE" do | arg |
+     accumulate_opt arg
+   end
+ 
+   option %w[-p --pattern --glob-pattern], "glob pattern","PATTERN"
+ end
+ 
+ os.register_opts do 
+   option %w[-n -num --num-values],"Number of val","VAL" do |arg|
+     set_opt arg.to_i
+   end
+ 
+   option "--range", "range: min,max (both >0) default is #{min},#{max}" do | arg1,arg2 |
+     min = arg1.to_i
+     max = arg2.to_i    
+      
+     error "max must be greater than min" unless max > min
+     error "both must be >=0" if min < 0
+   end
+ 
+   flag %w[-v  --verbose],"Verbosity. the more you set, the more we give" do 
+     accumulate_opt
+   end
+ end
+ 
+ options,arguments = os.parse_opts!
+ 
+ puts "Options"
+ puts options.inspect
+ 
+ puts "Arguments"
+ puts arguments.inspect
+ 
+ puts "ARGV"
+ puts ARGV
+ 
  
 == Questions and/or Comments
-
+ 
 email {Ethan Stryker}[mailto:e.stryker@gmail.com]
-
+ 
+ 

data/lib/opt_simple.rb

@@ -57,94 +57,108 @@ class OptSimple
     @banner = str
   end
 
-  # Parse the options, destructively pulling them out of the args array as it goes.
-  # If no block is given, then a default parser with no error checking will be run. 
-  def parse_opts!(&block)
-    
-    if block_given?
+  # Simply register options without actually parsing them. 
+  # This allows registering parms in multiple places in your code.
+  def register_opts(&block)
+    begin
       # call the block to register all the parameters and
       # their corresponding code blocks
       # We use instance_exec so that the API is cleaner. 
-      begin
-	instance_exec(@options,@positional_arguments,&block)
-      ensure
-	# we are ensuring that the options that occur before any break statement
-	# actually get parsed. 
-	
-	# add the help option at the end
+      instance_exec(@options,@positional_arguments,&block) 
+    ensure
+      # we are ensuring that the options that occur before any break statement
+      # actually get parsed. 
+      
+      # add the help option at the end the first time register_opts is called
+      unless(@parameters.find {|p| p.switches.include?('-h')})
 	flag %w[-h --help] ,"(for this help message)"
-	
-	# first look for a call for help
-	unless (%w[-h --help] & @args).empty?
-	  $stdout.puts self.to_s
-	  exit(0)
-	end
-	
-	mandatory_check = mandatory_opts.map {|m| m.switches}
-
-	if(loc = @args.index('--'))
-	  #remove the '--', but don't include it w/ positional arguments
-	  @positional_arguments += @args.slice!(loc..-1)[1..-1] 
-	end
-	
-	# Handle the case where a user specifies --foo=bar, or --foo=bar,baz
-	equal_args = @args.find_all {|arg| arg.include?('=') }
-	@args.delete_if {|arg| arg.include?('=') }
-	equal_args.each do | e |
-	  switch,list = e.split('=')
-	  @args << switch
-	  list.split(',').each {|val| @args << val }
-	end
+      end
+    end
+  end
 
-	# now actually parse the args, and call all the stored up blocks from the options
-	@parameters.each do | parm |
-	  intersection = @args & parm.switches
-	  unless intersection.empty?
-	    mandatory_check.delete(parm.switches)
-	 
-	    arg_locations =  []
-	    @args.each_with_index {|arg,i| arg_locations << i if intersection.include?(arg) }
-
-	    # we want to process the args in order to provide predictable behavior
-	    # in the case of switch duplication. 
-	    # We do pull them out in reverse so that the slicing removes pieces from the end 
-	    # of @args, so we don't disrupt the other locations, but put them into 'chunks'
-	    # backwards to restore their order. 
-	    chunks = []
-	    arg_locations.sort.reverse.each do |loc|  
-	      chunks.unshift @args.slice!(loc .. loc + parm.block.arity)[1..-1]
-	    end
+  # Parse the options, destructively pulling them out of the args array as it goes.
+  # If no block is given, then a default parser with no error checking will be run. 
+  def parse_opts!(&block)
+    
+    if block_given?
+      register_opts(&block)
+    end
+  
+    if @parameters.empty?
+      #parse the @args array by looking for switches/args by regex
+      default_arg_parser
+    else
+      # go through the  registered parameters, and pull out 
+      # the specified parms from @arg
 
-	    chunks.each do | pieces |
-	      if pieces.length < parm.block.arity or
-		  pieces.any? {|p| p.start_with?('-')}
-		raise OptSimple::ParameterUsageError.new "Not enough args following #{intersection}",self 
-	      end
-	      
-	      begin
-		parm.instance_exec(*pieces,&parm.block)
-	      rescue OptSimple::Error => e
-		raise OptSimple::Error.new e.message,self
-	      end
+      # first look for a call for help
+      unless (%w[-h --help] & @args).empty?
+	$stdout.puts self.to_s
+	exit(0)
+      end
+      
+      mandatory_check = mandatory_opts.map {|m| m.switches}
+      
+      if(loc = @args.index('--'))
+	#remove the '--', but don't include it w/ positional arguments
+	@positional_arguments += @args.slice!(loc..-1)[1..-1] 
+      end
+      
+      # Handle the case where a user specifies --foo=bar, or --foo=bar,baz
+      equal_args = @args.find_all {|arg| arg.include?('=') }
+      @args.delete_if {|arg| arg.include?('=') }
+      equal_args.each do | e |
+	switch,list = e.split('=')
+	@args << switch
+	list.split(',').each {|val| @args << val }
+      end
+      
+      # now actually parse the args, and call all the stored up blocks from the options
+      @parameters.each do | parm |
+	intersection = @args & parm.switches
+	unless intersection.empty?
+	  mandatory_check.delete(parm.switches)
+	  
+	  arg_locations =  []
+	  @args.each_with_index {|arg,i| arg_locations << i if intersection.include?(arg) }
+	  
+	  # we want to process the args in order to provide predictable behavior
+	  # in the case of switch duplication. 
+	  # We do pull them out in reverse so that the slicing removes pieces from the end 
+	  # of @args, so we don't disrupt the other locations, but put them into 'chunks'
+	  # backwards to restore their order. 
+	  chunks = []
+	  arg_locations.sort.reverse.each do |loc|  
+	    chunks.unshift @args.slice!(loc .. loc + parm.block.arity)[1..-1]
+	  end
+	  
+	  chunks.each do | pieces |
+	    if pieces.length < parm.block.arity or
+		pieces.any? {|p| p.start_with?('-')}
+	      raise OptSimple::ParameterUsageError.new "Not enough args following #{intersection}",self 
 	    end
 	    
-	    @options.merge!(parm.param_options)
+	    begin
+	      parm.instance_exec(*pieces,&parm.block)
+	    rescue OptSimple::Error => e
+	      raise OptSimple::Error.new e.message,self
+	    end
 	  end
+	  
+	  @options.merge!(parm.param_options)
 	end
-	
-	unless mandatory_check.empty?
-	  raise MissingArgument.new "Must set the following parameters: #{mandatory_check.map {|a| a.join(' OR ')}.join(', ')}",self
-	end
-
-	extra_switches = @args.find_all {|a| a.start_with?('-') }
-	raise OptSimple::InvalidOption.new "Unknown options: #{extra_switches.join(' ')}",self unless extra_switches.empty?
-	
-	@positional_arguments += @args.slice!(0..-1)
       end
-    else
-      #parse the @args array by looking for switches/args by regex
-      default_arg_parser
-    end	
+      
+      unless mandatory_check.empty?
+	raise MissingArgument.new "Must set the following parameters: #{mandatory_check.map {|a| a.join(' OR ')}.join(', ')}",self
+      end
+      
+      extra_switches = @args.find_all {|a| a.start_with?('-') }
+      raise OptSimple::InvalidOption.new "Unknown options: #{extra_switches.join(' ')}",self unless extra_switches.empty?
+      
+      @positional_arguments += @args.slice!(0..-1)
+    end
+    
     return [@options,@positional_arguments]
   end
 

data/test/test_usage.rb

@@ -55,7 +55,7 @@ class TestHelpStatement < Test::Unit::TestCase
   must "accumulate lists of args when asked" do 
     os = OptSimple.new({},%w[-i foo.bar --infile bar.in])
     o,a = os.parse_opts! do 
-      option %w[-i --infile], "Infile, multiple allowed", "INFILE" do | arg |
+      option %w[-i --infile], "Infile, multiple allowed", "FILE" do | arg |
 	accumulate_opt arg
       end
     end
@@ -78,7 +78,7 @@ class TestHelpStatement < Test::Unit::TestCase
   must "set last arg when duplicated when accumulate opt isn't used" do 
     os = OptSimple.new({},%w[-i foo.bar --infile bar.in -i baz])
     o,a = os.parse_opts! do 
-      option %w[-i --infile], "Infile, multiple allowed", "INFILE" do | arg |
+      option %w[-i --infile], "Infile, multiple allowed", "FILE" do | arg |
 	set_opt arg
       end
     end
@@ -86,5 +86,24 @@ class TestHelpStatement < Test::Unit::TestCase
     assert_equal o['i'],'baz'
     assert_equal o['infile'],'baz'
   end
+
+  must "allow parameters to be registered in multiple spots" do 
+    os = OptSimple.new({},%w[-i foo.bar --outfile bar.out])
+    os.register_opts do 
+      option %w[-i --infile], "Infile", "FILE" do | arg |
+	set_opt arg
+      end
+    end
+
+    os.register_opts do 
+      option %w[-o --outfile], "outfile", "FILE" do | arg |
+	set_opt arg
+      end
+    end
+    o,a = os.parse_opts!
+    
+    assert_equal o['i'],'foo.bar'
+    assert_equal o['o'],'bar.out'
+  end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: opt-simple
 version: !ruby/object:Gem::Version 
-  version: 0.7.4
+  version: 0.7.5
 platform: ruby
 authors: 
 - Ethan Stryker