CFPropertyList 2.0.16 → 2.0.17

data/lib/rbBinaryCFPropertyList.rb

@@ -16,7 +16,7 @@ module CFPropertyList
       @offsets = []
 
       fd = nil
-      if(opts.has_key?(:file)) then
+      if(opts.has_key?(:file))
         fd = File.open(opts[:file],"rb")
         file = opts[:file]
       else
@@ -40,7 +40,7 @@ module CFPropertyList
       # decode offset table
       formats = ["","C*","n*","(H6)*","N*"]
       @offsets = coded_offset_table.unpack(formats[offset_size])
-      if(offset_size == 3) then
+      if(offset_size == 3)
         0.upto(@offsets.size-1) { |i| @offsets[i] = @offsets[i].to_i(16) }
       end
 
@@ -48,7 +48,7 @@ module CFPropertyList
       val = read_binary_object_at(file,fd,top_object)
 
       fd.close
-      return val
+      val
     end
 
 
@@ -60,19 +60,21 @@ module CFPropertyList
 
       @written_object_count = 0
       @object_table = []
-      @object_ref_size = 0
 
       @offsets = []
 
       binary_str = "bplist00"
 
       @object_refs = count_object_refs(opts[:root])
-      @object_ref_size = Binary.bytes_needed(@object_refs)
 
       opts[:root].to_binary(self)
 
       next_offset = 8
-      offsets = @object_table.collect { |object| offset = next_offset; next_offset += object.bytesize; offset }
+      offsets = @object_table.map do |object|
+        offset = next_offset
+        next_offset += object.bytesize
+        offset
+      end
       binary_str << @object_table.join
 
       table_offset = next_offset
@@ -89,60 +91,59 @@ module CFPropertyList
         end
       end
 
-      binary_str << [offset_size, @object_ref_size].pack("x6CC")
+      binary_str << [offset_size, object_ref_size(@object_refs)].pack("x6CC")
       binary_str << [@object_table.size].pack("x4N")
       binary_str << [0].pack("x4N")
       binary_str << [table_offset].pack("x4N")
 
-      return binary_str
+      binary_str
+    end
+
+    def object_ref_size object_refs
+      Binary.bytes_needed(object_refs)
     end
 
     # read a „null” type (i.e. null byte, marker byte, bool value)
     def read_binary_null_type(length)
       case length
-      when 0 then return 0 # null byte
-      when 8 then return CFBoolean.new(false)
-      when 9 then return CFBoolean.new(true)
-      when 15 then return 15 # fill type
+      when 0  then 0 # null byte
+      when 8  then CFBoolean.new(false)
+      when 9  then CFBoolean.new(true)
+      when 15 then 15 # fill type
+      else
+        raise CFFormatError.new("unknown null type: #{length}")
       end
-
-      raise CFFormatError.new("unknown null type: #{length}")
     end
     protected :read_binary_null_type
 
     # read a binary int value
     def read_binary_int(fname,fd,length)
-      raise CFFormatError.new("Integer greater than 8 bytes: #{length}") if length > 3
+      if length > 3
+        raise CFFormatError.new("Integer greater than 8 bytes: #{length}")
+      end
 
       nbytes = 1 << length
 
-      val = nil
       buff = fd.read(nbytes)
 
