sj-plist 3.2

data/test/assets/test_data_elements.plist

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>stringio</key>
+    <data>dGhpcyBpcyBhIHN0cmluZ2lvIG9iamVjdA==
+    </data>
+    <key>file</key>
+    <data>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+    AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+    AAAAAAAAAAAAAA==
+    </data>
+    <key>io</key>
+    <data>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+    AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+    AAAAAAAAAAAAAA==
+    </data>
+    <key>marshal</key>
+    <!-- The <data> element below contains a Ruby object which has been serialized with Marshal.dump. -->
+    <data>BAhvOhZNYXJzaGFsYWJsZU9iamVjdAY6CUBmb28iHnRoaXMgb2JqZWN0IHdh
+    cyBtYXJzaGFsZWQ=
+    </data>
+  </dict>
+</plist>

data/test/assets/test_empty_key.plist

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>key</key>
+    <dict>
+      <key></key>
+      <string>1</string>
+      <key>subkey</key>
+      <string>2</string>
+    </dict>
+  </dict>
+</plist>

data/test/test_ascii.rb

@@ -0,0 +1,143 @@
+# encoding: utf-8
+
+require "test/unit"
+require "date"
+require "plist/ascii"
+
+class TestAscii < Test::Unit::TestCase
+  def test_should_parse_a_simple_dictionary
+    assert_equal({'a' => 'b'}, parse("{ a = b; }"))
+  end
+
+  def test_should_parse_a_simple_array
+    assert_equal(%w[1 2 3], parse("(1, 2, 3)"))
+    assert_equal(%w[foo], parse("(foo, )"))
+  end
+
+  def test_should_assume_dictionary_keys_are_strings_when_they_start_with_a_number
+    assert_equal({ '1' => 'foo' }, parse("{ 1 = foo; }"))
+  end
+
+  def test_should_correctly_parse_escaped_unicode_points
+    assert_equal({'foo' => "æ"}, parse('{ foo = "\u00e6"; }'))
+  end
+
+  def test_should_always_return_string_keys
+    assert_equal({'1234' => 'boo'}, parse_with_numbers('{ 1234 = boo; }'))
+  end
+
+  def test_should_correctly_parse_control_chars
+    assert_equal({'foo' => "\a\v\r\t\n\b\f"}, parse('{ foo = "\a\v\r\t\n\b\f"; }'))
+  end
+
+  def test_should_correctly_parse_octal_escapes
+    expected = "\303\246"
+    expected.force_encoding("BINARY") if expected.respond_to?(:force_encoding)
+    assert_equal({'foo' => expected}, parse('{ foo = "\303\246"; }'))
+  end
+
+  def test_should_correctly_parse_escaped_strings
+    assert_equal({'foo' => '"hello world"'}, parse('{ foo = "\"hello world\""; }'))
+  end
+
+  def test_should_correctly_parse_NSDate_strings
+    assert_equal({'time' => DateTime.parse("2008-11-22 14:17:04 +0100")}, parse('{ time = 2008-11-22 14:17:04 +0100;}'))
+  end
+
+  def test_should_parse_floats
+    assert_equal({ 'hello' => 1.2 }, parse_with_numbers("{ hello = 1.2; }"))
+  end
+
+  def test_should_parse_ints
+    assert_equal([1,2,3], parse_with_numbers("(1, 2, 3)"))
+    assert_equal({ 'hello' => "12abc" }, parse_with_numbers('{ hello = 12abc; }'))
+  end
+
+  def test_should_parse_booleans
+    assert_equal({'foo' => true}, parse_with_bools("{foo = true;}"))
+    assert_equal({'foo' => "1"}, parse("{foo = true;}"))
+  end
+
+  def test_should_parse_data
+    assert_equal({'data' => "foo\n"}, parse("{data = <666f6f0a>;}"))
+    assert_equal(asset("example_data.jpg"), parse(asset("example_data_ascii.plist"))['image'])
+  end
+
+  #
+  #  errors
+  #
+
+  def test_should_raise_error_if_given_a_non_string_key
+    assert_raises Plist::AsciiParser::ParseError do
+      parse_with_numbers "{ 1.2 = foo; }"
+    end
+  end
+
+  def test_should_raise_error_on_missing_semicolons
+    assert_raises Plist::AsciiParser::ParseError do
+      parse "{ foo = bar }"
+    end
+  end
+
+  def test_should_raise_error_on_missing_closing_parenthesis
+    assert_raises Plist::AsciiParser::ParseError do
+      parse "( foo, bar "
+    end
+  end
+
+  def test_should_raise_error_on_missing_end_quote
+    assert_raises Plist::AsciiParser::ParseError do
+      parse '{ foo = "bar; }'
+    end
+  end
+
+  def test_wshould_raise_error_on_empty_string
+    assert_raises Plist::AsciiParser::ParseError do
+      parse ''
+    end
+  end
+
+  #
+  #  other
+  #
+
+  def test_should_parse_textmate_ruby_grammar_without_errors
+    assert_nothing_raised do
+      parse asset("ruby.plist")
+    end
+  end
+
+  def test_should_handle_a_stringio_as_input
+    io = StringIO.new("(a,b,c)")
+    assert_equal(%w[a b c], parse(io))
+  end
+
+  def test_should_handle_an_io_as_input
+    File.open(path = "test.txt", "w") { |file| file << "{baz=(1,2,3);}" }
+    io = File.open(path, "r")
+    assert_equal({'baz' => [1,2,3] }, parse_with_numbers(io))
+  ensure
+    io.close
+    File.delete(io.path)
+  end
+
+  #
+  #  helpers
+  #
+
+  def parse(str)
+    Plist.parse_ascii(str)
+  end
+
+  def parse_with_numbers(str)
+    Plist.parse_ascii(str, :parse_numbers => true)
+  end
+
+  def parse_with_bools(str)
+    Plist.parse_ascii(str, :parse_booleans => true)
+  end
+
+  def asset(filename)
+    File.read("#{File.dirname(__FILE__)}/assets/#{filename}")
+  end
+end

