CFPropertyList 2.0.14 → 3.0.0

data/lib/{rbCFPlistError.rb → cfpropertylist/rbCFPlistError.rb}

@@ -12,7 +12,7 @@
 # License::   MIT License
 
 # general plist error. All exceptions thrown are derived from this class.
-class CFPlistError < Exception
+class CFPlistError < StandardError
 end
 
 # Exception thrown when format errors occur

data/lib/{rbCFPropertyList.rb → cfpropertylist/rbCFPropertyList.rb}

@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 
-require 'libxml'
 require 'kconv'
 require 'date'
 require 'time'
@@ -44,6 +43,10 @@ require 'time'
 # Copyright:: Copyright (c) 2010
 # License::   MIT License
 module CFPropertyList
+  class << self
+    attr_accessor :xml_parser_interface
+  end
+
   # interface class for PList parsers
   class ParserInterface
     # load a plist
@@ -56,25 +59,15 @@ module CFPropertyList
       return true
     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
+  class XMLParserInterface < ParserInterface
+    def new_node(name)
+    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
+    def new_text(val)
     end
-  end
 
-  unless("".respond_to?(:bytesize)) then
-    def bytesize
-      self.length
+    def append_node(parent, child)
     end
   end
 end
@@ -82,10 +75,29 @@ end
 dirname = File.dirname(__FILE__)
 require dirname + '/rbCFPlistError.rb'
 require dirname + '/rbCFTypes.rb'
-require dirname + '/rbXMLCFPropertyList.rb'
 require dirname + '/rbBinaryCFPropertyList.rb'
+require dirname + '/rbPlainCFPropertyList.rb'
+
+begin
+  require dirname + '/rbLibXMLParser.rb'
+  temp = LibXML::XML::Parser::Options::NOBLANKS # check if we have a version with parser options
+  temp = false # avoid a warning
+  try_nokogiri = false
+  CFPropertyList.xml_parser_interface = CFPropertyList::LibXMLParser
+rescue LoadError, NameError
+  try_nokogiri = true
+end
+
+if try_nokogiri then
+  begin
+    require dirname + '/rbNokogiriParser.rb'
+    CFPropertyList.xml_parser_interface = CFPropertyList::NokogiriXMLParser
+  rescue LoadError
+    require dirname + '/rbREXMLParser.rb'
+    CFPropertyList.xml_parser_interface = CFPropertyList::ReXMLParser
+  end
+end
 
-require 'iconv' unless "".respond_to?("encode")
 
 module CFPropertyList
   # Create CFType hierarchy by guessing the correct CFType, e.g.
@@ -99,43 +111,59 @@ module CFPropertyList
   # +convert_unknown_to_string+::   Convert unknown objects to string calling to_str()
   # +converter_method+::    Convert unknown objects to known objects calling +method_name+
   #
-  #  cftypes = CFPropertyList.guess(x,:convert_unknown_to_string => true,:converter_method => :to_hash)
+  #  cftypes = CFPropertyList.guess(x,:convert_unknown_to_string => true,:converter_method => :to_hash, :converter_with_opts => true)
   def guess(object, options = {})
-    if(object.is_a?(Fixnum) || object.is_a?(Integer)) then
-      return CFInteger.new(object)
-    elsif(object.is_a?(Float) || (Object.const_defined?('BigDecimal') and object.is_a?(BigDecimal))) then
-      return CFReal.new(object)
-    elsif(object.is_a?(TrueClass) || object.is_a?(FalseClass)) then
-      return CFBoolean.new(object)
-    elsif(object.is_a?(String)) then
-      return object.blob? ? CFData.new(object, CFData::DATA_RAW) : CFString.new(object)
-    elsif(object.respond_to?(:read)) then
-      return CFData.new(object.read(), CFData::DATA_RAW)
-    elsif(object.is_a?(Time) || object.is_a?(DateTime) || object.is_a?(Date)) then
-      return CFDate.new(object)
-    elsif(object.is_a?(Array)) then
+    case object
+    when Integer               then CFInteger.new(object)
+    when UidFixnum             then CFUid.new(object)
+    when Float                 then CFReal.new(object)
+    when TrueClass, FalseClass then CFBoolean.new(object)
+
+    when Blob
+      CFData.new(object, CFData::DATA_RAW)
+
+    when String, Symbol
+      CFString.new(object.to_s)
+
+    when Time, DateTime, Date
+      CFDate.new(object)
+
+    when Array, Enumerator
       ary = Array.new
-      object.each do
-        |o|
+      object.each do |o|
         ary.push CFPropertyList.guess(o, options)
       end