-      case length
-      when 0 then
-        val = buff.unpack("C")
-        val = val[0]
-      when 1 then
-        val = buff.unpack("n")
-        val = val[0]
-      when 2 then
-        val = buff.unpack("N")
-        val = val[0]
-      when 3
-        hiword,loword = buff.unpack("NN")
-        if (hiword & 0x80000000) != 0
-          # 8 byte integers are always signed, and are negative when bit 63 is
-          # set. Decoding into either a Fixnum or Bignum is tricky, however,
-          # because the size of a Fixnum varies among systems, and Ruby
-          # doesn't consider the number to be negative, and won't sign extend.
-          val = -(2**63 - ((hiword & 0x7fffffff) << 32 | loword))
-        else
-          val = hiword << 32 | loword
+      CFInteger.new(
+        case length
+        when 0 then buff.unpack("C")[0]
+        when 1 then buff.unpack("n")[0]
+        when 2 then buff.unpack("N")[0]
+        when 3
+          hiword,loword = buff.unpack("NN")
+          if (hiword & 0x80000000) != 0
+            # 8 byte integers are always signed, and are negative when bit 63 is
+            # set. Decoding into either a Fixnum or Bignum is tricky, however,
+            # because the size of a Fixnum varies among systems, and Ruby
+            # doesn't consider the number to be negative, and won't sign extend.
+            -(2**63 - ((hiword & 0x7fffffff) << 32 | loword))
+          else
+            hiword << 32 | loword
+          end
         end
-      end
-
-      return CFInteger.new(val);
+      )
     end
     protected :read_binary_int
 
@@ -151,23 +152,22 @@ module CFPropertyList
       raise CFFormatError.new("Real greater than 8 bytes: #{length}") if length > 3
 
       nbytes = 1 << length
-      val = nil
       buff = fd.read(nbytes)
 
-      case length
-      when 0 then # 1 byte float? must be an error
-        raise CFFormatError.new("got #{length+1} byte float, must be an error!")
-      when 1 then # 2 byte float? must be an error
-        raise CFFormatError.new("got #{length+1} byte float, must be an error!")
-      when 2 then
-        val = buff.reverse.unpack("f")
-        val = val[0]
-      when 3 then
-        val = buff.reverse.unpack("d")
-        val = val[0]
-      end
-
-      return CFReal.new(val)
+      CFReal.new(
+        case length
+        when 0 # 1 byte float? must be an error
+          raise CFFormatError.new("got #{length+1} byte float, must be an error!")
+        when 1 # 2 byte float? must be an error
+          raise CFFormatError.new("got #{length+1} byte float, must be an error!")
+        when 2 then
+          buff.reverse.unpack("f")[0]
+        when 3 then
+          buff.reverse.unpack("d")[0]
+        else
+          fail "unexpected length: #{length}"
+        end
+      )
     end
     protected :read_binary_real
 
@@ -176,48 +176,46 @@ module CFPropertyList
       raise CFFormatError.new("Date greater than 8 bytes: #{length}") if length > 3
 
       nbytes = 1 << length
-      val = nil
       buff = fd.read(nbytes)
 
-      case length
-      when 0 then # 1 byte CFDate is an error
-        raise CFFormatError.new("#{length+1} byte CFDate, error")
-      when 1 then # 2 byte CFDate is an error
-        raise CFFormatError.new("#{length+1} byte CFDate, error")
-      when 2 then
-        val = buff.reverse.unpack("f")
-        val = val[0]
-      when 3 then
-        val = buff.reverse.unpack("d")
-        val = val[0]
-      end
-
-      return CFDate.new(val,CFDate::TIMESTAMP_APPLE)
+      CFDate.new(
+        case length
+        when 0 then # 1 byte CFDate is an error
+          raise CFFormatError.new("#{length+1} byte CFDate, error")
+        when 1 then # 2 byte CFDate is an error
+          raise CFFormatError.new("#{length+1} byte CFDate, error")
+        when 2 then
+          buff.reverse.unpack("f")[0]
+        when 3 then
+          buff.reverse.unpack("d")[0]
+        end,
+        CFDate::TIMESTAMP_APPLE
+      )
     end
     protected :read_binary_date
 
     # Read a binary data value
     def read_binary_data(fname,fd,length)
-      buff = "";
-      buff = fd.read(length) if length > 0
-      return CFData.new(buff,CFData::DATA_RAW)
+      CFData.new(read_fd(fd, length), CFData::DATA_RAW)
     end
     protected :read_binary_data
 
+    def read_fd fd, length
+      length > 0 ? fd.read(length) : ""
+    end
+
     # Read a binary string value
     def read_binary_string(fname,fd,length)
