diff --git a/lib/puppet/parser/yaml_trimmer.rb b/lib/puppet/parser/yaml_trimmer.rb
index cf7870916..b9e6a260f 100644
--- a/lib/puppet/parser/yaml_trimmer.rb
+++ b/lib/puppet/parser/yaml_trimmer.rb
@@ -1,9 +1,9 @@
 module Puppet::Parser::YamlTrimmer
-  REMOVE = %w{@scope @source}
+  REMOVE = [:@scope, :@source]
 
   def to_yaml_properties
     r = instance_variables - REMOVE
     r -= skip_for_yaml if respond_to?(:skip_for_yaml)
     r
   end
 end
diff --git a/lib/puppet/resource/status.rb b/lib/puppet/resource/status.rb
index dea8c105d..ed2e019a3 100644
--- a/lib/puppet/resource/status.rb
+++ b/lib/puppet/resource/status.rb
@@ -1,79 +1,82 @@
 module Puppet
   class Resource
     class Status
       include Puppet::Util::Tagging
       include Puppet::Util::Logging
 
       attr_accessor :resource, :node, :file, :line, :current_values, :status, :evaluation_time
 
       STATES = [:skipped, :failed, :failed_to_restart, :restarted, :changed, :out_of_sync, :scheduled]
       attr_accessor *STATES
 
       attr_reader :source_description, :default_log_level, :time, :resource
       attr_reader :change_count, :out_of_sync_count, :resource_type, :title
 
-      YAML_ATTRIBUTES = %w{@resource @file @line @evaluation_time @change_count @out_of_sync_count @tags @time @events @out_of_sync @changed @resource_type @title @skipped @failed}
+      YAML_ATTRIBUTES = %w{@resource @file @line @evaluation_time @change_count
+                           @out_of_sync_count @tags @time @events @out_of_sync
+                           @changed @resource_type @title @skipped @failed}.
+        map(&:to_sym)
 
       # Provide a boolean method for each of the states.
       STATES.each do |attr|
         define_method("#{attr}?") do
           !! send(attr)
         end
       end
 
       def <<(event)
         add_event(event)
         self
       end
 
       def add_event(event)
         @events << event
         if event.status == 'failure'
           self.failed = true
         elsif event.status == 'success'
           @change_count += 1
           @changed = true
         end
         if event.status != 'audit'
           @out_of_sync_count += 1
           @out_of_sync = true
         end
       end
 
       def events
         @events
       end
 
       def initialize(resource)
         @source_description = resource.path
         @resource = resource.to_s
         @change_count = 0
         @out_of_sync_count = 0
         @changed = false
         @out_of_sync = false
         @skipped = false
         @failed = false
 
         [:file, :line].each do |attr|
           send(attr.to_s + "=", resource.send(attr))
         end
 
         tag(*resource.tags)
         @time = Time.now
         @events = []
         @resource_type = resource.type.to_s.capitalize
         @title = resource.title
       end
 
       def to_yaml_properties
         (YAML_ATTRIBUTES & instance_variables).sort
       end
 
       private
 
       def log_source
         source_description
       end
     end
   end
 end