+      CFArray.new(ary)
 
-      return CFArray.new(ary)
-    elsif(object.is_a?(Hash)) then
+    when Hash
       hsh = Hash.new
-      object.each_pair do
-        |k,v|
+      object.each_pair do |k,v|
         k = k.to_s if k.is_a?(Symbol)
         hsh[k] = CFPropertyList.guess(v, options)
       end
-
-      return CFDictionary.new(hsh)
-    elsif options[:converter_method] and object.respond_to?(options[:converter_method]) then
-      return CFPropertyList.guess(object.send(options[:converter_method]))
-    elsif options[:convert_unknown_to_string] then
-      return CFString.new(object.to_s)
+      CFDictionary.new(hsh)
     else
-      raise CFTypeError.new("Unknown class #{object.class.to_s}! Try using :convert_unknown_to_string if you want to use unknown object types!")
+      case
+      when Object.const_defined?('BigDecimal') && object.is_a?(BigDecimal)
+        CFReal.new(object)
+      when object.respond_to?(:read)
+        raw_data = object.read
+        # treat the data as a bytestring (ASCII-8BIT) if Ruby supports it.  Do this by forcing
+        # the encoding, on the assumption that the bytes were read correctly, and just tagged with
+        # an inappropriate encoding, rather than transcoding.
+        raw_data.force_encoding(Encoding::ASCII_8BIT) if raw_data.respond_to?(:force_encoding)
+        CFData.new(raw_data, CFData::DATA_RAW)
+      when options[:converter_method] && object.respond_to?(options[:converter_method])
+        if options[:converter_with_opts]
+          CFPropertyList.guess(object.send(options[:converter_method],options),options)
+        else
+          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
 
@@ -143,10 +171,10 @@ module CFPropertyList
   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
+    if(object.is_a?(CFDate) || object.is_a?(CFString) || object.is_a?(CFInteger) || object.is_a?(CFReal) || object.is_a?(CFBoolean)) || object.is_a?(CFUid) then
       return object.value
     elsif(object.is_a?(CFData)) then
-      return object.decoded_value
+      return CFPropertyList::Blob.new(object.decoded_value)
     elsif(object.is_a?(CFArray)) then
       ary = []
       object.value.each do
@@ -177,17 +205,22 @@ module CFPropertyList
     # Format constant for XML format
     FORMAT_XML = 2
 
+    # Format constant for the old plain format
+    FORMAT_PLAIN = 3
+
     # Format constant for automatic format recognizing
     FORMAT_AUTO = 0
 
-    @@parsers = [Binary,XML]
+    @@parsers = [Binary, CFPropertyList.xml_parser_interface, PlainParser]
 
     # Path of PropertyList
     attr_accessor :filename
-    # Path of PropertyList
+    # the original format of the PropertyList
     attr_accessor :format
     # the root value in the plist file
     attr_accessor :value
+    # default value for XML generation; if true generate formatted XML
+    attr_accessor :formatted
 
     # initialize a new CFPropertyList, arguments are:
     #
@@ -200,11 +233,22 @@ module CFPropertyList
       @filename = opts[:file]
       @format = opts[:format] || FORMAT_AUTO
       @data = opts[:data]
+      @formatted = opts[:formatted]
 
       load(@filename) unless @filename.nil?
       load_str(@data) unless @data.nil?
     end
 
+    # returns a list of registered parsers
+    def self.parsers
+      @@parsers
+    end
+
+    # set a list of parsers
+    def self.parsers=(val)
+      @@parsers = val
+    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)
@@ -217,6 +261,12 @@ module CFPropertyList
       load(filename,List::FORMAT_BINARY)
     end
 
+    # read a plain plist file
+    # filename = nil:: The filename to read from; if nil, read from the file defined by instance variable +filename+
+    def load_plain(filename=nil)
+      load(filename,List::FORMAT_PLAIN)
+    end
+
     # load a plist from a XML string
     # str:: The string containing the plist
     def load_xml_str(str=nil)
@@ -229,6 +279,12 @@ module CFPropertyList
       load_str(str,List::FORMAT_BINARY)
     end
 
+    # load a plist from a plain string
+    # str:: The string containing the plist
+    def load_plain_str(str=nil)
+      load_str(str,List::FORMAT_PLAIN)
+    end
+
     # load a plist from a string
     # str = nil:: The string containing the plist
     # format = nil:: The format of the plist
@@ -238,7 +294,7 @@ module CFPropertyList
 
       @value = {}
       case format