-      buff = ""
-      buff = fd.read(length) if length > 0
-
+      buff = read_fd fd, length
       @unique_table[buff] = true unless @unique_table.has_key?(buff)
-      return CFString.new(buff)
+      CFString.new(buff)
     end
     protected :read_binary_string
 
     # Convert the given string from one charset to another
     def Binary.charset_convert(str,from,to="UTF-8")
       return str.clone.force_encoding(from).encode(to) if str.respond_to?("encode")
-      return Iconv.conv(to,from,str)
+      Iconv.conv(to,from,str)
     end
 
     # Count characters considering character set
@@ -228,7 +226,7 @@ module CFPropertyList
         utf8_str = Iconv.conv("UTF-8",charset,str)
         size = utf8_str.scan(/./mu).size
       end
-      
+
       # UTF-16 code units in the range D800-DBFF are the beginning of
       # a surrogate pair, and count as one additional character for
       # length calculation.
@@ -239,8 +237,8 @@ module CFPropertyList
           str.split('').each_slice(2) { |pair| size += 1 if ("\xd8".."\xdb").include?(pair[0]) }
         end
       end
-      
-      return size
+
+      size
     end
 
     # Read a unicode string value, coded as UTF-16BE
@@ -251,7 +249,7 @@ module CFPropertyList
       buff = fd.read(2*length)
 
       @unique_table[buff] = true unless @unique_table.has_key?(buff)
-      return CFString.new(Binary.charset_convert(buff,"UTF-16BE","UTF-8"))
+      CFString.new(Binary.charset_convert(buff,"UTF-16BE","UTF-8"))
     end
     protected :read_binary_unicode_string
 
@@ -260,7 +258,7 @@ module CFPropertyList
       ary = []
 
       # first: read object refs
-      if(length != 0) then
+      if(length != 0)
         buff = fd.read(length * @object_ref_size)
         objects = buff.unpack(@object_ref_size == 1 ? "C*" : "n*")
 
@@ -271,7 +269,7 @@ module CFPropertyList
         end
       end
 
-      return CFArray.new(ary)
+      CFArray.new(ary)
     end
     protected :read_binary_array
 
@@ -296,7 +294,7 @@ module CFPropertyList
         end
       end
 
-      return CFDictionary.new(dict)
+      CFDictionary.new(dict)
     end
     protected :read_binary_dict
 
@@ -316,29 +314,26 @@ module CFPropertyList
         object_length = object_length.value
       end
 
-      retval = nil
       case object_type
-      when '0' then # null, false, true, fillbyte
-        retval = read_binary_null_type(object_length)
-      when '1' then # integer
-        retval = read_binary_int(fname,fd,object_length)
-      when '2' then # real
-        retval = read_binary_real(fname,fd,object_length)
-      when '3' then # date
-        retval = read_binary_date(fname,fd,object_length)
-      when '4' then # data
-        retval = read_binary_data(fname,fd,object_length)
-      when '5' then # byte string, usually utf8 encoded
-        retval = read_binary_string(fname,fd,object_length)
-      when '6' then # unicode string (utf16be)
-        retval = read_binary_unicode_string(fname,fd,object_length)
-      when 'a' then # array
-        retval = read_binary_array(fname,fd,object_length)
-      when 'd' then # dictionary
-        retval = read_binary_dict(fname,fd,object_length)
+      when '0' # null, false, true, fillbyte
+        read_binary_null_type(object_length)
+      when '1' # integer
+        read_binary_int(fname,fd,object_length)
+      when '2' # real
+        read_binary_real(fname,fd,object_length)
+      when '3' # date
+        read_binary_date(fname,fd,object_length)
+      when '4' # data
+        read_binary_data(fname,fd,object_length)
+      when '5' # byte string, usually utf8 encoded
+        read_binary_string(fname,fd,object_length)
+      when '6' # unicode string (utf16be)
+        read_binary_unicode_string(fname,fd,object_length)
+      when 'a' # array
+        read_binary_array(fname,fd,object_length)
+      when 'd' # dictionary
+        read_binary_dict(fname,fd,object_length)
       end
