diff --git a/lib/puppet/interface/action.rb b/lib/puppet/interface/action.rb
index 08bc0a345..f8eef69b1 100644
--- a/lib/puppet/interface/action.rb
+++ b/lib/puppet/interface/action.rb
@@ -1,252 +1,257 @@
 # -*- coding: utf-8 -*-
 require 'puppet/interface'
 require 'puppet/interface/option'
 
 class Puppet::Interface::Action
   def initialize(face, name, attrs = {})
     raise "#{name.inspect} is an invalid action name" unless name.to_s =~ /^[a-z]\w*$/
     @face    = face
     @name    = name.to_sym
     attrs.each do |k, v| send("#{k}=", v) end
 
     @options        = {}
     @when_rendering = {}
   end
 
   # This is not nice, but it is the easiest way to make us behave like the
   # Ruby Method object rather than UnboundMethod.  Duplication is vaguely
   # annoying, but at least we are a shallow clone. --daniel 2011-04-12
   def __dup_and_rebind_to(to)
     bound_version = self.dup
     bound_version.instance_variable_set(:@face, to)
     return bound_version
   end
 
   def to_s() "#{@face}##{@name}" end
 
   attr_reader   :name
   attr_accessor :default
   def default?
     !!@default
   end
 
   attr_accessor :summary
 
 
   ########################################################################
   # Support for rendering formats and all.
   def when_rendering(type)
     unless type.is_a? Symbol
       raise ArgumentError, "The rendering format must be a symbol, not #{type.class.name}"
     end
     return unless @when_rendering.has_key? type
     return @when_rendering[type].bind(@face)
   end
   def set_rendering_method_for(type, proc)
     unless proc.is_a? Proc
       msg = "The second argument to set_rendering_method_for must be a Proc"
       msg += ", not #{proc.class.name}" unless proc.nil?
       raise ArgumentError, msg
     end
     if proc.arity != 1 then
       msg = "when_rendering methods take one argument, the result, not "
       if proc.arity < 0 then
         msg += "a variable number"
       else
         msg += proc.arity.to_s
       end
       raise ArgumentError, msg
     end
     unless type.is_a? Symbol
       raise ArgumentError, "The rendering format must be a symbol, not #{type.class.name}"
     end
     if @when_rendering.has_key? type then
       raise ArgumentError, "You can't define a rendering method for #{type} twice"
     end
     # Now, the ugly bit.  We add the method to our interface object, and
     # retrieve it, to rotate through the dance of getting a suitable method
     # object out of the whole process. --daniel 2011-04-18
     @when_rendering[type] =
       @face.__send__( :__add_method, __render_method_name_for(type), proc)
   end
 
   def __render_method_name_for(type)
     :"#{name}_when_rendering_#{type}"
   end
   private :__render_method_name_for
 
 
   attr_accessor :render_as
   def render_as=(value)
     @render_as = value.to_sym
   end
 
 
   ########################################################################
   # Documentation stuff, whee!
   attr_accessor :summary, :description
   def summary=(value)
     value = value.to_s
     value =~ /\n/ and
       raise ArgumentError, "Face summary should be a single line; put the long text in 'description' instead."
 
     @summary = value
   end
 
 
   ########################################################################
   # Initially, this was defined to allow the @action.invoke pattern, which is
   # a very natural way to invoke behaviour given our introspection
   # capabilities.   Heck, our initial plan was to have the faces delegate to
   # the action object for invocation and all.
   #
   # It turns out that we have a binding problem to solve: @face was bound to
   # the parent class, not the subclass instance, and we don't pass the
   # appropriate context or change the binding enough to make this work.
   #
   # We could hack around it, by either mandating that you pass the context in
   # to invoke, or try to get the binding right, but that has probably got
   # subtleties that we don't instantly think of – especially around threads.
   #
   # So, we are pulling this method for now, and will return it to life when we
   # have the time to resolve the problem.  For now, you should replace...
   #
   #     @action = @face.get_action(name)
   #     @action.invoke(arg1, arg2, arg3)
   #
   # ...with...
   #
   #     @action = @face.get_action(name)
   #     @face.send(@action.name, arg1, arg2, arg3)
   #
   # I understand that is somewhat cumbersome, but it functions as desired.
   # --daniel 2011-03-31
   #
   # PS: This code is left present, but commented, to support this chunk of
   # documentation, for the benefit of the reader.
   #
   # def invoke(*args, &block)
   #   @face.send(name, *args, &block)
   # end
 
 
   # We need to build an instance method as a wrapper, using normal code, to be
   # able to expose argument defaulting between the caller and definer in the
   # Ruby API.  An extra method is, sadly, required for Ruby 1.8 to work since
   # it doesn't expose bind on a block.
   #
   # Hopefully we can improve this when we finally shuffle off the last of Ruby
   # 1.8 support, but that looks to be a few "enterprise" release eras away, so
   # we are pretty stuck with this for now.
   #
   # Patches to make this work more nicely with Ruby 1.9 using runtime version
   # checking and all are welcome, provided that they don't change anything
   # outside this little ol' bit of code and all.
   #
   # Incidentally, we though about vendoring evil-ruby and actually adjusting
   # the internal C structure implementation details under the hood to make
   # this stuff work, because it would have been cleaner.  Which gives you an
   # idea how motivated we were to make this cleaner.  Sorry.
   # --daniel 2011-03-31
   def when_invoked=(block)
 
     internal_name = "#{@name} implementation, required on Ruby 1.8".to_sym
 
     arity = block.arity
     if arity == 0 then
       # This will never fire on 1.8.7, which treats no arguments as "*args",
       # but will on 1.9.2, which treats it as "no arguments".  Which bites,
       # because this just begs for us to wind up in the horrible situation
       # where a 1.8 vs 1.9 error bites our end users. --daniel 2011-04-19
       raise ArgumentError, "action when_invoked requires at least one argument (options)"
     elsif arity > 0 then
       range = Range.new(1, arity - 1)
       decl = range.map { |x| "arg#{x}" } << "options = {}"
       optn = ""
       args = "[" + (range.map { |x| "arg#{x}" } << "options").join(", ") + "]"
     else
       range = Range.new(1, arity.abs - 1)
       decl = range.map { |x| "arg#{x}" } << "*rest"
       optn = "rest << {} unless rest.last.is_a?(Hash)"
       if arity == -1 then
         args = "rest"
       else
         args = "[" + range.map { |x| "arg#{x}" }.join(", ") + "] + rest"
       end
     end
 
     file    = __FILE__ + "+eval[wrapper]"
     line    = __LINE__ + 2 # <== points to the same line as 'def' in the wrapper.
     wrapper = <<WRAPPER
 def #{@name}(#{decl.join(", ")})
   #{optn}
   args = #{args}
   options = args.last
 
   action = get_action(#{name.inspect})
   action.validate_args(args)
   __invoke_decorations(:before, action, args, options)
   rval = self.__send__(#{internal_name.inspect}, *args)
   __invoke_decorations(:after, action, args, options)
   return rval
 end
 WRAPPER
 
     if @face.is_a?(Class)
       @face.class_eval do eval wrapper, nil, file, line end
       @face.define_method(internal_name, &block)
     else
       @face.instance_eval do eval wrapper, nil, file, line end
       @face.meta_def(internal_name, &block)
     end
   end
 
   def add_option(option)
     option.aliases.each do |name|
       if conflict = get_option(name) then
         raise ArgumentError, "Option #{option} conflicts with existing option #{conflict}"
       elsif conflict = @face.get_option(name) then
         raise ArgumentError, "Option #{option} conflicts with existing option #{conflict} on #{@face}"
       end
     end
 
     option.aliases.each do |name|
       @options[name] = option
     end
 
     option
   end
 
+  def inherit_options_from(action)
+    options = action.options.map { |opt| action.get_option(opt, false) }
+    options.reject!(&:nil?).uniq.each { |option| add_option(option) }
+  end
+
   def option?(name)
     @options.include? name.to_sym
   end
 
   def options
     (@options.keys + @face.options).sort
   end
 
   def get_option(name, with_inherited_options = true)
     option = @options[name.to_sym]
     if option.nil? and with_inherited_options
       option = @face.get_option(name)
     end
     option
   end
 
   def validate_args(args)
     required = options.map do |name|
       get_option(name)
     end.select(&:required?).collect(&:name) - args.last.keys
 
     return if required.empty?
     raise ArgumentError, "missing required options (#{required.join(', ')})"
   end
 
   ########################################################################
   # Support code for action decoration; see puppet/interface.rb for the gory
   # details of why this is hidden away behind private. --daniel 2011-04-15
   private
   def __add_method(name, proc)
     @face.__send__ :__add_method, name, proc
   end
 end
diff --git a/lib/puppet/interface/action_builder.rb b/lib/puppet/interface/action_builder.rb
index 2ffa38709..fd8b0856f 100644
--- a/lib/puppet/interface/action_builder.rb
+++ b/lib/puppet/interface/action_builder.rb
@@ -1,73 +1,83 @@
 require 'puppet/interface'
 require 'puppet/interface/action'
 
 class Puppet::Interface::ActionBuilder
   attr_reader :action
 
   def self.build(face, name, &block)
     raise "Action #{name.inspect} must specify a block" unless block
     new(face, name, &block).action
   end
 
   private
   def initialize(face, name, &block)
     @face   = face
     @action = Puppet::Interface::Action.new(face, name)
     instance_eval(&block)
   end
 
   # Ideally the method we're defining here would be added to the action, and a
   # method on the face would defer to it, but we can't get scope correct, so
   # we stick with this. --daniel 2011-03-24
   def when_invoked(&block)
     @action.when_invoked = block
   end
 
   def when_rendering(type = nil, &block)
     if type.nil? then           # the default error message sucks --daniel 2011-04-18
       raise ArgumentError, 'You must give a rendering format to when_rendering'
     end
     if block.nil? then
       raise ArgumentError, 'You must give a block to when_rendering'
     end
     @action.set_rendering_method_for(type, block)
   end
 
   def option(*declaration, &block)
     option = Puppet::Interface::OptionBuilder.build(@action, *declaration, &block)
     @action.add_option(option)
   end
 
+  def inherit_options_from(action)
+    if action.is_a? Symbol
+      name = action
+      action = @face.get_action(name) or
+      raise ArgumentError, "This Face has no action named #{name}!"
+    end
+
+    @action.inherit_options_from(action)
+  end
+
   def default(value = true)
     @action.default = !!value
   end
 
   def render_as(value = nil)
     value.nil? and raise ArgumentError, "You must give a rendering format to render_as"
 
     formats = Puppet::Network::FormatHandler.formats << :for_humans
     unless formats.include? value
       raise ArgumentError, "#{value.inspect} is not a valid rendering format: #{formats.sort.join(", ")}"
     end
 
     @action.render_as = value
   end
 
   # Metaprogram the simple DSL from the target class.
   Puppet::Interface::Action.instance_methods.grep(/=$/).each do |setter|
     next if setter =~ /^=/
     dsl = setter.sub(/=$/, '')
 
     unless private_instance_methods.include? dsl
       # Using eval because the argument handling semantics are less awful than
       # when we use the define_method/block version.  The later warns on older
       # Ruby versions if you pass the wrong number of arguments, but carries
       # on, which is totally not what we want. --daniel 2011-04-18
       eval <<METHOD
 def #{dsl}(value)
   @action.#{dsl} = value
 end
 METHOD
     end
   end
 end
diff --git a/lib/puppet/provider/naginator.rb b/lib/puppet/provider/naginator.rb
index 5c610fb31..17cc24086 100644
--- a/lib/puppet/provider/naginator.rb
+++ b/lib/puppet/provider/naginator.rb
@@ -1,58 +1,66 @@
 #  Created by Luke Kanies on 2007-11-27.
 #  Copyright (c) 2007. All rights reserved.
 
 require 'puppet'
 require 'puppet/provider/parsedfile'
 require 'puppet/external/nagios'
 
 # The base class for all Naginator providers.
 class Puppet::Provider::Naginator < Puppet::Provider::ParsedFile
   NAME_STRING = "## --PUPPET_NAME-- (called '_naginator_name' in the manifest)"
   # Retrieve the associated class from Nagios::Base.
   def self.nagios_type
     unless @nagios_type
       name = resource_type.name.to_s.sub(/^nagios_/, '')
       unless @nagios_type = Nagios::Base.type(name.to_sym)
         raise Puppet::DevError, "Could not find nagios type '#{name}'"
       end
 
       # And add our 'ensure' settings, since they aren't a part of
       # Naginator by default
       @nagios_type.send(:attr_accessor, :ensure, :target, :on_disk)
     end
     @nagios_type
   end
 
   def self.parse(text)
       Nagios::Parser.new.parse(text.gsub(NAME_STRING, "_naginator_name"))
   rescue => detail
       raise Puppet::Error, "Could not parse configuration for #{resource_type.name}: #{detail}"
   end
 
   def self.to_file(records)
-    header + records.collect { |record| record.to_s }.join("\n").gsub("_naginator_name", NAME_STRING)
+    header + records.collect { |record|
+        # Remap the TYPE_name or _naginator_name params to the
+        # name if the record is a template (register == 0)
+        if record.to_s =~ /register\s+0/
+            record.to_s.sub("_naginator_name", "name").sub(record.type.to_s + "_name", "name")
+        else
+            record.to_s.sub("_naginator_name", NAME_STRING)
+        end
+    }.join("\n")
   end
 
   def self.skip_record?(record)
     false
   end
 
   def self.valid_attr?(klass, attr_name)
     nagios_type.parameters.include?(attr_name)
   end
 
   def initialize(resource = nil)
     if resource.is_a?(Nagios::Base)
       # We don't use a duplicate here, because some providers (ParsedFile, at least)
       # use the hash here for later events.
       @property_hash = resource
     elsif resource
       @resource = resource if resource
       # LAK 2007-05-09: Keep the model stuff around for backward compatibility
       @model = resource
       @property_hash = self.class.nagios_type.new
     else
       @property_hash = self.class.nagios_type.new
     end
   end
 end
diff --git a/lib/puppet/provider/nameservice/directoryservice.rb b/lib/puppet/provider/nameservice/directoryservice.rb
index c1139a679..35ac8d76a 100644
--- a/lib/puppet/provider/nameservice/directoryservice.rb
+++ b/lib/puppet/provider/nameservice/directoryservice.rb
@@ -1,534 +1,537 @@
 require 'puppet'
 require 'puppet/provider/nameservice'
 require 'facter/util/plist'
 require 'cgi'
 
 
 class Puppet::Provider::NameService
 class DirectoryService < Puppet::Provider::NameService
   # JJM: Dive into the singleton_class
   class << self
     # JJM: This allows us to pass information when calling
     #      Puppet::Type.type
     #  e.g. Puppet::Type.type(:user).provide :directoryservice, :ds_path => "Users"
     #  This is referenced in the get_ds_path class method
     attr_writer :ds_path
     attr_writer :macosx_version_major
   end
 
   initvars
 
   commands :dscl => "/usr/bin/dscl"
   commands :dseditgroup => "/usr/sbin/dseditgroup"
   commands :sw_vers => "/usr/bin/sw_vers"
   confine :operatingsystem => :darwin
   defaultfor :operatingsystem => :darwin
 
 
   # JJM 2007-07-25: This map is used to map NameService attributes to their
   #     corresponding DirectoryService attribute names.
   #     See: http://images.apple.com/server/docs.Open_Directory_v10.4.pdf
   # JJM: Note, this is de-coupled from the Puppet::Type, and must
   #     be actively maintained.  There may also be collisions with different
   #     types (Users, Groups, Mounts, Hosts, etc...)
   @@ds_to_ns_attribute_map = {
     'RecordName' => :name,
     'PrimaryGroupID' => :gid,
     'NFSHomeDirectory' => :home,
     'UserShell' => :shell,
     'UniqueID' => :uid,
     'RealName' => :comment,
     'Password' => :password,
     'GeneratedUID' => :guid,
     'IPAddress'    => :ip_address,
     'ENetAddress'  => :en_address,
     'GroupMembership' => :members,
   }
   # JJM The same table as above, inverted.
   @@ns_to_ds_attribute_map = {
     :name => 'RecordName',
     :gid => 'PrimaryGroupID',
     :home => 'NFSHomeDirectory',
     :shell => 'UserShell',
     :uid => 'UniqueID',
     :comment => 'RealName',
     :password => 'Password',
     :guid => 'GeneratedUID',
     :en_address => 'ENetAddress',
     :ip_address => 'IPAddress',
     :members => 'GroupMembership',
   }
 
   @@password_hash_dir = "/var/db/shadow/hash"
 
   def self.instances
     # JJM Class method that provides an array of instance objects of this
     #     type.
     # JJM: Properties are dependent on the Puppet::Type we're managine.
     type_property_array = [:name] + @resource_type.validproperties
 
     # Create a new instance of this Puppet::Type for each object present
     #    on the system.
     list_all_present.collect do |name_string|
       self.new(single_report(name_string, *type_property_array))
     end
   end
 
   def self.get_ds_path
     # JJM: 2007-07-24 This method dynamically returns the DS path we're concerned with.
     #      For example, if we're working with an user type, this will be /Users
     #      with a group type, this will be /Groups.
     #   @ds_path is an attribute of the class itself.
     return @ds_path if defined?(@ds_path)
     # JJM: "Users" or "Groups" etc ...  (Based on the Puppet::Type)
     #       Remember this is a class method, so self.class is Class
     #       Also, @resource_type seems to be the reference to the
     #       Puppet::Type this class object is providing for.
     @resource_type.name.to_s.capitalize + "s"
   end
 
   def self.get_macosx_version_major
     return @macosx_version_major if defined?(@macosx_version_major)
     begin
       # Make sure we've loaded all of the facts
       Facter.loadfacts
 
       if Facter.value(:macosx_productversion_major)
         product_version_major = Facter.value(:macosx_productversion_major)
       else
         # TODO: remove this code chunk once we require Facter 1.5.5 or higher.
         Puppet.warning("DEPRECATION WARNING: Future versions of the directoryservice provider will require Facter 1.5.5 or newer.")
         product_version = Facter.value(:macosx_productversion)
         fail("Could not determine OS X version from Facter") if product_version.nil?
         product_version_major = product_version.scan(/(\d+)\.(\d+)./).join(".")
       end
       fail("#{product_version_major} is not supported by the directoryservice provider") if %w{10.0 10.1 10.2 10.3}.include?(product_version_major)
       @macosx_version_major = product_version_major
       return @macosx_version_major
     rescue Puppet::ExecutionFailure => detail
       fail("Could not determine OS X version: #{detail}")
     end
   end
 
 
   def self.list_all_present
     # JJM: List all objects of this Puppet::Type already present on the system.
     begin
       dscl_output = execute(get_exec_preamble("-list"))
     rescue Puppet::ExecutionFailure => detail
       fail("Could not get #{@resource_type.name} list from DirectoryService")
     end
     dscl_output.split("\n")
   end
 
   def self.parse_dscl_url_data(dscl_output)
     # we need to construct a Hash from the dscl -url output to match
     # that returned by the dscl -plist output for 10.5+ clients.
     #
     # Nasty assumptions:
     #   a) no values *end* in a colon ':', only keys
     #   b) if a line ends in a colon and the next line does start with
     #      a space, then the second line is a value of the first.
     #   c) (implied by (b)) keys don't start with spaces.
 
     dscl_plist = {}
     dscl_output.split("\n").inject([]) do |array, line|
       if line =~ /^\s+/   # it's a value
         array[-1] << line # add the value to the previous key
       else
         array << line
       end
       array
     end.compact
 
     dscl_output.each do |line|
       # This should be a 'normal' entry. key and value on one line.
       # We split on ': ' to deal with keys/values with a colon in them.
       split_array = line.split(/:\s+/)
       key = split_array.first
       value = CGI::unescape(split_array.last.strip.chomp)
       # We need to treat GroupMembership separately as it is currently
       # the only attribute we care about multiple values for, and
       # the values can never contain spaces (shortnames)
       # We also make every value an array to be consistent with the
       # output of dscl -plist under 10.5
       if key == "GroupMembership"
         dscl_plist[key] = value.split(/\s/)
       else
         dscl_plist[key] = [value]
       end
     end
     dscl_plist
   end
 
   def self.parse_dscl_plist_data(dscl_output)
     Plist.parse_xml(dscl_output)
   end
 
   def self.generate_attribute_hash(input_hash, *type_properties)
     attribute_hash = {}
     input_hash.keys.each do |key|
       ds_attribute = key.sub("dsAttrTypeStandard:", "")
       next unless (@@ds_to_ns_attribute_map.keys.include?(ds_attribute) and type_properties.include? @@ds_to_ns_attribute_map[ds_attribute])
       ds_value = input_hash[key]
       case @@ds_to_ns_attribute_map[ds_attribute]
         when :members
           ds_value = ds_value # only members uses arrays so far
         when :gid, :uid
           # OS X stores objects like uid/gid as strings.
           # Try casting to an integer for these cases to be
           # consistent with the other providers and the group type
           # validation
           begin
             ds_value = Integer(ds_value[0])
           rescue ArgumentError
             ds_value = ds_value[0]
           end
         else ds_value = ds_value[0]
       end
       attribute_hash[@@ds_to_ns_attribute_map[ds_attribute]] = ds_value
     end
 
     # NBK: need to read the existing password here as it's not actually
     # stored in the user record. It is stored at a path that involves the
     # UUID of the user record for non-Mobile local acccounts.
     # Mobile Accounts are out of scope for this provider for now
     attribute_hash[:password] = self.get_password(attribute_hash[:guid]) if @resource_type.validproperties.include?(:password) and Puppet.features.root?
     attribute_hash
   end
 
   def self.single_report(resource_name, *type_properties)
     # JJM 2007-07-24:
     #     Given a the name of an object and a list of properties of that
     #     object, return all property values in a hash.
     #
     #     This class method returns nil if the object doesn't exist
     #     Otherwise, it returns a hash of the object properties.
 
     all_present_str_array = list_all_present
 
     # NBK: shortcut the process if the resource is missing
     return nil unless all_present_str_array.include? resource_name
 
     dscl_vector = get_exec_preamble("-read", resource_name)
     begin
       dscl_output = execute(dscl_vector)
     rescue Puppet::ExecutionFailure => detail
       fail("Could not get report.  command execution failed.")
     end
 
     # Two code paths is ugly, but until we can drop 10.4 support we don't
     # have a lot of choice. Ultimately this should all be done using Ruby
     # to access the DirectoryService APIs directly, but that's simply not
     # feasible for a while yet.
-    case self.get_macosx_version_major
-    when "10.4"
-      dscl_plist = self.parse_dscl_url_data(dscl_output)
-    when "10.5", "10.6"
+    if self.get_macosx_version_major > "10.4"
       dscl_plist = self.parse_dscl_plist_data(dscl_output)
+    elsif self.get_macosx_version_major == "10.4"
+      dscl_plist = self.parse_dscl_url_data(dscl_output)
+    else
+      fail("Puppet does not support OS X versions < 10.4")
     end
 
     self.generate_attribute_hash(dscl_plist, *type_properties)
   end
 
   def self.get_exec_preamble(ds_action, resource_name = nil)
     # JJM 2007-07-24
     #     DSCL commands are often repetitive and contain the same positional
     #     arguments over and over. See http://developer.apple.com/documentation/Porting/Conceptual/PortingUnix/additionalfeatures/chapter_10_section_9.html
     #     for an example of what I mean.
     #     This method spits out proper DSCL commands for us.
     #     We EXPECT name to be @resource[:name] when called from an instance object.
 
     # 10.4 doesn't support the -plist option for dscl, and 10.5 has a
     # different format for the -url output with objects with spaces in
     # their values. *sigh*. Use -url for 10.4 in the hope this can be
     # deprecated one day, and use -plist for 10.5 and higher.
-    case self.get_macosx_version_major
-    when "10.4"
-      command_vector = [ command(:dscl), "-url", "." ]
-    when "10.5", "10.6"
+    if self.get_macosx_version_major > "10.4"
       command_vector = [ command(:dscl), "-plist", "." ]
+    elsif self.get_macosx_version_major == "10.4"
+      command_vector = [ command(:dscl), "-url", "." ]
+    else
+      fail("Puppet does not support OS X versions < 10.4")
     end
+
     # JJM: The actual action to perform.  See "man dscl"
     #      Common actiosn: -create, -delete, -merge, -append, -passwd
     command_vector << ds_action
     # JJM: get_ds_path will spit back "Users" or "Groups",
     # etc...  Depending on the Puppet::Type of our self.
     if resource_name
       command_vector << "/#{get_ds_path}/#{resource_name}"
     else
       command_vector << "/#{get_ds_path}"
     end
     # JJM:  This returns most of the preamble of the command.
     #       e.g. 'dscl / -create /Users/mccune'
     command_vector
   end
 
   def self.set_password(resource_name, guid, password_hash)
     password_hash_file = "#{@@password_hash_dir}/#{guid}"
     begin
       File.open(password_hash_file, 'w') { |f| f.write(password_hash)}
     rescue Errno::EACCES => detail
       fail("Could not write to password hash file: #{detail}")
     end
 
     # NBK: For shadow hashes, the user AuthenticationAuthority must contain a value of
     # ";ShadowHash;". The LKDC in 10.5 makes this more interesting though as it
     # will dynamically generate ;Kerberosv5;;username@LKDC:SHA1 attributes if
     # missing. Thus we make sure we only set ;ShadowHash; if it is missing, and
     # we can do this with the merge command. This allows people to continue to
     # use other custom AuthenticationAuthority attributes without stomping on them.
     #
     # There is a potential problem here in that we're only doing this when setting
     # the password, and the attribute could get modified at other times while the
     # hash doesn't change and so this doesn't get called at all... but
     # without switching all the other attributes to merge instead of create I can't
     # see a simple enough solution for this that doesn't modify the user record
     # every single time. This should be a rather rare edge case. (famous last words)
 
     dscl_vector = self.get_exec_preamble("-merge", resource_name)
     dscl_vector << "AuthenticationAuthority" << ";ShadowHash;"
     begin
       dscl_output = execute(dscl_vector)
     rescue Puppet::ExecutionFailure => detail
       fail("Could not set AuthenticationAuthority.")
     end
   end
 
   def self.get_password(guid)
     password_hash = nil
     password_hash_file = "#{@@password_hash_dir}/#{guid}"
     if File.exists?(password_hash_file) and File.file?(password_hash_file)
       fail("Could not read password hash file at #{password_hash_file}") if not File.readable?(password_hash_file)
       f = File.new(password_hash_file)
       password_hash = f.read
       f.close
     end
     password_hash
   end
 
   # Unlike most other *nixes, OS X doesn't provide built in functionality
   # for automatically assigning uids and gids to accounts, so we set up these
   # methods for consumption by functionality like --mkusers
   # By default we restrict to a reasonably sane range for system accounts
   def self.next_system_id(id_type, min_id=20)
     dscl_args = ['.', '-list']
     if id_type == 'uid'
       dscl_args << '/Users' << 'uid'
     elsif id_type == 'gid'
       dscl_args << '/Groups' << 'gid'
     else
       fail("Invalid id_type #{id_type}. Only 'uid' and 'gid' supported")
     end
     dscl_out = dscl(dscl_args)
     # We're ok with throwing away negative uids here.
     ids = dscl_out.split.compact.collect { |l| l.to_i if l.match(/^\d+$/) }
     ids.compact!.sort! { |a,b| a.to_f <=> b.to_f }
     # We're just looking for an unused id in our sorted array.
     ids.each_index do |i|
       next_id = ids[i] + 1
       return next_id if ids[i+1] != next_id and next_id >= min_id
     end
   end
 
 
   def ensure=(ensure_value)
     super
     # We need to loop over all valid properties for the type we're
     # managing and call the method which sets that property value
     # dscl can't create everything at once unfortunately.
     if ensure_value == :present
       @resource.class.validproperties.each do |name|
         next if name == :ensure
         # LAK: We use property.sync here rather than directly calling
         # the settor method because the properties might do some kind
         # of conversion.  In particular, the user gid property might
         # have a string and need to convert it to a number
         if @resource.should(name)
           @resource.property(name).sync
         elsif value = autogen(name)
           self.send(name.to_s + "=", value)
         else
           next
         end
       end
     end
   end
 
   def password=(passphrase)
     exec_arg_vector = self.class.get_exec_preamble("-read", @resource.name)
     exec_arg_vector << @@ns_to_ds_attribute_map[:guid]
     begin
       guid_output = execute(exec_arg_vector)
       guid_plist = Plist.parse_xml(guid_output)
       # Although GeneratedUID like all DirectoryService values can be multi-valued
       # according to the schema, in practice user accounts cannot have multiple UUIDs
       # otherwise Bad Things Happen, so we just deal with the first value.
       guid = guid_plist["dsAttrTypeStandard:#{@@ns_to_ds_attribute_map[:guid]}"][0]
       self.class.set_password(@resource.name, guid, passphrase)
     rescue Puppet::ExecutionFailure => detail
       fail("Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}")
     end
   end
 
   # NBK: we override @parent.set as we need to execute a series of commands
   # to deal with array values, rather than the single command nameservice.rb
   # expects to be returned by modifycmd. Thus we don't bother defining modifycmd.
 
   def set(param, value)
     self.class.validate(param, value)
     current_members = @property_value_cache_hash[:members]
     if param == :members
       # If we are meant to be authoritative for the group membership
       # then remove all existing members who haven't been specified
       # in the manifest.
       remove_unwanted_members(current_members, value) if @resource[:auth_membership] and not current_members.nil?
 
       # if they're not a member, make them one.
       add_members(current_members, value)
     else
       exec_arg_vector = self.class.get_exec_preamble("-create", @resource[:name])
       # JJM: The following line just maps the NS name to the DS name
       #      e.g. { :uid => 'UniqueID' }
       exec_arg_vector << @@ns_to_ds_attribute_map[symbolize(param)]
       # JJM: The following line sends the actual value to set the property to
       exec_arg_vector << value.to_s
       begin
         execute(exec_arg_vector)
       rescue Puppet::ExecutionFailure => detail
         fail("Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}")
       end
     end
   end
 
   # NBK: we override @parent.create as we need to execute a series of commands
   # to create objects with dscl, rather than the single command nameservice.rb
   # expects to be returned by addcmd. Thus we don't bother defining addcmd.
   def create
     if exists?
       info "already exists"
       return nil
     end
 
     # NBK: First we create the object with a known guid so we can set the contents
     # of the password hash if required
     # Shelling out sucks, but for a single use case it doesn't seem worth
     # requiring people install a UUID library that doesn't come with the system.
     # This should be revisited if Puppet starts managing UUIDs for other platform
     # user records.
     guid = %x{/usr/bin/uuidgen}.chomp
 
     exec_arg_vector = self.class.get_exec_preamble("-create", @resource[:name])
     exec_arg_vector << @@ns_to_ds_attribute_map[:guid] << guid
     begin
       execute(exec_arg_vector)
     rescue Puppet::ExecutionFailure => detail
       fail("Could not set GeneratedUID for #{@resource.class.name} #{@resource.name}: #{detail}")
     end
 
     if value = @resource.should(:password) and value != ""
       self.class.set_password(@resource[:name], guid, value)
     end
 
     # Now we create all the standard properties
     Puppet::Type.type(@resource.class.name).validproperties.each do |property|
       next if property == :ensure
       value = @resource.should(property)
       if property == :gid and value.nil?
         value = self.class.next_system_id(id_type='gid')
       end
       if property == :uid and value.nil?
         value = self.class.next_system_id(id_type='uid')
       end
       if value != "" and not value.nil?
         if property == :members
           add_members(nil, value)
         else
           exec_arg_vector = self.class.get_exec_preamble("-create", @resource[:name])
           exec_arg_vector << @@ns_to_ds_attribute_map[symbolize(property)]
           next if property == :password  # skip setting the password here
           exec_arg_vector << value.to_s
           begin
             execute(exec_arg_vector)
           rescue Puppet::ExecutionFailure => detail
             fail("Could not create #{@resource.class.name} #{@resource.name}: #{detail}")
           end
         end
       end
     end
   end
 
   def remove_unwanted_members(current_members, new_members)
     current_members.each do |member|
       if not new_members.flatten.include?(member)
         cmd = [:dseditgroup, "-o", "edit", "-n", ".", "-d", member, @resource[:name]]
         begin
           execute(cmd)
         rescue Puppet::ExecutionFailure => detail
           fail("Could not remove #{member} from group: #{@resource.name}, #{detail}")
         end
       end
     end
   end
 
   def add_members(current_members, new_members)
     new_members.flatten.each do |new_member|
       if current_members.nil? or not current_members.include?(new_member)
         cmd = [:dseditgroup, "-o", "edit", "-n", ".", "-a", new_member, @resource[:name]]
         begin
           execute(cmd)
         rescue Puppet::ExecutionFailure => detail
           fail("Could not add #{new_member} to group: #{@resource.name}, #{detail}")
         end
       end
     end
   end
 
   def deletecmd
     # JJM: Like addcmd, only called when deleting the object itself
     #    Note, this isn't used to delete properties of the object,
     #    at least that's how I understand it...
     self.class.get_exec_preamble("-delete", @resource[:name])
   end
 
   def getinfo(refresh = false)
     # JJM 2007-07-24:
     #      Override the getinfo method, which is also defined in nameservice.rb
     #      This method returns and sets @infohash
     # I'm not re-factoring the name "getinfo" because this method will be
     # most likely called by nameservice.rb, which I didn't write.
     if refresh or (! defined?(@property_value_cache_hash) or ! @property_value_cache_hash)
       # JJM 2007-07-24: OK, there's a bit of magic that's about to
       # happen... Let's see how strong my grip has become... =)
       #
       # self is a provider instance of some Puppet::Type, like
       # Puppet::Type::User::ProviderDirectoryservice for the case of the
       # user type and this provider.
       #
       # self.class looks like "user provider directoryservice", if that
       # helps you ...
       #
       # self.class.resource_type is a reference to the Puppet::Type class,
       # probably Puppet::Type::User or Puppet::Type::Group, etc...
       #
       # self.class.resource_type.validproperties is a class method,
       # returning an Array of the valid properties of that specific
       # Puppet::Type.
       #
       # So... something like [:comment, :home, :password, :shell, :uid,
       # :groups, :ensure, :gid]
       #
       # Ultimately, we add :name to the list, delete :ensure from the
       # list, then report on the remaining list. Pretty whacky, ehh?
       type_properties = [:name] + self.class.resource_type.validproperties
       type_properties.delete(:ensure) if type_properties.include? :ensure
       type_properties << :guid  # append GeneratedUID so we just get the report here
       @property_value_cache_hash = self.class.single_report(@resource[:name], *type_properties)
       [:uid, :gid].each do |param|
         @property_value_cache_hash[param] = @property_value_cache_hash[param].to_i if @property_value_cache_hash and @property_value_cache_hash.include?(param)
       end
     end
     @property_value_cache_hash
   end
 end
 end
diff --git a/lib/puppet/rails/host.rb b/lib/puppet/rails/host.rb
index b9dea2a3d..e5360217c 100644
--- a/lib/puppet/rails/host.rb
+++ b/lib/puppet/rails/host.rb
@@ -1,251 +1,258 @@
+require 'puppet/node/environment'
 require 'puppet/rails'
 require 'puppet/rails/resource'
 require 'puppet/rails/fact_name'
 require 'puppet/rails/source_file'
 require 'puppet/rails/benchmark'
 require 'puppet/util/rails/collection_merger'
 
 class Puppet::Rails::Host < ActiveRecord::Base
   include Puppet::Rails::Benchmark
   extend Puppet::Rails::Benchmark
   include Puppet::Util
   include Puppet::Util::CollectionMerger
 
   has_many :fact_values, :dependent => :destroy, :class_name => "Puppet::Rails::FactValue"
   has_many :fact_names, :through => :fact_values, :class_name => "Puppet::Rails::FactName"
   belongs_to :source_file
   has_many :resources, :dependent => :destroy, :class_name => "Puppet::Rails::Resource"
 
   def self.from_puppet(node)
     host = find_by_name(node.name) || new(:name => node.name)
 
     {"ipaddress" => "ip", "environment" => "environment"}.each do |myparam, itsparam|
       if value = node.send(myparam)
         host.send(itsparam + "=", value)
       end
     end
 
     host
   end
 
+  # Override the setter for environment to force it to be a string, lest it
+  # be YAML encoded.  See #4487.
+  def environment=(value)
+    super value.to_s
+  end
+
   # returns a hash of fact_names.name => [ fact_values ] for this host.
   # Note that 'fact_values' is actually a list of the value instances, not
   # just actual values.
   def get_facts_hash
     fact_values = self.fact_values.find(:all, :include => :fact_name)
     return fact_values.inject({}) do | hash, value |
       hash[value.fact_name.name] ||= []
       hash[value.fact_name.name] << value
       hash
     end
   end
 
 
   # This is *very* similar to the merge_parameters method
   # of Puppet::Rails::Resource.
   def merge_facts(facts)
     db_facts = {}
 
     deletions = []
     self.fact_values.find(:all, :include => :fact_name).each do |value|
       deletions << value['id'] and next unless facts.include?(value['name'])
       # Now store them for later testing.
       db_facts[value['name']] ||= []
       db_facts[value['name']] << value
     end
 
     # Now get rid of any parameters whose value list is different.
     # This might be extra work in cases where an array has added or lost
     # a single value, but in the most common case (a single value has changed)
     # this makes sense.
     db_facts.each do |name, value_hashes|
       values = value_hashes.collect { |v| v['value'] }
 
       unless values == facts[name]
         value_hashes.each { |v| deletions << v['id'] }
       end
     end
 
     # Perform our deletions.
     Puppet::Rails::FactValue.delete(deletions) unless deletions.empty?
 
     # Lastly, add any new parameters.
     facts.each do |name, value|
       next if db_facts.include?(name)
       values = value.is_a?(Array) ? value : [value]
 
       values.each do |v|
         fact_values.build(:value => v, :fact_name => Puppet::Rails::FactName.find_or_create_by_name(name))
       end
     end
   end
 
   # Set our resources.
   def merge_resources(list)
     # keep only exported resources in thin_storeconfig mode
     list = list.select { |r| r.exported? } if Puppet.settings[:thin_storeconfigs]
 
     resources_by_id = nil
     debug_benchmark("Searched for resources") {
       resources_by_id = find_resources
     }
 
     debug_benchmark("Searched for resource params and tags") {
       find_resources_parameters_tags(resources_by_id)
     } if id
 
     debug_benchmark("Performed resource comparison") {
       compare_to_catalog(resources_by_id, list)
     }
   end
 
   def find_resources
     condition = { :exported => true } if Puppet.settings[:thin_storeconfigs]
 
     resources.find(:all, :include => :source_file, :conditions => condition || {}).inject({}) do | hash, resource |
       hash[resource.id] = resource
       hash
     end
   end
 
   def find_resources_parameters_tags(resources)
     find_resources_parameters(resources)
     find_resources_tags(resources)
   end
 
   def compare_to_catalog(existing, list)
     compiled = list.inject({}) do |hash, resource|
       hash[resource.ref] = resource
       hash
     end
 
     resources = nil
     debug_benchmark("Resource removal") {
       resources = remove_unneeded_resources(compiled, existing)
     }
 
     # Now for all resources in the catalog but not in the db, we're pretty easy.
     additions = nil
     debug_benchmark("Resource merger") {
       additions = perform_resource_merger(compiled, resources)
     }
 
     debug_benchmark("Resource addition") {
       additions.each do |resource|
         build_rails_resource_from_parser_resource(resource)
       end
 
       log_accumulated_marks "Added resources"
     }
   end
 
   def add_new_resources(additions)
     additions.each do |resource|
       Puppet::Rails::Resource.from_parser_resource(self, resource)
     end
   end
 
   # Turn a parser resource into a Rails resource.
   def build_rails_resource_from_parser_resource(resource)
     db_resource = nil
     accumulate_benchmark("Added resources", :initialization) {
       args = Puppet::Rails::Resource.rails_resource_initial_args(resource)
 
       db_resource = self.resources.build(args)
 
       # Our file= method does the name to id conversion.
       db_resource.file = resource.file
     }
 
 
     accumulate_benchmark("Added resources", :parameters) {
       resource.each do |param, value|
         Puppet::Rails::ParamValue.from_parser_param(param, value).each do |value_hash|
           db_resource.param_values.build(value_hash)
         end
       end
     }
 
     accumulate_benchmark("Added resources", :tags) {
       resource.tags.each { |tag| db_resource.add_resource_tag(tag) }
     }
 
     db_resource.save
 
     db_resource
   end
 
 
   def perform_resource_merger(compiled, resources)
     return compiled.values if resources.empty?
 
     # Now for all resources in the catalog but not in the db, we're pretty easy.
     additions = []
     compiled.each do |ref, resource|
       if db_resource = resources[ref]
         db_resource.merge_parser_resource(resource)
       else
         additions << resource
       end
     end
     log_accumulated_marks "Resource merger"
 
     additions
   end
 
   def remove_unneeded_resources(compiled, existing)
     deletions = []
     resources = {}
     existing.each do |id, resource|
       # it seems that it can happen (see bug #2010) some resources are duplicated in the
       # database (ie logically corrupted database), in which case we remove the extraneous
       # entries.
       if resources.include?(resource.ref)
         deletions << id
         next
       end
 
       # If the resource is in the db but not in the catalog, mark it
       # for removal.
       unless compiled.include?(resource.ref)
         deletions << id
         next
       end
 
       resources[resource.ref] = resource
     end
     # We need to use 'destroy' here, not 'delete', so that all
     # dependent objects get removed, too.
     Puppet::Rails::Resource.destroy(deletions) unless deletions.empty?
 
     resources
   end
 
   def find_resources_parameters(resources)
     params = Puppet::Rails::ParamValue.find_all_params_from_host(self)
 
     # assign each loaded parameters/tags to the resource it belongs to
     params.each do |param|
       resources[param['resource_id']].add_param_to_list(param) if resources.include?(param['resource_id'])
     end
   end
 
   def find_resources_tags(resources)
     tags = Puppet::Rails::ResourceTag.find_all_tags_from_host(self)
 
     tags.each do |tag|
       resources[tag['resource_id']].add_tag_to_list(tag) if resources.include?(tag['resource_id'])
     end
   end
 
   def to_puppet
     node = Puppet::Node.new(self.name)
     {"ip" => "ipaddress", "environment" => "environment"}.each do |myparam, itsparam|
       if value = send(myparam)
         node.send(itsparam + "=", value)
       end
     end
 
     node
   end
 end
diff --git a/lib/puppet/type/file.rb b/lib/puppet/type/file.rb
index 715836b22..1790c5e92 100644
--- a/lib/puppet/type/file.rb
+++ b/lib/puppet/type/file.rb
@@ -1,794 +1,800 @@
 require 'digest/md5'
 require 'cgi'
 require 'etc'
 require 'uri'
 require 'fileutils'
 require 'puppet/network/handler'
 require 'puppet/util/diff'
 require 'puppet/util/checksums'
 require 'puppet/network/client'
 require 'puppet/util/backups'
 
 Puppet::Type.newtype(:file) do
   include Puppet::Util::MethodHelper
   include Puppet::Util::Checksums
   include Puppet::Util::Backups
   @doc = "Manages local files, including setting ownership and
     permissions, creation of both files and directories, and
     retrieving entire files from remote servers.  As Puppet matures, it
     expected that the `file` resource will be used less and less to
     manage content, and instead native resources will be used to do so.
 
     If you find that you are often copying files in from a central
     location, rather than using native resources, please contact
     Puppet Labs and we can hopefully work with you to develop a
     native resource to support what you are doing.
     
     **Autorequires:** If Puppet is managing the user or group that owns a file, the file resource will autorequire them. If Puppet is managing any parent directories of a file, the file resource will autorequire them."
 
   def self.title_patterns
     [ [ /^(.*?)\/*\Z/m, [ [ :path, lambda{|x| x} ] ] ] ]
   end
 
   newparam(:path) do
     desc "The path to the file to manage.  Must be fully qualified."
     isnamevar
 
     validate do |value|
       # accept various path syntaxes: lone slash, posix, win32, unc
       unless (Puppet.features.posix? and value =~ /^\//) or (Puppet.features.microsoft_windows? and (value =~ /^.:\// or value =~ /^\/\/[^\/]+\/[^\/]+/))
         fail Puppet::Error, "File paths must be fully qualified, not '#{value}'"
       end
     end
 
     # convert the current path in an index into the collection and the last
     # path name. The aim is to use less storage for all common paths in a hierarchy
     munge do |value|
       path, name = ::File.split(value.gsub(/\/+/,'/'))
       { :index => Puppet::FileCollection.collection.index(path), :name => name }
     end
 
     # and the reverse
     unmunge do |value|
       basedir = Puppet::FileCollection.collection.path(value[:index])
       # a lone slash as :name indicates a root dir on windows
       if value[:name] == '/'
         basedir
       else
         ::File.join( basedir, value[:name] )
       end
     end
   end
 
   newparam(:backup) do
     desc "Whether files should be backed up before
       being replaced.  The preferred method of backing files up is via
       a `filebucket`, which stores files by their MD5 sums and allows
       easy retrieval without littering directories with backups.  You
       can specify a local filebucket or a network-accessible
       server-based filebucket by setting `backup => bucket-name`.
       Alternatively, if you specify any value that begins with a `.`
       (e.g., `.puppet-bak`), then Puppet will use copy the file in
       the same directory with that value as the extension of the
       backup. Setting `backup => false` disables all backups of the
       file in question.
 
       Puppet automatically creates a local filebucket named `puppet` and
       defaults to backing up there.  To use a server-based filebucket,
       you must specify one in your configuration
 
             filebucket { main:
               server => puppet
             }
 
       The `puppet master` daemon creates a filebucket by default,
       so you can usually back up to your main server with this
       configuration.  Once you've described the bucket in your
       configuration, you can use it in any file
 
             file { \"/my/file\":
               source => \"/path/in/nfs/or/something\",
               backup => main
             }
 
       This will back the file up to the central server.
 
       At this point, the benefits of using a filebucket are that you do not
       have backup files lying around on each of your machines, a given
       version of a file is only backed up once, and you can restore
       any given file manually, no matter how old.  Eventually,
       transactional support will be able to automatically restore
       filebucketed files.
       "
 
     defaultto "puppet"
 
     munge do |value|
       # I don't really know how this is happening.
       value = value.shift if value.is_a?(Array)
 
       case value
       when false, "false", :false
         false
       when true, "true", ".puppet-bak", :true
         ".puppet-bak"
       when String
         value
       else
         self.fail "Invalid backup type #{value.inspect}"
       end
     end
   end
 
   newparam(:recurse) do
     desc "Whether and how deeply to do recursive
       management. Options are:
 
       * `inf,true` --- Regular style recursion on both remote and local
         directory structure.
       * `remote` --- Descends recursively into the remote directory
         but not the local directory. Allows copying of
         a few files into a directory containing many
         unmanaged files without scanning all the local files.
       * `false` --- Default of no recursion.
       * `[0-9]+` --- Same as true, but limit recursion. Warning: this syntax
         has been deprecated in favor of the `recurselimit` attribute.
     "
 
     newvalues(:true, :false, :inf, :remote, /^[0-9]+$/)
 
     # Replace the validation so that we allow numbers in
     # addition to string representations of them.
     validate { |arg| }
     munge do |value|
       newval = super(value)
       case newval
       when :true, :inf; true
       when :false; false
       when :remote; :remote
       when Integer, Fixnum, Bignum
         self.warning "Setting recursion depth with the recurse parameter is now deprecated, please use recurselimit"
 
         # recurse == 0 means no recursion
         return false if value == 0
 
         resource[:recurselimit] = value
         true
       when /^\d+$/
         self.warning "Setting recursion depth with the recurse parameter is now deprecated, please use recurselimit"
         value = Integer(value)
 
         # recurse == 0 means no recursion
         return false if value == 0
 
         resource[:recurselimit] = value
         true
       else
         self.fail "Invalid recurse value #{value.inspect}"
       end
     end
   end
 
   newparam(:recurselimit) do
     desc "How deeply to do recursive management."
 
     newvalues(/^[0-9]+$/)
 
     munge do |value|
       newval = super(value)
       case newval
       when Integer, Fixnum, Bignum; value
       when /^\d+$/; Integer(value)
       else
         self.fail "Invalid recurselimit value #{value.inspect}"
       end
     end
   end
 
   newparam(:replace, :boolean => true) do
     desc "Whether or not to replace a file that is
       sourced but exists.  This is useful for using file sources
       purely for initialization."
     newvalues(:true, :false)
     aliasvalue(:yes, :true)
     aliasvalue(:no, :false)
     defaultto :true
   end
 
   newparam(:force, :boolean => true) do
     desc "Force the file operation.  Currently only used when replacing
       directories with links."
     newvalues(:true, :false)
     defaultto false
   end
 
   newparam(:ignore) do
     desc "A parameter which omits action on files matching
       specified patterns during recursion.  Uses Ruby's builtin globbing
       engine, so shell metacharacters are fully supported, e.g. `[a-z]*`.
       Matches that would descend into the directory structure are ignored,
       e.g., `*/*`."
 
     validate do |value|
       unless value.is_a?(Array) or value.is_a?(String) or value == false
         self.devfail "Ignore must be a string or an Array"
       end
     end
   end
 
   newparam(:links) do
     desc "How to handle links during file actions.  During file copying,
       `follow` will copy the target file instead of the link, `manage`
       will copy the link itself, and `ignore` will just pass it by.
       When not copying, `manage` and `ignore` behave equivalently
       (because you cannot really ignore links entirely during local recursion), and `follow` will manage the file to which the
       link points."
 
     newvalues(:follow, :manage)
 
     defaultto :manage
   end
 
   newparam(:purge, :boolean => true) do
     desc "Whether unmanaged files should be purged.  If you have a filebucket
       configured the purged files will be uploaded, but if you do not,
       this will destroy data.  Only use this option for generated
       files unless you really know what you are doing.  This option only
       makes sense when recursively managing directories.
 
       Note that when using `purge` with `source`, Puppet will purge any files
       that are not on the remote system."
 
     defaultto :false
 
     newvalues(:true, :false)
   end
 
   newparam(:sourceselect) do
     desc "Whether to copy all valid sources, or just the first one.  This parameter
       is only used in recursive copies; by default, the first valid source is the
       only one used as a recursive source, but if this parameter is set to `all`,
       then all valid sources will have all of their contents copied to the local host,
       and for sources that have the same file, the source earlier in the list will
       be used."
 
     defaultto :first
 
     newvalues(:first, :all)
   end
 
-  # Autorequire any parent directories.
+  # Autorequire the nearest ancestor directory found in the catalog.
   autorequire(:file) do
     basedir = ::File.dirname(self[:path])
     if basedir != self[:path]
-      basedir
+      parents = []
+      until basedir == parents.last
+        parents << basedir
+        basedir = File.dirname(basedir)
+      end
+      # The filename of the first ancestor found, or nil
+      parents.find { |dir| catalog.resource(:file, dir) }
     else
       nil
     end
   end
 
   # Autorequire the owner and group of the file.
   {:user => :owner, :group => :group}.each do |type, property|
     autorequire(type) do
       if @parameters.include?(property)
         # The user/group property automatically converts to IDs
         next unless should = @parameters[property].shouldorig
         val = should[0]
         if val.is_a?(Integer) or val =~ /^\d+$/
           nil
         else
           val
         end
       end
     end
   end
 
   CREATORS = [:content, :source, :target]
   SOURCE_ONLY_CHECKSUMS = [:none, :ctime, :mtime]
 
   validate do
     creator_count = 0
     CREATORS.each do |param|
       creator_count += 1 if self.should(param)
     end
     creator_count += 1 if @parameters.include?(:source)
     self.fail "You cannot specify more than one of #{CREATORS.collect { |p| p.to_s}.join(", ")}" if creator_count > 1
 
     self.fail "You cannot specify a remote recursion without a source" if !self[:source] and self[:recurse] == :remote
 
     self.fail "You cannot specify source when using checksum 'none'" if self[:checksum] == :none && !self[:source].nil?
 
     SOURCE_ONLY_CHECKSUMS.each do |checksum_type|
       self.fail "You cannot specify content when using checksum '#{checksum_type}'" if self[:checksum] == checksum_type && !self[:content].nil?
     end
 
     self.warning "Possible error: recurselimit is set but not recurse, no recursion will happen" if !self[:recurse] and self[:recurselimit]
   end
 
   def self.[](path)
     return nil unless path
     super(path.gsub(/\/+/, '/').sub(/\/$/, ''))
   end
 
   def self.instances(base = '/')
     return self.new(:name => base, :recurse => true, :recurselimit => 1, :audit => :all).recurse_local.values
   end
 
   # Determine the user to write files as.
   def asuser
     if self.should(:owner) and ! self.should(:owner).is_a?(Symbol)
       writeable = Puppet::Util::SUIDManager.asuser(self.should(:owner)) {
         FileTest.writable?(::File.dirname(self[:path]))
       }
 
       # If the parent directory is writeable, then we execute
       # as the user in question.  Otherwise we'll rely on
       # the 'owner' property to do things.
       asuser = self.should(:owner) if writeable
     end
 
     asuser
   end
 
   def bucket
     return @bucket if @bucket
 
     backup = self[:backup]
     return nil unless backup
     return nil if backup =~ /^\./
 
     unless catalog or backup == "puppet"
       fail "Can not find filebucket for backups without a catalog"
     end
 
     unless catalog and filebucket = catalog.resource(:filebucket, backup) or backup == "puppet"
       fail "Could not find filebucket #{backup} specified in backup"
     end
 
     return default_bucket unless filebucket
 
     @bucket = filebucket.bucket
 
     @bucket
   end
 
   def default_bucket
     Puppet::Type.type(:filebucket).mkdefaultbucket.bucket
   end
 
   # Does the file currently exist?  Just checks for whether
   # we have a stat
   def exist?
     stat ? true : false
   end
 
   # We have to do some extra finishing, to retrieve our bucket if
   # there is one.
   def finish
     # Look up our bucket, if there is one
     bucket
     super
   end
 
   # Create any children via recursion or whatever.
   def eval_generate
     return [] unless self.recurse?
 
     recurse
     #recurse.reject do |resource|
     #    catalog.resource(:file, resource[:path])
     #end.each do |child|
     #    catalog.add_resource child
     #    catalog.relationship_graph.add_edge self, child
     #end
   end
 
   def flush
     # We want to make sure we retrieve metadata anew on each transaction.
     @parameters.each do |name, param|
       param.flush if param.respond_to?(:flush)
     end
     @stat = nil
   end
 
   def initialize(hash)
     # Used for caching clients
     @clients = {}
 
     super
 
     # If they've specified a source, we get our 'should' values
     # from it.
     unless self[:ensure]
       if self[:target]
         self[:ensure] = :symlink
       elsif self[:content]
         self[:ensure] = :file
       end
     end
 
     @stat = nil
   end
 
   # Configure discovered resources to be purged.
   def mark_children_for_purging(children)
     children.each do |name, child|
       next if child[:source]
       child[:ensure] = :absent
     end
   end
 
   # Create a new file or directory object as a child to the current
   # object.
   def newchild(path)
     full_path = ::File.join(self[:path], path)
 
     # Add some new values to our original arguments -- these are the ones
     # set at initialization.  We specifically want to exclude any param
     # values set by the :source property or any default values.
     # LAK:NOTE This is kind of silly, because the whole point here is that
     # the values set at initialization should live as long as the resource
     # but values set by default or by :source should only live for the transaction
     # or so.  Unfortunately, we don't have a straightforward way to manage
     # the different lifetimes of this data, so we kludge it like this.
     # The right-side hash wins in the merge.
     options = @original_parameters.merge(:path => full_path).reject { |param, value| value.nil? }
 
     # These should never be passed to our children.
     [:parent, :ensure, :recurse, :recurselimit, :target, :alias, :source].each do |param|
       options.delete(param) if options.include?(param)
     end
 
     self.class.new(options)
   end
 
   # Files handle paths specially, because they just lengthen their
   # path names, rather than including the full parent's title each
   # time.
   def pathbuilder
     # We specifically need to call the method here, so it looks
     # up our parent in the catalog graph.
     if parent = parent()
       # We only need to behave specially when our parent is also
       # a file
       if parent.is_a?(self.class)
         # Remove the parent file name
         list = parent.pathbuilder
         list.pop # remove the parent's path info
         return list << self.ref
       else
         return super
       end
     else
       return [self.ref]
     end
   end
 
   # Should we be purging?
   def purge?
     @parameters.include?(:purge) and (self[:purge] == :true or self[:purge] == "true")
   end
 
   # Recursively generate a list of file resources, which will
   # be used to copy remote files, manage local files, and/or make links
   # to map to another directory.
   def recurse
     children = (self[:recurse] == :remote) ? {} : recurse_local
 
     if self[:target]
       recurse_link(children)
     elsif self[:source]
       recurse_remote(children)
     end
 
     # If we're purging resources, then delete any resource that isn't on the
     # remote system.
     mark_children_for_purging(children) if self.purge?
 
     result = children.values.sort { |a, b| a[:path] <=> b[:path] }
     remove_less_specific_files(result)
   end
 
   # This is to fix bug #2296, where two files recurse over the same
   # set of files.  It's a rare case, and when it does happen you're
   # not likely to have many actual conflicts, which is good, because
   # this is a pretty inefficient implementation.
   def remove_less_specific_files(files)
     mypath = self[:path].split(::File::Separator)
     other_paths = catalog.vertices.
       select  { |r| r.is_a?(self.class) and r[:path] != self[:path] }.
       collect { |r| r[:path].split(::File::Separator) }.
       select  { |p| p[0,mypath.length]  == mypath }
 
     return files if other_paths.empty?
 
     files.reject { |file|
       path = file[:path].split(::File::Separator)
       other_paths.any? { |p| path[0,p.length] == p }
       }
   end
 
   # A simple method for determining whether we should be recursing.
   def recurse?
     self[:recurse] == true or self[:recurse] == :remote
   end
 
   # Recurse the target of the link.
   def recurse_link(children)
     perform_recursion(self[:target]).each do |meta|
       if meta.relative_path == "."
         self[:ensure] = :directory
         next
       end
 
       children[meta.relative_path] ||= newchild(meta.relative_path)
       if meta.ftype == "directory"
         children[meta.relative_path][:ensure] = :directory
       else
         children[meta.relative_path][:ensure] = :link
         children[meta.relative_path][:target] = meta.full_path
       end
     end
     children
   end
 
   # Recurse the file itself, returning a Metadata instance for every found file.
   def recurse_local
     result = perform_recursion(self[:path])
     return {} unless result
     result.inject({}) do |hash, meta|
       next hash if meta.relative_path == "."
 
       hash[meta.relative_path] = newchild(meta.relative_path)
       hash
     end
   end
 
   # Recurse against our remote file.
   def recurse_remote(children)
     sourceselect = self[:sourceselect]
 
     total = self[:source].collect do |source|
       next unless result = perform_recursion(source)
       return if top = result.find { |r| r.relative_path == "." } and top.ftype != "directory"
       result.each { |data| data.source = "#{source}/#{data.relative_path}" }
       break result if result and ! result.empty? and sourceselect == :first
       result
     end.flatten
 
     # This only happens if we have sourceselect == :all
     unless sourceselect == :first
       found = []
       total.reject! do |data|
         result = found.include?(data.relative_path)
         found << data.relative_path unless found.include?(data.relative_path)
         result
       end
     end
 
     total.each do |meta|
       if meta.relative_path == "."
         parameter(:source).metadata = meta
         next
       end
       children[meta.relative_path] ||= newchild(meta.relative_path)
       children[meta.relative_path][:source] = meta.source
       children[meta.relative_path][:checksum] = :md5 if meta.ftype == "file"
 
       children[meta.relative_path].parameter(:source).metadata = meta
     end
 
     children
   end
 
   def perform_recursion(path)
     Puppet::FileServing::Metadata.indirection.search(
       path,
       :links => self[:links],
       :recurse => (self[:recurse] == :remote ? true : self[:recurse]),
       :recurselimit => self[:recurselimit],
       :ignore => self[:ignore],
       :checksum_type => (self[:source] || self[:content]) ? self[:checksum] : :none
     )
   end
 
   # Remove any existing data.  This is only used when dealing with
   # links or directories.
   def remove_existing(should)
     return unless s = stat
 
     self.fail "Could not back up; will not replace" unless perform_backup
 
     unless should.to_s == "link"
       return if s.ftype.to_s == should.to_s
     end
 
     case s.ftype
     when "directory"
       if self[:force] == :true
         debug "Removing existing directory for replacement with #{should}"
         FileUtils.rmtree(self[:path])
       else
         notice "Not removing directory; use 'force' to override"
       end
     when "link", "file"
       debug "Removing existing #{s.ftype} for replacement with #{should}"
       ::File.unlink(self[:path])
     else
       self.fail "Could not back up files of type #{s.ftype}"
     end
     expire
   end
 
   def retrieve
     if source = parameter(:source)
       source.copy_source_values
     end
     super
   end
 
   # Set the checksum, from another property.  There are multiple
   # properties that modify the contents of a file, and they need the
   # ability to make sure that the checksum value is in sync.
   def setchecksum(sum = nil)
     if @parameters.include? :checksum
       if sum
         @parameters[:checksum].checksum = sum
       else
         # If they didn't pass in a sum, then tell checksum to
         # figure it out.
         currentvalue = @parameters[:checksum].retrieve
         @parameters[:checksum].checksum = currentvalue
       end
     end
   end
 
   # Should this thing be a normal file?  This is a relatively complex
   # way of determining whether we're trying to create a normal file,
   # and it's here so that the logic isn't visible in the content property.
   def should_be_file?
     return true if self[:ensure] == :file
 
     # I.e., it's set to something like "directory"
     return false if e = self[:ensure] and e != :present
 
     # The user doesn't really care, apparently
     if self[:ensure] == :present
       return true unless s = stat
       return(s.ftype == "file" ? true : false)
     end
 
     # If we've gotten here, then :ensure isn't set
     return true if self[:content]
     return true if stat and stat.ftype == "file"
     false
   end
 
   # Stat our file.  Depending on the value of the 'links' attribute, we
   # use either 'stat' or 'lstat', and we expect the properties to use the
   # resulting stat object accordingly (mostly by testing the 'ftype'
   # value).
   cached_attr(:stat) do
     method = :stat
 
     # Files are the only types that support links
     if (self.class.name == :file and self[:links] != :follow) or self.class.name == :tidy
       method = :lstat
     end
     path = self[:path]
 
     begin
       ::File.send(method, self[:path])
     rescue Errno::ENOENT => error
       return nil
     rescue Errno::EACCES => error
       warning "Could not stat; permission denied"
       return nil
     end
   end
 
   # We have to hack this just a little bit, because otherwise we'll get
   # an error when the target and the contents are created as properties on
   # the far side.
   def to_trans(retrieve = true)
     obj = super
     obj.delete(:target) if obj[:target] == :notlink
     obj
   end
 
   # Write out the file.  Requires the property name for logging.
   # Write will be done by the content property, along with checksum computation
   def write(property)
     remove_existing(:file)
 
     use_temporary_file = write_temporary_file?
     if use_temporary_file
       path = "#{self[:path]}.puppettmp_#{rand(10000)}"
       path = "#{self[:path]}.puppettmp_#{rand(10000)}" while ::File.exists?(path) or ::File.symlink?(path)
     else
       path = self[:path]
     end
 
     mode = self.should(:mode) # might be nil
     umask = mode ? 000 : 022
     mode_int = mode ? mode.to_i(8) : nil
 
     content_checksum = Puppet::Util.withumask(umask) { ::File.open(path, 'w', mode_int ) { |f| write_content(f) } }
 
     # And put our new file in place
     if use_temporary_file # This is only not true when our file is empty.
       begin
         fail_if_checksum_is_wrong(path, content_checksum) if validate_checksum?
         ::File.rename(path, self[:path])
       rescue => detail
         fail "Could not rename temporary file #{path} to #{self[:path]}: #{detail}"
       ensure
         # Make sure the created file gets removed
         ::File.unlink(path) if FileTest.exists?(path)
       end
     end
 
     # make sure all of the modes are actually correct
     property_fix
 
   end
 
   private
 
   # Should we validate the checksum of the file we're writing?
   def validate_checksum?
     self[:checksum] !~ /time/
   end
 
   # Make sure the file we wrote out is what we think it is.
   def fail_if_checksum_is_wrong(path, content_checksum)
     newsum = parameter(:checksum).sum_file(path)
     return if [:absent, nil, content_checksum].include?(newsum)
 
     self.fail "File written to disk did not match checksum; discarding changes (#{content_checksum} vs #{newsum})"
   end
 
   # write the current content. Note that if there is no content property
   # simply opening the file with 'w' as done in write is enough to truncate
   # or write an empty length file.
   def write_content(file)
     (content = property(:content)) && content.write(file)
   end
 
   private
 
   def write_temporary_file?
     # unfortunately we don't know the source file size before fetching it
     # so let's assume the file won't be empty
     (c = property(:content) and c.length) || (s = @parameters[:source] and 1)
   end
 
   # There are some cases where all of the work does not get done on
   # file creation/modification, so we have to do some extra checking.
   def property_fix
     properties.each do |thing|
       next unless [:mode, :owner, :group, :seluser, :selrole, :seltype, :selrange].include?(thing.name)
 
       # Make sure we get a new stat objct
       expire
       currentvalue = thing.retrieve
       thing.sync unless thing.safe_insync?(currentvalue)
     end
   end
 end
 
 # We put all of the properties in separate files, because there are so many
 # of them.  The order these are loaded is important, because it determines
 # the order they are in the property lit.
 require 'puppet/type/file/checksum'
 require 'puppet/type/file/content'     # can create the file
 require 'puppet/type/file/source'      # can create the file
 require 'puppet/type/file/target'      # creates a different type of file
 require 'puppet/type/file/ensure'      # can create the file
 require 'puppet/type/file/owner'
 require 'puppet/type/file/group'
 require 'puppet/type/file/mode'
 require 'puppet/type/file/type'
 require 'puppet/type/file/selcontext'  # SELinux file context
 require 'puppet/type/file/ctime'
 require 'puppet/type/file/mtime'
diff --git a/spec/unit/interface/action_builder_spec.rb b/spec/unit/interface/action_builder_spec.rb
index bf7afa74e..6f36d2b44 100755
--- a/spec/unit/interface/action_builder_spec.rb
+++ b/spec/unit/interface/action_builder_spec.rb
@@ -1,193 +1,248 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/interface/action_builder'
 require 'puppet/network/format_handler'
 
 describe Puppet::Interface::ActionBuilder do
   let :face do Puppet::Interface.new(:puppet_interface_actionbuilder, '0.0.1') end
 
   it "should build an action" do
     action = Puppet::Interface::ActionBuilder.build(nil, :foo) do
     end
     action.should be_a(Puppet::Interface::Action)
     action.name.should == :foo
   end
 
   it "should define a method on the face which invokes the action" do
     face = Puppet::Interface.new(:action_builder_test_interface, '0.0.1') do
       action(:foo) { when_invoked { "invoked the method" } }
     end
 
     face.foo.should == "invoked the method"
   end
 
   it "should require a block" do
     expect { Puppet::Interface::ActionBuilder.build(nil, :foo) }.
       should raise_error("Action :foo must specify a block")
   end
 
   describe "when handling options" do
     it "should have a #option DSL function" do
       method = nil
       Puppet::Interface::ActionBuilder.build(face, :foo) do
         method = self.method(:option)
       end
       method.should be
     end
 
     it "should define an option without a block" do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do
         option "--bar"
       end
       action.should be_option :bar
     end
 
     it "should accept an empty block" do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do
         option "--bar" do
           # This space left deliberately blank.
         end
       end
       action.should be_option :bar
     end
   end
 
+  describe "#inherit_options_from" do
+    let :face do
+      Puppet::Interface.new(:face_with_some_options, '0.0.1') do
+        option '-w'
+
+        action(:foo) do
+          option '-x', '--ex'
+          option '-y', '--why'
+        end
+
+        action(:bar) do
+          option '-z', '--zee'
+        end
+
+        action(:baz) do
+          option '-z', '--zed'
+        end
+      end
+    end
+
+    it 'should add the options from the specified action' do
+      foo = face.get_action(:foo)
+      action = Puppet::Interface::ActionBuilder.build(face, :inherit_options) do
+        inherit_options_from foo
+      end
+      action.options.should == foo.options
+    end
+
+    it 'should add the options from multiple actions' do
+      foo = face.get_action(:foo)
+      bar = face.get_action(:bar)
+      action = Puppet::Interface::ActionBuilder.build(face, :inherit_options) do
+        inherit_options_from foo
+        inherit_options_from bar
+      end
+      action.options.should == (foo.options + bar.options).uniq.sort
+    end
+
+    it 'should permit symbolic names for actions in the same face' do
+      foo = face.get_action(:foo)
+      action = Puppet::Interface::ActionBuilder.build(face, :inherit_options) do
+        inherit_options_from :foo
+      end
+      action.options.should == foo.options
+    end
+
+    it 'should raise a useful error if you supply a bad action name' do
+      expect do
+        Puppet::Interface::ActionBuilder.build(face, :inherit_options) do
+          inherit_options_from :nowhere
+        end
+      end.to raise_error /nowhere/
+    end
+  end
+
   context "inline documentation" do
     it "should set the summary" do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do
         summary "this is some text"
       end
       action.summary.should == "this is some text"
     end
   end
 
   context "action defaulting" do
     it "should set the default to true" do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do
         default
       end
       action.default.should be_true
     end
 
     it "should not be default by, er, default. *cough*" do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do end
       action.default.should be_false
     end
   end
 
   context "#when_rendering" do
     it "should fail if no rendering format is given" do
       expect {
         Puppet::Interface::ActionBuilder.build(face, :foo) do
           when_rendering do true end
         end
       }.to raise_error ArgumentError, /must give a rendering format to when_rendering/
     end
 
     it "should fail if no block is given" do
       expect {
         Puppet::Interface::ActionBuilder.build(face, :foo) do
           when_rendering :json
         end
       }.to raise_error ArgumentError, /must give a block to when_rendering/
     end
 
     it "should fail if the block takes no arguments" do
       expect {
         Puppet::Interface::ActionBuilder.build(face, :foo) do
           when_rendering :json do true end
         end
       }.to raise_error ArgumentError, /when_rendering methods take one argument, the result, not/
     end
 
     it "should fail if the block takes more than one argument" do
       expect {
         Puppet::Interface::ActionBuilder.build(face, :foo) do
           when_rendering :json do |a, b, c| true end
         end
       }.to raise_error ArgumentError, /when_rendering methods take one argument, the result, not/
     end
 
     it "should fail if the block takes a variable number of arguments" do
       expect {
         Puppet::Interface::ActionBuilder.build(face, :foo) do
           when_rendering :json do |*args| true end
         end
       }.to raise_error(ArgumentError,
                        /when_rendering methods take one argument, the result, not/)
     end
 
     it "should stash a rendering block" do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do
         when_rendering :json do |a| true end
       end
       action.when_rendering(:json).should be_an_instance_of Method
     end
 
     it "should fail if you try to set the same rendering twice" do
       expect {
         Puppet::Interface::ActionBuilder.build(face, :foo) do
           when_rendering :json do |a| true end
           when_rendering :json do |a| true end
         end
       }.to raise_error ArgumentError, /You can't define a rendering method for json twice/
     end
 
     it "should work if you set two different renderings" do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do
         when_rendering :json do |a| true end
         when_rendering :yaml do |a| true end
       end
       action.when_rendering(:json).should be_an_instance_of Method
       action.when_rendering(:yaml).should be_an_instance_of Method
     end
 
     it "should be bound to the face when called" do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do
         when_rendering :json do |a| self end
       end
       action.when_rendering(:json).call(true).should == face
     end
   end
 
   context "#render_as" do
     it "should default to nil (eg: based on context)" do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do end
       action.render_as.should be_nil
     end
 
     it "should fail if not rendering format is given" do
       expect {
         Puppet::Interface::ActionBuilder.build(face, :foo) do
           render_as
         end
       }.to raise_error ArgumentError, /must give a rendering format to render_as/
     end
 
     Puppet::Network::FormatHandler.formats.each do |name|
       it "should accept #{name.inspect} format" do
         action = Puppet::Interface::ActionBuilder.build(face, :foo) do
           render_as name
         end
         action.render_as.should == name
       end
     end
 
     it "should accept :for_humans format" do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do
         render_as :for_humans
       end
       action.render_as.should == :for_humans
     end
 
     [:if_you_define_this_format_you_frighten_me, "json", 12].each do |input|
       it "should fail if given #{input.inspect}" do
         expect {
           Puppet::Interface::ActionBuilder.build(face, :foo) do
             render_as input
           end
         }.to raise_error ArgumentError, /#{input.inspect} is not a valid rendering format/
       end
     end
   end
 end
diff --git a/spec/unit/interface/action_spec.rb b/spec/unit/interface/action_spec.rb
index 24826a6ef..735fbcb72 100755
--- a/spec/unit/interface/action_spec.rb
+++ b/spec/unit/interface/action_spec.rb
@@ -1,448 +1,503 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/interface/action'
 
 describe Puppet::Interface::Action do
   describe "when validating the action name" do
     [nil, '', 'foo bar', '-foobar'].each do |input|
       it "should treat #{input.inspect} as an invalid name" do
         expect { Puppet::Interface::Action.new(nil, input) }.
           should raise_error(/is an invalid action name/)
       end
     end
   end
 
   describe "#when_invoked=" do
     it "should fail if the block has arity 0" do
       pending "Ruby 1.8 (painfully) treats argument-free blocks as arity -1" if
         RUBY_VERSION =~ /^1\.8/
 
       expect {
         Puppet::Interface.new(:action_when_invoked, '1.0.0') do
           action :foo do
             when_invoked do
             end
           end
         end
       }.to raise_error ArgumentError, /foobra/
     end
 
     it "should work with arity 1 blocks" do
       face = Puppet::Interface.new(:action_when_invoked, '1.0.0') do
         action :foo do
           when_invoked {|one| }
         end
       end
       # -1, because we use option defaulting. :(
       face.method(:foo).arity.should == -1
     end
 
     it "should work with arity 2 blocks" do
       face = Puppet::Interface.new(:action_when_invoked, '1.0.0') do
         action :foo do
           when_invoked {|one, two| }
         end
       end
       # -2, because we use option defaulting. :(
       face.method(:foo).arity.should == -2
     end
 
     it "should work with arity 1 blocks that collect arguments" do
       face = Puppet::Interface.new(:action_when_invoked, '1.0.0') do
         action :foo do
           when_invoked {|*one| }
         end
       end
       # -1, because we use only varargs
       face.method(:foo).arity.should == -1
     end
 
     it "should work with arity 2 blocks that collect arguments" do
       face = Puppet::Interface.new(:action_when_invoked, '1.0.0') do
         action :foo do
           when_invoked {|one, *two| }
         end
       end
       # -2, because we take one mandatory argument, and one varargs
       face.method(:foo).arity.should == -2
     end
   end
 
+  describe "#inherit_options_from" do
+    let :face do
+      Puppet::Interface.new(:face_with_some_options, '0.0.1') do
+        option '-w'
+
+        action(:foo) do
+          option '-x', '--ex'
+          option '-y', '--why'
+        end
+
+        action(:bar) do
+          option '-z', '--zee'
+        end
+
+        action(:baz) do
+          option '-z', '--zed'
+        end
+
+        action(:noopts) do
+          # no options declared
+        end
+      end
+    end
+
+    subject { action = face.action(:new_action) { } }
+
+    it 'should add the options from the specified action' do
+      subject.inherit_options_from(foo = face.get_action(:foo))
+      subject.options.should == foo.options
+    end
+
+    it 'should not die when the specified action has no options' do
+      original_options = subject.options
+      subject.inherit_options_from(face.get_action(:noopts))
+      subject.options.should == original_options
+    end
+
+    it 'should add the options from multiple actions' do
+      subject.inherit_options_from(foo = face.get_action(:foo))
+      subject.inherit_options_from(bar = face.get_action(:bar))
+      subject.options.should == (foo.options + bar.options).uniq.sort
+    end
+
+    it 'should not inherit face options' do
+      subject.expects(:add_option)
+      subject.expects(:add_option).with(face.get_option(:w)).never
+      subject.inherit_options_from(face.get_action(:bar))
+    end
+
+    it 'should raise an error if inheritance would duplicate options' do
+      subject.inherit_options_from(face.get_action(:bar))
+      expect { subject.inherit_options_from(face.get_action(:baz)) }.to raise_error
+    end
+  end
+
   describe "when invoking" do
     it "should be able to call other actions on the same object" do
       face = Puppet::Interface.new(:my_face, '0.0.1') do
         action(:foo) do
           when_invoked { 25 }
         end
 
         action(:bar) do
           when_invoked { "the value of foo is '#{foo}'" }
         end
       end
       face.foo.should == 25
       face.bar.should == "the value of foo is '25'"
     end
 
     # bar is a class action calling a class action
     # quux is a class action calling an instance action
     # baz is an instance action calling a class action
     # qux is an instance action calling an instance action
     it "should be able to call other actions on the same object when defined on a class" do
       class Puppet::Interface::MyInterfaceBaseClass < Puppet::Interface
         action(:foo) do
           when_invoked { 25 }
         end
 
         action(:bar) do
           when_invoked { "the value of foo is '#{foo}'" }
         end
 
         action(:quux) do
           when_invoked { "qux told me #{qux}" }
         end
       end
 
       face = Puppet::Interface::MyInterfaceBaseClass.new(:my_inherited_face, '0.0.1') do
         action(:baz) do
           when_invoked { "the value of foo in baz is '#{foo}'" }
         end
 
         action(:qux) do
           when_invoked { baz }
         end
       end
       face.foo.should  == 25
       face.bar.should  == "the value of foo is '25'"
       face.quux.should == "qux told me the value of foo in baz is '25'"
       face.baz.should  == "the value of foo in baz is '25'"
       face.qux.should  == "the value of foo in baz is '25'"
     end
 
     context "when calling the Ruby API" do
       let :face do
         Puppet::Interface.new(:ruby_api, '1.0.0') do
           action :bar do
             when_invoked do |*args|
               args.last
             end
           end
         end
       end
 
       it "should work when no options are supplied" do
         options = face.bar
         options.should == {}
       end
 
       it "should work when options are supplied" do
         options = face.bar(:bar => "beer")
         options.should == { :bar => "beer" }
       end
 
       it "should call #validate_args on the action when invoked" do
         face.get_action(:bar).expects(:validate_args).with([1, :two, 'three', {}])
         face.bar 1, :two, 'three'
       end
     end
   end
 
   describe "with action-level options" do
     it "should support options with an empty block" do
       face = Puppet::Interface.new(:action_level_options, '0.0.1') do
         action :foo do
           option "--bar" do
             # this line left deliberately blank
           end
         end
       end
 
       face.should_not be_option :bar
       face.get_action(:foo).should be_option :bar
     end
 
     it "should return only action level options when there are no face options" do
       face = Puppet::Interface.new(:action_level_options, '0.0.1') do
         action :foo do option "--bar" end
       end
 
       face.get_action(:foo).options.should =~ [:bar]
     end
 
     describe "with both face and action options" do
       let :face do
         Puppet::Interface.new(:action_level_options, '0.0.1') do
           action :foo do option "--bar" end
           action :baz do option "--bim" end
           option "--quux"
         end
       end
 
       it "should return combined face and action options" do
         face.get_action(:foo).options.should =~ [:bar, :quux]
       end
 
       it "should fetch options that the face inherited" do
         parent = Class.new(Puppet::Interface)
         parent.option "--foo"
         child = parent.new(:inherited_options, '0.0.1') do
           option "--bar"
           action :action do option "--baz" end
         end
 
         action = child.get_action(:action)
         action.should be
 
         [:baz, :bar, :foo].each do |name|
           action.get_option(name).should be_an_instance_of Puppet::Interface::Option
         end
       end
 
       it "should get an action option when asked" do
         face.get_action(:foo).get_option(:bar).
           should be_an_instance_of Puppet::Interface::Option
       end
 
       it "should get a face option when asked" do
         face.get_action(:foo).get_option(:quux).
           should be_an_instance_of Puppet::Interface::Option
       end
 
       it "should return options only for this action" do
         face.get_action(:baz).options.should =~ [:bim, :quux]
       end
     end
 
     it_should_behave_like "things that declare options" do
       def add_options_to(&block)
         face = Puppet::Interface.new(:with_options, '0.0.1') do
           action(:foo, &block)
         end
         face.get_action(:foo)
       end
     end
 
     it "should fail when a face option duplicates an action option" do
       expect {
         Puppet::Interface.new(:action_level_options, '0.0.1') do
           option "--foo"
           action :bar do option "--foo" end
         end
       }.should raise_error ArgumentError, /Option foo conflicts with existing option foo/i
     end
 
     it "should fail when a required action option is not provided" do
       face = Puppet::Interface.new(:required_action_option, '0.0.1') do
         action(:bar) do
           option('--foo') { required }
           when_invoked { }
         end
       end
       expect { face.bar }.to raise_error ArgumentError, /missing required options \(foo\)/
     end
 
     it "should fail when a required face option is not provided" do
       face = Puppet::Interface.new(:required_face_option, '0.0.1') do
         option('--foo') { required }
         action(:bar) { when_invoked { } }
       end
       expect { face.bar }.to raise_error ArgumentError, /missing required options \(foo\)/
     end
   end
 
   context "with action decorators" do
     context "local only" do
       let :face do
         Puppet::Interface.new(:action_decorators, '0.0.1') do
           action :bar do when_invoked do true end end
           def report(arg) end
         end
       end
 
       it "should call action before decorators" do
         face.action(:baz) do
           option "--baz" do
             before_action do |action, args, options|
               report(:action_option)
             end
           end
           when_invoked do true end
         end
 
         face.expects(:report).with(:action_option)
         face.baz :baz => true
       end
 
       it "should call action after decorators" do
         face.action(:baz) do
           option "--baz" do
             after_action do |action, args, options|
               report(:action_option)
             end
           end
           when_invoked do true end
         end
 
         face.expects(:report).with(:action_option)
         face.baz :baz => true
       end
 
       it "should call local before decorators" do
         face.option "--foo FOO" do
           before_action do |action, args, options|
             report(:before)
           end
         end
         face.expects(:report).with(:before)
         face.bar({:foo => 12})
       end
 
       it "should call local after decorators" do
         face.option "--foo FOO" do
           after_action do |action, args, options| report(:after) end
         end
         face.expects(:report).with(:after)
         face.bar({:foo => 12})
       end
 
       context "with inactive decorators" do
         it "should not invoke a decorator if the options are empty" do
           face.option "--foo FOO" do
             before_action do |action, args, options|
               report :before_action
             end
           end
           face.expects(:report).never # I am testing the negative.
           face.bar
         end
 
         context "with some decorators only" do
           before :each do
             face.option "--foo" do
               before_action do |action, args, options| report :foo end
             end
             face.option "--bar" do
               before_action do |action, args, options| report :bar end
             end
           end
 
           it "should work with the foo option" do
             face.expects(:report).with(:foo)
             face.bar(:foo => true)
           end
 
           it "should work with the bar option" do
             face.expects(:report).with(:bar)
             face.bar(:bar => true)
           end
 
           it "should work with both options" do
             face.expects(:report).with(:foo)
             face.expects(:report).with(:bar)
             face.bar(:foo => true, :bar => true)
           end
         end
       end
     end
 
     context "with inherited decorators" do
       let :parent do
         parent = Class.new(Puppet::Interface)
         parent.script :on_parent do :on_parent end
         parent.define_method :report do |arg| arg end
         parent
       end
 
       let :child do
         child = parent.new(:inherited_decorators, '0.0.1') do
           script :on_child do :on_child end
         end
       end
 
       context "with a child decorator" do
         subject do
           child.option "--foo FOO" do
             before_action do |action, args, options|
               report(:child_before)
             end
           end
           child.expects(:report).with(:child_before)
           child
         end
 
         it "child actions should invoke the decorator" do
           subject.on_child({:foo => true, :bar => true}).should == :on_child
         end
 
         it "parent actions should invoke the decorator" do
           subject.on_parent({:foo => true, :bar => true}).should == :on_parent
         end
       end
 
       context "with a parent decorator" do
         subject do
           parent.option "--foo FOO" do
             before_action do |action, args, options|
               report(:parent_before)
             end
           end
           child.expects(:report).with(:parent_before)
           child
         end
 
         it "child actions should invoke the decorator" do
           subject.on_child({:foo => true, :bar => true}).should == :on_child
         end
 
         it "parent actions should invoke the decorator" do
           subject.on_parent({:foo => true, :bar => true}).should == :on_parent
         end
       end
 
       context "with child and parent decorators" do
         subject do
           parent.option "--foo FOO" do
             before_action { |action, args, options| report(:parent_before) }
             after_action  { |action, args, options| report(:parent_after)  }
           end
           child.option "--bar BAR" do
             before_action { |action, args, options| report(:child_before) }
             after_action  { |action, args, options| report(:child_after)  }
           end
 
           child.expects(:report).with(:child_before)
           child.expects(:report).with(:parent_before)
           child.expects(:report).with(:parent_after)
           child.expects(:report).with(:child_after)
 
           child
         end
 
         it "child actions should invoke all the decorator" do
           subject.on_child({:foo => true, :bar => true}).should == :on_child
         end
 
         it "parent actions should invoke all the decorator" do
           subject.on_parent({:foo => true, :bar => true}).should == :on_parent
         end
       end
     end
   end
 
   it_should_behave_like "documentation on faces" do
     subject do
       face = Puppet::Interface.new(:action_documentation, '0.0.1') do
         action :documentation do end
       end
       face.get_action(:documentation)
     end
   end
 
   context "#when_rendering" do
     it "should fail if no type is given when_rendering"
     it "should accept a when_rendering block"
     it "should accept multiple when_rendering blocks"
     it "should fail if when_rendering gets a non-symbol identifier"
     it "should fail if a second block is given for the same type"
     it "should return the block if asked"
   end
 end
diff --git a/spec/unit/provider/nameservice/directoryservice_spec.rb b/spec/unit/provider/nameservice/directoryservice_spec.rb
index 47f2ad0cd..7a83d7f20 100755
--- a/spec/unit/provider/nameservice/directoryservice_spec.rb
+++ b/spec/unit/provider/nameservice/directoryservice_spec.rb
@@ -1,37 +1,97 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 # We use this as a reasonable way to obtain all the support infrastructure.
 [:user, :group].each do |type_for_this_round|
   provider_class = Puppet::Type.type(type_for_this_round).provider(:directoryservice)
 
   describe provider_class do
     before do
       @resource = stub("resource")
       @provider = provider_class.new(@resource)
     end
 
     it "[#6009] should handle nested arrays of members" do
       current = ["foo", "bar", "baz"]
       desired = ["foo", ["quux"], "qorp"]
       group   = 'example'
 
       @resource.stubs(:[]).with(:name).returns(group)
       @resource.stubs(:[]).with(:auth_membership).returns(true)
       @provider.instance_variable_set(:@property_value_cache_hash,
                                       { :members => current })
 
       %w{bar baz}.each do |del|
         @provider.expects(:execute).once.
           with([:dseditgroup, '-o', 'edit', '-n', '.', '-d', del, group])
       end
 
       %w{quux qorp}.each do |add|
         @provider.expects(:execute).once.
           with([:dseditgroup, '-o', 'edit', '-n', '.', '-a', add, group])
       end
 
       expect { @provider.set(:members, desired) }.should_not raise_error
     end
   end
 end
+
+describe 'DirectoryService.single_report' do
+  it 'should fail on OS X < 10.4' do
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_macosx_version_major).returns("10.3")
+
+    lambda {
+      Puppet::Provider::NameService::DirectoryService.single_report('resource_name')
+    }.should raise_error(RuntimeError, "Puppet does not support OS X versions < 10.4")
+  end
+
+  it 'should use url data on 10.4' do
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_macosx_version_major).returns("10.4")
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_ds_path).returns('Users')
+    Puppet::Provider::NameService::DirectoryService.stubs(:list_all_present).returns(
+      ['root', 'user1', 'user2', 'resource_name']
+    )
+    Puppet::Provider::NameService::DirectoryService.stubs(:generate_attribute_hash)
+    Puppet::Provider::NameService::DirectoryService.stubs(:execute)
+    Puppet::Provider::NameService::DirectoryService.expects(:parse_dscl_url_data)
+
+    Puppet::Provider::NameService::DirectoryService.single_report('resource_name')
+  end
+
+  it 'should use plist data on > 10.4' do
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_macosx_version_major).returns("10.5")
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_ds_path).returns('Users')
+    Puppet::Provider::NameService::DirectoryService.stubs(:list_all_present).returns(
+      ['root', 'user1', 'user2', 'resource_name']
+    )
+    Puppet::Provider::NameService::DirectoryService.stubs(:generate_attribute_hash)
+    Puppet::Provider::NameService::DirectoryService.stubs(:execute)
+    Puppet::Provider::NameService::DirectoryService.expects(:parse_dscl_plist_data)
+
+    Puppet::Provider::NameService::DirectoryService.single_report('resource_name')
+  end
+end
+
+describe 'DirectoryService.get_exec_preamble' do
+  it 'should fail on OS X < 10.4' do
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_macosx_version_major).returns("10.3")
+
+    lambda {
+      Puppet::Provider::NameService::DirectoryService.get_exec_preamble('-list')
+    }.should raise_error(RuntimeError, "Puppet does not support OS X versions < 10.4")
+  end
+
+  it 'should use url data on 10.4' do
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_macosx_version_major).returns("10.4")
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_ds_path).returns('Users')
+
+    Puppet::Provider::NameService::DirectoryService.get_exec_preamble('-list').should include("-url")
+  end
+
+  it 'should use plist data on > 10.4' do
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_macosx_version_major).returns("10.5")
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_ds_path).returns('Users')
+
+    Puppet::Provider::NameService::DirectoryService.get_exec_preamble('-list').should include("-plist")
+  end
+end
diff --git a/spec/unit/rails/host_spec.rb b/spec/unit/rails/host_spec.rb
index df0b2fa1d..98541c0a8 100755
--- a/spec/unit/rails/host_spec.rb
+++ b/spec/unit/rails/host_spec.rb
@@ -1,160 +1,168 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
+require 'puppet/node/environment'
+
 describe "Puppet::Rails::Host", :if => Puppet.features.rails? do
   def column(name, type)
     ActiveRecord::ConnectionAdapters::Column.new(name, nil, type, false)
   end
 
   before do
     require 'puppet/rails/host'
 
     # Stub this so we don't need access to the DB.
     Puppet::Rails::Host.stubs(:columns).returns([column("name", "string"), column("environment", "string"), column("ip", "string")])
 
     @node = Puppet::Node.new("foo")
     @node.environment = "production"
     @node.ipaddress = "127.0.0.1"
 
     @host = stub 'host', :environment= => nil, :ip= => nil
   end
 
   describe "when converting a Puppet::Node instance into a Rails instance" do
     it "should modify any existing instance in the database" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
 
       Puppet::Rails::Host.from_puppet(@node)
     end
 
     it "should create a new instance in the database if none can be found" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns nil
       Puppet::Rails::Host.expects(:new).with(:name => "foo").returns @host
 
       Puppet::Rails::Host.from_puppet(@node)
     end
 
     it "should copy the environment from the Puppet instance" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
 
       @node.environment = "production"
       @host.expects(:environment=).with {|x| x.name.to_s == 'production' }
 
       Puppet::Rails::Host.from_puppet(@node)
     end
 
+    it "should stringify the environment" do
+      host = Puppet::Rails::Host.new
+      host.environment = Puppet::Node::Environment.new("production")
+      host.environment.class.should == String
+    end
+
     it "should copy the ipaddress from the Puppet instance" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
 
       @node.ipaddress = "192.168.0.1"
       @host.expects(:ip=).with "192.168.0.1"
 
       Puppet::Rails::Host.from_puppet(@node)
     end
 
     it "should not save the Rails instance" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
 
       @host.expects(:save).never
 
       Puppet::Rails::Host.from_puppet(@node)
     end
   end
 
   describe "when converting a Puppet::Rails::Host instance into a Puppet::Node instance" do
     before do
       @host = Puppet::Rails::Host.new(:name => "foo", :environment => "production", :ip => "127.0.0.1")
       @node = Puppet::Node.new("foo")
       Puppet::Node.stubs(:new).with("foo").returns @node
     end
 
     it "should create a new instance with the correct name" do
       Puppet::Node.expects(:new).with("foo").returns @node
 
       @host.to_puppet
     end
 
     it "should copy the environment from the Rails instance" do
       @host.environment = "prod"
       @node.expects(:environment=).with "prod"
       @host.to_puppet
     end
 
     it "should copy the ipaddress from the Rails instance" do
       @host.ip = "192.168.0.1"
       @node.expects(:ipaddress=).with "192.168.0.1"
       @host.to_puppet
     end
   end
 
   describe "when merging catalog resources and database resources" do
     before :each do
       Puppet.settings.stubs(:[]).with(:thin_storeconfigs).returns(false)
       @resource1 = stub_everything 'res1'
       @resource2 = stub_everything 'res2'
       @resources = [ @resource1, @resource2 ]
 
       @dbresource1 = stub_everything 'dbres1'
       @dbresource2 = stub_everything 'dbres2'
       @dbresources = { 1 => @dbresource1, 2 => @dbresource2 }
 
       @host = Puppet::Rails::Host.new(:name => "foo", :environment => "production", :ip => "127.0.0.1")
       @host.stubs(:find_resources).returns(@dbresources)
       @host.stubs(:find_resources_parameters_tags)
       @host.stubs(:compare_to_catalog)
       @host.stubs(:id).returns(1)
     end
 
     it "should find all database resources" do
       @host.expects(:find_resources)
 
       @host.merge_resources(@resources)
     end
 
     it "should find all paramaters and tags for those database resources" do
       @host.expects(:find_resources_parameters_tags).with(@dbresources)
 
       @host.merge_resources(@resources)
     end
 
     it "should compare all database resources to catalog" do
       @host.expects(:compare_to_catalog).with(@dbresources, @resources)
 
       @host.merge_resources(@resources)
     end
 
     it "should compare only exported resources in thin_storeconfigs mode" do
       Puppet.settings.stubs(:[]).with(:thin_storeconfigs).returns(true)
       @resource1.stubs(:exported?).returns(true)
 
       @host.expects(:compare_to_catalog).with(@dbresources, [ @resource1 ])
 
       @host.merge_resources(@resources)
     end
   end
 
   describe "when searching the database for host resources" do
     before :each do
       Puppet.settings.stubs(:[]).with(:thin_storeconfigs).returns(false)
       @resource1 = stub_everything 'res1', :id => 1
       @resource2 = stub_everything 'res2', :id => 2
       @resources = [ @resource1, @resource2 ]
 
       @dbresources = stub 'resources'
       @dbresources.stubs(:find).returns(@resources)
 
       @host = Puppet::Rails::Host.new(:name => "foo", :environment => "production", :ip => "127.0.0.1")
       @host.stubs(:resources).returns(@dbresources)
     end
 
     it "should return a hash keyed by id of all resources" do
       @host.find_resources.should == { 1 => @resource1, 2 => @resource2 }
     end
 
     it "should return a hash keyed by id of only exported resources in thin_storeconfigs mode" do
       Puppet.settings.stubs(:[]).with(:thin_storeconfigs).returns(true)
       @dbresources.expects(:find).with { |*h| h[1][:conditions] == { :exported => true } }.returns([])
 
       @host.find_resources
     end
   end
 end
diff --git a/spec/unit/type/file_spec.rb b/spec/unit/type/file_spec.rb
index 683c3654b..6cd3ab701 100755
--- a/spec/unit/type/file_spec.rb
+++ b/spec/unit/type/file_spec.rb
@@ -1,1184 +1,1241 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe Puppet::Type.type(:file) do
   before do
     Puppet.settings.stubs(:use)
     @real_posix = Puppet.features.posix?
     Puppet.features.stubs("posix?").returns(true)
 
     @path = Tempfile.new("puppetspec")
     pathname = @path.path
     @path.close!()
     @path = pathname
     @file = Puppet::Type::File.new(:name => @path)
 
     @catalog = Puppet::Resource::Catalog.new
     @file.catalog = @catalog
   end
 
   describe "when determining if recursion is enabled" do
     it "should default to recursion being disabled" do
       @file.should_not be_recurse
     end
     [true, "true", 10, "inf", "remote"].each do |value|
       it "should consider #{value} to enable recursion" do
         @file[:recurse] = value
         @file.must be_recurse
       end
     end
 
     [false, "false", 0].each do |value|
       it "should consider #{value} to disable recursion" do
         @file[:recurse] = value
         @file.should_not be_recurse
       end
     end
   end
 
   describe "#write" do
 
     it "should propagate failures encountered when renaming the temporary file" do
       File.stubs(:open)
 
       File.expects(:rename).raises ArgumentError
       file = Puppet::Type::File.new(:name => "/my/file", :backup => "puppet")
 
       file.stubs(:validate_checksum?).returns(false)
 
       property = stub('content_property', :actual_content => "something", :length => "something".length)
       file.stubs(:property).with(:content).returns(property)
 
       lambda { file.write(:content) }.should raise_error(Puppet::Error)
     end
 
     it "should delegate writing to the content property" do
       filehandle = stub_everything 'fh'
       File.stubs(:open).yields(filehandle)
       File.stubs(:rename)
       property = stub('content_property', :actual_content => "something", :length => "something".length)
       file = Puppet::Type::File.new(:name => "/my/file", :backup => "puppet")
       file.stubs(:validate_checksum?).returns(false)
       file.stubs(:property).with(:content).returns(property)
 
       property.expects(:write).with(filehandle)
 
       file.write(:content)
     end
 
     describe "when validating the checksum" do
       before { @file.stubs(:validate_checksum?).returns(true) }
 
       it "should fail if the checksum parameter and content checksums do not match" do
         checksum = stub('checksum_parameter',  :sum => 'checksum_b', :sum_file => 'checksum_b')
         @file.stubs(:parameter).with(:checksum).returns(checksum)
 
         property = stub('content_property', :actual_content => "something", :length => "something".length, :write => 'checksum_a')
         @file.stubs(:property).with(:content).returns(property)
 
         lambda { @file.write :NOTUSED }.should raise_error(Puppet::Error)
       end
     end
 
     describe "when not validating the checksum" do
       before { @file.stubs(:validate_checksum?).returns(false) }
 
       it "should not fail if the checksum property and content checksums do not match" do
         checksum = stub('checksum_parameter',  :sum => 'checksum_b')
         @file.stubs(:parameter).with(:checksum).returns(checksum)
 
         property = stub('content_property', :actual_content => "something", :length => "something".length, :write => 'checksum_a')
         @file.stubs(:property).with(:content).returns(property)
 
         lambda { @file.write :NOTUSED }.should_not raise_error(Puppet::Error)
       end
 
     end
   end
 
   it "should have a method for determining if the file is present" do
     @file.must respond_to(:exist?)
   end
 
   it "should be considered existent if it can be stat'ed" do
     @file.expects(:stat).returns mock('stat')
     @file.must be_exist
   end
 
   it "should be considered nonexistent if it can not be stat'ed" do
     @file.expects(:stat).returns nil
     @file.must_not be_exist
   end
 
   it "should have a method for determining if the file should be a normal file" do
     @file.must respond_to(:should_be_file?)
   end
 
   it "should be a file if :ensure is set to :file" do
     @file[:ensure] = :file
     @file.must be_should_be_file
   end
 
   it "should be a file if :ensure is set to :present and the file exists as a normal file" do
     @file.stubs(:stat).returns(mock('stat', :ftype => "file"))
     @file[:ensure] = :present
     @file.must be_should_be_file
   end
 
   it "should not be a file if :ensure is set to something other than :file" do
     @file[:ensure] = :directory
     @file.must_not be_should_be_file
   end
 
   it "should not be a file if :ensure is set to :present and the file exists but is not a normal file" do
     @file.stubs(:stat).returns(mock('stat', :ftype => "directory"))
     @file[:ensure] = :present
     @file.must_not be_should_be_file
   end
 
   it "should be a file if :ensure is not set and :content is" do
     @file[:content] = "foo"
     @file.must be_should_be_file
   end
 
   it "should be a file if neither :ensure nor :content is set but the file exists as a normal file" do
     @file.stubs(:stat).returns(mock("stat", :ftype => "file"))
     @file.must be_should_be_file
   end
 
   it "should not be a file if neither :ensure nor :content is set but the file exists but not as a normal file" do
     @file.stubs(:stat).returns(mock("stat", :ftype => "directory"))
     @file.must_not be_should_be_file
   end
 
   describe "when using POSIX filenames" do
     describe "on POSIX systems" do
       before do
         Puppet.features.stubs(:posix?).returns(true)
         Puppet.features.stubs(:microsoft_windows?).returns(false)
       end
 
       it "should autorequire its parent directory" do
         file = Puppet::Type::File.new(:path => "/foo/bar")
         dir = Puppet::Type::File.new(:path => "/foo")
         @catalog.add_resource file
         @catalog.add_resource dir
         reqs = file.autorequire
         reqs[0].source.must == dir
         reqs[0].target.must == file
       end
 
+      it "should autorequire its nearest ancestor directory" do
+        file = Puppet::Type::File.new(:path => "/foo/bar/baz")
+        dir = Puppet::Type::File.new(:path => "/foo")
+        root = Puppet::Type::File.new(:path => "/")
+        @catalog.add_resource file
+        @catalog.add_resource dir
+        @catalog.add_resource root
+        reqs = file.autorequire
+        reqs.length.must == 1
+        reqs[0].source.must == dir
+        reqs[0].target.must == file
+      end
+
+      it "should not autorequire anything when there is no nearest ancestor directory" do
+        file = Puppet::Type::File.new(:path => "/foo/bar/baz")
+        @catalog.add_resource file
+        file.autorequire.should be_empty
+      end
+
       it "should not autorequire its parent dir if its parent dir is itself" do
         file = Puppet::Type::File.new(:path => "/")
         @catalog.add_resource file
         file.autorequire.should be_empty
       end
 
       it "should remove trailing slashes" do
         file = Puppet::Type::File.new(:path => "/foo/bar/baz/")
         file[:path].should == "/foo/bar/baz"
       end
 
       it "should remove double slashes" do
         file = Puppet::Type::File.new(:path => "/foo/bar//baz")
         file[:path].should == "/foo/bar/baz"
       end
 
       it "should remove trailing double slashes" do
         file = Puppet::Type::File.new(:path => "/foo/bar/baz//")
         file[:path].should == "/foo/bar/baz"
       end
 
       it "should leave a single slash alone" do
         file = Puppet::Type::File.new(:path => "/")
         file[:path].should == "/"
       end
 
       it "should accept a double-slash at the start of the path" do
         expect {
           file = Puppet::Type::File.new(:path => "//tmp/xxx")
           # REVISIT: This should be wrong, later.  See the next test.
           # --daniel 2011-01-31
           file[:path].should == '/tmp/xxx'
         }.should_not raise_error
       end
 
       # REVISIT: This is pending, because I don't want to try and audit the
       # entire codebase to make sure we get this right.  POSIX treats two (and
       # exactly two) '/' characters at the start of the path specially.
       #
       # See sections 3.2 and 4.11, which allow DomainOS to be all special like
       # and still have the POSIX branding and all. --daniel 2011-01-31
       it "should preserve the double-slash at the start of the path"
     end
 
     describe "on Microsoft Windows systems" do
       before do
         Puppet.features.stubs(:posix?).returns(false)
         Puppet.features.stubs(:microsoft_windows?).returns(true)
       end
 
       it "should refuse to work" do
         lambda { Puppet::Type::File.new(:path => "/foo/bar") }.should raise_error(Puppet::Error)
       end
     end
   end
 
   describe "when using Microsoft Windows filenames", :if => Puppet.features.microsoft_windows? do
     describe "on Microsoft Windows systems" do
       before do
         Puppet.features.stubs(:posix?).returns(false)
         Puppet.features.stubs(:microsoft_windows?).returns(true)
       end
 
       it "should autorequire its parent directory" do
         file = Puppet::Type::File.new(:path => "X:/foo/bar")
         dir = Puppet::Type::File.new(:path => "X:/foo")
         @catalog.add_resource file
         @catalog.add_resource dir
         reqs = file.autorequire
         reqs[0].source.must == dir
         reqs[0].target.must == file
       end
 
+      it "should autorequire its nearest ancestor directory" do
+        file = Puppet::Type::File.new(:path => "X:/foo/bar/baz")
+        dir = Puppet::Type::File.new(:path => "X:/foo")
+        root = Puppet::Type::File.new(:path => "X:/")
+        @catalog.add_resource file
+        @catalog.add_resource dir
+        @catalog.add_resource root
+        reqs = file.autorequire
+        reqs.length.must == 1
+        reqs[0].source.must == dir
+        reqs[0].target.must == file
+      end
+
+      it "should not autorequire anything when there is no nearest ancestor directory" do
+        file = Puppet::Type::File.new(:path => "X:/foo/bar/baz")
+        @catalog.add_resource file
+        file.autorequire.should be_empty
+      end
+
       it "should not autorequire its parent dir if its parent dir is itself" do
         file = Puppet::Type::File.new(:path => "X:/")
         @catalog.add_resource file
         file.autorequire.should be_empty
       end
 
       it "should remove trailing slashes" do
         file = Puppet::Type::File.new(:path => "X:/foo/bar/baz/")
         file[:path].should == "X:/foo/bar/baz"
       end
 
       it "should remove double slashes" do
         file = Puppet::Type::File.new(:path => "X:/foo/bar//baz")
         file[:path].should == "X:/foo/bar/baz"
       end
 
       it "should remove trailing double slashes" do
         file = Puppet::Type::File.new(:path => "X:/foo/bar/baz//")
         file[:path].should == "X:/foo/bar/baz"
       end
 
       it "should leave a drive letter with a slash alone" do
         file = Puppet::Type::File.new(:path => "X:/")
         file[:path].should == "X:/"
       end
 
       it "should add a slash to a drive letter" do
         file = Puppet::Type::File.new(:path => "X:")
         file[:path].should == "X:/"
       end
     end
 
     describe "on POSIX systems" do
       before do
         Puppet.features.stubs(:posix?).returns(true)
         Puppet.features.stubs(:microsoft_windows?).returns(false)
       end
 
       it "should refuse to work" do
         lambda { Puppet::Type::File.new(:path => "X:/foo/bar") }.should raise_error(Puppet::Error)
       end
     end
   end
 
   describe "when using UNC filenames" do
     describe "on Microsoft Windows systems", :if => Puppet.features.microsoft_windows? do
       before do
         Puppet.features.stubs(:posix?).returns(false)
         Puppet.features.stubs(:microsoft_windows?).returns(true)
       end
 
       it "should autorequire its parent directory" do
         file = Puppet::Type::File.new(:path => "//server/foo/bar")
         dir = Puppet::Type::File.new(:path => "//server/foo")
         @catalog.add_resource file
         @catalog.add_resource dir
         reqs = file.autorequire
         reqs[0].source.must == dir
         reqs[0].target.must == file
       end
 
+      it "should autorequire its nearest ancestor directory" do
+        file = Puppet::Type::File.new(:path => "//server/foo/bar/baz/qux")
+        dir = Puppet::Type::File.new(:path => "//server/foo/bar")
+        root = Puppet::Type::File.new(:path => "//server/foo")
+        @catalog.add_resource file
+        @catalog.add_resource dir
+        @catalog.add_resource root
+        reqs = file.autorequire
+        reqs.length.must == 1
+        reqs[0].source.must == dir
+        reqs[0].target.must == file
+      end
+
+      it "should not autorequire anything when there is no nearest ancestor directory" do
+        file = Puppet::Type::File.new(:path => "//server/foo/bar/baz/qux")
+        @catalog.add_resource file
+        file.autorequire.should be_empty
+      end
+
       it "should not autorequire its parent dir if its parent dir is itself" do
         file = Puppet::Type::File.new(:path => "//server/foo")
         @catalog.add_resource file
         puts file.autorequire
         file.autorequire.should be_empty
       end
 
       it "should remove trailing slashes" do
         file = Puppet::Type::File.new(:path => "//server/foo/bar/baz/")
         file[:path].should == "//server/foo/bar/baz"
       end
 
       it "should remove double slashes" do
         file = Puppet::Type::File.new(:path => "//server/foo/bar//baz")
         file[:path].should == "//server/foo/bar/baz"
       end
 
       it "should remove trailing double slashes" do
         file = Puppet::Type::File.new(:path => "//server/foo/bar/baz//")
         file[:path].should == "//server/foo/bar/baz"
       end
 
       it "should remove a trailing slash from a sharename" do
         file = Puppet::Type::File.new(:path => "//server/foo/")
         file[:path].should == "//server/foo"
       end
 
       it "should not modify a sharename" do
         file = Puppet::Type::File.new(:path => "//server/foo")
         file[:path].should == "//server/foo"
       end
     end
 
     describe "on POSIX systems" do
       before do
         Puppet.features.stubs(:posix?).returns(true)
         Puppet.features.stubs(:microsoft_windows?).returns(false)
       end
 
       it "should refuse to work" do
         lambda { Puppet::Type::File.new(:path => "X:/foo/bar") }.should raise_error(Puppet::Error)
       end
     end
   end
 
   describe "when initializing" do
     it "should set a desired 'ensure' value if none is set and 'content' is set" do
       file = Puppet::Type::File.new(:name => "/my/file", :content => "/foo/bar")
       file[:ensure].should == :file
     end
 
     it "should set a desired 'ensure' value if none is set and 'target' is set" do
       file = Puppet::Type::File.new(:name => "/my/file", :target => "/foo/bar")
       file[:ensure].should == :symlink
     end
   end
 
   describe "when validating attributes" do
     %w{path checksum backup recurse recurselimit source replace force ignore links purge sourceselect}.each do |attr|
       it "should have a '#{attr}' parameter" do
         Puppet::Type.type(:file).attrtype(attr.intern).should == :param
       end
     end
 
     %w{content target ensure owner group mode type}.each do |attr|
       it "should have a '#{attr}' property" do
         Puppet::Type.type(:file).attrtype(attr.intern).should == :property
       end
     end
 
     it "should have its 'path' attribute set as its namevar" do
       Puppet::Type.type(:file).key_attributes.should == [:path]
     end
   end
 
   describe "when managing links" do
     require 'tempfile'
 
     if @real_posix
       describe "on POSIX systems" do
         before do
           @basedir = tempfile
           Dir.mkdir(@basedir)
           @file = File.join(@basedir, "file")
           @link = File.join(@basedir, "link")
 
           File.open(@file, "w", 0644) { |f| f.puts "yayness"; f.flush }
           File.symlink(@file, @link)
 
           @resource = Puppet::Type.type(:file).new(:path => @link, :mode => "755")
           @catalog.add_resource @resource
         end
 
         after do
           remove_tmp_files
         end
 
         it "should default to managing the link" do
           @catalog.apply
           # I convert them to strings so they display correctly if there's an error.
           ("%o" % (File.stat(@file).mode & 007777)).should == "%o" % 0644
         end
 
         it "should be able to follow links" do
           @resource[:links] = :follow
           @catalog.apply
 
           ("%o" % (File.stat(@file).mode & 007777)).should == "%o" % 0755
         end
       end
     else # @real_posix
       # should recode tests using expectations instead of using the filesystem
     end
 
     describe "on Microsoft Windows systems" do
       before do
         Puppet.features.stubs(:posix?).returns(false)
         Puppet.features.stubs(:microsoft_windows?).returns(true)
       end
 
       it "should refuse to work with links"
     end
   end
 
   it "should be able to retrieve a stat instance for the file it is managing" do
     Puppet::Type.type(:file).new(:path => "/foo/bar", :source => "/bar/foo").should respond_to(:stat)
   end
 
   describe "when stat'ing its file" do
     before do
       @resource = Puppet::Type.type(:file).new(:path => "/foo/bar")
       @resource[:links] = :manage # so we always use :lstat
     end
 
     it "should use :stat if it is following links" do
       @resource[:links] = :follow
       File.expects(:stat)
 
       @resource.stat
     end
 
     it "should use :lstat if is it not following links" do
       @resource[:links] = :manage
       File.expects(:lstat)
 
       @resource.stat
     end
 
     it "should stat the path of the file" do
       File.expects(:lstat).with("/foo/bar")
 
       @resource.stat
     end
 
     # This only happens in testing.
     it "should return nil if the stat does not exist" do
       File.expects(:lstat).returns nil
 
       @resource.stat.should be_nil
     end
 
     it "should return nil if the file does not exist" do
       File.expects(:lstat).raises(Errno::ENOENT)
 
       @resource.stat.should be_nil
     end
 
     it "should return nil if the file cannot be stat'ed" do
       File.expects(:lstat).raises(Errno::EACCES)
 
       @resource.stat.should be_nil
     end
 
     it "should return the stat instance" do
       File.expects(:lstat).returns "mystat"
 
       @resource.stat.should == "mystat"
     end
 
     it "should cache the stat instance if it has a catalog and is applying" do
       stat = mock 'stat'
       File.expects(:lstat).returns stat
 
       catalog = Puppet::Resource::Catalog.new
       @resource.catalog = catalog
 
       catalog.stubs(:applying?).returns true
 
       @resource.stat.should equal(@resource.stat)
     end
   end
 
   describe "when flushing" do
     it "should flush all properties that respond to :flush" do
       @resource = Puppet::Type.type(:file).new(:path => "/foo/bar", :source => "/bar/foo")
       @resource.parameter(:source).expects(:flush)
       @resource.flush
     end
 
     it "should reset its stat reference" do
       @resource = Puppet::Type.type(:file).new(:path => "/foo/bar")
       File.expects(:lstat).times(2).returns("stat1").then.returns("stat2")
       @resource.stat.should == "stat1"
       @resource.flush
       @resource.stat.should == "stat2"
     end
   end
 
   it "should have a method for performing recursion" do
     @file.must respond_to(:perform_recursion)
   end
 
   describe "when executing a recursive search" do
     it "should use Metadata to do its recursion" do
       Puppet::FileServing::Metadata.indirection.expects(:search)
       @file.perform_recursion(@file[:path])
     end
 
     it "should use the provided path as the key to the search" do
       Puppet::FileServing::Metadata.indirection.expects(:search).with { |key, options| key == "/foo" }
       @file.perform_recursion("/foo")
     end
 
     it "should return the results of the metadata search" do
       Puppet::FileServing::Metadata.indirection.expects(:search).returns "foobar"
       @file.perform_recursion(@file[:path]).should == "foobar"
     end
 
     it "should pass its recursion value to the search" do
       @file[:recurse] = true
       Puppet::FileServing::Metadata.indirection.expects(:search).with { |key, options| options[:recurse] == true }
       @file.perform_recursion(@file[:path])
     end
 
     it "should pass true if recursion is remote" do
       @file[:recurse] = :remote
       Puppet::FileServing::Metadata.indirection.expects(:search).with { |key, options| options[:recurse] == true }
       @file.perform_recursion(@file[:path])
     end
 
     it "should pass its recursion limit value to the search" do
       @file[:recurselimit] = 10
       Puppet::FileServing::Metadata.indirection.expects(:search).with { |key, options| options[:recurselimit] == 10 }
       @file.perform_recursion(@file[:path])
     end
 
     it "should configure the search to ignore or manage links" do
       @file[:links] = :manage
       Puppet::FileServing::Metadata.indirection.expects(:search).with { |key, options| options[:links] == :manage }
       @file.perform_recursion(@file[:path])
     end
 
     it "should pass its 'ignore' setting to the search if it has one" do
       @file[:ignore] = %w{.svn CVS}
       Puppet::FileServing::Metadata.indirection.expects(:search).with { |key, options| options[:ignore] == %w{.svn CVS} }
       @file.perform_recursion(@file[:path])
     end
   end
 
   it "should have a method for performing local recursion" do
     @file.must respond_to(:recurse_local)
   end
 
   describe "when doing local recursion" do
     before do
       @metadata = stub 'metadata', :relative_path => "my/file"
     end
 
     it "should pass its path to the :perform_recursion method" do
       @file.expects(:perform_recursion).with(@file[:path]).returns [@metadata]
       @file.stubs(:newchild)
       @file.recurse_local
     end
 
     it "should return an empty hash if the recursion returns nothing" do
       @file.expects(:perform_recursion).returns nil
       @file.recurse_local.should == {}
     end
 
     it "should create a new child resource with each generated metadata instance's relative path" do
       @file.expects(:perform_recursion).returns [@metadata]
       @file.expects(:newchild).with(@metadata.relative_path).returns "fiebar"
       @file.recurse_local
     end
 
     it "should not create a new child resource for the '.' directory" do
       @metadata.stubs(:relative_path).returns "."
 
       @file.expects(:perform_recursion).returns [@metadata]
       @file.expects(:newchild).never
       @file.recurse_local
     end
 
     it "should return a hash of the created resources with the relative paths as the hash keys" do
       @file.expects(:perform_recursion).returns [@metadata]
       @file.expects(:newchild).with("my/file").returns "fiebar"
       @file.recurse_local.should == {"my/file" => "fiebar"}
     end
 
     it "should set checksum_type to none if this file checksum is none" do
       @file[:checksum] = :none
       Puppet::FileServing::Metadata.indirection.expects(:search).with { |path,params| params[:checksum_type] == :none }.returns [@metadata]
       @file.expects(:newchild).with("my/file").returns "fiebar"
       @file.recurse_local
     end
   end
 
   it "should have a method for performing link recursion" do
     @file.must respond_to(:recurse_link)
   end
 
   describe "when doing link recursion" do
     before do
       @first = stub 'first', :relative_path => "first", :full_path => "/my/first", :ftype => "directory"
       @second = stub 'second', :relative_path => "second", :full_path => "/my/second", :ftype => "file"
 
       @resource = stub 'file', :[]= => nil
     end
 
     it "should pass its target to the :perform_recursion method" do
       @file[:target] = "mylinks"
       @file.expects(:perform_recursion).with("mylinks").returns [@first]
       @file.stubs(:newchild).returns @resource
       @file.recurse_link({})
     end
 
     it "should ignore the recursively-found '.' file and configure the top-level file to create a directory" do
       @first.stubs(:relative_path).returns "."
       @file[:target] = "mylinks"
       @file.expects(:perform_recursion).with("mylinks").returns [@first]
       @file.stubs(:newchild).never
       @file.expects(:[]=).with(:ensure, :directory)
       @file.recurse_link({})
     end
 
     it "should create a new child resource for each generated metadata instance's relative path that doesn't already exist in the children hash" do
       @file.expects(:perform_recursion).returns [@first, @second]
       @file.expects(:newchild).with(@first.relative_path).returns @resource
       @file.recurse_link("second" => @resource)
     end
 
     it "should not create a new child resource for paths that already exist in the children hash" do
       @file.expects(:perform_recursion).returns [@first]
       @file.expects(:newchild).never
       @file.recurse_link("first" => @resource)
     end
 
     it "should set the target to the full path of discovered file and set :ensure to :link if the file is not a directory" do
       file = stub 'file'
       file.expects(:[]=).with(:target, "/my/second")
       file.expects(:[]=).with(:ensure, :link)
 
       @file.stubs(:perform_recursion).returns [@first, @second]
       @file.recurse_link("first" => @resource, "second" => file)
     end
 
     it "should :ensure to :directory if the file is a directory" do
       file = stub 'file'
       file.expects(:[]=).with(:ensure, :directory)
 
       @file.stubs(:perform_recursion).returns [@first, @second]
       @file.recurse_link("first" => file, "second" => @resource)
     end
 
     it "should return a hash with both created and existing resources with the relative paths as the hash keys" do
       file = stub 'file', :[]= => nil
 
       @file.expects(:perform_recursion).returns [@first, @second]
       @file.stubs(:newchild).returns file
       @file.recurse_link("second" => @resource).should == {"second" => @resource, "first" => file}
     end
   end
 
   it "should have a method for performing remote recursion" do
     @file.must respond_to(:recurse_remote)
   end
 
   describe "when doing remote recursion" do
     before do
       @file[:source] = "puppet://foo/bar"
 
       @first = Puppet::FileServing::Metadata.new("/my", :relative_path => "first")
       @second = Puppet::FileServing::Metadata.new("/my", :relative_path => "second")
       @first.stubs(:ftype).returns "directory"
       @second.stubs(:ftype).returns "directory"
 
       @parameter = stub 'property', :metadata= => nil
       @resource = stub 'file', :[]= => nil, :parameter => @parameter
     end
 
     it "should pass its source to the :perform_recursion method" do
       data = Puppet::FileServing::Metadata.new("/whatever", :relative_path => "foobar")
       @file.expects(:perform_recursion).with("puppet://foo/bar").returns [data]
       @file.stubs(:newchild).returns @resource
       @file.recurse_remote({})
     end
 
     it "should not recurse when the remote file is not a directory" do
       data = Puppet::FileServing::Metadata.new("/whatever", :relative_path => ".")
       data.stubs(:ftype).returns "file"
       @file.expects(:perform_recursion).with("puppet://foo/bar").returns [data]
       @file.expects(:newchild).never
       @file.recurse_remote({})
     end
 
     it "should set the source of each returned file to the searched-for URI plus the found relative path" do
       @first.expects(:source=).with File.join("puppet://foo/bar", @first.relative_path)
       @file.expects(:perform_recursion).returns [@first]
       @file.stubs(:newchild).returns @resource
       @file.recurse_remote({})
     end
 
     it "should create a new resource for any relative file paths that do not already have a resource" do
       @file.stubs(:perform_recursion).returns [@first]
       @file.expects(:newchild).with("first").returns @resource
       @file.recurse_remote({}).should == {"first" => @resource}
     end
 
     it "should not create a new resource for any relative file paths that do already have a resource" do
       @file.stubs(:perform_recursion).returns [@first]
       @file.expects(:newchild).never
       @file.recurse_remote("first" => @resource)
     end
 
     it "should set the source of each resource to the source of the metadata" do
       @file.stubs(:perform_recursion).returns [@first]
       @resource.stubs(:[]=)
       @resource.expects(:[]=).with(:source, File.join("puppet://foo/bar", @first.relative_path))
       @file.recurse_remote("first" => @resource)
     end
 
     # LAK:FIXME This is a bug, but I can't think of a fix for it.  Fortunately it's already
     # filed, and when it's fixed, we'll just fix the whole flow.
     it "should set the checksum type to :md5 if the remote file is a file" do
       @first.stubs(:ftype).returns "file"
       @file.stubs(:perform_recursion).returns [@first]
       @resource.stubs(:[]=)
       @resource.expects(:[]=).with(:checksum, :md5)
       @file.recurse_remote("first" => @resource)
     end
 
     it "should store the metadata in the source property for each resource so the source does not have to requery the metadata" do
       @file.stubs(:perform_recursion).returns [@first]
       @resource.expects(:parameter).with(:source).returns @parameter
 
       @parameter.expects(:metadata=).with(@first)
 
       @file.recurse_remote("first" => @resource)
     end
 
     it "should not create a new resource for the '.' file" do
       @first.stubs(:relative_path).returns "."
       @file.stubs(:perform_recursion).returns [@first]
 
       @file.expects(:newchild).never
 
       @file.recurse_remote({})
     end
 
     it "should store the metadata in the main file's source property if the relative path is '.'" do
       @first.stubs(:relative_path).returns "."
       @file.stubs(:perform_recursion).returns [@first]
 
       @file.parameter(:source).expects(:metadata=).with @first
 
       @file.recurse_remote("first" => @resource)
     end
 
     describe "and multiple sources are provided" do
       describe "and :sourceselect is set to :first" do
         it "should create file instances for the results for the first source to return any values" do
           data = Puppet::FileServing::Metadata.new("/whatever", :relative_path => "foobar")
           @file[:source] = %w{/one /two /three /four}
           @file.expects(:perform_recursion).with("/one").returns nil
           @file.expects(:perform_recursion).with("/two").returns []
           @file.expects(:perform_recursion).with("/three").returns [data]
           @file.expects(:perform_recursion).with("/four").never
           @file.expects(:newchild).with("foobar").returns @resource
           @file.recurse_remote({})
         end
       end
 
       describe "and :sourceselect is set to :all" do
         before do
           @file[:sourceselect] = :all
         end
 
         it "should return every found file that is not in a previous source" do
           klass = Puppet::FileServing::Metadata
           @file[:source] = %w{/one /two /three /four}
           @file.stubs(:newchild).returns @resource
 
           one = [klass.new("/one", :relative_path => "a")]
           @file.expects(:perform_recursion).with("/one").returns one
           @file.expects(:newchild).with("a").returns @resource
 
           two = [klass.new("/two", :relative_path => "a"), klass.new("/two", :relative_path => "b")]
           @file.expects(:perform_recursion).with("/two").returns two
           @file.expects(:newchild).with("b").returns @resource
 
           three = [klass.new("/three", :relative_path => "a"), klass.new("/three", :relative_path => "c")]
           @file.expects(:perform_recursion).with("/three").returns three
           @file.expects(:newchild).with("c").returns @resource
 
           @file.expects(:perform_recursion).with("/four").returns []
 
           @file.recurse_remote({})
         end
       end
     end
   end
 
   describe "when specifying both source, and content properties" do
     before do
       @file[:source]  = '/one'
       @file[:content] = 'file contents'
     end
 
     it "should raise an exception" do
       lambda {@file.validate }.should raise_error(/You cannot specify more than one of/)
     end
   end
 
   describe "when using source" do
     before do
       @file[:source]   = '/one'
     end
     Puppet::Type::File::ParameterChecksum.value_collection.values.reject {|v| v == :none}.each do |checksum_type|
       describe "with checksum '#{checksum_type}'" do
         before do
           @file[:checksum] = checksum_type
         end
 
         it 'should validate' do
 
           lambda { @file.validate }.should_not raise_error
         end
       end
     end
 
     describe "with checksum 'none'" do
       before do
         @file[:checksum] = :none
       end
 
       it 'should raise an exception when validating' do
         lambda { @file.validate }.should raise_error(/You cannot specify source when using checksum 'none'/)
       end
     end
   end
 
   describe "when using content" do
     before do
       @file[:content] = 'file contents'
     end
 
     (Puppet::Type::File::ParameterChecksum.value_collection.values - SOURCE_ONLY_CHECKSUMS).each do |checksum_type|
       describe "with checksum '#{checksum_type}'" do
         before do
           @file[:checksum] = checksum_type
         end
 
         it 'should validate' do
           lambda { @file.validate }.should_not raise_error
         end
       end
     end
 
     SOURCE_ONLY_CHECKSUMS.each do |checksum_type|
       describe "with checksum '#{checksum_type}'" do
         it 'should raise an exception when validating' do
           @file[:checksum] = checksum_type
 
           lambda { @file.validate }.should raise_error(/You cannot specify content when using checksum '#{checksum_type}'/)
         end
       end
     end
   end
 
   describe "when returning resources with :eval_generate" do
     before do
       @graph = stub 'graph', :add_edge => nil
       @catalog.stubs(:relationship_graph).returns @graph
 
       @file.catalog = @catalog
       @file[:recurse] = true
     end
 
     it "should recurse if recursion is enabled" do
       resource = stub('resource', :[] => "resource")
       @file.expects(:recurse?).returns true
       @file.expects(:recurse).returns [resource]
       @file.eval_generate.should == [resource]
     end
 
     it "should not recurse if recursion is disabled" do
       @file.expects(:recurse?).returns false
       @file.expects(:recurse).never
       @file.eval_generate.should == []
     end
 
     it "should return each resource found through recursion" do
       foo = stub 'foo', :[] => "/foo"
       bar = stub 'bar', :[] => "/bar"
       bar2 = stub 'bar2', :[] => "/bar"
 
       @file.expects(:recurse).returns [foo, bar]
 
       @file.eval_generate.should == [foo, bar]
     end
   end
 
   describe "when recursing" do
     before do
       @file[:recurse] = true
       @metadata = Puppet::FileServing::Metadata
     end
 
     describe "and a source is set" do
       before { @file[:source] = "/my/source" }
 
       it "should pass the already-discovered resources to recurse_remote" do
         @file.stubs(:recurse_local).returns(:foo => "bar")
         @file.expects(:recurse_remote).with(:foo => "bar").returns []
         @file.recurse
       end
     end
 
     describe "and a target is set" do
       before { @file[:target] = "/link/target" }
 
       it "should use recurse_link" do
         @file.stubs(:recurse_local).returns(:foo => "bar")
         @file.expects(:recurse_link).with(:foo => "bar").returns []
         @file.recurse
       end
     end
 
     it "should use recurse_local if recurse is not remote" do
       @file.expects(:recurse_local).returns({})
       @file.recurse
     end
 
     it "should not use recurse_local if recurse remote" do
       @file[:recurse] = :remote
       @file.expects(:recurse_local).never
       @file.recurse
     end
 
     it "should return the generated resources as an array sorted by file path" do
       one = stub 'one', :[] => "/one"
       two = stub 'two', :[] => "/one/two"
       three = stub 'three', :[] => "/three"
       @file.expects(:recurse_local).returns(:one => one, :two => two, :three => three)
       @file.recurse.should == [one, two, three]
     end
 
     describe "and purging is enabled" do
       before do
         @file[:purge] = true
       end
 
       it "should configure each file to be removed" do
         local = stub 'local'
         local.stubs(:[]).with(:source).returns nil # Thus, a local file
         local.stubs(:[]).with(:path).returns "foo"
         @file.expects(:recurse_local).returns("local" => local)
         local.expects(:[]=).with(:ensure, :absent)
 
         @file.recurse
       end
 
       it "should not remove files that exist in the remote repository" do
         @file["source"] = "/my/file"
         @file.expects(:recurse_local).returns({})
 
         remote = stub 'remote'
         remote.stubs(:[]).with(:source).returns "/whatever" # Thus, a remote file
         remote.stubs(:[]).with(:path).returns "foo"
 
         @file.expects(:recurse_remote).with { |hash| hash["remote"] = remote }
         remote.expects(:[]=).with(:ensure, :absent).never
 
         @file.recurse
       end
     end
 
     describe "and making a new child resource" do
       it "should not copy the parent resource's parent" do
         Puppet::Type.type(:file).expects(:new).with { |options| ! options.include?(:parent) }
         @file.newchild("my/path")
       end
 
       {:recurse => true, :target => "/foo/bar", :ensure => :present, :alias => "yay", :source => "/foo/bar"}.each do |param, value|
         it "should not pass on #{param} to the sub resource" do
           @file = Puppet::Type::File.new(:name => @path, param => value, :catalog => @catalog)
 
           @file.class.expects(:new).with { |params| params[param].nil? }
 
           @file.newchild("sub/file")
         end
       end
 
       it "should copy all of the parent resource's 'should' values that were set at initialization" do
         file = @file.class.new(:path => "/foo/bar", :owner => "root", :group => "wheel")
         @catalog.add_resource(file)
         file.class.expects(:new).with { |options| options[:owner] == "root" and options[:group] == "wheel" }
         file.newchild("my/path")
       end
 
       it "should not copy default values to the new child" do
         @file.class.expects(:new).with { |params| params[:backup].nil? }
         @file.newchild("my/path")
       end
 
       it "should not copy values to the child which were set by the source" do
         @file[:source] = "/foo/bar"
         metadata = stub 'metadata', :owner => "root", :group => "root", :mode => 0755, :ftype => "file", :checksum => "{md5}whatever"
         @file.parameter(:source).stubs(:metadata).returns metadata
 
         @file.parameter(:source).copy_source_values
 
         @file.class.expects(:new).with { |params| params[:group].nil? }
         @file.newchild("my/path")
       end
     end
   end
 
   describe "when setting the backup" do
     it "should default to 'puppet'" do
       Puppet::Type::File.new(:name => "/my/file")[:backup].should == "puppet"
     end
 
     it "should allow setting backup to 'false'" do
       (!Puppet::Type::File.new(:name => "/my/file", :backup => false)[:backup]).should be_true
     end
 
     it "should set the backup to '.puppet-bak' if it is set to true" do
       Puppet::Type::File.new(:name => "/my/file", :backup => true)[:backup].should == ".puppet-bak"
     end
 
     it "should support any other backup extension" do
       Puppet::Type::File.new(:name => "/my/file", :backup => ".bak")[:backup].should == ".bak"
     end
 
     it "should set the filebucket when backup is set to a string matching the name of a filebucket in the catalog" do
       catalog = Puppet::Resource::Catalog.new
       bucket_resource = Puppet::Type.type(:filebucket).new :name => "foo", :path => "/my/file/bucket"
       catalog.add_resource bucket_resource
 
       file = Puppet::Type::File.new(:name => "/my/file")
       catalog.add_resource file
 
       file[:backup] = "foo"
       file.bucket.should == bucket_resource.bucket
     end
 
     it "should find filebuckets added to the catalog after the file resource was created" do
       catalog = Puppet::Resource::Catalog.new
 
       file = Puppet::Type::File.new(:name => "/my/file", :backup => "foo")
       catalog.add_resource file
 
       bucket_resource = Puppet::Type.type(:filebucket).new :name => "foo", :path => "/my/file/bucket"
       catalog.add_resource bucket_resource
 
       file.bucket.should == bucket_resource.bucket
     end
 
     it "should have a nil filebucket if backup is false" do
       catalog = Puppet::Resource::Catalog.new
       bucket_resource = Puppet::Type.type(:filebucket).new :name => "foo", :path => "/my/file/bucket"
       catalog.add_resource bucket_resource
 
       file = Puppet::Type::File.new(:name => "/my/file", :backup => false)
       catalog.add_resource file
 
       file.bucket.should be_nil
     end
 
     it "should have a nil filebucket if backup is set to a string starting with '.'" do
       catalog = Puppet::Resource::Catalog.new
       bucket_resource = Puppet::Type.type(:filebucket).new :name => "foo", :path => "/my/file/bucket"
       catalog.add_resource bucket_resource
 
       file = Puppet::Type::File.new(:name => "/my/file", :backup => ".foo")
       catalog.add_resource file
 
       file.bucket.should be_nil
     end
 
     it "should fail if there's no catalog and backup is not false" do
       file = Puppet::Type::File.new(:name => "/my/file", :backup => "foo")
 
       lambda { file.bucket }.should raise_error(Puppet::Error)
     end
 
     it "should fail if a non-existent catalog is specified" do
       file = Puppet::Type::File.new(:name => "/my/file", :backup => "foo")
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource file
 
       lambda { file.bucket }.should raise_error(Puppet::Error)
     end
 
     it "should be able to use the default filebucket without a catalog" do
       file = Puppet::Type::File.new(:name => "/my/file", :backup => "puppet")
       file.bucket.should be_instance_of(Puppet::FileBucket::Dipper)
     end
 
     it "should look up the filebucket during finish()" do
       file = Puppet::Type::File.new(:name => "/my/file", :backup => ".foo")
       file.expects(:bucket)
       file.finish
     end
   end
 
   describe "when retrieving the current file state" do
     it "should copy the source values if the 'source' parameter is set" do
       file = Puppet::Type::File.new(:name => "/my/file", :source => "/foo/bar")
       file.parameter(:source).expects(:copy_source_values)
       file.retrieve
     end
   end
 
   describe ".title_patterns" do
     before do
       @type_class = Puppet::Type.type(:file)
     end
 
     it "should have a regexp that captures the entire string, except for a terminating slash" do
       patterns = @type_class.title_patterns
       string = "abc/\n\tdef/"
       patterns[0][0] =~ string
       $1.should == "abc/\n\tdef"
     end
   end
 
   describe "when auditing" do
     it "should not fail if creating a new file if group is not set" do
       File.exists?(@path).should == false
       file = Puppet::Type::File.new(:name => @path, :audit => "all", :content => "content")
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource(file)
 
       Puppet::Util::Storage.stubs(:store) # to prevent the catalog from trying to write state.yaml
       transaction = catalog.apply
 
       transaction.report.resource_statuses["File[#{@path}]"].failed.should == false
       File.exists?(@path).should == true
     end
 
     it "should not log errors if creating a new file with ensure present and no content" do
       File.exists?(@path).should == false
       file = Puppet::Type::File.new(:name => @path, :audit => "content", :ensure => "present")
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource(file)
 
       Puppet::Util::Storage.stubs(:store) # to prevent the catalog from trying to write state.yaml
 
       catalog.apply
       @logs.reject {|l| l.level == :notice }.should be_empty
     end
   end
 
   describe "when specifying both source and checksum" do
     it 'should use the specified checksum when source is first' do
       @file[:source] = '/foo'
       @file[:checksum] = :md5lite
 
       @file[:checksum].should be :md5lite
     end
     it 'should use the specified checksum when source is last' do
       @file[:checksum] = :md5lite
       @file[:source] = '/foo'
 
       @file[:checksum].should be :md5lite
     end
   end
 end