toys 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9aca0f88db86e761a9c149409ac63f3abe8965f8bc3ed32c0367f248cfcb953
-  data.tar.gz: 8e23447ec1fb3ccc91d0367bd120bcc388147cd7b114cc9e3d1e91833323076a
+  metadata.gz: 4b496ae16cf08a819091313e3b0ae83db93f7f7fa47430845fae2c254d35cf17
+  data.tar.gz: 2d23c96333efb627ee8a89ff91acc841aabaa08e413f3aaa89cc693993edeb82
 SHA512:
-  metadata.gz: 99865d61911d609c1dcf55ba6190f16f4bc00e044b696fed1b6bf202f29e3a0533ce87a971fbe1ae1b9cd83ec57a0a62f1eff49efd7f2801818bd43eafefd07e
-  data.tar.gz: a5ae272ae4585690cf5ab0abf7beabd9ba356203a26ebac976e90f94ca5a2120f62dd7a57b80ddc5907d7c04158e304df0a048dec543121b993de0fd8a7868fd
+  metadata.gz: 8df0872e8a6753a0a8e3a79640b45e96486b8bdf1d5ea7b9bebff4cb7575932ba1fddd634b9deaa637d1e88507d161c563dae885ab6b357bf156c8522ee384a1
+  data.tar.gz: 4034d1dfec8d5aa21314adcebce48d8351f978f90eb1ea28333f2a12b8007adde48711baadb41f2299a0180ab1a4ee548fed9a753828861e6d284195d84f5887

data/CHANGELOG.md

@@ -1,5 +1,59 @@
 # Release History
 
+### 0.8.0 / 2019-06-20
+
+This is a major update with significant new features and a bunch of fixes.
+It does include a few minor backward-incompatible changes. All signifiant
+features planned for beta are now implemented.
+
+Highlights:
+
+* Tab completion is available for Bash! See the README for instructions on installing it. Tab completion covers tool names, flags, flag values, and positional arguments. Tools can also customize the completion for their own flag and argument values.
+* Toys now integrates with `did_you_mean` to provide suggestions for misspelled tools, flags, and arguments (when run on Ruby 2.4 or later.)
+* Tools can now provide their own interrupt handler to respond to user `CTRL-C`. And the default handler no longer displays an unsightly stack trace. Tools can also provide their own handler for usage errors.
+* A new argument parsing engine, supporting additional features such as optional enforcing that flags appear before positional arguments, as well as a bunch of fixes, especially around acceptors and optional flag values.
+* Changed the license from BSD to MIT to better match how most libraries in the Ruby community are licensed.
+
+Details:
+
+* CHANGED: Relicensed under the MIT License.
+* CHANGED: Toys now requires Ruby 2.4 or later.
+* ADDED: Tab completion for bash. Args and flags can provide their own completion information.
+* ADDED: The usage error screen displays alternative suggestions when an argument is misspelled. (Requires Ruby 2.4 or later.)
+* ADDED: Tools can provide an interrupt handler.
+* ADDED: Tools can enforce that flags must be given before positional args. In particular, `toys do` now uses this feature, which eliminates most of the need to use `--` to get flags to work for subtools.
+* ADDED: Tools can control whether their flags can be invoked by partial matches.
+* ADDED: Function and range based acceptors.
+* ADDED: Flag handlers can accept the symbolic names `:set` and `:push` for common cases.
+* ADDED: The `:gem_build` template includes an `:install_gem` option. It also allows customization of gem output path.
+* ADDED: The `acceptor` directive takes an optional `type_desc` argument.
+* ADDED: The `accept` directives under flag and positional arg blocks in the DSL can now take blocks and `type_desc` values.
+* ADDED: Context keys `UNMATCHED_ARGS`, `UNMATCHED_POSITIONAL`, and `UNMATCHED_FLAGS` that provide arguments that were not handled during arg parsing.
+* ADDED: The Exec util and mixin support specifying a callback for process results.
+* ADDED: The Exec util and mixin provide a way to identify processes by name.
+* CHANGED: Toys now implements its own argument parsing and standard acceptors rather than relying on OptionParser. For the most part, OptionParser behavior is preserved, except in cases where there is clearly a bug.
+* CHANGED: Flags create a short form flag by default if the name has one character.
+* CHANGED: Flags with explicit value-less syntax are no longer given a value even if they specify a default or an acceptor.
+* CHANGED: Renamed the `TOOL_DEFINITION` context key to `TOOL`, and removed the `tool_definition` convenience method.
+* CHANGED: Removed the `BINARY_NAME` and `LOADER` context keys, and removed and the corresponding convenience methods. Get these values from the CLI if needed.
+* CHANGED: Renamed the `USAGE_ERROR` context key to `USAGE_ERRORS`, and the corresponding convenience method to `usage_errors`. The value is now a (possibly empty) array of `Toys::ArgParser::UsageError` objects rather than a string that isn't machine-parseable.
+* CHANGED: The root tool no longer defines remaining_args.
+* CHANGED: Renamed `to_expand` to `on_expand` in template definitions.
+* CHANGED: Renamed `to_initialize` to `on_initialize`, and `to_include` to `on_include` in mixin definitions.
+* CHANGED: Default descriptions for flag groups is now handled by the `set_default_descriptions` middleware rather than hard-coded in FlagGroup.
+* CHANGED: Exec reports failure to start processes in the result object rather than, e.g. raising ENOENT.
+* IMPROVED: Toys no longer displays a stack trace if a tool is interrupted.
+* IMPROVED: Error messages for flag groups are more complete.
+* IMPROVED: All context data, including well-known data, is available to be modified by flags and args.
+* FIXED: Flags with optional values are properly set to `true` (rather than left at `nil`) if no value is provided.
+* FIXED: Prevented toys-core from being ousted from the load path if a toys file invoked bundler setup.
+* FIXED: Acceptors no longer raise errors when run on missing optional values.
+* FIXED: When reporting errors in toys files, the line number was off by 2.
+* FIXED: The `--usage` help flag now honors `--all` and `--no-recursive`.
+* FIXED: The terminal now handles nil streams, as advertised.
+
+Additionally, a significant amount of internal reorganization and cleanup happened in the toys-core gem. See the changelog for toys-core for more details.
+
 ### 0.7.0 / 2019-01-23
 
 * ADDED: A template for creating tools that invoke RSpec.