-
-      return retval
     end
     protected :read_binary_object
 
@@ -346,36 +341,30 @@ module CFPropertyList
     def read_binary_object_at(fname,fd,pos)
       position = @offsets[pos]
       fd.seek(position,IO::SEEK_SET)
-      return read_binary_object(fname,fd)
+      read_binary_object(fname,fd)
     end
     protected :read_binary_object_at
 
     # pack an +int+ of +nbytes+ with size
     def Binary.pack_it_with_size(nbytes,int)
       case nbytes
-      when 1
-        return [int].pack('c')
-      when 2
-        return [int].pack('n')
-      when 4
-        return [int].pack('N')
+      when 1 then [int].pack('c')
+      when 2 then [int].pack('n')
+      when 4 then [int].pack('N')
       when 8
-        return [int >> 32, int & 0xFFFFFFFF].pack('NN')
+        [int >> 32, int & 0xFFFFFFFF].pack('NN')
       else
         raise CFFormatError.new("Don't know how to pack #{nbytes} byte integer")
       end
     end
-    
+
     def Binary.pack_int_array_with_size(nbytes, array)
       case nbytes
-      when 1
-        array.pack('C*')
-      when 2
-        array.pack('n*')
-      when 4
-        array.pack('N*')
+      when 1 then array.pack('C*')
+      when 2 then array.pack('n*')
+      when 4 then array.pack('N*')
       when 8
-        array.collect { |int| [int >> 32, int & 0xFFFFFFFF].pack('NN') }.join
+        array.map { |int| [int >> 32, int & 0xFFFFFFFF].pack('NN') }.join
       else
         raise CFFormatError.new("Don't know how to pack #{nbytes} byte integer")
       end
@@ -383,41 +372,36 @@ module CFPropertyList
 
     # calculate how many bytes are needed to save +count+
     def Binary.bytes_needed(count)
-      if count < 2**8
-        nbytes = 1
-      elsif count < 2**16
-        nbytes = 2
-      elsif count < 2**32
-        nbytes = 4
-      elsif count < 2**64
-        nbytes = 8
+      case
+      when count < 2**8  then 1
+      when count < 2**16 then 2
+      when count < 2**32 then 4
+      when count < 2**64 then 8
       else
         raise CFFormatError.new("Data size too large: #{count}")
       end
-
-      return nbytes
     end
 
     # Create a type byte for binary format as defined by apple
     def Binary.type_bytes(type, length)
       if length < 15
-        return [(type << 4) | length].pack('C')
+        [(type << 4) | length].pack('C')
       else
         bytes = [(type << 4) | 0xF]
         if length <= 0xFF
-          return bytes.push(0x10, length).pack('CCC')                              # 1 byte length
+          bytes.push(0x10, length).pack('CCC')                              # 1 byte length
         elsif length <= 0xFFFF
-          return bytes.push(0x11, length).pack('CCn')                              # 2 byte length
+          bytes.push(0x11, length).pack('CCn')                              # 2 byte length
         elsif length <= 0xFFFFFFFF
-          return bytes.push(0x12, length).pack('CCN')                              # 4 byte length
+          bytes.push(0x12, length).pack('CCN')                              # 4 byte length
         elsif length <= 0x7FFFFFFFFFFFFFFF
-          return bytes.push(0x13, length >> 32, length & 0xFFFFFFFF).pack('CCNN')  # 8 byte length
+          bytes.push(0x13, length >> 32, length & 0xFFFFFFFF).pack('CCNN')  # 8 byte length
         else
           raise CFFormatError.new("Integer too large: #{int}")
         end
       end
     end
-    
+
     def count_object_refs(object)
       case object
       when CFArray
@@ -443,140 +427,115 @@ module CFPropertyList
 
     def Binary.ascii_string?(str)
       if str.respond_to?(:ascii_only?)
-        return str.ascii_only?
+        str.ascii_only?
       else
-        return str.scan(/[\x80-\xFF]/mn).size == 0
+        str !~ /[\x80-\xFF]/mn
       end
     end
