facter 1.7.6 → 2.0.1.rc1

data/lib/facter/util/macosx.rb

@@ -6,8 +6,7 @@
 ##
 
 module Facter::Util::Macosx
-  require 'thread'
-  require 'facter/util/cfpropertylist'
+  require 'cfpropertylist'
   require 'facter/util/resolution'
 
   Plist_Xml_Doctype  = '<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">'
@@ -16,7 +15,7 @@ module Facter::Util::Macosx
   # by looking at the _name key of the _items dict for each _dataType
 
   def self.profiler_xml(data_field)
-    Facter::Util::Resolution.exec("/usr/sbin/system_profiler -xml #{data_field}")
+    Facter::Core::Execution.exec("/usr/sbin/system_profiler -xml #{data_field}")
   end
 
   def self.intern_xml(xml)
@@ -26,13 +25,13 @@ module Facter::Util::Macosx
       xml.gsub!( bad_xml_doctype, Plist_Xml_Doctype )
       Facter.debug("Had to fix plist with incorrect DOCTYPE declaration")
     end
-    plist = Facter::Util::CFPropertyList::List.new
+    plist = CFPropertyList::List.new
     begin
       plist.load_str(xml)
-    rescue => e
-      fail("A plist file could not be properly read by Facter::Util::CFPropertyList: #{e.inspect}")
+    rescue CFFormatError => e
+      raise RuntimeError, "A plist file could not be properly read by CFPropertyList: #{e.message}", e.backtrace
     end
-    Facter::Util::CFPropertyList.native_types(plist.value)
+    CFPropertyList.native_types(plist.value)
   end
 
   # Return an xml result, modified as we need it.
@@ -58,7 +57,7 @@ module Facter::Util::Macosx
   def self.sw_vers
     ver = Hash.new
     [ "productName", "productVersion", "buildVersion" ].each do |option|
-      ver["macosx_#{option}"] = Facter::Util::Resolution.exec("/usr/bin/sw_vers -#{option}").strip
+      ver["macosx_#{option}"] = Facter::Core::Execution.exec("/usr/bin/sw_vers -#{option}").strip
     end
     productversion = ver["macosx_productVersion"]
     if not productversion.nil?

data/lib/facter/util/manufacturer.rb

@@ -55,7 +55,7 @@ module Facter::Manufacturer
       Facter.add(facterkey) do
         confine :kernel => [:openbsd, :darwin]
         setcode do
-          Facter::Util::Resolution.exec("sysctl -n #{sysctlkey} 2>/dev/null")
+          Facter::Core::Execution.exec("sysctl -n #{sysctlkey} 2>/dev/null")
         end
       end
     end
@@ -63,7 +63,7 @@ module Facter::Manufacturer
 
   def self.prtdiag_sparc_find_system_info()
     # Parses prtdiag for a SPARC architecture string, won't work with Solaris x86
-    output = Facter::Util::Resolution.exec('/usr/sbin/prtdiag 2>/dev/null')
+    output = Facter::Core::Execution.exec('/usr/sbin/prtdiag 2>/dev/null')
 
     # System Configuration:  Sun Microsystems  sun4u Sun SPARC Enterprise M3000 Server
     if output and output =~ /^System Configuration:\s+(.+?)\s+(sun\d+\S+)\s+(.+)/
@@ -81,7 +81,7 @@ module Facter::Manufacturer
 
     Facter.add('serialnumber') do
       setcode do
-        Facter::Util::Resolution.exec("/usr/sbin/sneep")
+        Facter::Core::Execution.exec("/usr/sbin/sneep")
       end
     end
   end

data/lib/facter/util/memory.rb

@@ -35,7 +35,7 @@ module Facter::Memory
   def self.vmstat_find_free_memory(args = [])
     cmd = 'vmstat'
     cmd += (' ' + args.join(' ')) unless args.empty?
-    row = Facter::Util::Resolution.exec(cmd).split("\n")[-1]
+    row = Facter::Core::Execution.exec(cmd).split("\n")[-1]
     if row =~ /^\s*\d+\s*\d+\s*\d+\s*\d+\s*(\d+)/
       memfree = $1
     end
@@ -52,7 +52,7 @@ module Facter::Memory
     pagesize = 0
     memspecfree = 0
 
