plist4r 0.2.2 → 1.0.0

data/.gitignore

@@ -21,3 +21,7 @@ pkg
 ## PROJECT::SPECIFIC
 .yardoc
 doc
+
+# Ruby
+*.bundle
+

data/.yardopts

@@ -1 +1,12 @@
 --no-private
+--exclude "backend\/c_f_property_list\/cf*"
+--exclude "backend\/c_f_property_list\/rb*"
+--exclude "mixin\/haml4r*"
+-
+"lib/plist4r/docs/InfoPlistExample.rdoc"
+"lib/plist4r/docs/LaunchdPlistExample.rdoc"
+"lib/plist4r/docs/EditingPlistFiles.rdoc"
+"lib/plist4r/docs/PlistKeyNames.rdoc"
+"lib/plist4r/docs/Backends.html"
+"lib/plist4r/docs/DeveloperGuide.rdoc"
+"LICENSE"

data/LICENSE

@@ -1,4 +1,6 @@
-Copyright (c) 2009 dreamcat4
+= MIT License
+
+Copyright (c) 2009 Dreamcat4
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -1,10 +1,8 @@
 = plist4r
 
-Plist4r is a friendly ruby library for reading and writing plist files.
+Plist4r is a friendly rubygem / ruby lib for handling plist files.
 
-==== Current status: Beta, 0.2.x series
-
-We can read / write various kinds of plist files reliably. The API interfaces (for the pluggable backends and plist_types) are mature. The user API works well. Searchable Documentation is included, complete with examples.
+* Documentation at http://dreamcat4.github.com/plist4r
 
 == Installation
 
