accessibility_bridge 0.1.0

data/.yardopts

@@ -0,0 +1,9 @@
+--no-cache
+--no-output
+--verbose
+--markup markdown
+--markup-provider kramdown
+--readme README.markdown
+--hide-void-return
+lib/**/*.rb
+ext/**/*{.m,.c}

data/History.markdown

@@ -0,0 +1,5 @@
+# v0.1.0 - Initial release
+
+ * MRI and MacRuby compatible
+ * Bare minimum bridging so that accessibility-core works
+

data/README.markdown

@@ -0,0 +1,39 @@
+# accessibility\_bridge
+
+Bare minimum bridging for MRI to easily use Cocoa objects. The intended
+use for this code is as a support for other gems that require some
+bridging to Cocoa stuff.
+
+This was extracted from the
+[accessibility\_core](https://github.com/AXElements/accessibility_core)
+project and is a work-in-progress.
+
+
+## Copyright
+
+Copyright (c)2012, Mark Rada
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of Mark Rada nor the names of its
+  contributors may be used to endorse or promote products derived
+  from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL Mark Rada BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/Rakefile

@@ -0,0 +1,51 @@
+task :default => :test
+
+require 'rake/clean'
+CLEAN.include '*.plist', '*.gch'
+
+desc 'Run the Clang static analyzer'
+task :analyze do
+  sh "clang --analyze ext/accessibility/bridge/bridge.c"
+end
+
+desc 'Startup an IRb console with accessibility-core loaded'
+task :console => [:compile] do
+  sh 'irb -Ilib -raccessibility/bridge'
+end
+
+desc 'Build the test fixture'
+task :fixture do
+  sh 'cd test/AXElementsTester && xcodebuild'
+end
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << '.'
+  t.pattern = 'test/*_test.rb'
+end
+task :test => :compile
+
+
+# Gem stuff
+
+require 'rubygems/package_task'
+SPEC = Gem::Specification.load('accessibility_bridge.gemspec')
+
+Gem::PackageTask.new(SPEC) { }
+
+desc 'Build and install gem (not including deps)'
+task :install => :gem do
+  require 'rubygems/installer'
+  Gem::Installer.new("pkg/#{SPEC.file_name}").install
+end
+
+
+# C extensions!
+
+require 'rake/extensiontask'
+
+Rake::ExtensionTask.new('bridge', SPEC) do |ext|
+  ext.ext_dir = 'ext/accessibility/bridge'
+  ext.lib_dir = 'lib/accessibility'
+end
+

data/ext/accessibility/bridge/bridge.c

@@ -0,0 +1,490 @@
+#include "ruby.h"
+#import <Cocoa/Cocoa.h>
+
+#ifndef ACCESSIBILITY_BRIDGE
+#define ACCESSIBILITY_BRIDGE 1
+
+#ifdef NOT_MACRUBY
+
+VALUE rb_mAccessibility;
+VALUE rb_cElement;
+VALUE rb_cCGPoint;
+VALUE rb_cCGSize;
+VALUE rb_cCGRect;
+VALUE rb_mURI; // URI module
+VALUE rb_cURI; // URI::Generic class
+
+ID sel_x;
+ID sel_y;
+ID sel_width;
+ID sel_height;
+ID sel_origin;
+ID sel_size;
+ID sel_to_point;
+ID sel_to_size;
+ID sel_to_rect;
+ID sel_to_s;
+ID sel_parse;
+
+
+#define WRAP_ARRAY(wrapper) do {				\
+    CFIndex length = CFArrayGetCount(array);			\
+    VALUE      ary = rb_ary_new2(length);			\
+								\
+    for (CFIndex idx = 0; idx < length; idx++)			\
+      rb_ary_store(						\
+		   ary,						\
+		   idx,						\
+		   wrapper(CFArrayGetValueAtIndex(array, idx))	\
+		   );	                                        \
+    return ary;							\
+  } while (false);
+
+
+VALUE
+wrap_unknown(CFTypeRef obj)
+{
+  // TODO: this will leak, can we use something like alloca?
+  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
+}
+
+CFTypeRef
+unwrap_unknown(VALUE obj)
+{
+  obj = rb_funcall(obj, sel_to_s, 0);
+  rb_raise(
+	   rb_eRuntimeError,
+	   "accessibility-core doesn't know how to unwrap `%s'",
+	   StringValuePtr(obj)
+	   );
+  return NULL; // unreachable
+}
+
+
+VALUE
+wrap_point(CGPoint point)
+{
+  return rb_struct_new(rb_cCGPoint, DBL2NUM(point.x), DBL2NUM(point.y));
+}
+
+CGPoint
+unwrap_point(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);
+}
+
+
+VALUE
+wrap_size(CGSize size)
+{
+  return rb_struct_new(rb_cCGSize, DBL2NUM(size.width), DBL2NUM(size.height));
+}
+
+CGSize
+unwrap_size(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);
+}
+
+
+VALUE
+wrap_rect(CGRect rect)
+{
+  VALUE point = wrap_point(rect.origin);
+  VALUE  size = wrap_size(rect.size);
+  return rb_struct_new(rb_cCGRect, point, size);
+}
+
+CGRect
+unwrap_rect(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);
+}
+
+
+VALUE
+convert_cf_range(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);
+}
+
+CFRange
+convert_rb_range(VALUE range)
+{
+  VALUE b, e;
+  int exclusive;
+
+  rb_range_values(range, &b, &e, &exclusive);
+
+  int begin = NUM2INT(b);
+  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."
+	     );
+
+  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);					\
+
+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)    }
+
+#define UNWRAP_VALUE(type, value, unwrapper) do {		\
+    type st = unwrapper(val);					\
+    return AXValueCreate(value, &st);				\
+  }  while(0);
+
+AXValueRef unwrap_value_point(VALUE val) { UNWRAP_VALUE(CGPoint, kAXValueCGPointType, unwrap_point) }
+AXValueRef unwrap_value_size(VALUE val)  { UNWRAP_VALUE(CGSize,  kAXValueCGSizeType,  unwrap_size)  }
+AXValueRef unwrap_value_rect(VALUE val)  { UNWRAP_VALUE(CGRect,  kAXValueCGRectType,  unwrap_rect)  }
+AXValueRef unwrap_value_range(VALUE val) { UNWRAP_VALUE(CFRange, kAXValueCFRangeType, convert_rb_range) }
+
+
+VALUE
+wrap_value(AXValueRef value)
+{
+  switch (AXValueGetType(value))
+    {
+    case kAXValueIllegalType:
+      // TODO better error message
+      rb_raise(rb_eArgError, "herped when you should have derped");
+    case kAXValueCGPointType:
+      return wrap_value_point(value);
+    case kAXValueCGSizeType:
+      return wrap_value_size(value);
+    case kAXValueCGRectType:
+      return wrap_value_rect(value);
+    case kAXValueCFRangeType:
+      return wrap_value_range(value);
+    case kAXValueAXErrorType:
+      return wrap_value_error(value);
+    default:
+      // TODO better error message
+      rb_raise(
+	       rb_eRuntimeError,
+	       "Could not wrap You've found a bug in something...not sure who to blame"
+	       );
+    }
+
+  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
+}
+
+VALUE wrap_array_values(CFArrayRef array) { WRAP_ARRAY(wrap_value) }
+
+
+static
+void
+ref_finalizer(void* obj)
+{
+  CFRelease((CFTypeRef)obj);
+}
+
+VALUE
+wrap_ref(AXUIElementRef ref)
+{
+  return Data_Wrap_Struct(rb_cElement, NULL, ref_finalizer, (void*)ref);
+}
+
+AXUIElementRef
+unwrap_ref(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;
+}
+
+VALUE wrap_array_refs(CFArrayRef array) { WRAP_ARRAY(wrap_ref) }
+
+
+VALUE
+wrap_string(CFStringRef string)
+{
+  // flying by the seat of our pants here, this hasn't failed yet
+  // but probably will one day when I'm not looking
+  const char* name = CFStringGetCStringPtr(string, kCFStringEncodingMacRoman);
+  if (name)
+    return rb_str_new(name, CFStringGetLength(string));
+  else
+    // use rb_external_str_new() ? assume always UTF-8?
+    rb_raise(rb_eRuntimeError, "NEED TO IMPLEMNET STRING COPYING");
+
+  return Qnil; // unreachable
+}
+
+CFStringRef
+unwrap_string(VALUE string)
+{
+  return CFStringCreateWithCStringNoCopy(
+					 NULL,
+					 StringValueCStr(string),
+					 0,
+					 kCFAllocatorNull
+					 );
+  /* return CFStringCreateWithCString( */
+  /* 				   NULL, */
+  /* 				   StringValuePtr(string), */
+  /* 				   kCFStringEncodingUTF8 */
+  /* 				   ); */
+}
+
+VALUE wrap_array_strings(CFArrayRef array) { WRAP_ARRAY(wrap_string) }
+
+
+#define WRAP_NUM(type, cookie, macro) do {		        \
+    type value;							\
+    if (CFNumberGetValue(num, cookie, &value))			\
+      return macro(value);					\
+    rb_raise(rb_eRuntimeError, "I goofed wrapping a number");	\
+    return Qnil;						\
+  } while(0);
+
+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)  }
+
+#define UNWRAP_NUM(type, cookie, macro) do {	\
+    type base = macro(num);			\
+    return CFNumberCreate(NULL, cookie, &base); \
+  } while(0);
+
+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)  }
+
+VALUE
+wrap_number(CFNumberRef number)
+{
+  switch (CFNumberGetType(number))
+    {
+    case kCFNumberSInt8Type:
+    case kCFNumberSInt16Type:
+    case kCFNumberSInt32Type:
+    case kCFNumberSInt64Type:
+      return wrap_long(number);
+    case kCFNumberFloat32Type:
+    case kCFNumberFloat64Type:
+      return wrap_float(number);
+    case kCFNumberCharType:
+    case kCFNumberShortType:
+    case kCFNumberIntType:
+    case kCFNumberLongType:
+      return wrap_long(number);
+    case kCFNumberLongLongType:
+      return wrap_long_long(number);
+    case kCFNumberFloatType:
+    case kCFNumberDoubleType:
+      return wrap_float(number);
+    case kCFNumberCFIndexType:
+    case kCFNumberNSIntegerType:
+      return wrap_long(number);
+    case kCFNumberCGFloatType: // == kCFNumberMaxType
+      return wrap_float(number);
+    default:
+      return INT2NUM(0); // unreachable unless system goofed
+    }
+}
+
+CFNumberRef
+unwrap_number(VALUE number)
+{
+  switch (TYPE(number))
+    {
+    case T_FIXNUM:
+      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
+    }
+}
+
+VALUE wrap_array_numbers(CFArrayRef array) { WRAP_ARRAY(wrap_number) }
+
+
+VALUE
+wrap_url(CFURLRef url)
+{
+  return rb_funcall(rb_mURI, sel_parse, 1, wrap_string(CFURLGetString(url)));
+}
+
+CFURLRef
+unwrap_url(VALUE url)
+{
+  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 wrap_array_urls(CFArrayRef array) { WRAP_ARRAY(wrap_url) }
+
+VALUE
+wrap_date(CFDateRef date)
+{
+  NSTimeInterval time = [(NSDate*)date timeIntervalSince1970];
+  return rb_time_new((time_t)time, 0);
+}
+
+CFDateRef
+unwrap_date(VALUE date)
+{
+  struct timeval t = rb_time_timeval(date);
+  NSDate* ns_date = [NSDate dateWithTimeIntervalSince1970:t.tv_sec];
+  return (CFDateRef)ns_date;
+}
+
+VALUE wrap_array_dates(CFArrayRef array) { WRAP_ARRAY(wrap_date) }
+
+
+VALUE
+wrap_boolean(CFBooleanRef bool_val)
+{
+  return (CFBooleanGetValue(bool_val) ? Qtrue : Qfalse);
+}
+
+CFBooleanRef
+unwrap_boolean(VALUE bool_val)
+{
+  return (bool_val == Qtrue ? kCFBooleanTrue : kCFBooleanFalse);
+}
+
+VALUE wrap_array_booleans(CFArrayRef array) { WRAP_ARRAY(wrap_boolean) }
+
+
+VALUE
+wrap_array(CFArrayRef array)
+{
+  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                                   return wrap_unknown(obj);
+}
+
+VALUE
+to_ruby(CFTypeRef 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                                   return wrap_unknown(obj);
+}
+
+CFTypeRef
+to_ax(VALUE obj)
+{
+  // TODO we can better optimize this when running under MacRuby
+  VALUE type = CLASS_OF(obj);
+  if      (type == rb_cElement)            return unwrap_ref(obj);
+  else if (type == rb_cString)             return unwrap_string(obj);
+  else if (type == rb_cStruct)             return unwrap_value(obj);
+  else if (type == rb_cRange)              return unwrap_value(obj);
+  else if (type == rb_cFixnum)             return unwrap_number(obj);
+  else if (type == rb_cFloat)              return unwrap_number(obj);
+  else if (type == rb_cTime)               return unwrap_date(obj);
+  else if (type == rb_cURI)                return unwrap_url(obj);
+  else if (obj  == Qtrue || obj == Qfalse) return unwrap_boolean(obj);
+  else                                     return unwrap_unknown(obj);
+}
+
+#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_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"));
+#endif
+}
+
+#endif

