accessibility_core 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bd22e137f404608ca6b7cbb145104897d85e08fb
-  data.tar.gz: 6ce032c9c683c94e8f19c79723991ea6e6bf81a0
+  metadata.gz: 4cbd058164686f1cb295d5e5b2aef609c9bc0a0b
+  data.tar.gz: e5c662c8fae2eaa2391be2748d5f178e8c2da8c3
 SHA512:
-  metadata.gz: 878efe9ec2813bfb7a21ee9d6149c49a46941f467c631d8fefbda0f4d0c3c8825cc25b08b7637f0e3a2311ee9488a20b0154420f43fda4fbb462ab661ce43647
-  data.tar.gz: 10425a3d104e3326b4a1c32255193f36a7950f2a96819819f2000920df11547c764fa704321649dd4e0fda357ebb0c6da6f57e2fbde2fab1e2f63ffca1a12304
+  metadata.gz: fb57e3c3dad828b4c62d241971f8af1c767a8ddcd0db3ad7c0031423f178b91422ebf5566e364245be1814d1a85cbc8af6568b1ccd3cd310b3750f0bd43fe38b
+  data.tar.gz: 42cd3444bcc4a5c152d3cca0955b0407856fd9386c53e9b714f1f6b19f38a3c3cf3d479c0cccec04487c761e970ae581d53b385113538ab8be7f5523cc4c9c91

data/History.markdown

@@ -1,3 +1,9 @@
+# 0.5.0 - Yosemite Compatability
+
+  * Fix various warnings that show up when compiling against Yosemite system ruby
+  * Remove MacRuby support
+  * Convert test app to Swift
+
 # 0.4.3 - Oops, -Werror
 
   * Fix a C warning generated in the Sea Lion compatability code path

data/README.markdown

