rubycf 0.0.2

data/README

@@ -0,0 +1,20 @@
+Ruby extension for dealing with CoreFoundation types.  Mostly designed for marshaling structures through binary plists.
+
+See tests for usage.
+
+To get this to work outside of the OS X, you need to compile lib/CoreFoundation and link against it when building the gem.  This isn't build into extconf.rb yet, but it will need to be in the future.
+
+About CFData:
+Since Ruby doesn't treat strings any differently from raw data and CoreFoundation does, there needed to be a way to specify if a string is a string or if it's just data.  For this purpose, I've created the class RubyCF::Data, which is just a container for a ruby string.  When a RubyCF::Data object is passed into the plist encoder, it will encode the data as CFData.  Likewise, when a CFData object is encountered while decoding a plist, a RubyCF::Data object will be created.
+
+TODO
+--------------
+- rubyland convenience methods
+
+
+==========
+notes:
+
+Building CFLite:
+http://cafeine.crulrg.ulaval.ca/users/dccote/weblog/0514e/CoreFoundation_Lite_on_Linux.html
+http://developer.apple.com/opensource/cflite.html

data/extconf.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby -wKU
+
+require 'mkmf'
+
+if RUBY_PLATFORM.downcase.include?("darwin")
+  with_ldflags($LDFLAGS + ' -framework Foundation') {true}
+else
+  with_ldflags($LIBS + ' -lCoreFoundation') {true}
+end
+create_makefile('rubycf', 'lib')

data/lib/cfarray.c

@@ -0,0 +1,32 @@
+#import "cfarray.h"
+#import "plist.h"
+
+VALUE rbcf_array_convert_to_ruby(CFArrayRef array_ref) {
+
+    CFIndex count = CFArrayGetCount(array_ref);
+    CFIndex i = 0;
+    
+    VALUE array = rb_ary_new();
+    
+    for(i=0; i < count; ++i){
+        rb_ary_push(array, rbcf_plist_convert_to_ruby(CFArrayGetValueAtIndex(array_ref, i)));
+    }
+
+    OBJ_TAINT(array);
+    
+    return array;
+}
+
+CFArrayRef rbcf_array_convert_to_cf(VALUE array) {
+    CFIndex size = FIX2INT(rb_funcall(array, rb_intern("size"), 0));
+    CFIndex i;
+    CFTypeRef *values = (CFTypeRef *)malloc(size * sizeof(CFTypeRef));
+    for(i = 0; i < size; ++i){
+        values[i] = rbcf_plist_convert_to_cf(rb_ary_entry(array, i));
+    }
+    
+    CFArrayRef newArray = CFArrayCreate(kCFAllocatorDefault, values, size, &kCFTypeArrayCallBacks);
+    rbcf_register_for_release(newArray);
+    
+    return newArray;
+}

data/lib/cfarray.h

@@ -0,0 +1,5 @@
+#include <ruby.h>
+#include <CoreFoundation/CFArray.h>
+
+VALUE rbcf_array_convert_to_ruby(CFArrayRef array_ref);
+CFArrayRef rbcf_array_convert_to_cf(VALUE array);

data/lib/cfdata.c

@@ -0,0 +1,19 @@
+#include "cfdata.h"
+#include "plist.h"
+
+VALUE rbcf_data_convert_to_ruby(CFDataRef data_ref) {
+    VALUE rubydata = rb_eval_string("RubyCF::Data.new('')");
+    rb_funcall(rubydata, rb_intern("data="), 1, rb_str_new((char *)CFDataGetBytePtr(data_ref), CFDataGetLength(data_ref)));
+    OBJ_TAINT(rubydata);
+    return rubydata;
+}
+
+
+CFDataRef rbcf_data_convert_to_cf(VALUE data_obj) {
+    VALUE data_str = rb_iv_get(data_obj, "@data");
+    
+    CFDataRef outData = CFDataCreate(kCFAllocatorDefault, (UInt8 *)RSTRING(data_str)->ptr, RSTRING(data_str)->len);
+    rbcf_register_for_release(outData);
+    
+    return outData;
+}

