facter 1.6.18 → 1.7.0.rc1

data/lib/facter/util/cfpropertylist/lib/rbCFPlistError.rb

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+#
+# Exceptions used:
+# CFPlistError:: General base exception
+# CFFormatError:: Format error
+# CFTypeError:: Type error
+#
+# Easy and simple :-)
+#
+# Author::    Christian Kruse (mailto:cjk@wwwtech.de)
+# Copyright:: Copyright (c) 2010
+# License::   MIT License
+
+# general plist error. All exceptions thrown are derived from this class.
+class CFPlistError < Exception
+end
+
+# Exception thrown when format errors occur
+class CFFormatError < CFPlistError
+end
+
+# Exception thrown when type errors occur
+class CFTypeError < CFPlistError
+end
+
+# eof

data/lib/facter/util/cfpropertylist/lib/rbCFPropertyList.rb

@@ -0,0 +1,402 @@
+# -*- coding: utf-8 -*-
+
+require 'kconv'
+require 'date'
+require 'time'
+
+#
+# Facter::Util::CFPropertyList implementation
+#
+# class to read, manipulate and write both XML and binary property list
+# files (plist(5)) as defined by Apple. Have a look at Facter::Util::CFPropertyList::List
+# for more documentation.
+#
+# == Example
+#   require 'cfpropertylist'
+#
+#   # create a arbitrary data structure of basic data types
+#   data = {
+#     'name' => 'John Doe',
+#     'missing' => true,
+#     'last_seen' => Time.now,
+#     'friends' => ['Jane Doe','Julian Doe'],
+#     'likes' => {
+#       'me' => false
+#     }
+#   }
+#
+#   # create Facter::Util::CFPropertyList::List object
+#   plist = Facter::Util::CFPropertyList::List.new
+#
+#   # call Facter::Util::CFPropertyList.guess() to create corresponding CFType values
+#   # pass in optional :convert_unknown_to_string => true to convert things like symbols into strings.
+#   plist.value = Facter::Util::CFPropertyList.guess(data)
+#
+#   # write plist to file
+#   plist.save("example.plist", Facter::Util::CFPropertyList::List::FORMAT_BINARY)
+#
+#   # … later, read it again
+#   plist = Facter::Util::CFPropertyList::List.new(:file => "example.plist")
+#   data = Facter::Util::CFPropertyList.native_types(plist.value)
+#
+# Author::    Christian Kruse (mailto:cjk@wwwtech.de)
+# Copyright:: Copyright (c) 2010
+# License::   MIT License
+module Facter::Util::CFPropertyList
+  # interface class for PList parsers
+  class ParserInterface
+    # load a plist
+    def load(opts={})
+      return ""
+    end
+
+    # convert a plist to string
+    def to_str(opts={})
+      return true
+    end
+  end
+
+  class XMLParserInterface < ParserInterface
+    def new_node(name)
+    end
+
+    def new_text(val)
+    end
+
+    def append_node(parent, child)
+    end
+  end
+end
+
+class String
+  unless("".respond_to?(:blob) && "".respond_to?(:blob=)) then
+    # The blob status of this string (to set to true if a binary string)
+    attr_accessor :blob
+  end
+
+  unless("".respond_to?(:blob?)) then
+    # Returns whether or not +str+ is a blob.
+    # @return [true,false] If true, this string contains binary data. If false, its a regular string
+    def blob?
+      blob
+    end
+  end
+
+  unless("".respond_to?(:bytesize)) then
+    def bytesize
+      self.length
+    end
+  end
+end
+
+dirname = File.dirname(__FILE__)
+require dirname + '/rbCFPlistError.rb'
+require dirname + '/rbCFTypes.rb'
+require dirname + '/rbBinaryCFPropertyList.rb'
+
+require 'iconv' unless "".respond_to?("encode")
+
+begin
+  Enumerable::Enumerator.new([])
+rescue NameError => e
+  module Enumerable
+    class Enumerator
+    end
+  end
+end
+
+begin
+  require dirname + '/rbLibXMLParser.rb'
+  try_nokogiri = false
+rescue LoadError => e
+  try_nokogiri = true
+end
+
+if try_nokogiri then
+  begin
+    require dirname + '/rbNokogiriParser.rb'
+  rescue LoadError => e
+    require dirname + '/rbREXMLParser.rb'
+  end
+end
+
+
+module Facter::Util::CFPropertyList
+  # Create CFType hierarchy by guessing the correct CFType, e.g.
+  #
+  #  x = {
+  #    'a' => ['b','c','d']
+  #  }
+  #  cftypes = Facter::Util::CFPropertyList.guess(x)
+  #
+  # pass optional options hash. Only possible value actually:
+  # +convert_unknown_to_string+::   Convert unknown objects to string calling to_str()
+  # +converter_method+::    Convert unknown objects to known objects calling +method_name+
+  #
+  #  cftypes = Facter::Util::CFPropertyList.guess(x,:convert_unknown_to_string => true,:converter_method => :to_hash, :converter_with_opts => true)
+  def guess(object, options = {})
+    case object
+    when Fixnum, Integer       then CFInteger.new(object)
+    when Float                 then CFReal.new(object)
+    when TrueClass, FalseClass then CFBoolean.new(object)
+
+    when String
+      object.blob? ? CFData.new(object, CFData::DATA_RAW) : CFString.new(object)
+
+    when Time, DateTime, Date  then CFDate.new(object)
+
+    when Array, Enumerator, Enumerable::Enumerator
+      ary = Array.new
+      object.each do |o|
+        ary.push Facter::Util::CFPropertyList.guess(o, options)
+      end
+      CFArray.new(ary)
+
+    when Hash
+      hsh = Hash.new
+      object.each_pair do |k,v|
+        k = k.to_s if k.is_a?(Symbol)
+        hsh[k] = Facter::Util::CFPropertyList.guess(v, options)
+      end
+      CFDictionary.new(hsh)
+    else
+      case
+      when Object.const_defined?('BigDecimal') && object.is_a?(BigDecimal)
+        CFReal.new(object)
+      when object.respond_to?(:read)
+        CFData.new(object.read(), CFData::DATA_RAW)
+      when options[:converter_method] && object.respond_to?(options[:converter_method])
+        if options[:converter_with_opts]
+          Facter::Util::CFPropertyList.guess(object.send(options[:converter_method],options),options)
+        else
+          Facter::Util::CFPropertyList.guess(object.send(options[:converter_method]),options)
+        end
+      when options[:convert_unknown_to_string]
+        CFString.new(object.to_s)
+      else
+        raise CFTypeError.new("Unknown class #{object.class.to_s}. Try using :convert_unknown_to_string if you want to use unknown object types!")
+      end
+    end
+  end
+
+  # Converts a CFType hiercharchy to native Ruby types
+  def native_types(object,keys_as_symbols=false)
+    return if object.nil?
+
+    if(object.is_a?(CFDate) || object.is_a?(CFString) || object.is_a?(CFInteger) || object.is_a?(CFReal) || object.is_a?(CFBoolean)) then
+      return object.value
+    elsif(object.is_a?(CFData)) then
+      return object.decoded_value
+    elsif(object.is_a?(CFArray)) then
+      ary = []
+      object.value.each do
+        |v|
+        ary.push Facter::Util::CFPropertyList.native_types(v)
+      end
+
+      return ary
+    elsif(object.is_a?(CFDictionary)) then
+      hsh = {}
+      object.value.each_pair do
+        |k,v|
+        k = k.to_sym if keys_as_symbols
+        hsh[k] = Facter::Util::CFPropertyList.native_types(v)
+      end
+
+      return hsh
+    end
+  end
+
+  module_function :guess, :native_types
+
+  # Class representing a Facter::Util::CFPropertyList. Instanciate with #new
+  class List
+    # Format constant for binary format
+    FORMAT_BINARY = 1
+
+    # Format constant for XML format
+    FORMAT_XML = 2
+
+    # Format constant for automatic format recognizing
+    FORMAT_AUTO = 0
+
+    @@parsers = [Binary,XML]
+
+    # Path of PropertyList
+    attr_accessor :filename
+    # Path of PropertyList
+    attr_accessor :format
+    # the root value in the plist file
+    attr_accessor :value
+
+    # initialize a new Facter::Util::CFPropertyList, arguments are:
+    #
+    # :file:: Parse a file
+    # :format:: Format is one of FORMAT_BINARY or FORMAT_XML. Defaults to FORMAT_AUTO
+    # :data:: Parse a string
+    #
+    # All arguments are optional
+    def initialize(opts={})
+      @filename = opts[:file]
+      @format = opts[:format] || FORMAT_AUTO
+      @data = opts[:data]
+
+      load(@filename) unless @filename.nil?
+      load_str(@data) unless @data.nil?
+    end
+
+    # Load an XML PropertyList
+    # filename = nil:: The filename to read from; if nil, read from the file defined by instance variable +filename+
+    def load_xml(filename=nil)
+      load(filename,List::FORMAT_XML)
+    end
+
+    # read a binary plist file
+    # filename = nil:: The filename to read from; if nil, read from the file defined by instance variable +filename+
+    def load_binary(filename=nil)
+      load(filename,List::FORMAT_BINARY)
+    end
+
+    # load a plist from a XML string
+    # str:: The string containing the plist
+    def load_xml_str(str=nil)
+      load_str(str,List::FORMAT_XML)
+    end
+
+    # load a plist from a binary string
+    # str:: The string containing the plist
+    def load_binary_str(str=nil)
+      load_str(str,List::FORMAT_BINARY)
+    end
+
+    # load a plist from a string
+    # str = nil:: The string containing the plist
+    # format = nil:: The format of the plist
+    def load_str(str=nil,format=nil)
+      str = @data if str.nil?
+      format = @format if format.nil?
+
+      @value = {}
+      case format
+      when List::FORMAT_BINARY, List::FORMAT_XML then
+        prsr = @@parsers[format-1].new
+        @value = prsr.load({:data => str})
+
+      when List::FORMAT_AUTO then # what we now do is ugly, but neccessary to recognize the file format
+        filetype = str[0..5]
+        version = str[6..7]
+
+        prsr = nil
+        if filetype == "bplist" then
+          raise CFFormatError.new("Wong file version #{version}") unless version == "00"
+          prsr = Binary.new
+        else
+          prsr = XML.new
+        end
+
+        @value = prsr.load({:data => str})
+      end
+    end
+
+    # Read a plist file
+    # file = nil:: The filename of the file to read. If nil, use +filename+ instance variable
+    # format = nil:: The format of the plist file. Auto-detect if nil
+    def load(file=nil,format=nil)
+      file = @filename if file.nil?
+      format = @format if format.nil?
+      @value = {}
+
+      raise IOError.new("File #{file} not readable!") unless File.readable? file
+
+      case format
+      when List::FORMAT_BINARY, List::FORMAT_XML then
+        prsr = @@parsers[format-1].new
+        @value = prsr.load({:file => file})
+
+      when List::FORMAT_AUTO then # what we now do is ugly, but neccessary to recognize the file format
+        magic_number = IO.read(file,8)
+        filetype = magic_number[0..5]
+        version = magic_number[6..7]
+
+        prsr = nil
+        if filetype == "bplist" then
+          raise CFFormatError.new("Wong file version #{version}") unless version == "00"
+          prsr = Binary.new
+        else
+          prsr = XML.new
+        end
+
+        @value = prsr.load({:file => file})
+      end
+    end
+
+    # Serialize Facter::Util::CFPropertyList object to specified format and write it to file
+    # file = nil:: The filename of the file to write to. Uses +filename+ instance variable if nil
+    # format = nil:: The format to save in. Uses +format+ instance variable if nil
+    def save(file=nil,format=nil,opts={})
+      format = @format if format.nil?
+      file = @filename if file.nil?
+
+      raise CFFormatError.new("Format #{format} not supported, use List::FORMAT_BINARY or List::FORMAT_XML") if format != FORMAT_BINARY && format != FORMAT_XML
+
+      if(!File.exists?(file)) then
+        raise IOError.new("File #{file} not writable!") unless File.writable?(File.dirname(file))
+      elsif(!File.writable?(file)) then
+        raise IOError.new("File #{file} not writable!")
+      end
+
+      opts[:root] = @value
+      prsr = @@parsers[format-1].new
+      content = prsr.to_str(opts)
+
+      File.open(file, 'wb') {
+        |fd|
+        fd.write content
+      }
+    end
+
+    # convert plist to string
+    # format = List::FORMAT_BINARY:: The format to save the plist
+    # opts={}:: Pass parser options
+    def to_str(format=List::FORMAT_BINARY,opts={})
+      prsr = @@parsers[format-1].new
+      opts[:root] = @value
+      return prsr.to_str(opts)
+    end
+  end
+end
+
+class Array
+  # convert an array to plist format
+  def to_plist(options={})
+    options[:plist_format] ||= Facter::Util::CFPropertyList::List::FORMAT_BINARY
+
+    plist = Facter::Util::CFPropertyList::List.new
+    plist.value = Facter::Util::CFPropertyList.guess(self, options)
+    plist.to_str(options[:plist_format])
+  end
+end
+
+class Enumerator
+  # convert an array to plist format
+  def to_plist(options={})
+    options[:plist_format] ||= Facter::Util::CFPropertyList::List::FORMAT_BINARY
+
+    plist = Facter::Util::CFPropertyList::List.new
+    plist.value = Facter::Util::CFPropertyList.guess(self, options)
+    plist.to_str(options[:plist_format])
+  end
+end
+
+class Hash
+  # convert a hash to plist format
+  def to_plist(options={})
+    options[:plist_format] ||= Facter::Util::CFPropertyList::List::FORMAT_BINARY
+
+    plist = Facter::Util::CFPropertyList::List.new
+    plist.value = Facter::Util::CFPropertyList.guess(self, options)
+    plist.to_str(options[:plist_format])
+  end
+end
+
+# eof

