ffi-yajl 2.7.5-universal-mingw-ucrt

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

@@ -0,0 +1,86 @@
+# rubocop:disable Style/GlobalVars
+require "mkmf"
+require "rubygems"
+require "libyajl2"
+
+RbConfig::MAKEFILE_CONFIG["CC"] = ENV["CC"] if ENV["CC"]
+
+# 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 $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/
+  $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
+
+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"
+
+create_makefile "ffi_yajl/ext/encoder"

data/ext/ffi_yajl/ext/parser/extconf.rb

@@ -0,0 +1,86 @@
+# rubocop:disable Style/GlobalVars
+require "mkmf"
+require "rubygems"
+require "libyajl2"
+
+RbConfig::MAKEFILE_CONFIG["CC"] = ENV["CC"] if ENV["CC"]
+
+# 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 $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/
+  $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
+
+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 "parser"
+
+create_makefile "ffi_yajl/ext/parser"

data/ext/ffi_yajl/ext/parser/parser.c

@@ -0,0 +1,240 @@
+#include <ruby.h>
+#include <yajl/yajl_parse.h>
+
+#ifdef HAVE_RUBY_ENCODING_H
+#include <ruby/encoding.h>
+static rb_encoding *utf8Encoding;
+#endif
+
+static VALUE mFFI_Yajl, mExt, mParser, cParseError;
+
+typedef struct {
+  VALUE self;
+  int symbolizeKeys;
+  int uniqueKeyChecking;
+} CTX;
+
+void set_value(CTX *ctx, VALUE val) {
+  VALUE stack = rb_ivar_get(ctx->self, rb_intern("stack"));
+  VALUE key = rb_ivar_get(ctx->self, rb_intern("key"));
+  long len = RARRAY_LEN(stack);
+  VALUE last = rb_ary_entry(stack, len-1);
+  switch (TYPE(last)) {
+    case T_ARRAY:
+      rb_ary_push(last, val);
+      break;
+    case T_HASH:
+      if ( ctx->uniqueKeyChecking ) {
+        ID sym_has_key = rb_intern("has_key?");
+        if ( rb_funcall(last, sym_has_key, 1, key) == Qtrue ) {
+          rb_raise(cParseError, "repeated key: %s", RSTRING_PTR(key));
+        }
+      }
+      rb_hash_aset(last, key, val);
+      break;
+    default:
+      rb_ary_push(stack, val);
+      break;
+  }
+}
+
+void set_key(CTX *ctx, VALUE key) {
+  rb_ivar_set(ctx->self, rb_intern("key"), key);
+}
+
+void start_object(CTX *ctx, VALUE obj) {
+  VALUE key_stack = rb_ivar_get(ctx->self, rb_intern("key_stack"));
+  VALUE key       = rb_ivar_get(ctx->self, rb_intern("key"));
+  VALUE stack     = rb_ivar_get(ctx->self, rb_intern("stack"));
+
+  rb_ary_push(key_stack, key);
+  rb_ary_push(stack, obj);
+}
+
+void end_object(CTX *ctx) {
+  VALUE key_stack = rb_ivar_get(ctx->self, rb_intern("key_stack"));
+  VALUE stack = rb_ivar_get(ctx->self, rb_intern("stack"));
+  rb_ivar_set(ctx->self, rb_intern("key"), rb_ary_pop(key_stack));
+  if ( RARRAY_LEN(stack) > 1 ) {
+    set_value(ctx, rb_ary_pop(stack));
+  }
+}
+
+int null_callback(void *ctx) {
+  set_value(ctx, Qnil);
+  return 1;
+}
+
+int boolean_callback(void *ctx, int boolean) {
+  set_value(ctx, boolean ? Qtrue : Qfalse);
+  return 1;
+}
+
+int integer_callback(void *ctx, long long intVal) {
+  set_value(ctx, LONG2NUM(intVal));
+  return 1;
+}
+
+int double_callback(void *ctx, double doubleVal) {
+  set_value(ctx, rb_float_new(doubleVal));
+  return 1;
+}
+
+int number_callback(void *ctx, const char *numberVal, size_t numberLen) {
+  char *buf = (char *)malloc(numberLen+1);
+  buf[numberLen] = 0;
+  memcpy(buf, numberVal, numberLen);
+  if (memchr(buf, '.', numberLen) ||
+    memchr(buf, 'e', numberLen) ||
+    memchr(buf, 'E', numberLen)) {
+    set_value(ctx, rb_float_new(strtod(buf, NULL)));
+  } else {
+    set_value(ctx, rb_cstr2inum(buf, 10));
+  }
+  free(buf);
+  return 1;
+}
+
+int string_callback(void *ctx, const unsigned char *stringVal, size_t stringLen) {
+  VALUE str = rb_str_new((const char *)stringVal, stringLen);
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_encoding *default_internal_enc = rb_default_internal_encoding();
+  rb_enc_associate(str, utf8Encoding);
+  if (default_internal_enc) {
+    str = rb_str_export_to_enc(str, default_internal_enc);
+  }
+#endif
+  set_value(ctx,str);
+  return 1;
+}
+
+int start_map_callback(void *ctx) {
+  start_object(ctx,rb_hash_new());
+  return 1;
+}
+
+int map_key_callback(void *ctx, const unsigned char *stringVal, size_t stringLen) {
+  VALUE key;
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_encoding *default_internal_enc;
+#endif
+
+  if ( ((CTX *)ctx)->symbolizeKeys ) {
+#ifdef HAVE_RUBY_ENCODING_H
+    ID id = rb_intern3((const char *)stringVal, stringLen, utf8Encoding);
+    key = ID2SYM(id);
+#else
+    VALUE str = rb_str_new((const char *)stringVal, stringLen);
+    key = rb_str_intern(str);
+#endif
+  } else {
+    key = rb_str_new((const char *)stringVal, stringLen);
+#ifdef HAVE_RUBY_ENCODING_H
+    default_internal_enc = rb_default_internal_encoding();
+    rb_enc_associate(key, utf8Encoding);
+    if (default_internal_enc) {
+      key = rb_str_export_to_enc(key, default_internal_enc);
+    }
+#endif
+  }
+  set_key(ctx, key);
+  return 1;
+}
+
+int end_map_callback(void *ctx) {
+  end_object(ctx);
+  return 1;
+}
+
+int start_array_callback(void *ctx) {
+  start_object(ctx,rb_ary_new());
+  return 1;
+}
+
+int end_array_callback(void *ctx) {
+  end_object(ctx);
+  return 1;
+}
+
+static yajl_callbacks callbacks = {
+  null_callback,
+  boolean_callback,
+  integer_callback,
+  double_callback,
+  number_callback,
+  string_callback,
+  start_map_callback,
+  map_key_callback,
+  end_map_callback,
+  start_array_callback,
+  end_array_callback,
+};
+
+int get_opts_key(VALUE self, const char *key) {
+  VALUE opts = rb_iv_get(self, "@opts");
+  if (TYPE(opts) != T_HASH) {
+    rb_raise(rb_eTypeError, "opts is not a valid hash");
+  }
+  return rb_hash_aref(opts, ID2SYM(rb_intern(key))) == Qtrue;
+}
+
+static VALUE mParser_do_yajl_parse(VALUE self, VALUE str, VALUE yajl_opts) {
+  yajl_handle hand;
+  yajl_status stat;
+  unsigned char *err;
+  volatile CTX ctx;
+
+  rb_ivar_set(self, rb_intern("key"), Qnil);
+  rb_ivar_set(self, rb_intern("stack"), rb_ary_new());
+  rb_ivar_set(self, rb_intern("key_stack"), rb_ary_new());
+
+  ctx.self = self;
+  ctx.symbolizeKeys = get_opts_key(self, "symbolize_keys");
+  ctx.uniqueKeyChecking = get_opts_key(self, "unique_key_checking");
+
+  hand = yajl_alloc(&callbacks, NULL, (void *)&ctx);
+
+  if (rb_hash_aref(yajl_opts, ID2SYM(rb_intern("yajl_allow_comments"))) == Qtrue) {
+    yajl_config(hand, yajl_allow_comments, 1);
+  }
+  if (rb_hash_aref(yajl_opts, ID2SYM(rb_intern("yajl_dont_validate_strings"))) == Qtrue) {
+    yajl_config(hand, yajl_dont_validate_strings, 1);
+  }
+  if (rb_hash_aref(yajl_opts, ID2SYM(rb_intern("yajl_allow_trailing_garbage"))) == Qtrue) {
+    yajl_config(hand, yajl_allow_trailing_garbage, 1);
+  }
+  if (rb_hash_aref(yajl_opts, ID2SYM(rb_intern("yajl_allow_multiple_values"))) == Qtrue) {
+    yajl_config(hand, yajl_allow_multiple_values, 1);
+  }
+  if (rb_hash_aref(yajl_opts, ID2SYM(rb_intern("yajl_allow_partial_values"))) == Qtrue) {
+    yajl_config(hand, yajl_allow_partial_values, 1);
+  }
+
+  if ((stat = yajl_parse(hand, (unsigned char *)RSTRING_PTR(str), RSTRING_LEN(str))) != yajl_status_ok) {
+    err = yajl_get_error(hand, 1, (unsigned char *)RSTRING_PTR(str), RSTRING_LEN(str));
+    goto raise;
+  }
+  if ((stat = yajl_complete_parse(hand)) != yajl_status_ok) {
+    err = yajl_get_error(hand, 1, (unsigned char *)RSTRING_PTR(str), RSTRING_LEN(str));
+    goto raise;
+  }
+  yajl_free(hand);
+  return rb_ary_pop(rb_ivar_get(self, rb_intern("stack")));
+
+raise:
+  if (hand) {
+    yajl_free(hand);
+  }
+  rb_raise(cParseError, "%s", err);
+}
+
+void Init_parser() {
+  mFFI_Yajl = rb_define_module("FFI_Yajl");
+  cParseError = rb_define_class_under(mFFI_Yajl, "ParseError", rb_eStandardError);
+  mExt = rb_define_module_under(mFFI_Yajl, "Ext");
+  mParser = rb_define_module_under(mExt, "Parser");
+  rb_define_method(mParser, "do_yajl_parse", mParser_do_yajl_parse, 2);
+#ifdef HAVE_RUBY_ENCODING_H
+  utf8Encoding = rb_utf8_encoding();
+#endif
+}

