Class: OptionParser

Inherits:
Object
  • Object
show all
Defined in:
lib/llm/shell/internal/optparse/lib/optparse.rb,
lib/llm/shell/internal/optparse/lib/optparse/kwargs.rb

Overview

–

Developer Documentation (not for RDoc output)

Class tree

  • OptionParser

    front end

  • OptionParser::Switch

    each switches

  • OptionParser::List

    options list

  • OptionParser::ParseError

    errors on parsing

    • OptionParser::AmbiguousOption

    • OptionParser::NeedlessArgument

    • OptionParser::MissingArgument

    • OptionParser::InvalidOption

    • OptionParser::InvalidArgument

      • OptionParser::AmbiguousArgument

Object relationship diagram

+--------------+
| OptionParser |<>-----+
+--------------+       |                      +--------+
                       |                    ,-| Switch |
     on_head -------->+---------------+    /  +--------+
     accept/reject -->| List          |<|>-
                      |               |<|>-  +----------+
     on ------------->+---------------+    `-| argument |
                        :           :        |  class   |
                      +---------------+      |==========|
     on_tail -------->|               |      |pattern   |
                      +---------------+      |----------|
OptionParser.accept ->| DefaultList   |      |converter |
             reject   |(shared between|      +----------+
                      | all instances)|
                      +---------------+

++

OptionParser

New to OptionParser?

See the Tutorial.

Introduction

OptionParser is a class for command-line option analysis. It is much more advanced, yet also easier to use, than GetoptLong, and is a more Ruby-oriented solution.

Features

  1. The argument specification and the code to handle it are written in the same place.

  2. It can output an option summary; you don’t need to maintain this string separately.

  3. Optional and mandatory arguments are specified very gracefully.

  4. Arguments can be automatically converted to a specified class.

  5. Arguments can be restricted to a certain set.

All of these features are demonstrated in the examples below. See #make_switch for full documentation.

Minimal example

require 'optparse'

options = {}
OptionParser.new do |parser|
  parser.banner = "Usage: example.rb [options]"

  parser.on("-v", "--[no-]verbose", "Run verbosely") do |v|
    options[:verbose] = v
  end
end.parse!

p options
p ARGV

Generating Help

OptionParser can be used to automatically generate help for the commands you write:

require 'optparse'

Options = Struct.new(:name)

class Parser
  def self.parse(options)
    args = Options.new("world")

    opt_parser = OptionParser.new do |parser|
      parser.banner = "Usage: example.rb [options]"

      parser.on("-nNAME", "--name=NAME", "Name to say hello to") do |n|
        args.name = n
      end

      parser.on("-h", "--help", "Prints this help") do
        puts parser
        exit
      end
    end

    opt_parser.parse!(options)
    return args
  end
end
options = Parser.parse %w[--help]

#=>
   # Usage: example.rb [options]
   #     -n, --name=NAME                  Name to say hello to
   #     -h, --help                       Prints this help

Required Arguments

For options that require an argument, option specification strings may include an option name in all caps. If an option is used without the required argument, an exception will be raised.

require 'optparse'

options = {}
OptionParser.new do |parser|
  parser.on("-r", "--require LIBRARY",
            "Require the LIBRARY before executing your script") do |lib|
    puts "You required #{lib}!"
  end
end.parse!

Used:

$ ruby optparse-test.rb -r
optparse-test.rb:9:in '<main>': missing argument: -r (OptionParser::MissingArgument)
$ ruby optparse-test.rb -r my-library
You required my-library!

Type Coercion

OptionParser supports the ability to coerce command line arguments into objects for us.

OptionParser comes with a few ready-to-use kinds of type coercion. They are:

  • Date – Anything accepted by Date.parse (need to require optparse/date)

  • DateTime – Anything accepted by DateTime.parse (need to require optparse/date)

  • Time – Anything accepted by Time.httpdate or Time.parse (need to require optparse/time)

  • URI – Anything accepted by URI.parse (need to require optparse/uri)

  • Shellwords – Anything accepted by Shellwords.shellwords (need to require optparse/shellwords)

  • String – Any non-empty string

  • Integer – Any integer. Will convert octal. (e.g. 124, -3, 040)

  • Float – Any float. (e.g. 10, 3.14, -100E+13)

  • Numeric – Any integer, float, or rational (1, 3.4, 1/3)

  • DecimalInteger – Like Integer, but no octal format.

  • OctalInteger – Like Integer, but no decimal format.

  • DecimalNumeric – Decimal integer or float.

  • TrueClass – Accepts ‘+, yes, true, -, no, false’ and defaults as true

  • FalseClass – Same as TrueClass, but defaults to false

  • Array – Strings separated by ‘,’ (e.g. 1,2,3)

  • Regexp – Regular expressions. Also includes options.

We can also add our own coercions, which we will cover below.

Using Built-in Conversions

As an example, the built-in Time conversion is used. The other built-in conversions behave in the same way. OptionParser will attempt to parse the argument as a Time. If it succeeds, that time will be passed to the handler block. Otherwise, an exception will be raised.

require 'optparse'
require 'optparse/time'
OptionParser.new do |parser|
  parser.on("-t", "--time [TIME]", Time, "Begin execution at given time") do |time|
    p time
  end
end.parse!

Used:

$ ruby optparse-test.rb  -t nonsense
... invalid argument: -t nonsense (OptionParser::InvalidArgument)
$ ruby optparse-test.rb  -t 10-11-12
2010-11-12 00:00:00 -0500
$ ruby optparse-test.rb  -t 9:30
2014-08-13 09:30:00 -0400

Creating Custom Conversions

The accept method on OptionParser may be used to create converters. It specifies which conversion block to call whenever a class is specified. The example below uses it to fetch a User object before the on handler receives it.

require 'optparse'

User = Struct.new(:id, :name)

def find_user id
  not_found = ->{ raise "No User Found for id #{id}" }
  [ User.new(1, "Sam"),
    User.new(2, "Gandalf") ].find(not_found) do |u|
    u.id == id
  end
end

op = OptionParser.new
op.accept(User) do |user_id|
  find_user user_id.to_i
end

op.on("--user ID", User) do |user|
  puts user
end

op.parse!

Used:

$ ruby optparse-test.rb --user 1
#<struct User id=1, name="Sam">
$ ruby optparse-test.rb --user 2
#<struct User id=2, name="Gandalf">
$ ruby optparse-test.rb --user 3
optparse-test.rb:15:in 'block in find_user': No User Found for id 3 (RuntimeError)

Store options to a Hash

The into option of order, parse and so on methods stores command line options into a Hash.

require 'optparse'

options = {}
OptionParser.new do |parser|
  parser.on('-a')
  parser.on('-b NUM', Integer)
  parser.on('-v', '--verbose')
end.parse!(into: options)

p options

Used:

$ ruby optparse-test.rb -a
{:a=>true}
$ ruby optparse-test.rb -a -v
{:a=>true, :verbose=>true}
$ ruby optparse-test.rb -a -b 100
{:a=>true, :b=>100}

Complete example

The following example is a complete Ruby program. You can run it and see the effect of specifying various options. This is probably the best way to learn the features of optparse.

require 'optparse'
require 'optparse/time'
require 'ostruct'
require 'pp'

class OptparseExample
  Version = '1.0.0'

  CODES = %w[iso-2022-jp shift_jis euc-jp utf8 binary]
  CODE_ALIASES = { "jis" => "iso-2022-jp", "sjis" => "shift_jis" }

  class ScriptOptions
    attr_accessor :library, :inplace, :encoding, :transfer_type,
                  :verbose, :extension, :delay, :time, :record_separator,
                  :list

    def initialize
      self.library = []
      self.inplace = false
      self.encoding = "utf8"
      self.transfer_type = :auto
      self.verbose = false
    end

    def define_options(parser)
      parser.banner = "Usage: example.rb [options]"
      parser.separator ""
      parser.separator "Specific options:"

      # add additional options
      perform_inplace_option(parser)
      delay_execution_option(parser)
      execute_at_time_option(parser)
      specify_record_separator_option(parser)
      list_example_option(parser)
      specify_encoding_option(parser)
      optional_option_argument_with_keyword_completion_option(parser)
      boolean_verbose_option(parser)

      parser.separator ""
      parser.separator "Common options:"
      # No argument, shows at tail.  This will print an options summary.
      # Try it and see!
      parser.on_tail("-h", "--help", "Show this message") do
        puts parser
        exit
      end
      # Another typical switch to print the version.
      parser.on_tail("--version", "Show version") do
        puts Version
        exit
      end
    end

    def perform_inplace_option(parser)
      # Specifies an optional option argument
      parser.on("-i", "--inplace [EXTENSION]",
                "Edit ARGV files in place",
                "(make backup if EXTENSION supplied)") do |ext|
        self.inplace = true
        self.extension = ext || ''
        self.extension.sub!(/\A\.?(?=.)/, ".")  # Ensure extension begins with dot.
      end
    end

    def delay_execution_option(parser)
      # Cast 'delay' argument to a Float.
      parser.on("--delay N", Float, "Delay N seconds before executing") do |n|
        self.delay = n
      end
    end

    def execute_at_time_option(parser)
      # Cast 'time' argument to a Time object.
      parser.on("-t", "--time [TIME]", Time, "Begin execution at given time") do |time|
        self.time = time
      end
    end

    def specify_record_separator_option(parser)
      # Cast to octal integer.
      parser.on("-F", "--irs [OCTAL]", OptionParser::OctalInteger,
                "Specify record separator (default \\0)") do |rs|
        self.record_separator = rs
      end
    end

    def list_example_option(parser)
      # List of arguments.
      parser.on("--list x,y,z", Array, "Example 'list' of arguments") do |list|
        self.list = list
      end
    end

    def specify_encoding_option(parser)
      # Keyword completion.  We are specifying a specific set of arguments (CODES
      # and CODE_ALIASES - notice the latter is a Hash), and the user may provide
      # the shortest unambiguous text.
      code_list = (CODE_ALIASES.keys + CODES).join(', ')
      parser.on("--code CODE", CODES, CODE_ALIASES, "Select encoding",
                "(#{code_list})") do |encoding|
        self.encoding = encoding
      end
    end

    def optional_option_argument_with_keyword_completion_option(parser)
      # Optional '--type' option argument with keyword completion.
      parser.on("--type [TYPE]", [:text, :binary, :auto],
                "Select transfer type (text, binary, auto)") do |t|
        self.transfer_type = t
      end
    end

    def boolean_verbose_option(parser)
      # Boolean switch.
      parser.on("-v", "--[no-]verbose", "Run verbosely") do |v|
        self.verbose = v
      end
    end
  end

  #
  # Return a structure describing the options.
  #
  def parse(args)
    # The options specified on the command line will be collected in
    # *options*.

    @options = ScriptOptions.new
    @args = OptionParser.new do |parser|
      @options.define_options(parser)
      parser.parse!(args)
    end
    @options
  end

  attr_reader :parser, :options
end  # class OptparseExample

example = OptparseExample.new
options = example.parse(ARGV)
pp options # example.options
pp ARGV

Shell Completion

For modern shells (e.g. bash, zsh, etc.), you can use shell completion for command line options.

Further documentation

The above examples, along with the accompanying Tutorial, should be enough to learn how to use this class. If you have any questions, file a ticket at bugs.ruby-lang.org.

Direct Known Subclasses

AC

Defined Under Namespace

Modules: Acceptables, Arguable, Completion Classes: AC, AmbiguousArgument, AmbiguousOption, CompletingHash, InvalidArgument, InvalidOption, List, MissingArgument, NeedlessArgument, OptionMap, ParseError, Switch

Constant Summary collapse

Version =

The version string

"0.7.0.dev.2"
NoArgument =

:stopdoc:

[NO_ARGUMENT = :NONE, nil].freeze
RequiredArgument = 
[REQUIRED_ARGUMENT = :REQUIRED, true].freeze
OptionalArgument = 
[OPTIONAL_ARGUMENT = :OPTIONAL, false].freeze
ArgumentStyle =

Enumeration of acceptable argument styles. Possible values are:

NO_ARGUMENT

The switch takes no arguments. (:NONE)

REQUIRED_ARGUMENT

The switch requires an argument. (:REQUIRED)

OPTIONAL_ARGUMENT

The switch requires an optional argument. (:OPTIONAL)

Use like –switch=argument (long style) or -Xargument (short style). For short style, only portion matched to argument pattern is treated as argument.

{}
DefaultList =

Switches common used such as ‘–’, and also provides default argument classes

List.new
COMPSYS_HEADER =

:nodoc:

<<'XXX'      # :nodoc:

typeset -A opt_args
local context state line

_argume
Officious =

Default options for ARGV, which never appear in option summary.

{}
SPLAT_PROC =

:nodoc:

proc {|*a| a.length <= 1 ? a.first : a}
DecimalInteger =

Decimal integer format, to be converted to Integer.

/\A[-+]?#{decimal}\z/io
OctalInteger =

Ruby/C like octal/hexadecimal/binary integer format, to be converted to Integer.

/\A[-+]?(?:[0-7]+(?:_[0-7]+)*|0(?:#{binary}|#{hex}))\z/io
DecimalNumeric =

Decimal integer/float number format, to be converted to Integer for integer format, Float for float format.

floatpat

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(banner = nil, width = 32, indent = ' ' * 4) {|_self| ... } ⇒ OptionParser

Initializes the instance and yields itself if called with a block.

banner

Banner message.

width

Summary width.

indent

Summary indent.

Yields:

  • (_self)

Yield Parameters:

  • _self (OptionParser) —

    the object that the method was called on



1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1184

def initialize(banner = nil, width = 32, indent = ' ' * 4)
  @stack = [DefaultList, List.new, List.new]
  @program_name = nil
  @banner = banner
  @summary_width = width
  @summary_indent = indent
  @default_argv = ARGV
  @require_exact = false
  @raise_unknown = true
  add_officious
  yield self if block_given?
end

Instance Attribute Details

Heading banner preceding summary.



1284
1285
1286
1287
1288
1289
1290
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1284

def banner
  unless @banner
    @banner = +"Usage: #{program_name} [options]"
    visit(:add_banner, @banner)
  end
  @banner
end

#default_argv ⇒ Object

Strings to be parsed in default.



1272
1273
1274
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1272

def default_argv
  @default_argv
end

#program_name ⇒ Object

Program name to be emitted in error message and default banner, defaults to $0.



1296
1297
1298
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1296

def program_name
  @program_name || strip_ext(File.basename($0))
end

#raise_unknown ⇒ Object

Whether to raise at unknown option.



1279
1280
1281
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1279

def raise_unknown
  @raise_unknown
end

#release ⇒ Object

Release code



1329
1330
1331
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1329

def release
  (defined?(@release) && @release) || (defined?(::Release) && ::Release) || (defined?(::RELEASE) && ::RELEASE)
end

#require_exact ⇒ Object

Whether to require that options match exactly (disallows providing abbreviated long option as short option).



1276
1277
1278
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1276

def require_exact
  @require_exact
end

#summary_indent ⇒ Object

Indentation for summary. Must be String (or have + String method).



1269
1270
1271
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1269

def summary_indent
  @summary_indent
end

#summary_width ⇒ Object

Width for option list portion of summary. Must be Numeric.



1266
1267
1268
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1266

def summary_width
  @summary_width
end

#version ⇒ Object

Version



1322
1323
1324
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1322

def version
  (defined?(@version) && @version) || (defined?(::Version) && ::Version)
end

Class Method Details

.accept(*args, &blk) ⇒ Object

See #accept.



1239
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1239

def self.accept(*args, &blk) top.accept(*args, &blk) end

.each_const(path, base = ::Object) ⇒ Object

:stopdoc:



57
58
59
60
61
62
63
64
65
 
# File 'lib/llm/shell/internal/optparse/lib/optparse/version.rb', line 57

def each_const(path, base = ::Object)
  path.split(/::|\//).inject(base) do |klass, name|
    raise NameError, path unless Module === klass
    klass.constants.grep(/#{name}/i) do |c|
      klass.const_defined?(c) or next
      klass.const_get(c)
    end
  end
end

.getopts(*args, symbolize_names: false) ⇒ Object

See #getopts.



1944
1945
1946
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1944

def self.getopts(*args, symbolize_names: false)
  new.getopts(*args, symbolize_names: symbolize_names)
end

.inc(arg, default = nil) ⇒ Object

Returns an incremented value of default according to arg.



1161
1162
1163
1164
1165
1166
1167
1168
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1161

def self.inc(arg, default = nil)
  case arg
  when Integer
    arg.nonzero?
  when nil
    default.to_i + 1
  end
end

.reject(*args, &blk) ⇒ Object

See #reject.



1252
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1252

def self.reject(*args, &blk) top.reject(*args, &blk) end

.search_const(klass, name) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/llm/shell/internal/optparse/lib/optparse/version.rb', line 67

def search_const(klass, name)
  klasses = [klass]
  while klass = klasses.shift
    klass.constants.each do |cname|
      klass.const_defined?(cname) or next
      const = klass.const_get(cname)
      yield klass, cname, const if name === cname
      klasses << const if Module === const and const != ::Object
    end
  end
end

.show_version(*pkgs) ⇒ Object

Shows version string in packages if Version is defined.

pkgs

package list



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/llm/shell/internal/optparse/lib/optparse/version.rb', line 10

def show_version(*pkgs)
  progname = ARGV.options.program_name
  result = false
  show = proc do |klass, cname, version|
    str = "#{progname}"
    unless klass == ::Object and cname == :VERSION
      version = version.join(".") if Array === version
      str << ": #{klass}" unless klass == Object
      str << " version #{version}"
    end
    [:Release, :RELEASE].find do |rel|
      if klass.const_defined?(rel)
        str << " (#{klass.const_get(rel)})"
      end
    end
    puts str
    result = true
  end
  if pkgs.size == 1 and pkgs[0] == "all"
    self.search_const(::Object, /\AV(?:ERSION|ersion)\z/) do |klass, cname, version|
      unless cname[1] == ?e and klass.const_defined?(:Version)
        show.call(klass, cname.intern, version)
      end
    end
  else
    pkgs.each do |pkg|
      begin
        pkg = pkg.split(/::|\//).inject(::Object) {|m, c| m.const_get(c)}
        v = case
            when pkg.const_defined?(:Version)
              pkg.const_get(n = :Version)
            when pkg.const_defined?(:VERSION)
              pkg.const_get(n = :VERSION)
            else
              n = nil
              "unknown"
            end
        show.call(pkg, n, v)
      rescue NameError
      end
    end
  end
  result
end

.terminate(arg = nil) ⇒ Object

See #terminate.



1214
1215
1216
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1214

def self.terminate(arg = nil)
  throw :terminate, arg
end

.top ⇒ Object

Returns the global top option list.

Do not use directly.



1224
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1224

def self.top() DefaultList end

.with(*args, &block) ⇒ Object

Initializes a new instance and evaluates the optional block in context of the instance. Arguments args are passed to #new, see there for description of parameters.

This method is deprecated, its behavior corresponds to the older #new method.



1152
1153
1154
1155
1156
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1152

def self.with(*args, &block)
  opts = new(*args)
  opts.instance_eval(&block)
  opts
end

Instance Method Details

#abort(mesg = $!) ⇒ Object

Shows message with the program name then aborts.

mesg

Message, defaulted to $!.

See Kernel#abort.



1362
1363
1364
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1362

def abort(mesg = $!)
  super("#{program_name}: #{mesg}")
end

#accept(*args, &blk) ⇒ Object

Directs to accept specified class t. The argument string is passed to the block in which it should be converted to the desired class.

t

Argument class specifier, any object including Class.

pat

Pattern for argument, defaults to t if it responds to match.

accept(t, pat, &block)



1235
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1235

def accept(*args, &blk) top.accept(*args, &blk) end

#add_officious ⇒ Object

:nodoc:



1197
1198
1199
1200
1201
1202
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1197

def add_officious  # :nodoc:
  list = base()
  Officious.each do |opt, block|
    list.long[opt] ||= block.call(self)
  end
end

#additional_message(typ, opt) ⇒ Object

Returns additional info.



1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1995

def additional_message(typ, opt)
  return unless typ and opt and defined?(DidYouMean::SpellChecker)
  all_candidates = []
  visit(:get_candidates, typ) do |candidates|
    all_candidates.concat(candidates)
  end
  all_candidates.select! {|cand| cand.is_a?(String) }
  checker = DidYouMean::SpellChecker.new(dictionary: all_candidates)
  DidYouMean.formatter.message_for(all_candidates & checker.correct(opt))
end

#base ⇒ Object

Subject of #on_tail.



1376
1377
1378
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1376

def base
  @stack[1]
end

#candidate(word) ⇒ Object

Return candidates for word.



2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 2009

def candidate(word)
  list = []
  case word
  when '-'
    long = short = true
  when /\A--/
    word, arg = word.split(/=/, 2)
    argpat = Completion.regexp(arg, false) if arg and !arg.empty?
    long = true
  when /\A-/
    short = true
  end
  pat = Completion.regexp(word, long)
  visit(:each_option) do |opt|
    next unless Switch === opt
    opts = (long ? opt.long : []) + (short ? opt.short : [])
    opts = Completion.candidate(word, true, pat, &opts.method(:each)).map(&:first) if pat
    if /\A=/ =~ opt.arg
      opts.map! {|sw| sw + "="}
      if arg and CompletingHash === opt.pattern
        if opts = opt.pattern.candidate(arg, false, argpat)
          opts.map!(&:last)
        end
      end
    end
    list.concat(opts)
  end
  list
end

#compsys(to, name = File.basename($0)) ⇒ Object

:nodoc:



1050
1051
1052
1053
1054
1055
1056
1057
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1050

def compsys(to, name = File.basename($0)) # :nodoc:
  to << "#compdef #{name}\n"
  to << COMPSYS_HEADER
  visit(:compsys, {}, {}) {|o, d|
    to << %Q[  "#{o}[#{d.gsub(/[\\\"\[\]]/, '\\\\\&')}]" \\\n]
  }
  to << "  '*:file:_files' && return 0\n"
end

#define(*opts, &block) ⇒ Object Also known as: def_option

:call-seq:

define(*params, &block)

:include: ../doc/optparse/creates_option.rdoc



1634
1635
1636
1637
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1634

def define(*opts, &block)
  top.append(*(sw = make_switch(opts, block)))
  sw[0]
end

#define_by_keywords(options, method, **params) ⇒ Object

:call-seq:

define_by_keywords(options, method, **params)

:include: ../../doc/optparse/creates_option.rdoc

Defines options which set in to options for keyword parameters of method.

Parameters for each keywords are given as elements of params.



15
16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/llm/shell/internal/optparse/lib/optparse/kwargs.rb', line 15

def define_by_keywords(options, method, **params)
  method.parameters.each do |type, name|
    case type
    when :key, :keyreq
      op, cl = *(type == :key ? %w"[ ]" : ["", ""])
      define("--#{name}=#{op}#{name.upcase}#{cl}", *params[name]) do |o|
        options[name] = o
      end
    end
  end
  options
end

#define_head(*opts, &block) ⇒ Object Also known as: def_head_option

:call-seq:

define_head(*params, &block)

:include: ../doc/optparse/creates_option.rdoc



1655
1656
1657
1658
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1655

def define_head(*opts, &block)
  top.prepend(*(sw = make_switch(opts, block)))
  sw[0]
end

#define_tail(*opts, &block) ⇒ Object Also known as: def_tail_option

:call-seq:

define_tail(*params, &block)

:include: ../doc/optparse/creates_option.rdoc



1678
1679
1680
1681
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1678

def define_tail(*opts, &block)
  base.append(*(sw = make_switch(opts, block)))
  sw[0]
end

#environment(env = File.basename($0, '.*'), **keywords) ⇒ Object

Parses environment variable env or its uppercase with splitting like a shell.

env defaults to the basename of the program.



2090
2091
2092
2093
2094
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 2090

def environment(env = File.basename($0, '.*'), **keywords)
  env = ENV[env] || ENV[env.upcase] or return
  require 'shellwords'
  parse(*Shellwords.shellwords(env), **keywords)
end

#getopts(*args, symbolize_names: false, **keywords) ⇒ Object

Wrapper method for getopts.rb.

params = ARGV.getopts("ab:", "foo", "bar:", "zot:Z;zot option")
# params["a"] = true   # -a
# params["b"] = "1"    # -b1
# params["foo"] = "1"  # --foo
# params["bar"] = "x"  # --bar x
# params["zot"] = "z"  # --zot Z

Option symbolize_names (boolean) specifies whether returned Hash keys should be Symbols; defaults to false (use Strings).

params = ARGV.getopts("ab:", "foo", "bar:", "zot:Z;zot option", symbolize_names: true)
# params[:a] = true   # -a
# params[:b] = "1"    # -b1
# params[:foo] = "1"  # --foo
# params[:bar] = "x"  # --bar x
# params[:zot] = "z"  # --zot Z



1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1906

def getopts(*args, symbolize_names: false, **keywords)
  argv = Array === args.first ? args.shift : default_argv
  single_options, *long_options = *args

  result = {}
  setter = (symbolize_names ?
              ->(name, val) {result[name.to_sym] = val}
            : ->(name, val) {result[name] = val})

  single_options.scan(/(.)(:)?/) do |opt, val|
    if val
      setter[opt, nil]
      define("-#{opt} VAL")
    else
      setter[opt, false]
      define("-#{opt}")
    end
  end if single_options

  long_options.each do |arg|
    arg, desc = arg.split(';', 2)
    opt, val = arg.split(':', 2)
    if val
      setter[opt, (val unless val.empty?)]
      define("--#{opt}=#{result[opt] || "VAL"}", *[desc].compact)
    else
      setter[opt, false]
      define("--#{opt}", *[desc].compact)
    end
  end

  parse_in_order(argv, setter, **keywords)
  result
end

#help ⇒ Object Also known as: to_s

Returns option summary string.



1421
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1421

def help; summarize("#{banner}".sub(/\n?\z/, "\n")) end

#help_exit ⇒ Object 



1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1059

def help_exit
  if $stdout.tty? && (pager = ENV.values_at(*%w[RUBY_PAGER PAGER]).find {|e| e && !e.empty?})
    less = ENV["LESS"]
    args = [{"LESS" => "#{less} -Fe"}, pager, "w"]
    print = proc do |f|
      f.puts help
    rescue Errno::EPIPE
      # pager terminated
    end
    if Process.respond_to?(:fork) and false
      IO.popen("-") {|f| f ? Process.exec(*args, in: f) : print.call($stdout)}
      # unreachable
    end
    IO.popen(*args, &print)
  else
    puts help
  end
  exit
end

#inc(*args) ⇒ Object

See self.inc



1173
1174
1175
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1173

def inc(*args)
  self.class.inc(*args)
end

#inspect ⇒ Object

:nodoc:



1442
1443
1444
1445
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1442

def inspect                   # :nodoc:
  require 'pp'
  pretty_print_inspect
end

#load(filename = nil, **keywords) ⇒ Object

Loads options from file names as filename. Does nothing when the file is not present. Returns whether successfully loaded.

filename defaults to basename of the program without suffix in a directory ~/.options, then the basename with ‘.options’ suffix under XDG and Haiku standard places.

The optional into keyword argument works exactly like that accepted in method #parse.



2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 2050

def load(filename = nil, **keywords)
  unless filename
    basename = File.basename($0, '.*')
    return true if load(File.expand_path("~/.options/#{basename}"), **keywords) rescue nil
    basename << ".options"
    if !(xdg = ENV['XDG_CONFIG_HOME']) or xdg.empty?
      # https://specifications.freedesktop.org/basedir-spec/latest/#variables
      #
      # If $XDG_CONFIG_HOME is either not set or empty, a default
      # equal to $HOME/.config should be used.
      xdg = ['~/.config', true]
    end
    return [
      xdg,

      *ENV['XDG_CONFIG_DIRS']&.split(File::PATH_SEPARATOR),

      # Haiku
      ['~/config/settings', true],
    ].any? {|dir, expand|
      next if !dir or dir.empty?
      filename = File.join(dir, basename)
      filename = File.expand_path(filename) if expand
      load(filename, **keywords) rescue nil
    }
  end
  begin
    parse(*File.readlines(filename, chomp: true), **keywords)
    true
  rescue Errno::ENOENT, Errno::ENOTDIR
    false
  end
end

#make_switch(opts, block = nil) ⇒ Object

:call-seq:

make_switch(params, block = nil)

:include: ../doc/optparse/creates_option.rdoc



1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1476

def make_switch(opts, block = nil)
  short, long, nolong, style, pattern, conv, not_pattern, not_conv, not_style = [], [], []
  ldesc, sdesc, desc, arg = [], [], []
  default_style = Switch::NoArgument
  default_pattern = nil
  klass = nil
  q, a = nil
  has_arg = false
  values = nil

  opts.each do |o|
    # argument class
    next if search(:atype, o) do |pat, c|
      klass = notwice(o, klass, 'type')
      if not_style and not_style != Switch::NoArgument
        not_pattern, not_conv = pat, c
      else
        default_pattern, conv = pat, c
      end
    end

    # directly specified pattern(any object possible to match)
    if !Completion.completable?(o) and o.respond_to?(:match)
      pattern = notwice(o, pattern, 'pattern')
      if pattern.respond_to?(:convert)
        conv = pattern.method(:convert).to_proc
      else
        conv = SPLAT_PROC
      end
      next
    end

    # anything others
    case o
    when Proc, Method
      block = notwice(o, block, 'block')
    when Array, Hash, Set
      if Array === o
        o, v = o.partition {|v,| Completion.completable?(v)}
        values = notwice(v, values, 'values') unless v.empty?
        next if o.empty?
      end
      case pattern
      when CompletingHash
      when nil
        pattern = CompletingHash.new
        conv = pattern.method(:convert).to_proc if pattern.respond_to?(:convert)
      else
        raise ArgumentError, "argument pattern given twice"
      end
      o.each {|pat, *v| pattern[pat] = v.fetch(0) {pat}}
    when Range
      values = notwice(o, values, 'values')
    when Module
      raise ArgumentError, "unsupported argument type: #{o}", ParseError.filter_backtrace(caller(4))
    when *ArgumentStyle.keys
      style = notwice(ArgumentStyle[o], style, 'style')
    when /\A--no-([^\[\]=\s]*)(.+)?/
      q, a = $1, $2
      o = notwice(a ? Object : TrueClass, klass, 'type')
      not_pattern, not_conv = search(:atype, o) unless not_style
      not_style = (not_style || default_style).guess(arg = a) if a
      default_style = Switch::NoArgument
      default_pattern, conv = search(:atype, FalseClass) unless default_pattern
      ldesc << "--no-#{q}"
      (q = q.downcase).tr!('_', '-')
      long << "no-#{q}"
      nolong << q
    when /\A--\[no-\]([^\[\]=\s]*)(.+)?/
      q, a = $1, $2
      o = notwice(a ? Object : TrueClass, klass, 'type')
      if a
        default_style = default_style.guess(arg = a)
        default_pattern, conv = search(:atype, o) unless default_pattern
      end
      ldesc << "--[no-]#{q}"
      (o = q.downcase).tr!('_', '-')
      long << o
      not_pattern, not_conv = search(:atype, FalseClass) unless not_style
      not_style = Switch::NoArgument
      nolong << "no-#{o}"
    when /\A--([^\[\]=\s]*)(.+)?/
      q, a = $1, $2
      if a
        o = notwice(NilClass, klass, 'type')
        default_style = default_style.guess(arg = a)
        default_pattern, conv = search(:atype, o) unless default_pattern
      end
      ldesc << "--#{q}"
      (o = q.downcase).tr!('_', '-')
      long << o
    when /\A-(\[\^?\]?(?:[^\\\]]|\\.)*\])(.+)?/
      q, a = $1, $2
      o = notwice(Object, klass, 'type')
      if a
        default_style = default_style.guess(arg = a)
        default_pattern, conv = search(:atype, o) unless default_pattern
      else
        has_arg = true
      end
      sdesc << "-#{q}"
      short << Regexp.new(q)
    when /\A-(.)(.+)?/
      q, a = $1, $2
      if a
        o = notwice(NilClass, klass, 'type')
        default_style = default_style.guess(arg = a)
        default_pattern, conv = search(:atype, o) unless default_pattern
      end
      sdesc << "-#{q}"
      short << q
    when /\A=/
      style = notwice(default_style.guess(arg = o), style, 'style')
      default_pattern, conv = search(:atype, Object) unless default_pattern
    else
      desc.push(o) if o && !o.empty?
    end
  end

  default_pattern, conv = search(:atype, default_style.pattern) unless default_pattern
  if Range === values and klass
    unless (!values.begin or klass === values.begin) and
          (!values.end or klass === values.end)
      raise ArgumentError, "range does not match class"
    end
  end
  if !(short.empty? and long.empty?)
    if has_arg and default_style == Switch::NoArgument
      default_style = Switch::RequiredArgument
    end
    s = (style || default_style).new(pattern || default_pattern,
                                     conv, sdesc, ldesc, arg, desc, block, values)
  elsif !block
    if style or pattern
      raise ArgumentError, "no switch given", ParseError.filter_backtrace(caller)
    end
    s = desc
  else
    short << pattern
    s = (style || default_style).new(pattern,
                                     conv, nil, nil, arg, desc, block, values)
  end
  return s, short, long,
    (not_style.new(not_pattern, not_conv, sdesc, ldesc, nil, desc, block) if not_style),
    nolong
end

#new ⇒ Object

Pushes a new List.

If a block is given, yields self and returns the result of the block, otherwise returns self.



1386
1387
1388
1389
1390
1391
1392
1393
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1386

def new
  @stack.push(List.new)
  if block_given?
    yield self
  else
    self
  end
end

#on(*opts, &block) ⇒ Object

:call-seq:

on(*params, &block)

:include: ../doc/optparse/creates_option.rdoc



1644
1645
1646
1647
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1644

def on(*opts, &block)
  define(*opts, &block)
  self
end

#on_head(*opts, &block) ⇒ Object

:call-seq:

on_head(*params, &block)

:include: ../doc/optparse/creates_option.rdoc

The new option is added at the head of the summary.



1667
1668
1669
1670
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1667

def on_head(*opts, &block)
  define_head(*opts, &block)
  self
end

#on_tail(*opts, &block) ⇒ Object

:call-seq:

on_tail(*params, &block)

:include: ../doc/optparse/creates_option.rdoc

The new option is added at the tail of the summary.



1691
1692
1693
1694
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1691

def on_tail(*opts, &block)
  define_tail(*opts, &block)
  self
end

#order(*argv, **keywords, &nonopt) ⇒ Object

Parses command line arguments argv in order. When a block is given, each non-option argument is yielded. When optional into keyword argument is provided, the parsed option values are stored there via []= method (so it can be Hash, or OpenStruct, or other similar object).

Returns the rest of argv left unparsed.



1720
1721
1722
1723
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1720

def order(*argv, **keywords, &nonopt)
  argv = argv[0].dup if argv.size == 1 and Array === argv[0]
  order!(argv, **keywords, &nonopt)
end

#order!(argv = default_argv, into: nil, **keywords, &nonopt) ⇒ Object

Same as #order, but removes switches destructively. Non-option arguments remain in argv.



1729
1730
1731
1732
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1729

def order!(argv = default_argv, into: nil, **keywords, &nonopt)
  setter = ->(name, val) {into[name.to_sym] = val} if into
  parse_in_order(argv, setter, **keywords, &nonopt)
end

#parse(*argv, **keywords) ⇒ Object

Parses command line arguments argv in order when environment variable POSIXLY_CORRECT is set, and in permutation mode otherwise. When optional into keyword argument is provided, the parsed option values are stored there via []= method (so it can be Hash, or OpenStruct, or other similar object).



1870
1871
1872
1873
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1870

def parse(*argv, **keywords)
  argv = argv[0].dup if argv.size == 1 and Array === argv[0]
  parse!(argv, **keywords)
end

#parse!(argv = default_argv, **keywords) ⇒ Object

Same as #parse, but removes switches destructively. Non-option arguments remain in argv.



1879
1880
1881
1882
1883
1884
1885
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1879

def parse!(argv = default_argv, **keywords)
  if ENV.include?('POSIXLY_CORRECT')
    order!(argv, **keywords)
  else
    permute!(argv, **keywords)
  end
end

#permute(*argv, **keywords) ⇒ Object

Parses command line arguments argv in permutation mode and returns list of non-option arguments. When optional into keyword argument is provided, the parsed option values are stored there via []= method (so it can be Hash, or OpenStruct, or other similar object).



1847
1848
1849
1850
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1847

def permute(*argv, **keywords)
  argv = argv[0].dup if argv.size == 1 and Array === argv[0]
  permute!(argv, **keywords)
end

#permute!(argv = default_argv, **keywords) ⇒ Object

Same as #permute, but removes switches destructively. Non-option arguments remain in argv.



1856
1857
1858
1859
1860
1861
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1856

def permute!(argv = default_argv, **keywords)
  nonopts = []
  order!(argv, **keywords) {|nonopt| nonopts << nonopt}
  argv[0, 0] = nonopts
  argv
end

#pretty_print(q) ⇒ Object

:nodoc:



1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1424

def pretty_print(q)           # :nodoc:
  q.object_group(self) do
    first = true
    if @stack.size > 2
      @stack.each_with_index do |s, i|
        next if i < 2
        next if s.list.empty?
        if first
          first = false
          q.text ":"
        end
        q.breakable
        s.pretty_print(q)
      end
    end
  end
end

#reject(*args, &blk) ⇒ Object

Directs to reject specified class argument.

type

Argument class specifier, any object including Class.

reject(type)



1248
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1248

def reject(*args, &blk) top.reject(*args, &blk) end

#remove ⇒ Object

Removes the last List.



1398
1399
1400
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1398

def remove
  @stack.pop
end

#separator(string) ⇒ Object

Add separator in summary.



1700
1701
1702
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1700

def separator(string)
  top.append(string, nil, nil)
end

#summarize(to = [], width = @summary_width, max = width - 1, indent = @summary_indent, &blk) ⇒ Object

Puts option summary into to and returns to. Yields each line if a block is given.

to

Output destination, which must have method <<. Defaults to [].

width

Width of left side, defaults to @summary_width.

max

Maximum length allowed for left side, defaults to width - 1.

indent

Indentation, defaults to @summary_indent.



1411
1412
1413
1414
1415
1416
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1411

def summarize(to = [], width = @summary_width, max = width - 1, indent = @summary_indent, &blk)
  nl = "\n"
  blk ||= proc {|l| to << (l.index(nl, -1) ? l : l + nl)}
  visit(:summarize, {}, {}, width, max, indent, &blk)
  to
end

#terminate(arg = nil) ⇒ Object

Terminates option parsing. Optional parameter arg is a string pushed back to be the first non-option argument.



1208
1209
1210
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1208

def terminate(arg = nil)
  self.class.terminate(arg)
end

#to_a ⇒ Object

Returns option summary list.



1450
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1450

def to_a; summarize("#{banner}".split(/^/)) end

#top ⇒ Object

Subject of #on / #on_head, #accept / #reject



1369
1370
1371
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1369

def top
  @stack[-1]
end

#ver ⇒ Object

Returns version string from program_name, version and release.



1336
1337
1338
1339
1340
1341
1342
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1336

def ver
  if v = version
    str = +"#{program_name} #{[v].join('.')}"
    str << " (#{v})" if v = release
    str
  end
end

#warn(mesg = $!) ⇒ Object

Shows warning message with the program name

mesg

Message, defaulted to $!.

See Kernel#warn.



1351
1352
1353
 
# File 'lib/llm/shell/internal/optparse/lib/optparse.rb', line 1351

def warn(mesg = $!)
  super("#{program_name}: #{mesg}")
end