Merge branch '2.3.x'

* 2.3.x:
  (#12357) Fix broken compatibility with Puppet 2.6
  (maint) Comment Ken's fix to String#any?
  (#13018) Fix missing method any? message for ruby 1.9.x
  (#12357) Add ability to display an error message from validate_re
  (#12357) Add validate_absolute_path() function
  (maint) Stop printing the directory of spec_helper
  (#12357) Make facter_dot_d look in Puppet[:confdir]/facts.d
  (#12357) Add puppet_vardir custom fact
  (#12357) Fix root_home fact on Windows

12 files changed, 353 insertions, 16 deletions

diff --git a/README_DEVELOPER.markdown b/README_DEVELOPER.markdown
new file mode 100644
index 0000000..e8aa27a
--- /dev/null
+++ b/README_DEVELOPER.markdown
@@ -0,0 +1,35 @@
+Puppet Specific Facts
+=====================
+
+Facter is meant to stand alone and apart from Puppet.  However, Facter often
+runs inside Puppet and all custom facts included in the stdlib module will
+almost always be evaluated in the context of Puppet and Facter working
+together.
+
+Still, we don't want to write custom facts that blow up in the users face if
+Puppet is not loaded in memory.  This is often the case if the user run
+`facter` without also supplying the `--puppet` flag.
+
+Ah! But Jeff, the custom fact won't be in the `$LOAD_PATH` unless the user
+supplies `--facter`! You might say...
+
+Not (always) true I say!  If the user happens to have a CWD of
+`<modulepath>/stdlib/lib` then the facts will automatically be evaluated and
+blow up.
+
+In any event, it's pretty easy to write a fact that has no value if Puppet is
+not loaded.  Simply do it like this:
+
+    Facter.add(:node_vardir) do
+      setcode do
+        # This will be nil if Puppet is not available.
+        Facter::Util::PuppetSettings.with_puppet do
+          Puppet[:vardir]
+        end
+      end
+    end
+
+The `Facter::Util::PuppetSettings.with_puppet` method accepts a block and
+yields to it only if the Puppet library is loaded.  If the Puppet library is
+not loaded, then the method silently returns `nil` which Facter interprets as
+an undefined fact value.  The net effect is that the fact won't be set.
diff --git a/lib/facter/facter_dot_d.rb b/lib/facter/facter_dot_d.rb
index b94aacd..8543c7c 100644
--- a/lib/facter/facter_dot_d.rb
+++ b/lib/facter/facter_dot_d.rb
@@ -11,6 +11,9 @@
 # The cache is stored in /tmp/facts_cache.yaml as a mode
 # 600 file and will have the end result of not calling your
 # fact scripts more often than is needed
+
+require 'facter/util/puppet_settings'
+
 class Facter::Util::DotD
     require 'yaml'
 
@@ -182,3 +185,10 @@ end
 
 Facter::Util::DotD.new("/etc/facter/facts.d").create
 Facter::Util::DotD.new("/etc/puppetlabs/facter/facts.d").create
+
+# Windows has a different configuration directory that defaults to a vendor
+# specific sub directory of the %COMMON_APPDATA% directory.
+if Dir.const_defined? 'COMMON_APPDATA' then
+  windows_facts_dot_d = File.join(Dir::COMMON_APPDATA, 'PuppetLabs', 'facter', 'facts.d')
+  Facter::Util::DotD.new(windows_facts_dot_d).create
+end
diff --git a/lib/facter/puppet_vardir.rb b/lib/facter/puppet_vardir.rb
new file mode 100644
index 0000000..755e33c
--- /dev/null
+++ b/lib/facter/puppet_vardir.rb
@@ -0,0 +1,16 @@
+# This facter fact returns the value of the Puppet vardir setting for the node
+# running puppet or puppet agent.  The intent is to enable Puppet modules to
+# automatically have insight into a place where they can place variable data,
+# regardless of the node's platform.
+#
+# The value should be directly usable in a File resource path attribute.
+require 'facter/util/puppet_settings'
+
+Facter.add(:puppet_vardir) do
+  setcode do
+    # This will be nil if Puppet is not available.
+    Facter::Util::PuppetSettings.with_puppet do
+      Puppet[:vardir]
+    end
+  end
+end
diff --git a/lib/facter/root_home.rb b/lib/facter/root_home.rb
index 61fcf39..8249f7d 100644
--- a/lib/facter/root_home.rb
+++ b/lib/facter/root_home.rb
@@ -7,7 +7,9 @@ module Facter::Util::RootHome
   def get_root_home
     root_ent = Facter::Util::Resolution.exec("getent passwd root")
     # The home directory is the sixth element in the passwd entry
-    root_ent.split(":")[5]
+    # If the platform doesn't have getent, root_ent will be nil and we should
+    # return it straight away.
+    root_ent && root_ent.split(":")[5]
   end
   end
 end
diff --git a/lib/facter/util/puppet_settings.rb b/lib/facter/util/puppet_settings.rb
new file mode 100644
index 0000000..c8c8363
--- /dev/null
+++ b/lib/facter/util/puppet_settings.rb
@@ -0,0 +1,17 @@
+module Facter
+  module Util
+    module PuppetSettings
+      class << self
+        def with_puppet
+          begin
+            Module.const_get("Puppet")
+          rescue NameError
+            nil
+          else
+            yield
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/puppet/parser/functions/validate_absolute_path.rb b/lib/puppet/parser/functions/validate_absolute_path.rb
new file mode 100644
index 0000000..fe27974
--- /dev/null
+++ b/lib/puppet/parser/functions/validate_absolute_path.rb
@@ -0,0 +1,56 @@
+module Puppet::Parser::Functions
+  newfunction(:validate_absolute_path, :doc => <<-'ENDHEREDOC') do |args|
+    Validate the string represents an absolute path in the filesystem.  This function works
+    for windows and unix style paths.
+
+    The following values will pass:
+
+        $my_path = "C:/Program Files (x86)/Puppet Labs/Puppet"
+        validate_absolute_path($my_path)
+        $my_path2 = "/var/lib/puppet"
+        validate_absolute_path($my_path2)
+
+
+    The following values will fail, causing compilation to abort:
+
+        validate_absolute_path(true)
+        validate_absolute_path([ 'var/lib/puppet', '/var/foo' ])
+        validate_absolute_path([ '/var/lib/puppet', 'var/foo' ])
+        $undefined = undef
+        validate_absolute_path($undefined)
+
+    ENDHEREDOC
+
+    require 'puppet/util'
+
+    unless args.length > 0 then
+      raise Puppet::ParseError, ("validate_absolute_path(): wrong number of arguments (#{args.length}; must be > 0)")
+    end
+
+    args.each do |arg|
+      # This logic was borrowed from
+      # [lib/puppet/file_serving/base.rb](https://github.com/puppetlabs/puppet/blob/master/lib/puppet/file_serving/base.rb)
+
+      # Puppet 2.7 and beyond will have Puppet::Util.absolute_path?  Fall back to a back-ported implementation otherwise.
+      if Puppet::Util.respond_to?(:absolute_path?) then
+        unless Puppet::Util.absolute_path?(arg, :posix) or Puppet::Util.absolute_path?(arg, :windows)
+          raise Puppet::ParseError, ("#{arg.inspect} is not an absolute path.")
+        end
+      else
+        # This code back-ported from 2.7.x's lib/puppet/util.rb Puppet::Util.absolute_path?
+        # Determine in a platform-specific way whether a path is absolute. This
+        # defaults to the local platform if none is specified.
+        # Escape once for the string literal, and once for the regex.
+        slash = '[\\\\/]'
+        name = '[^\\\\/]+'
+        regexes = {
+          :windows => %r!^(([A-Z]:#{slash})|(#{slash}#{slash}#{name}#{slash}#{name})|(#{slash}#{slash}\?#{slash}#{name}))!i,
+          :posix   => %r!^/!,
+        }
+
+        rval = (!!(arg =~ regexes[:posix])) || (!!(arg =~ regexes[:windows]))
+        rval or raise Puppet::ParseError, ("#{arg.inspect} is not an absolute path.")
+      end
+    end
+  end
+end
diff --git a/lib/puppet/parser/functions/validate_re.rb b/lib/puppet/parser/functions/validate_re.rb
index 8033ca3..ca25a70 100644
--- a/lib/puppet/parser/functions/validate_re.rb
+++ b/lib/puppet/parser/functions/validate_re.rb
@@ -1,5 +1,4 @@
 module Puppet::Parser::Functions
-
   newfunction(:validate_re, :doc => <<-'ENDHEREDOC') do |args|
     Perform simple validation of a string against one or more regular
     expressions. The first argument of this function should be a string to
@@ -8,6 +7,9 @@ module Puppet::Parser::Functions
     of the regular expressions match the string passed in, compilation will
     abort with a parse error.
 
+    If a third argument is specified, this will be the error message raised and
+    seen by the user.
+
     The following strings will validate against the regular expressions:
 
         validate_re('one', '^one$')
@@ -17,17 +19,22 @@ module Puppet::Parser::Functions
 
         validate_re('one', [ '^two', '^three' ])
 
+    A helpful error message can be returned like this:
+
+        validate_re($::puppetversion, '^2.7', 'The $puppetversion fact value does not match 2.7')
+
     ENDHEREDOC
-    if args.length != 2 then
-      raise Puppet::ParseError, ("validate_re(): wrong number of arguments (#{args.length}; must be 2)")
+    if (args.length < 2) or (args.length > 3) then
+      raise Puppet::ParseError, ("validate_re(): wrong number of arguments (#{args.length}; must be 2 or 3)")
     end
 
-    msg = "validate_re(): #{args[0].inspect} does not match #{args[1].inspect}"
+    msg = args[2] || "validate_re(): #{args[0].inspect} does not match #{args[1].inspect}"
 
-    raise Puppet::ParseError, (msg) unless args[1].any? do |re_str|
+    # We're using a flattened array here because we can't call String#any? in
+    # Ruby 1.9 like we can in Ruby 1.8
+    raise Puppet::ParseError, (msg) unless [args[1]].flatten.any? do |re_str|
       args[0] =~ Regexp.compile(re_str)
     end
 
   end
-
 end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index 87aac34..ad736d8 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -1,8 +1,6 @@
 dir = File.expand_path(File.dirname(__FILE__))
 $LOAD_PATH.unshift File.join(dir, 'lib')
 
-p dir
-
 # Don't want puppet getting the command line arguments for rake or autotest
 ARGV.clear
 
diff --git a/spec/unit/facter/root_home_spec.rb b/spec/unit/facter/root_home_spec.rb
index 8946d9d..ce80684 100644
--- a/spec/unit/facter/root_home_spec.rb
+++ b/spec/unit/facter/root_home_spec.rb
@@ -30,13 +30,11 @@ describe Facter::Util::RootHome do
     end
   end
   context "windows" do
-    let(:root_ent) { "FIXME TBD on Windows" }
-    let(:expected_root_home) { "FIXME TBD on Windows" }
-
-    it "should return FIXME TBD on windows" do
-      pending "FIXME: TBD on windows"
-      Facter::Util::Resolution.expects(:exec).with("getent passwd root").returns(root_ent)
-      Facter::Util::RootHome.get_root_home.should == expected_root_home
+    before :each do
+      Facter::Util::Resolution.expects(:exec).with("getent passwd root").returns(nil)
+    end
+    it "should be nil on windows" do
+      Facter::Util::RootHome.get_root_home.should be_nil
     end
   end
 end
diff --git a/spec/unit/facter/util/puppet_settings_spec.rb b/spec/unit/facter/util/puppet_settings_spec.rb
new file mode 100644
index 0000000..c3ce6ea
--- /dev/null
+++ b/spec/unit/facter/util/puppet_settings_spec.rb
@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'facter/util/puppet_settings'
+
+describe Facter::Util::PuppetSettings do
+
+  describe "#with_puppet" do
+    context "Without Puppet loaded" do
+      before(:each) do
+        Module.expects(:const_get).with("Puppet").raises(NameError)
+      end
+
+      it 'should be nil' do
+        subject.with_puppet { Puppet[:vardir] }.should be_nil
+      end
+      it 'should not yield to the block' do
+        Puppet.expects(:[]).never
+        subject.with_puppet { Puppet[:vardir] }.should be_nil
+      end
+    end
+    context "With Puppet loaded" do
+      module Puppet; end
+      let(:vardir) { "/var/lib/puppet" }
+
+      before :each do
+        Puppet.expects(:[]).with(:vardir).returns vardir
+      end
+      it 'should yield to the block' do
+        subject.with_puppet { Puppet[:vardir] }
+      end
+      it 'should return the nodes vardir' do
+        subject.with_puppet { Puppet[:vardir] }.should eq vardir
+      end
+    end
+  end
+end
diff --git a/spec/unit/puppet/parser/functions/validate_absolute_path_spec.rb b/spec/unit/puppet/parser/functions/validate_absolute_path_spec.rb
new file mode 100644
index 0000000..1e0b5ac
--- /dev/null
+++ b/spec/unit/puppet/parser/functions/validate_absolute_path_spec.rb
@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:validate_absolute_path) do
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
+
+  # The subject of these examplres is the method itself.
+  subject do
+    Puppet::Parser::Scope.new.method :function_validate_absolute_path
+  end
+
+  describe "Valid Paths" do
+    def self.valid_paths
+      %w{
+        C:/
+        C:\\
+        C:\\WINDOWS\\System32
+        C:/windows/system32
+        X:/foo/bar
+        X:\\foo\\bar
+        /var/tmp
+        /var/lib/puppet
+        /var/opt/../lib/puppet
+      }
+    end
+
+    context "Without Puppet::Util.absolute_path? (e.g. Puppet <= 2.6)" do
+      before :each do
+        # The intent here is to mock Puppet to behave like Puppet 2.6 does.
+        # Puppet 2.6 does not have the absolute_path? method.  This is only a
+        # convenience test, stdlib should be run with the Puppet 2.6.x in the
+        # $LOAD_PATH in addition to 2.7.x and master.
+        Puppet::Util.expects(:respond_to?).with(:absolute_path?).returns(false)
+      end
+      valid_paths.each do |path|
+        it "validate_absolute_path(#{path.inspect}) should not fail" do
+          expect { subject.call [path] }.not_to raise_error Puppet::ParseError
+        end
+      end
+    end
+
+    context "Puppet without mocking" do
+      valid_paths.each do |path|
+        it "validate_absolute_path(#{path.inspect}) should not fail" do
+          expect { subject.call [path] }.not_to raise_error Puppet::ParseError
+        end
+      end
+    end
+  end
+
+  describe 'Invalid paths' do
+    context 'Garbage inputs' do
+      [
+        nil,
+        [ nil ],
+        { 'foo' => 'bar' },
+        { },
+        '',
+      ].each do |path|
+        it "validate_absolute_path(#{path.inspect}) should fail" do
+          expect { subject.call [path] }.to raise_error Puppet::ParseError
+        end
+      end
+    end
+
+    context 'Relative paths' do
+      %w{
+        relative1
+        .
+        ..
+        ./foo
+        ../foo
+        etc/puppetlabs/puppet
+        opt/puppet/bin
+      }.each do |path|
+        it "validate_absolute_path(#{path.inspect}) should fail" do
+          expect { subject.call [path] }.to raise_error Puppet::ParseError
+        end
+      end
+    end
+  end
+end
diff --git a/spec/unit/puppet/parser/functions/validate_re_spec.rb b/spec/unit/puppet/parser/functions/validate_re_spec.rb
new file mode 100644
index 0000000..c35ae14
--- /dev/null
+++ b/spec/unit/puppet/parser/functions/validate_re_spec.rb
@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:validate_re) do
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
+
+  let(:scope) do
+    scope = Puppet::Parser::Scope.new
+  end
+
+  # The subject of these examplres is the method itself.
+  subject do
+    scope.method :function_validate_re
+  end
+
+  context 'Using Puppet::Parser::Scope.new' do
+
+    describe 'Garbage inputs' do
+      inputs = [
+        [ nil ],
+        [ [ nil ] ],
+        [ { 'foo' => 'bar' } ],
+        [ { } ],
+        [ '' ],
+        [ "one", "one", "MSG to User", "4th arg" ],
+      ]
+
+      inputs.each do |input|
+        it "validate_re(#{input.inspect}) should fail" do
+          expect { subject.call [input] }.to raise_error Puppet::ParseError
+        end
+      end
+    end
+
+    describe 'Valid inputs' do
+      inputs = [
+        [ '/full/path/to/something', '^/full' ],
+        [ '/full/path/to/something', 'full' ],
+        [ '/full/path/to/something', ['full', 'absent'] ],
+        [ '/full/path/to/something', ['full', 'absent'], 'Message to the user' ],
+      ]
+
+      inputs.each do |input|
+        it "validate_re(#{input.inspect}) should not fail" do
+          expect { subject.call input }.not_to raise_error
+        end
+      end
+    end
+    describe "Valid inputs which should raise an exception without a message" do
+      # The intent here is to make sure valid inputs raise exceptions when they
+      # don't specify an error message to display.  This is the behvior in
+      # 2.2.x and prior.
+      inputs = [
+        [ "hello", [ "bye", "later", "adios" ] ],
+        [ "greetings", "salutations" ],
+      ]
+
+      inputs.each do |input|
+        it "validate_re(#{input.inspect}) should fail" do
+          expect { subject.call input }.to raise_error /validate_re.*?does not match/
+        end
+      end
+    end
+    describe "Nicer Error Messages" do
+      # The intent here is to make sure the function returns the 3rd argument
+      # in the exception thrown
+      inputs = [
+        [ "hello", [ "bye", "later", "adios" ], "MSG to User" ],
+        [ "greetings", "salutations", "Error, greetings does not match salutations" ],
+      ]
+
+      inputs.each do |input|
+        it "validate_re(#{input.inspect}) should fail" do
+          expect { subject.call input }.to raise_error /#{input[2]}/
+        end
+      end
+    end
+  end
+end