data/ext/accessibility/bridge/extconf.rb

@@ -0,0 +1,22 @@
+require 'mkmf'
+
+$CFLAGS << ' -std=c99 -Wall -Werror -pedantic -ObjC'
+$LIBS   << ' -framework CoreFoundation -framework ApplicationServices -framework Cocoa'
+$LIBS   << ' -framework CoreGraphics' unless `sw_vers -productVersion`.to_f == 10.7
+
+if RUBY_ENGINE == 'macruby'
+  $CFLAGS << ' -fobjc-gc'
+else
+  unless RbConfig::CONFIG["CC"].match /clang/
+    clang = `which clang`.chomp
+    if clang.empty?
+      raise "Clang not installed. Cannot build C extension"
+    else
+      RbConfig::MAKEFILE_CONFIG["CC"]  = clang
+      RbConfig::MAKEFILE_CONFIG["CXX"] = clang
+    end
+  end
+  $CFLAGS << ' -DNOT_MACRUBY'
+end
+
+create_makefile 'accessibility/bridge'

data/lib/accessibility/bridge.rb

@@ -0,0 +1,33 @@
+require 'accessibility/bridge/version'
+
+if RUBY_ENGINE == 'macruby'
+
+  ##
+  # Whether or not we are running on MacRuby
+  def on_macruby?
+    true
+  end
+
+  framework 'Cocoa'
+
+  # A workaround that guarantees that `CGPoint` is defined
+  unless defined? MOUNTAIN_LION_APPKIT_VERSION
+    MOUNTAIN_LION_APPKIT_VERSION = 1187
+  end
+
+  if NSAppKitVersionNumber >= MOUNTAIN_LION_APPKIT_VERSION
+    framework '/System/Library/Frameworks/CoreGraphics.framework'
+  end
+
+  require 'accessibility/bridge/macruby'
+
+else
+
+  def on_macruby?
+    false
+  end
+
+  require 'accessibility/bridge/mri'
+
+end
+

