srl_ruby 0.3.5 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 711c793cad016254dd13088c99e47e4128c54b0e
-  data.tar.gz: d9fdec5bc246ba494554cd86ff5ff2a1851b2491
+  metadata.gz: f476a011aec905f943e525e2fb73770d6fe253b0
+  data.tar.gz: 3a93a4502442762e7101bb46f58be95ac60a7730
 SHA512:
-  metadata.gz: 9dc549cc35d3fe9d0ee75090f4647d38376e531d0f058be1e8d07975e7d260eb14783a618ae2651f63b358f2aa6173da8fca4dadf9d1faa63e1925d0886f2e59
-  data.tar.gz: 80edcec42446d9200cd7d500624461d31258f712a8a0749d73705e0b7f4f7ca703dac892ed3bbd1111f7200049ecb081624f4511531989308b05b7a8555a2cb2
+  metadata.gz: 064d58d3a68227f7f0e636b3228194262bf08b79b07d807edd9c99042fa9e22a39735c4798a9bd918adb24216095849e7e69f5500447e4b2c1fe519823cac5d8
+  data.tar.gz: 63e7d716017d8fc95dfbac33fc1b36e0d4b39bcf0803b192f30b7d772747f5c811619afabcec0dbcb8091788e62d378b982de5e20978bea717f054301b3c4f57

data/.rubocop.yml

@@ -27,6 +27,9 @@ Layout/IndentationWidth:
 Layout/IndentationConsistency:
   Enabled: true
   
+Layout/IndentHeredoc:
+  Enabled: false
+  
 Layout/MultilineHashBraceLayout:
   Enabled: true
 
@@ -99,7 +102,7 @@ Naming/ClassAndModuleCamelCase:
   Enabled: false
   
 Naming/UncommunicativeBlockParamName:
-  Enabled: false
+  Enabled: true
   
 Naming/UncommunicativeMethodParamName:
   Enabled: false
@@ -144,7 +147,7 @@ Style/ConditionalAssignment:
   Enabled: false
 
 Style/DefWithParentheses:
-  Enabled: false
+  Enabled: true
 
 Style/Documentation:
   Enabled: false
@@ -159,7 +162,7 @@ Style/IfUnlessModifier:
   Enabled: false
 
 Style/InverseMethods:
-  Enabled: false
+  Enabled: true
 
 Style/Next:
   Enabled: false
@@ -178,6 +181,9 @@ Style/RegexpLiteral:
 
 Style/PercentLiteralDelimiters:
   Enabled: false
+  
+Style/StderrPuts:
+  Enabled: false  
 
 Style/StringLiterals:
   Enabled: true

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+## [0.4.0] - 2018-05-13
+Version bump: SrlRuby has a command-line compiler `srl2ruby`
+
+### Added
+- File `bin/srl2ruby` A compiler that parses SRL expressions and transform them into regular Regexp.
+- File `srl2ruby_cli_parser.rb` Implementation of the CLI of the `srl2ruby` compiler.
+- Directory `templates` contains ERB templates that can be used to format `srl2ruby` output.
+
+### Changed
+- File `README.md` vastly expanded in order to cover `srl2ruby` compiler and a couple of SRL examples
+- File `.rubocop.yml` enabled some of the complaining cops
+
+### Removed
+- File `srl_ruby` the previous binary of the gem is now replaced by `srl2ruby`.
+
+### Fixed
+- Method `Tokenizer#_next_token` failed to recognize digit or integer value immediately followed by a closing parenthesis ')'.
+- Many classes lightly refactored in order to please Rubocop.
+
+
 ## [0.3.5] - 2018-04-29
 
 ### Added

data/README.md