diff --git a/lib/puppet/simple_graph.rb b/lib/puppet/simple_graph.rb
index fd38bb2cc..c1a198867 100644
--- a/lib/puppet/simple_graph.rb
+++ b/lib/puppet/simple_graph.rb
@@ -1,550 +1,547 @@
 require 'puppet/external/dot'
 require 'puppet/relationship'
 require 'set'
 
 # A hopefully-faster graph class to replace the use of GRATR.
 class Puppet::SimpleGraph
   #
   # All public methods of this class must maintain (assume ^ ensure) the following invariants, where "=~=" means
   # equiv. up to order:
   #
   #   @in_to.keys =~= @out_to.keys =~= all vertices
   #   @in_to.values.collect { |x| x.values }.flatten =~= @out_from.values.collect { |x| x.values }.flatten =~= all edges
   #   @in_to[v1][v2] =~= @out_from[v2][v1] =~= all edges from v1 to v2
   #   @in_to   [v].keys =~= vertices with edges leading to   v
   #   @out_from[v].keys =~= vertices with edges leading from v
   #   no operation may shed reference loops (for gc)
   #   recursive operation must scale with the depth of the spanning trees, or better (e.g. no recursion over the set
   #       of all vertices, etc.)
   #
   # This class is intended to be used with DAGs.  However, if the
   # graph has a cycle, it will not cause non-termination of any of the
   # algorithms.  
   #
   def initialize
     @in_to = {}
     @out_from = {}
     @upstream_from = {}
     @downstream_from = {}
   end
 
   # Clear our graph.
   def clear
     @in_to.clear
     @out_from.clear
     @upstream_from.clear
     @downstream_from.clear
   end
 
   # Which resources depend upon the given resource.
   def dependencies(resource)
     vertex?(resource) ? upstream_from_vertex(resource).keys : []
   end
 
   def dependents(resource)
     vertex?(resource) ? downstream_from_vertex(resource).keys : []
   end
 
   # Whether our graph is directed.  Always true.  Used to produce dot files.
   def directed?
     true
   end
 
   # Determine all of the leaf nodes below a given vertex.
   def leaves(vertex, direction = :out)
     tree_from_vertex(vertex, direction).keys.find_all { |c| adjacent(c, :direction => direction).empty? }
   end
 
   # Collect all of the edges that the passed events match.  Returns
   # an array of edges.
   def matching_edges(event, base = nil)
     source = base || event.resource
 
     unless vertex?(source)
       Puppet.warning "Got an event from invalid vertex #{source.ref}"
       return []
     end
     # Get all of the edges that this vertex should forward events
     # to, which is the same thing as saying all edges directly below
     # This vertex in the graph.
     @out_from[source].values.flatten.find_all { |edge| edge.match?(event.name) }
   end
 
   # Return a reversed version of this graph.
   def reversal
     result = self.class.new
     vertices.each { |vertex| result.add_vertex(vertex) }
     edges.each do |edge|
       result.add_edge edge.class.new(edge.target, edge.source, edge.label)
     end
     result
   end
 
   # Return the size of the graph.
   def size
     vertices.size
   end
 
   def to_a
     vertices
   end
 
   # This is a simple implementation of Tarjan's algorithm to find strongly
   # connected components in the graph; this is a fairly ugly implementation,
   # because I can't just decorate the vertices themselves.
   #
   # This method has an unhealthy relationship with the find_cycles_in_graph
   # method below, which contains the knowledge of how the state object is
   # maintained.
   def tarjan(root, s)
     # initialize the recursion stack we use to work around the nasty lack of a
     # decent Ruby stack.
     recur = [{ :node => root }]
 
     while not recur.empty? do
       frame = recur.last
       vertex = frame[:node]
 
       case frame[:step]
       when nil then
         s[:index][vertex]   = s[:number]
         s[:lowlink][vertex] = s[:number]
         s[:number]          = s[:number] + 1
 
         s[:stack].push(vertex)
         s[:seen][vertex] = true
 
         frame[:children] = adjacent(vertex)
         frame[:step]     = :children
 
       when :children then
         if frame[:children].length > 0 then
           child = frame[:children].shift
           if ! s[:index][child] then
             # Never seen, need to recurse.
             frame[:step] = :after_recursion
             frame[:child] = child
             recur.push({ :node => child })
           elsif s[:seen][child] then
             s[:lowlink][vertex] = [s[:lowlink][vertex], s[:index][child]].min
           end
         else
           if s[:lowlink][vertex] == s[:index][vertex] then
             this_scc = []
             begin
               top = s[:stack].pop
               s[:seen][top] = false
               this_scc << top
             end until top == vertex
             s[:scc] << this_scc
           end
           recur.pop               # done with this node, finally.
         end
 
       when :after_recursion then
         s[:lowlink][vertex] = [s[:lowlink][vertex], s[:lowlink][frame[:child]]].min
         frame[:step] = :children
 
       else
         fail "#{frame[:step]} is an unknown step"
       end
     end
   end
 
   # Find all cycles in the graph by detecting all the strongly connected
   # components, then eliminating everything with a size of one as
   # uninteresting - which it is, because it can't be a cycle. :)
   #
   # This has an unhealthy relationship with the 'tarjan' method above, which
   # it uses to implement the detection of strongly connected components.
   def find_cycles_in_graph
     state = {
       :number => 0, :index => {}, :lowlink => {}, :scc => [],
       :stack => [], :seen => {}
     }
 
     # we usually have a disconnected graph, must walk all possible roots
     vertices.each do |vertex|
       if ! state[:index][vertex] then
         tarjan vertex, state
       end
     end
 
     # To provide consistent results to the user, given that a hash is never
     # assured to return the same order, and given our graph processing is
     # based on hash tables, we need to sort the cycles internally, as well as
     # the set of cycles.
     #
     # Given we are in a failure state here, any extra cost is more or less
     # irrelevant compared to the cost of a fix - which is on a human
     # time-scale.
     state[:scc].select { |c| c.length > 1 }.map {|x| x.sort }.sort
   end
 
   # Perform a BFS on the sub graph representing the cycle, with a view to
   # generating a sufficient set of paths to report the cycle meaningfully, and
   # ideally usefully, for the end user.
   #
   # BFS is preferred because it will generally report the shortest paths
   # through the graph first, which are more likely to be interesting to the
   # user.  I think; it would be interesting to verify that. --daniel 2011-01-23
   def paths_in_cycle(cycle, max_paths = 1)
     raise ArgumentError, "negative or zero max_paths" if max_paths < 1
 
     # Calculate our filtered outbound vertex lists...
     adj = {}
     cycle.each do |vertex|
       adj[vertex] = adjacent(vertex).select{|s| cycle.member? s}
     end
 
     found = []
 
     # frame struct is vertex, [path]
     stack = [[cycle.first, []]]
     while frame = stack.shift do
       if frame[1].member?(frame[0]) then
         found << frame[1] + [frame[0]]
         break if found.length >= max_paths
       else
         adj[frame[0]].each do |to|
           stack.push [to, frame[1] + [frame[0]]]
         end
       end
     end
 
     return found.sort
   end
 
   def report_cycles_in_graph
     cycles = find_cycles_in_graph
     n = cycles.length           # where is "pluralize"? --daniel 2011-01-22
     return if n == 0
     s = n == 1 ? '' : 's'
 
     message = "Found #{n} dependency cycle#{s}:\n"
     cycles.each do |cycle|
       paths = paths_in_cycle(cycle)
       message += paths.map{ |path| '(' + path.join(" => ") + ')'}.join("\n") + "\n"
     end
 
     if Puppet[:graph] then
       filename = write_cycles_to_graph(cycles)
       message += "Cycle graph written to #{filename}."
     else
       message += "Try the '--graph' option and opening the "
       message += "resulting '.dot' file in OmniGraffle or GraphViz"
     end
 
     raise Puppet::Error, message
   end
 
   def write_cycles_to_graph(cycles)
     # This does not use the DOT graph library, just writes the content
     # directly.  Given the complexity of this, there didn't seem much point
     # using a heavy library to generate exactly the same content. --daniel 2011-01-27
     Puppet.settings.use(:graphing)
 
     graph = ["digraph Resource_Cycles {"]
     graph << '  label = "Resource Cycles"'
 
     cycles.each do |cycle|
       paths_in_cycle(cycle, 10).each do |path|
         graph << path.map { |v| '"' + v.to_s.gsub(/"/, '\\"') + '"' }.join(" -> ")
       end
     end
 
     graph << '}'
 
     filename = File.join(Puppet[:graphdir], "cycles.dot")
     File.open(filename, "w") { |f| f.puts graph }
     return filename
   end
 
   # Add a new vertex to the graph.
   def add_vertex(vertex)
     @in_to[vertex]    ||= {}
     @out_from[vertex] ||= {}
   end
 
   # Remove a vertex from the graph.
   def remove_vertex!(v)
     return unless vertex?(v)
     @upstream_from.clear
     @downstream_from.clear
     (@in_to[v].values+@out_from[v].values).flatten.each { |e| remove_edge!(e) }
     @in_to.delete(v)
     @out_from.delete(v)
   end
 
   # Test whether a given vertex is in the graph.
   def vertex?(v)
     @in_to.include?(v)
   end
 
   # Return a list of all vertices.
   def vertices
     @in_to.keys
   end
 
   # Add a new edge.  The graph user has to create the edge instance,
   # since they have to specify what kind of edge it is.
   def add_edge(e,*a)
     return add_relationship(e,*a) unless a.empty?
     @upstream_from.clear
     @downstream_from.clear
     add_vertex(e.source)
     add_vertex(e.target)
     @in_to[   e.target][e.source] ||= []; @in_to[   e.target][e.source] |= [e]
     @out_from[e.source][e.target] ||= []; @out_from[e.source][e.target] |= [e]
   end
 
   def add_relationship(source, target, label = nil)
     add_edge Puppet::Relationship.new(source, target, label)
   end
 
   # Find all matching edges.
   def edges_between(source, target)
     (@out_from[source] || {})[target] || []
   end
 
   # Is there an edge between the two vertices?
   def edge?(source, target)
     vertex?(source) and vertex?(target) and @out_from[source][target]
   end
 
   def edges
     @in_to.values.collect { |x| x.values }.flatten
   end
 
   def each_edge
     @in_to.each { |t,ns| ns.each { |s,es| es.each { |e| yield e }}}
   end
 
   # Remove an edge from our graph.
   def remove_edge!(e)
     if edge?(e.source,e.target)
       @upstream_from.clear
       @downstream_from.clear
       @in_to   [e.target].delete e.source if (@in_to   [e.target][e.source] -= [e]).empty?
       @out_from[e.source].delete e.target if (@out_from[e.source][e.target] -= [e]).empty?
     end
   end
 
   # Find adjacent edges.
   def adjacent(v, options = {})
     return [] unless ns = (options[:direction] == :in) ? @in_to[v] : @out_from[v]
     (options[:type] == :edges) ? ns.values.flatten : ns.keys
   end
 
   # Just walk the tree and pass each edge.
   def walk(source, direction)
     # Use an iterative, breadth-first traversal of the graph. One could do
     # this recursively, but Ruby's slow function calls and even slower
     # recursion make the shorter, recursive algorithm cost-prohibitive.
     stack = [source]
     seen = Set.new
     until stack.empty?
       node = stack.shift
       next if seen.member? node
       connected = adjacent(node, :direction => direction)
       connected.each do |target|
         yield node, target
       end
       stack.concat(connected)
       seen << node
     end
   end
 
   # A different way of walking a tree, and a much faster way than the
   # one that comes with GRATR.
   def tree_from_vertex(start, direction = :out)
     predecessor={}
     walk(start, direction) do |parent, child|
       predecessor[child] = parent
     end
     predecessor
   end
 
   def downstream_from_vertex(v)
     return @downstream_from[v] if @downstream_from[v]
     result = @downstream_from[v] = {}
     @out_from[v].keys.each do |node|
       result[node] = 1
       result.update(downstream_from_vertex(node))
     end
     result
   end
 
   def direct_dependents_of(v)
     (@out_from[v] || {}).keys 
   end
 
   def upstream_from_vertex(v)
     return @upstream_from[v] if @upstream_from[v]
     result = @upstream_from[v] = {}
     @in_to[v].keys.each do |node|
       result[node] = 1
       result.update(upstream_from_vertex(node))
     end
     result
   end
 
   def direct_dependencies_of(v)
     (@in_to[v] || {}).keys 
   end
 
   # Return an array of the edge-sets between a series of n+1 vertices (f=v0,v1,v2...t=vn)
   #   connecting the two given verticies.  The ith edge set is an array containing all the
   #   edges between v(i) and v(i+1); these are (by definition) never empty.
   #
   #     * if f == t, the list is empty
   #     * if they are adjacent the result is an array consisting of
   #       a single array (the edges from f to t)
   #     * and so on by induction on a vertex m between them
   #     * if there is no path from f to t, the result is nil
   #
   # This implementation is not particularly efficient; it's used in testing where clarity
   #   is more important than last-mile efficiency. 
   #
   def path_between(f,t)
     if f==t
       []
     elsif direct_dependents_of(f).include?(t)
       [edges_between(f,t)]
     elsif dependents(f).include?(t)
       m = (dependents(f) & direct_dependencies_of(t)).first
       path_between(f,m) + path_between(m,t)
     else
       nil
     end
   end
 
   # LAK:FIXME This is just a paste of the GRATR code with slight modifications.
 
   # Return a DOT::DOTDigraph for directed graphs or a DOT::DOTSubgraph for an
   # undirected Graph.  _params_ can contain any graph property specified in
   # rdot.rb. If an edge or vertex label is a kind of Hash then the keys
   # which match +dot+ properties will be used as well.
   def to_dot_graph (params = {})
     params['name'] ||= self.class.name.gsub(/:/,'_')
     fontsize   = params['fontsize'] ? params['fontsize'] : '8'
     graph      = (directed? ? DOT::DOTDigraph : DOT::DOTSubgraph).new(params)
     edge_klass = directed? ? DOT::DOTDirectedEdge : DOT::DOTEdge
     vertices.each do |v|
       name = v.to_s
       params = {'name'     => '"'+name+'"',
         'fontsize' => fontsize,
         'label'    => name}
       v_label = v.to_s
       params.merge!(v_label) if v_label and v_label.kind_of? Hash
       graph << DOT::DOTNode.new(params)
     end
     edges.each do |e|
       params = {'from'     => '"'+ e.source.to_s + '"',
         'to'       => '"'+ e.target.to_s + '"',
         'fontsize' => fontsize }
       e_label = e.to_s
       params.merge!(e_label) if e_label and e_label.kind_of? Hash
       graph << edge_klass.new(params)
     end
     graph
   end
 
   # Output the dot format as a string
   def to_dot (params={}) to_dot_graph(params).to_s; end
 
   # Call +dotty+ for the graph which is written to the file 'graph.dot'
   # in the # current directory.
   def dotty (params = {}, dotfile = 'graph.dot')
     File.open(dotfile, 'w') {|f| f << to_dot(params) }
     system('dotty', dotfile)
   end
 
   # Produce the graph files if requested.
   def write_graph(name)
     return unless Puppet[:graph]
 
     Puppet.settings.use(:graphing)
 
     file = File.join(Puppet[:graphdir], "#{name}.dot")
     File.open(file, "w") { |f|
       f.puts to_dot("name" => name.to_s.capitalize)
     }
   end
 
   # This flag may be set to true to use the new YAML serialzation
   # format (where @vertices is a simple list of vertices rather than a
   # list of VertexWrapper objects).  Deserialization supports both
   # formats regardless of the setting of this flag.
   class << self
     attr_accessor :use_new_yaml_format
   end
   self.use_new_yaml_format = false
 
   # Stub class to allow graphs to be represented in YAML using the old
   # (version 2.6) format.
   class VertexWrapper
     attr_reader :vertex, :adjacencies
     def initialize(vertex, adjacencies)
       @vertex = vertex
       @adjacencies = adjacencies
     end
 
     def inspect
       { :@adjacencies => @adjacencies, :@vertex => @vertex.to_s }.inspect
     end
   end
 
   # instance_variable_get is used by Object.to_zaml to get instance
   # variables.  Override it so that we can simulate the presence of
   # instance variables @edges and @vertices for serialization.
   def instance_variable_get(v)
     case v.to_s
     when '@edges' then
       edges
     when '@vertices' then
       if self.class.use_new_yaml_format
         vertices
       else
         result = {}
         vertices.each do |vertex|
           adjacencies = {}
           [:in, :out].each do |direction|
             adjacencies[direction] = {}
             adjacent(vertex, :direction => direction, :type => :edges).each do |edge|
               other_vertex = direction == :in ? edge.source : edge.target
               (adjacencies[direction][other_vertex] ||= Set.new).add(edge)
             end
           end
           result[vertex] = Puppet::SimpleGraph::VertexWrapper.new(vertex, adjacencies)
         end
         result
       end
     else
       super(v)
     end
   end
 
   def to_yaml_properties
-    other_vars = instance_variables.
-      map {|v| v.to_s}.
-      reject { |v| %w{@in_to @out_from @upstream_from @downstream_from}.include?(v) }
-
-    (other_vars + %w{@vertices @edges}).sort.uniq
+    (instance_variables + [:@vertices, :@edges] -
+     [:@in_to, :@out_from, :@upstream_from, :@downstream_from]).sort.uniq
   end
 
   def yaml_initialize(tag, var)
     initialize()
     vertices = var.delete('vertices')
     edges = var.delete('edges')
     if vertices.is_a?(Hash)
       # Support old (2.6) format
       vertices = vertices.keys
     end
     vertices.each { |v| add_vertex(v) }
     edges.each { |e| add_edge(e) }
     var.each do |varname, value|
       instance_variable_set("@#{varname}", value)
     end
   end
 end
diff --git a/lib/puppet/transaction/event.rb b/lib/puppet/transaction/event.rb
index 3e1c289c3..5e4a8eb50 100644
--- a/lib/puppet/transaction/event.rb
+++ b/lib/puppet/transaction/event.rb
@@ -1,73 +1,73 @@
 require 'puppet/transaction'
 require 'puppet/util/tagging'
 require 'puppet/util/logging'
 
 # A simple struct for storing what happens on the system.
 class Puppet::Transaction::Event
   include Puppet::Util::Tagging
   include Puppet::Util::Logging
 
   ATTRIBUTES = [:name, :resource, :property, :previous_value, :desired_value, :historical_value, :status, :message, :file, :line, :source_description, :audited]
-  YAML_ATTRIBUTES = %w{@audited @property @previous_value @desired_value @historical_value @message @name @status @time}
+  YAML_ATTRIBUTES = %w{@audited @property @previous_value @desired_value @historical_value @message @name @status @time}.map(&:to_sym)
   attr_accessor *ATTRIBUTES
   attr_writer :tags
   attr_accessor :time
   attr_reader :default_log_level
 
   EVENT_STATUSES = %w{noop success failure audit}
 
   def initialize(options = {})
     @audited = false
     options.each { |attr, value| send(attr.to_s + "=", value) }
 
     @time = Time.now
   end
 
   def property=(prop)
     @property = prop.to_s
   end
 
   def resource=(res)
     begin
       # In Ruby 1.8 looking up a symbol on a string gives nil; in 1.9 it will
       # raise a TypeError, which we then catch.  This should work on both
       # versions, for all that it is a bit naff. --daniel 2012-03-11
       if res.respond_to?(:[]) and level = res[:loglevel]
         @default_log_level = level
       end
     rescue TypeError => e
       raise unless e.to_s == "can't convert Symbol into Integer"
     end
     @resource = res.to_s
   end
 
   def send_log
     super(log_level, message)
   end
 
   def status=(value)
     raise ArgumentError, "Event status can only be #{EVENT_STATUSES.join(', ')}" unless EVENT_STATUSES.include?(value)
     @status = value
   end
 
   def to_s
     message
   end
 
   def to_yaml_properties
-    (YAML_ATTRIBUTES.map {|ya| ya.to_s} & instance_variables.map{|iv| iv.to_s}).sort
+    (YAML_ATTRIBUTES & instance_variables).sort
   end
 
   private
 
   # If it's a failure, use 'err', else use either the resource's log level (if available)
   # or 'notice'.
   def log_level
     status == "failure" ? :err : (@default_log_level || :notice)
   end
 
   # Used by the Logging module
   def log_source
     source_description || property || resource
   end
 end
diff --git a/lib/puppet/transaction/report.rb b/lib/puppet/transaction/report.rb
index b7a0341b1..7c9ffe811 100644
--- a/lib/puppet/transaction/report.rb
+++ b/lib/puppet/transaction/report.rb
@@ -1,200 +1,200 @@
 require 'puppet'
 require 'puppet/indirector'
 
 # A class for reporting what happens on each client.  Reports consist of
 # two types of data:  Logs and Metrics.  Logs are the output that each
 # change produces, and Metrics are all of the numerical data involved
 # in the transaction.
 class Puppet::Transaction::Report
   extend Puppet::Indirector
 
   indirects :report, :terminus_class => :processor
 
   attr_accessor :configuration_version, :host, :environment
   attr_reader :resource_statuses, :logs, :metrics, :time, :kind, :status
 
   # This is necessary since Marshall doesn't know how to
   # dump hash with default proc (see below @records)
   def self.default_format
     :yaml
   end
 
   def <<(msg)
     @logs << msg
     self
   end
 
   def add_times(name, value)
     @external_times[name] = value
   end
 
   def add_metric(name, hash)
     metric = Puppet::Util::Metric.new(name)
 
     hash.each do |name, value|
       metric.newvalue(name, value)
     end
 
     @metrics[metric.name] = metric
     metric
   end
 
   def add_resource_status(status)
     @resource_statuses[status.resource] = status
   end
 
   def compute_status(resource_metrics, change_metric)
     if (resource_metrics["failed"] || 0) > 0
       'failed'
     elsif change_metric > 0
       'changed'
     else
       'unchanged'
     end
   end
 
   def prune_internal_data
     resource_statuses.delete_if {|name,res| res.resource_type == 'Whit'}
   end
 
   def finalize_report
     prune_internal_data
 
     resource_metrics = add_metric(:resources, calculate_resource_metrics)
     add_metric(:time, calculate_time_metrics)
     change_metric = calculate_change_metric
     add_metric(:changes, {"total" => change_metric})
     add_metric(:events, calculate_event_metrics)
     @status = compute_status(resource_metrics, change_metric)
   end
 
   def initialize(kind, configuration_version=nil, environment=nil)
     @metrics = {}
     @logs = []
     @resource_statuses = {}
     @external_times ||= {}
     @host = Puppet[:node_name_value]
     @time = Time.now
     @kind = kind
     @report_format = 2
     @puppet_version = Puppet.version
     @configuration_version = configuration_version
     @environment = environment
     @status = 'failed' # assume failed until the report is finalized
   end
 
   def name
     host
   end
 
   # Provide a human readable textual summary of this report.
   def summary
     report = raw_summary
 
     ret = ""
     report.keys.sort { |a,b| a.to_s <=> b.to_s }.each do |key|
       ret += "#{Puppet::Util::Metric.labelize(key)}:\n"
 
       report[key].keys.sort { |a,b|
         # sort by label
         if a == :total
           1
         elsif b == :total
           -1
         else
           report[key][a].to_s <=> report[key][b].to_s
         end
       }.each do |label|
         value = report[key][label]
         next if value == 0
         value = "%0.2f" % value if value.is_a?(Float)
         ret += "   %15s %s\n" % [Puppet::Util::Metric.labelize(label) + ":", value]
       end
     end
     ret
   end
 
   # Provide a raw hash summary of this report.
   def raw_summary
     report = { "version" => { "config" => configuration_version, "puppet" => Puppet.version  } }
 
     @metrics.each do |name, metric|
       key = metric.name.to_s
       report[key] = {}
       metric.values.each do |name, label, value|
         report[key][name.to_s] = value
       end
       report[key]["total"] = 0 unless key == "time" or report[key].include?("total")
     end
     (report["time"] ||= {})["last_run"] = Time.now.tv_sec
     report
   end
 
   # Based on the contents of this report's metrics, compute a single number
   # that represents the report. The resulting number is a bitmask where
   # individual bits represent the presence of different metrics.
   def exit_status
     status = 0
     status |= 2 if @metrics["changes"]["total"] > 0
     status |= 4 if @metrics["resources"]["failed"] > 0
     status
   end
 
   def to_yaml_properties
-    (instance_variables - ["@external_times"]).sort
+    (instance_variables - [:@external_times]).sort
   end
 
   private
 
   def calculate_change_metric
     resource_statuses.map { |name, status| status.change_count || 0 }.inject(0) { |a,b| a+b }
   end
 
   def calculate_event_metrics
     metrics = Hash.new(0)
     %w{total failure success}.each { |m| metrics[m] = 0 }
     resource_statuses.each do |name, status|
       metrics["total"] += status.events.length
       status.events.each do |event|
         metrics[event.status] += 1
       end
     end
 
     metrics
   end
 
   def calculate_resource_metrics
     metrics = {}
     metrics["total"] = resource_statuses.length
 
     # force every resource key in the report to be present
     # even if no resources is in this given state
     Puppet::Resource::Status::STATES.each do |state|
       metrics[state.to_s] = 0
     end
 
     resource_statuses.each do |name, status|
       Puppet::Resource::Status::STATES.each do |state|
         metrics[state.to_s] += 1 if status.send(state)
       end
     end
 
     metrics
   end
 
   def calculate_time_metrics
     metrics = Hash.new(0)
     resource_statuses.each do |name, status|
       type = Puppet::Resource.new(name).type
       metrics[type.to_s.downcase] += status.evaluation_time if status.evaluation_time
     end
 
     @external_times.each do |name, value|
       metrics[name.to_s.downcase] = value
     end
 
     metrics["total"] = metrics.values.inject(0) { |a,b| a+b }
 
     metrics
   end
 end
diff --git a/lib/puppet/util/log.rb b/lib/puppet/util/log.rb
index c67d0e93f..41839b106 100644
--- a/lib/puppet/util/log.rb
+++ b/lib/puppet/util/log.rb
@@ -1,273 +1,274 @@
 require 'puppet/util/tagging'
 require 'puppet/util/classgen'
 
 # Pass feedback to the user.  Log levels are modeled after syslog's, and it is
 # expected that that will be the most common log destination.  Supports
 # multiple destinations, one of which is a remote server.
 class Puppet::Util::Log
   include Puppet::Util
   extend Puppet::Util::ClassGen
   include Puppet::Util::Tagging
 
   @levels = [:debug,:info,:notice,:warning,:err,:alert,:emerg,:crit]
   @loglevel = 2
 
   @desttypes = {}
 
   # Create a new destination type.
   def self.newdesttype(name, options = {}, &block)
 
     dest = genclass(
       name,
       :parent     => Puppet::Util::Log::Destination,
       :prefix     => "Dest",
       :block      => block,
       :hash       => @desttypes,
       :attributes => options
     )
     dest.match(dest.name)
 
     dest
   end
 
   require 'puppet/util/log/destination'
   require 'puppet/util/log/destinations'
 
   @destinations = {}
 
   @queued = []
 
   class << self
     include Puppet::Util
     include Puppet::Util::ClassGen
 
     attr_reader :desttypes
   end
 
   # Reset log to basics.  Basically just flushes and closes files and
   # undefs other objects.
   def Log.close(destination)
     if @destinations.include?(destination)
       @destinations[destination].flush if @destinations[destination].respond_to?(:flush)
       @destinations[destination].close if @destinations[destination].respond_to?(:close)
       @destinations.delete(destination)
     end
   end
 
   def self.close_all
     destinations.keys.each { |dest|
       close(dest)
     }
     raise Puppet::DevError.new("Log.close_all failed to close #{@destinations.keys.inspect}") if !@destinations.empty?
   end
 
   # Flush any log destinations that support such operations.
   def Log.flush
     @destinations.each { |type, dest|
       dest.flush if dest.respond_to?(:flush)
     }
   end
 
   def Log.autoflush=(v)
     @destinations.each do |type, dest|
       dest.autoflush = v if dest.respond_to?(:autoflush=)
     end
   end
 
   # Create a new log message.  The primary role of this method is to
   # avoid creating log messages below the loglevel.
   def Log.create(hash)
     raise Puppet::DevError, "Logs require a level" unless hash.include?(:level)
     raise Puppet::DevError, "Invalid log level #{hash[:level]}" unless @levels.index(hash[:level])
     @levels.index(hash[:level]) >= @loglevel ? Puppet::Util::Log.new(hash) : nil
   end
 
   def Log.destinations
     @destinations
   end
 
   # Yield each valid level in turn
   def Log.eachlevel
     @levels.each { |level| yield level }
   end
 
   # Return the current log level.
   def Log.level
     @levels[@loglevel]
   end
 
   # Set the current log level.
   def Log.level=(level)
     level = level.intern unless level.is_a?(Symbol)
 
     raise Puppet::DevError, "Invalid loglevel #{level}" unless @levels.include?(level)
 
     @loglevel = @levels.index(level)
   end
 
   def Log.levels
     @levels.dup
   end
 
   # Create a new log destination.
   def Log.newdestination(dest)
     # Each destination can only occur once.
     if @destinations.find { |name, obj| obj.name == dest }
       return
     end
 
     name, type = @desttypes.find do |name, klass|
       klass.match?(dest)
     end
 
     if type.respond_to?(:suitable?) and not type.suitable?(dest)
       return
     end
 
     raise Puppet::DevError, "Unknown destination type #{dest}" unless type
 
     begin
       if type.instance_method(:initialize).arity == 1
         @destinations[dest] = type.new(dest)
       else
         @destinations[dest] = type.new
       end
       flushqueue
       @destinations[dest]
     rescue => detail
       Puppet.log_exception(detail)
 
       # If this was our only destination, then add the console back in.
       newdestination(:console) if @destinations.empty? and (dest != :console and dest != "console")
     end
   end
 
   # Route the actual message. FIXME There are lots of things this method
   # should do, like caching and a bit more.  It's worth noting that there's
   # a potential for a loop here, if the machine somehow gets the destination set as
   # itself.
   def Log.newmessage(msg)
     return if @levels.index(msg.level) < @loglevel
 
     queuemessage(msg) if @destinations.length == 0
 
     @destinations.each do |name, dest|
       threadlock(dest) do
         dest.handle(msg)
       end
     end
   end
 
   def Log.queuemessage(msg)
     @queued.push(msg)
   end
 
   def Log.flushqueue
     return unless @destinations.size >= 1
     @queued.each do |msg|
       Log.newmessage(msg)
     end
     @queued.clear
   end
 
   def Log.sendlevel?(level)
     @levels.index(level) >= @loglevel
   end
 
   # Reopen all of our logs.
   def Log.reopen
     Puppet.notice "Reopening log files"
     types = @destinations.keys
     @destinations.each { |type, dest|
       dest.close if dest.respond_to?(:close)
     }
     @destinations.clear
     # We need to make sure we always end up with some kind of destination
     begin
       types.each { |type|
         Log.newdestination(type)
       }
     rescue => detail
       if @destinations.empty?
         Log.setup_default
         Puppet.err detail.to_s
       end
     end
   end
 
   def self.setup_default
     Log.newdestination(Puppet.features.syslog? ? :syslog : Puppet[:puppetdlog])
   end
 
   # Is the passed level a valid log level?
   def self.validlevel?(level)
     @levels.include?(level)
   end
 
   attr_accessor :time, :remote, :file, :line, :source
   attr_reader :level, :message
 
   def initialize(args)
     self.level = args[:level]
     self.message = args[:message]
     self.source = args[:source] || "Puppet"
 
     @time = Time.now
 
     if tags = args[:tags]
       tags.each { |t| self.tag(t) }
     end
 
     [:file, :line].each do |attr|
       next unless value = args[attr]
       send(attr.to_s + "=", value)
     end
 
     Log.newmessage(self)
   end
 
   def message=(msg)
     raise ArgumentError, "Puppet::Util::Log requires a message" unless msg
     @message = msg.to_s
   end
 
   def level=(level)
     raise ArgumentError, "Puppet::Util::Log requires a log level" unless level
+    raise ArgumentError, "Puppet::Util::Log requires a symbol or string" unless level.respond_to? "to_sym"
     @level = level.to_sym
     raise ArgumentError, "Invalid log level #{@level}" unless self.class.validlevel?(@level)
 
     # Tag myself with my log level
     tag(level)
   end
 
   # If they pass a source in to us, we make sure it is a string, and
   # we retrieve any tags we can.
   def source=(source)
     if source.respond_to?(:source_descriptors)
       descriptors = source.source_descriptors
       @source = descriptors[:path]
 
       descriptors[:tags].each { |t| tag(t) }
 
       [:file, :line].each do |param|
         next unless descriptors[param]
         send(param.to_s + "=", descriptors[param])
       end
     else
       @source = source.to_s
     end
   end
 
   def to_report
     "#{time} #{source} (#{level}): #{to_s}"
   end
 
   def to_s
     message
   end
 end
 
 # This is for backward compatibility from when we changed the constant to Puppet::Util::Log
 # because the reports include the constant name.  Apparently the alias was created in
 # March 2007, should could probably be removed soon.
 Puppet::Log = Puppet::Util::Log
diff --git a/lib/puppet/util/monkey_patches.rb b/lib/puppet/util/monkey_patches.rb
index 6c1012d5c..8e8aecd55 100644
--- a/lib/puppet/util/monkey_patches.rb
+++ b/lib/puppet/util/monkey_patches.rb
@@ -1,155 +1,208 @@
 
 unless defined? JRUBY_VERSION
   Process.maxgroups = 1024
 end
 
 module RDoc
   def self.caller(skip=nil)
     in_gem_wrapper = false
     Kernel.caller.reject { |call|
       in_gem_wrapper ||= call =~ /#{Regexp.escape $0}:\d+:in `load'/
     }
   end
 end
 
 
 require "yaml"
 require "puppet/util/zaml.rb"
 
 class Symbol
   def to_zaml(z)
     z.emit("!ruby/sym ")
     to_s.to_zaml(z)
   end
   def <=> (other)
     self.to_s <=> other.to_s
   end
 end
 
 [Object, Exception, Integer, Struct, Date, Time, Range, Regexp, Hash, Array, Float, String, FalseClass, TrueClass, Symbol, NilClass, Class].each { |cls|
   cls.class_eval do
     def to_yaml(ignored=nil)
       ZAML.dump(self)
     end
   end
 }
 
 def YAML.dump(*args)
   ZAML.dump(*args)
 end
 
 #
 # Workaround for bug in MRI 1.8.7, see
 #     http://redmine.ruby-lang.org/issues/show/2708
 # for details
 #
 if RUBY_VERSION == '1.8.7'
   class NilClass
     def closed?
       true
     end
   end
 end
 
 class Object
   # ActiveSupport 2.3.x mixes in a dangerous method
   # that can cause rspec to fork bomb
   # and other strange things like that.
   def daemonize
     raise NotImplementedError, "Kernel.daemonize is too dangerous, please don't try to use it."
   end
 end
 
 # Workaround for yaml_initialize, which isn't supported before Ruby
 # 1.8.3.
 if RUBY_VERSION == '1.8.1' || RUBY_VERSION == '1.8.2'
   YAML.add_ruby_type( /^object/ ) { |tag, val|
     type, obj_class = YAML.read_type_class( tag, Object )
     r = YAML.object_maker( obj_class, val )
     if r.respond_to? :yaml_initialize
       r.instance_eval { instance_variables.each { |name| remove_instance_variable name } }
       r.yaml_initialize(tag, val)
     end
     r
   }
 end
 
 class Array
   # Ruby < 1.8.7 doesn't have this method but we use it in tests
   def combination(num)
     return [] if num < 0 || num > size
     return [[]] if num == 0
     return map{|e| [e] } if num == 1
     tmp = self.dup
     self[0, size - (num - 1)].inject([]) do |ret, e|
       tmp.shift
       ret += tmp.combination(num - 1).map{|a| a.unshift(e) }
     end
   end unless method_defined? :combination
 
   alias :count :length unless method_defined? :count
 end
 
 
 class Symbol
   def to_proc
     Proc.new { |*args| args.shift.__send__(self, *args) }
   end unless method_defined? :to_proc
 end
 
 
 class String
   def lines(separator = $/)
     lines = split(separator)
     block_given? and lines.each {|line| yield line }
     lines
   end
 end
 
 class IO
   def lines(separator = $/)
     lines = split(separator)
     block_given? and lines.each {|line| yield line }
     lines
   end
 
   def self.binread(name, length = nil, offset = 0)
     File.open(name, 'rb') do |f|
       f.seek(offset) if offset > 0
       f.read(length)
     end
   end unless singleton_methods.include?(:binread)
 
   def self.binwrite(name, string, offset = 0)
     File.open(name, 'wb') do |f|
       f.write(offset > 0 ? string[offset..-1] : string)
     end
   end unless singleton_methods.include?(:binwrite)
 
 end
 
 class Range
   def intersection(other)
     raise ArgumentError, 'value must be a Range' unless other.kind_of?(Range)
     return unless other === self.first || self === other.first
 
     start = [self.first, other.first].max
     if self.exclude_end? && self.last <= other.last
       start ... self.last
     elsif other.exclude_end? && self.last >= other.last
       start ... other.last
     else
       start .. [ self.last, other.last ].min
     end
   end unless method_defined? :intersection
 
   alias_method :&, :intersection unless method_defined? :&
 end
 
 # Ruby 1.8.5 doesn't have tap
 module Kernel
   def tap
     yield(self)
     self
   end unless method_defined?(:tap)
 end
+
+
+########################################################################
+# The return type of `instance_variables` changes between Ruby 1.8 and 1.9
+# releases; it used to return an array of strings in the form "@foo", but
+# now returns an array of symbols in the form :@foo.
+#
+# Nothing else in the stack cares which form you get - you can pass the
+# string or symbol to things like `instance_variable_set` and they will work
+# transparently.
+#
+# Having the same form in all releases of Puppet is a win, though, so we
+# pick a unification and enforce than on all releases.  That way developers
+# who do set math on them (eg: for YAML rendering) don't have to handle the
+# distinction themselves.
+#
+# In the sane tradition, we bring older releases into conformance with newer
+# releases, so we return symbols rather than strings, to be more like the
+# future versions of Ruby are.
+#
+# We also carefully support reloading, by only wrapping when we don't
+# already have the original version of the method aliased away somewhere.
+if RUBY_VERSION[0,3] == '1.8'
+  unless Object.respond_to?(:puppet_original_instance_variables)
+
+    # Add our wrapper to the method.
+    class Object
+      alias :puppet_original_instance_variables :instance_variables
+
+      def instance_variables
+        puppet_original_instance_variables.map(&:to_sym)
+      end
+    end
+
+    # The one place that Ruby 1.8 assumes something about the return format of
+    # the `instance_variables` method is actually kind of odd, because it uses
+    # eval to get at instance variables of another object.
+    #
+    # This takes the original code and applies replaces instance_eval with
+    # instance_variable_get through it.  All other bugs in the original (such
+    # as equality depending on the instance variables having the same order
+    # without any promise from the runtime) are preserved. --daniel 2012-03-11
+    require 'resolv'
+    class Resolv::DNS::Resource
+      def ==(other) # :nodoc:
+        return self.class == other.class &&
+          self.instance_variables == other.instance_variables &&
+          self.instance_variables.collect {|name| self.instance_variable_get name} ==
+          other.instance_variables.collect {|name| other.instance_variable_get name}
+      end
+    end
+  end
+end
diff --git a/lib/puppet/util/zaml.rb b/lib/puppet/util/zaml.rb
index e07a2d7b9..f00227b6f 100644
--- a/lib/puppet/util/zaml.rb
+++ b/lib/puppet/util/zaml.rb
@@ -1,355 +1,355 @@
 # encoding: UTF-8
 #
 # The above encoding line is a magic comment to set the default source encoding
 # of this file for the Ruby interpreter.  It must be on the first or second
 # line of the file if an interpreter is in use.  In Ruby 1.9 and later, the
 # source encoding determines the encoding of String and Regexp objects created
 # from this source file.  This explicit encoding is important becuase otherwise
 # Ruby will pick an encoding based on LANG or LC_CTYPE environment variables.
 # These may be different from site to site so it's important for us to
 # establish a consistent behavior.  For more information on M17n please see:
 # http://links.puppetlabs.com/understanding_m17n
 
 # ZAML -- A partial replacement for YAML, writen with speed and code clarity
 #         in mind.  ZAML fixes one YAML bug (loading Exceptions) and provides
 #         a replacement for YAML.dump unimaginatively called ZAML.dump,
 #         which is faster on all known cases and an order of magnitude faster
 #         with complex structures.
 #
 # http://github.com/hallettj/zaml
 #
 # Authors: Markus Roberts, Jesse Hallett, Ian McIntosh, Igal Koshevoy, Simon Chiang
 #
 
 require 'yaml'
 
 class ZAML
   VERSION = "0.1.1"
   #
   # Class Methods
   #
   def self.dump(stuff, where='')
     z = new
     stuff.to_zaml(z)
     where << z.to_s
   end
   #
   # Instance Methods
   #
   def initialize
     @result = []
     @indent = nil
     @structured_key_prefix = nil
     @previously_emitted_object = {}
     @next_free_label_number = 0
     emit('--- ')
   end
   def nested(tail='  ')
     old_indent = @indent
     @indent = "#{@indent || "\n"}#{tail}"
     yield
     @indent = old_indent
   end
   class Label
     #
     # YAML only wants objects in the datastream once; if the same object
     #    occurs more than once, we need to emit a label ("&idxxx") on the
     #    first occurrence and then emit a back reference (*idxxx") on any
     #    subsequent occurrence(s).
     #
     # To accomplish this we keeps a hash (by object id) of the labels of
     #    the things we serialize as we begin to serialize them.  The labels
     #    initially serialize as an empty string (since most objects are only
     #    going to be be encountered once), but can be changed to a valid
     #    (by assigning it a number) the first time it is subsequently used,
     #    if it ever is.  Note that we need to do the label setup BEFORE we
     #    start to serialize the object so that circular structures (in
     #    which we will encounter a reference to the object as we serialize
     #    it can be handled).
     #
     attr_accessor :this_label_number
     def initialize(obj,indent)
       @indent = indent
       @this_label_number = nil
       @obj = obj # prevent garbage collection so that object id isn't reused
     end
     def to_s
       @this_label_number ? ('&id%03d%s' % [@this_label_number, @indent]) : ''
     end
     def reference
       @reference         ||= '*id%03d' % @this_label_number
     end
   end
   def label_for(obj)
     @previously_emitted_object[obj.object_id]
   end
   def new_label_for(obj)
     label = Label.new(obj,(Hash === obj || Array === obj) ? "#{@indent || "\n"}  " : ' ')
     @previously_emitted_object[obj.object_id] = label
     label
   end
   def first_time_only(obj)
     if label = label_for(obj)
       label.this_label_number ||= (@next_free_label_number += 1)
       emit(label.reference)
     else
       if @structured_key_prefix and not obj.is_a? String
         emit(@structured_key_prefix)
         @structured_key_prefix = nil
       end
       emit(new_label_for(obj))
       yield
     end
   end
   def emit(s)
     @result << s
     @recent_nl = false unless s.kind_of?(Label)
   end
   def nl(s='')
     emit(@indent || "\n") unless @recent_nl
     emit(s)
     @recent_nl = true
   end
   def to_s
     @result.join
   end
   def prefix_structured_keys(x)
     @structured_key_prefix = x
     yield
     nl unless @structured_key_prefix
     @structured_key_prefix = nil
   end
 end
 
 ################################################################
 #
 #   Behavior for custom classes
 #
 ################################################################
 
 class Object
   def to_yaml_properties
     instance_variables.sort        # Default YAML behavior
   end
   def yaml_property_munge(x)
     x
   end
   def zamlized_class_name(root)
     cls = self.class
     "!ruby/#{root.name.downcase}#{cls == root ? '' : ":#{cls.respond_to?(:name) ? cls.name : cls}"}"
   end
   def to_zaml(z)
     z.first_time_only(self) {
       z.emit(zamlized_class_name(Object))
       z.nested {
         instance_variables = to_yaml_properties
         if instance_variables.empty?
           z.emit(" {}")
         else
           instance_variables.each { |v|
             z.nl
-            v[1..-1].to_zaml(z)       # Remove leading '@'
+            v.to_s[1..-1].to_zaml(z)       # Remove leading '@'
             z.emit(': ')
             yaml_property_munge(instance_variable_get(v)).to_zaml(z)
           }
         end
       }
     }
   end
 end
 
 ################################################################
 #
 #   Behavior for built-in classes
 #
 ################################################################
 
 class NilClass
   def to_zaml(z)
     z.emit('')        # NOTE: blank turns into nil in YAML.load
   end
 end
 
 class Symbol
   def to_zaml(z)
     z.emit(self.inspect)
   end
 end
 
 class TrueClass
   def to_zaml(z)
     z.emit('true')
   end
 end
 
 class FalseClass
   def to_zaml(z)
     z.emit('false')
   end
 end
 
 class Numeric
   def to_zaml(z)
     z.emit(self)
   end
 end
 
 class Regexp
   def to_zaml(z)
     z.first_time_only(self) { z.emit("#{zamlized_class_name(Regexp)} #{inspect}") }
   end
 end
 
 class Exception
   def to_zaml(z)
     z.emit(zamlized_class_name(Exception))
     z.nested {
       z.nl("message: ")
       message.to_zaml(z)
     }
   end
   #
   # Monkey patch for buggy Exception restore in YAML
   #
   #     This makes it work for now but is not very future-proof; if things
   #     change we'll most likely want to remove this.  To mitigate the risks
   #     as much as possible, we test for the bug before appling the patch.
   #
   if respond_to? :yaml_new and yaml_new(self, :tag, "message" => "blurp").message != "blurp"
     def self.yaml_new( klass, tag, val )
       o = YAML.object_maker( klass, {} ).exception(val.delete( 'message'))
       val.each_pair do |k,v|
         o.instance_variable_set("@#{k}", v)
       end
       o
     end
   end
 end
 
 class String
   ZAML_ESCAPES = %w{\x00 \x01 \x02 \x03 \x04 \x05 \x06 \a \x08 \t \n \v \f \r \x0e \x0f \x10 \x11 \x12 \x13 \x14 \x15 \x16 \x17 \x18 \x19 \x1a \e \x1c \x1d \x1e \x1f }
   def escaped_for_zaml
     # JJM (Note the trailing dots to construct a multi-line method chain.) This
     # code is meant to escape all bytes which are not ASCII-8BIT printable
     # characters.  Multi-byte unicode characters are handled just fine because
     # each byte of the character results in an escaped string emitted to the
     # YAML stream.  When the YAML is de-serialized back into a String the bytes
     # will be reconstructed properly into the unicode character.
     self.to_ascii8bit.gsub( /\x5C/n, "\\\\\\" ).  # Demi-kludge for Maglev/rubinius; the regexp should be /\\/ but parsetree chokes on that.
     gsub( /"/n, "\\\"" ).
     gsub( /([\x00-\x1F])/n ) { |x| ZAML_ESCAPES[ x.unpack("C")[0] ] }.
     gsub( /([\x80-\xFF])/n ) { |x| "\\x#{x.unpack("C")[0].to_s(16)}" }
   end
   def to_zaml(z)
     z.first_time_only(self) {
       num = '[-+]?(0x)?\d+\.?\d*'
       case
         when self == ''
           z.emit('""')
         # when self =~ /[\x00-\x08\x0B\x0C\x0E-\x1F\x80-\xFF]/
         #   z.emit("!binary |\n")
         #   z.emit([self].pack("m*"))
         when (
           (self =~ /\A(true|false|yes|no|on|null|off|#{num}(:#{num})*|!|=|~)$/i) or
           (self =~ /\A\n* /) or
           (self =~ /[\s:]$/) or
           (self =~ /^[>|][-+\d]*\s/i) or
           (self[-1..-1] =~ /\s/) or
           # This regular expression assumes the string is a byte sequence.
           # It does not concern itself with characters so we convert the string
           # to ASCII-8BIT for Ruby 1.9 to match up encodings.
           (self.to_ascii8bit=~ /[\x00-\x08\x0B\x0C\x0E-\x1F\x80-\xFF]/n) or
           (self =~ /[,\[\]\{\}\r\t]|:\s|\s#/) or
           (self =~ /\A([-:?!#&*'"]|<<|%.+:.)/)
           )
           z.emit("\"#{escaped_for_zaml}\"")
         when self =~ /\n/
           if self[-1..-1] == "\n" then z.emit('|+') else z.emit('|-') end
           z.nested { split("\n",-1).each { |line| z.nl; z.emit(line.chomp("\n")) } }
         else
           z.emit(self)
       end
     }
   end
 
   # Return a guranteed ASCII-8BIT encoding for Ruby 1.9 This is a helper
   # method for other methods that perform regular expressions against byte
   # sequences deliberately rather than dealing with characters.
   # The method may or may not return a new instance.
   def to_ascii8bit
     if self.respond_to?(:encoding) and self.encoding.name != "ASCII-8BIT" then
       str = self.dup
       str.force_encoding("ASCII-8BIT")
       return str
     else
       return self
     end
   end
 end
 
 class Hash
   def to_zaml(z)
     z.first_time_only(self) {
       z.nested {
         if empty?
           z.emit('{}')
         else
           each_pair { |k, v|
             z.nl
             z.prefix_structured_keys('? ') { k.to_zaml(z) }
             z.emit(': ')
             v.to_zaml(z)
           }
         end
       }
     }
   end
 end
 
 class Array
   def to_zaml(z)
     z.first_time_only(self) {
       z.nested {
         if empty?
           z.emit('[]')
         else
           each { |v| z.nl('- '); v.to_zaml(z) }
         end
       }
     }
   end
 end
 
 class Time
   def to_zaml(z)
     # 2008-12-06 10:06:51.373758 -07:00
     ms = ("%0.6f" % (usec * 1e-6)).sub(/^\d+\./,'')
     offset = "%+0.2i:%0.2i" % [utc_offset / 3600, (utc_offset / 60) % 60]
     z.emit(self.strftime("%Y-%m-%d %H:%M:%S.#{ms} #{offset}"))
   end
 end
 
 class Date
   def to_zaml(z)
     z.emit(strftime('%Y-%m-%d'))
   end
 end
 
 class Range
   def to_zaml(z)
     z.first_time_only(self) {
       z.emit(zamlized_class_name(Range))
       z.nested {
         z.nl
         z.emit('begin: ')
         z.emit(first)
         z.nl
         z.emit('end: ')
         z.emit(last)
         z.nl
         z.emit('excl: ')
         z.emit(exclude_end?)
       }
     }
   end
 end
diff --git a/spec/unit/application/inspect_spec.rb b/spec/unit/application/inspect_spec.rb
index 58eff023a..13db4123c 100755
--- a/spec/unit/application/inspect_spec.rb
+++ b/spec/unit/application/inspect_spec.rb
@@ -1,284 +1,285 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application/inspect'
 require 'puppet/resource/catalog'
 require 'puppet/indirector/catalog/yaml'
 require 'puppet/indirector/report/rest'
 require 'puppet/indirector/file_bucket_file/rest'
 
 describe Puppet::Application::Inspect do
   include PuppetSpec::Files
 
   before :each do
     @inspect = Puppet::Application[:inspect]
     @inspect.preinit
   end
 
   it "should operate in agent run_mode" do
     @inspect.class.run_mode.name.should == :agent
   end
 
   describe "during setup" do
     it "should print its configuration if asked" do
       Puppet[:configprint] = "all"
 
       Puppet.settings.expects(:print_configs).returns(true)
       expect { @inspect.setup }.to exit_with 0
     end
 
     it "should fail if reporting is turned off" do
       Puppet[:report] = false
       lambda { @inspect.setup }.should raise_error(/report=true/)
     end
   end
 
   describe "when executing" do
     before :each do
       Puppet[:report] = true
       @inspect.options[:logset] = true
       Puppet::Transaction::Report::Rest.any_instance.stubs(:save)
       @inspect.setup
     end
 
     it "should retrieve the local catalog" do
       Puppet::Resource::Catalog::Yaml.any_instance.expects(:find).with {|request| request.key == Puppet[:certname] }.returns(Puppet::Resource::Catalog.new)
 
       @inspect.run_command
     end
 
     it "should save the report to REST" do
       Puppet::Resource::Catalog::Yaml.any_instance.stubs(:find).returns(Puppet::Resource::Catalog.new)
       Puppet::Transaction::Report::Rest.any_instance.expects(:save).with {|request| request.instance.host == Puppet[:certname] }
 
       @inspect.run_command
     end
 
     it "should audit the specified properties" do
       catalog = Puppet::Resource::Catalog.new
       file = Tempfile.new("foo")
       file.binmode
       file.puts("file contents")
       file.close
       resource = Puppet::Resource.new(:file, file.path, :parameters => {:audit => "all"})
       catalog.add_resource(resource)
       Puppet::Resource::Catalog::Yaml.any_instance.stubs(:find).returns(catalog)
 
       events = nil
 
       Puppet::Transaction::Report::Rest.any_instance.expects(:save).with do |request|
         events = request.instance.resource_statuses.values.first.events
       end
 
       @inspect.run_command
 
       properties = events.inject({}) do |property_values, event|
         property_values.merge(event.property => event.previous_value)
       end
       properties["ensure"].should == :file
       properties["content"].should == "{md5}#{Digest::MD5.hexdigest("file contents\n")}"
       properties.has_key?("target").should == false
     end
 
     it "should set audited to true for all events" do
       catalog = Puppet::Resource::Catalog.new
       file = Tempfile.new("foo")
       resource = Puppet::Resource.new(:file, file.path, :parameters => {:audit => "all"})
       catalog.add_resource(resource)
       Puppet::Resource::Catalog::Yaml.any_instance.stubs(:find).returns(catalog)
 
       events = nil
 
       Puppet::Transaction::Report::Rest.any_instance.expects(:save).with do |request|
         events = request.instance.resource_statuses.values.first.events
       end
 
       @inspect.run_command
 
       events.each do |event|
         event.audited.should == true
       end
     end
 
     it "should not report irrelevent attributes if the resource is absent" do
       catalog = Puppet::Resource::Catalog.new
       file = Tempfile.new("foo")
       resource = Puppet::Resource.new(:file, file.path, :parameters => {:audit => "all"})
       file.close
       file.delete
       catalog.add_resource(resource)
       Puppet::Resource::Catalog::Yaml.any_instance.stubs(:find).returns(catalog)
 
       events = nil
 
       Puppet::Transaction::Report::Rest.any_instance.expects(:save).with do |request|
         events = request.instance.resource_statuses.values.first.events
       end
 
       @inspect.run_command
 
       properties = events.inject({}) do |property_values, event|
         property_values.merge(event.property => event.previous_value)
       end
       properties.should == {"ensure" => :absent}
     end
 
     describe "when archiving to a bucket" do
       before :each do
         Puppet[:archive_files] = true
         Puppet[:archive_file_server] = "filebucketserver"
         @catalog = Puppet::Resource::Catalog.new
         Puppet::Resource::Catalog::Yaml.any_instance.stubs(:find).returns(@catalog)
       end
 
       describe "when auditing files" do
         before :each do
           @file = tmpfile("foo")
           @resource = Puppet::Resource.new(:file, @file, :parameters => {:audit => "content"})
           @catalog.add_resource(@resource)
         end
 
         it "should send an existing file to the file bucket" do
           File.open(@file, 'w') { |f| f.write('stuff') }
           Puppet::FileBucketFile::Rest.any_instance.expects(:head).with do |request|
             request.server == Puppet[:archive_file_server]
           end.returns(false)
           Puppet::FileBucketFile::Rest.any_instance.expects(:save).with do |request|
             request.server == Puppet[:archive_file_server] and request.instance.contents == 'stuff'
           end
           @inspect.run_command
         end
 
         it "should not send unreadable files", :unless => Puppet.features.microsoft_windows? do
           File.open(@file, 'w') { |f| f.write('stuff') }
           File.chmod(0, @file)
           Puppet::FileBucketFile::Rest.any_instance.expects(:head).never
           Puppet::FileBucketFile::Rest.any_instance.expects(:save).never
           @inspect.run_command
         end
 
         it "should not try to send non-existent files" do
           Puppet::FileBucketFile::Rest.any_instance.expects(:head).never
           Puppet::FileBucketFile::Rest.any_instance.expects(:save).never
           @inspect.run_command
         end
 
         it "should not try to send files whose content we are not auditing" do
           @resource[:audit] = "group"
           Puppet::FileBucketFile::Rest.any_instance.expects(:head).never
           Puppet::FileBucketFile::Rest.any_instance.expects(:save).never
           @inspect.run_command
         end
 
         it "should continue if bucketing a file fails" do
           File.open(@file, 'w') { |f| f.write('stuff') }
           Puppet::FileBucketFile::Rest.any_instance.stubs(:head).returns false
           Puppet::FileBucketFile::Rest.any_instance.stubs(:save).raises "failure"
           Puppet::Transaction::Report::Rest.any_instance.expects(:save).with do |request|
             @report = request.instance
           end
 
           @inspect.run_command
 
           @report.logs.first.should_not == nil
           @report.logs.first.message.should =~ /Could not back up/
         end
       end
 
       describe "when auditing non-files" do
         before :each do
           Puppet::Type.newtype(:stub_type) do
             newparam(:name) do
               desc "The name var"
               isnamevar
             end
 
             newproperty(:content) do
               desc "content"
               def retrieve
                 :whatever
               end
             end
           end
 
           @resource = Puppet::Resource.new(:stub_type, 'foo', :parameters => {:audit => "all"})
           @catalog.add_resource(@resource)
         end
 
         after :each do
           Puppet::Type.rmtype(:stub_type)
         end
 
         it "should not try to send non-files" do
           Puppet::FileBucketFile::Rest.any_instance.expects(:head).never
           Puppet::FileBucketFile::Rest.any_instance.expects(:save).never
           @inspect.run_command
         end
       end
     end
 
     describe "when there are failures" do
       before :each do
         Puppet::Type.newtype(:stub_type) do
           newparam(:name) do
             desc "The name var"
             isnamevar
           end
 
           newproperty(:content) do
             desc "content"
             def retrieve
               raise "failed"
             end
           end
         end
 
         @catalog = Puppet::Resource::Catalog.new
         Puppet::Resource::Catalog::Yaml.any_instance.stubs(:find).returns(@catalog)
 
         Puppet::Transaction::Report::Rest.any_instance.expects(:save).with do |request|
           @report = request.instance
         end
       end
 
       after :each do
         Puppet::Type.rmtype(:stub_type)
       end
 
       it "should mark the report failed and create failed events for each property" do
         @resource = Puppet::Resource.new(:stub_type, 'foo', :parameters => {:audit => "all"})
         @catalog.add_resource(@resource)
 
         @inspect.run_command
 
         @report.status.should == "failed"
         @report.logs.select{|log| log.message =~ /Could not inspect/}.size.should == 1
         @report.resource_statuses.size.should == 1
         @report.resource_statuses['Stub_type[foo]'].events.size.should == 1
 
         event = @report.resource_statuses['Stub_type[foo]'].events.first
         event.property.should == "content"
         event.status.should == "failure"
         event.audited.should == true
-        event.instance_variables.should_not include("@previous_value")
+        event.instance_variables.should_not include "@previous_value"
+        event.instance_variables.should_not include :@previous_value
       end
 
       it "should continue to the next resource" do
         @resource = Puppet::Resource.new(:stub_type, 'foo', :parameters => {:audit => "all"})
         @other_resource = Puppet::Resource.new(:stub_type, 'bar', :parameters => {:audit => "all"})
         @catalog.add_resource(@resource)
         @catalog.add_resource(@other_resource)
 
         @inspect.run_command
 
         @report.resource_statuses.size.should == 2
         @report.resource_statuses.keys.should =~ ['Stub_type[foo]', 'Stub_type[bar]']
       end
     end
   end
 
   after :all do
     Puppet::Resource::Catalog.indirection.reset_terminus_class
     Puppet::Transaction::Report.indirection.terminus_class = :processor
   end
 end
diff --git a/spec/unit/resource/status_spec.rb b/spec/unit/resource/status_spec.rb
index 18e3359df..922f9edad 100755
--- a/spec/unit/resource/status_spec.rb
+++ b/spec/unit/resource/status_spec.rb
@@ -1,154 +1,154 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/resource/status'
 
 describe Puppet::Resource::Status do
   include PuppetSpec::Files
 
   before do
     @resource = Puppet::Type.type(:file).new :path => make_absolute("/my/file")
     @status = Puppet::Resource::Status.new(@resource)
   end
 
   it "should compute type and title correctly" do
     @status.resource_type.should == "File"
     @status.title.should == make_absolute("/my/file")
   end
 
   [:node, :file, :line, :current_values, :status, :evaluation_time].each do |attr|
     it "should support #{attr}" do
       @status.send(attr.to_s + "=", "foo")
       @status.send(attr).should == "foo"
     end
   end
 
   [:skipped, :failed, :restarted, :failed_to_restart, :changed, :out_of_sync, :scheduled].each do |attr|
     it "should support #{attr}" do
       @status.send(attr.to_s + "=", "foo")
       @status.send(attr).should == "foo"
     end
 
     it "should have a boolean method for determining whehter it was #{attr}" do
       @status.send(attr.to_s + "=", "foo")
       @status.should send("be_#{attr}")
     end
   end
 
   it "should accept a resource at initialization" do
     Puppet::Resource::Status.new(@resource).resource.should_not be_nil
   end
 
   it "should set its source description to the resource's path" do
     @resource.expects(:path).returns "/my/path"
     Puppet::Resource::Status.new(@resource).source_description.should == "/my/path"
   end
 
   [:file, :line].each do |attr|
     it "should copy the resource's #{attr}" do
       @resource.expects(attr).returns "foo"
       Puppet::Resource::Status.new(@resource).send(attr).should == "foo"
     end
   end
 
   it "should copy the resource's tags" do
     @resource.expects(:tags).returns %w{foo bar}
     Puppet::Resource::Status.new(@resource).tags.should == %w{foo bar}
   end
 
   it "should always convert the resource to a string" do
     @resource.expects(:to_s).returns "foo"
     Puppet::Resource::Status.new(@resource).resource.should == "foo"
   end
 
   it "should support tags" do
     Puppet::Resource::Status.ancestors.should include(Puppet::Util::Tagging)
   end
 
   it "should create a timestamp at its creation time" do
     @status.time.should be_instance_of(Time)
   end
 
   describe "when sending logs" do
     before do
       Puppet::Util::Log.stubs(:new)
     end
 
     it "should set the tags to the event tags" do
       Puppet::Util::Log.expects(:new).with { |args| args[:tags] == %w{one two} }
       @status.stubs(:tags).returns %w{one two}
       @status.send_log :notice, "my message"
     end
 
     [:file, :line].each do |attr|
       it "should pass the #{attr}" do
         Puppet::Util::Log.expects(:new).with { |args| args[attr] == "my val" }
         @status.send(attr.to_s + "=", "my val")
         @status.send_log :notice, "my message"
       end
     end
 
     it "should use the source description as the source" do
       Puppet::Util::Log.expects(:new).with { |args| args[:source] == "my source" }
       @status.stubs(:source_description).returns "my source"
       @status.send_log :notice, "my message"
     end
   end
 
   it "should support adding events" do
     event = Puppet::Transaction::Event.new(:name => :foobar)
     @status.add_event(event)
     @status.events.should == [event]
   end
 
   it "should use '<<' to add events" do
     event = Puppet::Transaction::Event.new(:name => :foobar)
     (@status << event).should equal(@status)
     @status.events.should == [event]
   end
 
   it "should count the number of successful events and set changed" do
     3.times{ @status << Puppet::Transaction::Event.new(:status => 'success') }
     @status.change_count.should == 3
 
     @status.changed.should == true
     @status.out_of_sync.should == true
   end
 
   it "should not start with any changes" do
     @status.change_count.should == 0
 
     @status.changed.should == false
     @status.out_of_sync.should == false
   end
 
   it "should not treat failure, audit, or noop events as changed" do
     ['failure', 'audit', 'noop'].each do |s| @status << Puppet::Transaction::Event.new(:status => s) end
     @status.change_count.should == 0
     @status.changed.should == false
   end
 
   it "should not treat audit events as out of sync" do
     @status << Puppet::Transaction::Event.new(:status => 'audit')
     @status.out_of_sync_count.should == 0
     @status.out_of_sync.should == false
   end
 
   ['failure', 'noop', 'success'].each do |event_status|
     it "should treat #{event_status} events as out of sync" do
       3.times do @status << Puppet::Transaction::Event.new(:status => event_status) end
       @status.out_of_sync_count.should == 3
       @status.out_of_sync.should == true
     end
   end
 
   describe "When converting to YAML", :'fails_on_ruby_1.9.2' => true do
     it "should include only documented attributes" do
       @status.file = "/foo.rb"
       @status.line = 27
       @status.evaluation_time = 2.7
       @status.tags = %w{one two}
-      @status.to_yaml_properties.should == Puppet::Resource::Status::YAML_ATTRIBUTES.sort
+      @status.to_yaml_properties.should =~ Puppet::Resource::Status::YAML_ATTRIBUTES
     end
   end
 end
diff --git a/spec/unit/transaction/resource_harness_spec.rb b/spec/unit/transaction/resource_harness_spec.rb
index cadc31a0f..20aac576e 100755
--- a/spec/unit/transaction/resource_harness_spec.rb
+++ b/spec/unit/transaction/resource_harness_spec.rb
@@ -1,484 +1,484 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/transaction/resource_harness'
 
 describe Puppet::Transaction::ResourceHarness do
   include PuppetSpec::Files
 
   before do
     @mode_750 = Puppet.features.microsoft_windows? ? '644' : '750'
     @mode_755 = Puppet.features.microsoft_windows? ? '644' : '755'
     path = make_absolute("/my/file")
 
     @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
     @resource = Puppet::Type.type(:file).new :path => path
     @harness = Puppet::Transaction::ResourceHarness.new(@transaction)
     @current_state = Puppet::Resource.new(:file, path)
     @resource.stubs(:retrieve).returns @current_state
     @status = Puppet::Resource::Status.new(@resource)
     Puppet::Resource::Status.stubs(:new).returns @status
   end
 
   it "should accept a transaction at initialization" do
     harness = Puppet::Transaction::ResourceHarness.new(@transaction)
     harness.transaction.should equal(@transaction)
   end
 
   it "should delegate to the transaction for its relationship graph" do
     @transaction.expects(:relationship_graph).returns "relgraph"
     Puppet::Transaction::ResourceHarness.new(@transaction).relationship_graph.should == "relgraph"
   end
 
   describe "when evaluating a resource" do
     it "should create and return a resource status instance for the resource" do
       @harness.evaluate(@resource).should be_instance_of(Puppet::Resource::Status)
     end
 
     it "should fail if no status can be created" do
       Puppet::Resource::Status.expects(:new).raises ArgumentError
 
       lambda { @harness.evaluate(@resource) }.should raise_error
     end
 
     it "should retrieve the current state of the resource" do
       @resource.expects(:retrieve).returns @current_state
       @harness.evaluate(@resource)
     end
 
     it "should mark the resource as failed and return if the current state cannot be retrieved" do
       @resource.expects(:retrieve).raises ArgumentError
       @harness.evaluate(@resource).should be_failed
     end
 
     it "should store the resource's evaluation time in the resource status" do
       @harness.evaluate(@resource).evaluation_time.should be_instance_of(Float)
     end
   end
 
   def events_to_hash(events)
     events.map do |event|
       hash = {}
       event.instance_variables.each do |varname|
-        hash[varname] = event.instance_variable_get(varname.to_sym)
+        hash[varname] = event.instance_variable_get(varname)
       end
       hash
     end
   end
 
   def make_stub_provider
     stubProvider = Class.new(Puppet::Type)
     stubProvider.instance_eval do
       initvars
 
       newparam(:name) do
         desc "The name var"
         isnamevar
       end
 
       newproperty(:foo) do
         desc "A property that can be changed successfully"
         def sync
         end
 
         def retrieve
           :absent
         end
 
         def insync?(reference_value)
           false
         end
       end
 
       newproperty(:bar) do
         desc "A property that raises an exception when you try to change it"
         def sync
           raise ZeroDivisionError.new('bar')
         end
 
         def retrieve
           :absent
         end
 
         def insync?(reference_value)
           false
         end
       end
     end
     stubProvider
   end
 
   describe "when an error occurs" do
     before :each do
       stub_provider = make_stub_provider
       resource = stub_provider.new :name => 'name', :foo => 1, :bar => 2
       resource.expects(:err).never
       @status = @harness.evaluate(resource)
     end
 
     it "should record previous successful events" do
       @status.events[0].property.should == 'foo'
       @status.events[0].status.should == 'success'
     end
 
     it "should record a failure event" do
       @status.events[1].property.should == 'bar'
       @status.events[1].status.should == 'failure'
     end
   end
 
   describe "when auditing" do
     it "should not call insync? on parameters that are merely audited" do
       stub_provider = make_stub_provider
       resource = stub_provider.new :name => 'name', :audit => ['foo']
       resource.property(:foo).expects(:insync?).never
       status = @harness.evaluate(resource)
       status.events.each do |event|
         event.status.should != 'failure'
       end
     end
 
     it "should be able to audit a file's group" do # see bug #5710
       test_file = tmpfile('foo')
       File.open(test_file, 'w').close
       resource = Puppet::Type.type(:file).new :path => test_file, :audit => ['group'], :backup => false
       resource.expects(:err).never # make sure no exceptions get swallowed
       status = @harness.evaluate(resource)
       status.events.each do |event|
         event.status.should != 'failure'
       end
     end
   end
 
   describe "when applying changes" do
     [false, true].each do |noop_mode|; describe (noop_mode ? "in noop mode" : "in normal mode") do
       [nil, @mode_750].each do |machine_state|; describe (machine_state ? "with a file initially present" : "with no file initially present") do
         [nil, @mode_750, @mode_755].each do |yaml_mode|
           [nil, :file, :absent].each do |yaml_ensure|; describe "with mode=#{yaml_mode.inspect} and ensure=#{yaml_ensure.inspect} stored in state.yml" do
             [false, true].each do |auditing_ensure|
               [false, true].each do |auditing_mode|
                 auditing = []
                 auditing.push(:mode) if auditing_mode
                 auditing.push(:ensure) if auditing_ensure
                 [nil, :file, :absent].each do |ensure_property| # what we set "ensure" to in the manifest
                   [nil, @mode_750, @mode_755].each do |mode_property| # what we set "mode" to in the manifest
                     manifest_settings = {}
                     manifest_settings[:audit] = auditing if !auditing.empty?
                     manifest_settings[:ensure] = ensure_property if ensure_property
                     manifest_settings[:mode] = mode_property if mode_property
                     describe "with manifest settings #{manifest_settings.inspect}" do; it "should behave properly" do
                       # Set up preconditions
                       test_file = tmpfile('foo')
                       if machine_state
                         File.open(test_file, 'w', machine_state.to_i(8)).close
                       end
 
                       Puppet[:noop] = noop_mode
                       params = { :path => test_file, :backup => false }
                       params.merge!(manifest_settings)
                       resource = Puppet::Type.type(:file).new params
 
                       @harness.cache(resource, :mode, yaml_mode) if yaml_mode
                       @harness.cache(resource, :ensure, yaml_ensure) if yaml_ensure
 
                       fake_time = Time.utc(2011, 'jan', 3, 12, 24, 0)
                       Time.stubs(:now).returns(fake_time) # So that Puppet::Resource::Status objects will compare properly
 
                       resource.expects(:err).never # make sure no exceptions get swallowed
                       status = @harness.evaluate(resource) # do the thing
 
                       # check that the state of the machine has been properly updated
                       expected_logs = []
                       expected_status_events = []
                       if auditing_mode
                         @harness.cached(resource, :mode).should == (machine_state || :absent)
                       else
                         @harness.cached(resource, :mode).should == yaml_mode
                       end
                       if auditing_ensure
                         @harness.cached(resource, :ensure).should == (machine_state ? :file : :absent)
                       else
                         @harness.cached(resource, :ensure).should == yaml_ensure
                       end
                       if ensure_property == :file
                         file_would_be_there_if_not_noop = true
                       elsif ensure_property == nil
                         file_would_be_there_if_not_noop = machine_state != nil
                       else # ensure_property == :absent
                         file_would_be_there_if_not_noop = false
                       end
                       file_should_be_there = noop_mode ? machine_state != nil : file_would_be_there_if_not_noop
                       File.exists?(test_file).should == file_should_be_there
                       if file_should_be_there
                         if noop_mode
                           expected_file_mode = machine_state
                         else
                           expected_file_mode = mode_property || machine_state
                         end
                         if !expected_file_mode
                           # we didn't specify a mode and the file was created, so mode comes from umode
                         else
                           file_mode = File.stat(test_file).mode & 0777
                           file_mode.should == expected_file_mode.to_i(8)
                         end
                       end
 
                       # Test log output for the "mode" parameter
                       previously_recorded_mode_already_logged = false
                       mode_status_msg = nil
                       if machine_state && file_would_be_there_if_not_noop && mode_property && machine_state != mode_property
                         if noop_mode
                           what_happened = "current_value #{machine_state}, should be #{mode_property} (noop)"
                           expected_status = 'noop'
                         else
                           what_happened = "mode changed '#{machine_state}' to '#{mode_property}'"
                           expected_status = 'success'
                         end
                         if auditing_mode && yaml_mode && yaml_mode != machine_state
                           previously_recorded_mode_already_logged = true
                           mode_status_msg = "#{what_happened} (previously recorded value was #{yaml_mode})"
                         else
                           mode_status_msg = what_happened
                         end
                         expected_logs << "notice: /#{resource}/mode: #{mode_status_msg}"
                       end
                       if @harness.cached(resource, :mode) && @harness.cached(resource, :mode) != yaml_mode
                         if yaml_mode
                           unless previously_recorded_mode_already_logged
                             mode_status_msg = "audit change: previously recorded value #{yaml_mode} has been changed to #{@harness.cached(resource, :mode)}"
                             expected_logs << "notice: /#{resource}/mode: #{mode_status_msg}"
                             expected_status = 'audit'
                           end
                         else
                           expected_logs << "notice: /#{resource}/mode: audit change: newly-recorded value #{@harness.cached(resource, :mode)}"
                         end
                       end
                       if mode_status_msg
                         expected_status_events << Puppet::Transaction::Event.new(
                             :source_description => "/#{resource}/mode", :resource => resource, :file => nil,
                             :line => nil, :tags => %w{file}, :desired_value => mode_property,
                             :historical_value => yaml_mode, :message => mode_status_msg, :name => :mode_changed,
                             :previous_value => machine_state || :absent, :property => :mode, :status => expected_status,
                             :audited => auditing_mode)
                       end
 
                       # Test log output for the "ensure" parameter
                       previously_recorded_ensure_already_logged = false
                       ensure_status_msg = nil
                       if file_would_be_there_if_not_noop != (machine_state != nil)
                         if noop_mode
                           what_happened = "current_value #{machine_state ? 'file' : 'absent'}, should be #{file_would_be_there_if_not_noop ? 'file' : 'absent'} (noop)"
                           expected_status = 'noop'
                         else
                           what_happened = file_would_be_there_if_not_noop ? 'created' : 'removed'
                           expected_status = 'success'
                         end
                         if auditing_ensure && yaml_ensure && yaml_ensure != (machine_state ? :file : :absent)
                           previously_recorded_ensure_already_logged = true
                           ensure_status_msg = "#{what_happened} (previously recorded value was #{yaml_ensure})"
                         else
                           ensure_status_msg = "#{what_happened}"
                         end
                         expected_logs << "notice: /#{resource}/ensure: #{ensure_status_msg}"
                       end
                       if @harness.cached(resource, :ensure) && @harness.cached(resource, :ensure) != yaml_ensure
                         if yaml_ensure
                           unless previously_recorded_ensure_already_logged
                             ensure_status_msg = "audit change: previously recorded value #{yaml_ensure} has been changed to #{@harness.cached(resource, :ensure)}"
                             expected_logs << "notice: /#{resource}/ensure: #{ensure_status_msg}"
                             expected_status = 'audit'
                           end
                         else
                           expected_logs << "notice: /#{resource}/ensure: audit change: newly-recorded value #{@harness.cached(resource, :ensure)}"
                         end
                       end
                       if ensure_status_msg
                         if ensure_property == :file
                           ensure_event_name = :file_created
                         elsif ensure_property == nil
                           ensure_event_name = :file_changed
                         else # ensure_property == :absent
                           ensure_event_name = :file_removed
                         end
                         expected_status_events << Puppet::Transaction::Event.new(
                             :source_description => "/#{resource}/ensure", :resource => resource, :file => nil,
                             :line => nil, :tags => %w{file}, :desired_value => ensure_property,
                             :historical_value => yaml_ensure, :message => ensure_status_msg, :name => ensure_event_name,
                             :previous_value => machine_state ? :file : :absent, :property => :ensure,
                             :status => expected_status, :audited => auditing_ensure)
                       end
 
                       # Actually check the logs.
                       @logs.map {|l| "#{l.level}: #{l.source}: #{l.message}"}.should =~ expected_logs
 
                       # All the log messages should show up as events except the "newly-recorded" ones.
                       expected_event_logs = @logs.reject {|l| l.message =~ /newly-recorded/ }
                       status.events.map {|e| e.message}.should =~ expected_event_logs.map {|l| l.message }
                       events_to_hash(status.events).should =~ events_to_hash(expected_status_events)
 
                       # Check change count - this is the number of changes that actually occurred.
                       expected_change_count = 0
                       if (machine_state != nil) != file_should_be_there
                         expected_change_count = 1
                       elsif machine_state != nil
                         if expected_file_mode != machine_state
                           expected_change_count = 1
                         end
                       end
                       status.change_count.should == expected_change_count
 
                       # Check out of sync count - this is the number
                       # of changes that would have occurred in
                       # non-noop mode.
                       expected_out_of_sync_count = 0
                       if (machine_state != nil) != file_would_be_there_if_not_noop
                         expected_out_of_sync_count = 1
                       elsif machine_state != nil
                         if mode_property != nil && mode_property != machine_state
                           expected_out_of_sync_count = 1
                         end
                       end
                       if !noop_mode
                         expected_out_of_sync_count.should == expected_change_count
                       end
                       status.out_of_sync_count.should == expected_out_of_sync_count
 
                       # Check legacy summary fields
                       status.changed.should == (expected_change_count != 0)
                       status.out_of_sync.should == (expected_out_of_sync_count != 0)
 
                       # Check the :synced field on state.yml
                       synced_should_be_set = !noop_mode && status.changed
                       (@harness.cached(resource, :synced) != nil).should == synced_should_be_set
                     end; end
                   end
                 end
               end
             end
           end; end
         end
       end; end
     end; end
 
     it "should not apply changes if allow_changes?() returns false" do
       test_file = tmpfile('foo')
       resource = Puppet::Type.type(:file).new :path => test_file, :backup => false, :ensure => :file
       resource.expects(:err).never # make sure no exceptions get swallowed
       @harness.expects(:allow_changes?).with(resource).returns false
       status = @harness.evaluate(resource)
       File.exists?(test_file).should == false
     end
   end
 
   describe "when determining whether the resource can be changed" do
     before do
       @resource.stubs(:purging?).returns true
       @resource.stubs(:deleting?).returns true
     end
 
     it "should be true if the resource is not being purged" do
       @resource.expects(:purging?).returns false
       @harness.should be_allow_changes(@resource)
     end
 
     it "should be true if the resource is not being deleted" do
       @resource.expects(:deleting?).returns false
       @harness.should be_allow_changes(@resource)
     end
 
     it "should be true if the resource has no dependents" do
       @harness.relationship_graph.expects(:dependents).with(@resource).returns []
       @harness.should be_allow_changes(@resource)
     end
 
     it "should be true if all dependents are being deleted" do
       dep = stub 'dependent', :deleting? => true
       @harness.relationship_graph.expects(:dependents).with(@resource).returns [dep]
       @resource.expects(:purging?).returns true
       @harness.should be_allow_changes(@resource)
     end
 
     it "should be false if the resource's dependents are not being deleted" do
       dep = stub 'dependent', :deleting? => false, :ref => "myres"
       @resource.expects(:warning)
       @harness.relationship_graph.expects(:dependents).with(@resource).returns [dep]
       @harness.should_not be_allow_changes(@resource)
     end
   end
 
   describe "when finding the schedule" do
     before do
       @catalog = Puppet::Resource::Catalog.new
       @resource.catalog = @catalog
     end
 
     it "should warn and return nil if the resource has no catalog" do
       @resource.catalog = nil
       @resource.expects(:warning)
 
       @harness.schedule(@resource).should be_nil
     end
 
     it "should return nil if the resource specifies no schedule" do
       @harness.schedule(@resource).should be_nil
     end
 
     it "should fail if the named schedule cannot be found" do
       @resource[:schedule] = "whatever"
       @resource.expects(:fail)
       @harness.schedule(@resource)
     end
 
     it "should return the named schedule if it exists" do
       sched = Puppet::Type.type(:schedule).new(:name => "sched")
       @catalog.add_resource(sched)
       @resource[:schedule] = "sched"
       @harness.schedule(@resource).to_s.should == sched.to_s
     end
   end
 
   describe "when determining if a resource is scheduled" do
     before do
       @catalog = Puppet::Resource::Catalog.new
       @resource.catalog = @catalog
       @status = Puppet::Resource::Status.new(@resource)
     end
 
     it "should return true if 'ignoreschedules' is set" do
       Puppet[:ignoreschedules] = true
       @resource[:schedule] = "meh"
       @harness.should be_scheduled(@status, @resource)
     end
 
     it "should return true if the resource has no schedule set" do
       @harness.should be_scheduled(@status, @resource)
     end
 
     it "should return the result of matching the schedule with the cached 'checked' time if a schedule is set" do
       t = Time.now
       @harness.expects(:cached).with(@resource, :checked).returns(t)
 
       sched = Puppet::Type.type(:schedule).new(:name => "sched")
       @catalog.add_resource(sched)
       @resource[:schedule] = "sched"
 
       sched.expects(:match?).with(t.to_i).returns "feh"
 
       @harness.scheduled?(@status, @resource).should == "feh"
     end
   end
 
   it "should be able to cache data in the Storage module" do
     data = {}
     Puppet::Util::Storage.expects(:cache).with(@resource).returns data
     @harness.cache(@resource, :foo, "something")
 
     data[:foo].should == "something"
   end
 
   it "should be able to retrieve data from the cache" do
     data = {:foo => "other"}
     Puppet::Util::Storage.expects(:cache).with(@resource).returns data
     @harness.cached(@resource, :foo).should == "other"
   end
 end
diff --git a/spec/unit/util/log_spec.rb b/spec/unit/util/log_spec.rb
index 6dd365e19..77f1aa342 100755
--- a/spec/unit/util/log_spec.rb
+++ b/spec/unit/util/log_spec.rb
@@ -1,259 +1,259 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/util/log'
 
 describe Puppet::Util::Log do
   include PuppetSpec::Files
 
   it "should write a given message to the specified destination" do
     arraydest = []
     Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(arraydest))
     Puppet::Util::Log.new(:level => :notice, :message => "foo")
     message = arraydest.last.message
     message.should == "foo"
   end
 
   describe ".setup_default" do
     it "should default to :syslog" do
       Puppet.features.stubs(:syslog?).returns(true)
       Puppet::Util::Log.expects(:newdestination).with(:syslog)
 
       Puppet::Util::Log.setup_default
     end
 
     it "should fall back to :file" do
       Puppet.features.stubs(:syslog?).returns(false)
       Puppet::Util::Log.expects(:newdestination).with(Puppet[:puppetdlog])
 
       Puppet::Util::Log.setup_default
     end
   end
 
   describe Puppet::Util::Log::DestConsole do
     before do
       @console = Puppet::Util::Log::DestConsole.new
     end
 
     it "should colorize if Puppet[:color] is :ansi" do
       Puppet[:color] = :ansi
 
       @console.colorize(:alert, "abc").should == "\e[0;31mabc\e[0m"
     end
 
     it "should colorize if Puppet[:color] is 'yes'" do
       Puppet[:color] = "yes"
 
       @console.colorize(:alert, "abc").should == "\e[0;31mabc\e[0m"
     end
 
     it "should htmlize if Puppet[:color] is :html" do
       Puppet[:color] = :html
 
       @console.colorize(:alert, "abc").should == "<span style=\"color: #FFA0A0\">abc</span>"
     end
 
     it "should do nothing if Puppet[:color] is false" do
       Puppet[:color] = false
 
       @console.colorize(:alert, "abc").should == "abc"
     end
 
     it "should do nothing if Puppet[:color] is invalid" do
       Puppet[:color] = "invalid option"
 
       @console.colorize(:alert, "abc").should == "abc"
     end
   end
 
   describe Puppet::Util::Log::DestSyslog do
     before do
       @syslog = Puppet::Util::Log::DestSyslog.new
     end
   end
 
   describe "instances" do
     before do
       Puppet::Util::Log.stubs(:newmessage)
     end
 
     [:level, :message, :time, :remote].each do |attr|
       it "should have a #{attr} attribute" do
         log = Puppet::Util::Log.new :level => :notice, :message => "A test message"
         log.should respond_to(attr)
         log.should respond_to(attr.to_s + "=")
       end
     end
 
     it "should fail if created without a level" do
       lambda { Puppet::Util::Log.new(:message => "A test message") }.should raise_error(ArgumentError)
     end
 
     it "should fail if created without a message" do
       lambda { Puppet::Util::Log.new(:level => :notice) }.should raise_error(ArgumentError)
     end
 
     it "should make available the level passed in at initialization" do
       Puppet::Util::Log.new(:level => :notice, :message => "A test message").level.should == :notice
     end
 
     it "should make available the message passed in at initialization" do
       Puppet::Util::Log.new(:level => :notice, :message => "A test message").message.should == "A test message"
     end
 
     # LAK:NOTE I don't know why this behavior is here, I'm just testing what's in the code,
     # at least at first.
     it "should always convert messages to strings" do
       Puppet::Util::Log.new(:level => :notice, :message => :foo).message.should == "foo"
     end
 
     it "should flush the log queue when the first destination is specified" do
       Puppet::Util::Log.close_all
       Puppet::Util::Log.expects(:flushqueue)
       Puppet::Util::Log.newdestination(:console)
     end
 
     it "should convert the level to a symbol if it's passed in as a string" do
       Puppet::Util::Log.new(:level => "notice", :message => :foo).level.should == :notice
     end
 
-    it "should fail if the level is not a symbol or string", :'fails_on_ruby_1.9.2' => true do
+    it "should fail if the level is not a symbol or string" do
       lambda { Puppet::Util::Log.new(:level => 50, :message => :foo) }.should raise_error(ArgumentError)
     end
 
     it "should fail if the provided level is not valid" do
       Puppet::Util::Log.expects(:validlevel?).with(:notice).returns false
       lambda { Puppet::Util::Log.new(:level => :notice, :message => :foo) }.should raise_error(ArgumentError)
     end
 
     it "should set its time to the initialization time" do
       time = mock 'time'
       Time.expects(:now).returns time
       Puppet::Util::Log.new(:level => "notice", :message => :foo).time.should equal(time)
     end
 
     it "should make available any passed-in tags" do
       log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :tags => %w{foo bar})
       log.tags.should be_include("foo")
       log.tags.should be_include("bar")
     end
 
     it "should use an passed-in source" do
       Puppet::Util::Log.any_instance.expects(:source=).with "foo"
       Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => "foo")
     end
 
     [:file, :line].each do |attr|
       it "should use #{attr} if provided" do
         Puppet::Util::Log.any_instance.expects(attr.to_s + "=").with "foo"
         Puppet::Util::Log.new(:level => "notice", :message => :foo, attr => "foo")
       end
     end
 
     it "should default to 'Puppet' as its source" do
       Puppet::Util::Log.new(:level => "notice", :message => :foo).source.should == "Puppet"
     end
 
     it "should register itself with Log" do
       Puppet::Util::Log.expects(:newmessage)
       Puppet::Util::Log.new(:level => "notice", :message => :foo)
     end
 
     it "should update Log autoflush when Puppet[:autoflush] is set" do
       Puppet::Util::Log.expects(:autoflush=).once.with(true)
       Puppet[:autoflush] = true
     end
 
     it "should have a method for determining if a tag is present" do
       Puppet::Util::Log.new(:level => "notice", :message => :foo).should respond_to(:tagged?)
     end
 
     it "should match a tag if any of the tags are equivalent to the passed tag as a string" do
       Puppet::Util::Log.new(:level => "notice", :message => :foo, :tags => %w{one two}).should be_tagged(:one)
     end
 
     it "should tag itself with its log level" do
       Puppet::Util::Log.new(:level => "notice", :message => :foo).should be_tagged(:notice)
     end
 
     it "should return its message when converted to a string" do
       Puppet::Util::Log.new(:level => "notice", :message => :foo).to_s.should == "foo"
     end
 
     it "should include its time, source, level, and message when prepared for reporting" do
       log = Puppet::Util::Log.new(:level => "notice", :message => :foo)
       report = log.to_report
       report.should be_include("notice")
       report.should be_include("foo")
       report.should be_include(log.source)
       report.should be_include(log.time.to_s)
     end
 
     it "should not create unsuitable log destinations" do
       Puppet.features.stubs(:syslog?).returns(false)
 
       Puppet::Util::Log::DestSyslog.expects(:suitable?)
       Puppet::Util::Log::DestSyslog.expects(:new).never
 
       Puppet::Util::Log.newdestination(:syslog)
     end
 
     describe "when setting the source as a RAL object" do
       it "should tag itself with any tags the source has" do
         source = Puppet::Type.type(:file).new :path => make_absolute("/foo/bar")
         log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
         source.tags.each do |tag|
           log.tags.should be_include(tag)
         end
       end
 
       it "should use the source_descriptors" do
         source = stub "source"
         source.stubs(:source_descriptors).returns(:tags => ["tag","tag2"], :path => "path", :version => 100)
 
         log = Puppet::Util::Log.new(:level => "notice", :message => :foo)
         log.expects(:tag).with("tag")
         log.expects(:tag).with("tag2")
 
         log.source = source
 
         log.source.should == "path"
       end
 
       it "should copy over any file and line information" do
         source = Puppet::Type.type(:file).new :path => make_absolute("/foo/bar")
         source.file = "/my/file"
         source.line = 50
         log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
         log.file.should == "/my/file"
         log.line.should == 50
       end
     end
 
     describe "when setting the source as a non-RAL object" do
       it "should not try to copy over file, version, line, or tag information" do
         source = Puppet::Module.new("foo")
         source.expects(:file).never
         log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
       end
     end
   end
 
   describe "to_yaml", :'fails_on_ruby_1.9.2' => true do
     it "should not include the @version attribute" do
       log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :version => 100)
       log.to_yaml_properties.should_not include('@version')
     end
 
     it "should include attributes @level, @message, @source, @tags, and @time" do
       log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :version => 100)
-      log.to_yaml_properties.should == %w{@level @message @source @tags @time}
+      log.to_yaml_properties.should == [:@level, :@message, :@source, :@tags, :@time]
     end
 
     it "should include attributes @file and @line if specified" do
       log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :file => "foo", :line => 35)
-      log.to_yaml_properties.should include('@file')
-      log.to_yaml_properties.should include('@line')
+      log.to_yaml_properties.should include(:@file)
+      log.to_yaml_properties.should include(:@line)
     end
   end
 end
diff --git a/spec/unit/util/monkey_patches_spec.rb b/spec/unit/util/monkey_patches_spec.rb
index 5e4e073d1..b3ff331b7 100755
--- a/spec/unit/util/monkey_patches_spec.rb
+++ b/spec/unit/util/monkey_patches_spec.rb
@@ -1,174 +1,187 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/util/monkey_patches'
 
 
 
 describe "yaml deserialization" do
   it "should call yaml_initialize when deserializing objects that have that method defined" do
     class Puppet::TestYamlInitializeClass
       attr_reader :foo
 
       def yaml_initialize(tag, var)
         var.should == {'foo' => 100}
         instance_variables.should == []
         @foo = 200
       end
     end
 
     obj = YAML.load("--- !ruby/object:Puppet::TestYamlInitializeClass\n  foo: 100")
     obj.foo.should == 200
   end
 
   it "should not call yaml_initialize if not defined" do
     class Puppet::TestYamlNonInitializeClass
       attr_reader :foo
     end
 
     obj = YAML.load("--- !ruby/object:Puppet::TestYamlNonInitializeClass\n  foo: 100")
     obj.foo.should == 100
   end
 end
 
 # In Ruby > 1.8.7 this is a builtin, otherwise we monkey patch the method in
 describe "Array#combination" do
   it "should fail if wrong number of arguments given" do
     lambda { [1,2,3].combination() }.should raise_error(ArgumentError, /wrong number/)
     lambda { [1,2,3].combination(1,2) }.should raise_error(ArgumentError, /wrong number/)
   end
 
   it "should return an empty array if combo size than array size or negative" do
     [1,2,3].combination(4).to_a.should == []
     [1,2,3].combination(-1).to_a.should == []
   end
 
   it "should return an empty array with an empty array if combo size == 0" do
     [1,2,3].combination(0).to_a.should == [[]]
   end
 
   it "should all provide all combinations of size passed in" do
     [1,2,3,4].combination(1).to_a.should == [[1], [2], [3], [4]]
     [1,2,3,4].combination(2).to_a.should == [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]
     [1,2,3,4].combination(3).to_a.should == [[1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]]
   end
 end
 
 describe IO do
   include PuppetSpec::Files
 
   let(:file) { tmpfile('io-binary') }
   let(:content) { "\x01\x02\x03\x04" }
 
   describe "::binread" do
     it "should read in binary mode" do
       File.open(file, 'wb') {|f| f.write(content) }
       IO.binread(file).should == content
     end
 
     it "should read with a length and offset" do
       offset = 1
       length = 2
       File.open(file, 'wb') {|f| f.write(content) }
       IO.binread(file, length, offset).should == content[offset..length]
     end
 
     it "should raise an error if the file doesn't exist" do
       expect { IO.binread('/path/does/not/exist') }.to raise_error(Errno::ENOENT)
     end
   end
 
   describe "::binwrite" do
     it "should write in binary mode" do
       IO.binwrite(file, content).should == content.length
       File.open(file, 'rb') {|f| f.read.should == content }
     end
 
     it "should write using an offset" do
       offset = 1
       IO.binwrite(file, content, offset).should == content.length - offset
       File.open(file, 'rb') {|f| f.read.should == content[offset..-1] }
     end
 
     it "should raise an error if the file doesn't exist" do
       expect { IO.binwrite('/path/does/not/exist', 'foo') }.to raise_error(Errno::ENOENT)
     end
   end
 end
 
 describe Range do
   def do_test( range, other, expected )
     result = range.intersection(other)
     result.should == expected
   end
 
   it "should return expected ranges for iterable things" do
     iterable_tests = {
       1  .. 4   => nil,          # before
       11 .. 15  => nil,          # after
       1  .. 6   => 5  ..  6,     # overlap_begin
       9  .. 15  => 9  ..  10,    # overlap_end
       1  .. 5   => 5  ..  5,     # overlap_begin_edge
       10 .. 15  => 10 ..  10,    # overlap_end_edge
       5  .. 10  => 5  ..  10,    # overlap_all
       6  .. 9   => 6  ..  9,     # overlap_inner
 
       1 ... 5   => nil,          # before             (exclusive range)
       1 ... 7   => 5  ... 7,     # overlap_begin      (exclusive range)
       1 ... 6   => 5  ... 6,     # overlap_begin_edge (exclusive range)
       5 ... 11  => 5  ..  10,    # overlap_all        (exclusive range)
       6 ... 10  => 6  ... 10,    # overlap_inner      (exclusive range)
     }
 
     iterable_tests.each do |other, expected|
       do_test( 5..10, other, expected )
       do_test( other, 5..10, expected )
     end
   end
 
   it "should return expected ranges for noniterable things" do
     inclusive_base_case = {
       1.to_f  .. 4.to_f   => nil,                   # before
       11.to_f .. 15.to_f  => nil,                   # after
       1.to_f  .. 6.to_f   => 5.to_f  ..  6.to_f,    # overlap_begin
       9.to_f  .. 15.to_f  => 9.to_f  ..  10.to_f,   # overlap_end
       1.to_f  .. 5.to_f   => 5.to_f  ..  5.to_f,    # overlap_begin_edge
       10.to_f .. 15.to_f  => 10.to_f ..  10.to_f,   # overlap_end_edge
       5.to_f  .. 10.to_f  => 5.to_f  ..  10.to_f,   # overlap_all
       6.to_f  .. 9.to_f   => 6.to_f  ..  9.to_f,    # overlap_inner
 
       1.to_f ... 5.to_f   => nil,                   # before             (exclusive range)
       1.to_f ... 7.to_f   => 5.to_f  ... 7.to_f,    # overlap_begin      (exclusive range)
       1.to_f ... 6.to_f   => 5.to_f  ... 6.to_f,    # overlap_begin_edge (exclusive range)
       5.to_f ... 11.to_f  => 5.to_f  ..  10.to_f,   # overlap_all        (exclusive range)
       6.to_f ... 10.to_f  => 6.to_f  ... 10.to_f,   # overlap_inner      (exclusive range)
     }
 
     inclusive_base_case.each do |other, expected|
       do_test( 5.to_f..10.to_f, other, expected )
       do_test( other, 5.to_f..10.to_f, expected )
     end
 
     exclusive_base_case = {
       1.to_f  .. 4.to_f   => nil,                   # before
       11.to_f .. 15.to_f  => nil,                   # after
       1.to_f  .. 6.to_f   => 5.to_f  ..  6.to_f,    # overlap_begin
       9.to_f  .. 15.to_f  => 9.to_f  ... 10.to_f,   # overlap_end
       1.to_f  .. 5.to_f   => 5.to_f  ..  5.to_f,    # overlap_begin_edge
       10.to_f .. 15.to_f  => nil,                   # overlap_end_edge
       5.to_f  .. 10.to_f  => 5.to_f  ... 10.to_f,   # overlap_all
       6.to_f  .. 9.to_f   => 6.to_f  ..  9.to_f,    # overlap_inner
 
       1.to_f ... 5.to_f   => nil,                   # before             (exclusive range)
       1.to_f ... 7.to_f   => 5.to_f  ... 7.to_f,    # overlap_begin      (exclusive range)
       1.to_f ... 6.to_f   => 5.to_f  ... 6.to_f,    # overlap_begin_edge (exclusive range)
       5.to_f ... 11.to_f  => 5.to_f  ... 10.to_f,   # overlap_all        (exclusive range)
       6.to_f ... 10.to_f  => 6.to_f  ... 10.to_f,   # overlap_inner      (exclusive range)
     }
 
     exclusive_base_case.each do |other, expected|
       do_test( 5.to_f...10.to_f, other, expected )
       do_test( other, 5.to_f...10.to_f, expected )
     end
   end
 end
+
+
+describe Object, "#instance_variables" do
+  it "should work with no instance variables" do
+    Object.new.instance_variables.should == []
+  end
+
+  it "should return symbols, not strings" do
+    o = Object.new
+    ["@foo", "@bar", "@baz"].map {|x| o.instance_variable_set(x, x) }
+    o.instance_variables.should =~ [:@foo, :@bar, :@baz]
+  end
+end