data/lib/accessibility/bridge/common.rb

@@ -0,0 +1,57 @@
+class CGPoint
+  ##
+  # Returns the receiver, since the receiver is already a {CGPoint}
+  #
+  # @return [CGPoint]
+  def to_point
+    self
+  end
+end
+
+class CGSize
+  ##
+  # Returns the receiver, since the receiver is already a {CGSize}
+  #
+  # @return [CGSize]
+  def to_size
+    self
+  end
+end
+
+class CGRect
+  ##
+  # Returns the receiver, since the receiver is already a {CGRect}
+  #
+  # @return [CGRect]
+  def to_rect
+    self
+  end
+end
+
+##
+# accessibility-core extensions to `Array`
+class Array
+  ##
+  # Coerce the first two elements of the receiver into a {CGPoint}
+  #
+  # @return [CGPoint]
+  def to_point
+    CGPoint.new self[0], self[1]
+  end
+
+  ##
+  # Coerce the first two elements of the receiver into a {CGSize}
+  #
+  # @return [CGSize]
+  def to_size
+    CGSize.new self[0], self[1]
+  end
+
+  ##
+  # Coerce the first four elements of the receiver into a {CGRect}
+  #
+  # @return [CGRect]
+  def to_rect
+    CGRect.new CGPoint.new(self[0], self[1]), CGSize.new(self[2], self[3])
+  end
+end