data/lib/cfdata.h

@@ -0,0 +1,5 @@
+#include <ruby.h>
+#include <CoreFoundation/CFData.h>
+
+VALUE rbcf_data_convert_to_ruby(CFDataRef data_ref);
+CFDataRef rbcf_data_convert_to_cf(VALUE data);

data/lib/cfdate.c

@@ -0,0 +1,18 @@
+#import "cfdate.h"
+
+VALUE rbcf_date_convert_to_ruby(CFDateRef date_ref) {
+    //fixme: this isn't 100% accurate, but should be close enough
+    CFDateRef currentTime = CFDateCreate(NULL, CFAbsoluteTimeGetCurrent());
+    CFTimeInterval difference = CFDateGetTimeIntervalSinceDate(date_ref, currentTime);
+    
+    return rb_funcall(rb_funcall(rb_cTime, rb_intern("now"), 0), rb_intern("+"), 1, rb_float_new(difference));
+}
+
+CFDateRef rbcf_date_convert_to_cf(VALUE time) {
+    VALUE reference_date = rb_eval_string("Time.gm(2001, 'jan', 1)");
+    CFTimeInterval difference = NUM2DBL(rb_funcall(time, rb_intern("-"), 1, reference_date));
+    CFDateRef date = CFDateCreate(kCFAllocatorDefault, difference);
+    rbcf_register_for_release(date);
+    
+    return date;
+}

data/lib/cfdate.h

@@ -0,0 +1,5 @@
+#include <ruby.h>
+#include <CoreFoundation/CFDate.h>
+
+VALUE rbcf_date_convert_to_ruby(CFDateRef date_ref);
+CFDateRef rbcf_date_convert_to_cf(VALUE time);

data/lib/cfdictionary.c

