osx-plist 1.0.3

data/History.txt

@@ -0,0 +1,12 @@
+== 1.0.3 / 2009-09-21
+  * Add two new methods OSX::PropertyList.load_file and OSX::PropertyList.dump_file
+  * Clean up the RDoc documentation
+
+== 1.0.2 / 2009-09-17
+  * Build properly under Mac OS X 10.6
+
+== 1.0.1 / 2009-02-05
+  * Ruby 1.9.1 compatibility
+
+== 1.0 / 2008-04-25
+  * First public release

data/Manifest.txt

@@ -0,0 +1,10 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+ext/plist/extconf.rb
+ext/plist/plist.c
+lib/osx/plist.rb
+test/fixtures/xml_plist
+test/suite.rb
+test/test_plist.rb

data/README.txt

@@ -0,0 +1,92 @@
+== osx-plist
+
+* http://github.com/kballard/osx-plist
+* by Kevin Ballard
+
+== DESCRIPTION:
+
+osx-plist is a Ruby library for manipulating Property Lists natively using the built-in support in OS X.
+
+== REQUIREMENTS:
+
+* CoreFoundation (i.e. Mac OS X)
+
+== INSTALL:
+
+  $ gem sources -a http://gems.github.com/ (you only need to do this once)
+  $ gem install kballard-osx-plist
+
+== SOURCE:
+
+osx-plist's git repo is available on GitHub, which can be browsed at:
+
+  http://github.com/kballard/osx-plist
+
+and cloned from:
+
+  git://github.com/kballard/osx-plist.git
+
+== USAGE:
+
+One new module is provided, named OSX::PropertyList. It has the following 4 methods:
+
+==== OSX::PropertyList.load(input, format = false)
+
+Loads the property list from input, which is either an IO, StringIO, or a string. Format is an optional parameter - if false, the return value is the converted property list object. If true, the return value is a 2-element array, the first element being the returned value and the second being a symbol identifying the property list format.
+
+==== OSX::PropertyList.dump(output, obj, format = :xml1)
+
+Dumps the property list object into output, which is either an IO or StringIO. Format determines the property list format to write out. The supported values are :xml1,, :binary1, and :openstep; however, OpenStep format appears to not be supported by the system for output anymore.
+
+The valid formats are :xml1, :binary1, and :openstep. When loading a property list, if the format is something else (not possible under any current OS, but perhaps if a future OS includes another type) then the format will be :unknown.
+
+==== OSX::PropertyList.load_file(filepath, format = false)
+
+Calls OSX::PropertyList.load() on the file at the given path.
+
+==== OSX::PropertyList.dump_file(filepath, obj, format = :xml1)
+
+Calls OSX::PropertyList.dump() on the file at the given path.
+
+This module also provides a method on Object:
+
+==== Object#to_plist(format = :xml1)
+
+This is the same as PropertyList.dump except it outputs the property list as a string return value instead of writing it to a stream
+
+This module also provides 2 methods on String:
+
+==== String#blob?
+
+Returns whether the string is a blob.
+
+==== String#blob=
+
+Sets whether the string is a blob.
+
+A blob is a string that's been converted from a <data> property list item. When dumping to a property list, any strings that are blobs are written as <data> items rather than <string> items.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Kevin Ballard
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'hoe'
+
+Hoe.spec 'osx-plist' do
+  developer("Kevin Ballard", "kevin@sb.org")
+  self.version = "1.0.3"
+  self.summary = "Property List manipulation for OS X"
+  self.spec_extras = {:extensions => "ext/plist/extconf.rb"}
+end
+
+# override Hoe's default :test task
+Rake::Task["test"].clear
+desc "Run the unit tests"
+task :test do
+  ruby "test/test_plist.rb"
+end

data/ext/plist/extconf.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/ruby
+require 'mkmf'
+$LDFLAGS += ' -framework CoreFoundation -undefined suppress -flat_namespace'
+$LIBRUBYARG_SHARED=""
+create_makefile("osx/plist/ext/plist")

data/ext/plist/plist.c