data/test/test_binary.rb

@@ -0,0 +1,116 @@
+# encoding: binary
+require "test/unit"
+require "plist"
+
+class TestBinary < Test::Unit::TestCase
+  def test_binary_min_byte_size
+    # 1-, 2-, and 4-byte integers are unsigned.
+    assert_equal(1, Plist::Binary.send(:min_byte_size, 0))
+    assert_equal(1, Plist::Binary.send(:min_byte_size, 0xff))
+    assert_equal(2, Plist::Binary.send(:min_byte_size, 0x100))
+    assert_equal(2, Plist::Binary.send(:min_byte_size, 0xffff))
+    assert_equal(4, Plist::Binary.send(:min_byte_size, 0x10000))
+    assert_equal(4, Plist::Binary.send(:min_byte_size, 0xffffffff))
+    # 8- and 16-byte integers are signed.
+    assert_equal(8, Plist::Binary.send(:min_byte_size, 0x100000000))
+    assert_equal(8, Plist::Binary.send(:min_byte_size, 0x7fffffffffffffff))
+    assert_equal(16, Plist::Binary.send(:min_byte_size, 0x8000000000000000))
+    assert_equal(16, Plist::Binary.send(:min_byte_size, 0x7fffffffffffffffffffffffffffffff))
+    assert_raises(RangeError) { Plist::Binary.send(:min_byte_size, 0x80000000000000000000000000000000) }
+    assert_equal(8, Plist::Binary.send(:min_byte_size, -1))
+    assert_equal(8, Plist::Binary.send(:min_byte_size, -0x8000000000000000))
+    assert_equal(16, Plist::Binary.send(:min_byte_size, -0x8000000000000001))
+    assert_equal(16, Plist::Binary.send(:min_byte_size, -0x80000000000000000000000000000000))
+    assert_raises(RangeError) { Plist::Binary.send(:min_byte_size, -0x80000000000000000000000000000001) }
+  end
+  
+  def test_binary_pack_int
+    assert_equal("\x0", Plist::Binary.send(:pack_int, 0, 1))
+    assert_equal("\x0\x34", Plist::Binary.send(:pack_int, 0x34, 2))
+    assert_equal("\x0\xde\xdb\xef", Plist::Binary.send(:pack_int, 0xdedbef, 4))
+    assert_equal("\x0\xca\xfe\x0\x0\xde\xdb\xef", Plist::Binary.send(:pack_int, 0xcafe0000dedbef, 8))
+    assert_equal("\x0\x7f\xf7\x0\x0\x12\x34\x0\x0\xca\xfe\x0\x0\xde\xdb\xef", Plist::Binary.send(:pack_int, 0x7ff7000012340000cafe0000dedbef, 16))
+    assert_raises(ArgumentError) { Plist::Binary.send(:pack_int, -1, 1) }
+    assert_raises(ArgumentError) { Plist::Binary.send(:pack_int, -1, 2) }
+    assert_raises(ArgumentError) { Plist::Binary.send(:pack_int, -1, 4) }
+    assert_equal("\xff\xff\xff\xff\xff\xff\xff\xff", Plist::Binary.send(:pack_int, -1, 8))
+    assert_equal("\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff", Plist::Binary.send(:pack_int, -1, 16))
+    [-2,0,3,5,6,7,9,10,11,12,13,14,15,17,18,19,20,32].each do |i|
+      assert_raises(ArgumentError) { Plist::Binary.send(:pack_int, 0, i) }
+    end
+  end
+  
+  def test_binary_plist_data
+    assert_equal("\x4ahelloworld",
+      Plist::Binary.send(:binary_plist_data, "helloworld"))
+    data = "x" * 32000
+    assert_equal("\x4f\x11\x7d\x00#{data}",
+      Plist::Binary.send(:binary_plist_data, data))
+  end
+  
+  def test_flatten_collection
+    assert_equal([[1, 2, 3], :a, :b, :c],
+      Plist::Binary.send(:flatten_collection, [:a, :b, :c]))
+    assert_equal([[1, 2, 3, 4], :a, :b, :c, [1, 1]],
+      Plist::Binary.send(:flatten_collection, [:a, :b, :c, [:a, :a]]))
+    assert_equal(["booger"],
+      Plist::Binary.send(:flatten_collection, "booger"))
+    assert_equal([[1, 2], "hello", { 3 => 4 }, "key", [5, 6, 7], 1, 2, 3],
+      Plist::Binary.send(:flatten_collection, ["hello", { :key => [1, 2, 3] }]))
+    ary = [:a, :b, :c]
+    assert_equal([[1, 5], [2, 3, 4], :a, :b, :c, { 1 => 6 }, "whee"],
+      Plist::Binary.send(:flatten_collection, [ary, { ary => "whee" }]))
+    hsh = { :a => :b }
+    assert_equal([[1, 4], { 2 => 3 }, "a", :b, [5, 6, 1], 1, 2],
+      Plist::Binary.send(:flatten_collection, [hsh, [1, 2, hsh]]))
+  end
+  
+  def test_binary_plist_obj
+    assert_equal("\x5bHello World",
+      Plist::Binary.send(:binary_plist_obj, "Hello World"))
+    assert_equal("\x5f\x10\x1bDomo-kun's Angry Smash Fest",
+      Plist::Binary.send(:binary_plist_obj, "Domo-kun's Angry Smash Fest"))
+    assert_equal("\x63\x59\x7d\x30\x4d\x30\x60",
+      Plist::Binary.send(:binary_plist_obj, "好きだ"))
+    assert_raises(ArgumentError) { Plist::Binary.send(:binary_plist_obj, "𝄢") }
+    assert_equal("\x63\x59\x7d\x30\x4d\x30\x60",
+      Plist::Binary.send(:binary_plist_obj, "好きだ"))
+    assert_equal("\x66\000s\000e\0\361\000o\000r\000a",
+      Plist::Binary.send(:binary_plist_obj, "señora"))
+    assert_equal("\x23#{[3.14159].pack('G')}",
+      Plist::Binary.send(:binary_plist_obj, 3.14159))
+    assert_equal("\x9", Plist::Binary.send(:binary_plist_obj, true))
+    assert_equal("\x8", Plist::Binary.send(:binary_plist_obj, false))
+    assert_equal("\x33\xc1\xcd\x27\xe4\x2\x80\x0\x0",
+      Plist::Binary.send(:binary_plist_obj, Time.at(123)))
+    sio = StringIO.new("Hello World")
+    assert_equal("\x4bHello World", Plist::Binary.send(:binary_plist_obj, sio))
+    assert_equal("\xa3\x1\x2\x3",
+      Plist::Binary.send(:binary_plist_obj, [1, 2, 3], 1))
+    assert_equal("\xaf\x10\x10\x1\x2\x3\x4\x5\x6\x7\x8\x9\xa\xb\xc\xd\xe\xf\x10",
+      Plist::Binary.send(:binary_plist_obj, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], 1))
+    assert_equal("\xa3\x0\x1\x0\x2\x0\x3",
+      Plist::Binary.send(:binary_plist_obj, [1, 2, 3], 2))
+    assert_equal("\xd2\x1\x3\x2\x4",
+      Plist::Binary.send(:binary_plist_obj, {1=>2, 3=>4}, 1))
+    assert_equal("\xdf\x10\x10\x5\x0\xb\x6\x1\xc\x7\x2\xd\x8\x3\xe\x9\x4\xf\xa\x15\x10\x1b\x16\x11\x1c\x17\x12\x1d\x18\x13\x1e\x19\x14\x1f\x1a",
+      Plist::Binary.send(:binary_plist_obj, {5=>21, 11=>27, 0=>16, 6=>22, 12=>28, 1=>17, 7=>23, 13=>29, 2=>18, 8=>24, 14=>30, 3=>19, 9=>25, 15=>31, 4=>20, 10=>26}, 1))
+    assert_equal("\xd2\x0\x1\x0\x3\x0\x2\x0\x4",
+      Plist::Binary.send(:binary_plist_obj, {1=>2, 3=>4}, 2))
+    assert_equal("\xc3\x1\x2\x3",
+      Plist::Binary.send(:binary_plist_obj, Set.new([1, 2, 3]), 1))
+    assert_equal("\xcf\x10\x10\x10\x5\xb\x6\xc\x1\x7\xd\x2\x8\xe\x3\x9\xf\x4\xa",
+      Plist::Binary.send(:binary_plist_obj, Set.new([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]), 1))
+    assert_equal("\xc3\x0\x1\x0\x2\x0\x3",
+      Plist::Binary.send(:binary_plist_obj, Set.new([1, 2, 3]), 2))
+    assert_equal("\x49\x4\x8/\x9narf\0",
+      Plist::Binary.send(:binary_plist_obj, /narf/))
+  end
+  
+  def test_binary_plist
+    assert_equal("bplist00\x55hello\x8\x0\x0\x0\x0\x0\x0\x1\x1\x0\x0\x0\x0\x0\x0\x0\x1\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\xe",
+      Plist::Binary.binary_plist("hello"))
+    assert_equal("bplist00\xa4\x1\x2\x3\x6\x45\x4\x8\x3a\x6\x61\x45\x4\x8\x3a\x6\x62\xd1\x4\x5\x55\x73\x74\x75\x66\x66\x58\x77\x68\x61\x74\x65\x76\x65\x72\x10\x7b\x8\xd\x13\x19\x1c\x22\x2b\x0\x0\x0\x0\x0\x0\x1\x1\x0\x0\x0\x0\x0\x0\x0\x7\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x2d",
+      Plist::Binary.binary_plist([:a, :b, { :stuff => "whatever" }, 123]))
+  end
+end