-    
+
     # Uniques and transforms a string value to binary format and adds it to the object table
     def string_to_binary(val)
-      saved_object_count = -1
-
-      unless(@unique_table.has_key?(val)) then
-        saved_object_count = @written_object_count
-        @written_object_count += 1
-
-        @unique_table[val] = saved_object_count
-        utf16 = !Binary.ascii_string?(val)
-
-        utf8_strlen = 0
-        if(utf16) then
+      @unique_table[val] ||= begin
+        if !Binary.ascii_string?(val)
           utf8_strlen = Binary.charset_strlen(val, "UTF-8")
           val = Binary.charset_convert(val,"UTF-8","UTF-16BE")
           bdata = Binary.type_bytes(0b0110, Binary.charset_strlen(val,"UTF-16BE"))
 
           val.force_encoding("ASCII-8BIT") if val.respond_to?("encode")
-          @object_table[saved_object_count] = bdata + val
+          @object_table[@written_object_count] = bdata << val
         else
           utf8_strlen = val.bytesize
           bdata = Binary.type_bytes(0b0101,val.bytesize)
-          @object_table[saved_object_count] = bdata + val
+          @object_table[@written_object_count] = bdata << val
         end
-      else
-        saved_object_count = @unique_table[val]
+        @written_object_count += 1
+        @written_object_count - 1
       end
-
-      return saved_object_count
     end
 
     # Codes an integer to binary format
     def int_to_binary(value)
       nbytes = 0
-      nbytes = 1 if value > 0xFF # 1 byte integer
+      nbytes = 1  if value > 0xFF # 1 byte integer
       nbytes += 1 if value > 0xFFFF # 4 byte integer
       nbytes += 1 if value > 0xFFFFFFFF # 8 byte integer
-      nbytes = 3 if value < 0 # 8 byte integer, since signed
-
-      bdata = Binary.type_bytes(0b0001, nbytes)
-      buff = ""
-
-      if(nbytes < 3) then
-        fmt = "N"
-
-        if(nbytes == 0) then
-          fmt = "C"
-        elsif(nbytes == 1)
-          fmt = "n"
+      nbytes = 3  if value < 0 # 8 byte integer, since signed
+
+      Binary.type_bytes(0b0001, nbytes) <<
+        if nbytes < 3
+          [value].pack(
+            if nbytes == 0    then "C"
+            elsif nbytes == 1 then "n"
+            else "N"
+            end
+          )
+        else
+          # 64 bit signed integer; we need the higher and the lower 32 bit of the value
+          high_word = value >> 32
+          low_word = value & 0xFFFFFFFF
+          [high_word,low_word].pack("NN")
         end
-
-        buff = [value].pack(fmt)
-      else
-        # 64 bit signed integer; we need the higher and the lower 32 bit of the value
-        high_word = value >> 32
-        low_word = value & 0xFFFFFFFF
-        buff = [high_word,low_word].pack("NN")
-      end
-
-      return bdata + buff
     end
 
     # Codes a real value to binary format
     def real_to_binary(val)
-      bdata = Binary.type_bytes(0b0010,3)
-      buff = [val].pack("d")
-      return bdata + buff.reverse
+      Binary.type_bytes(0b0010,3) << [val].pack("d").reverse
     end
 
     # Converts a numeric value to binary and adds it to the object table
     def num_to_binary(value)
-      saved_object_count = @written_object_count
-      @written_object_count += 1
-
-      val = ""
-      if(value.is_a?(CFInteger)) then
-        val = int_to_binary(value.value)
-      else
-        val = real_to_binary(value.value)
-      end
+      @object_table[@written_object_count] =
+        if value.is_a?(CFInteger)
+          int_to_binary(value.value)
+        else
+          real_to_binary(value.value)
+        end
 
-      @object_table[saved_object_count] = val
-      return saved_object_count
+      @written_object_count += 1
+      @written_object_count - 1
     end
 
     # Convert date value (apple format) to binary and adds it to the object table
     def date_to_binary(val)
