ffi-yajl 0.0.1-universal-java → 3.0.1

data/ext/ffi_yajl/ext/encoder/encoder.c

@@ -2,18 +2,12 @@
 #include <yajl/yajl_gen.h>
 
 static VALUE mFFI_Yajl, mExt, mEncoder, mEncoder2, cEncodeError;
+static VALUE cDate, cTime, cDateTime, cStringIO;
+static VALUE cYajl_Gen;
 
 /* FIXME: the json gem does a whole bunch of indirection around monkeypatching...  not sure if we need to as well... */
 
-#define CHECK_STATUS(call) \
-      if ((status = (call)) != yajl_gen_status_ok) { rb_funcall(mEncoder2, rb_intern("raise_error_for_status"), 1, status); }
-
-typedef struct {
-  VALUE json_opts;
-  int processing_key;
-} ffi_state_t;
-
-static VALUE mEncoder_do_yajl_encode(VALUE self, VALUE obj, VALUE yajl_gen_opts) {
+static VALUE mEncoder_do_yajl_encode(VALUE self, VALUE obj, VALUE yajl_gen_opts, VALUE json_opts) {
   ID sym_ffi_yajl = rb_intern("ffi_yajl");
   VALUE sym_yajl_gen_beautify = ID2SYM(rb_intern("yajl_gen_beautify"));
   VALUE sym_yajl_gen_validate_utf8 = ID2SYM(rb_intern("yajl_gen_validate_utf8"));
@@ -21,9 +15,10 @@ static VALUE mEncoder_do_yajl_encode(VALUE self, VALUE obj, VALUE yajl_gen_opts)
   yajl_gen yajl_gen;
   const unsigned char *buf;
   size_t len;
-  ffi_state_t state;
+  VALUE state;
   VALUE ret;
   VALUE indent_string;
+  VALUE rb_yajl_gen;
 
   yajl_gen = yajl_gen_alloc(NULL);
 
@@ -41,9 +36,15 @@ static VALUE mEncoder_do_yajl_encode(VALUE self, VALUE obj, VALUE yajl_gen_opts)
     yajl_gen_config(yajl_gen, yajl_gen_indent_string, " ");
   }
 
-  state.processing_key = 0;
+  state = rb_hash_new();
+
+  rb_hash_aset(state, rb_str_new2("processing_key"), Qfalse);
+
+  rb_hash_aset(state, rb_str_new2("json_opts"), json_opts);
 
-  rb_funcall(obj, sym_ffi_yajl, 2, yajl_gen, (VALUE) &state);
+  rb_yajl_gen = Data_Wrap_Struct(cYajl_Gen, NULL, NULL, yajl_gen);
+
+  rb_funcall(obj, sym_ffi_yajl, 2, rb_yajl_gen, state);
 
   yajl_gen_get_buf(yajl_gen, &buf, &len);
 
@@ -54,167 +55,301 @@ static VALUE mEncoder_do_yajl_encode(VALUE self, VALUE obj, VALUE yajl_gen_opts)
   return ret;
 }
 
-typedef struct {
-  VALUE yajl_gen;
-  ffi_state_t *state;
-} ffs_extra_t;
-
 int rb_cHash_ffi_yajl_callback(VALUE key, VALUE val, VALUE extra) {
-  ffs_extra_t *extra_p = (ffs_extra_t *)extra;
   ID sym_ffi_yajl = rb_intern("ffi_yajl");
+  VALUE state = rb_hash_aref(extra, rb_str_new2("state"));
+  VALUE rb_yajl_gen = rb_hash_aref(extra, rb_str_new2("yajl_gen"));
 
-  extra_p->state->processing_key = 1;
-  rb_funcall(key, sym_ffi_yajl, 2, extra_p->yajl_gen, extra_p->state);
-  extra_p->state->processing_key = 0;
-  rb_funcall(val, sym_ffi_yajl, 2, extra_p->yajl_gen, extra_p->state);
+  rb_hash_aset(state, rb_str_new2("processing_key"), Qtrue);
+  rb_funcall(key, sym_ffi_yajl, 2, rb_yajl_gen, state);
+  rb_hash_aset(state, rb_str_new2("processing_key"), Qfalse);
+
+  rb_funcall(val, sym_ffi_yajl, 2, rb_yajl_gen, state);
 
   return 0;
 }
 