data/LICENSE.md

@@ -1,29 +1,21 @@
 # License
 
-Copyright 2018 Daniel Azuma
+Copyright 2019 Daniel Azuma
 
-All rights reserved.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
 
-*   Redistributions of source code must retain the above copyright notice,
-    this list of conditions and the following disclaimer.
-*   Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-*   Neither the name of the copyright holder, nor the names of any other
-    contributors to this software, may be used to endorse or promote products
-    derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

data/README.md

@@ -1,50 +1,62 @@
 # Toys
 
 Toys is a configurable command line tool. Write commands in config files using
-a simple DSL, and Toys will provide the command line binary and take care of
-all the details such as argument parsing, online help, and error reporting.
+a simple DSL, and Toys will provide the command line executable and take care
+of all the details such as argument parsing, online help, and error reporting.
 
 Toys is designed for software developers, IT professionals, and other power
 users who want to write and organize scripts to automate their workflows. It
-can also be used as a Rake replacement, providing a more natural command line
-interface for your project's build tasks.
+can also be used as a replacement for Rake, providing a more natural command
+line interface for your project's build tasks.
 
 Unlike most command line frameworks, Toys is *not primarily* designed to help
-you build and ship a custom command line binary written in Ruby. However, you
-*can* use it in that way by building with the "toys-core" API, available as a
-separate gem. For more info on using toys-core, see
-https://www.rubydoc.info/gems/toys-core
+you build and ship a custom command line executable written in Ruby. However,
+you *can* use it in that way with the "toys-core" API, available as a separate
+gem. For more info on using toys-core, see
+[its documentation](https://www.rubydoc.info/gems/toys-core).
 
-## Quick Start
+## Introductory tutorial
 
-Here's a five-minute tutorial to get a feel of what Toys can do.
+Here's a tutorial to help you get a feel of what Toys can do.
 
 ### Install Toys
 
+Toys requires Ruby 2.3 or later. (JRuby is not currently supported.)
+
 Install the **toys** gem using:
 
-    gem install toys
+    $ gem install toys
 
-This installs the `toys` binary, along with some builtin tools and libraries.
-You can run the binary immediately:
+This installs the `toys` executable, along with some builtin tools and
+libraries. You can run the executable immediately:
 
-    toys
+    $ toys
 
-This displays overall help for the Toys binary. If you have `less` installed,
-Toys will use it to display the help screen. Press `q` to exit.
+This displays overall help for Toys. If you have `less` installed, Toys will
+use it to display the help screen. Press `q` to exit.
 
 You may notice that the help screen lists some tools that are preinstalled.
 Let's run one of them:
 
-    toys system version
+    $ toys system version
+
+The `system version` tool displays the current version of the toys gem.
+
+Toys also provides optional tab completion for bash. To install it, execute the
+following command in your shell, or add it to your bash configuration file
+(e.g. `~/.bashrc`).
 
-The "system version" tool displays the current version of the toys gem.
+    $(toys system bash-completion install)
+
+Toys does not yet specially implement tab completion for zsh or other shells.
+However, if you are using zsh, installing bash completion using `bashcompinit`
+*mostly* works.
 
 ### Write your first tool
 
 You can define tools by creating a *Toys file*. Go into any directory, and,
 using your favorite editor, create a new file called `.toys.rb` (note the
-leading period). Copy the following into the file, and save it:
+leading period). Copy the following text into the file, and save it:
 
     tool "greet" do
       desc "My first tool!"
