Previously, we were always using string comparisons, and hard-coded
paths to temp locations on non-Windows platforms.  This was
problematic for a few reasons.  We had to maintain a list of temp
locations for the various platforms, and the string comparisons were
unreliable on Windows, since paths have two string representations
(the "short" name containing a ~ followed by a number, and the "full"
name).

By getting the current temp location using Dir.tempdir (the same
mechanism our temp creation code uses), we no longer need to maintain
the list of temp locations.  Also, rather than doing string
comparisons on file paths, we can use a combination of
Pathname#ascend, and File.identical? to determine if the path
registered as a temp file for deletion was actually created in the
temp location.

With this refactoring, the same code now works for both Windows, and
non-Windows platforms.

Reviewed-by: Nick Lewis <nick@puppetlabs.com>

Conflicts:
	lib/puppet/type/file/source.rb
	spec/unit/resource/catalog_spec.rb

Ruby 1.8.7 is fairly lax about various bits of introspection, including that
we can't tell much about what arguments a block takes.  Ruby 1.9.2 makes it
possible to do this, though.

Meanwhile, the Faces system uses this to make sure that scripts and actions
take the right set of arguments, to avoid surprises: failing early and
explicitly is better than failing at runtime.

Which, in final turn, exposes that I forgot to accept the right arguments in a
couple of my testing actions for Faces, but didn't notice because 1.8.7
doesn't check that, and I didn't test on 1.9.2.

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>

Absolute paths on Unix, e.g. /foo/bar, are not absolute on Windows,
which breaks many test cases. This commit adds a method to
PuppetSpec::Files.make_absolute that makes the path absolute in
test cases.

On Unix (Puppet.features.posix?) it is a no-op. On Windows,
(Puppet.features.microsoft_windows?) the drive from the current
 working directory is prepended.

Reviewed-by: Jacob Helwig <jacob@puppetlabs.com>

We were emitting a bunch of unhelpful failure messages, surrounding invalid
actions and especially default actions interacting with the command-line.

This cleans those up, to give a helpful, informative, and correct message in
all cases.  Notably, we no longer report that there is no "default" action
when you specify an unknown action on a face.

This change revealed some other weaknesses in our unit tests, now correctly,
that result in slightly more robust code.

Ruby 1.9 is stricter about arity for for arguments passed as a block.  A
test case just hadn't been updated to take this into account for Face
scripts (a simpler form of action), which isn't surprising since script
isn't used anywhere in the code, which makes it a prime candidate for
removal as far as I'm concerned, but apparently Luke wants it in there.

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

We refer to rendering formats pretty consistently as `json`, `yaml`, `s`, and
so forth; unqualified names.

On the other hand, we refer to the rendering hooks *mostly* as `to_*`, except
the `:for_humans` and `:json` formats.  Which is kind of confusing because of
the internal inconsistency, and because it doesn't match the public name.

Fix the code to resolve both, so the `to_*` format still works, but we mostly
expect to use the `*` version, to match public expectation.

We used to let actions be declared without the `when_invoked` block, which was
usually a sign of either someone writing their method code direct in action
declaration, or someone forgetting to add their code at all.

This was just let silently by: the error only showed up when you finally tried
to invoke the action, and a NoMethod error was raised by the face.

...except for our own testing.  We took advantage of this a whole pile of
times in there; fixing the original UI issue means fixing all those too.

Reviewed-By: Nick Lewis <nick@puppetlabs.com>