@@ -14,7 +12,7 @@ We can read / write various kinds of plist files reliably. The API interfaces (f
 
   require 'plist4r'
 
-  Plist4r::Config.default_dir "/Library/LaunchDaemons"
+  Plist4r::Config.default_path = "/Library/LaunchDaemons"
   filename = "com.github.myservice.plist"
   p = Plist4r.open(filename)
 
@@ -24,130 +22,35 @@ We can read / write various kinds of plist files reliably. The API interfaces (f
   p.file_format
   # => :xml
 
-  p.<< do
-    ProgramArguments ["/usr/local/bin/myservice"]
-  end
-
   p.edit do
-    WatchPaths ["/var/db/myservice"]
+    program_arguments ["/usr/local/bin/myservice"]
+    watch_paths ["/var/db/myservice"]
   end
 
   p.save
 
-== Plist4r Backends
-
-There are now a number of ruby libraries which can read / write plist files. The aim of plist4r is to utilize the individual best features from all of those libraries, as a series of "backends". And hide those behind a "frontend" that is easy to work with.
-
-Backends often only need to be a single ruby file, which implements the Plist4r API methods and calls out to other (existing) ruby code. No single backend has to provide the whole API. Instead, Plist4r simply iterates over all of the backends it knows about, and then calls the first backend that can responds to the API method.
-
-There are just 6 supported API methods
-
-  ApiMethods = %w[from_string to_xml to_binary to_next_step open save]
-
-And (as above) the 3 supported Plist file formats are
-
-  FileFormats = %w[binary xml next_step]
-
-We believe thats allright for most uses, and decided to include `next_step` for completeness. `NextStep` is also known by other names such as `OpenStep` and (more updated version) `GNU Step`. For example the apple `defaults` command on Mac OS-X will still return `NextStep` formatted plist data.
-
-== Plist4r Types
-
-A Plist type can be one of `%w[plist info launchd]`, and is the data type for the whole plist file. The plist data type provides convenience methods for setting the Type-specific data structures. For example "Sockets" in a launchd plist.
-
-Plist types are also useful to disallow keys which arent recognized or supported by that format. Setting `:strict_keys true` the Plist4r::Config object will globaly enable strict keys.
-
-  ::Plist4r::Config[:unsupported_keys] = true
-
-Or individually, per plist object with
-
-  plist.strict_keys false
-  
-Default is false, which allows editing of any arbitrary plist keys. We think thats a good choice, since unsupported keys can already be present in many existing plist files.
-
-== More Examples
-
-	module ::Plist4r::Backend::MyPlistReaderWriter
-	  # implement some plist4r api calls here
-	end
-  
-  # append my backend to the end of the list
-	Plist4r::Config[:backends] << :my_plist_reader_writer
-	
-	# or to the front of the list (executes first)
-	Plist4r::Config[:backends].insert 0 :my_plist_reader_writer
-  
-	# The default directory to load / save files from
-	Plist4r::Config.default_path "/Library/Cars"
-	
-	car = Plist4r.new("car.plist")
-	
-	car.load	
-  
-	car.file_format :binary
-  # car.plist_type  :car # not implemented *yet*
-	
-	car.save
-	
-	car.<< do
-	  road_legal true
-	  brake_light_color "red"
-	end
-	
-	car.save_as("car2.plist", :binary => true)
-	
-	car.<< do
-	  eyes "blue"
-	end
-	# => Exception, invalid plist key name "Eyes"
-	
-	car.<< do
-	  tyres "Pirelli"
-	end
-	
-	car.to_xml
-	# => xml string
-
-== Remaining Work
-
-Plist4r has now moved from alpha to beta - quality software. TBC...
-
-* Regression Tests (rspec)
-* Test harness for the backends
-* Testing of the individual backends
-* A Plist Type for Info.plist
-* Tests for Plist Types
-
-== Notes on Patches/Pull Requests
- 
-* Fork the project, and create a topic branch as per {these instructions}[http://wiki.opscode.com/display/opscode/Working+with+Git].
-* Make your feature addition or bug fix.
-* Include documentation for it.
-* Include a regression test for it. So I dont break it in a future version unintentionally.
-
-== Contributors
-
-Popen4
-* Ara T Howard
-
-ActiveSupport::OrderedHash
-* Copyright (c) 2005 David Hansson,
-* Copyright (c) 2007 Mauricio Fernandez, Sam Stephenson
-* Copyright (c) 2008 Steve Purcell, Josh Peek
-* Copyright (c) 2009 Christoffer Sawicki
-
-Mixlib::Config
-* Author:: Adam Jacob
-* Author:: Nuo Yan
-* Author:: Christopher Brown
-* Copyright:: Copyright (c) 2008 Opscode, Inc.
-
-Backends...
-
-Haml, Libxml4r, RubyCocoa
-* Dreamcat4
+== Overview
+
+* For convenience we invoke {Plist4r.open} and {Plist4r.new} to initially create a plist object.
+
+* And use {Plist4r::Config} to set any global configuration defaults.
+
+* See {file:Backends} for the backends performance data.
+
+Examples
+* See {file:InfoPlistExample}
+* See {file:LaunchdPlistExample}
+
+Recommended reading
+* See {file:EditingPlistFiles}
+* See {file:PlistKeyNames}
+* Please see the inline source-code documentation on {Plist4r::Plist}
+
+How to contribute
+* {file:DeveloperGuide}
 
 == Copyright
 
-Copyright (c) 2010 Dreamcat4. See LICENSE for details.
+Plist4r is Copyright (c) 2009 under MIT License. See {file:LICENSE} for details.
 
 

data/Rakefile

@@ -10,9 +10,13 @@ begin
     gem.email = "dreamcat4@gmail.com"
     gem.homepage = "http://github.com/dreamcat4/plist4r"
     gem.authors = ["dreamcat4"]
+    gem.add_dependency "libxml-ruby"
+    gem.add_dependency "haml"
+    gem.add_dependency "libxml4r"
     gem.add_development_dependency "rspec", ">= 1.2.9"
     gem.add_development_dependency "yard", ">= 0"
     gem.add_development_dependency "cucumber", ">= 0"
+    gem.files.include %w(lib/plist4r/cli.rb) # no idea why this file gets ommited
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new
@@ -47,6 +51,16 @@ end
 
 task :default => :spec
 
+namespace :backend do
+  task :tests do
+    require 'lib/plist4r'
+    require 'plist4r/backend/test/output'
+    o = Plist4r::Backend::Test::Output.new
+    puts o
+    o.write_html_file
+  end
+end
+
 require 'yard'
 YARD::Rake::YardocTask.new do |t|
   t.after = lambda { `touch doc/.nojekyll` }

data/VERSION

@@ -1 +1 @@
-0.2.2
+1.0.0

data/bin/plist4r

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 
+require 'rubygems'
+
 dir = File.expand_path "../lib", File.dirname(__FILE__)
 $LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
 

data/ext/osx_plist/Makefile

@@ -0,0 +1,157 @@
+
+SHELL = /bin/sh
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/1.8/universal-darwin10.0
+hdrdir = $(topdir)
+VPATH = $(srcdir):$(topdir):$(hdrdir)
+exec_prefix = $(prefix)
+prefix = $(DESTDIR)/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr
+sharedstatedir = $(prefix)/com
+mandir = $(DESTDIR)/usr/share/man
+psdir = $(docdir)
+oldincludedir = $(DESTDIR)/usr/include
+localedir = $(datarootdir)/locale
+bindir = $(exec_prefix)/bin
+libexecdir = $(exec_prefix)/libexec
+sitedir = $(DESTDIR)/Library/Ruby/Site
+htmldir = $(docdir)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+includedir = $(prefix)/include
+infodir = $(DESTDIR)/usr/share/info
+vendorlibdir = $(vendordir)/$(ruby_version)
+sysconfdir = $(prefix)/etc
+libdir = $(exec_prefix)/lib
+sbindir = $(exec_prefix)/sbin
+rubylibdir = $(libdir)/ruby/$(ruby_version)
+docdir = $(datarootdir)/doc/$(PACKAGE)
+dvidir = $(docdir)
+vendordir = $(libdir)/ruby/vendor_ruby
+datarootdir = $(prefix)/share
+pdfdir = $(docdir)
+archdir = $(rubylibdir)/$(arch)
+sitearchdir = $(sitelibdir)/$(sitearch)
+datadir = $(datarootdir)
+localstatedir = $(prefix)/var
+sitelibdir = $(sitedir)/$(ruby_version)
+
+CC = gcc
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = 
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)
+
+RUBY_EXTCONF_H = 
+CFLAGS   =  -fno-common -arch i386 -arch x86_64 -g -Os -pipe -fno-common -DENABLE_DTRACE  -fno-common  -pipe -fno-common $(cflags) 
+INCFLAGS = -I. -I$(topdir) -I$(hdrdir) -I$(srcdir)
+DEFS     = 
+CPPFLAGS =   -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE $(DEFS) $(cppflags)
+CXXFLAGS = $(CFLAGS) 
+ldflags  = -L. -arch i386 -arch x86_64  -framework CoreFoundation -undefined suppress -flat_namespace
+dldflags = 
+archflag = 
+DLDFLAGS = $(ldflags) $(dldflags) $(archflag)
+LDSHARED = cc -arch i386 -arch x86_64 -pipe -bundle -undefined dynamic_lookup
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = ruby
+RUBY_SO_NAME = ruby
+arch = universal-darwin10.0
+sitearch = universal-darwin10.0
+ruby_version = 1.8
+ruby = /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby
+RUBY = $(ruby)
+RM = rm -f
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = . $(libdir)
+LIBPATH =  -L. -L$(libdir)
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+
+extout = 
+extout_prefix = 
+target_prefix = /plist4r/backend/osx_plist/ext
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED)  -lpthread -ldl  
+SRCS = plist.c
+OBJS = plist.o
+TARGET = osx_plist
+DLLIB = $(TARGET).bundle
+EXTSTATIC = 
+STATIC_LIB = 
+
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).bundle $(TARGET).il? $(TARGET).tds $(TARGET).map
+CLEANOBJS     = *.o *.a *.s[ol] *.pdb *.exp *.bak
+
+all:		$(DLLIB)
+static:		$(STATIC_LIB)
+
+clean:
+		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
+
+distclean:	clean
+		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+
+realclean:	distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+$(RUBYARCHDIR):
+	$(MAKEDIRS) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .cxx .cpp .C .o
+
+.cc.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cxx.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cpp.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.C.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.c.o:
+	$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) -c $<
+
+$(DLLIB): $(OBJS) Makefile
+	@-$(RM) $@
+	$(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): ruby.h defines.h