@@ -5,72 +5,362 @@
 [![License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](https://github.com/famished-tiger/SRL-Ruby/blob/master/LICENSE.txt)
 
 
-This project implements a [Simple Regex Language](https://simple-regex.com) parser and interpreter in Ruby.
+Welcome to the first Ruby implementation of a [Simple Regex Language](https://simple-regex.com) (SRL) parser and compiler.  
+It allows you to write __highly-readable__ text patterns in SRL and then generate their Ruby `Regexp` counterparts.  
+Ever wanted to write challenging regular expressions but were intimided by their arcane, cryptic syntax?  
+With **srl_ruby** you can easily design your patterns in SRL and let *srl_ruby* transform them into terse `Regexp`.
+
+### Features:
+- Command-line SRL-to-Ruby compiler with customizable output.
+- Ruby API for integrating a SRL parser or compiler with your code.
+- 100% pure Ruby with clean design (_not a port from some other language_)
+- Minimal runtime dependency ([Rley](https://rubygems.org/gems/rley) gem). Won't drag a bunch of gems...
+- Compatibility: works with 2.x+ MRI, JRuby
+- Portability: tested on both Linux and Windows,...
 
-## What is SRL?
-[SRL](https://github.com/SimpleRegex) is a small language that lets you write pattern matching expressions
+## Installation
+
+### ...with Bundler
+Add this line to your application's Gemfile:
+
+    gem 'srl_ruby'
+
+And then execute:
+
+    $ bundle
+
+### ...with Rubygem
+Or install it directly yourself with the command line:
+
+    $ gem install srl_ruby
+
+## Usage
+Let's test the installation by launching the __srl2ruby__ (SRL-to-Ruby) command-line compiler with the help option:
+
+    $ srl2ruby --help
+
+It should output something similar to:
+
+```
+Usage: srl2ruby SRL_FILE [options]
+
+Description:
+  Parses a SRL file and compiles it into a Ruby Regexp literal.
+  Simple Regex Language (SRL) website: https://simple-regex.com
+
+Examples:
+  srl2ruby example.srl
+  srl2ruby example.srl -o example_re.rb -t srl_and_ruby.erb
+
+Options:
+    -o, --output-file PATH           Output to a file with specified name.
+    -t, --template-file TEMPLATE     Use given ERB template for the Ruby code generation. srl2ruby looks for
+the template file in current dir first then in its gem's /templates dir.
+
+        --version                    Display the program version then quit.
+    -?, -h, --help                   Display this help then quit.
+```
+
+## A quick intro to SRL and srl2ruby
+### What is SRL?
+SRL is a small language that lets you write pattern matching expressions
 in a readable syntax that bears some resemblance with English.
+For SRL documentation and examples, we cannot but recommend you to jump to the [official SRL website](https://simple-regex.com).
+
+### Why SRL?
+It is a well-known fact: regexes can be really hard to write and even harder to read ('decipher' verb is closer to reality).  
+Alas, the path of creating and maintaining regexes can be full of frustration.
+
+There comes SRL. The intent is to let developers define self-documenting patterns with an easy syntax.
+And then let your computer translate SRL expressions into terse regular expressions.
+
+### Our first SRL pattern
+Let's succumb to the traditional 'hello world' example. True, it is a contrived example that doesn't make justice to SRL expressiveness. On the other hand, it is a starting point good enough to learn the compile cycle.
+
+As a first step, let's create a file named `hello.srl` with just the following line:  
+```
+begin with literally "Hello world!"
+```
+
+It should read as 'Match any text that begins with the exact text "Hello world!"'  
+Now, if one invokes the `srl2ruby` compiler with the command line...
+
+    $ srl2ruby hello.srl
+
+
+... one gets the following output:
+```
+Parsing file 'hello.srl'
+/^Hello world!/
+```
+
+The last displayed line is the Ruby `Regexp` representation of the above SRL line. It can be pasted as such in your Ruby code, like in the following Ruby snippet:
+```ruby
+subject = 'Hello world! Welcome to SRL...'
+puts 'It matches!' if subject =~ /^Hello world!/  
+```
+
+As expected the snippet results in the message:
+```
+It matches!
+```
+
+**Quick recap:**  
+- `srl2ruby` expects a SRL file (typically with a .srl extension)  
+- It parses the _Simple Regex Language_ content...  
+- ... then generates the `Regexp` that is equivalent to the SRL input  
+- Finally, it prints the results to the console.
+
+Feature: with the command-line `-o` option the compiler will send the output to a file with specified name.  
+
+
+### Gears up
+Let's admit it, our first example wasn't really impressive.  
+So, let's try with a more imposing example inspired from the [official SRL website](https://simple-regex.com): an email validation pattern.
+
+```
+begin with any of (digit, letter, one of "._%+-") once or more,
+literally "@",
+any of (digit, letter, one of ".-") once or more,
+( literally ".",
+  letter at least 2 times
+) optional,
+must end,
+case insensitive
+```
+
+Assume that the previous SRL pattern was put in a file named `email_validation.srl` and that we invoked `srl2ruby` with the following command-line:
+
+    $ srl2ruby email_validation.srl
+
+Then the output should be:
+```
+Parsing file 'email_validation.srl'
+/(?i-mx:^(?:\d|[a-z]|[._%+\-])+@(?:\d|[a-z]|[.\-])+(?:\.[a-z]{2,})?$)/
+```
+
+The resulting regexp isn't for the fainted hearts: who's ready to maintain it? In addition, the above pattern covers only the most frequent cases.  
+If you were asked to cover more exotic case, and knowing that it means an expression at least twice as complex, which version are you willing to update the SRL or the Regexp one?
+
+#### Good to know: customizable output
+In fact, if one wants to update or maintain a pattern, it would be practical to have the SRL expression and its equivalent Regexp next to each other in our Ruby source code.  
+Can the `srl2ruby` compiler help there?  The answer is ... yes.  
+First, it is good to know that the output of the `srl2ruby` compiler can be tailored with an ERB template. For instance, the output of all the previous examples is relying on a default template called `base.erb`. It is bundled in the `srl_ruby` gem as another template called `srl_and_ruby.erb`. This second template will emit the SRL code (in Ruby comments) followed by the Regexp literal.  
+So let's use it with our email validation example:
+
+    $ srl2ruby email_validation.srl --template-file srl_and_ruby.erb
+
+The shorter option `-t` syntax is also possible:
+
+    $ srl2ruby email_validation.srl -t srl_and_ruby.erb
+
+The compiler's output contains now the original SRL expression in comments:  
+
+```
+Parsing file 'email_validation.srl'
+# SRL expression follows:
+# begin with any of (digit, letter, one of "._%+-") once or more,
+# literally "@",
+# any of (digit, letter, one of ".-") once or more,
+# ( literally ".",
+#   letter at least 2 times
+# ) optional,
+# must end,
+# case insensitive
+#
+# ... and its Regexp equivalent:
+/(?i-mx:^(?:\d|[a-z]|[._%+\-])+@(?:\d|[a-z]|[.\-])+(?:\.[a-z]{2,})?$)/
+```
+The above SRL code in comments can be safely inserted in a Ruby file.
+
+**Quick recap:**  
+- SRL can be used to specify much more challenging patterns than our boring 'Hello world!'.  
+- The `srl2ruby` compiler uses a ERB template to format its output.  
+- It is possible to choose a specific template via the `-t` option.  
+
+_Feature_: When given the name of a template via the `-t` option, the compiler will look first for such a template in the current directory, then, if not found, in its `templates` directory. This gives the opportunity to use customized local template files.  
+
+## Time for yet another example
 
-As an example, let's assume that our mission is to create a regular expression
-that matches the time in 12 hour clock format.  
-Here is a SRL expression that matches the _hh:mm AM/PM_ time format:
+As an example, let's assume that we are asked to create a regular expression that matches the time in 12 hour clock format (say, _hh:mm AM/PM_).
+In addition, the hour and minute values must be put (= captured) in a variable named `hour` and `min` respectively.  
+
+We will proceed in multiple iterations of increasing complexity.  
+However, for those that are always in a hurry and like movie spoils, here is the requested `Regexp`:
+```ruby
+/(?i-mx:^(?<hour>(?:(?:0?\d)|(?:1[01]))):(?<min>(?:0?|[1-5])\d)\s?[AP]M$)/
+```
+Want to jump directly to the latest [iteration](#iteration-5)?...
+
+
+### Iteration 1
+Here is a very naive SRL expression that matches the requested time format:
 ```
-digit from 0 to 1,
-digit optional,
+begin with digit twice,
 literally ":",
-digit from 0 to 5, digit,
+digit twice
 literally " ",
-one of "AP", literally "M"
+one of "AP", literally "M",
+must end
 ```
 
-### Learn more about Simple Regex Language
-Here are a couple of hyperlinks of interest:  
-[Main SRL website](https://simple-regex.com)  
-[SRL libraries](https://github.com/SimpleRegex)
+If one compiles the above SRL expression with `srl2ruby` as explained earlier in ['Our first SRL pattern'](#our-first-srl-pattern) section, it will generate the following Regexp literal:
+```ruby
+/^\d{2}:\d{2} [AP]M$/
+```
 
+When I want to test regular expressions, one of my favorite tool is the
+[Rubular website](http://rubular.com/). Tom Lovitt created a great Regexp editor and tester specifically for the Ruby community.
 
-## Why SRL?
-Even without knowing SRL, a reader can easily grasp the details of the above SRL expression.
-This is where SRL shines over the traditional regular expressions: high readability.
-For instance, a regex for the clock format problem may look like this:
+By the way, perhaps, some lynx-eyed readers spotted a small "mistake" on the third line of the SRL snippet: it doesn't end with a comma.  
+My apologies... For style consistency this line should be written as:  
 ```
-/[0-1]?\d:[0-5]\d [AP]M/
+digit twice,
 ```
+In reality, SRL happily ignores comma. Well..., most of the time. There is one exception: for the `any of` construct commas are used to separate alternatives (see example in [Iteration 3](#iteration-3)
 
-In terms of terseness, regexes are hard to beat. But it is also a well-known fact: regexes can be really hard to write and even harder to read ('decipher' verb is closer to reality).  
-Alas, the path of creating and maintaining regexes can be full of frustration.
+### Iteration 2
+Tests won't take a long time to show that the previous pattern is much too 'lenient' and will accept grossly incorrect entries such as 45:67 PM.  
 
-There comes SRL. The intent is to let developers define self-documenting patterns with an easy syntax.
-And then let your computer translate SRL expressions into regular expressions.
-`srl_ruby` allows you to craft self-documenting patterns in SRL and then generate
-their Ruby regular expression representation.
+For our next iteration, we keep note that:  
+- The first digit (from the left) can take the values 0 or 1 only.  
+- The third digit may run from 0 to 5 since the highest value for the minutes is 59.  
+
+Here is the improved SRL version:
+```
+begin with digit from 0 to 1,
+digit,
+literally ":",
+digit from 0 to 5,
+digit,
+literally " ",
+one of "AP", literally "M"
+must end
+```
+
+`srl2ruby` will swallow the SRL file and will spit out the next Regexp:
+```ruby
+/^[0-1]\d:[0-5]\d [AP]M$/
+```
+### Iteration 3
+Erroneous values like 45:67 PM are no more accepted this time. That's definitively better...
+But other tests will reveal that our pattern is still too permissive since it accepts values like 17:23 PM. A hour value of 17 is OK in 24 hour format but here we fail meeting our requirements...
+
+So, for our third try, we keep note that:
+- If the first hour digit is 1, then the second digit can take the values 0 or 1 only.
 
+Let's refactor our pattern:
+```
+begin with any of (
+  (literally "0", digit),
+  (literally "1", one of "01")
+)
+literally ":",
+digit from 0 to 5,
+digit,
+literally " ",
+one of "AP", literally "M"
+must end
+```
 
-Ah, by the way, our clock format pattern isn't completely correct. It will match invalid times like 19:34 PM.
-The problem arises when the first digit in the hour field is a one: in that case the second digit can only be
-zero or one.
+Remarks:  
+- The indentation isn't required by SRL, but I find that it contributes to the readability...
 
-Let's fix the issue in SRL:
+`srl2ruby` will transform this into:
+```ruby
+/^(?:(?:0\d)|(?:1[01])):[0-5]\d [AP]M$/
 ```
-any of (
+
+### Iteration 4
+This time the pattern works correctly. But in the meantime, our customer changed his requirements (*of course, such things never happen in real life...*). He asks for more flexibility in the pattern:
+- If the most significant digit value is zero, it is optional (i.e. some clock models won't display it).
+- The space between the minute value and the AM/PM indicator is now optional.
+- The AM/PM indicator can sometimes be written in small letters (am/pm).
+
+Let's go for another tour:
+```
+begin with any of (
   (literally "0" optional, digit),
   (literally "1", one of "01")
+)
+literally ":",
+any of (
+  literally "0" optional,
+  digit from 1 to 5
 ),
+digit,
+whitespace optional,
+one of "AP", literally "M"
+must end,
+case insensitive
+```
+
+Here is the Regexp counterpart:
+```ruby
+/(?i-mx:^(?:(?:0?\d)|(?:1[01])):(?:0?|[1-5])\d\s?[AP]M$)/
+```
+### Iteration 5
+Are we done? No: we were asked to capture the values of hours and minutes.
+
+SRL allows for named captures, so here is the updated version:
+```
+begin with capture(
+  any of (
+    (literally "0" optional, digit),
+    (literally "1", one of "01")
+  )
+) as "hour",
 literally ":",
-digit from 0 to 5, digit,
-literally " ",
+capture(
+  any of (
+    literally "0" optional,
+    digit from 1 to 5
+  ),
+  digit
+) as "min",
+whitespace optional,
 one of "AP", literally "M"
+must end,
+case insensitive
 ```
 
-And there is the equivalent regex found by `srl_ruby`:  
+`srl2ruby` will swiftly swallow the above SRL pattern and generate the following Regexp:
+```ruby
+/(?i-mx:^(?<hour>(?:(?:0?\d)|(?:1[01]))):(?<min>(?:0?|[1-5])\d)\s?[AP]M$)/
 ```
-/(?:(?:0?\d)|(?:1[01])):[0-5]\d [AP]M/
+
+That's becoming insane...
+
+
+#### Does this last Regexp really work?
+Glad you asked... Here is a Ruby snippet that can be used to test the last generated Regexp:
+
+```ruby
+# Next Regexp was copy-pasted from srl2ruby output
+pattern = /(?i-mx:^(?<hour>(?:(?:0?\d)|(?:1[01]))):(?<min>(?:0?|[1-5])\d)\s?[AP]M$)/
+text = '1:43am'
+
+matching = pattern.match(text)
+if matching
+  print 'Capture names: '; p(matching.names) # => Capture names: ["hour", "min"]
+  puts "Value of 'hour': #{matching[:hour]}" # => Value of 'hour': 1
+  puts "Value of 'min': #{matching[:min]}" # => Value of 'min': 43
+else
+  puts "Text '#{text}' doesn't match."
+end
 ```
 
+Running this snippet, gives the following output:
+```
+Capture names: ["hour", "min"]
+Value of 'hour': 1
+Value of 'min': 43
+```
+As one can see, from the input '1:43am', the Regexp captured the hour and minute values in the appropriate capture variable. Mission accomplished...   
 
-## Usage
+## srl_ruby API
 
-The method `SrlRuby#parse` accepts a Simple Regex Language string as input, and returns the corresponding regular expression.
+The method `SrlRuby#parse` accepts a Simple Regex Language string as input, and returns the corresponding regular expression as a `Regexp` instance.
 
 For instance, the following snippet...  
 
@@ -106,22 +396,6 @@ puts 'Equivalent regexp: /' + result + '/'
 Equivalent regexp: /(?:19|20)\d{2}-(?:(?:0\d)|(?:1[012]))-(?:(?:0\d)|(?:[12]\d)|(?:3[01]))/
 ```
 
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'srl_ruby'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install srl_ruby
-
 
 ## Contributing
 

data/bin/srl2ruby

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+require 'erb'
+require 'rubygems'
+require 'pathname'
+
+require_relative '../lib/srl_ruby'
+require_relative 'srl2ruby_cli_parser'
+
+class Srl2RubyProg
+  DefaultSRLExtension = 'srl'.freeze
+  DefDirname = '/templates'.freeze
+  DefTemplate = 'base.erb'.freeze
+  attr_reader(:cli_options)
+  attr_reader(:template)
+
+  def initialize(prog_name, args)
+    my_version = SrlRuby::VERSION
+    cli = Srl2RubyCLIParser.new(prog_name, my_version)
+    @cli_options = cli.parse!(args)
+    @template = valid_template
+  end
+
+  def run!(file_names)
+    file_names.each do |srl_file|
+      fname = validate_filename(srl_file)
+      next unless file_exist?(fname)
+      puts "Parsing file '#{fname}'"
+      srl_source = File.read(fname)
+      result = SrlRuby.parse(srl_source)
+      destination = $stdout
+      if cli_options.include?(:output)
+        filepath = cli_options[:output]
+        destination = File.open(filepath, 'w')
+      end
+      puts "Writing to file '#{filepath}'" unless destination == $stdout
+      destination.puts emit_code(template, srl_source, result)
+    end
+  end
+
+  private
+
+  def valid_template
+    t_filepath = nil
+    bindir = Gem.bin_path('srl_ruby', File.basename(__FILE__))
+    gem_dir = Pathname.new(bindir.sub(/(?<=\/)[^\/]+$/, '')).parent
+    def_template_dir = gem_dir.expand_path.to_s + DefDirname
+
+    if cli_options.include?(:template)
+      fname = cli_options[:template]
+      exists = File.exist?(fname)
+      if exists
+        t_filepath = Dir.getwd + '/' + fname
+      else
+        t_filepath = def_template_dir + '/' + fname
+        exit(1) unless file_exist?(t_filepath)
+      end
+    else
+      t_filepath = def_template_dir + '/' + DefTemplate
+    end
+    path = Pathname.new(t_filepath)
+    erb_template = ERB.new(path.read, nil, '<>')
+
+    erb_template
+  end
+
+  def validate_filename(raw_fname)
+    # When necessary add extension to file name
+    fname = raw_fname.dup
+    basename = File.basename(fname)
+    has_extension = basename =~ /(?<=[^.])\.[^.]+$/
+    fname << '.' << DefaultSRLExtension unless has_extension
+
+    fname
+  end
+
+  def file_exist?(fname)
+    exists = File.exist?(fname)
+    $stderr.puts "No such file '#{fname}'" unless exists
+
+    exists
+  end
+
+  def emit_code(template, srl_source, regexp)
+    template.result(binding)
+  end
+end # class
+
+########################################
+# ENTRY POINT
+########################################
+program = Srl2RubyProg.new(File.basename(__FILE__), ARGV)
+
+# All options from CLI gobbled from ARGV, remains only file name
+program.run!(ARGV)
+# End of file

data/bin/srl2ruby_cli_parser.rb

@@ -0,0 +1,89 @@
+require 'optparse' # Use standard OptionParser class for command-line parsing
+
+# A command-line option parser for the srl2ruby compiler.
+# It is a specialisation of the OptionParser class.
+class Srl2RubyCLIParser < OptionParser
+  # @return [Hash{Symbol=>String, Array}]
+  attr_reader(:parsed_options)
+
+  # Constructor.
+  def initialize(prog_name, ver)
+    super()
+    reset(prog_name, ver)
+
+    heading
+    separator 'Options:'
+    add_o_option
+    add_t_option
+    separator ''
+    add_tail_options
+  end
+
+  def parse!(args)
+    super
+    parsed_options
+  end
+
+  private
+
+  def reset(prog_name, ver)
+    @program_name = prog_name
+    @version = ver
+    @banner = "Usage: #{prog_name} SRL_FILE [options]"
+    @parsed_options = {}
+  end
+
+  def description
+    descr = <<-DESCR
+Description:
+  Parses a SRL file and compiles it into a Ruby Regexp literal.
+  Simple Regex Language (SRL) website: https://simple-regex.com
+
+Examples:
+  #{program_name} example.srl
+  #{program_name} example.srl -o example_re.rb -t srl_and_ruby.erb
+DESCR
+
+    descr
+  end
+
+  def heading
+    banner
+    separator ''
+    separator description
+    separator ''
+  end
+
+  def add_o_option
+    explanation = 'Output to a file with specified name.'
+
+    on '-o', '--output-file PATH', explanation do |pathname|
+      @parsed_options[:output] = pathname
+    end
+  end
+
+  def add_t_option
+    explanation = <<-EXPLANATION
+Use given ERB template for the Ruby code generation. srl2ruby looks for
+the template file in current dir first then in its gem's /templates dir.
+EXPLANATION
+
+    on '-t', '--template-file TEMPLATE', explanation do |template|
+      @parsed_options[:template] = template
+    end
+  end
+
+  def add_tail_options
+    on_tail('--version', 'Display the program version then quit.') do
+      puts version
+      exit(0)
+    end
+
+    on_tail('-?', '-h', '--help', 'Display this help then quit.') do
+      puts help
+      exit(0)
+    end
+  end
+end # class
+
+# End of file