diff --git a/lib/puppet/provider/augeas/augeas.rb b/lib/puppet/provider/augeas/augeas.rb
index 75ea9b940..a0016ef09 100644
--- a/lib/puppet/provider/augeas/augeas.rb
+++ b/lib/puppet/provider/augeas/augeas.rb
@@ -1,418 +1,418 @@
 #
 #   Copyright 2011 Bryan Kearney <bkearney@redhat.com>
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");
 #   you may not use this file except in compliance with the License.
 #   You may obtain a copy of the License at
 #
 #       http://www.apache.org/licenses/LICENSE-2.0
 #
 #   Unless required by applicable law or agreed to in writing, software
 #   distributed under the License is distributed on an "AS IS" BASIS,
 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
 require 'augeas' if Puppet.features.augeas?
 require 'strscan'
 require 'puppet/util'
 require 'puppet/util/diff'
 require 'puppet/util/package'
 
 Puppet::Type.type(:augeas).provide(:augeas) do
   include Puppet::Util
   include Puppet::Util::Diff
   include Puppet::Util::Package
 
-  confine :true => Puppet.features.augeas?
+  confine :feature => :augeas
 
   has_features :parse_commands, :need_to_run?,:execute_changes
 
   SAVE_NOOP = "noop"
   SAVE_OVERWRITE = "overwrite"
   SAVE_NEWFILE = "newfile"
   SAVE_BACKUP = "backup"
 
   COMMANDS = {
     "set" => [ :path, :string ],
     "setm" => [ :path, :string, :string ],
     "rm" => [ :path ],
     "clear" => [ :path ],
     "mv" => [ :path, :path ],
     "insert" => [ :string, :string, :path ],
     "get" => [ :path, :comparator, :string ],
     "defvar" => [ :string, :path ],
     "defnode" => [ :string, :path, :string ],
     "match" => [ :path, :glob ],
     "size" => [:comparator, :int],
     "include" => [:string],
     "not_include" => [:string],
     "==" => [:glob],
     "!=" => [:glob]
   }
 
   COMMANDS["ins"] = COMMANDS["insert"]
   COMMANDS["remove"] = COMMANDS["rm"]
   COMMANDS["move"] = COMMANDS["mv"]
 
   attr_accessor :aug
 
   # Extracts an 2 dimensional array of commands which are in the
   # form of command path value.
   # The input can be
   # - A string with one command
   # - A string with many commands per line
   # - An array of strings.
   def parse_commands(data)
     context = resource[:context]
     # Add a trailing / if it is not there
     if (context.length > 0)
       context << "/" if context[-1, 1] != "/"
     end
 
     data = data.split($/) if data.is_a?(String)
     data = data.flatten
     args = []
     data.each do |line|
       line.strip!
       next if line.nil? || line.empty?
       argline = []
       sc = StringScanner.new(line)
       cmd = sc.scan(/\w+|==|!=/)
       formals = COMMANDS[cmd]
       fail("Unknown command #{cmd}") unless formals
       argline << cmd
       narg = 0
       formals.each do |f|
         sc.skip(/\s+/)
         narg += 1
         if f == :path
           start = sc.pos
           nbracket = 0
           inSingleTick = false
           inDoubleTick = false
           begin
             sc.skip(/([^\]\[\s\\'"]|\\.)+/)
             ch = sc.getch
             nbracket += 1 if ch == "["
             nbracket -= 1 if ch == "]"
             inSingleTick = !inSingleTick if ch == "'"
             inDoubleTick = !inDoubleTick if ch == "\""
             fail("unmatched [") if nbracket < 0
           end until ((nbracket == 0 && !inSingleTick && !inDoubleTick && (ch =~ /\s/)) || sc.eos?)
             len = sc.pos - start
             len -= 1 unless sc.eos?
           unless p = sc.string[start, len]
             fail("missing path argument #{narg} for #{cmd}")
           end
           # Rip off any ticks if they are there.
           p = p[1, (p.size - 2)] if p[0,1] == "'" || p[0,1] == "\""
           p.chomp!("/")
           if p[0,1] != '$' && p[0,1] != "/"
             argline << context + p
           else
             argline << p
           end
         elsif f == :string
           delim = sc.peek(1)
           if delim == "'" || delim == "\""
             sc.getch
             argline << sc.scan(/([^\\#{delim}]|(\\.))*/)
             sc.getch
           else
             argline << sc.scan(/[^\s]+/)
           end
           fail("missing string argument #{narg} for #{cmd}") unless argline[-1]
         elsif f == :comparator
           argline << sc.scan(/(==|!=|=~|<|<=|>|>=)/)
           unless argline[-1]
             puts sc.rest
             fail("invalid comparator for command #{cmd}")
           end
         elsif f == :int
           argline << sc.scan(/\d+/).to_i
         elsif f== :glob
           argline << sc.rest
         end
       end
       args << argline
     end
     args
   end
 
 
   def open_augeas
     unless @aug
       flags = Augeas::NONE
       flags = Augeas::TYPE_CHECK if resource[:type_check] == :true
       flags |= Augeas::NO_MODL_AUTOLOAD if resource[:incl]
       root = resource[:root]
       load_path = get_load_path(resource)
       debug("Opening augeas with root #{root}, lens path #{load_path}, flags #{flags}")
       @aug = Augeas::open(root, load_path,flags)
 
       debug("Augeas version #{get_augeas_version} is installed") if versioncmp(get_augeas_version, "0.3.6") >= 0
 
       if resource[:incl]
         aug.set("/augeas/load/Xfm/lens", resource[:lens])
         aug.set("/augeas/load/Xfm/incl", resource[:incl])
         aug.load
       end
     end
     @aug
   end
 
   def close_augeas
     if @aug
       @aug.close
       debug("Closed the augeas connection")
       @aug = nil
     end
   end
 
   # Used by the need_to_run? method to process get filters. Returns
   # true if there is a match, false if otherwise
   # Assumes a syntax of get /files/path [COMPARATOR] value
   def process_get(cmd_array)
     return_value = false
 
     #validate and tear apart the command
     fail ("Invalid command: #{cmd_array.join(" ")}") if cmd_array.length < 4
     cmd = cmd_array.shift
     path = cmd_array.shift
     comparator = cmd_array.shift
     arg = cmd_array.join(" ")
 
     #check the value in augeas
     result = @aug.get(path) || ''
     case comparator
     when "!="
       return_value = (result != arg)
     when "=~"
       regex = Regexp.new(arg)
       return_value = (result =~ regex)
     else
       return_value = (result.send(comparator, arg))
     end
     !!return_value
   end
 
   # Used by the need_to_run? method to process match filters. Returns
   # true if there is a match, false if otherwise
   def process_match(cmd_array)
     return_value = false
 
     #validate and tear apart the command
     fail("Invalid command: #{cmd_array.join(" ")}") if cmd_array.length < 3
     cmd = cmd_array.shift
     path = cmd_array.shift
 
     # Need to break apart the clause
     clause_array = parse_commands(cmd_array.shift)[0]
     verb = clause_array.shift
 
     #Get the values from augeas
     result = @aug.match(path) || []
     fail("Error trying to match path '#{path}'") if (result == -1)
 
     # Now do the work
     case verb
     when "size"
       fail("Invalid command: #{cmd_array.join(" ")}") if clause_array.length != 2
       comparator = clause_array.shift
       arg = clause_array.shift
       case comparator
       when "!="
         return_value = !(result.size.send(:==, arg))
       else
         return_value = (result.size.send(comparator, arg))
       end
     when "include"
       arg = clause_array.shift
       return_value = result.include?(arg)
     when "not_include"
       arg = clause_array.shift
       return_value = !result.include?(arg)
     when "=="
       begin
         arg = clause_array.shift
         new_array = eval arg
         return_value = (result == new_array)
       rescue
         fail("Invalid array in command: #{cmd_array.join(" ")}")
       end
     when "!="
       begin
         arg = clause_array.shift
         new_array = eval arg
         return_value = (result != new_array)
       rescue
         fail("Invalid array in command: #{cmd_array.join(" ")}")
       end
     end
     !!return_value
   end
 
   # Generate lens load paths from user given paths and local pluginsync dir
   def get_load_path(resource)
     load_path = []
 
     # Permits colon separated strings or arrays
     if resource[:load_path]
       load_path = [resource[:load_path]].flatten
       load_path.map! { |path| path.split(/:/) }
       load_path.flatten!
     end
 
     if File.exists?("#{Puppet[:libdir]}/augeas/lenses")
       load_path << "#{Puppet[:libdir]}/augeas/lenses"
     end
 
     load_path.join(":")
   end
 
   def get_augeas_version
     @aug.get("/augeas/version") || ""
   end
 
   def set_augeas_save_mode(mode)
     @aug.set("/augeas/save", mode)
   end
 
   # Determines if augeas acutally needs to run.
   def need_to_run?
     force = resource[:force]
     return_value = true
     begin
       open_augeas
       filter = resource[:onlyif]
       unless filter == ""
         cmd_array = parse_commands(filter)[0]
         command = cmd_array[0];
         begin
           case command
           when "get"; return_value = process_get(cmd_array)
           when "match"; return_value = process_match(cmd_array)
           end
         rescue SystemExit,NoMemoryError
           raise
         rescue Exception => e
           fail("Error sending command '#{command}' with params #{cmd_array[1..-1].inspect}/#{e.message}")
         end
       end
 
       unless force
         # If we have a verison of augeas which is at least 0.3.6 then we
         # can make the changes now and see if changes were made.
         if return_value and versioncmp(get_augeas_version, "0.3.6") >= 0
           debug("Will attempt to save and only run if files changed")
           # Execute in NEWFILE mode so we can show a diff
           set_augeas_save_mode(SAVE_NEWFILE)
           do_execute_changes
           save_result = @aug.save
           fail("Save failed with return code #{save_result}") unless save_result
 
           saved_files = @aug.match("/augeas/events/saved")
           if saved_files.size > 0
             root = resource[:root].sub(/^\/$/, "")
             saved_files.map! {|key| @aug.get(key).sub(/^\/files/, root) }
             saved_files.uniq.each do |saved_file|
               if Puppet[:show_diff]
                 notice "\n" + diff(saved_file, saved_file + ".augnew")
               end
               File.delete(saved_file + ".augnew")
             end
             debug("Files changed, should execute")
             return_value = true
           else
             debug("Skipping because no files were changed")
             return_value = false
           end
         end
       end
     ensure
       if not return_value or resource.noop? or not save_result
         close_augeas
       end
     end
     return_value
   end
 
   def execute_changes
     # Workaround Augeas bug where changing the save mode doesn't trigger a
     # reload of the previously saved file(s) when we call Augeas#load
     @aug.match("/augeas/events/saved").each do |file|
       @aug.rm("/augeas#{@aug.get(file)}/mtime")
     end
 
     # Reload augeas, and execute the changes for real
     set_augeas_save_mode(SAVE_OVERWRITE) if versioncmp(get_augeas_version, "0.3.6") >= 0
     @aug.load
     do_execute_changes
     success = @aug.save
     fail("Save failed with return code #{success}") if success != true
 
     :executed
   ensure
     close_augeas
   end
 
   # Actually execute the augeas changes.
   def do_execute_changes
     commands = parse_commands(resource[:changes])
     commands.each do |cmd_array|
       fail("invalid command #{cmd_array.join[" "]}") if cmd_array.length < 2
       command = cmd_array[0]
       cmd_array.shift
       begin
         case command
           when "set"
             debug("sending command '#{command}' with params #{cmd_array.inspect}")
             rv = aug.set(cmd_array[0], cmd_array[1])
             fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (!rv)
           when "setm"
             debug("sending command '#{command}' with params #{cmd_array.inspect}")
             rv = aug.setm(cmd_array[0], cmd_array[1], cmd_array[2])
             fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (rv == -1)
           when "rm", "remove"
             debug("sending command '#{command}' with params #{cmd_array.inspect}")
             rv = aug.rm(cmd_array[0])
             fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (rv == -1)
           when "clear"
             debug("sending command '#{command}' with params #{cmd_array.inspect}")
             rv = aug.clear(cmd_array[0])
             fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (!rv)
           when "insert", "ins"
             label = cmd_array[0]
             where = cmd_array[1]
             path = cmd_array[2]
             case where
               when "before"; before = true
               when "after"; before = false
               else fail("Invalid value '#{where}' for where param")
             end
             debug("sending command '#{command}' with params #{[label, where, path].inspect}")
             rv = aug.insert(path, label, before)
             fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (rv == -1)
           when "defvar"
             debug("sending command '#{command}' with params #{cmd_array.inspect}")
             rv = aug.defvar(cmd_array[0], cmd_array[1])
             fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (!rv)
           when "defnode"
             debug("sending command '#{command}' with params #{cmd_array.inspect}")
             rv = aug.defnode(cmd_array[0], cmd_array[1], cmd_array[2])
             fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (!rv)
           when "mv", "move"
             debug("sending command '#{command}' with params #{cmd_array.inspect}")
             rv = aug.mv(cmd_array[0], cmd_array[1])
             fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (rv == -1)
           else fail("Command '#{command}' is not supported")
         end
       rescue SystemExit,NoMemoryError
         raise
       rescue Exception => e
         fail("Error sending command '#{command}' with params #{cmd_array.inspect}/#{e.message}")
       end
     end
   end
 end
diff --git a/lib/puppet/provider/group/ldap.rb b/lib/puppet/provider/group/ldap.rb
index 78333f176..19e9e1b14 100644
--- a/lib/puppet/provider/group/ldap.rb
+++ b/lib/puppet/provider/group/ldap.rb
@@ -1,45 +1,45 @@
 require 'puppet/provider/ldap'
 
 Puppet::Type.type(:group).provide :ldap, :parent => Puppet::Provider::Ldap do
   desc "Group management via LDAP.
 
     This provider requires that you have valid values for all of the
     LDAP-related settings in `puppet.conf`, including `ldapbase`.  You will
     almost definitely need settings for `ldapuser` and `ldappassword` in order
     for your clients to write to LDAP.
 
     Note that this provider will automatically generate a GID for you if you do
     not specify one, but it is a potentially expensive operation, as it
     iterates across all existing groups to pick the appropriate next one."
 
-  confine :true => Puppet.features.ldap?, :false => (Puppet[:ldapuser] == "")
+  confine :feature => :ldap, :false => (Puppet[:ldapuser] == "")
 
   # We're mapping 'members' here because we want to make it
   # easy for the ldap user provider to manage groups.  This
   # way it can just use the 'update' method in the group manager,
   # whereas otherwise it would need to replicate that code.
   manages(:posixGroup).at("ou=Groups").and.maps :name => :cn, :gid => :gidNumber, :members => :memberUid
 
   # Find the next gid after the current largest gid.
   provider = self
   manager.generates(:gidNumber).with do
     largest = 500
     if existing = provider.manager.search
         existing.each do |hash|
         next unless value = hash[:gid]
         num = value[0].to_i
         largest = num if num > largest
       end
     end
     largest + 1
   end
 
   # Convert a group name to an id.
   def self.name2id(group)
     return nil unless result = manager.search("cn=#{group}") and result.length > 0
 
     # Only use the first result.
     group = result[0]
     gid = group[:gid][0]
   end
 end
diff --git a/lib/puppet/util/feature.rb b/lib/puppet/util/feature.rb
index 5a7fbf773..c829c5fda 100644
--- a/lib/puppet/util/feature.rb
+++ b/lib/puppet/util/feature.rb
@@ -1,81 +1,83 @@
 class Puppet::Util::Feature
   attr_reader :path
 
   # Create a new feature test.  You have to pass the feature name,
   # and it must be unique.  You can either provide a block that
   # will get executed immediately to determine if the feature
   # is present, or you can pass an option to determine it.
   # Currently, the only supported option is 'libs' (must be
   # passed as a symbol), which will make sure that each lib loads
   # successfully.
   def add(name, options = {})
     method = name.to_s + "?"
     raise ArgumentError, "Feature #{name} is already defined" if self.class.respond_to?(method)
 
     if block_given?
       begin
         result = yield
       rescue Exception => detail
         warn "Failed to load feature test for #{name}: #{detail}"
         result = false
       end
       @results[name] = result
     end
 
     meta_def(method) do
-      @results[name] = test(name, options) unless @results.include?(name)
+      # Positive cache only, except blocks which are executed just once above
+      final = @results[name] || block_given?
+      @results[name] = test(name, options) unless final
       @results[name]
     end
   end
 
   # Create a new feature collection.
   def initialize(path)
     @path = path
     @results = {}
     @loader = Puppet::Util::Autoload.new(self, @path)
   end
 
   def load
     @loader.loadall
   end
 
   def method_missing(method, *args)
     return super unless method.to_s =~ /\?$/
 
     feature = method.to_s.sub(/\?$/, '')
     @loader.load(feature)
 
     respond_to?(method) && self.send(method)
   end
 
   # Actually test whether the feature is present.  We only want to test when
   # someone asks for the feature, so we don't unnecessarily load
   # files.
   def test(name, options)
     return true unless ary = options[:libs]
     ary = [ary] unless ary.is_a?(Array)
 
     ary.each do |lib|
       return false unless load_library(lib, name)
     end
 
     # We loaded all of the required libraries
     true
   end
 
   private
 
   def load_library(lib, name)
     raise ArgumentError, "Libraries must be passed as strings not #{lib.class}" unless lib.is_a?(String)
 
     begin
       require lib
     rescue SystemExit,NoMemoryError
       raise
     rescue Exception
       Puppet.debug "Failed to load library '#{lib}' for feature '#{name}'"
       return false
     end
     true
   end
 end
diff --git a/spec/unit/util/feature_spec.rb b/spec/unit/util/feature_spec.rb
index 15375e0b1..4490675b0 100755
--- a/spec/unit/util/feature_spec.rb
+++ b/spec/unit/util/feature_spec.rb
@@ -1,71 +1,82 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/util/feature'
 
 describe Puppet::Util::Feature do
   before do
     @features = Puppet::Util::Feature.new("features")
     @features.stubs(:warn)
   end
 
   it "should consider undefined features to be absent" do
     @features.should_not be_defined_feature
   end
 
   it "should be able to add new features" do
     @features.add(:myfeature) {}
     @features.should respond_to(:myfeature?)
   end
 
   it "should call associated code when loading a feature" do
     $loaded_feature = false
     @features.add(:myfeature) { $loaded_feature = true}
     $loaded_feature.should be_true
   end
 
   it "should consider a feature absent when the feature load fails" do
     @features.add(:failer) { raise "foo" }
     @features.should_not be_failer
   end
 
   it "should consider a feature to be absent when the feature load returns false" do
     @features.add(:failer) { false }
     @features.should_not be_failer
   end
 
   it "should consider a feature to be present when the feature load returns true" do
     @features.add(:available) { true }
     @features.should be_available
   end
 
-  it "should cache the results of a feature load" do
+  it "should cache the results of a feature load via code block" do
     $loaded_feature = 0
     @features.add(:myfeature) { $loaded_feature += 1 }
     @features.myfeature?
     @features.myfeature?
     $loaded_feature.should == 1
   end
 
   it "should support features with libraries" do
     lambda { @features.add(:puppet, :libs => %w{puppet}) }.should_not raise_error
   end
 
   it "should consider a feature to be present if all of its libraries are present" do
     @features.add(:myfeature, :libs => %w{foo bar})
     @features.expects(:require).with("foo")
     @features.expects(:require).with("bar")
 
     @features.should be_myfeature
   end
 
   it "should log and consider a feature to be absent if any of its libraries are absent" do
     @features.add(:myfeature, :libs => %w{foo bar})
     @features.expects(:require).with("foo").raises(LoadError)
     @features.stubs(:require).with("bar")
 
     Puppet.expects(:debug)
 
     @features.should_not be_myfeature
   end
+
+  it "should change the feature to be present when its libraries become available" do
+    @features.add(:myfeature, :libs => %w{foo bar})
+    @features.expects(:require).twice().with("foo").raises(LoadError).then.returns(nil)
+    @features.stubs(:require).with("bar")
+
+    Puppet.expects(:debug)
+
+    @features.should_not be_myfeature
+    @features.should be_myfeature
+  end
 end