facter 2.0.1.rc1-x86-mingw32

data/lib/facter/util/monkey_patches.rb

@@ -0,0 +1,8 @@
+# This provides an alias for RbConfig to Config for versions of Ruby older then
+# 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'
+
+unless defined? ::RbConfig
+  ::RbConfig = ::Config
+end

data/lib/facter/util/netmask.rb

@@ -0,0 +1,40 @@
+module Facter::NetMask
+  def self.get_netmask
+    netmask = nil;
+    ipregex = %r{(\d{1,3}\.){3}\d{1,3}}
+
+    ops = nil
+    case Facter.value(:kernel)
+    when 'Linux'
+      ops = {
+        :ifconfig_opts => ['2>/dev/null'],
+        :regex => %r{#{Facter.value(:ipaddress)}.*?(?:Mask:|netmask)\s*(#{ipregex})}x,
+        :munge => nil,
+      }
+    when 'SunOS'
+      ops = {
+        :ifconfig_opts => ['-a'],
+        :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.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
+
+    String(Facter::Util::IP.exec_ifconfig(ops[:ifconfig_opts])).split(/\n/).collect do |line|
+      matches = line.match(ops[:regex])
+      if !matches.nil?
+        if ops[:munge].nil?
+          netmask = matches[1]
+        else
+          netmask = ops[:munge].call(matches[1])
+        end
+      end
+    end
+    netmask
+  end
+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

@@ -0,0 +1,12 @@
+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
+  end
+end

data/lib/facter/util/parser.rb

@@ -0,0 +1,158 @@
+# This class acts as the factory and parent class for parsed
+# facts such as scripts, text, json and yaml files.
+#
+# Parsers must subclass this class and provide their own #results method.
+require 'facter'
+require 'yaml'
+
+module Facter::Util::Parser
+  @parsers = []
+
+  # For support mutliple extensions you can pass an array of extensions as
+  # +ext+.
+  def self.extension_matches?(filename, ext)
+    extension = case ext
+    when String
+      ext.downcase
+    when Enumerable
+      ext.collect {|x| x.downcase }
+    end
+    [extension].flatten.to_a.include?(file_extension(filename).downcase)
+  end
+
+  def self.file_extension(filename)
+    File.extname(filename).sub(".", '')
+  end
+
+  def self.register(klass, &suitable)
+    @parsers << [klass, suitable]
+  end
+
+  def self.parser_for(filename)
+    registration = @parsers.detect { |k| k[1].call(filename) }
+
+    if registration.nil?
+      NothingParser.new
+    else
+      registration[0].new(filename)
+    end
+  end
+
+  class Base
+    attr_reader :filename
+
+    def initialize(filename, content = nil)
+      @filename = filename
+      @content  = content
+    end
+
+    def content
+      @content ||= File.read(filename)
+    end
+
+    # results on the base class is really meant to be just an exception handler
+    # wrapper.
+    def results
+      parse_results
+    rescue Exception => detail
+      Facter.log_exception(detail, "Failed to handle #{filename} as #{self.class} facts: #{detail.message}")
+      nil
+    end
+
+    def parse_results
+      raise ArgumentError, "Subclasses must respond to parse_results"
+    end
+  end
+
+  module KeyValuePairOutputFormat
+    def self.parse(output)
+      return {} if output.nil?
+
+      result = {}
+      re = /^(.+?)=(.+)$/
+      output.each_line do |line|
+        if match_data = re.match(line.chomp)
+          result[match_data[1]] = match_data[2]
+        end
+      end
+      result
+    end
+  end
+
+  class YamlParser < Base
+    def parse_results
+      YAML.load(content)
+    end
+  end
+
+  register(YamlParser) do |filename|
+    extension_matches?(filename, "yaml")
+  end
+
+  class TextParser < Base
+    def parse_results
+      KeyValuePairOutputFormat.parse content
+    end
+  end
+
+  register(TextParser) do |filename|
+    extension_matches?(filename, "txt")
+  end
+
+  class JsonParser < Base
+    def parse_results
+      if Facter.json?
+        JSON.load(content)
+      else
+        Facter.warnonce "Cannot parse JSON data file #{filename} without the json library."
+        Facter.warnonce "Suggested next step is `gem install json` to install the json library."
+        nil
+      end
+    end
+  end
+
+  register(JsonParser) do |filename|
+    extension_matches?(filename, "json")
+  end
+
+  class ScriptParser < Base
+    def parse_results
+      KeyValuePairOutputFormat.parse Facter::Core::Execution.exec(quote(filename))
+    end
+
+    private
+
+    def quote(filename)
+      filename.index(' ') ? "\"#{filename}\"" : filename
+    end
+  end
+
+  register(ScriptParser) do |filename|
+    if Facter::Util::Config.is_windows?
+      extension_matches?(filename, %w{bat cmd com exe}) && File.file?(filename)
+    else
+      File.executable?(filename) && File.file?(filename) && ! extension_matches?(filename, %w{bat cmd com exe})
+    end
+  end
+
+  # Executes and parses the key value output of Powershell scripts
+  class PowershellParser < Base
+    # Returns a hash of facts from powershell output
+    def parse_results
+      shell_command = "powershell -NoProfile -NonInteractive -NoLogo -ExecutionPolicy Bypass -File \"#{filename}\""
+      KeyValuePairOutputFormat.parse Facter::Core::Execution.exec(shell_command)
+    end
+  end
+
+  register(PowershellParser) do |filename|
+    Facter::Util::Config.is_windows? && extension_matches?(filename, "ps1") && File.file?(filename)
+  end
+
+  # A parser that is used when there is no other parser that can handle the file
+  # The return from results indicates to the caller the file was not parsed correctly.
+  class NothingParser
+    def results
+      nil
+    end
+  end
+end

data/lib/facter/util/plist.rb

@@ -0,0 +1,24 @@
+#--
+##############################################################
+# Copyright 2006, Ben Bleything <ben@bleything.net> and      #
+# Patrick May <patrick@hexane.org>                           #
+#                                                            #
+# Distributed under the MIT license.                         #
+##############################################################
+#++
+# = Plist
+#
+# This is the main file for plist.  Everything interesting happens in Plist and Plist::Emit.
+
+require 'base64'
+require 'cgi'
+require 'stringio'
+
+require 'facter/util/plist/generator'
+require 'facter/util/plist/parser'
+
+module Plist
+  VERSION = '3.0.0'
+end
+
+# $Id: plist.rb 1781 2006-10-16 01:01:35Z luke $

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

@@ -0,0 +1,228 @@
+#--###########################################################
+# Copyright 2006, Ben Bleything <ben@bleything.net> and    #
+# Patrick May <patrick@hexane.org>               #
+#                              #
+# Distributed under the MIT license.             #
+##############################################################
+#++
+# See Plist::Emit.
+module Plist
+  # === Create a plist
+  # You can dump an object to a plist in one of two ways:
+  #
+  # * <tt>Plist::Emit.dump(obj)</tt>
+  # * <tt>obj.to_plist</tt>
+  #   * This requires that you mixin the <tt>Plist::Emit</tt> module, which is already done for +Array+ and +Hash+.
+  #
+  # The following Ruby classes are converted into native plist types:
+  #   Array, Bignum, Date, DateTime, Fixnum, Float, Hash, Integer, String, Symbol, Time, true, false
+  # * +Array+ and +Hash+ are both recursive; their elements will be converted into plist nodes inside the <array> and <dict> containers (respectively).
+  # * +IO+ (and its descendants) and +StringIO+ objects are read from and their contents placed in a <data> element.
+  # * User classes may implement +to_plist_node+ to dictate how they should be serialized; otherwise the object will be passed to <tt>Marshal.dump</tt> and the result placed in a <data> element.
+  #
+  # For detailed usage instructions, refer to USAGE[link:files/docs/USAGE.html] and the methods documented below.
+  module Emit
+    # Helper method for injecting into classes.  Calls <tt>Plist::Emit.dump</tt> with +self+.
+    def to_plist(envelope = true)
+      return Plist::Emit.dump(self, envelope)
+    end
+
+    # Helper method for injecting into classes.  Calls <tt>Plist::Emit.save_plist</tt> with +self+.
+    def save_plist(filename)
+      Plist::Emit.save_plist(self, filename)
+    end
+
+    # The following Ruby classes are converted into native plist types:
+    #   Array, Bignum, Date, DateTime, Fixnum, Float, Hash, Integer, String, Symbol, Time
+    #
+    # Write us (via RubyForge) if you think another class can be coerced safely into one of the expected plist classes.
+    #
+    # +IO+ and +StringIO+ objects are encoded and placed in <data> elements; other objects are <tt>Marshal.dump</tt>'ed unless they implement +to_plist_node+.
+    #
+    # The +envelope+ parameters dictates whether or not the resultant plist fragment is wrapped in the normal XML/plist header and footer.  Set it to false if you only want the fragment.
+    def self.dump(obj, envelope = true)
+      output = plist_node(obj)
+
+      output = wrap(output) if envelope
+
+      return output
+    end
+
+    # Writes the serialized object's plist to the specified filename.
+    def self.save_plist(obj, filename)
+      File.open(filename, 'wb') do |f|
+        f.write(Plist::Emit.dump(obj))
+      end
+    end
+
+    private
+    def self.plist_node(element)
+      output = ''
+
+      if element.respond_to? :to_plist_node
+        output << element.to_plist_node
+      else
+        case element
+        when Array
+          if element.empty?
+            output << "<array/>\n"
+          else
+            output << tag('array') {
+              element.collect {|e| plist_node(e)}
+            }
+          end
+        when Hash
+          if element.empty?
+            output << "<dict/>\n"
+          else
+            inner_tags = []
+
+            element.keys.sort.each do |k|
+              v = element[k]
+              inner_tags << tag('key', CGI::escapeHTML(k.to_s))
+              inner_tags << plist_node(v)
+            end
+
+            output << tag('dict') {
+              inner_tags
+            }
+          end
+        when true, false
+          output << "<#{element}/>\n"
+        when Time
+          output << tag('date', element.utc.strftime('%Y-%m-%dT%H:%M:%SZ'))
+        when Date # also catches DateTime
+          output << tag('date', element.strftime('%Y-%m-%dT%H:%M:%SZ'))
+        when String, Symbol, Fixnum, Bignum, Integer, Float
+          output << tag(element_type(element), CGI::escapeHTML(element.to_s))
+        when IO, StringIO
+          element.rewind
+          contents = element.read
+          # note that apple plists are wrapped at a different length then
+          # what ruby's base64 wraps by default.
+          # I used #encode64 instead of #b64encode (which allows a length arg)
+          # because b64encode is b0rked and ignores the length arg.
+          data = "\n"
+          Base64::encode64(contents).gsub(/\s+/, '').scan(/.{1,68}/o) { data << $& << "\n" }
+          output << tag('data', data)
+        else
+          output << comment( 'The <data> element below contains a Ruby object which has been serialized with Marshal.dump.' )
+          data = "\n"
+          Base64::encode64(Marshal.dump(element)).gsub(/\s+/, '').scan(/.{1,68}/o) { data << $& << "\n" }
+          output << tag('data', data )
+        end
+      end
+
+      return output
+    end
+
+    def self.comment(content)
+      return "<!-- #{content} -->\n"
+    end
+
+    def self.tag(type, contents = '', &block)
+      out = nil
+
+      if block_given?
+        out = IndentedString.new
+        out << "<#{type}>"
+        out.raise_indent
+
+        out << block.call
+
+        out.lower_indent
+        out << "</#{type}>"
+      else
+        out = "<#{type}>#{contents.to_s}</#{type}>\n"
+      end
+
+      return out.to_s
+    end
+
+    def self.wrap(contents)
+      output = ''
+
+      output << '<?xml version="1.0" encoding="UTF-8"?>' + "\n"
+      output << '<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">' + "\n"
+      output << '<plist version="1.0">' + "\n"
+
+      output << contents
+
+      output << '</plist>' + "\n"
+
+      return output
+    end
+
+    def self.element_type(item)
+      return case item
+      when String, Symbol;      'string'
+      when Fixnum, Bignum, Integer; 'integer'
+      when Float;           'real'
+      else
+        raise "Don't know about this data type... something must be wrong!"
+      end
+    end
+
+    private
+
+    class IndentedString #:nodoc:
+      attr_accessor :indent_string
+
+      @@indent_level = 0
+
+      def initialize(str = "\t")
+        @indent_string = str
+        @contents = ''
+      end
+
+      def to_s
+        return @contents
+      end
+
+      def raise_indent
+        @@indent_level += 1
+      end
+
+      def lower_indent
+        @@indent_level -= 1 if @@indent_level > 0
+      end
+
+      def <<(val)
+        if val.is_a? Array
+          val.each do |f|
+            self << f
+          end
+        else
+          # if it's already indented, don't bother indenting further
+          unless val =~ /\A#{@indent_string}/
+            indent = @indent_string * @@indent_level
+
+            @contents << val.gsub(/^/, indent)
+          else
+            @contents << val
+          end
+
+          # it already has a newline, don't add another
+          @contents << "\n" unless val =~ /\n$/
+        end
+      end
+    end
+  end
+end
+
+# we need to add this so sorting hash keys works properly
+class Symbol #:nodoc:
+  def <=> (other)
+    self.to_s <=> other.to_s
+  end
+end
+
+class Array #:nodoc:
+  include Plist::Emit
+end
+
+class Hash #:nodoc:
+  include Plist::Emit
+end
+
+# $Id: generator.rb 1781 2006-10-16 01:01:35Z luke $