-      saved_object_count = @written_object_count
-      @written_object_count += 1
-
       val = val.getutc.to_f - CFDate::DATE_DIFF_APPLE_UNIX # CFDate is a real, number of seconds since 01/01/2001 00:00:00 GMT
 
-      bdata = Binary.type_bytes(0b0011, 3)
-      @object_table[saved_object_count] = bdata + [val].pack("d").reverse
+      @object_table[@written_object_count] =
+        (Binary.type_bytes(0b0011, 3) << [val].pack("d").reverse)
 
-      return saved_object_count
+      @written_object_count += 1
+      @written_object_count - 1
     end
 
     # Convert a bool value to binary and add it to the object table
     def bool_to_binary(val)
-      saved_object_count = @written_object_count
-      @written_object_count += 1
 
-      @object_table[saved_object_count] = val ? "\x9" : "\x8" # 0x9 is 1001, type indicator for true; 0x8 is 1000, type indicator for false
-      return saved_object_count
+      @object_table[@written_object_count] = val ? "\x9" : "\x8" # 0x9 is 1001, type indicator for true; 0x8 is 1000, type indicator for false
+      @written_object_count += 1
+      @written_object_count - 1
     end
 
     # Convert data value to binary format and add it to the object table
     def data_to_binary(val)
-      saved_object_count = @written_object_count
-      @written_object_count += 1
-
-      bdata = Binary.type_bytes(0b0100, val.bytesize)
-      @object_table[saved_object_count] = bdata + val
+      @object_table[@written_object_count] =
+        (Binary.type_bytes(0b0100, val.bytesize) << val)
 
-      return saved_object_count
+      @written_object_count += 1
+      @written_object_count - 1
     end
 
     # Convert array to binary format and add it to the object table
     def array_to_binary(val)
       saved_object_count = @written_object_count
       @written_object_count += 1
+      #@object_refs += val.value.size
 
-      bdata = Binary.type_bytes(0b1010, val.value.size) +
-        Binary.pack_int_array_with_size(@object_ref_size, val.value.collect { |v| v.to_binary(self) })
+      values = val.value.map { |v| v.to_binary(self) }
+      bdata = Binary.type_bytes(0b1010, val.value.size) <<
+        Binary.pack_int_array_with_size(object_ref_size(@object_refs),
+                                        values)
 
       @object_table[saved_object_count] = bdata
-      return saved_object_count
+      saved_object_count
     end
 
     # Convert dictionary to binary format and add it to the object table
@@ -584,15 +543,44 @@ module CFPropertyList
       saved_object_count = @written_object_count
       @written_object_count += 1
 
-      keys_and_values = val.value.keys.collect { |k| CFString.new(k).to_binary(self) }
-      keys_and_values += val.value.keys.collect { |k| val.value[k].to_binary(self) }
-      
-      bdata = Binary.type_bytes(0b1101,val.value.size) +
-        Binary.pack_int_array_with_size(@object_ref_size, keys_and_values)
+      #@object_refs += val.value.keys.size * 2
+
+      keys_and_values = val.value.keys.map { |k| CFString.new(k).to_binary(self) }
+      keys_and_values.concat(val.value.values.map { |v| v.to_binary(self) })
+
+      bdata = Binary.type_bytes(0b1101,val.value.size) <<
+        Binary.pack_int_array_with_size(object_ref_size(@object_refs), keys_and_values)
 
       @object_table[saved_object_count] = bdata
       return saved_object_count
     end
+
+=begin It is difficult to reap benefits from an Enumerator
+    # like an array, but we don't know length ahead of time
+    def enum_to_binary(val)
+      saved_object_count = @written_object_count
+      @written_object_count += 1
+
+      size = 0
+      # This destroys our low-memory stream.
+      # However, testing shows that it is faster
+      #   Probably because packing this single Array (in pack_int_array_with_size)
+      #   is faster than packing each individual array member separately
+      #   i.e. to be faster it needs an Enumerator#pack
+      binary = val.value.map do |v|
+        size += 1;
+        v.to_binary(self)
+      end
+      @object_refs += size
+
+      bdata = Binary.type_bytes(0b1010, size) <<
+        Binary.pack_int_array_with_size(object_ref_size(@object_refs), binary)
+
+      @object_table[saved_object_count] = bdata
+      saved_object_count
+    end
+=end
+
   end
 end
 

