1
2
3
4
5
6
7
8
9
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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
Slop
====
Slop is a simple option parser with an easy to remember syntax and friendly API.
[](http://travis-ci.org/leejarvis/slop)
Installation
------------
gem install slop
Usage
-----
```ruby
opts = Slop.parse do |o|
o.string '-h', '--host', 'a hostname'
o.integer '--port', 'custom port', default: 80
o.bool '-v', '--verbose', 'enable verbose mode'
o.bool '-q', '--quiet', 'surpress output (quiet mode)'
o.on '--version', 'print the version' do
puts Slop::VERSION
exit
end
end
ARGV #=> -v --host 192.168.0.1
opts[:host] #=> 192.168.0.1
opts.verbose? #=> true
opts.quiet? #=> false
opts.to_hash #=> { host: "192.168.0.1", port: 80, verbose: true, quiet: false }
```
Advanced Usage
--------------
This example is really just to describe how the underlying API works.
It's not necessarily the best way to do it.
```ruby
opts = Slop::Options.new
opts.banner = "usage: connect [options] ..."
opts.separator ""
opts.separator "Connection options:"
opts.string "-H", "--hostname", "a hostname"
opts.int "-p", "--port", "a port", default: 80
opts.separator ""
opts.separator "Extra options:"
opts.array "--files", "a list of files to import"
opts.bool "-v", "--verbose", "enable verbose mode"
parser = Slop::Parser.new(opts)
result = parser.parse(["--hostname", "192.168.0.1"])
result.to_hash #=> { hostname: "192.168.0.1", port: 80,
# files: [], verbose: false }
puts opts # prints out help
```
Arrays
------
Slop has a built in `ArrayOption` for handling array values:
```ruby
opts = Slop.parse do |o|
# the delimiter defaults to ','
o.array '--files', 'a list of files', delimiter: ','
end
# both of these will return o[:files] as ["foo.txt", "bar.rb"]:
# --files foo.txt,bar.rb
# --files foo.txt --files bar.rb
```
Custom option types
-------------------
Slop uses option type classes for every new option added. They default to the
`StringOption`. When you type `o.array` Slop looks for an option called
`Slop::ArrayOption`. This class must contain at least 1 method, `call`. This
method is executed at parse time, and the return value of this method is
used for the option value. We can use this to build custom option types:
```ruby
module Slop
class PathOption < Option
def call(value)
Pathname.new(value)
end
end
end
opts = Slop.parse %w(--path ~/) do |o|
o.path '--path', 'a custom path name'
end
p opts[:path] #=> #<Pathname:~/>
```
Custom options can also implement a `finish` method. This method by default
does nothing, but it's executed once *all* options have been parsed. This
allows us to go back and mutate state without having to rely on options
being parsed in a particular order. Here's an example:
```ruby
module Slop
class FilesOption < ArrayOption
def finish(opts)
if opts.expand?
self.value = value.map { |f| File.expand_path(f) }
end
end
end
end
opts = Slop.parse %w(--files foo.txt,bar.rb -e) do |o|
o.files '--files', 'an array of files'
o.bool '-e', '--expand', 'if used, list of files will be expanded'
end
p opts[:files] #=> ["/full/path/foo.txt", "/full/path/bar.rb"]
```
|