data/test/test_data_elements.rb

@@ -0,0 +1,115 @@
+##############################################################
+# Copyright 2006, Ben Bleything <ben@bleything.net> and      #
+#                 Patrick May <patrick@hexane.org>           #
+#                                                            #
+# Distributed under the MIT license.                         #
+##############################################################
+
+require 'test/unit'
+require 'plist'
+require 'stringio'
+
+class MarshalableObject
+  attr_accessor :foo
+
+  def initialize(str)
+    @foo = str
+  end
+end
+
+class TestDataElements < Test::Unit::TestCase
+  @@result = Plist::parse_xml('test/assets/test_data_elements.plist')
+
+  def test_marshal
+    expected = <<END
+<!-- The <data> element below contains a Ruby object which has been serialized with Marshal.dump. -->
+<data>
+BAhvOhZNYXJzaGFsYWJsZU9iamVjdAY6CUBmb28iHnRoaXMgb2JqZWN0IHdhcyBtYXJz
+aGFsZWQ=
+</data>
+END
+
+    mo = MarshalableObject.new('this object was marshaled')
+
+    assert_equal expected.chomp, Plist::Emit.dump(mo, false).chomp
+
+    assert_instance_of MarshalableObject, @@result['marshal']
+
+    assert_equal mo.foo, @@result['marshal'].foo
+  end
+
+  def test_generator_io_and_file
+    expected = <<END
+<data>
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==
+</data>
+END
+
+    expected.chomp!
+
+    fd = IO.sysopen('test/assets/example_data.bin')
+    io = IO.open(fd, 'r')
+
+    # File is a subclass of IO, so catching IO in the dispatcher should work for File as well...
+    f = File.open('test/assets/example_data.bin')
+
+    assert_equal expected, Plist::Emit.dump(io, false).chomp
+    assert_equal expected, Plist::Emit.dump(f, false).chomp
+
+    assert_instance_of StringIO, @@result['io']
+    assert_instance_of StringIO, @@result['file']
+
+    io.rewind
+    f.rewind
+
+    assert_equal io.read, @@result['io'].read
+    assert_equal f.read,  @@result['file'].read
+
+    io.close
+    f.close
+  end
+
+  def test_generator_string_io
+    expected = <<END
+<data>
+dGhpcyBpcyBhIHN0cmluZ2lvIG9iamVjdA==
+</data>
+END
+
+    sio = StringIO.new('this is a stringio object')
+
+    assert_equal expected.chomp, Plist::Emit.dump(sio, false).chomp
+
+    assert_instance_of StringIO, @@result['stringio']
+
+    sio.rewind
+    assert_equal sio.read, @@result['stringio'].read
+  end
+
+  # this functionality is credited to Mat Schaffer,
+  # who discovered the plist with the data tag
+  # supplied the test data, and provided the parsing code.
+  def test_data
+    # test reading plist <data> elements
+    data = Plist::parse_xml("test/assets/example_data.plist");
+    assert_equal( File.open("test/assets/example_data.jpg"){|f| f.read }, data['image'].read )
+
+    # test writing data elements
+    expected = File.read("test/assets/example_data.plist")
+    result   = data.to_plist
+    #File.open('result.plist', 'w') {|f|f.write(result)} # debug
+    assert_equal( expected, result )
+
+    # Test changing the <data> object in the plist to a StringIO and writing.
+    # This appears extraneous given that plist currently returns a StringIO,
+    # so the above writing test also flexes StringIO#to_plist_node.
+    # However, the interface promise is to return an IO, not a particular class.
+    # plist used to return Tempfiles, which was changed solely for performance reasons.
+    data['image'] = StringIO.new( File.read("test/assets/example_data.jpg"))
+
+    assert_equal(expected, data.to_plist )
+
+  end
+
+end