@@ -9,6 +9,8 @@ runtimes.
 [![Dependency Status](https://gemnasium.com/AXElements/accessibility_core.png)](https://gemnasium.com/AXElements/accessibility_core)
 [![Code Climate](https://codeclimate.com/github/AXElements/accessibility_core.png)](https://codeclimate.com/github/AXElements/accessibility_core)
 
+[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/AXElements/accessibility_core/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
+
 
 ## Examples
 
@@ -25,9 +27,10 @@ runtimes.
 
 ## TODO
 
-  * more descriptive error handling for the C extension
-  * handle string encodings that are not UTF8 (or a subset of UTF8)
-
+- [ ] run static analyzer on code and change warning level to -Weverything
+- [ ] remove all old MacRuby related code
+- [ ] more descriptive error handling
+- [ ] handle stirng encodings that are not UTF8
 
 ## Tests
 

data/Rakefile

@@ -1,17 +1,3 @@
-if defined? MACRUBY_REVISION
-  def on_macruby?
-    true
-  end
-else
-  def on_macruby?
-    false
-  end
-end
-
-def on_mri?
-  !on_macruby?
-end
-
 task :default => :test
 
 # @todo restore the clang analyze task, don't forget to add rubyhdrdir

data/ext/accessibility/bridge/bridge.c

@@ -1,18 +1,17 @@
 #include "bridge.h"
 #include "ruby/encoding.h"
+#include "assert.h"
 
 
 void
-spin(double seconds)
+spin(const double seconds)
 {
-  NSDate* interval = [NSDate dateWithTimeIntervalSinceNow:seconds];
+  NSDate* const interval = [NSDate dateWithTimeIntervalSinceNow:seconds];
   [[NSRunLoop currentRunLoop] runUntilDate:interval];
   [interval release];
 }
 
 
-#ifdef NOT_MACRUBY
-
 VALUE rb_cData;
 VALUE rb_cAttributedString;
 VALUE rb_mAccessibility;
@@ -37,154 +36,134 @@ ID sel_to_s;
 ID sel_parse;
 
 
-void
-cf_finalizer(void* obj)
-{
-  CFRelease((CFTypeRef)obj);
-}
-
-void
-objc_finalizer(void* obj)
+VALUE
+wrap_unknown(CFTypeRef const obj)
 {
-  [(id)obj release];
-}
+    // TODO: this will leak...
+    CFStringRef const description = CFCopyDescription(obj);
 
+    rb_raise(rb_eRuntimeError,
+             "accessibility-core doesn't know how to wrap `%s` objects yet",
+             CFStringGetCStringPtr(description, kCFStringEncodingMacRoman));
 
-VALUE
-wrap_unknown(CFTypeRef obj)
-{
-  // TODO: this will leak...
-  CFStringRef description = CFCopyDescription(obj);
-  rb_raise(
-           rb_eRuntimeError,
-	     "accessibility-core doesn't know how to wrap `%s` objects yet",
-	   CFStringGetCStringPtr(description, kCFStringEncodingMacRoman)
-	   );
-  return Qnil; // unreachable
+    return Qnil; // unreachable
 }
 
 CFTypeRef
-unwrap_unknown(VALUE obj)
+unwrap_unknown(const VALUE obj)
 {
   // TODO: rb_check_convert_type instead?
-  obj = rb_funcall(obj, sel_to_s, 0);
-  rb_raise(
-	   rb_eRuntimeError,
+  VALUE obj_string = rb_funcall(obj, sel_to_s, 0);
+  rb_raise(rb_eRuntimeError,
 	   "accessibility-core doesn't know how to unwrap `%s'",
-	   StringValuePtr(obj)
-	   );
+	   StringValuePtr(obj_string));
   return NULL; // unreachable
 }
 
 
 VALUE
-wrap_point(CGPoint point)
+wrap_point(const CGPoint point)
 {
   return rb_struct_new(rb_cCGPoint, DBL2NUM(point.x), DBL2NUM(point.y));
 }
 
 CGPoint
-unwrap_point(VALUE point)
+unwrap_point(const VALUE point)
 {
-  point = rb_funcall(point, sel_to_point, 0);
-  double x = NUM2DBL(rb_struct_getmember(point, sel_x));
-  double y = NUM2DBL(rb_struct_getmember(point, sel_y));
-  return CGPointMake(x, y);
+    const  VALUE p = rb_funcall(point, sel_to_point, 0);
+    const double x = NUM2DBL(rb_struct_getmember(p, sel_x));
+    const double y = NUM2DBL(rb_struct_getmember(p, sel_y));
+    return CGPointMake(x, y);
 }
 
 
 VALUE
-wrap_size(CGSize size)
+wrap_size(const CGSize size)
 {
   return rb_struct_new(rb_cCGSize, DBL2NUM(size.width), DBL2NUM(size.height));
 }
 
 CGSize
-unwrap_size(VALUE size)
+unwrap_size(const VALUE size)
 {
-  size = rb_funcall(size, sel_to_size, 0);
-  double width  = NUM2DBL(rb_struct_getmember(size, sel_width));
-  double height = NUM2DBL(rb_struct_getmember(size, sel_height));
-  return CGSizeMake(width, height);
+    const  VALUE      s = rb_funcall(size, sel_to_size, 0);
+    const double width  = NUM2DBL(rb_struct_getmember(s, sel_width));
+    const double height = NUM2DBL(rb_struct_getmember(s, sel_height));
+    return CGSizeMake(width, height);
 }
 
 
-
 VALUE
-wrap_rect(CGRect rect)
+wrap_rect(const CGRect rect)
 {
-  VALUE point = wrap_point(rect.origin);
-  VALUE  size = wrap_size(rect.size);
-  return rb_struct_new(rb_cCGRect, point, size);
+    const VALUE point = wrap_point(rect.origin);
+    const VALUE  size = wrap_size(rect.size);
+    return rb_struct_new(rb_cCGRect, point, size);
 }
 
 
 VALUE
-coerce_to_rect(VALUE obj)
+coerce_to_rect(const VALUE obj)
 {
   return rb_funcall(obj, sel_to_rect, 0);
 }
 
 CGRect
-unwrap_rect(VALUE rect)
+unwrap_rect(const VALUE rect)
 {
-  rect = rb_funcall(rect, sel_to_rect, 0);
-  CGPoint origin = unwrap_point(rb_struct_getmember(rect, sel_origin));
-  CGSize    size = unwrap_size(rb_struct_getmember(rect, sel_size));
-  return CGRectMake(origin.x, origin.y, size.width, size.height);
+    const   VALUE      r = rb_funcall(rect, sel_to_rect, 0);
+    const CGPoint origin = unwrap_point(rb_struct_getmember(r, sel_origin));
+    const CGSize    size = unwrap_size(rb_struct_getmember(r, sel_size));
+    return CGRectMake(origin.x, origin.y, size.width, size.height);
 }
 
 
 VALUE
-convert_cf_range(CFRange range)
+convert_cf_range(const CFRange range)
 {
-  CFIndex end_index = range.location + range.length;
-  if (range.length != 0)
-    end_index -= 1;
-  return rb_range_new(INT2FIX(range.location), INT2FIX(end_index), 0);
+    const CFIndex end_index =
+        range.location + (range.length ? range.length - 1 : 0);
+    return rb_range_new(INT2FIX(range.location), INT2FIX(end_index), 0);
 }
 
 CFRange
-convert_rb_range(VALUE range)
+convert_rb_range(const VALUE range)
 {
-  VALUE b, e;
-  int exclusive;
+    VALUE b, e;
+    int exclusive;
 
-  rb_range_values(range, &b, &e, &exclusive);
+    rb_range_values(range, &b, &e, &exclusive);
 
-  int begin = NUM2INT(b);
-  int   end = NUM2INT(e);
+    const int begin = NUM2INT(b);
+    const int   end = NUM2INT(e);
 
-  if (begin < 0 || end < 0)
-    // We don't know what the max length of the range will be, so we
-    // can't count backwards.
-    rb_raise(
-	     rb_eArgError,
-	     "negative values are not allowed in ranges " \
-	     "that are converted to CFRange structures."
-	     );
+    if (begin < 0 || end < 0)
+        // We don't know what the max length of the range will be, so we
+        // can't count backwards.
+        rb_raise(rb_eArgError,
+                 "negative values are not allowed in ranges "
+                 "that are converted to CFRange structures.");
 
-  int length = exclusive ? end-begin : end-begin + 1;
-  return CFRangeMake(begin, length);
+    const int length = exclusive ? end-begin : end-begin + 1;
+    return CFRangeMake(begin, length);
 }
 
 
-#define WRAP_VALUE(type, cookie, wrapper) do {	\
-    type st;					\
-    AXValueGetValue(value, cookie, &st);	\
-    return wrapper(st);				\
-  } while (0);					\
+#define WRAP_VALUE(type, cookie, wrapper)                       \
+    type st;                                                    \
+    const Boolean result = AXValueGetValue(value, cookie, &st);	\
+    assert(result);                                             \
+    return wrapper(st);
 
-VALUE wrap_value_point(AXValueRef value) { WRAP_VALUE(CGPoint,  kAXValueCGPointType, wrap_point) }
-VALUE wrap_value_size(AXValueRef value)  { WRAP_VALUE(CGSize,   kAXValueCGSizeType,  wrap_size)  }
-VALUE wrap_value_rect(AXValueRef value)  { WRAP_VALUE(CGRect,   kAXValueCGRectType,  wrap_rect)  }
-VALUE wrap_value_range(AXValueRef value) { WRAP_VALUE(CFRange,  kAXValueCFRangeType, convert_cf_range) }
-VALUE wrap_value_error(AXValueRef value) { WRAP_VALUE(AXError,  kAXValueAXErrorType, INT2NUM)    }
+VALUE wrap_value_point(AXValueRef const value) { WRAP_VALUE(CGPoint,  kAXValueCGPointType, wrap_point) }
+VALUE wrap_value_size(AXValueRef  const value) { WRAP_VALUE(CGSize,   kAXValueCGSizeType,  wrap_size)  }
+VALUE wrap_value_rect(AXValueRef  const value) { WRAP_VALUE(CGRect,   kAXValueCGRectType,  wrap_rect)  }
+VALUE wrap_value_range(AXValueRef const value) { WRAP_VALUE(CFRange,  kAXValueCFRangeType, convert_cf_range) }
+VALUE wrap_value_error(AXValueRef const value) { WRAP_VALUE(AXError,  kAXValueAXErrorType, INT2NUM)    }
 
-#define UNWRAP_VALUE(type, value, unwrapper) do {		\
-    type st = unwrapper(val);					\
-    return AXValueCreate(value, &st);				\
-  }  while(0);
+#define UNWRAP_VALUE(type, value, unwrapper)     \
+    const type st = unwrapper(val);              \
+    return AXValueCreate(value, &st);
 
 AXValueRef unwrap_value_point(VALUE val) { UNWRAP_VALUE(CGPoint, kAXValueCGPointType, unwrap_point) }
 AXValueRef unwrap_value_size(VALUE val)  { UNWRAP_VALUE(CGSize,  kAXValueCGSizeType,  unwrap_size)  }
@@ -193,232 +172,227 @@ AXValueRef unwrap_value_range(VALUE val) { UNWRAP_VALUE(CFRange, kAXValueCFRange
 
 
 VALUE
-wrap_value(AXValueRef value)
+wrap_value(AXValueRef const value)
 {
-  switch (AXValueGetType(value))
-    {
+    switch (AXValueGetType(value)) {
     case kAXValueIllegalType:
-      rb_raise(rb_eArgError, "cannot wrap %s objects", rb_class2name(CLASS_OF(value)));
+        rb_raise(rb_eArgError, "cannot wrap %s objects", rb_class2name(CLASS_OF(value)));
     case kAXValueCGPointType:
-      return wrap_value_point(value);
+        return wrap_value_point(value);
     case kAXValueCGSizeType:
-      return wrap_value_size(value);
+        return wrap_value_size(value);
     case kAXValueCGRectType:
-      return wrap_value_rect(value);
+        return wrap_value_rect(value);
     case kAXValueCFRangeType:
-      return wrap_value_range(value);
+        return wrap_value_range(value);
     case kAXValueAXErrorType:
-      return wrap_value_error(value);
+        return wrap_value_error(value);
     default:
-      // TODO better error message
-      rb_raise(
-	       rb_eRuntimeError,
-	       "Either accessibility_core is out of date or your system has had a serious error"
-	       );
+        // TODO better error message
+        rb_raise(rb_eRuntimeError,
+                 "Either accessibility_core is out of date or your system "
+                 "has had a serious error");
     }
 
-  return Qnil; // unreachable
+    return Qnil; // unreachable
 }
 
 AXValueRef
-unwrap_value(VALUE value)
-{
-  VALUE type = CLASS_OF(value);
-  if (type == rb_cCGPoint)
-    return unwrap_value_point(value);
-  else if (type == rb_cCGSize)
-    return unwrap_value_size(value);
-  else if (type == rb_cCGRect)
-    return unwrap_value_rect(value);
-  else if (type == rb_cRange)
-    return unwrap_value_range(value);
-
-  rb_raise(rb_eArgError, "could not wrap %s", rb_class2name(type));
-  return NULL; // unreachable
+unwrap_value(const VALUE value)
+{
+    const VALUE type = CLASS_OF(value);
+    if (type == rb_cCGPoint)
+        return unwrap_value_point(value);
+    else if (type == rb_cCGSize)
+        return unwrap_value_size(value);
+    else if (type == rb_cCGRect)
+        return unwrap_value_rect(value);
+    else if (type == rb_cRange)
+        return unwrap_value_range(value);
+
+    rb_raise(rb_eArgError, "could not wrap %s", rb_class2name(type));
+    return NULL; // unreachable
 }
 
-VALUE wrap_array_values(CFArrayRef array) { WRAP_ARRAY(wrap_value) }
+VALUE wrap_array_values(CFArrayRef const array) { WRAP_ARRAY(wrap_value) }
 
 
-VALUE wrap_ref(AXUIElementRef obj) { WRAP_OBJC(rb_cElement, cf_finalizer); }
+VALUE wrap_ref(AXUIElementRef const obj) { WRAP_OBJC(rb_cElement, cf_finalizer); }
 
 AXUIElementRef
-unwrap_ref(VALUE obj)
+unwrap_ref(const VALUE obj)
 {
-  AXUIElementRef* ref;
-  Data_Get_Struct(obj, AXUIElementRef, ref);
-  // TODO we should return *ref? but that seems to fuck things up...
-  return (AXUIElementRef)ref;
+    AXUIElementRef* ref;
+    Data_Get_Struct(obj, AXUIElementRef, ref);
+    // TODO we should return *ref? but that seems to fuck things up...
+    return (AXUIElementRef)ref;
 }
 
-VALUE wrap_array_refs(CFArrayRef array) { WRAP_ARRAY(wrap_ref) }
+VALUE wrap_array_refs(CFArrayRef const array) { WRAP_ARRAY(wrap_ref) }
 
 
 VALUE
-wrap_string(CFStringRef string)
+wrap_string(CFStringRef const string)
 {
-  VALUE   rb_str = Qnil;
-  CFDataRef data = CFStringCreateExternalRepresentation(
-							NULL,
-							string,
-							kCFStringEncodingUTF8,
-							0
-							);
-  if (data) {
-    rb_str = rb_enc_str_new(
-			    (char*)CFDataGetBytePtr(data),
-			    CFDataGetLength(data),
-			    rb_utf8_encoding()
-			    );
-    CFRelease(data);
-  }
-  else {
+    CFDataRef const data =
+        CFStringCreateExternalRepresentation(NULL,
+                                             string,
+                                             kCFStringEncodingUTF8,
+                                             0);
+    if (data) {
+        const VALUE rb_str =
+            rb_enc_str_new((char*)CFDataGetBytePtr(data),
+                           CFDataGetLength(data),
+                           rb_utf8_encoding());
+        CFRelease(data);
+        return rb_str;
+    }
+
     CFRelease(data);
-    CFShow(string);
+    CFShow(string); // uhh....why?
     rb_raise(rb_eRuntimeError, "Could not convert a string to a Ruby string");
-  }
-
-  return rb_str;
+    return Qnil;
 }
 
 VALUE
-wrap_nsstring(NSString* string)
+wrap_nsstring(NSString* const string)
 {
   return wrap_string((CFStringRef)string);
 }
 
 CFStringRef
-unwrap_string(VALUE string)
+unwrap_string(const VALUE string)
 {
-  return CFStringCreateWithBytes(
-                                 NULL,
-                                 (UInt8*)StringValueCStr(string),
-                                 RSTRING_LEN(string),
-                                 kCFStringEncodingUTF8,
-                                 false
-                                 );
+    volatile VALUE str = string; // StringValue needs volatility guarantees :(
+    return CFStringCreateWithBytes(NULL,
+                                   (UInt8*)StringValueCStr(str),
+                                   RSTRING_LEN(string),
+                                   kCFStringEncodingUTF8,
+                                   false);
 }
 
 NSString*
-unwrap_nsstring(VALUE string)
+unwrap_nsstring(const VALUE string)
 {
   return (NSString*)unwrap_string(string);
 }
 
-VALUE wrap_array_strings(CFArrayRef array) { WRAP_ARRAY(wrap_string); }
-VALUE wrap_array_nsstrings(NSArray* ary)
+VALUE wrap_array_strings(CFArrayRef const array) { WRAP_ARRAY(wrap_string); }
+VALUE wrap_array_nsstrings(NSArray* const ary)
 {
-  CFArrayRef array = (CFArrayRef)ary;
+  CFArrayRef const array = (CFArrayRef const)ary;
   WRAP_ARRAY(wrap_string);
 }
 
 
 VALUE
-wrap_attributed_string(CFAttributedStringRef string)
+wrap_attributed_string(CFAttributedStringRef const string)
 {
-  return wrap_nsattributed_string((NSAttributedString*)string);
+  return wrap_nsattributed_string((NSAttributedString* const)string);
 }
 
 VALUE
-wrap_nsattributed_string(NSAttributedString* obj)
+wrap_nsattributed_string(NSAttributedString* const obj)
 {
   WRAP_OBJC(rb_cAttributedString, objc_finalizer);
 }
 
 CFAttributedStringRef
-unwrap_attributed_string(VALUE string)
+unwrap_attributed_string(const VALUE string)
 {
   return (CFAttributedStringRef)unwrap_nsattributed_string(string);
 }
 
 NSAttributedString*
-unwrap_nsattributed_string(VALUE obj)
+unwrap_nsattributed_string(const VALUE obj)
 {
   UNWRAP_OBJC(NSAttributedString);
 }
 
 VALUE
-wrap_array_attributed_strings(CFArrayRef array)
+wrap_array_attributed_strings(CFArrayRef const array)
 {
   WRAP_ARRAY(wrap_attributed_string);
 }
 
-VALUE wrap_array_nsattributed_strings(NSArray* ary)
+VALUE wrap_array_nsattributed_strings(NSArray* const ary)
 {
-  CFArrayRef array = (CFArrayRef)ary;
+  CFArrayRef const array = (CFArrayRef)ary;
   WRAP_ARRAY(wrap_nsattributed_string);
 }
 
 static
 VALUE
-rb_astring_alloc(VALUE self)
+rb_astring_alloc(const VALUE self)
 {
   return wrap_nsattributed_string([NSAttributedString alloc]);
 }
 
 static
 VALUE
-rb_astring_init_with_string(int argc, VALUE* argv, VALUE self)
+rb_astring_init_with_string(const int argc, VALUE* const argv, const VALUE self)
 {
-  if (!argc)
-    rb_raise(rb_eArgError, "wrong number of arguments (0 for 1+)");
+    if (!argc)
+        rb_raise(rb_eArgError, "wrong number of arguments (0 for 1+)");
 
-  NSString*              nsstring = unwrap_nsstring(argv[0]);
-  NSAttributedString* old_astring = unwrap_nsattributed_string(self);
-  NSAttributedString* new_astring = [old_astring initWithString:nsstring];
-  [nsstring release];
-  if (old_astring == new_astring)
-    return self;
-  return wrap_nsattributed_string(new_astring);
+    NSString* const              nsstring =
+        unwrap_nsstring(argv[0]);
+    NSAttributedString* const old_astring =
+        unwrap_nsattributed_string(self);
+    NSAttributedString* const new_astring =
+        [old_astring initWithString:nsstring];
+    [nsstring release];
+
+    if (old_astring == new_astring)
+        return self;
+    return wrap_nsattributed_string(new_astring);
 }
 
 static
 VALUE
-rb_astring_string(VALUE self)
+rb_astring_string(const VALUE self)
 {
-  NSString* string = [unwrap_nsattributed_string(self) string];
-  VALUE     rb_str = wrap_nsstring(string);
-  return rb_str;
+    NSString* const string = [unwrap_nsattributed_string(self) string];
+    const VALUE     rb_str = wrap_nsstring(string);
+    return rb_str;
 }
 
 static
 VALUE
-rb_astring_length(VALUE self)
+rb_astring_length(const VALUE self)
 {
   return ULONG2NUM([unwrap_nsattributed_string(self) length]);
 }
 
 static
 VALUE
-rb_astring_equality(VALUE self, VALUE other)
+rb_astring_equality(const VALUE self, const VALUE other)
 {
   OBJC_EQUALITY(rb_cAttributedString, unwrap_nsattributed_string);
 }
 
 
-#define WRAP_NUM(type, cookie, macro) do {		        \
+#define WRAP_NUM(type, cookie, macro)                           \
     type value;							\
     if (CFNumberGetValue(num, cookie, &value))			\
-      return macro(value);					\
+        return macro(value);					\
     rb_raise(rb_eRuntimeError, "I goofed wrapping a number");	\
-    return Qnil;						\
-  } while(0);
+    return Qnil;
 
-VALUE wrap_long(CFNumberRef num)      { WRAP_NUM(long,      kCFNumberLongType,     LONG2FIX) }
-VALUE wrap_long_long(CFNumberRef num) { WRAP_NUM(long long, kCFNumberLongLongType, LL2NUM)   }
-VALUE wrap_float(CFNumberRef num)     { WRAP_NUM(double,    kCFNumberDoubleType,   DBL2NUM)  }
+VALUE wrap_long(CFNumberRef const num)      { WRAP_NUM(long,      kCFNumberLongType,     LONG2FIX) }
+VALUE wrap_long_long(CFNumberRef const num) { WRAP_NUM(long long, kCFNumberLongLongType, LL2NUM)   }
+VALUE wrap_float(CFNumberRef const num)     { WRAP_NUM(double,    kCFNumberDoubleType,   DBL2NUM)  }
 
-#define UNWRAP_NUM(type, cookie, macro) do {	\
-    type base = macro(num);			\
-    return CFNumberCreate(NULL, cookie, &base); \
-  } while(0);
+#define UNWRAP_NUM(type, cookie, macro)         \
+    const type base = macro(num);		\
+    return CFNumberCreate(NULL, cookie, &base);
 
-CFNumberRef unwrap_long(VALUE num)      { UNWRAP_NUM(long,      kCFNumberLongType,     NUM2LONG) }
-CFNumberRef unwrap_long_long(VALUE num) { UNWRAP_NUM(long long, kCFNumberLongLongType, NUM2LL)   }
-CFNumberRef unwrap_float(VALUE num)     { UNWRAP_NUM(double,    kCFNumberDoubleType,   NUM2DBL)  }
+CFNumberRef unwrap_long(const VALUE num)      { UNWRAP_NUM(long,      kCFNumberLongType,     NUM2LONG) }
+CFNumberRef unwrap_long_long(const VALUE num) { UNWRAP_NUM(long long, kCFNumberLongLongType, NUM2LL)   }
+CFNumberRef unwrap_float(const VALUE num)     { UNWRAP_NUM(double,    kCFNumberDoubleType,   NUM2DBL)  }
 
 VALUE
-wrap_number(CFNumberRef number)
+wrap_number(CFNumberRef const number)
 {
   switch (CFNumberGetType(number))
     {
@@ -451,7 +425,7 @@ wrap_number(CFNumberRef number)
 }
 
 CFNumberRef
-unwrap_number(VALUE number)
+unwrap_number(const VALUE number)
 {
   switch (TYPE(number))
     {
@@ -459,218 +433,217 @@ unwrap_number(VALUE number)
       return unwrap_long(number);
     case T_FLOAT:
       return unwrap_float(number);
-    default:
-      rb_raise(
-	       rb_eRuntimeError,
-	       "wrapping %s is not supported; log a bug?",
-	       rb_string_value_cstr(&number)
-	       );
-      return kCFNumberNegativeInfinity; // unreachable
+    default: {
+        volatile VALUE num = number;
+        rb_raise(rb_eRuntimeError,
+                 "wrapping %s is not supported; log a bug?",
+                 rb_string_value_cstr(&num));
+        return kCFNumberNegativeInfinity; // unreachable
+    }
     }
 }
 
-VALUE wrap_array_numbers(CFArrayRef array) { WRAP_ARRAY(wrap_number) }
+VALUE wrap_array_numbers(CFArrayRef const array) { WRAP_ARRAY(wrap_number) }
 
 
 
 VALUE
-wrap_url(CFURLRef url)
+wrap_url(CFURLRef const url)
 {
   // @note CFURLGetString does not need to be CFReleased since it is a Get
   return rb_funcall(rb_mURI, sel_parse, 1, wrap_string(CFURLGetString(url)));
 }
 
 VALUE
-wrap_nsurl(NSURL* url)
+wrap_nsurl(NSURL* const url)
 {
-  NSString* str = [url absoluteString];
-  VALUE  rb_str = wrap_nsstring(str);
+  NSString* const str = [url absoluteString];
+  const VALUE  rb_str = wrap_nsstring(str);
   [str release];
   return rb_funcall(rb_mURI, sel_parse, 1, rb_str);
 }
 
 CFURLRef
-unwrap_url(VALUE url)
+unwrap_url(const VALUE url)
 {
   // TODO: should also force encoding to UTF-8 first?
-  url = rb_funcall(url, sel_to_s, 0);
-  CFStringRef string = CFStringCreateWithCString(
-						 NULL,
-						 StringValuePtr(url),
-						 kCFStringEncodingUTF8
-						 );
-  CFURLRef url_ref = CFURLCreateWithString(NULL, string, NULL);
-  CFRelease(string);
-  return url_ref;
+    VALUE url_string = rb_funcall(url, sel_to_s, 0);
+    CFStringRef const string =
+        CFStringCreateWithCString(NULL,
+                                  StringValuePtr(url_string),
+                                  kCFStringEncodingUTF8);
+    CFURLRef const url_ref = CFURLCreateWithString(NULL, string, NULL);
+    CFRelease(string);
+    return url_ref;
 }
 
 NSURL*
-unwrap_nsurl(VALUE url)
+unwrap_nsurl(const VALUE url)
 {
   return (NSURL*)unwrap_url(url);
 }
 
-VALUE wrap_array_urls(CFArrayRef array) { WRAP_ARRAY(wrap_url) }
+VALUE wrap_array_urls(CFArrayRef const array) { WRAP_ARRAY(wrap_url) }
 
 
 VALUE
-wrap_date(CFDateRef date)
+wrap_date(CFDateRef const date)
 {
-  NSTimeInterval time = [(NSDate*)date timeIntervalSince1970];
-  return rb_time_new((time_t)time, 0);
+    const NSTimeInterval time = [(NSDate*)date timeIntervalSince1970];
+    return rb_time_new((time_t)time, 0);
 }
 
 VALUE
-wrap_nsdate(NSDate* date)
+wrap_nsdate(NSDate* const date)
 {
   return wrap_date((CFDateRef)date);
 }
 
 CFDateRef
-unwrap_date(VALUE date)
+unwrap_date(const VALUE date)
 {
-  struct timeval t = rb_time_timeval(date);
-  NSDate* ns_date = [NSDate dateWithTimeIntervalSince1970:t.tv_sec];
-  return (CFDateRef)ns_date;
+    const struct timeval t = rb_time_timeval(date);
+    NSDate* const ns_date = [NSDate dateWithTimeIntervalSince1970:t.tv_sec];
+    return (CFDateRef)ns_date;
 }
 
-VALUE wrap_array_dates(CFArrayRef array) { WRAP_ARRAY(wrap_date) }
+VALUE wrap_array_dates(CFArrayRef const array) { WRAP_ARRAY(wrap_date) }
 
 
 VALUE
-wrap_boolean(CFBooleanRef bool_val)
+wrap_boolean(CFBooleanRef const bool_val)
 {
   return (CFBooleanGetValue(bool_val) ? Qtrue : Qfalse);
 }
 
 CFBooleanRef
-unwrap_boolean(VALUE bool_val)
+unwrap_boolean(const VALUE bool_val)
 {
   return (bool_val == Qtrue ? kCFBooleanTrue : kCFBooleanFalse);
 }
 
-VALUE wrap_array_booleans(CFArrayRef array) { WRAP_ARRAY(wrap_boolean) }
+VALUE wrap_array_booleans(CFArrayRef const array) { WRAP_ARRAY(wrap_boolean) }
 
 
 VALUE
-wrap_array(CFArrayRef array)
+wrap_array(CFArrayRef const array)
 {
-  CFIndex length = CFArrayGetCount(array);
-  if (length) {
-    CFTypeRef obj = CFArrayGetValueAtIndex(array, 0);
-    CFTypeID   di = CFGetTypeID(obj);
-    if      (di == AXUIElementGetTypeID())  return wrap_array_refs(array);
-    else if (di == AXValueGetTypeID())      return wrap_array_values(array);
-    else if (di == CFStringGetTypeID())     return wrap_array_strings(array);
-    else if (di == CFNumberGetTypeID())     return wrap_array_numbers(array);
-    else if (di == CFBooleanGetTypeID())    return wrap_array_booleans(array);
-    else if (di == CFURLGetTypeID())        return wrap_array_urls(array);
-    else if (di == CFDateGetTypeID())       return wrap_array_dates(array);
-    else if (di == CFDictionaryGetTypeID()) return wrap_array_dictionaries(array);
-    else                                    return wrap_unknown(obj);
-  }
-  return rb_ary_new();
+    const CFIndex length = CFArrayGetCount(array);
+    if (length) {
+        const CFTypeRef obj = CFArrayGetValueAtIndex(array, 0);
+        const CFTypeID   di = CFGetTypeID(obj);
+        if      (di == AXUIElementGetTypeID())  return wrap_array_refs(array);
+        else if (di == AXValueGetTypeID())      return wrap_array_values(array);
+        else if (di == CFStringGetTypeID())     return wrap_array_strings(array);
+        else if (di == CFNumberGetTypeID())     return wrap_array_numbers(array);
+        else if (di == CFBooleanGetTypeID())    return wrap_array_booleans(array);
+        else if (di == CFURLGetTypeID())        return wrap_array_urls(array);
+        else if (di == CFDateGetTypeID())       return wrap_array_dates(array);
+        else if (di == CFDictionaryGetTypeID()) return wrap_array_dictionaries(array);
+        else                                    return wrap_unknown(obj);
+    }
+    return rb_ary_new();
 }
 
 
 VALUE
-wrap_dictionary(NSDictionary* dict)
+wrap_dictionary(NSDictionary* const dict)
 {
-  __block VALUE hash = rb_hash_new();
+    const VALUE hash = rb_hash_new();
 
-  [dict enumerateKeysAndObjectsUsingBlock: ^(id key, id obj, BOOL* stop) {
-      rb_hash_aset(hash, to_ruby(key), to_ruby(obj));
-    }];
+    [dict enumerateKeysAndObjectsUsingBlock:
+     ^(const id key, const id obj, BOOL* const stop) {
+            rb_hash_aset(hash, to_ruby(key), to_ruby(obj));
+        }];
 
   return hash;
 }
 
-VALUE wrap_array_dictionaries(CFArrayRef array) { WRAP_ARRAY(wrap_dictionary); }
+VALUE wrap_array_dictionaries(CFArrayRef const array) { WRAP_ARRAY(wrap_dictionary); }
 
 
 VALUE
-to_ruby(CFTypeRef obj)
+to_ruby(CFTypeRef const obj)
 {
-  CFTypeID di = CFGetTypeID(obj);
-  if      (di == CFArrayGetTypeID())            return wrap_array(obj);
-  else if (di == AXUIElementGetTypeID())        return wrap_ref(obj);
-  else if (di == AXValueGetTypeID())            return wrap_value(obj);
-  else if (di == CFStringGetTypeID())           return wrap_string(obj);
-  else if (di == CFNumberGetTypeID())           return wrap_number(obj);
-  else if (di == CFBooleanGetTypeID())          return wrap_boolean(obj);
-  else if (di == CFURLGetTypeID())              return wrap_url(obj);
-  else if (di == CFDateGetTypeID())             return wrap_date(obj);
-  else if (di == CFDataGetTypeID())             return wrap_data(obj);
-  else if (di == CFAttributedStringGetTypeID()) return wrap_attributed_string(obj);
-  else if (di == CFDictionaryGetTypeID())       return wrap_dictionary(obj);
-  else                                          return wrap_unknown(obj);
+    const CFTypeID di = CFGetTypeID(obj);
+    if      (di == CFArrayGetTypeID())            return wrap_array(obj);
+    else if (di == AXUIElementGetTypeID())        return wrap_ref(obj);
+    else if (di == AXValueGetTypeID())            return wrap_value(obj);
+    else if (di == CFStringGetTypeID())           return wrap_string(obj);
+    else if (di == CFNumberGetTypeID())           return wrap_number(obj);
+    else if (di == CFBooleanGetTypeID())          return wrap_boolean(obj);
+    else if (di == CFURLGetTypeID())              return wrap_url(obj);
+    else if (di == CFDateGetTypeID())             return wrap_date(obj);
+    else if (di == CFDataGetTypeID())             return wrap_data(obj);
+    else if (di == CFAttributedStringGetTypeID()) return wrap_attributed_string(obj);
+    else if (di == CFDictionaryGetTypeID())       return wrap_dictionary(obj);
+    else                                          return wrap_unknown(obj);
 }
 
 CFTypeRef
-to_ax(VALUE obj)
+to_ax(const VALUE obj)
 {
-  switch (TYPE(obj))
-    {
+    switch (TYPE(obj)) {
     case T_STRING:
-      return unwrap_string(obj);
+        return unwrap_string(obj);
     case T_FIXNUM:
-      return unwrap_number(obj);
+        return unwrap_number(obj);
     case T_STRUCT:
-      return unwrap_value(obj);
+        return unwrap_value(obj);
     case T_FLOAT:
-      return unwrap_number(obj);
+        return unwrap_number(obj);
     case T_TRUE:
-      return kCFBooleanTrue;
+        return kCFBooleanTrue;
     case T_FALSE:
-      return kCFBooleanFalse;
+        return kCFBooleanFalse;
     }
 
-  VALUE type = CLASS_OF(obj);
-  if (type == rb_cTime)
-    return unwrap_date(obj);
-  else if (type == rb_cRange)
-    return unwrap_value_range(obj);
-  else if (type == rb_cAttributedString)
-    return unwrap_attributed_string(obj);
-  else if (type == rb_cData)
-    return unwrap_data(obj);
+    const VALUE type = CLASS_OF(obj);
+    if (type == rb_cTime)
+        return unwrap_date(obj);
+    else if (type == rb_cRange)
+        return unwrap_value_range(obj);
+    else if (type == rb_cAttributedString)
+        return unwrap_attributed_string(obj);
+    else if (type == rb_cData)
+        return unwrap_data(obj);
 
-  if (rb_obj_is_kind_of(obj, rb_cURI))
-    return unwrap_url(obj);
+    if (rb_obj_is_kind_of(obj, rb_cURI))
+        return unwrap_url(obj);
 
-  // give up if we get this far
-  return unwrap_unknown(obj);
+    // give up if we get this far
+    return unwrap_unknown(obj);
 }
 
 
 VALUE
-wrap_data(CFDataRef data)
+wrap_data(CFDataRef const data)
 {
   return wrap_nsdata((NSData*)data);
 }
 
 VALUE
-wrap_nsdata(NSData* obj)
+wrap_nsdata(NSData* const obj)
 {
   WRAP_OBJC(rb_cData, objc_finalizer);
 }
 
-VALUE wrap_array_data(CFArrayRef array) { WRAP_ARRAY(wrap_data); }
+VALUE wrap_array_data(CFArrayRef const array) { WRAP_ARRAY(wrap_data); }
 VALUE
-wrap_array_nsdata(NSArray* ary)
+wrap_array_nsdata(NSArray* const ary)
 {
-  CFArrayRef array = (CFArrayRef)ary;
+  CFArrayRef const array = (CFArrayRef)ary;
   WRAP_ARRAY(wrap_data);
 }
 
 CFDataRef
-unwrap_data(VALUE data)
+unwrap_data(const VALUE data)
 {
   return (CFDataRef)unwrap_nsdata(data);
 }
 
 NSData*
-unwrap_nsdata(VALUE obj)
+unwrap_nsdata(const VALUE obj)
 {
   UNWRAP_OBJC(NSData);
 }
@@ -678,177 +651,172 @@ unwrap_nsdata(VALUE obj)
 
 static
 VALUE
-rb_data_data(VALUE self)
+rb_data_data(const VALUE self)
 {
   return wrap_nsdata([NSData data]);
 }
 
 static
 VALUE
-rb_data_with_contents_of_url(VALUE self, VALUE url)
+rb_data_with_contents_of_url(const VALUE self, const VALUE url)
 {
-  NSData* data = [NSData dataWithContentsOfURL:unwrap_nsurl(url)];
-  if (data)
-    return wrap_nsdata(data);
-  return Qnil;
+    NSData* const data = [NSData dataWithContentsOfURL:unwrap_nsurl(url)];
+    if (data)
+        return wrap_nsdata(data);
+    return Qnil;
 }
 
 static
 VALUE
-rb_data_length(VALUE self)
+rb_data_length(const VALUE self)
 {
   return ULONG2NUM([unwrap_nsdata(self) length]);
 }
 
 static
 VALUE
-rb_data_equality(VALUE self, VALUE other)
+rb_data_equality(const VALUE self, const VALUE other)
 {
   OBJC_EQUALITY(rb_cData, unwrap_nsdata);
 }
 
 static
 VALUE
-rb_data_write_to_file(int argc, VALUE* argv, VALUE self)
+rb_data_write_to_file(const int argc, VALUE* const argv, const VALUE self)
 {
-  if (argc < 2)
-    rb_raise(
-	     rb_eArgError,
-	     "wrong number of arguments, got %d, expected 2",
-	     argc
-	     );
+    if (argc < 2)
+        rb_raise(rb_eArgError,
+                 "wrong number of arguments, got %d, expected 2",
+                 argc);
 
-  NSString* path = unwrap_nsstring(argv[0]);
-  BOOL    result = [unwrap_nsdata(self) writeToFile:path
-		                         atomically:(argv[1] == Qtrue)];
+    NSString* const path = unwrap_nsstring(argv[0]);
+    const BOOL    result = [unwrap_nsdata(self) writeToFile:path
+                                                 atomically:(argv[1] == Qtrue)];
 
-  [path release];
+    [path release];
 
-  return (result ? Qtrue : Qfalse);
+    return (result ? Qtrue : Qfalse);
 }
 
 
 static
 VALUE
-rb_data_to_str(VALUE self)
+rb_data_to_str(const VALUE self)
 {
-  NSData*      data = unwrap_nsdata(self);
-  const void* bytes = [data bytes];
-  NSUInteger length = [data length];
-  return rb_enc_str_new(bytes, length, rb_utf8_encoding());
+    NSData* const      data = unwrap_nsdata(self);
+    const void* const bytes = [data bytes];
+    const NSUInteger length = [data length];
+    return rb_enc_str_new(bytes, length, rb_utf8_encoding());
 }
 
 static
 VALUE
-rb_str_to_data(VALUE self)
+rb_str_to_data(const VALUE self)
 {
-  NSData* data = [NSData dataWithBytes:(void*)StringValuePtr(self)
-		                length:RSTRING_LEN(self)];
-  if (data)
-    return wrap_nsdata(data);
-  return Qnil; // I don't think this is possible except in case of ENOMEM
+    VALUE self_string = self;
+    NSData* const data = [NSData dataWithBytes:(void*)StringValuePtr(self_string)
+                                        length:RSTRING_LEN(self)];
+    if (data)
+        return wrap_nsdata(data);
+    return Qnil; // I don't think this is possible except in case of ENOMEM
 }
 
 
 static VALUE
-rb_spin(int argc, VALUE* argv, VALUE self)
+rb_spin(const int argc, VALUE* const argv, const VALUE self)
 {
-  if (argc == 0)
-    spin(0);
-  else
-    spin(NUM2DBL(argv[0]));
+    if (argc == 0)
+        spin(0);
+    else
+        spin(NUM2DBL(argv[0]));
 
-  return self;
+    return self;
 }
 
-#endif
-
 
 void
 Init_bridge()
 {
-#ifdef NOT_MACRUBY
-  sel_x        = rb_intern("x");
-  sel_y        = rb_intern("y");
-  sel_width    = rb_intern("width");
-  sel_height   = rb_intern("height");
-  sel_origin   = rb_intern("origin");
-  sel_size     = rb_intern("size");
-  sel_to_point = rb_intern("to_point");
-  sel_to_size  = rb_intern("to_size");
-  sel_to_rect  = rb_intern("to_rect");
-  sel_to_s     = rb_intern("to_s");
-  sel_parse    = rb_intern("parse");
-
-  rb_mAccessibility = rb_define_module("Accessibility");
-  rb_cElement       = rb_define_class_under(rb_mAccessibility, "Element", rb_cObject);
-  rb_cCGPoint       = rb_const_get(rb_cObject, rb_intern("CGPoint"));
-  rb_cCGSize        = rb_const_get(rb_cObject, rb_intern("CGSize"));
-  rb_cCGRect        = rb_const_get(rb_cObject, rb_intern("CGRect"));
-  rb_mURI           = rb_const_get(rb_cObject, rb_intern("URI"));
-  rb_cURI           = rb_const_get(rb_mURI, rb_intern("Generic"));
-
-
-  /*
-   * Document-class: NSAttributedString
-   *
-   * A 90% drop-in replacement for Cocoa's `NSAttributedString` class. The most likely
-   * to use methods have been bridged. Remaining methods can be bridged upon request.
-   *
-   * See [Apple's Developer Reference](https://developer.apple.com/library/mac/#documentation/Cocoa/Reference/Foundation/Classes/NSAttributedString_Class/Reference/Reference.html)
-   * for documentation on the methods available in this class.
-   */
-  rb_cAttributedString = rb_define_class("NSAttributedString", rb_cObject);
-
-  // LOL, but required to be a drop-in replacement
-  rb_define_singleton_method(rb_cAttributedString, "alloc", rb_astring_alloc, 0);
-
-  // TODO: all these methods :(
-  rb_define_method(rb_cAttributedString, "initWithString", rb_astring_init_with_string, -1);
-  /* rb_define_method(rb_cAttributedString, "initWithAttributedString", rb_astring_init_with_astring, 2); */
-  rb_define_method(rb_cAttributedString, "string", rb_astring_string, 0);
-  rb_define_method(rb_cAttributedString, "length", rb_astring_length, 0);
-  /* rb_define_method(rb_cAttributedString, "attributesAtIndex", rb_astring_attrs_at_index, -1); */
-  rb_define_method(rb_cAttributedString, "isEqualToAttributedString", rb_astring_equality, 1);
-  /* rb_define_method(rb_cAttributedString, "attributedSubstringFromRange", rb_astring_astring_from_range, 1); */
-
-  rb_define_alias(rb_cAttributedString, "to_s",   "string");
-  rb_define_alias(rb_cAttributedString, "to_str", "string");
-  rb_define_alias(rb_cAttributedString, "==",     "isEqualToAttributedString");
-
-
-  /*
-   * Document-class: NSData
-   *
-   * A 50% drop-in replacement for Cocoa's `NSData` class. Almost all
-   * non-deprecated methods have been bridged.
-   *
-   * See [Apple's Developer Reference](https://developer.apple.com/library/mac/#documentation/Cocoa/Reference/Foundation/Classes/NSData_Class/Reference/Reference.html)
-   * for documentation on the methods available in this class.
-   */
-  rb_cData = rb_define_class("NSData", rb_cObject);
-
-  // TODO: implement commented out methods
-  rb_define_singleton_method(rb_cData, "data", rb_data_data, 0);
-  //rb_define_singleton_method(rb_cData, "dataWithBytes", rb_data_with_bytes, 2);
-  //rb_define_singleton_method(rb_cData, "dataWithContentsOfFile", rb_data_with_contents_of_file, 1);
-  rb_define_singleton_method(rb_cData, "dataWithContentsOfURL", rb_data_with_contents_of_url, 1);
-  //rb_define_singleton_method(rb_cData, "dataWithData", rb_data_with_data, 1);
-
-  //rb_define_method(rb_cData, "bytes",            rb_data_bytes, 0);
-  //rb_define_method(rb_cData, "description",      rb_data_description, 0);
-  //rb_define_method(rb_cData, "subdataWithRange", rb_data_subrange, 1);
-  rb_define_method(rb_cData, "isEqualToData",    rb_data_equality, 1);
-  rb_define_method(rb_cData, "length",           rb_data_length, 0);
-  rb_define_method(rb_cData, "writeToFile",      rb_data_write_to_file, -1);
-  //rb_define_method(rb_cData, "writeToURL",       rb_data_write_to_url, -1);
-  rb_define_method(rb_cData, "to_str",           rb_data_to_str, 0);
-
-  rb_define_alias(rb_cData,  "==", "isEqualToData");
-
-
-  // misc freedom patches
-  rb_define_method(rb_cString, "to_data", rb_str_to_data, 0);
-  rb_define_method(rb_cObject, "spin", rb_spin, -1); // semi-private method
-#endif
+    sel_x        = rb_intern("x");
+    sel_y        = rb_intern("y");
+    sel_width    = rb_intern("width");
+    sel_height   = rb_intern("height");
+    sel_origin   = rb_intern("origin");
+    sel_size     = rb_intern("size");
+    sel_to_point = rb_intern("to_point");
+    sel_to_size  = rb_intern("to_size");
+    sel_to_rect  = rb_intern("to_rect");
+    sel_to_s     = rb_intern("to_s");
+    sel_parse    = rb_intern("parse");
+
+    rb_mAccessibility = rb_define_module("Accessibility");
+    rb_cElement       = rb_define_class_under(rb_mAccessibility, "Element", rb_cObject);
+    rb_cCGPoint       = rb_const_get(rb_cObject, rb_intern("CGPoint"));
+    rb_cCGSize        = rb_const_get(rb_cObject, rb_intern("CGSize"));
+    rb_cCGRect        = rb_const_get(rb_cObject, rb_intern("CGRect"));
+    rb_mURI           = rb_const_get(rb_cObject, rb_intern("URI"));
+    rb_cURI           = rb_const_get(rb_mURI, rb_intern("Generic"));
+
+
+    /*
+     * Document-class: NSAttributedString
+     *
+     * A 90% drop-in replacement for Cocoa's `NSAttributedString` class. The most likely
+     * to use methods have been bridged. Remaining methods can be bridged upon request.
+     *
+     * See [Apple's Developer Reference](https://developer.apple.com/library/mac/#documentation/Cocoa/Reference/Foundation/Classes/NSAttributedString_Class/Reference/Reference.html)
+     * for documentation on the methods available in this class.
+     */
+    rb_cAttributedString = rb_define_class("NSAttributedString", rb_cObject);
+
+    // LOL, but required to be a drop-in replacement
+    rb_define_singleton_method(rb_cAttributedString, "alloc", rb_astring_alloc, 0);
+
+    // TODO: all these methods :(
+    rb_define_method(rb_cAttributedString, "initWithString", rb_astring_init_with_string, -1);
+    /* rb_define_method(rb_cAttributedString, "initWithAttributedString", rb_astring_init_with_astring, 2); */
+    rb_define_method(rb_cAttributedString, "string", rb_astring_string, 0);
+    rb_define_method(rb_cAttributedString, "length", rb_astring_length, 0);
+    /* rb_define_method(rb_cAttributedString, "attributesAtIndex", rb_astring_attrs_at_index, -1); */
+    rb_define_method(rb_cAttributedString, "isEqualToAttributedString", rb_astring_equality, 1);
+    /* rb_define_method(rb_cAttributedString, "attributedSubstringFromRange", rb_astring_astring_from_range, 1); */
+
+    rb_define_alias(rb_cAttributedString, "to_s",   "string");
+    rb_define_alias(rb_cAttributedString, "to_str", "string");
+    rb_define_alias(rb_cAttributedString, "==",     "isEqualToAttributedString");
+
+
+    /*
+     * Document-class: NSData
+     *
+     * A 50% drop-in replacement for Cocoa's `NSData` class. Almost all
+     * non-deprecated methods have been bridged.
+     *
+     * See [Apple's Developer Reference](https://developer.apple.com/library/mac/#documentation/Cocoa/Reference/Foundation/Classes/NSData_Class/Reference/Reference.html)
+     * for documentation on the methods available in this class.
+     */
+    rb_cData = rb_define_class("NSData", rb_cObject);
+
+    // TODO: implement commented out methods
+    rb_define_singleton_method(rb_cData, "data", rb_data_data, 0);
+    //rb_define_singleton_method(rb_cData, "dataWithBytes", rb_data_with_bytes, 2);
+    //rb_define_singleton_method(rb_cData, "dataWithContentsOfFile", rb_data_with_contents_of_file, 1);
+    rb_define_singleton_method(rb_cData, "dataWithContentsOfURL", rb_data_with_contents_of_url, 1);
+    //rb_define_singleton_method(rb_cData, "dataWithData", rb_data_with_data, 1);
+
+    //rb_define_method(rb_cData, "bytes",            rb_data_bytes, 0);
+    //rb_define_method(rb_cData, "description",      rb_data_description, 0);
+    //rb_define_method(rb_cData, "subdataWithRange", rb_data_subrange, 1);
+    rb_define_method(rb_cData, "isEqualToData",    rb_data_equality, 1);
+    rb_define_method(rb_cData, "length",           rb_data_length, 0);
+    rb_define_method(rb_cData, "writeToFile",      rb_data_write_to_file, -1);
+    //rb_define_method(rb_cData, "writeToURL",       rb_data_write_to_url, -1);
+    rb_define_method(rb_cData, "to_str",           rb_data_to_str, 0);
+
+    rb_define_alias(rb_cData,  "==", "isEqualToData");
+
+
+    // misc freedom patches
+    rb_define_method(rb_cString, "to_data", rb_str_to_data, 0);
+    rb_define_method(rb_cObject, "spin", rb_spin, -1); // semi-private method
 }