data/lib/accessibility/bridge/macruby.rb

@@ -0,0 +1,185 @@
+require 'accessibility/bridge/common'
+
+##
+# accessibility-core extensions for `NSURL`
+class NSURL
+  ##
+  # Return the reciver, for the receiver is already a URL object
+  #
+  # @return [NSURL]
+  def to_url
+    self
+  end
+
+  # because printing is easier this way
+  alias_method :to_s, :inspect
+end
+
+##
+# accessibility-core extensions for `NSString`
+class NSString
+  ##
+  # Create an NSURL using the receiver as the initialization string
+  #
+  # If the receiver is not a valid URL then `nil` will be returned.
+  #
+  # This exists because of
+  # [rdar://11207662](http://openradar.appspot.com/11207662).
+  #
+  # @return [NSURL,nil]
+  def to_url
+    NSURL.URLWithString self
+  end
+end
+
+##
+# `accessibility-core` extensions for `NSObject`
+class NSObject
+  ##
+  # Return an object safe for passing to AXAPI
+  def to_ax
+    self
+  end
+
+  ##
+  # Return a usable object from an AXAPI pointer
+  def to_ruby
+    self
+  end
+end
+
+##
+# `accessibility-core` extensions for `CFRange`
+class CFRange
+  ##
+  # Convert the {CFRange} to a Ruby {Range} object
+  #
+  # @return [Range]
+  def to_ruby
+    Range.new location, (location + length - 1)
+  end
+end
+
+##
+# `accessibility-core` extensions for `Range`
+class Range
+  # @return [AXValueRef]
+  def to_ax
+    raise ArgumentError, "can't convert negative index" if last < 0 || first < 0
+    length = if exclude_end?
+               last - first
+             else
+               last - first + 1
+             end
+    CFRange.new(first, length).to_ax
+  end
+end
+
+##
+# AXElements extensions to the `Boxed` class
+#
+# The `Boxed` class is simply an abstract base class for structs that
+# MacRuby can use via bridge support.
+class Boxed
+  ##
+  # Returns the number that AXAPI uses in order to know how to wrap
+  # a struct.
+  #
+  # @return [Number]
+  def self.ax_value
+    raise NotImplementedError, "#{inspect}:#{self.class} cannot be wrapped"
+  end
+
+  ##
+  # Create an `AXValueRef` from the `Boxed` instance. This will only
+  # work if for the most common boxed types, you will need to check
+  # the AXAPI documentation for an up to date list.
+  #
+  # @example
+  #
+  #   CGPoint.new(12, 34).to_ax # => #<AXValueRef:0x455678e2>
+  #   CGSize.new(56, 78).to_ax  # => #<AXValueRef:0x555678e2>
+  #
+  # @return [AXValueRef]
+  def to_ax
+    klass = self.class
+    ptr   = Pointer.new klass.type
+    ptr.assign self
+    AXValueCreate(klass.ax_value, ptr)
+  end
+end
+
+# `accessibility-core` extensions for `CFRange`'s metaclass
+class << CFRange
+  # (see Boxed.ax_value)
+  def ax_value; KAXValueCFRangeType end
+end
+# `accessibility-core` extensions for `CGSize`'s metaclass
+class << CGSize
+  # (see Boxed.ax_value)
+  def ax_value; KAXValueCGSizeType end
+end
+# `accessibility-core` extensions for `CGRect`'s metaclass
+class << CGRect
+  # (see Boxed.ax_value)
+  def ax_value; KAXValueCGRectType end
+end
+# `accessibility-core` extensions for `CGPoint`'s metaclass
+class << CGPoint
+  # (see Boxed.ax_value)
+  def ax_value; KAXValueCGPointType end
+end
+
+##
+# Mixin for the special hidden class in MacRuby that represents `AXValueRef`
+#
+# This module adds a `#to_ruby` method that actually unwraps the object from
+# the `AXValueRef` to some sort of {Boxed} object, such as a {CGPoint} or a
+# {Range}.
+module ValueWrapper
+
+
+  ##
+  # Map of type encodings used for unwrapping structs wrapped in an `AXValueRef`
+  #
+  # The list is order sensitive, which is why we unshift nil, but
+  # should probably be more rigorously defined at runtime.
+  #
+  # @return [String,nil]
+  BOX_TYPES = [CGPoint, CGSize, CGRect, CFRange].map!(&:type).unshift(nil)
+
+  ##
+  # Unwrap an `AXValueRef` into the `Boxed` instance that it is supposed
+  # to be. This will only work for the most common boxed types, you will
+  # need to check the AXAPI documentation for an up to date list.
+  #
+  # @example
+  #
+  #   wrapped_point.to_ruby # => #<CGPoint x=44.3 y=99.0>
+  #   wrapped_range.to_ruby # => #<CFRange begin=7 length=100>
+  #   wrapped_thing.to_ruby # => wrapped_thing
+  #
+  # @return [Boxed]
+  def to_ruby
+    type = AXValueGetType(self)
+    return self if type.zero?
+
+    ptr = Pointer.new BOX_TYPES[type]
+    AXValueGetValue(self, type, ptr)
+    ptr.value.to_ruby
+  end
+
+  # hack to find the __NSCFType class and mix things in
+  klass = AXUIElementCreateSystemWide().class
+  klass.send :include, self
+
+end
+
+##
+# `accessibility-core` extensions to `NSArray`
+class NSArray
+  # @return [Array]
+  def to_ruby
+    map do |obj| obj.to_ruby end
+  end
+end