@@ -0,0 +1,49 @@
+#import "cfdictionary.h"
+#import "plist.h"
+#import "cfstring.h"
+
+VALUE rbcf_dict_convert_to_ruby(CFDictionaryRef dict_ref) {
+    
+    CFIndex count = CFDictionaryGetCount(dict_ref);
+    CFIndex i;
+    
+    CFTypeRef *keys = (CFTypeRef *)malloc(count * sizeof(CFTypeRef));
+    CFTypeRef *values = (CFTypeRef *)malloc(count * sizeof(CFTypeRef));
+    CFDictionaryGetKeysAndValues(dict_ref, (const void **)keys, (const void **)values);
+    
+    VALUE hash = rb_hash_new();
+    
+    for(i=0; i < count; ++i){
+        rb_hash_aset(hash, rbcf_string_convert_to_ruby(keys[i]), rbcf_plist_convert_to_ruby(values[i]));
+    }
+    
+    free(keys);
+    free(values);
+
+    OBJ_TAINT(hash);
+    
+    return hash;
+}
+
+CFDictionaryRef rbcf_dict_convert_to_cf(VALUE hash) {
+    
+    VALUE flat_hash = rb_funcall(hash, rb_intern("to_a"), 0);
+    CFIndex size = FIX2INT(rb_funcall(hash, rb_intern("size"), 0));
+    CFTypeRef *keys = (CFTypeRef *)malloc(size * sizeof(CFTypeRef));
+    CFTypeRef *values = (CFTypeRef *)malloc(size * sizeof(CFTypeRef));
+    
+    CFIndex i;
+    for(i = 0; i < size; ++i){
+        // Ruby Hash keys can be any object.  Convert keys into strings before using as CFDictionary keys.
+        keys[i] = rbcf_plist_convert_to_cf(rb_funcall(rb_ary_entry(rb_ary_entry(flat_hash, i), 0), rb_intern("to_s"), 0));
+        values[i] = rbcf_plist_convert_to_cf(rb_ary_entry(rb_ary_entry(flat_hash, i), 1));
+    }
+    
+    CFDictionaryRef dictionary = CFDictionaryCreate(kCFAllocatorDefault, keys, values, size, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+    rbcf_register_for_release(dictionary);
+    
+    free(keys);
+    free(values);
+    
+    return dictionary;
+}

data/lib/cfdictionary.h

@@ -0,0 +1,5 @@
+#include <ruby.h>
+#include <CoreFoundation/CFDictionary.h>
+
+VALUE rbcf_dict_convert_to_ruby(CFDictionaryRef dict_ref);
+CFDictionaryRef rbcf_dict_convert_to_cf(VALUE hash);

data/lib/cfnumber.c

@@ -0,0 +1,55 @@
+#include "cfnumber.h"
+
+VALUE rbcf_boolean_convert_to_ruby(CFBooleanRef bool_ref) {
+    if(bool_ref == kCFBooleanTrue){
+        return Qtrue;
+    }
+    else {
+        return Qfalse;
+    }
+}
+
+VALUE rbcf_number_convert_to_ruby(CFNumberRef number_ref) {
+    if(CFNumberIsFloatType(number_ref)){
+        double value = 0.0;
+        if(CFNumberGetValue(number_ref, kCFNumberDoubleType, &value)){
+            return rb_float_new(value);
+        }
+    }
+    else{
+        long value = 0;
+        if(CFNumberGetValue(number_ref, kCFNumberLongType, &value)){
+            return INT2NUM(value);
+        }
+    }
+
+    return Qnil;
+}
+
+CFBooleanRef rbcf_boolean_convert_to_cf(VALUE boolean) {
+    if(boolean == Qtrue){
+        return kCFBooleanTrue;
+    }
+    else {
+        return kCFBooleanFalse;
+    }
+}
+
+CFNumberRef rbcf_number_convert_to_cf(VALUE number) {
+    if(rb_obj_is_kind_of(number, rb_cInteger) == Qtrue){
+        long value = NUM2LONG(number);
+        CFNumberRef outnum = CFNumberCreate(kCFAllocatorDefault, kCFNumberLongType, &value);
+        rbcf_register_for_release(outnum);
+        return outnum;
+    }
+    else if(rb_obj_is_kind_of(number, rb_cFloat) == Qtrue) {
+        double value = NUM2DBL(number);
+        CFNumberRef outnum = CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType, &value);
+        rbcf_register_for_release(outnum);
+        return outnum;
+    }
+    else {
+        return NULL;
+    }
+    
+}

data/lib/cfnumber.h

@@ -0,0 +1,8 @@
+#include <ruby.h>
+#include <CoreFoundation/CFNumber.h>
+
+VALUE rbcf_boolean_convert_to_ruby(CFBooleanRef bool_ref);
+VALUE rbcf_number_convert_to_ruby(CFNumberRef number_ref);
+
+CFBooleanRef rbcf_boolean_convert_to_cf(VALUE boolean);
+CFNumberRef rbcf_number_convert_to_cf(VALUE number);

data/lib/cfstring.c

@@ -0,0 +1,30 @@
+#include "cfstring.h"
+
+VALUE rbcf_string_convert_to_ruby(CFStringRef string_ref) {
+
+    char *buffer;
+    CFIndex bufferSize = CFStringGetLength(string_ref) + 1;
+    VALUE rubystring;
+
+    buffer = malloc(bufferSize + 1);
+
+    if(CFStringGetCString(string_ref, buffer, bufferSize, kCFStringEncodingASCII)){
+        rubystring = rb_str_new2(buffer);
+        OBJ_TAINT(rubystring);
+    }
+    else{
+        rubystring = Qnil;
+    }
+
+    free(buffer);
+    return rubystring;
+}
+
+CFStringRef rbcf_string_convert_to_cf(VALUE string) {
+    
+    CFIndex num_bytes;
+    char *bytes = rb_str2cstr(string, &num_bytes);
+    CFStringRef cfstring = CFStringCreateWithBytes(kCFAllocatorDefault, (UInt8 *)bytes, num_bytes, kCFStringEncodingASCII, false);
+    rbcf_register_for_release(cfstring);
+    return cfstring;
+}

data/lib/cfstring.h