data/lib/ffi_yajl/benchmark/MIT-LICENSE

@@ -0,0 +1,20 @@
+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/lib/ffi_yajl/benchmark/encode.rb

@@ -0,0 +1,82 @@
+# Portions Originally Copyright (c) 2008-2011 Brian Lopez - http://github.com/brianmario
+# See MIT-LICENSE
+
+require "rubygems" unless defined?(Gem)
+require "benchmark" unless defined?(Benchmark)
+require "stringio" unless defined?(StringIO)
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE !~ /jruby/
+  begin
+    require "yajl"
+  rescue LoadError
+    puts "INFO: yajl-ruby not installed"
+  end
+else
+  puts "INFO: skipping yajl-ruby on jruby"
+end
+require_relative "../../ffi_yajl"
+begin
+  require "json" unless defined?(JSON)
+rescue LoadError
+  puts "INFO: json gem not installed"
+end
+begin
+  require "oj"
+rescue LoadError
+  puts "INFO: oj gem not installed"
+end
+
+module FFI_Yajl
+  class Benchmark
+    class Encode
+      def run
+        # filename = ARGV[0] || 'benchmark/subjects/ohai.json'
+        filename = File.expand_path(File.join(File.dirname(__FILE__), "subjects", "ohai.json"))
+        hash = File.open(filename, "rb") { |f| FFI_Yajl::Parser.parse(f.read) }
+
+        times = ARGV[1] ? ARGV[1].to_i : 1000
+        puts "Starting benchmark encoding #{filename} #{times} times\n\n"
+        ::Benchmark.bmbm do |x|
+          x.report("FFI_Yajl::Encoder.encode (to a String)") do
+            times.times { FFI_Yajl::Encoder.encode(hash) }
+          end
+
+          ffi_string_encoder = FFI_Yajl::Encoder.new
+          x.report("FFI_Yajl::Encoder#encode (to a String)") do
+            times.times { ffi_string_encoder.encode(hash) }
+          end
+
+          if defined?(Oj)
+            x.report("Oj.dump (to a String)") do
+              times.times { Oj.dump(hash) }
+            end
+          end
+
+          if defined?(Yajl::Encoder)
+            x.report("Yajl::Encoder.encode (to a String)") do
+              times.times { Yajl::Encoder.encode(hash) }
+            end
+
+            io_encoder = Yajl::Encoder.new
+            x.report("Yajl::Encoder#encode (to an IO)") do
+              times.times { io_encoder.encode(hash, StringIO.new) }
+            end
+
+            string_encoder = Yajl::Encoder.new
+            x.report("Yajl::Encoder#encode (to a String)") do
+              times.times { string_encoder.encode(hash) }
+            end
+          end
+
+          if defined?(JSON)
+            x.report("JSON.generate") do
+              times.times { JSON.generate(hash) }
+            end
+            x.report("JSON.fast_generate") do
+              times.times { JSON.fast_generate(hash) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ffi_yajl/benchmark/encode_json_and_marshal.rb

@@ -0,0 +1,42 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + "/..")
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
+
+require "rubygems" unless defined?(Gem)
+require "benchmark" unless defined?(Benchmark)
+require "yajl"
+require "stringio" unless defined?(StringIO)
+begin
+  require "json" unless defined?(JSON)
+rescue LoadError
+end
+
+times = ARGV[0] ? ARGV[0].to_i : 1000
+filename = "benchmark/subjects/ohai.json"
+json = File.new(filename, "r")
+hash = Yajl::Parser.new.parse(json)
+json.close
+
+puts "Starting benchmark encoding #{filename} #{times} times\n\n"
+Benchmark.bmbm do |x|
+  encoder = Yajl::Encoder.new
+  x.report do
+    puts "Yajl::Encoder#encode"
+    times.times do
+      encoder.encode(hash, StringIO.new)
+    end
+  end
+  if defined?(JSON)
+    x.report do
+      puts "JSON's #to_json"
+      times.times do
+        JSON.generate(hash)
+      end
+    end
+  end
+  x.report do
+    puts "Marshal.dump"
+    times.times do
+      Marshal.dump(hash)
+    end
+  end
+end