@@ -56,46 +68,227 @@ leading period). Copy the following into the file, and save it:
 
 This defines a tool named "greet". Try running it:
 
-    toys greet
+    $ toys greet
 
 The tool also recognizes a flag on the command line. Try this:
 
-    toys greet --whom=ruby
+    $ toys greet --whom=ruby
 
 Toys provides a rich set of features for defining command line arguments and
 flags. It can also validate arguments. Try this:
 
-    toys greet --bye
+    $ toys greet --bye
 
 Notice that Toys automatically generated a usage summary for your tool. It also
 automatically generates a full help screen, which you can view using the
 `--help` flag:
 
-    toys greet --help
+    $ toys greet --help
+
+Toys searches up the directory hierarchy for Toys files. So it will find this
+`.toys.rb` if you are located in this directory or any subdirectory. It will
+also read multiple files if it finds them, so you can "scope" your tools more
+specifically or generally by locating them in your directory hierarchy. 
+
+If you want to define "global" tools that apply anywhere, write a Toys file
+either in your home directory, or in the system configuration directory
+(usually `/etc`). Toys always searches these locations.
 
-### Next steps
+### A more sophisticated example
 
-You can add any number of additional tools to your `.toys.rb` config file. Note
-also that the tools you create in the config file are available only in this
-directory and its subdirectories. If you move into a different directory tree,
-Toys will instead look for a config file in that directory. Thus, you can
-define tools scoped to particular projects. You can also define "global" tools
-by creating a `.toys.rb` file in your home directory.
+Let's take a look at another example that exercises some of the features you're
+likely to see in real-world usage. Add the following to your `.toys.rb` file.
+(You don't need to replace the greet tool you just wrote; just add this new
+tool to the end of the file.)
 
-Toys provides a rich set of useful libraries for writing tools and subtools. It
-gives you a logger and automatically provides flags to control verbosity of log
-output. It includes a simple library that you can use to produce styled output
-and basic console-based interfaces, and another library that makes it easy to
-spawn and control subprocesses. You can also take advantage of a variety of
-third-party libraries such as Highline and TTY.
+    tool "new-repo" do
+      desc "Create a new git repo"
+
+      optional_arg :name, desc: "Name of the directory to create"
+
+      include :exec, exit_on_nonzero_status: true
+      include :fileutils
+      include :terminal
+
+      def run
+        if name.nil?
+          response = ask "Please enter a directory name: "
+          set :name, response
+        end
+        if File.exist? name
+          puts "Aborting because #{name} already exists", :red, :bold
+          exit 1
+        end
+        logger.info "Creating new repo in directory #{name}..."
+        mkdir name
+        cd name do
+          create_repo
+        end
+        puts "Created repo in #{name}", :green, :bold
+      end
 