@@ -0,0 +1,5 @@
+#include <ruby.h>
+#include <CoreFoundation/CFString.h>
+
+VALUE rbcf_string_convert_to_ruby(CFStringRef string_ref);
+CFStringRef rbcf_string_convert_to_cf(VALUE string);

data/lib/plist.c

@@ -0,0 +1,180 @@
+#include "plist.h"
+
+#include <CoreFoundation/CFBase.h>
+#include <CoreFoundation/CFString.h>
+#include <CoreFoundation/CFNumber.h>
+#include <CoreFoundation/CFStream.h>
+#include <CoreFoundation/CFDictionary.h>
+#include <CoreFoundation/CFArray.h>
+
+#include "cfstring.h"
+#include "cfnumber.h"
+#include "cfdate.h"
+#include "cfdictionary.h"
+#include "cfarray.h"
+#include "cfdata.h"
+
+void rbcf_reset_release_pool();
+static CFMutableArrayRef rbcf_plist_generation_release_pool;
+
+static const void *rbcf_retain(CFAllocatorRef ref, const void *obj){
+    CFRetain(obj);
+}
+
+static void rbcf_release(CFAllocatorRef ref, const void *obj){
+    CFRelease(obj);
+}
+
+static const CFArrayCallBacks poolarraycallbacks = {
+    0,
+    rbcf_retain,
+    rbcf_release,
+    NULL,
+    NULL
+};
+
+void rbcf_register_for_release(CFTypeRef obj) {
+    if(!rbcf_plist_generation_release_pool){
+        rbcf_plist_generation_release_pool = CFArrayCreateMutable(kCFAllocatorDefault, 0, &poolarraycallbacks);
+    }
+    CFArrayAppendValue(rbcf_plist_generation_release_pool, obj);
+    CFRelease(obj);
+}
+
+void rbcf_reset_release_pool() {
+    if(rbcf_plist_generation_release_pool){
+        CFRelease(rbcf_plist_generation_release_pool);
+        rbcf_plist_generation_release_pool = NULL;
+    }
+}
+
+VALUE rbcf_plist_convert_to_ruby(CFPropertyListRef plist) {
+    CFTypeID plist_type_id = CFGetTypeID(plist);
+
+    if(plist_type_id == CFStringGetTypeID()){
+        return rbcf_string_convert_to_ruby(plist);
+    }
+    else if(plist_type_id == CFBooleanGetTypeID()){
+        return rbcf_boolean_convert_to_ruby(plist);
+    }
+    else if(plist_type_id == CFNumberGetTypeID()){
+        return rbcf_number_convert_to_ruby(plist);
+    }
+    else if(plist_type_id == CFDateGetTypeID()){
+        return rbcf_date_convert_to_ruby(plist);
+    }
+    else if(plist_type_id == CFDataGetTypeID()){
+        return rbcf_data_convert_to_ruby(plist);
+    }
+    else if(plist_type_id == CFDictionaryGetTypeID()){
+        return rbcf_dict_convert_to_ruby(plist);
+    }
+    else if(plist_type_id == CFArrayGetTypeID()){
+        return rbcf_array_convert_to_ruby(plist);
+    }
+    else{
+        return Qnil;
+    }
+}
+
+CFPropertyListRef rbcf_plist_convert_to_cf(VALUE structure) {
+    VALUE out;
+    
+    if(rb_obj_is_kind_of(structure, rb_cString) == Qtrue){
+        return rbcf_string_convert_to_cf(structure);
+    }
+    else if(structure == Qtrue || structure == Qfalse){
+        return rbcf_boolean_convert_to_cf(structure);
+    }
+    else if(rb_obj_is_kind_of(structure, rb_cNumeric) == Qtrue){
+        return rbcf_number_convert_to_cf(structure);
+    }
+    else if(rb_obj_is_kind_of(structure, rb_cTime) == Qtrue){
+        return rbcf_date_convert_to_cf(structure);
+    }
+    else if(rb_obj_is_kind_of(structure, rb_eval_string("RubyCF::Data")) == Qtrue){
+        return rbcf_data_convert_to_cf(structure);
+    }
+    else if(rb_obj_is_kind_of(structure, rb_cArray) == Qtrue){
+        return rbcf_array_convert_to_cf(structure);
+    }
+    else if(rb_obj_is_kind_of(structure, rb_cHash) == Qtrue){
+        return rbcf_dict_convert_to_cf(structure);
+    }
+    else if(rb_respond_to(structure, rb_intern("to_hash"))){
+        return rbcf_dict_convert_to_cf(rb_funcall(structure, rb_intern("to_hash"), 0));
+    }
+    // default (depricated) behavior of to_a is to return [self], which is not helpful
+    else if(rb_respond_to(structure, rb_intern("to_a")) && 
+        rb_funcall(out = rb_funcall(structure, rb_intern("to_a"), 0), rb_intern("=="), 1, rb_ary_new3(1, structure)) == Qfalse
+    ){
+        return rbcf_array_convert_to_cf(out);
+    }
+    else if(rb_respond_to(structure, rb_intern("to_f"))){
+        return rbcf_number_convert_to_cf(rb_funcall(structure, rb_intern("to_f"), 0));
+    }
+    else if(rb_respond_to(structure, rb_intern("to_int"))){
+        return rbcf_number_convert_to_cf(rb_funcall(structure, rb_intern("to_i"), 0));
+    }
+    else if(rb_respond_to(structure, rb_intern("to_str"))){
+        return rbcf_string_convert_to_cf(rb_funcall(structure, rb_intern("to_s"), 0));
+    }
+    else {
+        return NULL;
+    }
+}
+
+
+VALUE rbcf_plist_parse(VALUE self, VALUE data) {
+    CFPropertyListFormat format; // the format of the plist
+    CFStringRef errorString; // Parsing error string
+
+    if(rb_obj_is_kind_of(data, rb_cString) == Qtrue){
+        CFReadStreamRef stream = CFReadStreamCreateWithBytesNoCopy(NULL, (UInt8 *)RSTRING(data)->ptr, RSTRING(data)->len, kCFAllocatorNull);
+
+        if(CFReadStreamOpen(stream)){
+            CFPropertyListRef plist = CFPropertyListCreateFromStream(NULL, stream, 0, kCFPropertyListImmutable, &format, &errorString);
+            CFReadStreamClose(stream);
+            CFRelease(stream);
+            if(plist){
+                VALUE plist_value = rbcf_plist_convert_to_ruby(plist);
+                CFRelease(plist);
+                rbcf_reset_release_pool();
+                return plist_value;
+            }
+
+        }
+    }
+
+    rbcf_reset_release_pool();
+    return Qnil;
+}
+
+
+VALUE rbcf_plist_encode(int argc, VALUE *argv, VALUE self) {
+    VALUE structure, encoding;
+    rb_scan_args(argc, argv, "11", &structure, &encoding);
+
+    CFPropertyListFormat format = kCFPropertyListBinaryFormat_v1_0; // the format of the plist
+    CFStringRef errorString; // Parsing error string
+
+    CFPropertyListRef cf_structure = rbcf_plist_convert_to_cf(structure);
+    CFWriteStreamRef stream = CFWriteStreamCreateWithAllocatedBuffers(kCFAllocatorDefault, kCFAllocatorDefault);
+    if(CFWriteStreamOpen(stream)){
+        CFIndex num_bytes = CFPropertyListWriteToStream(cf_structure, stream, format, &errorString);
+        if(num_bytes > 0){
+            CFTypeRef data = CFWriteStreamCopyProperty(stream, kCFStreamPropertyDataWritten);
+            rbcf_register_for_release(data);
+            CFRelease(stream);
+            if(data && CFGetTypeID(data) == CFDataGetTypeID()){
+                VALUE out_string = rb_str_new((char *)CFDataGetBytePtr(data), CFDataGetLength(data));
+                rbcf_reset_release_pool();
+                return out_string;
+            }
+        }
+    }
+    
+    rbcf_reset_release_pool();
+    return Qnil;
+}
+