data/lib/ffi_yajl/benchmark/encode_json_and_yaml.rb

@@ -0,0 +1,47 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + "/..")
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
+
+require "rubygems" unless defined?(Gem)
+require "benchmark" unless defined?(Benchmark)
+require "yajl"
+begin
+  require "json" unless defined?(JSON)
+rescue LoadError
+end
+require "yaml" unless defined?(YAML)
+
+# JSON Section
+filename = "benchmark/subjects/ohai.json"
+json = File.new(filename, "r")
+hash = Yajl::Parser.new.parse(json)
+json.close
+
+times = ARGV[0] ? ARGV[0].to_i : 1000
+puts "Starting benchmark encoding #{filename} into JSON #{times} times\n\n"
+Benchmark.bmbm do |x|
+  encoder = Yajl::Encoder.new
+  x.report do
+    puts "Yajl::Encoder#encode"
+    times.times { encoder.encode(hash, StringIO.new) }
+  end
+  if defined?(JSON)
+    x.report do
+      puts "JSON's #to_json"
+      times.times { JSON.generate(hash) }
+    end
+  end
+end
+
+# YAML Section
+filename = "benchmark/subjects/ohai.yml"
+yml = File.new(filename, "r")
+data = YAML.load_stream(yml)
+yml.close
+
+puts "Starting benchmark encoding #{filename} into YAML #{times} times\n\n"
+Benchmark.bmbm do |x|
+  x.report do
+    puts "YAML.dump"
+    times.times { YAML.dump(data, StringIO.new) }
+  end
+end