data/ext/osx_plist/extconf.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/ruby
+
+if File.exists? "/System/Library/Frameworks/CoreFoundation.framework"
+  require 'mkmf'
+  $LDFLAGS += ' -framework CoreFoundation -undefined suppress -flat_namespace'
+  $LIBRUBYARG_SHARED=""
+  create_makefile("plist4r/backend/osx_plist/ext/osx_plist")
+end
+

data/ext/osx_plist/plist.c

@@ -0,0 +1,606 @@
+/*
+ * 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 mPlist4r;
+static VALUE mBackend;
+static VALUE mOsxPlist;
+
+
+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_osx_plist() {
+	mPlist4r = rb_define_module("Plist4r");
+
+    if (rb_const_defined_at(mPlist4r, rb_intern("Backend")))
+	    mBackend = rb_const_get_at(mPlist4r, rb_intern("Backend"));
+	else
+		mBackend = rb_define_class_under(mPlist4r, "Backend", 0);
+
+    if (rb_const_defined_at(mBackend, rb_intern("OsxPlist")))
+	    mOsxPlist = rb_const_get_at(mBackend, rb_intern("OsxPlist"));
+	else
+		mOsxPlist = rb_define_module_under(mBackend, "OsxPlist");
+
+	rb_define_module_function(mOsxPlist, "load", plist_load, -1);
+	rb_define_module_function(mOsxPlist, "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(mOsxPlist, "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);
+	rb_define_const(mOsxPlist, "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");
+}