data/lib/plist.h

@@ -0,0 +1,12 @@
+#include <ruby.h>
+#include <CoreFoundation/CFPropertyList.h>
+
+RUBY_EXTERN VALUE rb_cCFData;
+
+VALUE rbcf_plist_parse(VALUE self, VALUE data);
+VALUE rbcf_plist_encode(int argc, VALUE *argv, VALUE self);
+
+VALUE rbcf_plist_convert_to_ruby(CFPropertyListRef plist);
+CFPropertyListRef rbcf_plist_convert_to_cf(VALUE structure);
+
+void rbcf_register_for_release(CFTypeRef obj);

data/lib/rubycf.c

@@ -0,0 +1,27 @@
+/*
+ *  rubycf.c
+ *  rubycf
+ *
+ *  Created by Dave Grijalva on 12/22/08.
+ *  Copyright 2008 __MyCompanyName__. All rights reserved.
+ *
+ */
+
+#include <ruby.h>
+#include <CoreFoundation/CoreFoundation.h>
+#include "plist.h"
+
+static VALUE rb_mRubyCF;
+static VALUE rb_cPlist;
+
+void Init_rubycf (void)
+{
+  // Add the initialization code of your module here.
+    rb_mRubyCF = rb_define_module("RubyCF");
+
+    rb_cPlist = rb_define_class_under(rb_mRubyCF, "PList", rb_cObject);
+    rb_define_module_function(rb_cPlist, "parse", rbcf_plist_parse, 1);
+    rb_define_module_function(rb_cPlist, "encode", rbcf_plist_encode, -1);
+ 
+    rb_require("rubycf_extensions.rb");
+}

