Extending Ruby

Extending Ruby

A guide to extending ruby, from RailsClub Moscow 2013. Code examples from the talk are available at https://github.com/fcheung/going_native_examples/

81b61875e41eaa58887543635d556fca?s=128

Frederick Cheung

September 28, 2013
Tweet

Transcript

  1. Extending Ruby Frederick Cheung CTO, dressipi.com @fglc2 / spacevatican.org Saturday,

    28 September 13
  2. Why? • Performance • Platform specific functionality • Access to

    best in class libraries Saturday, 28 September 13
  3. Downsides • Slower to write - ruby is very concise

    and expressive • Generally harder • Memory management • ruby c api • Crashes harder when things go wrong Saturday, 28 September 13
  4. Options • Native java code • “Classic” C-extension • SWIG

    • RubyInline • RICE • FFI Saturday, 28 September 13
  5. Calling java from JRuby • Just do it - stupidly

    easy • JRuby handles most of the type conversion, method name conversion require 'java' java_import java.lang.System version = System.getProperties.get("java.runtime.version") version = System.properties["java.runtime.version"] Saturday, 28 September 13
  6. • Can subclass java classes in ruby • Can implement

    a java interface in ruby • Rescue/raise java exceptions from ruby • Blocks handled nicely java.lang.Thread.new do puts 'hi' end Saturday, 28 September 13
  7. Ruby Motion / MacRuby • Uses OS X BridgeSupport mechanism

    for extracting available methods/signatures • No manual work required • Only works on OS X Saturday, 28 September 13
  8. C extensions • C code written using the C Ruby

    api - like the internals of ruby itself • Intricacies of the API not well documented (README.EXT, headers) • C api can change between versions (but then so can the ruby API) Saturday, 28 September 13
  9. Compatibility • C-Ruby • Rubinius (compatibility with MRI C api

    is a design goal) • partial compatibility with jruby (disabled by default) Saturday, 28 September 13
  10. What’s in a C extension? Saturday, 28 September 13

  11. static VALUE rb_keychain_find(int argc, VALUE *argv, VALUE self){ ... }

    void Init_keychain(){ rb_cKeychain = rb_const_get(rb_cObject, rb_intern("Keychain")); rb_define_singleton_method(rb_cKeychain, "find", RUBY_METHOD_FUNC(rb_keychain_find), -1); } C functions attached to ruby objects Saturday, 28 September 13
  12. static VALUE rb_keychain_find(int argc, VALUE *argv, VALUE self){ ... }

    void Init_keychain(){ rb_cKeychain = rb_const_get(rb_cObject, rb_intern("Keychain")); rb_define_singleton_method(rb_cKeychain, "find", RUBY_METHOD_FUNC(rb_keychain_find), -1); } C functions attached to ruby objects Saturday, 28 September 13
  13. static VALUE rb_keychain_find(int argc, VALUE *argv, VALUE self){ ... }

    void Init_keychain(){ rb_cKeychain = rb_const_get(rb_cObject, rb_intern("Keychain")); rb_define_singleton_method(rb_cKeychain, "find", RUBY_METHOD_FUNC(rb_keychain_find), -1); } C functions attached to ruby objects Saturday, 28 September 13
  14. Native data structures Person *person = ... VALUE ruby_object =

    Data_Wrap_Struct(rb_cPerson, NULL, free_person, person); Person *person=NULL; Data_Get_Struct(ruby_object, Person, person); Saturday, 28 September 13
  15. Native data structures Person *person = ... VALUE ruby_object =

    Data_Wrap_Struct(rb_cPerson, NULL, free_person, person); Person *person=NULL; Data_Get_Struct(ruby_object, Person, person); Saturday, 28 September 13
  16. Native data structures Person *person = ... VALUE ruby_object =

    Data_Wrap_Struct(rb_cPerson, NULL, free_person, person); Person *person=NULL; Data_Get_Struct(ruby_object, Person, person); Saturday, 28 September 13
  17. Convert/check types • rb_float_new / RFLOAT_VALUE • CheckType(foo, T_STRING) •

    StringValueCStr(foo) • FIX2INT, INT2FIX, LL2NUM, ... • NIL_P • RTEST Saturday, 28 September 13
  18. def find(first_or_all, kind, options={}) if options[:some_option] ... end end Gets

    verbose quickly Saturday, 28 September 13
  19. static VALUE rb_keychain_find(int argc, VALUE *argv, VALUE self){ VALUE kind;

    VALUE options; VALUE first_or_all; rb_scan_args(argc, argv, "2:", &first_or_all, &kind, &options); Check_Type(first_or_all, T_SYMBOL); Check_Type(kind, T_STRING); if(options){ if(RTEST(rb_hash_aref(options, ID2SYM(rb_intern("some_option"))))) { ... } } } Saturday, 28 September 13
  20. static VALUE rb_keychain_find(int argc, VALUE *argv, VALUE self){ VALUE kind;

    VALUE options; VALUE first_or_all; rb_scan_args(argc, argv, "2:", &first_or_all, &kind, &options); Check_Type(first_or_all, T_SYMBOL); Check_Type(kind, T_STRING); if(options){ if(RTEST(rb_hash_aref(options, ID2SYM(rb_intern("some_option"))))) { ... } } } Saturday, 28 September 13
  21. static VALUE rb_keychain_find(int argc, VALUE *argv, VALUE self){ VALUE kind;

    VALUE options; VALUE first_or_all; rb_scan_args(argc, argv, "2:", &first_or_all, &kind, &options); Check_Type(first_or_all, T_SYMBOL); Check_Type(kind, T_STRING); if(options){ if(RTEST(rb_hash_aref(options, ID2SYM(rb_intern("some_option"))))) { ... } } } Saturday, 28 September 13
  22. static VALUE rb_keychain_find(int argc, VALUE *argv, VALUE self){ VALUE kind;

    VALUE options; VALUE first_or_all; rb_scan_args(argc, argv, "2:", &first_or_all, &kind, &options); Check_Type(first_or_all, T_SYMBOL); Check_Type(kind, T_STRING); if(options){ if(RTEST(rb_hash_aref(options, ID2SYM(rb_intern("some_option"))))) { ... } } } Saturday, 28 September 13
  23. static VALUE doSomething(VALUE yielded_object, VALUE rb_context,int argc, VALUE *argv){ Context

    *context = NULL; Data_Get_Struct( rb_context, Context, context); ... return Qnil; } Context *context = ... VALUE wrapped_struct = Data_Wrap_Struct(rb_cFindContext, NULL,NULL,context); rb_block_call(rb_cUser, rb_intern("find_each"), 0, NULL, RUBY_METHOD_FUNC(doSomething), wrapped_struct); Call a method with a block Saturday, 28 September 13
  24. static VALUE doSomething(VALUE yielded_object, VALUE rb_context,int argc, VALUE *argv){ Context

    *context = NULL; Data_Get_Struct( rb_context, Context, context); ... return Qnil; } Context *context = ... VALUE wrapped_struct = Data_Wrap_Struct(rb_cFindContext, NULL,NULL,context); rb_block_call(rb_cUser, rb_intern("find_each"), 0, NULL, RUBY_METHOD_FUNC(doSomething), wrapped_struct); Call a method with a block Saturday, 28 September 13
  25. static VALUE doSomething(VALUE yielded_object, VALUE rb_context,int argc, VALUE *argv){ Context

    *context = NULL; Data_Get_Struct( rb_context, Context, context); ... return Qnil; } Context *context = ... VALUE wrapped_struct = Data_Wrap_Struct(rb_cFindContext, NULL,NULL,context); rb_block_call(rb_cUser, rb_intern("find_each"), 0, NULL, RUBY_METHOD_FUNC(doSomething), wrapped_struct); Call a method with a block Saturday, 28 September 13
  26. • Writing apis that are rubylike is difficult • Anything

    is possible but it can be quite laborious • Not much typesafety - nearly everything is a VALUE • Sometimes unhelpful api naming: rb_str_new, rb_str_new2, rb_str_new3, rb_str_new4, rb_str_new5 Saturday, 28 September 13
  27. • Generates code for C extensions automatically from a marked

    up header file • Can target many languages (ruby, python, php, ocaml, perl, ...) • Generated code is pretty illegible • Interfaces often unnatural - need wrapping SWIG Saturday, 28 September 13
  28. RubyInline • Write C extensions without some of the hassle

    • generates, compiles and loads extension at runtime • doesn’t work in irb Saturday, 28 September 13
  29. require 'inline' class Factorial inline :C do |builder| builder.c_singleton <<-SRC

    long calculate(long n){ long result = 1; for(long i = 2; i<=n; i++){ result *= i; } return result; } SRC end end Saturday, 28 September 13
  30. require 'inline' class Factorial inline :C do |builder| builder.c_singleton <<-SRC

    long calculate(long n){ long result = 1; for(long i = 2; i<=n; i++){ result *= i; } return result; } SRC end end Saturday, 28 September 13
  31. require 'inline' class Factorial inline :C do |builder| builder.c_singleton <<-SRC

    long calculate(long n){ long result = 1; for(long i = 2; i<=n; i++){ result *= i; } return result; } SRC end end Saturday, 28 September 13
  32. static VALUE calculate(VALUE self, VALUE _n) { long n =

    NUM2LONG(_n); long result = 1; for(long i = 2; i<=n; i++){ result *= i; } return LONG2NUM(result); } #ifdef __cplusplus extern "C" { #endif void Init_Inline_Factorial_7b051bd7f8f35cf0422f7470() { VALUE c = rb_cObject; c = rb_const_get(c, rb_intern("Factorial")); rb_define_singleton_method(c, "calculate", (VALUE(*)(ANYARGS))calculate, 1); } #ifdef __cplusplus } #endif Saturday, 28 September 13
  33. static VALUE calculate(VALUE self, VALUE _n) { long n =

    NUM2LONG(_n); long result = 1; for(long i = 2; i<=n; i++){ result *= i; } return LONG2NUM(result); } #ifdef __cplusplus extern "C" { #endif void Init_Inline_Factorial_7b051bd7f8f35cf0422f7470() { VALUE c = rb_cObject; c = rb_const_get(c, rb_intern("Factorial")); rb_define_singleton_method(c, "calculate", (VALUE(*)(ANYARGS))calculate, 1); } #ifdef __cplusplus } #endif Saturday, 28 September 13
  34. static VALUE calculate(VALUE self, VALUE _n) { long n =

    NUM2LONG(_n); long result = 1; for(long i = 2; i<=n; i++){ result *= i; } return LONG2NUM(result); } #ifdef __cplusplus extern "C" { #endif void Init_Inline_Factorial_7b051bd7f8f35cf0422f7470() { VALUE c = rb_cObject; c = rb_const_get(c, rb_intern("Factorial")); rb_define_singleton_method(c, "calculate", (VALUE(*)(ANYARGS))calculate, 1); } #ifdef __cplusplus } #endif Saturday, 28 September 13
  35. module Foo inline do |builder| builder.add_compile_flags '-x c++', '-lstdc++', '-Wall',

    '-Werror' builder.prefix <<-SRC # line #{__LINE__ + 1} "#{__FILE__}" class foo { ... } SRC builder.c_raw <<-SRC VALUE attr_1(VALUE self){ foo *data = NULL; Data_Get_Struct( self, foo, data); return INT2FIX(data->get_attr_1()); } SRC end end Saturday, 28 September 13
  36. module Foo inline do |builder| builder.add_compile_flags '-x c++', '-lstdc++', '-Wall',

    '-Werror' builder.prefix <<-SRC # line #{__LINE__ + 1} "#{__FILE__}" class foo { ... } SRC builder.c_raw <<-SRC VALUE attr_1(VALUE self){ foo *data = NULL; Data_Get_Struct( self, foo, data); return INT2FIX(data->get_attr_1()); } SRC end end Saturday, 28 September 13
  37. module Foo inline do |builder| builder.add_compile_flags '-x c++', '-lstdc++', '-Wall',

    '-Werror' builder.prefix <<-SRC # line #{__LINE__ + 1} "#{__FILE__}" class foo { ... } SRC builder.c_raw <<-SRC VALUE attr_1(VALUE self){ foo *data = NULL; Data_Get_Struct( self, foo, data); return INT2FIX(data->get_attr_1()); } SRC end end Saturday, 28 September 13
  38. module Foo inline do |builder| builder.add_compile_flags '-x c++', '-lstdc++', '-Wall',

    '-Werror' builder.prefix <<-SRC # line #{__LINE__ + 1} "#{__FILE__}" class foo { ... } SRC builder.c_raw <<-SRC VALUE attr_1(VALUE self){ foo *data = NULL; Data_Get_Struct( self, foo, data); return INT2FIX(data->get_attr_1()); } SRC end end Saturday, 28 September 13
  39. Rubyinline - conclusion • Easy to deploy - no extra

    steps required • great for small hotspots / simple interfaces • raises CompilationError on failure - easy to include pure ruby & native version • Advantages diminish as size grows, eg in general no syntax highlighting, code completion. Saturday, 28 September 13
  40. RICE • C++ library wrapping the ruby c api •

    automates some of the conversion boilerplate via templates • Can still call raw C api if needed Saturday, 28 September 13
  41. long calculate_fibonacci(Object self, long n){ long result = 1, previous=0;

    for(long i=0; i< n-1;i++){ long old_previous = previous; previous = result; result = old_previous + result; } return result; } extern "C" void Init_fib(){ Class rb_cTest = define_class("Fibonnaci"). define_singleton_method("value", &calculate_fibonacci); } Saturday, 28 September 13
  42. long calculate_fibonacci(Object self, long n){ long result = 1, previous=0;

    for(long i=0; i< n-1;i++){ long old_previous = previous; previous = result; result = old_previous + result; } return result; } extern "C" void Init_fib(){ Class rb_cTest = define_class("Fibonnaci"). define_singleton_method("value", &calculate_fibonacci); } Saturday, 28 September 13
  43. long calculate_fibonacci(Object self, long n){ long result = 1, previous=0;

    for(long i=0; i< n-1;i++){ long old_previous = previous; previous = result; result = old_previous + result; } return result; } extern "C" void Init_fib(){ Class rb_cTest = define_class("Fibonnaci"). define_singleton_method("value", &calculate_fibonacci); } Saturday, 28 September 13
  44. void some_method(String name, Object options_or_nil){ Hash options; if(!options_or_nil.is_nil()){ options =

    options_or_nil; } ... } extern "C" void Init_ext(){ Class rb_cTest = define_class("Test"). define_method("some_method",( Arg("name"), Arg("options_or_nil")=Nil)); } Optional arguments Saturday, 28 September 13
  45. void some_method(String name, Object options_or_nil){ Hash options; if(!options_or_nil.is_nil()){ options =

    options_or_nil; } ... } extern "C" void Init_ext(){ Class rb_cTest = define_class("Test"). define_method("some_method",( Arg("name"), Arg("options_or_nil")=Nil)); } Optional arguments Saturday, 28 September 13
  46. void some_method(String name, Object options_or_nil){ Hash options; if(!options_or_nil.is_nil()){ options =

    options_or_nil; } ... } extern "C" void Init_ext(){ Class rb_cTest = define_class("Test"). define_method("some_method",( Arg("name"), Arg("options_or_nil")=Nil)); } Optional arguments Saturday, 28 September 13
  47. void some_method(String name, Object options_or_nil){ Hash options; if(!options_or_nil.is_nil()){ options =

    options_or_nil; } ... } extern "C" void Init_ext(){ Class rb_cTest = define_class("Test"). define_method("some_method",( Arg("name"), Arg("options_or_nil")=Nil)); } Optional arguments Saturday, 28 September 13
  48. Type conversions Hash options = ... int value = options["amount"];

    VALUE amount_ = rb_hash_aref(options, rb_str_new2("amount")); int amount = FIX2INT(amount_); OR Saturday, 28 September 13
  49. Type conversions Hash options = ... int value = options["amount"];

    VALUE amount_ = rb_hash_aref(options, rb_str_new2("amount")); int amount = FIX2INT(amount_); OR Saturday, 28 September 13
  50. Type conversions Hash options = ... int value = options["amount"];

    VALUE amount_ = rb_hash_aref(options, rb_str_new2("amount")); int amount = FIX2INT(amount_); OR Saturday, 28 September 13
  51. Wrapping C++ objects extern "C" void Init_person(){ Data_Type<Person> rb_cPerson =

    define_class<Person>("Person"). define_constructor(Constructor<Person>()). define_method("name", &Person::get_name). define_method("name=",&Person::set_name). define_method("assimilate",&Person::assimilate). } Saturday, 28 September 13
  52. Wrapping C++ objects extern "C" void Init_person(){ Data_Type<Person> rb_cPerson =

    define_class<Person>("Person"). define_constructor(Constructor<Person>()). define_method("name", &Person::get_name). define_method("name=",&Person::set_name). define_method("assimilate",&Person::assimilate). } Saturday, 28 September 13
  53. Wrapping C++ objects extern "C" void Init_person(){ Data_Type<Person> rb_cPerson =

    define_class<Person>("Person"). define_constructor(Constructor<Person>()). define_method("name", &Person::get_name). define_method("name=",&Person::set_name). define_method("assimilate",&Person::assimilate). } Saturday, 28 September 13
  54. class Person { public: Person():m_name(""){} const std::string& get_name() const{ return

    m_name; } void set_name(const std::string& new_name){ m_name = new_name; } void assimilate(Person other_person){ ... } private: std::string m_name; }; Saturday, 28 September 13
  55. class Person { public: Person():m_name(""){} const std::string& get_name() const{ return

    m_name; } void set_name(const std::string& new_name){ m_name = new_name; } void assimilate(Person other_person){ ... } private: std::string m_name; }; Saturday, 28 September 13
  56. class Person { public: Person():m_name(""){} const std::string& get_name() const{ return

    m_name; } void set_name(const std::string& new_name){ m_name = new_name; } void assimilate(Person other_person){ ... } private: std::string m_name; }; Saturday, 28 September 13
  57. class Person { public: Person():m_name(""){} const std::string& get_name() const{ return

    m_name; } void set_name(const std::string& new_name){ m_name = new_name; } void assimilate(Person other_person){ ... } private: std::string m_name; }; Saturday, 28 September 13
  58. • bridges C++ and ruby exceptions • implements STL iterators

    for Array, Hash • Loads of details at http://jasonroelofs.com/ 2010/02/23/how-rice-works/ RICE Saturday, 28 September 13
  59. And now, for something completely different Saturday, 28 September 13

  60. FFI • based on libffi • Ruby DSL for binding

    C functions / global variables • No compiler toolchain required, no C code to write • Supported by jruby, mri, rubinius Saturday, 28 September 13
  61. require 'ffi' module C extend FFI::Library ffi_lib 'c' attach_function 'puts',

    [:string], :int end C.puts "Hello world" Saturday, 28 September 13
  62. require 'ffi' module C extend FFI::Library ffi_lib 'c' attach_function 'puts',

    [:string], :int end C.puts "Hello world" Saturday, 28 September 13
  63. require 'ffi' module C extend FFI::Library ffi_lib 'c' attach_function 'puts',

    [:string], :int end C.puts "Hello world" Saturday, 28 September 13
  64. require 'ffi' module C extend FFI::Library ffi_lib 'c' attach_function 'puts',

    [:string], :int end C.puts "Hello world" Saturday, 28 September 13
  65. module LibC extend FFI::Library ffi_lib FFI::Library::LIBC callback :qsort_cmp, [:pointer, :pointer

    ], :int attach_function :qsort, [:pointer, :ulong, :ulong, :qsort_cmp], :int end def sort(array_of_ints) p = FFI::MemoryPointer.new(:int32, array_of_ints.size) p.put_array_of_int32(0, array_of_ints) LibC.qsort(p, array_of_ints.size, 4) do |p1, p2| i1 = p1.get_int32(0) i2 = p2.get_int32(0) i1 <=> i2 end p.get_array_of_int32(0, array_of_ints.size) end Saturday, 28 September 13
  66. module LibC extend FFI::Library ffi_lib FFI::Library::LIBC callback :qsort_cmp, [:pointer, :pointer

    ], :int attach_function :qsort, [:pointer, :ulong, :ulong, :qsort_cmp], :int end def sort(array_of_ints) p = FFI::MemoryPointer.new(:int32, array_of_ints.size) p.put_array_of_int32(0, array_of_ints) LibC.qsort(p, array_of_ints.size, 4) do |p1, p2| i1 = p1.get_int32(0) i2 = p2.get_int32(0) i1 <=> i2 end p.get_array_of_int32(0, array_of_ints.size) end Saturday, 28 September 13
  67. module LibC extend FFI::Library ffi_lib FFI::Library::LIBC callback :qsort_cmp, [:pointer, :pointer],

    :int attach_function :qsort, [:pointer, :ulong, :ulong, :qsort_cmp], :int end def sort(array_of_ints) p = FFI::MemoryPointer.new(:int32, array_of_ints.size) p.put_array_of_int32(0, array_of_ints) LibC.qsort(p, array_of_ints.size, 4) do |p1, p2| i1 = p1.get_int32(0) i2 = p2.get_int32(0) i1 <=> i2 end p.get_array_of_int32(0, array_of_ints.size) end Saturday, 28 September 13
  68. module LibC extend FFI::Library ffi_lib FFI::Library::LIBC callback :qsort_cmp, [:pointer, :pointer],

    :int attach_function :qsort, [:pointer, :ulong, :ulong, :qsort_cmp], :int end def sort(array_of_ints) p = FFI::MemoryPointer.new(:int32, array_of_ints.size) p.put_array_of_int32(0, array_of_ints) LibC.qsort(p, array_of_ints.size, 4) do |p1, p2| i1 = p1.get_int32(0) i2 = p2.get_int32(0) i1 <=> i2 end p.get_array_of_int32(0, array_of_ints.size) end Saturday, 28 September 13
  69. module LibC extend FFI::Library ffi_lib FFI::Library::LIBC class Timezone < FFI::Struct

    layout :tz_minuteswest, :int, :tz_dsttime, :int end class Timeval < FFI::Struct layout :tv_sec, :time_t, :tv_usec, :suseconds_t end attach_function :gettimeofday, [Timeval, Timezone], :int end out = LibC::Timeval.new LibC.gettimeofday(out, nil) puts "the time according to libc is #{out[:tv_sec]}" Saturday, 28 September 13
  70. module LibC extend FFI::Library ffi_lib FFI::Library::LIBC class Timezone < FFI::Struct

    layout :tz_minuteswest, :int, :tz_dsttime, :int end class Timeval < FFI::Struct layout :tv_sec, :time_t, :tv_usec, :suseconds_t end attach_function :gettimeofday, [Timeval, Timezone], :int end out = LibC::Timeval.new LibC.gettimeofday(out, nil) puts "the time according to libc is #{out[:tv_sec]}" Saturday, 28 September 13
  71. module LibC extend FFI::Library ffi_lib FFI::Library::LIBC class Timezone < FFI::Struct

    layout :tz_minuteswest, :int, :tz_dsttime, :int end class Timeval < FFI::Struct layout :tv_sec, :time_t, :tv_usec, :suseconds_t end attach_function :gettimeofday, [Timeval, Timezone], :int end out = LibC::Timeval.new LibC.gettimeofday(out, nil) puts "the time according to libc is #{out[:tv_sec]}" Saturday, 28 September 13
  72. module LibC extend FFI::Library ffi_lib FFI::Library::LIBC class Timezone < FFI::Struct

    layout :tz_minuteswest, :int, :tz_dsttime, :int end class Timeval < FFI::Struct layout :tv_sec, :time_t, :tv_usec, :suseconds_t end attach_function :gettimeofday, [Timeval, Timezone], :int end out = LibC::Timeval.new LibC.gettimeofday(out, nil) puts "the time according to libc is #{out[:tv_sec]}" Saturday, 28 September 13
  73. Beyond toy examples • OS X Keychain wrapper written using

    C api, FFI, RICE • https://github.com/fcheung/keychain ~ 1000 lines of ruby, ~ 600 lines of real code • https://github.com/fcheung/keychain_c/ ~ 700 lines of C + a small amount of ruby to autogenerate accessors • https://github.com/fcheung/keychain_rice ~ 800 lines of C++ (no auto generated accessors) • All versions pass the same set of specs Saturday, 28 September 13
  74. def unlock! password=nil if password password = password.encode(Encoding::UTF_8) status =

    Sec.SecKeychainUnlock self, password.bytesize, password, 1 else status = Sec.SecKeychainUnlock self, 0, nil, 0 end Sec.check_osstatus status end FFI Saturday, 28 September 13
  75. RICE void Keychain::unlock(const Object password_or_nil){ OSStatus result = 0; if(password_or_nil.test()){

    String password = password_or_nil.call("encode","UTF-8"); result = SecKeychainUnlock(m_keychain, (UInt32)password.length(), (UInt8*)password.c_str(), true); } else{ result = SecKeychainUnlock(m_keychain,0,NULL,false); } CheckOSStatusOrRaise(result); } Saturday, 28 September 13
  76. C static VALUE rb_keychain_unlock(int argc, VALUE *argv, VALUE self){ OSStatus

    result = noErr; VALUE password; SecKeychainRef keychain=NULL; Data_Get_Struct(self, struct OpaqueSecKeychainRef, keychain); rb_scan_args(argc, argv, "01", &password); if(password){ StringValue(password); password = rb_str_export_to_enc(password, rb_utf8_encoding()); result = SecKeychainUnlock(keychain, (UInt32)RSTRING_LEN(password), (UInt8*)RSTRING_PTR(password), true); }else{ result = SecKeychainUnlock(keychain,0,NULL,false); } CheckOSStatusOrRaise(result); return Qnil; } Saturday, 28 September 13
  77. • Great when you have a C library to wrap

    • Small performance penalty over a C extension (often irrelevant) • Much easier/nicer (in my experience) than writing C extensions • Handles many difficult edge cases FFI summary Saturday, 28 September 13
  78. The good stuff • No knowledge of MRI C api

    required • Better compatibility across implementations • All glue code is ruby - easier to write and easier to be ruby-like • less typechecking/wrapping/unwrapping boilerplate • FFI yielded more reusable components (core_foundation gem) Saturday, 28 September 13
  79. But... • Takes a little getting used to • Constants

    / enums / #defines are a pain • you still need to understand C, memory management • Some incompatibilities between FFI implementations • harder to create narrow slices of functionality • Still crashes just as hard if you mess it up Saturday, 28 September 13
  80. Other languages • C is the lingua franca • Wrap

    with C, then use previous techniques Saturday, 28 September 13
  81. Objective-C • Not handled by ffi out of the box

    • Can write wrapper library exposing C entry points Saturday, 28 September 13
  82. Or... • Objective-C method calls are just calls to objc_msgSend

    • Objective-C supports run time introspection of classes, methods etc. • Can we use some ruby metaprogramming to bridge the two? Saturday, 28 September 13
  83. Thank You! • frederick.cheung@gmail.com • @fglc2 • github.com/fcheung • http://spacevatican.org

    Saturday, 28 September 13