-For a more detailed look at Toys, see the
+      def create_repo
+        exec "git init"
+        File.write ".gitignore", <<~CONTENT
+          tmp
+          .DS_STORE
+        CONTENT
+        # You can add additional files here.
+        exec "git add ."
+        exec "git commit -m 'Initial commit'"
+      end
+    end
+
+Now you should have an additional tool called `new-repo` available. Type:
+
+    $ toys
+
+The help screen lists both the `greet` tool we started with, and the new
+`new-repo` tool. This new tool creates a directory containing a newly created
+git repo. (It assumes you have `git` available on your path.) Try running it:
+
+    $ toys new-repo foo
+
+That should create a directory `foo`, initialize a git repository within it,
+and make a commit.
+
+Notice that this tool accepts a positional command line argument. Toys supports
+any combination of flags and required and optional arguments. This tool's
+argument is declared with a description string, which you can see if you view
+the tool's help:
+
+    $ toys new-repo --help
+
+The argument is marked as "optional" which means you can omit it. Notice that
+the tool's code detects that it has been omitted and responds by prompting you
+interactively for a directory name. You can also mark a positional argument as
+"required", which causes Toys to report a usage error if it is omitted.
+
+Next, notice this tool includes two methods, `create_repo` as well as `run`.
+The "entrypoint" for a tool is always the `run` method, but each tool is
+actually a class under the hood, and you can add any helper methods you want.
+You can even define and include modules if you want to share code across tools.
+
+For our tool, notice that the three "include" lines are taking symbols rather
+than modules. These symbols are the names of some of Toys's built-in helper
+*mixins*, which are configurable modules that enhance your tool. They may
+provide methods your tool can call, or invoke other behavior. In our example:
+
+*   The `:exec` mixin provides a variety of methods for running external
+    commands. In this example, we use the `exec` method to run shell
+    commands, but you can also signal and control these commands, capture
+    and redirect streams, and so forth. Note that we pass the
+    `:exit_on_nonzero_status` option, which configures the `:exec` mixin to
+    abort the tool automatically if any of the external commands fails (similar
+    to `set -e` in bash). This is a common pattern when writing tools that
+    invoke external commands. (If you want more control, the `:exec` mixin also
+    provides ways to respond to result codes individually.)
+*   The `:fileutils` mixin provides the methods of the Ruby `FileUtils`
+    library, such as `mkdir` and `cd` used in this example. It's effectively
+    shorthand for `require "fileutils"; include ::FileUtils`.
+*   The `:terminal` mixin provides styled output, as you can see with the style
+    codes being passed to `puts`. It also provides some user interaction
+    commands such as `ask`, as well as spinners and other controls. You can see
+    operation of the `:terminal` mixin in the tool's output, which is styled
+    either green (for success) or red (on error) when running on a supported
+    tty.
+
+Now try running this:
+
+    $ toys new-repo bar --verbose
+
+You'll notice some diagnostic log output. Toys provides a standard Ruby Logger
+for each tool, and you can use it to emit diagnostic logs directly as
+demonstrated in the example. Some other Toys features might also emit log
+entries: the `:exec` mixin, for example, by default logs every external command
+it runs (although this can be customized). 
+
+By default, only warnings and higher severity logs are displayed, but you can
+change that by applying the `--verbose` or `--quiet` flags as we have done
+here. These flags, like `--help`, are provided automatically to every tool.
+
+### A better Rake?
+
+Let's look at one more example. Traditionally, Ruby developers often use
+Rakefiles to write scripts for tasks such as build, test, and deploy. And Toys
+is similar to Rake in how it uses directory-scoped files to define tools.
+
+But Rake is really designed for dependency management, not for writing scripts.
+As a result, some features, such as passing arguments to a task, are very
+clumsy with Rake.
+
+If you have a project with a Rakefile, move into that directory and create a
+new file called `.toys.rb` in that same directory (next to the Rakefile). Add
+the following line to your `.toys.rb` file:
+
+    expand :rake
+
+This syntax is called a "template expansion." It's a way to generate tools
+programmatically. In this case, Toys provides the `:rake` template, which reads
+your Rakefile and generates Toys tools corresponding to all your Rake tasks!
+Now if you run:
+
+    $ toys
+
+You'll see that you now have tools associated with each of your Rake tasks. So
+if you have a `rake test` task, you can run it using `toys test`.
+
+Note that if you normally run Rake with Bundler (e.g. `bundle exec rake test`),
+you may need to add Toys to your Gemfile and use Bundler to invoke Toys (i.e.
+`bundle exec toys test`). This is because Toys is just calling the Rake API to
+run your task, and the Rake task might require the bundle. However, when Toys
+is not wrapping Rake, typical practice is actually *not* to use Bundler. Toys
+provides its own mechanisms to activate and even install needed gems for you.
+
+So far, we've made Toys a front-end for your Rake tasks. This may be useful by
+itself. Toys lets you pass command line arguments "normally" to tools, whereas
+Rake requires a weird square bracket syntax (which may also require escaping
+depending on your shell.) Toys also provides more sophisticated online help
+than Rake does.
+
+But you also might find Toys a more natural way to *write* tasks, and indeed
+you can often rewrite an entire Rakefile as a Toys file and get quite a bit of
+benefit in readability and maintainability. For an example, see the
+[Toys file for the Toys repo itself](https://github.com/dazuma/toys/blob/master/toys/.toys.rb).
+It contains the Toys scripts that I use to develop, test, and release Toys
+itself. Yes, Toys is self-hosted. You'll notice most of this Toys file consists
+of template expansions. Toys provides templates for a lot of common build,
+test, and release tasks for Ruby projects.
+
+If you're feeling adventurous, try translating some of your Rake tasks into
+native Toys tools. You can do so in your existing `.toys.rb` file. Keep the
+`expand :rake` line at the *end* of the file, and locate your tools (whether
+simple tools or template expansions) before it. That way, your Toys-native
+tools will take precedence, and `expand :rake` will proxy out to Rake only for
+the remaining tasks that haven't been ported explicitly.
+
+### Learning more
+
+This introduction should be enough to get you started. However, Toys is a deep
+tool with many more features, all explained in detail in the
 [User Guide](https://www.rubydoc.info/gems/toys/file/docs/guide.md).
 
+For example, Toys lets you create tool namespaces and "subtools", and search
+for tools by name and description. There are various ways to validate and
+interpret command line arguments. You can create your own mixins and templates,
+and take advantage of a variety of third-party libraries such as Highline and
+TTY. Finally, if your `.toys.rb` files are growing too large or complicated,
+you can replace them with `.toys` directories that contain tool definitions in
+separate files. Such directories are versatile, letting you organize your tool
+definitions, along with shared code, normal Ruby classes, and even data files
+for use by tools.
+
+Unlike most command line frameworks, Toys is *not primarily* designed to help
+you build and ship a custom command line executable written in Ruby. However,
+you *can* use it in that way with the "toys-core" API, available as a separate
+gem. You would effectively write your command line executable using the same
+Toys DSL that you use to write `.toys.rb` files. For more info on using
+toys-core, see [its documentation](https://www.rubydoc.info/gems/toys-core).
+
 ## Why Toys?
 
-I wrote Toys because I was accumulating dozens of ad hoc Ruby scripts that I
-had written to automate various tasks in my workflow, everything from
+I originally wrote Toys because I was accumulating dozens of *ad hoc* Ruby
+scripts I had written to automate various tasks in my workflow, everything from
 refreshing credentials, to displaying git history in my favorite format, to
 running builds and tests of complex multi-component projects. It was becoming
 difficult to remember which scripts did what, and what arguments each required,
@@ -104,26 +297,39 @@ them. Furthermore, when writing new scripts, I was repeating the same
 OptionParser boilerplate and common functionality.
 
 Toys was designed to address those problems by providing a framework for
-writing and organizing your own command line scripts. You provide the actual
-functionality, and Toys takes care of all the other details expected from a
-good command line tool. It provides a streamlined interface for defining and
-handling command line flags and positional arguments, and sensible ways to
-organize shared code. It automatically generates help text, so you can see
-usage information at a glance, and it also provides a search feature to help
-you find the script you need.
+writing *and organizing* your own command line scripts. You provide the actual
+functionality by writing Toys files, and Toys takes care of all the other
+details expected from a good command line tool. It provides a streamlined
+interface for defining and handling command line flags and positional
+arguments, and sensible ways to organize shared code. It automatically
+generates help text so you can see usage information at a glance, provides a
+search feature to help you find the script you need, and generates tab
+completion for your shell.
 
 Toys can also be used to share scripts. For example, it can be used instead of
-Rake to provide build and test scripts for a project—tools that, unlike Rake
-tasks, can be invoked and passed arguments and flags using familiar unix
-command line conventions. The Toys github repo itself comes with Toys config
-files instead of Rakefiles.
+Rake to provide build and test scripts for a project. Unlike Rake tasks,
+scripts written for Toys can be invoked and passed arguments and flags using
+familiar unix command line conventions. The Toys github repo itself comes with
+Toys scripts instead of Rakefiles.
 
 ## License
 
-Copyright 2018 Daniel Azuma
-
-This software is licensed under the 3-clause BSD license.
-
-See the LICENSE.md file for more information.
-
-The source can be found on Github at https://github.com/dazuma/toys
+Copyright 2019 Daniel Azuma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.