data/lib/facter/util/cfpropertylist/lib/rbCFTypes.rb

@@ -0,0 +1,244 @@
+# -*- coding: utf-8 -*-
+#
+# CFTypes, e.g. CFString, CFInteger
+# needed to create unambiguous plists
+#
+# Author::    Christian Kruse (mailto:cjk@wwwtech.de)
+# Copyright:: Copyright (c) 2009
+# License::   MIT License
+
+require 'base64'
+
+module Facter::Util::CFPropertyList
+  # This class defines the base class for all CFType classes
+  #
+  class CFType
+    # value of the type
+    attr_accessor :value
+
+    def initialize(value=nil)
+      @value = value
+    end
+
+    def to_xml(parser)
+    end
+
+    def to_binary(bplist) end
+  end
+
+  # This class holds string values, both, UTF-8 and UTF-16BE
+  # It will convert the value to UTF-16BE if necessary (i.e. if non-ascii char contained)
+  class CFString < CFType
+    # convert to XML
+    def to_xml(parser)
+      n = parser.new_node('string')
+      n = parser.append_node(n, parser.new_text(@value)) unless @value.nil?
+      n
+    end
+
+    # convert to binary
+    def to_binary(bplist)
+      bplist.string_to_binary(@value);
+    end
+  end
+
+  # This class holds integer/fixnum values
+  class CFInteger < CFType
+    # convert to XML
+    def to_xml(parser)
+      n = parser.new_node('integer')
+      n = parser.append_node(n, parser.new_text(@value.to_s))
+      n
+    end
+
+    # convert to binary
+    def to_binary(bplist)
+      bplist.num_to_binary(self)
+    end
+  end
+
+  # This class holds float values
+  class CFReal < CFType
+    # convert to XML
+    def to_xml(parser)
+      n = parser.new_node('real')
+      n = parser.append_node(n, parser.new_text(@value.to_s))
+      n
+    end
+
+    # convert to binary
+    def to_binary(bplist)
+      bplist.num_to_binary(self)
+    end
+  end
+
+  # This class holds Time values. While Apple uses seconds since 2001,
+  # the rest of the world uses seconds since 1970. So if you access value
+  # directly, you get the Time class. If you access via get_value you either
+  # geht the timestamp or the Apple timestamp
+  class CFDate < CFType
+    TIMESTAMP_APPLE = 0
+    TIMESTAMP_UNIX  = 1;
+    DATE_DIFF_APPLE_UNIX = 978307200
+
+    # create a XML date strimg from a time object
+    def CFDate.date_string(val)
+      # 2009-05-13T20:23:43Z
+      val.getutc.strftime("%Y-%m-%dT%H:%M:%SZ")
+    end
+
+    # parse a XML date string
+    def CFDate.parse_date(val)
+      # 2009-05-13T20:23:43Z
+      val =~ %r{^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})Z$}
+      year,month,day,hour,min,sec = $1, $2, $3, $4, $5, $6
+      return Time.utc(year,month,day,hour,min,sec).getlocal
+    end
+
+    # set value to defined state
+    def initialize(value = nil,format=CFDate::TIMESTAMP_UNIX)
+      if(value.is_a?(Time) || value.nil?) then
+        @value = value.nil? ? Time.now : value
+      elsif value.instance_of? Date
+        @value = Time.utc(value.year, value.month, value.day, 0, 0, 0)
+      elsif value.instance_of? DateTime
+        @value = value.to_time.utc
+      else
+        set_value(value,format)
+      end
+    end
+
+    # set value with timestamp, either Apple or UNIX
+    def set_value(value,format=CFDate::TIMESTAMP_UNIX)
+      if(format == CFDate::TIMESTAMP_UNIX) then
+        @value = Time.at(value)
+      else
+        @value = Time.at(value + CFDate::DATE_DIFF_APPLE_UNIX)
+      end
+    end
+
+    # get timestamp, either UNIX or Apple timestamp
+    def get_value(format=CFDate::TIMESTAMP_UNIX)
+      if(format == CFDate::TIMESTAMP_UNIX) then
+        @value.to_i
+      else
+        @value.to_f - CFDate::DATE_DIFF_APPLE_UNIX
+      end
+    end
+
+    # convert to XML
+    def to_xml(parser)
+      n = parser.new_node('date')
+      n = parser.append_node(n, parser.new_text(CFDate::date_string(@value)))
+      n
+    end
+
+    # convert to binary
+    def to_binary(bplist)
+      bplist.date_to_binary(@value)
+    end
+  end
+
+  # This class contains a boolean value
+  class CFBoolean < CFType
+    # convert to XML
+    def to_xml(parser)
+      parser.new_node(@value ? 'true' : 'false')
+    end
+
+    # convert to binary
+    def to_binary(bplist)
+      bplist.bool_to_binary(@value);
+    end
+  end
+
+  # This class contains binary data values
+  class CFData < CFType
+    # Base64 encoded data
+    DATA_BASE64 = 0
+    # Raw data
+    DATA_RAW = 1
+
+    # set value to defined state, either base64 encoded or raw
+    def initialize(value=nil,format=DATA_BASE64)
+      if(format == DATA_RAW)
+        @raw_value = value
+        @raw_value.blob = true
+      else
+        @value = value
+      end
+    end
+
+    # get base64 encoded value
+    def encoded_value
+      @value ||= "\n#{Base64.encode64(@raw_value).gsub("\n", '').scan(/.{1,76}/).join("\n")}\n"
+    end
+
+    # get base64 decoded value
+    def decoded_value
+      @raw_value ||= String.new(Base64.decode64(@value))
+      @raw_value.blob = true
+      @raw_value
+    end
+
+    # convert to XML
+    def to_xml(parser)
+      n = parser.new_node('data')
+      n = parser.append_node(n, parser.new_text(encoded_value()))
+      n
+    end
+
+    # convert to binary
+    def to_binary(bplist)
+      bplist.data_to_binary(decoded_value())
+    end
+  end
+
+  # This class contains an array of values
+  class CFArray < CFType
+    # create a new array CFType
+    def initialize(val=[])
+      @value = val
+    end
+
+    # convert to XML
+    def to_xml(parser)
+      n = parser.new_node('array')
+      @value.each do |v|
+        n = parser.append_node(n, v.to_xml(parser))
+      end
+      n
+    end
+
+    # convert to binary
+    def to_binary(bplist)
+      bplist.array_to_binary(self)
+    end
+  end
+
+  # this class contains a hash of values
+  class CFDictionary < CFType
+    # Create new CFDictonary type.
+    def initialize(value={})
+      @value = value
+    end
+
+    # convert to XML
+    def to_xml(parser)
+      n = parser.new_node('dict')
+      @value.each_pair do |key, value|
+        k = parser.append_node(parser.new_node('key'), parser.new_text(key.to_s))
+        n = parser.append_node(n, k)
+        n = parser.append_node(n, value.to_xml(parser))
+      end
+      n
+    end
+
+    # convert to binary
+    def to_binary(bplist)
+      bplist.dict_to_binary(self)
+    end
+  end
+end
+
+# eof