data/test/test_generator.rb

@@ -0,0 +1,59 @@
+##############################################################
+# Copyright 2006, Ben Bleything <ben@bleything.net> and      #
+#                 Patrick May <patrick@hexane.org>           #
+#                                                            #
+# Distributed under the MIT license.                         #
+##############################################################
+
+require 'test/unit'
+require 'plist'
+
+class SerializableObject
+  attr_accessor :foo
+
+  def initialize(str)
+    @foo = str
+  end
+
+  def to_plist_node
+    return "<string>#{CGI::escapeHTML @foo}</string>"
+  end
+end
+
+class TestGenerator < Test::Unit::TestCase
+  def test_to_plist_vs_plist_emit_dump_no_envelope
+    source = [1, :b, true]
+
+    to_plist = source.to_plist(false)
+    plist_emit_dump = Plist::Emit.dump(source, false)
+
+    assert_equal to_plist, plist_emit_dump
+  end
+
+  def test_to_plist_vs_plist_emit_dump_with_envelope
+    source   = [1, :b, true]
+
+    to_plist = source.to_plist
+    plist_emit_dump = Plist::Emit.dump(source)
+
+    assert_equal to_plist, plist_emit_dump
+  end
+
+  def test_dumping_serializable_object
+    str = 'this object implements #to_plist_node'
+    so = SerializableObject.new(str)
+
+    assert_equal "<string>#{str}</string>", Plist::Emit.dump(so, false)
+  end
+
+  def test_write_plist
+    data = [1, :two, {:c => 'dee'}]
+
+    data.save_plist('test.plist')
+    file = File.open('test.plist') {|f| f.read}
+
+    assert_equal file, data.to_plist
+
+    File.unlink('test.plist')
+  end
+end