data/lib/rbCFPropertyList.rb

@@ -101,41 +101,55 @@ module CFPropertyList
   #
   #  cftypes = CFPropertyList.guess(x,:convert_unknown_to_string => true,:converter_method => :to_hash)
   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 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
       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
+      CFDictionary.new(hsh)
+
+=begin
+    when Enumerator
+      CFEnumerator.new(
+        Enumerator.new do |yielder|
+          object.each do |o|
+            yielder << CFPropertyList.guess(o, options)
+          end
+        end
+      )
+=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]),options)
-    elsif options[:convert_unknown_to_string] then
-      return 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!")
+      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])
+        CFPropertyList.guess(object.send(options[:converter_method]),options)
+      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
 
@@ -337,6 +351,17 @@ class Array
   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])
+  end
+end
+
 class Hash
   # convert a hash to plist format
   def to_plist(options={})

data/lib/rbCFTypes.rb

@@ -16,19 +16,13 @@ module CFPropertyList
     # value of the type
     attr_accessor :value
 
-
-    # set internal value to parameter value by default
     def initialize(value=nil)
       @value = value
     end
 
-    # convert type to XML
-    def to_xml
-    end
+    def to_xml; end
 
-    # convert type to binary
-    def to_binary(bplist)
-    end
+    def to_binary(bplist) end
   end
 
   # This class holds string values, both, UTF-8 and UTF-16BE
@@ -38,12 +32,12 @@ module CFPropertyList
     def to_xml
       n = LibXML::XML::Node.new('string')
       n << LibXML::XML::Node.new_text(@value) unless @value.nil?
-      return n
+      n
     end
 
     # convert to binary
     def to_binary(bplist)
-      return bplist.string_to_binary(@value);
+      bplist.string_to_binary(@value);
     end
   end
 
@@ -56,7 +50,7 @@ module CFPropertyList
 
     # convert to binary
     def to_binary(bplist)
-      return bplist.num_to_binary(self)
+      bplist.num_to_binary(self)
     end
   end
 
@@ -69,7 +63,7 @@ module CFPropertyList
 
     # convert to binary
     def to_binary(bplist)
-      return bplist.num_to_binary(self)
+      bplist.num_to_binary(self)
     end
   end
 
@@ -100,6 +94,10 @@ module CFPropertyList
     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
@@ -117,20 +115,20 @@ module CFPropertyList
     # get timestamp, either UNIX or Apple timestamp
     def get_value(format=CFDate::TIMESTAMP_UNIX)
       if(format == CFDate::TIMESTAMP_UNIX) then
-        return @value.to_i
+        @value.to_i
       else
-        return @value.to_f - CFDate::DATE_DIFF_APPLE_UNIX
+        @value.to_f - CFDate::DATE_DIFF_APPLE_UNIX
       end
     end
 
     # convert to XML
     def to_xml
-      return LibXML::XML::Node.new('date') << LibXML::XML::Node.new_text(CFDate::date_string(@value))
+      LibXML::XML::Node.new('date') << LibXML::XML::Node.new_text(CFDate::date_string(@value))
     end
 
     # convert to binary
     def to_binary(bplist)
-      return bplist.date_to_binary(@value)
+      bplist.date_to_binary(@value)
     end
   end
 
@@ -138,12 +136,12 @@ module CFPropertyList
   class CFBoolean < CFType
     # convert to XML
     def to_xml
-      return LibXML::XML::Node.new(@value ? 'true' : 'false')
+      LibXML::XML::Node.new(@value ? 'true' : 'false')
     end
 
     # convert to binary
     def to_binary(bplist)