-      when List::FORMAT_BINARY, List::FORMAT_XML then
+      when List::FORMAT_BINARY, List::FORMAT_XML, List::FORMAT_PLAIN then
         prsr = @@parsers[format-1].new
         @value = prsr.load({:data => str})
 
@@ -247,11 +303,19 @@ module CFPropertyList
         version = str[6..7]
 
         prsr = nil
+
         if filetype == "bplist" then
-          raise CFFormatError.new("Wong file version #{version}") unless version == "00"
+          raise CFFormatError.new("Wrong file version #{version}") unless version == "00"
           prsr = Binary.new
+          @format = List::FORMAT_BINARY
         else
-          prsr = XML.new
+          if str =~ /^<(\?xml|!DOCTYPE|plist)/
+            prsr = CFPropertyList.xml_parser_interface.new
+            @format = List::FORMAT_XML
+          else
+            prsr = PlainParser.new
+            @format = List::FORMAT_PLAIN
+          end
         end
 
         @value = prsr.load({:data => str})
@@ -269,25 +333,35 @@ module CFPropertyList
       raise IOError.new("File #{file} not readable!") unless File.readable? file
 
       case format
-      when List::FORMAT_BINARY, List::FORMAT_XML then
+      when List::FORMAT_BINARY, List::FORMAT_XML, List::FORMAT_PLAIN 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)
+        magic_number = IO.read(file,12)
+        raise IOError.new("File #{file} is empty.") unless magic_number
         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"
+          raise CFFormatError.new("Wrong file version #{version}") unless version == "00"
           prsr = Binary.new
+          @format = List::FORMAT_BINARY
         else
-          prsr = XML.new
+          if magic_number =~ /^<(\?xml|!DOCTYPE|plist)/
+            prsr = CFPropertyList.xml_parser_interface.new
+            @format = List::FORMAT_XML
+          else
+            prsr = PlainParser.new
+            @format = List::FORMAT_PLAIN
+          end
         end
 
         @value = prsr.load({:file => file})
       end
+
+      raise CFFormatError.new("Invalid format or parser error!") if @value.nil?
     end
 
     # Serialize CFPropertyList object to specified format and write it to file
@@ -297,7 +371,9 @@ module CFPropertyList
       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 format != FORMAT_BINARY && format != FORMAT_XML && format != FORMAT_PLAIN
+        raise CFFormatError.new("Format #{format} not supported, use List::FORMAT_BINARY or List::FORMAT_XML")
+      end
 
       if(!File.exists?(file)) then
         raise IOError.new("File #{file} not writable!") unless File.writable?(File.dirname(file))
@@ -306,7 +382,10 @@ module CFPropertyList
       end
 
       opts[:root] = @value
+      opts[:formatted] = @formatted unless opts.has_key?(:formatted)
+
       prsr = @@parsers[format-1].new
+
       content = prsr.to_str(opts)
 
       File.open(file, 'wb') {
@@ -319,13 +398,21 @@ module CFPropertyList
     # format = List::FORMAT_BINARY:: The format to save the plist
     # opts={}:: Pass parser options
     def to_str(format=List::FORMAT_BINARY,opts={})
+      if format != FORMAT_BINARY && format != FORMAT_XML && format != FORMAT_PLAIN
+        raise CFFormatError.new("Format #{format} not supported, use List::FORMAT_BINARY or List::FORMAT_XML")
+      end
+
       prsr = @@parsers[format-1].new
+
       opts[:root] = @value
+      opts[:formatted] = @formatted unless opts.has_key?(:formatted)
+
       return prsr.to_str(opts)
     end
   end
 end
 
+
 class Array
   # convert an array to plist format
   def to_plist(options={})
@@ -333,7 +420,18 @@ class Array
 
     plist = CFPropertyList::List.new
     plist.value = CFPropertyList.guess(self, options)
-    plist.to_str(options[:plist_format])
+    plist.to_str(options[:plist_format], options)
+  end
+end
+
+class Enumerator
+  # convert an array to plist format
+  def to_plist(options={})
+    options[:plist_format] ||= CFPropertyList::List::FORMAT_BINARY
+
+    plist = CFPropertyList::List.new
+    plist.value = CFPropertyList.guess(self, options)
+    plist.to_str(options[:plist_format], options)
   end
 end
 
@@ -344,7 +442,7 @@ class Hash
 
     plist = CFPropertyList::List.new
     plist.value = CFPropertyList.guess(self, options)
-    plist.to_str(options[:plist_format])
+    plist.to_str(options[:plist_format], options)
   end
 end