ffi-yajl 2.7.5-universal-mingw-ucrt

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 61e4e54489f7ea4835b58105e6cb7b7d759da4a77e2ea72eb90e2064c3027345
+  data.tar.gz: 3685d7dc11576660418fdec28fa47b0ea0e31c8e1ccc963339d60ca97d9a5370
+SHA512:
+  metadata.gz: b28fc263e5acfce39f71c02a3887c4fcee1dde3ffd3560f2501006d386e60e697ec3cbf91d2676e6289aa009ab48c0b165669d4b905c528d5688826d0c8a85ae
+  data.tar.gz: e3372cd7d153a9e85a7fce925dddd0718e76c77f1e540c3b62d5e1fafd288e5b88064d239ee2bc1edd351e53e19583e8c6f7e5524ff445b9d66871581e41de01

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Lamont Granquist
+Copyright (c) 2014 Chef Software, Inc.
+Copyright (c) 2008-2011 Brian Lopez - http://github.com/brianmario
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,118 @@
+# FFI YAJL
+
+[![Build status](https://badge.buildkite.com/35c43155d637f5201a5030cd4e7d8025573c0042094e00bbb3.svg?branch=master)](https://buildkite.com/chef-oss/chef-ffi-yajl-master-verify) [![Gem Version](https://badge.fury.io/rb/ffi-yajl.svg)](https://badge.fury.io/rb/ffi-yajl)
+
+**Umbrella Project**: [Chef Foundation](https://github.com/chef/chef-oss-practices/blob/master/projects/chef-foundation.md)
+
+**Project State**: [Active](https://github.com/chef/chef-oss-practices/blob/master/repo-management/repo-states.md#active)
+
+**Issues [Response Time Maximum](https://github.com/chef/chef-oss-practices/blob/master/repo-management/repo-states.md)**: 14 days
+
+**Pull Request [Response Time Maximum](https://github.com/chef/chef-oss-practices/blob/master/repo-management/repo-states.md)**: 14 days
+
+
+ffi-yajl is a Ruby adapter for the [yajl](http://lloyd.github.io/yajl/) JSON parser/generator library. ffi-yajl supports multiple Ruby C extension mechanisms, including both MRI native extensions and FFI in order to be compatible with as many Ruby implementations as possible while providing good performance where possible.
+
+## How to Install
+
+**Warning** if building through Omnibus, a preinstalled ffi-yajl and libyajl2-gem version not matching the bundled version of the project you're attempting to build (e.g., Chef) may cause:
+
+`cannot find -lyajldll: No such file or directory`
+
+If your build script ends up up in this state, a short term fix is `gem uninstall -I libyajl2` before the failing `bundle install`
+
+
+### Install from the command-line:
+
+```
+gem install ffi-yajl
+```
+
+Or use a Gemfile:
+
+```
+gem 'ffi-yajl'
+```
+
+## Supported Ruby VMs:
+
+- Ruby 2.2+ and compatible rbx or jruby
+
+## Supported Distros:
+
+- Ubuntu 10.04 through 14.10
+- Debian 7.x
+- RHEL/CentOS/Oracle 5.x/6.x/7.x
+- Solaris 9/10/11 (gcc, sun compiler untested)
+- AIX 6.x/7.x (gcc or xlc)
+- Windows 2008r2/2012 (and Win2k/2k3 and consumer versions should work)
+
+## Basic Usage
+
+Start by requiring it:
+
+```ruby
+require 'ffi_yajl'
+```
+
+You can encode and parse with class objects:
+
+```ruby
+options_hash = {}
+json = FFI_Yajl::Encoder.encode( {"foo"=>["bar","baz"]}, options_hash )
+hash = FFI_Yajl::Parser.parse( json, options_hash )
+```
+
+Or you can be more object oriented:
+
+```ruby
+options_hash = {}
+encoder = FFI_Yajl::Encoder.new( options_hash )
+json = encoder.encode( {"foo"=>["bar","baz"]} )
+parser = FFI_Yajl::Parser.new( options_hash )
+hash = parser.parse( json )
+```
+
+## Parser Options
+
+- `:check_utf8`
+- `:dont_validate_strings`
+- `:symbolize_keys` (default = false): JSON keys are parsed into symbols instead of strings.
+- `:symbolize_names` (default = false): Alias for `:symbolize_keys`.
+- `:allow_trailing_garbage`
+- `:allow_multiple_values`
+- `:allow_partial_values`
+- `:unique_key_checking` (default = false): Will raise an exception if keys are repeated in hashes in the input JSON. Without this, repeated keys will silently replace the previous key.
+
+## Encoder Options
+
+- `:pretty` (default = false): Produces more human readable 'pretty' output.
+- `:validate_utf8` (default = true): Will raise an exception when trying to encode strings that are invalid UTF-8\. When set to false this still will produce valid UTF-8 JSON but will replace invalid characters.
+
+## Forcing FFI or C Extension
+
+You can set the environment variable `FORCE_FFI_YAJL` to `ext` or `ffi` to control if the C extension or FFI bindings are used.
+
+## Yajl Library Packaging
+
+This library prefers to use the embedded yajl 2.x C library packaged in the libyajl2 gem. In order to use the operating system yajl library (which must be yajl 2.x) the environment variable `USE_SYSTEM_LIBYAJL2` can be set before installing or bundling libyajl2\. This will force the libyajl2 gem to skip compiling its embedded library and the ffi-yajl gem will fallback to using the system yajl library.
+
+## No JSON Gem Compatiblity layer
+
+This library does not offer a feature to patch `#to_json` methods into all the ruby classes similarly to the JSON gem or yajl-ruby's `yajl/json_gem` compatibility API. The differences in encoding between the JSON gem and the Yajl C library can produce different output on different systems and makes testing brittle. Such a feature will not be included. It was removed in this pull request and could be easily extracted to its own gem (we have no interest in maintaining that gem):
+
+<https://github.com/chef/ffi-yajl/pull/47/files>
+
+## Why This Instead of X?
+
+yajl is the only JSON library we've found that has error messages that meet our requirements. The stdlib json gem and oj (at the time we started this project) have error messages like "invalid token at byte 1234," which are probably fine for server use, but in [chef](https://github.com/chef/chef) we frequently deal with user-written JSON documents, which means we need a good user experience when encountering malformed JSON.
+
+We previously used brianmario's [yajl-ruby](https://github.com/brianmario/yajl-ruby) project, but we wanted to be able to fallback to using FFI bindings to the C code (so we could support non-MRI rubies) and we also needed some bug fixes in yajl2, but the maintainer wasn't able to devote enough time to the project to make these updates in a timeframe that worked for us.
+
+## Thanks
+
+This was initially going to be a clean rewrite of an ffi ruby wrapper around yajl2, but as it progressed more and more code was pulled in from brianmario's existing yajl-ruby gem, particularly all the c extension code, lots of specs and the benchmarks. And the process of writing this would have been much more difficult without being able to draw heavily from already solved problems in yajl-ruby.
+
+## License
+
+Given that this draws heavily from the yajl-ruby sources, and could be considered a derivative work, the MIT License from that project has been preserved and this source code has deliberately not been dual licensed under Chef's typical Apache License. See the [LICENSE](https://github.com/chef/ffi-yajl/blob/master/LICENSE) file in this project.

data/bin/ffi-yajl-bench

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.expand_path(File.join(File.dirname( File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__ ), "../lib"))
+
+require "optparse"
+require "ffi_yajl/benchmark"
+
+opts = {}
+optparse = OptionParser.new do |o|
+  o.banner = "Usage: ffi-yajl-bench"
+
+  opts[:profile] = false
+  o.on( "-p", "--profile", "Run perftools.rb profiling" ) do
+    opts[:profile] = true
+  end
+
+  o.on( "-F", "--ffi", "Force using FFI" ) do
+    opts[:ffi] = true
+  end
+
+  o.on( "-E", "--ext", "Force using C ext" ) do
+    opts[:ext] = true
+  end
+end
+
+optparse.parse!
+
+ENV["FORCE_FFI_YAJL"] = "ffi" if opts[:ffi]
+ENV["FORCE_FFI_YAJL"] = "ext" if opts[:ext]
+
+if opts[:profile]
+  FFI_Yajl::Benchmark::ParseProfileRubyProf.new.run
+else
+  FFI_Yajl::Benchmark::Parse.new.run
+  FFI_Yajl::Benchmark::Encode.new.run
+end

data/ext/ffi_yajl/ext/dlopen/dlopen.c

@@ -0,0 +1,40 @@
+#include <ruby.h>
+
+#if defined(HAVE_DLFCN_H)
+# include <dlfcn.h>
+#ifndef RTLD_LAZY
+#define RTLD_LAZY 0
+#endif
+#ifndef RTLD_GLOBAL
+#define RTLD_GLOBAL 0
+#endif
+#ifndef RTLD_NOW
+#define RTLD_NOW 0
+#endif
+#else
+# if defined(_WIN32)
+#   include <windows.h>
+#   define dlopen(name,flag) ((void*)LoadLibrary(name))
+#   define dlerror() strerror(rb_w32_map_errno(GetLastError()))
+#   define dlsym(handle,name) ((void*)GetProcAddress((handle),(name)))
+#   define RTLD_LAZY -1
+#   define RTLD_NOW  -1
+#   define RTLD_GLOBAL -1
+# endif
+#endif
+
+static VALUE mFFI_Yajl, mDlopen, mExt;
+
+static VALUE mDlopen_dlopen(VALUE self, VALUE file) {
+  if (dlopen(RSTRING_PTR(file), RTLD_NOW|RTLD_GLOBAL) == NULL) {
+    rb_raise(rb_eArgError, "%s", dlerror());
+  }
+  return Qnil;
+}
+
+void Init_dlopen() {
+  mFFI_Yajl = rb_define_module("FFI_Yajl");
+  mExt = rb_define_module_under(mFFI_Yajl, "Ext");
+  mDlopen = rb_define_module_under(mExt, "Dlopen");
+  rb_define_method(mDlopen, "dlopen", mDlopen_dlopen, 1);
+}

data/ext/ffi_yajl/ext/dlopen/extconf.rb

@@ -0,0 +1,16 @@
+# rubocop:disable Style/GlobalVars
+require "mkmf"
+require "rubygems"
+
+RbConfig::MAKEFILE_CONFIG["CC"] = ENV["CC"] if ENV["CC"]
+
+puts $CFLAGS
+puts $LDFLAGS
+
+have_header("dlfcn.h")
+
+have_library("dl", "dlopen")
+
+dir_config "dlopen"
+
+create_makefile "ffi_yajl/ext/dlopen"

data/ext/ffi_yajl/ext/dlopen/yajl.sym

@@ -0,0 +1,18 @@
+_yajl_gen_alloc
+_yajl_gen_array_close
+_yajl_gen_array_open
+_yajl_gen_bool
+_yajl_gen_config
+_yajl_gen_free
+_yajl_gen_get_buf
+_yajl_gen_map_close
+_yajl_gen_map_open
+_yajl_gen_null
+_yajl_gen_number
+_yajl_gen_string
+_yajl_alloc
+_yajl_complete_parse
+_yajl_config
+_yajl_free
+_yajl_get_error
+_yajl_parse

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

@@ -0,0 +1,395 @@
+#include <ruby.h>
+#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... */
+
+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"));
+  VALUE sym_yajl_gen_indent_string = ID2SYM(rb_intern("yajl_gen_indent_string"));
+  yajl_gen yajl_gen;
+  const unsigned char *buf;
+  size_t len;
+  VALUE state;
+  VALUE ret;
+  VALUE indent_string;
+  VALUE rb_yajl_gen;
+
+  yajl_gen = yajl_gen_alloc(NULL);
+
+  if ( rb_hash_aref(yajl_gen_opts, sym_yajl_gen_beautify) == Qtrue ) {
+    yajl_gen_config(yajl_gen, yajl_gen_beautify, 1);
+  }
+  if ( rb_hash_aref(yajl_gen_opts, sym_yajl_gen_validate_utf8) == Qtrue ) {
+    yajl_gen_config(yajl_gen, yajl_gen_validate_utf8, 1);
+  }
+
+  indent_string = rb_hash_aref(yajl_gen_opts, sym_yajl_gen_indent_string);
+  if (indent_string != Qnil) {
+    yajl_gen_config(yajl_gen, yajl_gen_indent_string, RSTRING_PTR(indent_string));
+  } else {
+    yajl_gen_config(yajl_gen, yajl_gen_indent_string, " ");
+  }
+
+  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_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);
+
+  ret = rb_str_new2((char *)buf);
+
+  yajl_gen_free(yajl_gen);
+
+  return ret;
+}
+
+int rb_cHash_ffi_yajl_callback(VALUE key, VALUE val, VALUE 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"));
+
+  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;
+}
+
+#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;
+  struct yajl_gen_t *yajl_gen;
+  Data_Get_Struct(rb_yajl_gen, struct yajl_gen_t, yajl_gen);
+
+  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));
+  }
+
+  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;
+}
+
+/* encode hash open */
+VALUE gen_map_open(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_map_open(yajl_gen)) != yajl_gen_status_ok) {
+    rb_funcall(mEncoder2, rb_intern("raise_error_for_status"), 2, INT2FIX(status), rb_str_new2("{"));
+  }
+
+  return Qnil;
+}
+
+/* encode a hash close */
+VALUE gen_map_close(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_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;
+}
+
+/* encode an array open */
+VALUE gen_array_open(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_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;
+}
+
+/* encode an array close */
+VALUE gen_array_close(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_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;
+}
+
+/* encode a json null */
+VALUE gen_null(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_null(yajl_gen)) != yajl_gen_status_ok) {
+    rb_funcall(mEncoder2, rb_intern("raise_error_for_status"), 2, INT2FIX(status), rb_str_new2("null"));
+  }
+
+  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;
+}
+
+/* encode a false value */
+VALUE gen_false(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, 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);
+  }
+
+  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 {
+    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_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);
+
+  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 ( rb_hash_aref(state, rb_str_new2("processing_key")) == Qtrue ) {
+    gen_string(rb_yajl_gen, str);
+  } else {
+    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_cFloat_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 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");
+  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);
+  }
+
+  return Qnil;
+}
+
+void Init_encoder() {
+  mFFI_Yajl = rb_define_module("FFI_Yajl");
+  mEncoder2 = rb_define_class_under(mFFI_Yajl, "Encoder", rb_cObject);
+  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");
+  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);
+}