-    vmstats = Facter::Util::Resolution.exec('vm_stat')
+    vmstats = Facter::Core::Execution.exec('vm_stat')
     vmstats.each_line do |vmline|
       case
       when vmline =~ /page\ssize\sof\s(\d+)\sbytes/
@@ -71,7 +71,7 @@ module Facter::Memory
   # it's the third value on the line starting with memory
   # svmon can be run by non root users
   def self.svmon_aix_find_free_memory()
-    Facter::Util::Resolution.exec("/usr/bin/svmon -O unit=KB") =~ /^memory\s+\d+\s+\d+\s+(\d+)\s+/
+    Facter::Core::Execution.exec("/usr/bin/svmon -O unit=KB") =~ /^memory\s+\d+\s+\d+\s+(\d+)\s+/
     $1
   end
 
@@ -112,15 +112,15 @@ module Facter::Memory
   def self.mem_size_info(kernel = Facter.value(:kernel))
     case kernel
     when /OpenBSD/i
-      Facter::Util::Resolution.exec("sysctl hw.physmem | cut -d'=' -f2")
+      Facter::Core::Execution.exec("sysctl hw.physmem | cut -d'=' -f2")
     when /FreeBSD/i
-      Facter::Util::Resolution.exec("sysctl -n hw.physmem")
+      Facter::Core::Execution.exec("sysctl -n hw.physmem")
     when /Darwin/i
-      Facter::Util::Resolution.exec("sysctl -n hw.memsize")
+      Facter::Core::Execution.exec("sysctl -n hw.memsize")
     when /Dragonfly/i
-      Facter::Util::Resolution.exec("sysctl -n hw.physmem")
+      Facter::Core::Execution.exec("sysctl -n hw.physmem")
     when /AIX/i
-      if Facter::Util::Resolution.exec("/usr/bin/svmon -O unit=KB") =~ /^memory\s+(\d+)\s+/
+      if Facter::Core::Execution.exec("/usr/bin/svmon -O unit=KB") =~ /^memory\s+(\d+)\s+/
         $1
       end
     end
@@ -150,15 +150,15 @@ module Facter::Memory
   def self.swap_info(kernel = Facter.value(:kernel))
     case kernel
     when /AIX/i
-      (Facter.value(:id) == "root") ? Facter::Util::Resolution.exec('swap -l 2>/dev/null') : nil
+      (Facter.value(:id) == "root") ? Facter::Core::Execution.exec('swap -l 2>/dev/null') : nil
     when /OpenBSD/i
-      Facter::Util::Resolution.exec('swapctl -s')
+      Facter::Core::Execution.exec('swapctl -s')
     when /FreeBSD/i
-      Facter::Util::Resolution.exec('swapinfo -k')
+      Facter::Core::Execution.exec('swapinfo -k')
     when /Darwin/i
-      Facter::Util::Resolution.exec('sysctl vm.swapusage')
+      Facter::Core::Execution.exec('sysctl vm.swapusage')
     when /SunOS/i
-      Facter::Util::Resolution.exec('/usr/sbin/swap -l 2>/dev/null')
+      Facter::Core::Execution.exec('/usr/sbin/swap -l 2>/dev/null')
     end
   end
 

data/lib/facter/util/monkey_patches.rb

@@ -2,38 +2,7 @@
 # version 1.8.5. This allows us to use RbConfig in place of the older Config in
 # our code and still be compatible with at least Ruby 1.8.1.
 require 'rbconfig'
-require 'enumerator'
 
 unless defined? ::RbConfig
   ::RbConfig = ::Config
 end
-
-module Facter
-  module Util
-    module MonkeyPatches
-      module Lines
-        def lines(separator = $/)
-          if block_given?
-            self.each_line(separator) {|line| yield line }
-            return self
-          else
-            return enum_for(:each_line, separator)
-          end
-        end
-      end
-    end
-  end
-end
-
-public
-class String
-  unless method_defined? :lines
-    include Facter::Util::MonkeyPatches::Lines
-  end
-end
-
-class IO
-  unless method_defined? :lines
-    include Facter::Util::MonkeyPatches::Lines
-  end
-end

data/lib/facter/util/netmask.rb