data/lib/accessibility/bridge/mri.rb

@@ -0,0 +1,121 @@
+##
+# A structure that contains a point in a two-dimensional coordinate system
+CGPoint = Struct.new(:x, :y) do
+
+  # @param x [Number]
+  # @param y [Number]
+  def initialize x = 0.0, y = 0.0
+    super
+  end
+
+  # @!attribute [rw] x
+  #   The `x` co-ordinate of the screen point
+  #   @return [Number]
+
+  # @!attribute [rw] y
+  #   The `y` co-ordinate of the screen point
+  #   @return [Number]
+
+  ##
+  # Return a nice string representation of the point
+  #
+  # Overrides `Object#inspect` to more closely mimic MacRuby `Boxed#inspect`.
+  #
+  # @return [String]
+  def inspect
+    "#<CGPoint x=#{self.x.to_f} y=#{self.y.to_f}>"
+  end
+
+end
+
+
+##
+# A structure that contains the size of a rectangle in a 2D co-ordinate system
+CGSize = Struct.new(:width, :height) do
+
+  # @param width [Number]
+  # @param height [Number]
+  def initialize width = 0.0, height = 0.0
+    super
+  end
+
+  # @!attribute [rw] width
+  #   The `width` of the box
+  #   @return [Number]
+
+  # @!attribute [rw] height
+  #   The `heighth` of the box
+  #   @return [Number]
+
+  ##
+  # Return a nice string representation of the size
+  #
+  # Overrides `Object#inspect` to more closely mimic MacRuby `Boxed#inspect`.
+  #
+  # @return [String]
+  def inspect
+    "#<CGSize width=#{self.width.to_f} height=#{self.height.to_f}>"
+  end
+
+end
+
+
+##
+# Complete definition of a rectangle in a 2D coordinate system
+CGRect = Struct.new(:origin, :size) do
+
+  # @param origin [CGPoint,#to_point]
+  # @param size [CGSize,#to_size]
+  def initialize origin = CGPoint.new, size = CGSize.new
+    super(origin.to_point, size.to_size)
+  end
+
+  # @!attribute [rw] origin
+  #   The `origin` point
+  #   @return [CGPoint,#to_point]
+
+  # @!attribute [rw] size
+  #   The `size` of the rectangle
+  #   @return [CGSize,#to_size]
+
+  ##
+  # Return a nice string representation of the rectangle
+  #
+  # Overrides `Object#inspect` to more closely mimic MacRuby `Boxed#inspect`.
+  #
+  # @return [String]
+  def inspect
+    "#<CGRect origin=#{self.origin.inspect} size=#{self.size.inspect}>"
+  end
+
+end
+
+
+require 'uri'
+
+##
+# `accessibility-core` extensions to the `URI` family of classes
+class URI::Generic
+  ##
+  # Returns the receiver (since the receiver is already a `URI` object)
+  #
+  # @return [URI::Generic]
+  def to_url
+    self
+  end
+end
+
+##
+# `accessibility-core` extensions to the `String` class
+class String
+  ##
+  # Parse the receiver into a `URI` object
+  #
+  # @return [URI::Generic]
+  def to_url
+    URI.parse self
+  end
+end
+
+
+require 'accessibility/bridge/common'