-      return bplist.bool_to_binary(@value);
+      bplist.bool_to_binary(@value);
     end
   end
 
@@ -156,7 +154,7 @@ module CFPropertyList
 
     # set value to defined state, either base64 encoded or raw
     def initialize(value=nil,format=DATA_BASE64)
-      if(format == DATA_RAW) then
+      if(format == DATA_RAW)
         @raw_value = value
         @raw_value.blob = true
       else
@@ -178,12 +176,12 @@ module CFPropertyList
 
     # convert to XML
     def to_xml
-      return LibXML::XML::Node.new('data') << LibXML::XML::Node.new_text(encoded_value())
+      LibXML::XML::Node.new('data') << LibXML::XML::Node.new_text(encoded_value())
     end
 
     # convert to binary
     def to_binary(bplist)
-      return bplist.data_to_binary(decoded_value())
+      bplist.data_to_binary(decoded_value())
     end
   end
 
@@ -197,20 +195,26 @@ module CFPropertyList
     # convert to XML
     def to_xml
       n = LibXML::XML::Node.new('array')
-      @value.each do
-        |v|
+      @value.each do |v|
         n << v.to_xml
       end
-
-      return n
+      n
     end
 
     # convert to binary
     def to_binary(bplist)
-      return bplist.array_to_binary(self)
+      bplist.array_to_binary(self)
     end
   end
 
+=begin
+  class CFEnumerator < CFArray
+    def to_binary(bplist)
+      bplist.enum_to_binary(self)
+    end
+  end
+=end
+
   # this class contains a hash of values
   class CFDictionary < CFType
     # Create new CFDictonary type.
@@ -221,19 +225,17 @@ module CFPropertyList
     # convert to XML
     def to_xml
       n = LibXML::XML::Node.new('dict')
-      @value.each_pair do
-        |key,value|
+      @value.each_pair do |key,value|
         k = LibXML::XML::Node.new('key') << LibXML::XML::Node.new_text(key)
         n << k
         n << value.to_xml
       end
-
-      return n
+      n
     end
 
     # convert to binary
     def to_binary(bplist)
-      return bplist.dict_to_binary(self)
+      bplist.dict_to_binary(self)
     end
   end
 end

data/lib/rbXMLCFPropertyList.rb

@@ -33,8 +33,7 @@ module CFPropertyList
       str = doc.to_s(:indent => opts[:formatted])
       str1 = String.new
       first = false
-      str.each_line do
-        |line|
+      str.each_line do |line|
         str1 << line
         unless(first) then
           str1 << "<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n" if line =~ /^\s*<\?xml/
@@ -56,7 +55,7 @@ module CFPropertyList
       else
         n.content
       end
-      
+
       content.force_encoding('UTF-8') if content.respond_to?(:force_encoding)
       content
     end
@@ -71,8 +70,7 @@ module CFPropertyList
         key = nil
 
         if node.children? then
-          node.children.each do
-            |n|
+          node.children.each do |n|
             next if n.text? # avoid a bug of libxml
 
             if n.name == "key" then
@@ -91,8 +89,7 @@ module CFPropertyList
         ary = Array.new
 
         if node.children? then
-          node.children.each do
-            |n|
+          node.children.each do |n|
             ary.push import_xml(n)
           end
         end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 2
   - 0
-  - 16
-  version: 2.0.16
+  - 17
+  version: 2.0.17
 platform: ruby
 authors: 
 - Christian Kruse
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-21 00:00:00 +01:00
+date: 2011-07-02 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -57,11 +57,11 @@ extra_rdoc_files:
 - README
 files: 
 - lib/cfpropertylist.rb
+- lib/rbCFTypes.rb
+- lib/rbXMLCFPropertyList.rb
 - lib/rbBinaryCFPropertyList.rb
 - lib/rbCFPlistError.rb
 - lib/rbCFPropertyList.rb
-- lib/rbCFTypes.rb
-- lib/rbXMLCFPropertyList.rb
 - README
 has_rdoc: true
 homepage: http://github.com/ckruse/CFPropertyList