data/lib/rubycf_extensions.rb

@@ -0,0 +1,59 @@
+# Extensions to the build in C functions
+
+module RubyCF
+  class PList
+    class << self
+      alias decode parse
+    end
+
+    def self.parse_file file
+      self.parse(file.is_a?(File) ? file.read : File.read(file))
+    end
+  end
+  
+  # CF handles raw data different from strings.  Ruby treats them the same.
+  # use RubyCF::Data objects to tell the plist encoder to treat the objects
+  # as data.
+  class Data
+    attr_reader :data
+
+    def self.from_file file
+      Data.new(file.is_a?(File) ? file.read : File.read(file))
+    end
+
+    def initialize string
+      self.data = string
+    end
+
+    def inspect
+      "RubyCF::Data #{@data.size} bytes"
+    end
+    
+    def == other
+      if(other.is_a?(RubyCF::Data))
+        return other.data == @data
+      else
+        return other == @data
+      end
+    end
+    
+    def data= string
+      @data = string.to_s
+    end
+    
+  end
+end
+
+class Object
+  def to_plist
+    # supported types
+    # [Integer, Float, String, Array, Hash, RubyCF::Data].each do |klass|
+      return RubyCF::PList.encode(self) #if self.is_a? klass
+    # end
+    # 
+    # if self.resond_to? :to_hash
+    # elsif self.resond_to? :to_a
+    # elsif self.resond_to?
+    # 
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: rubycf
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Dave Grijalva
+autorequire: rubycf
+bindir: bin
+cert_chain: []
+
+date: 2009-11-02 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: 
+email: dgrijalva@ngmoco.com
+executables: []
+
+extensions: 
+- extconf.rb
+extra_rdoc_files: 
+- README
+files: 
+- lib/cfarray.c
+- lib/cfarray.h
+- lib/cfdata.c
+- lib/cfdata.h
+- lib/cfdate.c
+- lib/cfdate.h
+- lib/cfdictionary.c
+- lib/cfdictionary.h
+- lib/cfnumber.c
+- lib/cfnumber.h
+- lib/cfstring.c
+- lib/cfstring.h
+- lib/plist.c
+- lib/plist.h
+- lib/rubycf.c
+- lib/rubycf_extensions.rb
+- README
+has_rdoc: true
+homepage: http://ngmoco.com/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Bindings for Apple Core Foundation
+test_files: []
+