data/lib/accessibility/bridge/version.rb

@@ -0,0 +1,6 @@
+module Accessibility
+  module Bridge
+    # @return [String]
+    VERSION = '0.1.0'
+  end
+end

data/test/helper.rb

@@ -0,0 +1,19 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'accessibility/bridge'
+
+class MiniTest::Unit::TestCase
+
+  def rand_nums count, range = 1_000
+    Array.new count do
+      rand range
+    end
+  end
+
+  def rand_floats count, range = 1_000.0
+    Array.new count do
+      rand * range
+    end
+  end
+
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: accessibility_bridge
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Mark Rada
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.1
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+description: ! 'accessibility_bridge is a wrapper around various bits of Cocoa
+
+  so that the various accessibility projects can run on CRuby.
+
+
+  Originally extracted from the AXElements project.
+
+'
+email: markrada26@gmail.com
+executables: []
+extensions:
+- ext/accessibility/bridge/extconf.rb
+extra_rdoc_files: []
+files:
+- lib/accessibility/bridge/common.rb
+- lib/accessibility/bridge/macruby.rb
+- lib/accessibility/bridge/mri.rb
+- lib/accessibility/bridge/version.rb
+- lib/accessibility/bridge.rb
+- ext/accessibility/bridge/bridge.c
+- ext/accessibility/bridge/extconf.rb
+- Rakefile
+- README.markdown
+- History.markdown
+- .yardopts
+- test/helper.rb
+homepage: http://github.com/AXElements/accessibility_bridge
+licenses:
+- BSD 3-clause
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1210497514143783933
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1210497514143783933
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A library for bridging into Cocoa on OSX
+test_files:
+- test/helper.rb