@@ -8,19 +8,19 @@ module Facter::NetMask
     when 'Linux'
       ops = {
         :ifconfig_opts => ['2>/dev/null'],
-        :regex => %r{#{Facter.ipaddress}.*?(?:Mask:|netmask)\s*(#{ipregex})}x,
+        :regex => %r{#{Facter.value(:ipaddress)}.*?(?:Mask:|netmask)\s*(#{ipregex})}x,
         :munge => nil,
       }
     when 'SunOS'
       ops = {
         :ifconfig_opts => ['-a'],
-        :regex => %r{\s+ inet \s #{Facter.ipaddress} \s netmask \s (\w{8})}x,
+        :regex => %r{\s+ inet \s #{Facter.value(:ipaddress)} \s netmask \s (\w{8})}x,
         :munge => Proc.new { |mask| mask.scan(/../).collect do |byte| byte.to_i(16) end.join('.') }
       }
     when 'FreeBSD','NetBSD','OpenBSD', 'Darwin', 'GNU/kFreeBSD', 'DragonFly'
       ops = {
         :ifconfig_opts => ['-a'],
-        :regex => %r{\s+ inet \s #{Facter.ipaddress} \s netmask \s 0x(\w{8})}x,
+        :regex => %r{\s+ inet \s #{Facter.value(:ipaddress)} \s netmask \s 0x(\w{8})}x,
         :munge => Proc.new { |mask| mask.scan(/../).collect do |byte| byte.to_i(16) end.join('.') }
       }
     end

data/lib/facter/util/normalization.rb

@@ -0,0 +1,94 @@
+module Facter
+  module Util
+    module Normalization
+      class NormalizationError < StandardError; end
+
+      VALID_TYPES = [Integer, Float, TrueClass, FalseClass, NilClass, String, Array, Hash]
+
+      module_function
+
+      # Recursively normalize the given data structure
+      #
+      # @api public
+      # @raise [NormalizationError] If the data structure contained an invalid element.
+      # @return [void]
+      def normalize(value)
+        case value
+        when Integer, Float, TrueClass, FalseClass, NilClass
+          value
+        when String
+          normalize_string(value)
+        when Array
+          normalize_array(value)
+        when Hash
+          normalize_hash(value)
+        else
+          raise NormalizationError, "Expected #{value} to be one of #{VALID_TYPES.inspect}, but was #{value.class}"
+        end
+      end
+
+      # @!method normalize_string(value)
+      #
+      # Attempt to normalize and validate the given string.
+      #
+      # On Ruby 1.8 the string is checked by stripping out all non UTF-8
+      # characters and comparing the converted string to the original. If they
+      # do not match then the string is considered invalid.
+      #
+      # On Ruby 1.9+, the string is validate by checking that the string encoding
+      # is UTF-8 and that the string content matches the encoding. If the string
+      # is not an expected encoding then it is converted to UTF-8.
+      #
+      # @api public
+      # @raise [NormalizationError] If the string used an unsupported encoding or did not match its encoding
+      # @param value [String]
+      # @return [void]
+
+      if RUBY_VERSION =~ /^1\.8/
+        require 'iconv'
+
+        def normalize_string(value)
+          converted = Iconv.conv('UTF-8//IGNORE', 'UTF-8', value)
+          if converted != value
+            raise NormalizationError, "String #{value.inspect} is not valid UTF-8"
+          end
+          value
+        end
+      else
+        def normalize_string(value)
+          value = value.encode(Encoding::UTF_8)
+
+          unless value.valid_encoding?
+            raise NormalizationError, "String #{value.inspect} doesn't match the reported encoding #{value.encoding}"
+          end
+
+          value
+        rescue EncodingError
+          raise NormalizationError, "String encoding #{value.encoding} is not UTF-8 and could not be converted to UTF-8"
+        end
+      end
+
+      # Validate all elements of the array.
+      #
+      # @api public
+      # @raise [NormalizationError] If one of the elements failed validation
+      # @param value [Array]
+      # @return [void]
+      def normalize_array(value)
+        value.collect do |elem|
+          normalize(elem)
+        end
+      end
+
+      # Validate all keys and values of the hash.
+      #
+      # @api public
+      # @raise [NormalizationError] If one of the keys or values failed normalization
+      # @param value [Hash]
+      # @return [void]
+      def normalize_hash(value)
+        Hash[value.collect { |k, v| [ normalize(k), normalize(v) ] } ]
+      end
+    end
+  end
+end

data/lib/facter/util/nothing_loader.rb

@@ -1,13 +1,10 @@
-# An external fact loader that doesn't load anything
-
-# This makes it possible to disable loading
-# of external facts
-
 module Facter
   module Util
 
+    # An external fact loader that doesn't load anything
+    # This makes it possible to disable loading
+    # of external facts
     class NothingLoader
-
       def load(collection)
       end
     end

data/lib/facter/util/parser.rb

@@ -55,9 +55,7 @@ module Facter::Util::Parser
     def results
       parse_results
     rescue Exception => detail
-      Facter.warn("Failed to handle #{filename} as #{self.class} facts")
-      Facter.warn("detail: #{detail.class}: #{detail.message}")
-      Facter.debug(detail.backtrace.join("\n\t"))
+      Facter.log_exception(detail, "Failed to handle #{filename} as #{self.class} facts: #{detail.message}")
       nil
     end
 
@@ -119,7 +117,7 @@ module Facter::Util::Parser
 
   class ScriptParser < Base
     def parse_results
-      KeyValuePairOutputFormat.parse Facter::Util::Resolution.exec(quote(filename))
+      KeyValuePairOutputFormat.parse Facter::Core::Execution.exec(quote(filename))
     end
 
     private
@@ -142,7 +140,7 @@ module Facter::Util::Parser
     # Returns a hash of facts from powershell output
     def parse_results
       shell_command = "powershell -NoProfile -NonInteractive -NoLogo -ExecutionPolicy Bypass -File \"#{filename}\""
-      KeyValuePairOutputFormat.parse Facter::Util::Resolution.exec(shell_command)
+      KeyValuePairOutputFormat.parse Facter::Core::Execution.exec(shell_command)
     end
   end
 

data/lib/facter/util/plist/generator.rb

@@ -51,7 +51,7 @@ module Plist
     # Writes the serialized object's plist to the specified filename.
     def self.save_plist(obj, filename)
       File.open(filename, 'wb') do |f|
-        f.write(obj.to_plist)
+        f.write(Plist::Emit.dump(obj))
       end
     end
 

data/lib/facter/util/processor.rb

@@ -47,19 +47,19 @@ module Processor
   end
 
   ##
-  # lsdev is intended to directly delegate to Facter::Util::Resolution.exec in an
+  # lsdev is intended to directly delegate to Facter::Core::Execution.exec in an
   # effort to make the processorX facts easier to test by stubbing only the
   # behaviors we need to stub to get the output of the system command.
   def self.lsdev(command="lsdev -Cc processor")
-    Facter::Util::Resolution.exec(command)
+    Facter::Core::Execution.exec(command)
   end
 
   ##
-  # lsattr is intended to directly delegate to Facter::Util::Resolution.exec in
+  # lsattr is intended to directly delegate to Facter::Core::Execution.exec in
   # an effort to make the processorX facts easier to test.  See also the
   # {lsdev} method.
   def self.lsattr(command="lsattr -El proc0 -a type")
-    Facter::Util::Resolution.exec(command)
+    Facter::Core::Execution.exec(command)
   end
 
   ##
@@ -181,34 +181,34 @@ module Processor
   private_class_method :read_unistd_h
 
   ##
-  # machinfo delegates directly to Facter::Util::Resolution.exec, as with lsdev
+  # machinfo delegates directly to Facter::Core::Execution.exec, as with lsdev
   # above.
   def self.machinfo(command="/usr/contrib/bin/machinfo")
-    Facter::Util::Resolution.exec(command)
+    Facter::Core::Execution.exec(command)
   end
 
   ##
-  # model delegates directly to Facter::Util::Resolution.exec.
+  # model delegates directly to Facter::Core::Execution.exec.
   def self.model(command="model")
-    Facter::Util::Resolution.exec(command)
+    Facter::Core::Execution.exec(command)
   end
 
   ##
-  # ioscan delegates directly to Facter::Util::Resolution.exec.
+  # ioscan delegates directly to Facter::Core::Execution.exec.
   def self.ioscan(command="ioscan -fknCprocessor")
-    Facter::Util::Resolution.exec(command)
+    Facter::Core::Execution.exec(command)
   end
 
   ##
-  # getconf_cpu_version delegates directly to Facter::Util::Resolution.exec.
+  # getconf_cpu_version delegates directly to Facter::Core::Execution.exec.
   def self.getconf_cpu_version(command="getconf CPU_VERSION")
-    Facter::Util::Resolution.exec(command)
+    Facter::Core::Execution.exec(command)
   end
 
   ##
-  # getconf_cpu_chip_type delegates directly to Facter::Util::Resolution.exec.
+  # getconf_cpu_chip_type delegates directly to Facter::Core::Execution.exec.
   def self.getconf_cpu_chip_type(command="getconf CPU_CHIP_TYPE")
-    Facter::Util::Resolution.exec(command)
+    Facter::Core::Execution.exec(command)
   end
 
   def self.enum_cpuinfo
@@ -272,7 +272,7 @@ module Processor
     processor_num = -1
     processor_list = []
     Thread::exclusive do
-      kstat = Facter::Util::Resolution.exec('/usr/bin/kstat cpu_info')
+      kstat = Facter::Core::Execution.exec('/usr/bin/kstat cpu_info')
       if kstat
         kstat.each_line do |l|
           if l =~ /cpu_info(\d+)/

data/lib/facter/util/resolution.rb

@@ -1,329 +1,152 @@
-# An actual fact resolution mechanism.  These are largely just chunks of
-# code, with optional confinements restricting the mechanisms to only working on
-# specific systems.  Note that the confinements are always ANDed, so any
-# confinements specified must all be true for the resolution to be
-# suitable.
 require 'facter/util/confine'
 require 'facter/util/config'
-
-require 'timeout'
-
+require 'facter/util/normalization'
+require 'facter/core/execution'
+require 'facter/core/resolvable'
+require 'facter/core/suitable'
+
+# This represents a fact resolution. A resolution is a concrete
+# implementation of a fact. A single fact can have many resolutions and
+# the correct resolution will be chosen at runtime. Each time
+# {Facter.add} is called, a new resolution is created and added to the
+# set of resolutions for the fact named in the call.  Each resolution
+# has a {#has_weight weight}, which defines its priority over other
+# resolutions, and a set of {#confine _confinements_}, which defines the
+# conditions under which it will be chosen. All confinements must be
+# satisfied for a fact to be considered _suitable_.
+#
+# @api public
 class Facter::Util::Resolution
-  attr_accessor :interpreter, :code, :name, :timeout
-  attr_writer :value, :weight
-
-  INTERPRETER = Facter::Util::Config.is_windows? ? "cmd.exe" : "/bin/sh"
+  # @api private
+  attr_accessor :code
+  attr_writer :value
 
-  # Returns the locations to be searched when looking for a binary. This
-  # is currently determined by the +PATH+ environment variable plus
-  # <tt>/sbin</tt> and <tt>/usr/sbin</tt> when run on unix
-  def self.search_paths
-    if Facter::Util::Config.is_windows?
-      ENV['PATH'].split(File::PATH_SEPARATOR)
-    else
-      # Make sure facter is usable even for non-root users. Most commands
-      # in /sbin (like ifconfig) can be run as non priviledged users as
-      # long as they do not modify anything - which we do not do with facter
-      ENV['PATH'].split(File::PATH_SEPARATOR) + [ '/sbin', '/usr/sbin' ]
-    end
-  end
+  extend Facter::Core::Execution
 
-  # Determine the full path to a binary. If the supplied filename does not
-  # already describe an absolute path then different locations (determined
-  # by <tt>self.search_paths</tt>) will be searched for a match.
-  #
-  # Returns nil if no matching executable can be found otherwise returns
-  # the expanded pathname.
-  def self.which(bin)
-    if absolute_path?(bin)
-      return bin if File.executable?(bin)
-      if Facter::Util::Config.is_windows? and File.extname(bin).empty?
-        exts = ENV['PATHEXT']
-        exts = exts ? exts.split(File::PATH_SEPARATOR) : %w[.COM .EXE .BAT .CMD]
-        exts.each do |ext|
-          destext = bin + ext
-          if File.executable?(destext)
-            Facter.warnonce("Using Facter::Util::Resolution.which with an absolute path like #{bin} but no fileextension is deprecated. Please add the correct extension (#{ext})")
-            return destext
-          end
-        end
-      end
-    else
-      search_paths.each do |dir|
-        dest = File.join(dir, bin)
-        if Facter::Util::Config.is_windows?
-          dest.gsub!(File::SEPARATOR, File::ALT_SEPARATOR)
-          if File.extname(dest).empty?
-            exts = ENV['PATHEXT']
-            exts = exts ? exts.split(File::PATH_SEPARATOR) : %w[.COM .EXE .BAT .CMD]
-            exts.each do |ext|
-              destext = dest + ext
-              return destext if File.executable?(destext)
-            end
-          end
-        end
-        return dest if File.executable?(dest)
-      end
-    end
-    nil
+  class << self
+    # Expose command execution methods that were extracted into
+    # Facter::Util::Execution from Facter::Util::Resolution in Facter 2.0.0 for
+    # compatibility.
+    #
+    # @deprecated
+    public :search_paths, :which, :absolute_path?, :expand_command, :with_env, :exec
   end
 
-  # Determine in a platform-specific way whether a path is absolute. This
-  # defaults to the local platform if none is specified.
-  def self.absolute_path?(path, platform=nil)
-    # Escape once for the string literal, and once for the regex.
-    slash = '[\\\\/]'
-    name = '[^\\\\/]+'
-    regexes = {
-      :windows => %r!^(([A-Z]:#{slash})|(#{slash}#{slash}#{name}#{slash}#{name})|(#{slash}#{slash}\?#{slash}#{name}))!i,
-      :posix   => %r!^/!,
-    }
-    platform ||= Facter::Util::Config.is_windows? ? :windows : :posix
+  include Facter::Core::Resolvable
+  include Facter::Core::Suitable
 
-    !! (path =~ regexes[platform])
-  end
+  # @!attribute [rw] name
+  # The name of this resolution. The resolution name should be unique with
+  # respect to the given fact.
+  # @return [String]
+  # @api public
+  attr_accessor :name
 
-  # Expand the executable of a commandline to an absolute path. The executable
-  # is the first word of the commandline. If the executable contains spaces,
-  # it has be but in double quotes to be properly recognized.
-  #
-  # Returns the commandline with the expanded binary or nil if the binary
-  # can't be found. If the path to the binary contains quotes, the whole binary
-  # is put in quotes.
-  def self.expand_command(command)
-    if match = /^"(.+?)"(?:\s+(.*))?/.match(command)
-      exe, arguments = match.captures
-      exe = which(exe) and [ "\"#{exe}\"", arguments ].compact.join(" ")
-    elsif match = /^'(.+?)'(?:\s+(.*))?/.match(command) and not Facter::Util::Config.is_windows?
-      exe, arguments = match.captures
-      exe = which(exe) and [ "'#{exe}'", arguments ].compact.join(" ")
-    else
-      exe, arguments = command.split(/ /,2)
-      if exe = which(exe)
-        # the binary was not quoted which means it contains no spaces. But the
-        # full path to the binary may do so.
-        exe = "\"#{exe}\"" if exe =~ /\s/ and Facter::Util::Config.is_windows?
-        exe = "'#{exe}'" if exe =~ /\s/ and not Facter::Util::Config.is_windows?
-        [ exe, arguments ].compact.join(" ")
-      end
-    end
-  end
+  # @!attribute [r] fact
+  # @return [Facter::Util::Fact]
+  # @api private
+  attr_reader :fact
 
+  # Create a new resolution mechanism.
   #
-  # Call this method with a block of code for which you would like to temporarily modify
-  # one or more environment variables; the specified values will be set for the duration
-  # of your block, after which the original values (if any) will be restored.
+  # @param name [String] The name of the resolution.
+  # @return [void]
   #
-  # [values] a Hash containing the key/value pairs of any environment variables that you
-  # would like to temporarily override
-  def self.with_env(values)
-    old = {}
-    values.each do |var, value|
-      # save the old value if it exists
-      if old_val = ENV[var]
-        old[var] = old_val
-      end
-      # set the new (temporary) value for the environment variable
-      ENV[var] = value
-    end
-    # execute the caller's block, capture the return value
-    rv = yield
-  # use an ensure block to make absolutely sure we restore the variables
-  ensure
-    # restore the old values
-    values.each do |var, value|
-      if old.include?(var)
-        ENV[var] = old[var]
-      else
-        # if there was no old value, delete the key from the current environment variables hash
-        ENV.delete(var)
-      end
-    end
-    # return the captured return value
-    rv
+  # @api private
+  def initialize(name, fact)
+    @name = name
+    @fact = fact
+    @confines = []
+    @value = nil
+    @timeout = 0
+    @weight = nil
   end
 
-  # Execute a program and return the output of that program.
-  #
-  # Returns nil if the program can't be found, or if there is a problem
-  # executing the code.
+  # Evaluate the given block in the context of this resolution. If a block has
+  # already been evaluated emit a warning to that effect.
   #
-  def self.exec(code, interpreter = nil)
-    Facter.warnonce "The interpreter parameter to 'exec' is deprecated and will be removed in a future version." if interpreter
+  # @return [void]
+  def evaluate(&block)
+    if @last_evaluated
+      msg = "Already evaluated #{@name}"
+      msg << " at #{@last_evaluated}" if msg.is_a? String
+      msg << ", reevaluating anyways"
+      Facter.warn msg
+    end
 
-    ## Set LANG to force i18n to C for the duration of this exec; this ensures that any code that parses the
-    ## output of the command can expect it to be in a consistent / predictable format / locale
-    with_env "LANG" => "C" do
-      
-      if expanded_code = expand_command(code)
-        # if we can find the binary, we'll run the command with the expanded path to the binary
-        code = expanded_code
-      else
-        # if we cannot find the binary return nil on posix. On windows we'll still try to run the
-        # command in case it is a shell-builtin. In case it is not, windows will raise Errno::ENOENT
-        return nil unless Facter::Util::Config.is_windows?
-        return nil if absolute_path?(code)
-      end
-      
-      out = nil
+    instance_eval(&block)
 
-      begin
-        out = %x{#{code}}.chomp
-        Facter.warnonce "Using Facter::Util::Resolution.exec with a shell built-in is deprecated. Most built-ins can be replaced with native ruby commands. If you really have to run a built-in, pass \"cmd /c your_builtin\" as a command (command responsible for this message was \"#{code}\")" unless expanded_code
-      rescue Errno::ENOENT => detail
-        # command not found on Windows
-        return nil
-      rescue => detail
-        Facter.warn(detail)
-        return nil
-      end
-      
-      if out == ""
-        return nil
-      else
-        return out
-      end
+    # Ruby 1.9+ provides the source location of procs which can provide useful
+    # debugging information if a resolution is being evaluated twice. Since 1.8
+    # doesn't support this we opportunistically provide this information.
+    if block.respond_to? :source_location
+      @last_evaluated = block.source_location.join(':')
+    else
+      @last_evaluated = true
     end
   end
 
-  # Add a new confine to the resolution mechanism.
-  def confine(confines)
-    confines.each do |fact, values|
-      @confines.push Facter::Util::Confine.new(fact, *values)
+  def set_options(options)
+    if options[:name]
+      @name = options.delete(:name)
     end
-  end
-
-  def has_weight(weight)
-    @weight = weight
-  end
 
-  # Create a new resolution mechanism.
-  def initialize(name)
-    @name = name
-    @confines = []
-    @value = nil
-    @timeout = 0
-    @weight = nil
-  end
+    if options.has_key?(:value)
+      @value = options.delete(:value)
+    end
 
-  # Return the importance of this resolution.
-  def weight
-    if @weight
-      @weight
-    else
-      @confines.length
+    if options.has_key?(:timeout)
+      @timeout = options.delete(:timeout)
     end
-  end
 
-  # We need this as a getter for 'timeout', because some versions
-  # of ruby seem to already have a 'timeout' method and we can't
-  # seem to override the instance methods, somehow.
-  def limit
-    @timeout
-  end
+    if options.has_key?(:weight)
+      @weight = options.delete(:weight)
+    end
 
-  # Set our code for returning a value.
-  def setcode(string = nil, interp = nil, &block)
-    Facter.warnonce "The interpreter parameter to 'setcode' is deprecated and will be removed in a future version." if interp
-    if string
-      @code = string
-      @interpreter = interp || INTERPRETER
-    else
-      unless block_given?
-        raise ArgumentError, "You must pass either code or a block"
-      end
-      @code = block
+    if not options.keys.empty?
+      raise ArgumentError, "Invalid resolution options #{options.keys.inspect}"
     end
   end
 
-  ##
-  # on_flush accepts a block and executes the block when the resolution's value
-  # is flushed.  This makes it possible to model a single, expensive system
-  # call inside of a Ruby object and then define multiple dynamic facts which
-  # resolve by sending messages to the model instance.  If one of the dynamic
-  # facts is flushed then it can, in turn, flush the data stored in the model
-  # instance to keep all of the dynamic facts in sync without making multiple,
-  # expensive, system calls.
-  #
-  # Please see the Solaris zones fact for an example of how this feature may be
-  # used.
+  # Sets the code block or external program that will be evaluated to
+  # get the value of the fact.
   #
-  # @see Facter::Util::Fact#flush
-  # @see Facter::Util::Resolution#flush
+  # @return [void]
   #
-  # @api public
-  def on_flush(&block)
-    @on_flush_block = block
-  end
-
-  ##
-  # flush executes the block, if any, stored by the {on_flush} method
+  # @overload setcode(string)
+  #   Sets an external program to call to get the value of the resolution
+  #   @param [String] string the external program to run to get the
+  #     value
   #
-  # @see Facter::Util::Fact#flush
-  # @see Facter::Util::Resolution#on_flush
+  # @overload setcode(&block)
+  #   Sets the resolution's value by evaluating a block at runtime
+  #   @param [Proc] block The block to determine the resolution's value.
+  #     This block is run when the fact is evaluated. Errors raised from
+  #     inside the block are rescued and printed to stderr.
   #
-  # @api private
-  def flush
-    @on_flush_block.call if @on_flush_block
-  end
-
-  def interpreter
-    Facter.warnonce "The 'Facter::Util::Resolution.interpreter' method is deprecated and will be removed in a future version."
-    @interpreter
-  end
-
-  def interpreter=(interp)
-    Facter.warnonce "The 'Facter::Util::Resolution.interpreter=' method is deprecated and will be removed in a future version."
-    @interpreter = interp
-  end
-
-  # Is this resolution mechanism suitable on the system in question?
-  def suitable?
-    unless defined? @suitable
-      @suitable = ! @confines.detect { |confine| ! confine.true? }
+  # @api public
+  def setcode(string = nil, &block)
+    if string
+      @code = Proc.new do
+        output = Facter::Core::Execution.exec(string)
+        output.empty? ? nil : output
+      end
+    elsif block_given?
+      @code = block
+    else
+      raise ArgumentError, "You must pass either code or a block"
     end
-
-    return @suitable
-  end
-
-  def to_s
-    return self.value()
   end
 
-  # How we get a value for our resolution mechanism.
-  def value
-    return @value if @value
-    result = nil
-    return result if @code == nil
+  private
 
-    starttime = Time.now.to_f
-
-    begin
-      Timeout.timeout(limit) do
-        if @code.is_a?(Proc)
-          result = @code.call()
-        else
-          result = Facter::Util::Resolution.exec(@code)
-        end
-      end
-    rescue Timeout::Error => detail
-      Facter.warn "Timed out seeking value for %s" % self.name
-
-      # This call avoids zombies -- basically, create a thread that will
-      # dezombify all of the child processes that we're ignoring because
-      # of the timeout.
-      Thread.new { Process.waitall }
-      return nil
-    rescue => details
-      Facter.warn "Could not retrieve %s: %s" % [self.name, details]
-      return nil
+  def resolve_value
+    if @value
+      @value
+    elsif @code.nil?
+      nil
+    elsif @code
+      @code.call()
     end
-
-    finishtime = Time.now.to_f
-    ms = (finishtime - starttime) * 1000
-    Facter.show_time "#{self.name}: #{"%.2f" % ms}ms"
-
-    return nil if result == ""
-    return result
   end
 end