data/lib/ffi_yajl/benchmark/encode_profile.rb

@@ -0,0 +1,34 @@
+# Portions Originally Copyright (c) 2008-2011 Brian Lopez - http://github.com/brianmario
+# See MIT-LICENSE
+
+require "rubygems" unless defined?(Gem)
+require_relative "../../ffi_yajl"
+begin
+  require "perftools"
+rescue LoadError
+  puts "INFO: perftools.rb gem not installed"
+end
+
+ENV["CPUPROFILE_FREQUENCY"] = "4000"
+
+module FFI_Yajl
+  class Benchmark
+    class EncodeProfile
+      def run
+        return unless defined?(PerfTools)
+
+        filename = File.expand_path(File.join(File.dirname(__FILE__), "subjects", "ohai.json"))
+        hash = File.open(filename, "rb") { |f| FFI_Yajl::Parser.parse(f.read) }
+
+        times = 1000
+        puts "Starting profiling encoding #{filename} #{times} times\n\n"
+
+        ffi_string_encoder = FFI_Yajl::Encoder.new
+        PerfTools::CpuProfiler.start("/tmp/ffi_yajl_encode_profile.out") do
+          times.times { ffi_string_encoder.encode(hash) }
+        end
+        system("pprof.rb --text /tmp/ffi_yajl_encode_profile.out")
+      end
+    end
+  end
+end

data/lib/ffi_yajl/benchmark/http.rb

@@ -0,0 +1,28 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + "/..")
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
+
+require "rubygems" unless defined?(Gem)
+require "benchmark" unless defined?(Benchmark)
+require "yajl/http_stream"
+require "yajl/gzip"
+require "yajl/deflate"
+require "yajl/bzip2" unless defined?(Bzip2)
+require "json" unless defined?(JSON)
+require "uri" unless defined?(URI)
+require "net/http" unless defined?(Net::HTTP)
+
+uri = URI.parse("http://search.twitter.com/search.json?q=github")
+# uri = URI.parse('http://localhost/yajl-ruby.git/benchmark/subjects/contacts.json')
+
+times = ARGV[0] ? ARGV[0].to_i : 1
+puts "Starting benchmark parsing #{uri} #{times} times\n\n"
+Benchmark.bmbm do |x|
+  x.report do
+    puts "Yajl::HttpStream.get"
+    times.times { Yajl::HttpStream.get(uri) }
+  end
+  x.report do
+    puts "JSON.parser"
+    times.times { JSON.parse(Net::HTTP.get_response(uri).body, max_nesting: false) }
+  end
+end