CFPropertyList 2.0.14 → 3.0.0

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

@@ -1,5 +1,7 @@
 # -*- coding: utf-8 -*-
 
+require 'stringio'
+
 module CFPropertyList
   # Binary PList parser class
   class Binary
@@ -16,7 +18,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
@@ -38,17 +40,20 @@ module CFPropertyList
       @count_objects = number_of_objects
 
       # decode offset table
-      formats = ["","C*","n*","(H6)*","N*"]
-      @offsets = coded_offset_table.unpack(formats[offset_size])
-      if(offset_size == 3) then
-        0.upto(@offsets.size-1) { |i| @offsets[i] = @offsets[i].to_i(16) }
+      if(offset_size != 3)
+        formats = ["","C*","n*","","N*"]
+        @offsets = coded_offset_table.unpack(formats[offset_size])
+      else
+        @offsets = coded_offset_table.unpack("C*").each_slice(3).map {
+          |x,y,z| (x << 16) | (y << 8) | z
+        }
       end
 
       @object_ref_size = object_ref_size
       val = read_binary_object_at(file,fd,top_object)
 
       fd.close
-      return val
+      val
     end
 
 
@@ -60,19 +65,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 +96,54 @@ 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 > 4
+        raise CFFormatError.new("Integer greater than 16 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]
+        # 8 byte integers are always signed
+        when 3 then buff.unpack("q>")[0]
+        # 16 byte integers are used to represent unsigned 8 byte integers
+        # where the unsigned value is stored in the lower 8 bytes and the
+        # upper 8 bytes are unused.
+        when 4 then buff.unpack("Q>Q>")[1]
         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("e")[0]
+        when 3 then
+          buff.reverse.unpack("E")[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("e")[0]
+        when 3 then
+          buff.reverse.unpack("E")[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)
+      return str.dup.force_encoding(from).encode(to) if str.respond_to?("encode")
+      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,18 +249,28 @@ 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
 
+    def unpack_with_size(nbytes, buff)
+      format = ["C*", "n*", "N*", "N*"][nbytes - 1];
+
+      if nbytes == 3
+        buff = "\0" + buff.scan(/.{1,3}/).join("\0")
+      end
+
+      return buff.unpack(format)
+    end
+
     # Read an binary array value, including contained objects
     def read_binary_array(fname,fd,length)
       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*")
+        objects = unpack_with_size(@object_ref_size, buff) #buff.unpack(@object_ref_size == 1 ? "C*" : "n*")
 
         # now: read objects
         0.upto(length-1) do |i|
@@ -271,7 +279,7 @@ module CFPropertyList
         end
       end
 
-      return CFArray.new(ary)
+      CFArray.new(ary)
     end
     protected :read_binary_array
 
@@ -282,11 +290,11 @@ module CFPropertyList
       # first: read keys
       if(length != 0) then
         buff = fd.read(length * @object_ref_size)
-        keys = buff.unpack(@object_ref_size == 1 ? "C*" : "n*")
+        keys = unpack_with_size(@object_ref_size, buff)
 
         # second: read object refs
         buff = fd.read(length * @object_ref_size)
-        objects = buff.unpack(@object_ref_size == 1 ? "C*" : "n*")
+        objects = unpack_with_size(@object_ref_size, buff)
 
         # read real keys and objects
         0.upto(length-1) do |i|
@@ -296,17 +304,18 @@ module CFPropertyList
         end
       end
 
-      return CFDictionary.new(dict)
+      CFDictionary.new(dict)
     end
     protected :read_binary_dict
 
-    # Read an object type byte, decode it and delegate to the correct reader function
+    # Read an object type byte, decode it and delegate to the correct
+    # reader function
     def read_binary_object(fname,fd)
       # first: read the marker byte
       buff = fd.read(1)
 
       object_length = buff.unpack("C*")
-      object_length = object_length[0]  & 0xF
+      object_length = object_length[0] & 0xF
 
       buff = buff.unpack("H*")
       object_type = buff[0][0].chr
@@ -316,29 +325,28 @@ 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 '8'
+        CFUid.new(read_binary_int(fname, fd, object_length).value)
+      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 +354,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 +385,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 +440,136 @@ 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)
+      val = val.to_s
 
-        utf8_strlen = 0
-        if(utf16) then
-          utf8_strlen = Binary.charset_strlen(val, "UTF-8")
+      @unique_table[val] ||= begin
+        if !Binary.ascii_string?(val)
           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]
-      end
 
-      return saved_object_count
+        @written_object_count += 1
+        @written_object_count - 1
+      end
     end
 
     # Codes an integer to binary format
     def int_to_binary(value)
+      # Note: nbytes is actually an exponent.  number of bytes = 2**nbytes.
       nbytes = 0
-      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 = 1  if value > 0xFF # 1 byte unsigned integer
+      nbytes += 1 if value > 0xFFFF # 4 byte unsigned integer
+      nbytes += 1 if value > 0xFFFFFFFF # 8 byte unsigned integer
+      nbytes += 1 if value > 0x7FFFFFFFFFFFFFFF # 8 byte unsigned integer, stored in lower half of 16 bytes
+      nbytes = 3  if value < 0 # signed integers always stored in 8 bytes
+
+      Binary.type_bytes(0b0001, nbytes) <<
+        if nbytes < 4
+          [value].pack(["C", "n", "N", "q>"][nbytes])
+        else # nbytes == 4
+          [0,value].pack("Q>Q>")
         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("E").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
+      @object_table[@written_object_count] =
+        if value.is_a?(CFInteger)
+          int_to_binary(value.value)
+        else
+          real_to_binary(value.value)
+        end
+
       @written_object_count += 1
+      @written_object_count - 1
+    end
 
-      val = ""
-      if(value.is_a?(CFInteger)) then
-        val = int_to_binary(value.value)
-      else
-        val = real_to_binary(value.value)
-      end
+    def uid_to_binary(value)
+      nbytes = 0
+      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
+
+      @object_table[@written_object_count] = Binary.type_bytes(0b1000, 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
 
-      @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("E").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,11 +577,13 @@ 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