@@ -0,0 +1,589 @@
+/*
+ * plist
+ * Kevin Ballard
+ *
+ * This is a Ruby extension to read/write Cocoa property lists
+ * Not surprisingly, it only works on OS X
+ *
+ * Copyright © 2005, Kevin Ballard
+ *
+ * Usage:
+ * This extension provides a module named OSX::PropertyList
+ * This module has two methods:
+ *
+ * PropertyList::load(obj, format = false)
+ *     Takes either an IO stream open for reading or a String object
+ *     Returns an object representing the property list
+ *
+ *     Optionally takes a boolean format argument. If true, the
+ *     return value is an array with the second value being
+ *     the format of the plist, which can be one of
+ *     :xml1, :binary1, or :openstep
+ *
+ * PropertyList::dump(io, obj, type = :xml1)
+ *     Takes an IO stream (open for writing) and an object
+ *     Writes the object to the IO stream as a property list
+ *     Posible type values are :xml1 and :binary1
+ *
+ * It also adds a new method to Object:
+ *
+ * Object#to_plist(type = :xml1)
+ *     Returns a string representation of the property list
+ *     Possible type values are :xml1 and :binary1
+ *
+ * It also adds 2 new methods to String:
+ *
+ * String#blob=(b)
+ *     Sets whether the string is a blob
+ *
+ * String#blob?
+ *     Returns whether the string is a blob
+ *
+ * A blob string is turned into a CFData when dumped
+ *
+ */
+
+#include <ruby.h>
+#if HAVE_RUBY_ST_H
+#include <ruby/st.h>
+#else
+#include <st.h>
+#endif
+#include <CoreFoundation/CoreFoundation.h>
+
+// Here's some convenience macros
+#ifndef StringValue
+#define StringValue(x) do {								\
+		if (TYPE(x) != T_STRING) x = rb_str_to_str(x);	\
+	} while (0)
+#endif
+
+static VALUE mOSX;
+static VALUE mPlist;
+static VALUE timeEpoch;
+static VALUE ePropertyListError;
+
+static VALUE id_gm;
+static VALUE id_plus;
+static VALUE id_minus;
+static VALUE id_read;
+static VALUE id_write;
+
+static VALUE id_xml;
+static VALUE id_binary;
+static VALUE id_openstep;
+
+static VALUE id_blob;
+
+VALUE convertPropertyListRef(CFPropertyListRef plist);
+VALUE convertStringRef(CFStringRef plist);
+VALUE convertDictionaryRef(CFDictionaryRef plist);
+VALUE convertArrayRef(CFArrayRef plist);
+VALUE convertNumberRef(CFNumberRef plist);
+VALUE convertBooleanRef(CFBooleanRef plist);
+VALUE convertDataRef(CFDataRef plist);
+VALUE convertDateRef(CFDateRef plist);
+VALUE str_blob(VALUE self);
+VALUE str_setBlob(VALUE self, VALUE b);
+
+// Raises a Ruby exception with the given string
+void raiseError(CFStringRef error) {
+		char *errBuffer = (char *)CFStringGetCStringPtr(error, kCFStringEncodingUTF8);
+		int freeBuffer = 0;
+		if (!errBuffer) {
+			int len = CFStringGetLength(error)*2+1;
+			errBuffer = ALLOC_N(char, len);
+			Boolean succ = CFStringGetCString(error, errBuffer, len, kCFStringEncodingUTF8);
+			if (!succ) {
+				CFStringGetCString(error, errBuffer, len, kCFStringEncodingMacRoman);
+			}
+			freeBuffer = 1;
+		}
+		rb_raise(ePropertyListError, (char *)errBuffer);
+		if (freeBuffer) free(errBuffer);
+}
+
+/* call-seq:
+ *    load(obj, format = false)
+ *
+ * Loads a property list from an IO stream or a String and creates
+ * an equivalent Object from it.
+ *
+ * If +format+ is +true+, it returns an array of <tt>[object, format]</tt>
+ * where +format+ is one of <tt>:xml1</tt>, <tt>:binary1</tt>, or <tt>:openstep</tt>.
+ */
+VALUE plist_load(int argc, VALUE *argv, VALUE self) {
+	VALUE io, retFormat;
+	int count = rb_scan_args(argc, argv, "11", &io, &retFormat);
+	if (count < 2) retFormat = Qfalse;
+	VALUE buffer;
+	if (RTEST(rb_respond_to(io, id_read))) {
+		// Read from IO
+		buffer = rb_funcall(io, id_read, 0);
+	} else {
+		StringValue(io);
+		buffer = io;
+	}
+	// For some reason, the CFReadStream version doesn't work with input < 6 characters
+	// but the CFDataRef version doesn't return format
+	// So lets use the CFDataRef version unless format is requested
+	CFStringRef error = NULL;
+	CFPropertyListRef plist;
+	CFPropertyListFormat format;
+	if (RTEST(retFormat)) {
+		// Format was requested
+		// now just in case, if the input is < 6 characters, we will pad it out with newlines
+		// we could do this in all cases, but I don't think it will work with binary
+		// even though binary shouldn't be < 6 characters
+		UInt8 *bytes;
+		int len;
+		if (RSTRING_LEN(buffer) < 6) {
+			bytes = ALLOC_N(UInt8, 6);
+			memset(bytes, '\n', 6);
+			MEMCPY(bytes, RSTRING_PTR(buffer), UInt8, RSTRING_LEN(buffer));
+			len = 6;
+		} else {
+			bytes = (UInt8 *)RSTRING_PTR(buffer);
+			len = RSTRING_LEN(buffer);
+		}
+		CFReadStreamRef readStream = CFReadStreamCreateWithBytesNoCopy(kCFAllocatorDefault, bytes, len, kCFAllocatorNull);
+		CFReadStreamOpen(readStream);
+		plist = CFPropertyListCreateFromStream(kCFAllocatorDefault, readStream, 0, kCFPropertyListImmutable, &format, &error);
+		CFReadStreamClose(readStream);
+		CFRelease(readStream);
+	} else {
+		// Format wasn't requested
+		CFDataRef data = CFDataCreateWithBytesNoCopy(kCFAllocatorDefault, (const UInt8*)RSTRING_PTR(buffer), RSTRING_LEN(buffer), kCFAllocatorNull);
+		plist = CFPropertyListCreateFromXMLData(kCFAllocatorDefault, data, kCFPropertyListImmutable, &error);
+		CFRelease(data);
+	}
+	if (error) {
+		raiseError(error);
+		CFRelease(error);
+		return Qnil;
+	}
+	VALUE obj = convertPropertyListRef(plist);
+	CFRelease(plist);
+	if (RTEST(retFormat)) {
+		VALUE ary = rb_ary_new();
+		rb_ary_push(ary, obj);
+		if (format == kCFPropertyListOpenStepFormat) {
+			retFormat = id_openstep;
+		} else if (format == kCFPropertyListXMLFormat_v1_0) {
+			retFormat = id_xml;
+		} else if (format == kCFPropertyListBinaryFormat_v1_0) {
+			retFormat = id_binary;
+		} else {
+			retFormat = rb_intern("unknown");
+		}
+		rb_ary_push(ary, ID2SYM(retFormat));
+		return ary;
+	} else {
+		return obj;
+	}
+}
+
+// Maps the property list object to a ruby object
+VALUE convertPropertyListRef(CFPropertyListRef plist) {
+	CFTypeID typeID = CFGetTypeID(plist);
+	if (typeID == CFStringGetTypeID()) {
+		return convertStringRef((CFStringRef)plist);
+	} else if (typeID == CFDictionaryGetTypeID()) {
+		return convertDictionaryRef((CFDictionaryRef)plist);
+	} else if (typeID == CFArrayGetTypeID()) {
+		return convertArrayRef((CFArrayRef)plist);
+	} else if (typeID == CFNumberGetTypeID()) {
+		return convertNumberRef((CFNumberRef)plist);
+	} else if (typeID == CFBooleanGetTypeID()) {
+		return convertBooleanRef((CFBooleanRef)plist);
+	} else if (typeID == CFDataGetTypeID()) {
+		return convertDataRef((CFDataRef)plist);
+	} else if (typeID == CFDateGetTypeID()) {
+		return convertDateRef((CFDateRef)plist);
+	} else {
+		return Qnil;
+	}
+}
+
+// Converts a CFStringRef to a String
+VALUE convertStringRef(CFStringRef plist) {
+	CFIndex byteCount;
+	CFRange range = CFRangeMake(0, CFStringGetLength(plist));
+	CFStringEncoding enc = kCFStringEncodingUTF8;
+	Boolean succ = CFStringGetBytes(plist, range, enc, 0, false, NULL, 0, &byteCount);
+	if (!succ) {
+		enc = kCFStringEncodingMacRoman;
+		CFStringGetBytes(plist, range, enc, 0, false, NULL, 0, &byteCount);
+	}
+	UInt8 *buffer = ALLOC_N(UInt8, byteCount);
+	CFStringGetBytes(plist, range, enc, 0, false, buffer, byteCount, NULL);
+	VALUE retval = rb_str_new((char *)buffer, (long)byteCount);
+	free(buffer);
+	return retval;
+}
+
+// Converts the keys and values of a CFDictionaryRef
+void dictionaryConverter(const void *key, const void *value, void *context) {
+	rb_hash_aset((VALUE)context, convertPropertyListRef(key), convertPropertyListRef(value));
+}
+
+// Converts a CFDictionaryRef to a Hash
+VALUE convertDictionaryRef(CFDictionaryRef plist) {
+	VALUE hash = rb_hash_new();
+	CFDictionaryApplyFunction(plist, dictionaryConverter, (void *)hash);
+	return hash;
+}
+
+// Converts the values of a CFArrayRef
+void arrayConverter(const void *value, void *context) {
+	rb_ary_push((VALUE)context, convertPropertyListRef(value));
+}
+
+// Converts a CFArrayRef to an Array
+VALUE convertArrayRef(CFArrayRef plist) {
+	VALUE array = rb_ary_new();
+	CFRange range = CFRangeMake(0, CFArrayGetCount(plist));
+	CFArrayApplyFunction(plist, range, arrayConverter, (void *)array);
+	return array;
+}
+
+// Converts a CFNumberRef to a Number
+VALUE convertNumberRef(CFNumberRef plist) {
+	if (CFNumberIsFloatType(plist)) {
+		double val;
+		CFNumberGetValue(plist, kCFNumberDoubleType, &val);
+		return rb_float_new(val);
+	} else {
+#ifdef LL2NUM
+		long long val;
+		CFNumberGetValue(plist, kCFNumberLongLongType, &val);
+		return LL2NUM(val);
+#else
+		long val;
+		CFNumberGetValue(plist, kCFNumberLongType, &val);
+		return LONG2NUM(val);
+#endif
+	}
+}
+
+// Converts a CFBooleanRef to a Boolean
+VALUE convertBooleanRef(CFBooleanRef plist) {
+	if (CFBooleanGetValue(plist)) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+// Converts a CFDataRef to a String (with blob set to true)
+VALUE convertDataRef(CFDataRef plist) {
+	const UInt8 *bytes = CFDataGetBytePtr(plist);
+	CFIndex len = CFDataGetLength(plist);
+	VALUE str = rb_str_new((char *)bytes, (long)len);
+	str_setBlob(str, Qtrue);
+	return str;
+}
+
+// Converts a CFDateRef to a Time
+VALUE convertDateRef(CFDateRef plist) {
+	CFAbsoluteTime seconds = CFDateGetAbsoluteTime(plist);
+
+	// trunace the time since Ruby's Time object stores it as a 32 bit signed offset from 1970 (undocumented)
+	const float min_time = -3124310400.0f;
+	const float max_time =  1169098047.0f;
+	seconds = seconds < min_time ? min_time : (seconds > max_time ? max_time : seconds);
+
+	return rb_funcall(timeEpoch, id_plus, 1, rb_float_new(seconds));
+}
+
+CFPropertyListRef convertObject(VALUE obj);
+
+// Converts a PropertyList object to a string representation
+VALUE convertPlistToString(CFPropertyListRef plist, CFPropertyListFormat format) {
+	CFWriteStreamRef writeStream = CFWriteStreamCreateWithAllocatedBuffers(kCFAllocatorDefault, kCFAllocatorDefault);
+	CFWriteStreamOpen(writeStream);
+	CFStringRef error = NULL;
+	CFPropertyListWriteToStream(plist, writeStream, format, &error);
+	CFWriteStreamClose(writeStream);
+	if (error) {
+		raiseError(error);
+		return Qnil;
+	}
+	CFDataRef data = CFWriteStreamCopyProperty(writeStream, kCFStreamPropertyDataWritten);
+	CFRelease(writeStream);
+	VALUE plistData = convertDataRef(data);
+	CFRelease(data);
+	return plistData;
+}
+
+/* call-seq:
+ *    dump(io, obj, format = :xml1)
+ *
+ * Writes the property list representation of +obj+
+ * to the IO stream (must be open for writing).
+ *
+ * +format+ can be one of <tt>:xml1</tt> or <tt>:binary1</tt>.
+ *
+ * Returns the number of bytes written, or +nil+ if
+ * the object could not be represented as a property list
+ */
+VALUE plist_dump(int argc, VALUE *argv, VALUE self) {
+	VALUE io, obj, type;
+	int count = rb_scan_args(argc, argv, "21", &io, &obj, &type);
+	if (count < 3) {
+		type = id_xml;
+	} else {
+		type = rb_to_id(type);
+	}
+	if (!RTEST(rb_respond_to(io, id_write))) {
+		rb_raise(rb_eArgError, "Argument 1 must be an IO object");
+		return Qnil;
+	}
+	CFPropertyListFormat format;
+	if (type == id_xml) {
+		format = kCFPropertyListXMLFormat_v1_0;
+	} else if (type == id_binary) {
+		format = kCFPropertyListBinaryFormat_v1_0;
+	} else if (type == id_openstep) {
+		format = kCFPropertyListOpenStepFormat;
+	} else {
+		rb_raise(rb_eArgError, "Argument 3 must be one of :xml1, :binary1, or :openstep");
+		return Qnil;
+	}
+	CFPropertyListRef plist = convertObject(obj);
+	VALUE data = convertPlistToString(plist, format);
+	if (NIL_P(data)) {
+		return Qnil;
+	} else {
+		return rb_funcall(io, id_write, 1, data);
+	}
+}
+
+/* call-seq:
+ *    object.to_plist(format = :xml1)
+ *
+ * Converts the object to a property list representation
+ * and returns it as a string.
+ *
+ * +format+ can be one of <tt>:xml1</tt> or <tt>:binary1</tt>.
+ */
+VALUE obj_to_plist(int argc, VALUE *argv, VALUE self) {
+	VALUE type;
+	int count = rb_scan_args(argc, argv, "01", &type);
+	if (count < 1) {
+		type = id_xml;
+	} else {
+		type = rb_to_id(type);
+	}
+	CFPropertyListFormat format;
+	if (type == id_xml) {
+		format = kCFPropertyListXMLFormat_v1_0;
+	} else if (type == id_binary) {
+		format = kCFPropertyListBinaryFormat_v1_0;
+	} else if (type == id_openstep) {
+		format = kCFPropertyListOpenStepFormat;
+	} else {
+		rb_raise(rb_eArgError, "Argument 2 must be one of :xml1, :binary1, or :openstep");
+		return Qnil;
+	}
+	CFPropertyListRef plist = convertObject(self);
+	VALUE data = convertPlistToString(plist, format);
+	CFRelease(plist);
+	if (type == id_xml || type == id_binary) {
+		str_setBlob(data, Qfalse);
+	}
+	return data;
+}
+
+CFPropertyListRef convertString(VALUE obj);
+CFDictionaryRef convertHash(VALUE obj);
+CFArrayRef convertArray(VALUE obj);
+CFNumberRef convertNumber(VALUE obj);
+CFDateRef convertTime(VALUE obj);
+
+// Converts an Object to a CFTypeRef
+CFPropertyListRef convertObject(VALUE obj) {
+	switch (TYPE(obj)) {
+		case T_STRING: return convertString(obj); break;
+		case T_HASH: return convertHash(obj); break;
+		case T_ARRAY: return convertArray(obj); break;
+		case T_FLOAT:
+		case T_FIXNUM:
+		case T_BIGNUM: return convertNumber(obj); break;
+		case T_TRUE: return kCFBooleanTrue; break;
+		case T_FALSE: return kCFBooleanFalse; break;
+		default: if (rb_obj_is_kind_of(obj, rb_cTime)) return convertTime(obj);
+	}
+	rb_raise(rb_eArgError, "An object in the argument tree could not be converted");
+	return NULL;
+}
+
+// Converts a String to a CFStringRef
+CFPropertyListRef convertString(VALUE obj) {
+	if (RTEST(str_blob(obj))) {
+		// convert to CFDataRef
+		StringValue(obj);
+		CFDataRef data = CFDataCreate(kCFAllocatorDefault, (const UInt8*)RSTRING_PTR(obj), (CFIndex)RSTRING_LEN(obj));
+		return data;
+	} else {
+		// convert to CFStringRef
+		StringValue(obj);
+		CFStringRef string = CFStringCreateWithBytes(kCFAllocatorDefault, (const UInt8*)RSTRING_PTR(obj), (CFIndex)RSTRING_LEN(obj), kCFStringEncodingUTF8, false);
+		if (!string) {
+			// try MacRoman
+			string = CFStringCreateWithBytes(kCFAllocatorDefault, (const UInt8*)RSTRING_PTR(obj), (CFIndex)RSTRING_LEN(obj), kCFStringEncodingMacRoman, false);
+		}
+		return string;
+	}
+}
+
+// Converts the keys and values of a Hash to CFTypeRefs
+int iterateHash(VALUE key, VALUE val, VALUE dict) {
+	CFPropertyListRef dKey = convertObject(key);
+	CFPropertyListRef dVal = convertObject(val);
+	CFDictionaryAddValue((CFMutableDictionaryRef)dict, dKey, dVal);
+	CFRelease(dKey);
+	CFRelease(dVal);
+	return ST_CONTINUE;
+}
+
+// Converts a Hash to a CFDictionaryREf
+CFDictionaryRef convertHash(VALUE obj) {
+	// RHASH_TBL exists in ruby 1.8.7 but not ruby 1.8.6
+#ifdef RHASH_TBL
+	st_table *tbl = RHASH_TBL(obj);
+#else
+	st_table *tbl = RHASH(obj)->tbl;
+#endif
+	CFIndex count = (CFIndex)tbl->num_entries;
+	CFMutableDictionaryRef dict = CFDictionaryCreateMutable(kCFAllocatorDefault, count, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+	st_foreach(tbl, iterateHash, (VALUE)dict);
+	return dict;
+}
+
+// Converts an Array to a CFArrayRef
+CFArrayRef convertArray(VALUE obj) {
+	CFIndex count = (CFIndex)RARRAY_LEN(obj);
+	CFMutableArrayRef array = CFArrayCreateMutable(kCFAllocatorDefault, count, &kCFTypeArrayCallBacks);
+	int i;
+	for (i = 0; i < count; i++) {
+		CFPropertyListRef aVal = convertObject(RARRAY_PTR(obj)[i]);
+		CFArrayAppendValue(array, aVal);
+		CFRelease(aVal);
+	}
+	return array;
+}
+
+// Converts a Number to a CFNumberRef
+CFNumberRef convertNumber(VALUE obj) {
+	void *valuePtr;
+	CFNumberType type;
+	switch (TYPE(obj)) {
+		case T_FLOAT: {
+			double num = NUM2DBL(obj);
+			valuePtr = &num;
+			type = kCFNumberDoubleType;
+			break;
+		}
+		case T_FIXNUM: {
+			int num = NUM2INT(obj);
+			valuePtr = &num;
+			type = kCFNumberIntType;
+			break;
+		}
+		case T_BIGNUM: {
+#ifdef NUM2LL
+			long long num = NUM2LL(obj);
+			type = kCFNumberLongLongType;
+#else
+			long num = NUM2LONG(obj);
+			type = kCFNumberLongType;
+#endif
+			valuePtr = &num;
+			break;
+		}
+		default:
+			rb_raise(rb_eStandardError, "ERROR: Wrong object type passed to convertNumber");
+			return NULL;
+	}
+	CFNumberRef number = CFNumberCreate(kCFAllocatorDefault, type, valuePtr);
+	return number;
+}
+
+// Converts a Time to a CFDateRef
+CFDateRef convertTime(VALUE obj) {
+	VALUE secs = rb_funcall(obj, id_minus, 1, timeEpoch);
+	CFDateRef date = CFDateCreate(kCFAllocatorDefault, NUM2DBL(secs));
+	return date;
+}
+
+/* call-seq:
+ *    str.blob?
+ *
+ * Returns whether or not +str+ is a blob.
+ */
+VALUE str_blob(VALUE self) {
+	VALUE blob = rb_attr_get(self, id_blob);
+	if (NIL_P(blob)) {
+		return Qfalse;
+	} else {
+		return blob;
+	}
+}
+
+/* call-seq:
+ *    str.blob = bool
+ *
+ * Sets the blob status of +str+.
+ */
+VALUE str_setBlob(VALUE self, VALUE b) {
+	if (TYPE(b) == T_TRUE || TYPE(b) ==  T_FALSE) {
+		return rb_ivar_set(self, id_blob, b);
+	} else {
+		rb_raise(rb_eArgError, "Argument 1 must be true or false");
+		return Qnil;
+	}
+}
+
+/*
+ * Document-module: OSX
+ */
+
+/*
+ * Document-module: OSX::PropertyList
+ *
+ * The PropertyList module provides a means of converting a
+ * Ruby Object to a Property List.
+ *
+ * The various Objects that can be converted are the ones
+ * with an equivalent in CoreFoundation. This includes: String,
+ * Integer, Float, Boolean, Time, Hash, and Array.
+ *
+ * See also: String#blob?, String#blob=, and Object#to_plist
+ */
+
+/*
+ * Document-class: OSX::PropertyListError
+ */
+void Init_plist() {
+	mOSX = rb_define_module("OSX");
+	mPlist = rb_define_module_under(mOSX, "PropertyList");
+	rb_define_module_function(mPlist, "load", plist_load, -1);
+	rb_define_module_function(mPlist, "dump", plist_dump, -1);
+	rb_define_method(rb_cObject, "to_plist", obj_to_plist, -1);
+	rb_define_method(rb_cString, "blob?", str_blob, 0);
+	rb_define_method(rb_cString, "blob=", str_setBlob, 1);
+	ePropertyListError = rb_define_class_under(mOSX, "PropertyListError", rb_eStandardError);
+	id_gm = rb_intern("gm");
+	timeEpoch = rb_funcall(rb_cTime, id_gm, 1, INT2FIX(2001));
+	/* Time.gm(2001): The Cocoa epoch of January 1st, 2001*/
+	rb_define_const(mPlist, "EPOCH", timeEpoch);
+	id_plus = rb_intern("+");
+	id_minus = rb_intern("-");
+	id_read = rb_intern("read");
+	id_write = rb_intern("write");
+	id_xml = rb_intern("xml1");
+	id_binary = rb_intern("binary1");
+	id_openstep = rb_intern("openstep");
+	id_blob = rb_intern("@blob");
+}

data/lib/osx/plist.rb

@@ -0,0 +1,18 @@
+require "#{File.dirname(__FILE__)}/plist/ext/plist"
+
+module OSX
+  module PropertyList
+    # Loads a property list from the file at +filepath+ using OSX::PropertyList.load.
+    def self.load_file(filepath, format = false)
+      File.open(filepath, "r") do |f|
+        OSX::PropertyList.load(f, format)
+      end
+    end
+    # Writes the property list representation of +obj+ to the file at +filepath+ using OSX::PropertyList.dump.
+    def self.dump_file(filepath, obj, format = :xml1)
+      File.open(filepath, "w") do |f|
+        OSX::PropertyList.dump(f, obj, format)
+      end
+    end
+  end
+end

data/test/fixtures/xml_plist

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/OSX::PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>string!</key>
+  <string>indeedy</string>
+  <key>bar</key>
+  <array>
+    <integer>1</integer>
+    <integer>2</integer>
+    <integer>3</integer>
+  </array>
+  <key>foo</key>
+  <dict>
+    <key>correct?</key>
+    <true/>
+    <key>pi</key>
+    <real>3.14159265</real>
+    <key>random</key>
+    <data>
+    I0VniQ==
+    </data>
+    <key>today</key>
+    <date>2005-04-28T06:32:56Z</date>
+  </dict>
+</dict>
+</plist>

data/test/suite.rb

@@ -0,0 +1,6 @@
+require 'test/unit'
+
+tests = Dir["#{File.dirname(__FILE__)}/test_*.rb"]
+tests.each do |file|
+  require file
+end

data/test/test_plist.rb

@@ -0,0 +1,88 @@
+require 'rubygems'
+require 'osx/plist'
+require 'stringio'
+require 'tempfile'
+require 'test/unit'
+
+class TestPlist < Test::Unit::TestCase
+  def test_string
+    plist = OSX::PropertyList.load("{foo = bar; }")
+    assert_equal( { "foo" => "bar" }, plist )
+
+    plist, format = OSX::PropertyList.load("{foo = bar; }", true)
+    assert_equal( { "foo" => "bar" }, plist )
+    assert_equal( :openstep, format )
+    
+    # make sure sources < 6 characters work
+    plist = OSX::PropertyList.load("foo")
+    assert_equal( "foo", plist )
+    
+    # make sure it works with format too
+    plist, format = OSX::PropertyList.load("foo", true)
+    assert_equal( "foo", plist )
+    assert_equal( :openstep, format )
+    
+    assert_raise(OSX::PropertyListError) { OSX::PropertyList.load("") }
+  end
+
+  def setup_hash
+    time = Time.gm(2005, 4, 28, 6, 32, 56)
+    random = "\x23\x45\x67\x89"
+    random.blob = true
+    {
+      "string!" => "indeedy",
+      "bar" => [ 1, 2, 3 ],
+      "foo" => {
+        "correct?" => true,
+        "pi" => 3.14159265,
+        "random" => random,
+        "today" => time,
+      }
+    }
+  end
+
+  def test_io
+    plist, format = OSX::PropertyList.load(File.read("#{File.dirname(__FILE__)}/fixtures/xml_plist"), true)
+
+    hash = setup_hash
+
+    assert_equal(hash, plist)
+    assert_equal(true, plist['foo']['random'].blob?)
+    assert_equal(false, plist['string!'].blob?)
+    
+    assert_equal(:xml1, format)
+  end
+
+  def test_dump
+    str = StringIO.new("", "w")
+    hash = setup_hash
+    OSX::PropertyList.dump(str, hash)
+    hash2 = OSX::PropertyList.load(str.string)
+    assert_equal(hash, hash2)
+  end
+
+  def test_to_plist
+    assert_raise(OSX::PropertyListError) { "foo".to_plist(:openstep) }
+    assert_equal("foo", OSX::PropertyList.load("foo".to_plist))
+    hash = setup_hash()
+    assert_equal(hash, OSX::PropertyList.load(hash.to_plist))
+  end
+
+  def test_load_file
+    plist, format = OSX::PropertyList.load_file("#{File.dirname(__FILE__)}/fixtures/xml_plist", true)
+
+    hash = setup_hash
+
+    assert_equal(hash, plist)
+    assert_equal(:xml1, format)
+  end
+
+  def test_dump_file
+    hash = setup_hash
+    Tempfile.open("test_plist") do |temp|
+      OSX::PropertyList.dump_file(temp.path, hash)
+      hash2 = OSX::PropertyList.load_file(temp.path)
+      assert_equal(hash, hash2)
+    end
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: osx-plist
+version: !ruby/object:Gem::Version 
+  hash: 17
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 3
+  version: 1.0.3
+platform: ruby
+authors: 
+- Kevin Ballard
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-21 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 2
+        - 3
+        - 3
+        version: 2.3.3
+  type: :development
+  version_requirements: *id001
+description: osx-plist is a Ruby library for manipulating Property Lists natively using the built-in support in OS X.
+email: 
+- kevin@sb.org
+executables: []
+
+extensions: 
+- ext/plist/extconf.rb
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- ext/plist/extconf.rb
+- ext/plist/plist.c
+- lib/osx/plist.rb
+- test/fixtures/xml_plist
+- test/suite.rb
+- test/test_plist.rb
+homepage: http://github.com/kballard/osx-plist
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: osx-plist
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: Property List manipulation for OS X
+test_files: 
+- test/test_plist.rb