When we introduced verification of options, we forgot to handle the case that
global options from the Puppet settings system could be passed to the face.
This, in turn, means that the system would fail if you used any of those.

This remediates that, and now these work as expected.

Reviewed-By: Pieter van de Bruggen <pieter@puppetlabs.com>

Rewrite the process of validating and updating the options to fully reflect
the contract - we fail if there are unknown options passed, report nicely
errors of duplicate names, pass only the canonical names to the action code,
and generally enforce nicely.

Reviewed-By: Pieter van de Bruggen <pieter@puppetlabs.com>

Rather than having multiple, separate operations that modify and validate the
arguments to an action, a single pass makes sense.  This also means less walks
across the set of data, and a few less expensive method calls in Ruby.

Additionally, we work on a duplicate of the arguments hash rather than
directly modifying the original.  Because everything we do is at the top level
key/value mapping, this is sufficient to isolate the original.

While mostly theoretical, we now don't mutilate the hash passed in, so the
user won't get nastily surprised by the fact that we could have done so.

Reviewed-By: Pieter van de Bruggen <pieter@puppetlabs.com>

Part of the "social contract" of Faces, Actions and Options is that the
metadata we collect is authoritative: it covers everything that is possible.

In the initial release we didn't enforce that around options.  If you passed
an unknown option in the hash, we just silently ignored it in validation and
made it available down in the action.

Now, instead, we enforce that rule.  If you pass an unknown option we raise an
error and complain; anything that gets to the action will be listed in the set
of inspectable options.

Cases that depended on this behaviour to pass arbitrary content in the hash
should be rewritten to move that content down a level: take a hash value for
one option, and use that for your free content.

Reviewed-By: Pieter van de Bruggen <pieter@puppetlabs.com>

When we invoke an action, we parse a set of options.  These have a canonical
name, and optionally a set of aliases.  For example, :bar might have :b as an
alias to allow a short name to be given.

Previously we would just pass this on as received; if you passed :bar you got
:bar, and if you passed :b you got :b.  This works, but means that every
action has to write the same code to extract the appropriate version of an
option from whatever set of aliases might be passed.

Now, instead, we centralize that and always pass options as their canonical
name to the action code.  This makes it simpler to work with.  (This happens
before any validation, or other user-supplied, code to simplify everything
that handles options.)

Reviewed-By: Pieter van de Bruggen <pieter@puppetlabs.com>

When we define an action on an older version of a Face, we must be sure to
directly load the core of that version, not just define it with the external
Action(s) that it had.

Otherwise we break our contract, which is that any core Actions for a specific
version will be available to your external Action for as long as we support
that core version.

Reviewed-By: Pieter van de Bruggen <pieter@puppetlabs.com>

When we first touch a Face, we load all the available Actions from disk.

Given they define themselves against a specific version of a Face, they are
automatically available tied to the correct version; this makes it trivially
possible to locate those on demand and return them.

Now, we have the ability to find and, consequently, invoke Actions on older
versions of Faces.  We don't load enough context, though: the older face will
only have external Actions defined, not anything core.

Reviewed-By: Pieter van de Bruggen <pieter@puppetlabs.com>

Given the inheritance model for actions, we are sometimes going to need to set
them to 'default' at runtime, rather than during their static declaration.

Add tests to verify that this works correctly, and update the code to ensure
that happens.  This gives up caching of the default action, but this should be
an extremely rare operation - pretty much only CLI invocation, really.

Reviewed-By: Pieter van de Bruggen <pieter@puppetlabs.com>

This implement support for options with default values, allowing faces to set
those values when not invoked.  This can eliminate substantial duplicate code
from actions, especially when there are face-level options in use.

Reviewed-By: Pieter van de Bruggen <pieter@puppetlabs.com>

This introduces a class representing a semantic version, and
implementing a few of the most common uses of them: validation,
comparison, and finding the greatest available version matching
a range.  This refactoring also allows us to easily expand our
matching of version ranges in the future, which is a big plus.

Reviewed-By: Daniel Pittman