-static VALUE rb_cHash_ffi_yajl(VALUE self, VALUE yajl_gen, VALUE state) {
+#define RB_FUNC0(call) rb_funcall(self, rb_intern(call), 0)
+
+/*
+ * wrappers around yajl_gen_* functions
+ */
+
+/* encode a c-string as a yajl string */
+VALUE gen_cstring(VALUE rb_yajl_gen, char *cptr, int len) {
   yajl_gen_status status;
-  ffs_extra_t extra;
+  struct yajl_gen_t *yajl_gen;
+  Data_Get_Struct(rb_yajl_gen, struct yajl_gen_t, yajl_gen);
 
-  extra.yajl_gen = yajl_gen;
-  extra.state = (ffi_state_t *)state;
+  if ((status = yajl_gen_string(yajl_gen, (unsigned char *)cptr, len)) != yajl_gen_status_ok) {
+    rb_funcall(mEncoder2, rb_intern("raise_error_for_status"), 2, INT2FIX(status), rb_str_new(cptr, len));
+  }
 
-  CHECK_STATUS(
-    yajl_gen_map_open((struct yajl_gen_t *) yajl_gen)
-  );
-  rb_hash_foreach(self, rb_cHash_ffi_yajl_callback, (VALUE) &extra);
-  CHECK_STATUS(
-    yajl_gen_map_close((struct yajl_gen_t *) yajl_gen)
-  );
+  return Qnil;
+}
+
+/* encode a ruby-sring as a yajl string */
+VALUE gen_string(VALUE rb_yajl_gen, VALUE str) {
+  char *cptr = RSTRING_PTR(str);
+  int len = RSTRING_LEN(str);
+
+  return gen_cstring(rb_yajl_gen, cptr, len);
+}
+
+/* calls #to_s on an object to encode it as a yajl string */
+static VALUE gen_string_to_s(VALUE rb_yajl_gen, VALUE self) {
+  return gen_string(rb_yajl_gen, RB_FUNC0("to_s"));
+}
+
+/* encode a ruby string as a yajl number (also used to embed already-rendered json from #to_json) */
+VALUE gen_number(VALUE rb_yajl_gen, VALUE str) {
+  yajl_gen_status status;
+  struct yajl_gen_t *yajl_gen;
+  Data_Get_Struct(rb_yajl_gen, struct yajl_gen_t, yajl_gen);
+  char *cptr = RSTRING_PTR(str);
+  int len = RSTRING_LEN(str);
+
+  if ((status = yajl_gen_number(yajl_gen, cptr, len)) != yajl_gen_status_ok) {
+    rb_funcall(mEncoder2, rb_intern("raise_error_for_status"), 2, INT2FIX(status), str);
+  }
 
   return Qnil;
 }
 
-static VALUE rb_cArray_ffi_yajl(VALUE self, VALUE yajl_gen, VALUE state) {
+/* encode hash open */
+VALUE gen_map_open(VALUE rb_yajl_gen) {
   yajl_gen_status status;
-  ID sym_ffi_yajl = rb_intern("ffi_yajl");
-  long i;
-  VALUE val;
+  struct yajl_gen_t *yajl_gen;
+  Data_Get_Struct(rb_yajl_gen, struct yajl_gen_t, yajl_gen);
 
-  CHECK_STATUS(
-    yajl_gen_array_open((struct yajl_gen_t *) yajl_gen)
-  );
-  for(i=0; i<RARRAY_LEN(self); i++) {
-    val = rb_ary_entry(self, i);
-    rb_funcall(val, sym_ffi_yajl, 2, yajl_gen, state);
+  if ((status = yajl_gen_map_open(yajl_gen)) != yajl_gen_status_ok) {
+    rb_funcall(mEncoder2, rb_intern("raise_error_for_status"), 2, INT2FIX(status), rb_str_new2("{"));
   }
-  CHECK_STATUS(
-    yajl_gen_array_close((struct yajl_gen_t *) yajl_gen)
-  );
 
   return Qnil;
 }
 
-static VALUE rb_cNilClass_ffi_yajl(VALUE self, VALUE yajl_gen, VALUE state) {
+/* encode a hash close */
+VALUE gen_map_close(VALUE rb_yajl_gen) {
   yajl_gen_status status;
-  CHECK_STATUS(
-    yajl_gen_null((struct yajl_gen_t *) yajl_gen)
-  );
+  struct yajl_gen_t *yajl_gen;
+  Data_Get_Struct(rb_yajl_gen, struct yajl_gen_t, yajl_gen);
+
+  if ((status = yajl_gen_map_close(yajl_gen)) != yajl_gen_status_ok) {
+    rb_funcall(mEncoder2, rb_intern("raise_error_for_status"), 2, INT2FIX(status), rb_str_new2("}"));
+  }
+
   return Qnil;
 }
 
-static VALUE rb_cTrueClass_ffi_yajl(VALUE self, VALUE yajl_gen, VALUE state) {
+/* encode an array open */
+VALUE gen_array_open(VALUE rb_yajl_gen) {
   yajl_gen_status status;
-  CHECK_STATUS(
-    yajl_gen_bool((struct yajl_gen_t *) yajl_gen, 1)
-  );
+  struct yajl_gen_t *yajl_gen;
+  Data_Get_Struct(rb_yajl_gen, struct yajl_gen_t, yajl_gen);
+
+  if ((status = yajl_gen_array_open(yajl_gen)) != yajl_gen_status_ok) {
+    rb_funcall(mEncoder2, rb_intern("raise_error_for_status"), 2, INT2FIX(status), rb_str_new2("["));
+  }
+
   return Qnil;
 }
 
-static VALUE rb_cFalseClass_ffi_yajl(VALUE self, VALUE yajl_gen, VALUE state) {
+/* encode an array close */
+VALUE gen_array_close(VALUE rb_yajl_gen) {
   yajl_gen_status status;
-  CHECK_STATUS(
-    yajl_gen_bool((struct yajl_gen_t *) yajl_gen, 0)
-  );
+  struct yajl_gen_t *yajl_gen;
+  Data_Get_Struct(rb_yajl_gen, struct yajl_gen_t, yajl_gen);
+
+  if ((status = yajl_gen_array_close(yajl_gen)) != yajl_gen_status_ok) {
+    rb_funcall(mEncoder2, rb_intern("raise_error_for_status"), 2, INT2FIX(status), rb_str_new2("]"));
+  }
+
   return Qnil;
 }
 
-static VALUE rb_cFixnum_ffi_yajl(VALUE self, VALUE yajl_gen, VALUE state) {
+/* encode a json null */
+VALUE gen_null(VALUE rb_yajl_gen) {
   yajl_gen_status status;
-  ID sym_to_s = rb_intern("to_s");
-  VALUE str = rb_funcall(self, sym_to_s, 0);
-  char *cptr = RSTRING_PTR(str);
-  int len = RSTRING_LEN(str);
+  struct yajl_gen_t *yajl_gen;
+  Data_Get_Struct(rb_yajl_gen, struct yajl_gen_t, yajl_gen);
 
-  if (memcmp(cptr, "NaN", 3) == 0 || memcmp(cptr, "Infinity", 8) == 0 || memcmp(cptr, "-Infinity", 9) == 0) {
-    rb_raise(cEncodeError, "'%s' is an invalid number", cptr);
+  if ((status = yajl_gen_null(yajl_gen)) != yajl_gen_status_ok) {
+    rb_funcall(mEncoder2, rb_intern("raise_error_for_status"), 2, INT2FIX(status), rb_str_new2("null"));
   }
-  if ( ((ffi_state_t *)state)->processing_key ) {
-    CHECK_STATUS(
-      yajl_gen_string((struct yajl_gen_t *) yajl_gen, (unsigned char *)cptr, len)
-    );
-  } else {
-    CHECK_STATUS(
-      yajl_gen_integer((struct yajl_gen_t *) yajl_gen, NUM2INT(self))
-    );
+
+  return Qnil;
+}
+
+/* encode a true value */
+VALUE gen_true(VALUE rb_yajl_gen) {
+  yajl_gen_status status;
+  struct yajl_gen_t *yajl_gen;
+  Data_Get_Struct(rb_yajl_gen, struct yajl_gen_t, yajl_gen);
+
+  if ((status = yajl_gen_bool(yajl_gen, 1)) != yajl_gen_status_ok) {
+    rb_funcall(mEncoder2, rb_intern("raise_error_for_status"), 2, INT2FIX(status), rb_str_new2("true"));
   }
+
   return Qnil;
 }
 
-static VALUE rb_cBignum_ffi_yajl(VALUE self, VALUE yajl_gen, VALUE state) {
+/* encode a false value */
+VALUE gen_false(VALUE rb_yajl_gen) {
   yajl_gen_status status;
-  ID sym_to_s = rb_intern("to_s");
-  VALUE str = rb_funcall(self, sym_to_s, 0);
-  char *cptr = RSTRING_PTR(str);
-  int len = RSTRING_LEN(str);
-  if (memcmp(cptr, "NaN", 3) == 0 || memcmp(cptr, "Infinity", 8) == 0 || memcmp(cptr, "-Infinity", 9) == 0) {
-    rb_raise(cEncodeError, "'%s' is an invalid number", cptr);
+  struct yajl_gen_t *yajl_gen;
+  Data_Get_Struct(rb_yajl_gen, struct yajl_gen_t, yajl_gen);
+
+  if ((status = yajl_gen_bool(yajl_gen, 0)) != yajl_gen_status_ok) {
+    rb_funcall(mEncoder2, rb_intern("raise_error_for_status"), 2, INT2FIX(status), rb_str_new2("false"));
+  }
+
+  return Qnil;
+}
+
+/*
+ * <Object>#to_ffi_yajl() method calls
+ */
+
+static VALUE rb_cHash_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
+  if ( rb_hash_aref(state, rb_str_new2("processing_key")) == Qtrue ) {
+    gen_string(rb_yajl_gen, rb_funcall(self, rb_intern("to_s"), 0));
+  } else {
+
+    /* FIXME: i think this got refactored from something else and it is now pointless --
+       should just pass rb_yajl_gen directly instead of this 'extra' hash -- i don't
+       *think* this indirection is doing anything useful to mark memory against the GC */
+
+    VALUE extra = rb_hash_new();
+
+    rb_hash_aset(extra, rb_str_new2("yajl_gen"), rb_yajl_gen);
+
+    rb_hash_aset(extra, rb_str_new2("state"), state);
+
+    gen_map_open(rb_yajl_gen);
+
+    rb_hash_foreach(self, rb_cHash_ffi_yajl_callback, extra);
+
+    gen_map_close(rb_yajl_gen);
   }
-  if ( ((ffi_state_t *)state)->processing_key ) {
-    CHECK_STATUS(
-      yajl_gen_string((struct yajl_gen_t *) yajl_gen, (unsigned char *)cptr, len)
-    );
+
+  return Qnil;
+}
+
+static VALUE rb_cArray_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
+  if ( rb_hash_aref(state, rb_str_new2("processing_key")) == Qtrue ) {
+    gen_string(rb_yajl_gen, rb_funcall(self, rb_intern("to_s"), 0));
   } else {
-    CHECK_STATUS(
-      yajl_gen_number((struct yajl_gen_t *) yajl_gen, cptr, len)
-    );
+    VALUE val;
+    long i;
+    ID sym_ffi_yajl = rb_intern("ffi_yajl");
+
+    gen_array_open(rb_yajl_gen);
+
+    for(i=0; i<RARRAY_LEN(self); i++) {
+      val = rb_ary_entry(self, i);
+      rb_funcall(val, sym_ffi_yajl, 2, rb_yajl_gen, state);
+    }
+
+    gen_array_close(rb_yajl_gen);
   }
+
   return Qnil;
 }
 
-static VALUE rb_cFloat_ffi_yajl(VALUE self, VALUE yajl_gen, VALUE state) {
-  yajl_gen_status status;
-  ID sym_to_s = rb_intern("to_s");
-  VALUE str = rb_funcall(self, sym_to_s, 0);
+static VALUE rb_cNilClass_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
+  if ( rb_hash_aref(state, rb_str_new2("processing_key")) == Qtrue ) {
+    gen_cstring(rb_yajl_gen, "", sizeof("")-1);
+  } else {
+    gen_null(rb_yajl_gen);
+  }
+
+  return Qnil;
+}
+
+static VALUE rb_cTrueClass_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
+  if ( rb_hash_aref(state, rb_str_new2("processing_key")) == Qtrue ) {
+    gen_cstring(rb_yajl_gen, "true", sizeof("true")-1);
+  } else {
+    gen_true(rb_yajl_gen);
+  }
+
+  return Qnil;
+}
+
+static VALUE rb_cFalseClass_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
+  if ( rb_hash_aref(state, rb_str_new2("processing_key")) == Qtrue ) {
+    gen_cstring(rb_yajl_gen, "false", sizeof("false")-1);
+  } else {
+    gen_false(rb_yajl_gen);
+  }
+
+  return Qnil;
+}
+
+static VALUE rb_cFixnum_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
+  VALUE str = rb_funcall(self, rb_intern("to_s"), 0);
   char *cptr = RSTRING_PTR(str);
-  int len = RSTRING_LEN(str);
-  if (memcmp(cptr, "NaN", 3) == 0 || memcmp(cptr, "Infinity", 8) == 0 || memcmp(cptr, "-Infinity", 9) == 0) {
+
+  if (memcmp(cptr, "NaN", sizeof("NaN")) == 0 || memcmp(cptr, "Infinity", sizeof("Infinity")) == 0 || memcmp(cptr, "-Infinity", sizeof("-Infinity")) == 0) {
     rb_raise(cEncodeError, "'%s' is an invalid number", cptr);
   }
-  if ( ((ffi_state_t *)state)->processing_key ) {
-    CHECK_STATUS(
-      yajl_gen_string((struct yajl_gen_t *) yajl_gen, (unsigned char *)cptr, len)
-    );
+
+  if ( rb_hash_aref(state, rb_str_new2("processing_key")) == Qtrue ) {
+    gen_string(rb_yajl_gen, str);
   } else {
-    CHECK_STATUS(
-      yajl_gen_number((struct yajl_gen_t *) yajl_gen, cptr, len)
-    );
+    gen_number(rb_yajl_gen, str);
   }
+
   return Qnil;
 }
 
+static VALUE rb_cBignum_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
+  return rb_cFixnum_ffi_yajl(self, rb_yajl_gen, state);
+}
 
-static VALUE rb_cString_ffi_yajl(VALUE self, VALUE yajl_gen, VALUE state) {
-  yajl_gen_status status;
-  CHECK_STATUS(
-    yajl_gen_string((struct yajl_gen_t *) yajl_gen, (unsigned char *)RSTRING_PTR(self), RSTRING_LEN(self))
-  );
-  return Qnil;
+static VALUE rb_cFloat_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
+  return rb_cFixnum_ffi_yajl(self, rb_yajl_gen, state);
 }
 
-static VALUE rb_cObject_ffi_yajl(VALUE self, VALUE yajl_gen, VALUE state) {
-  yajl_gen_status status;
+static VALUE rb_cString_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
+  return gen_string(rb_yajl_gen, self);
+}
+
+static VALUE rb_cSymbol_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
+  return gen_string_to_s(rb_yajl_gen, self);
+}
+
+static VALUE rb_cDate_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
+  return gen_string_to_s(rb_yajl_gen, self);
+}
+
+static VALUE rb_cTime_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
+  ID sym_strftime = rb_intern("strftime");
+  VALUE str = rb_funcall(self, sym_strftime, 1, rb_str_new2("%Y-%m-%d %H:%M:%S %z"));
+
+  return gen_string(rb_yajl_gen, str);
+}
+
+static VALUE rb_cStringIO_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
+  return gen_string(rb_yajl_gen, RB_FUNC0("read"));
+}
+
+static VALUE rb_cDateTime_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
+  return gen_string_to_s(rb_yajl_gen, self);
+}
+
+static VALUE rb_cObject_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
   ID sym_to_json = rb_intern("to_json");
-  VALUE str;
+  if ( rb_hash_aref(state, rb_str_new2("processing_key")) != Qtrue && rb_respond_to(self, sym_to_json) ) {
+    VALUE json_opts = rb_hash_aref(state, rb_str_new2("json_opts"));
+    VALUE str = rb_funcall(self, sym_to_json, 1, json_opts);
+
+    gen_number(rb_yajl_gen, str);
+  } else {
+    gen_string_to_s(rb_yajl_gen, self);
+  }
 
-  str = rb_funcall(self, sym_to_json, 1, ((ffi_state_t *)state)->json_opts);
-  CHECK_STATUS(
-    yajl_gen_number((struct yajl_gen_t *) yajl_gen, (char *)RSTRING_PTR(str), RSTRING_LEN(str))
-  );
   return Qnil;
 }
 
@@ -224,17 +359,37 @@ void Init_encoder() {
   cEncodeError = rb_define_class_under(mFFI_Yajl, "EncodeError", rb_eStandardError);
   mExt = rb_define_module_under(mFFI_Yajl, "Ext");
   mEncoder = rb_define_module_under(mExt, "Encoder");
-  rb_define_method(mEncoder, "do_yajl_encode", mEncoder_do_yajl_encode, 2);
+  cYajl_Gen = rb_define_class_under(mEncoder, "YajlGen", rb_cObject);
+  rb_undef_alloc_func(cYajl_Gen);
+  rb_define_method(mEncoder, "do_yajl_encode", mEncoder_do_yajl_encode, 3);
+
+  /* use rb_const_get instead of rb_define_class so that we don't get superclass mismatches */
+  ID sym_Date = rb_intern("Date");
+  cDate = rb_const_get(rb_cObject, sym_Date);
+  ID sym_Time = rb_intern("Time");
+  cTime = rb_const_get(rb_cObject, sym_Time);
+  ID sym_DateTime = rb_intern("DateTime");
+  cDateTime = rb_const_get(rb_cObject, sym_DateTime);
+  ID sym_StringIO = rb_intern("StringIO");
+  cStringIO = rb_const_get(rb_cObject, sym_StringIO);
 
   rb_define_method(rb_cHash, "ffi_yajl", rb_cHash_ffi_yajl, 2);
   rb_define_method(rb_cArray, "ffi_yajl", rb_cArray_ffi_yajl, 2);
   rb_define_method(rb_cNilClass, "ffi_yajl", rb_cNilClass_ffi_yajl, 2);
   rb_define_method(rb_cTrueClass, "ffi_yajl", rb_cTrueClass_ffi_yajl, 2);
   rb_define_method(rb_cFalseClass, "ffi_yajl", rb_cFalseClass_ffi_yajl, 2);
+#ifdef rb_cFixnum /* ruby < 2.4 */
   rb_define_method(rb_cFixnum, "ffi_yajl", rb_cFixnum_ffi_yajl, 2);
   rb_define_method(rb_cBignum, "ffi_yajl", rb_cBignum_ffi_yajl, 2);
+#else
+  rb_define_method(rb_cInteger, "ffi_yajl", rb_cFixnum_ffi_yajl, 2);
+#endif
   rb_define_method(rb_cFloat, "ffi_yajl", rb_cFloat_ffi_yajl, 2);
   rb_define_method(rb_cString, "ffi_yajl", rb_cString_ffi_yajl, 2);
+  rb_define_method(rb_cSymbol, "ffi_yajl", rb_cSymbol_ffi_yajl, 2);
+  rb_define_method(cDate, "ffi_yajl", rb_cDate_ffi_yajl, 2);
+  rb_define_method(cTime, "ffi_yajl", rb_cTime_ffi_yajl, 2);
+  rb_define_method(cDateTime, "ffi_yajl", rb_cDateTime_ffi_yajl, 2);
+  rb_define_method(cStringIO, "ffi_yajl", rb_cStringIO_ffi_yajl, 2);
   rb_define_method(rb_cObject, "ffi_yajl", rb_cObject_ffi_yajl, 2);
 }
-

data/ext/ffi_yajl/ext/encoder/extconf.rb

@@ -1,29 +1,86 @@
-require 'mkmf'
+# rubocop:disable Style/GlobalVars
+require "mkmf"
+require "rubygems"
+require "libyajl2"
 
-# the customer is always right, ruby is always compiled to be stupid
-$CFLAGS = ENV['CFLAGS'] if ENV['CFLAGS']
-$LDFLAGS = ENV['LDFLAGS'] if ENV['LDFLAGS']
-RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+RbConfig::MAKEFILE_CONFIG["CC"] = ENV["CC"] if ENV["CC"]
 
-# search our gem root first to pick up libyajl2 that we vendored
-gem_root = File.expand_path(File.join(File.dirname(__FILE__), "../../../.."))
-$CFLAGS = "-I#{gem_root}/include -L#{gem_root}/lib #{$CFLAGS}"
-$LDFLAGS = "-L#{gem_root}/lib #{$CFLAGS}"
+# pick up the vendored libyajl2 out of the libyajl2 gem
+$CFLAGS = " -I#{Libyajl2.include_path} #{$CFLAGS}"
+$LDFLAGS = " -L#{Libyajl2.opt_path} #{$LDFLAGS}"
+
+# remove "-Wl,--no-undefined" flag if existent to allow for loading with dlopen
+$LDFLAGS.slice!("-Wl,--no-undefined")
 
-puts gem_root
 puts $CFLAGS
 puts $LDFLAGS
 
 # except if you're doing an unoptimized gcc install we're going to help you out a bit
-if RbConfig::MAKEFILE_CONFIG['CC'] =~ /gcc|clang/
+if RbConfig::MAKEFILE_CONFIG["CC"] =~ /gcc|clang/
   $CFLAGS << " -O3" unless $CFLAGS[/-O\d/]
   # how many people realize that -Wall is a compiler-specific flag???
   # apparently not many based on reading lots of shitty extconf.rb's out there
   $CFLAGS << " -Wall"
 end
 
-$LDFLAGS << " -lyajl"
+def windows?
+  !!(RUBY_PLATFORM =~ /mswin|mingw|cygwin|windows/)
+end
+
+def macos?
+  !!(RUBY_PLATFORM =~ /darwin/)
+end
+
+def clang?
+  cc_version = `#{RbConfig.expand("$(CC) --version")}`
+  cc_version.match?(/clang/i)
+end
+
+# XCode 14 warns if `-Wl,-undefined dynamic_lookup` is specified, and as
+# a result Ruby interpreters compiled under XCode 14 no longer specify
+# this flag by default in DLDFLAGS. Let's specify the list of dynamic symbols
+# here to avoid compilation failures.
+if clang? && macos?
+  symfile = File.join(__dir__, "../dlopen/yajl.sym")
+  dynamic_symbols = File.readlines(symfile)
+  dynamic_symbols.each do |sym|
+    $DLDFLAGS << " -Wl,-U,#{sym.strip}"
+  end
+end
+
+if windows?
+  # include our libyajldll.a definitions on windows in the libyajl2 gem
+  $libs = "#{$libs} -lyajldll"
+end
+
+# NOTE: find_library has the side effect of adding -lyajl to the flags which we are deliberately
+# avoiding doing with the libyajl2-gem (allowing it to be lazily loaded with dlopen)
+if !windows? && !find_header("yajl/yajl_tree.h")
+  puts "libyajl2 headers not found in libyajl2-gem, searching for system libraries..."
+
+  HEADER_DIRS = [
+    "/opt/local/include",                   # MacPorts
+    "/usr/local/include",                   # /usr/local
+    RbConfig::CONFIG["includedir"],         # Ruby
+    "/usr/include",                         # (default)
+  ].freeze
+
+  LIB_DIRS = [
+    "/opt/local/lib",                       # MacPorts
+    "/usr/local/lib",                       # /usr/local + Homebrew
+    RbConfig::CONFIG["libdir"],             # Ruby
+    "/usr/lib",                             # (default)
+  ].freeze
+
+  # add --with-yajl-dir, --with-yajl-include, --with-yajl-lib
+  dir_config("yajl", HEADER_DIRS, LIB_DIRS)
+
+  # here we use find_library in order to deliberately link with -lyajl as a useful side-effect
+  unless find_header("yajl/yajl_tree.h") && find_library("yajl", "yajl_complete_parse")
+    abort "libyajl2 is missing.  please install libyajl2"
+  end
+end
 
-dir_config 'encoder'
+dir_config "encoder"
 
-create_makefile 'ffi_yajl/ext/encoder'
+create_makefile "ffi_yajl/ext/encoder"