fjson 0.0.1 → 0.0.2

data/ext/extensions/hash_ext/hash_ext.h

@@ -0,0 +1,13 @@
+#include "ruby.h"
+#include <string.h>
+#include "../../state_ext/state_ext.h"
+#include "../../state_ext/state_ext.c"
+
+static VALUE json_shift(VALUE, VALUE, VALUE, VALUE);
+static VALUE generate_key_value_json(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
+static VALUE process_internal_json(VALUE, VALUE, VALUE, VALUE, VALUE);
+static VALUE json_transform(VALUE, VALUE, VALUE);
+static VALUE json_check_circular_and_transform_call(VALUE);
+static VALUE json_check_circular_and_transform_ensure(VALUE);
+static VALUE json_check_circular_and_transform(VALUE, VALUE, VALUE);
+static VALUE to_json(int, VALUE*, VALUE);

data/ext/extensions/integer_ext/extconf.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'mkrf'
+
+dir = File.dirname(__FILE__)
+Mkrf::Generator.new('integer_ext', "#{dir}/*.c")

data/ext/extensions/integer_ext/integer_ext.c

@@ -0,0 +1,19 @@
+#include "integer_ext.h"
+
+static VALUE cInteger;
+
+void Init_integer_ext() {
+  cInteger = rb_const_get(rb_cObject, rb_intern("Integer"));
+  rb_define_method(cInteger, "to_json", (VALUE(*)(ANYARGS)) &to_json, -1);
+}
+  
+/**
+ * Returns a JSON string representation for this Integer number.
+ */
+static VALUE to_json(argc, argv, self)
+  int argc;
+  VALUE *argv;
+  VALUE self;
+{
+  return rb_funcall(self, rb_intern("to_s"), 0);
+}

data/ext/extensions/integer_ext/integer_ext.h

@@ -0,0 +1,4 @@
+#include "ruby.h"
+#include <string.h>
+
+static VALUE to_json(int, VALUE*, VALUE);

data/ext/extensions/nil_class_ext/extconf.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'mkrf'
+
+dir = File.dirname(__FILE__)
+Mkrf::Generator.new('nil_class_ext', "#{dir}/*.c")

data/ext/extensions/nil_class_ext/nil_class_ext.c

@@ -0,0 +1,19 @@
+#include "nil_class_ext.h"
+
+static VALUE cNilClass;
+
+void Init_nil_class_ext() {
+  cNilClass = rb_const_get(rb_cObject, rb_intern("NilClass"));
+  rb_define_method(cNilClass, "to_json", (VALUE(*)(ANYARGS)) &to_json, -1);
+}
+
+/**
+ * Returns a JSON string for nil: 'null'.
+ */
+static VALUE to_json(argc, argv, self)
+  int argc;
+  VALUE *argv;
+  VALUE self;
+{
+  return rb_str_new2("null");
+}

data/ext/extensions/nil_class_ext/nil_class_ext.h

@@ -0,0 +1,4 @@
+#include "ruby.h"
+#include <string.h>
+
+static VALUE to_json(int, VALUE*, VALUE);

data/ext/extensions/object_ext/extconf.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'mkrf'
+
+dir = File.dirname(__FILE__)
+Mkrf::Generator.new('object_ext', "#{dir}/*.c")

data/ext/extensions/object_ext/object_ext.c

@@ -0,0 +1,21 @@
+#include "object_ext.h"
+
+void Init_object_ext() {
+  rb_define_method(rb_cObject, "to_json", (VALUE(*)(ANYARGS)) &to_json, -1);
+}
+
+/**
+ * Converts this object to a string (calling #to_s), converts
+ * it to a JSON string, and returns the result. This is a fallback, if no
+ * special method #to_json was defined for some object.
+ * _state_ is a JSON::State object, that can also be used
+ * to configure the produced JSON string output further.
+ */
+static VALUE to_json(argc, argv, self)
+  int argc;
+  VALUE *argv;
+  VALUE self;
+{
+  VALUE self_string = rb_funcall(self, rb_intern("to_s"), 0);
+  return rb_funcall(self_string, rb_intern("to_json"), 0);
+}

data/ext/extensions/object_ext/object_ext.h

@@ -0,0 +1,4 @@
+#include "ruby.h"
+#include <string.h>
+
+static VALUE to_json(int, VALUE*, VALUE);

data/ext/extensions/string_ext/extconf.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'mkrf'
+
+dir = File.dirname(__FILE__)
+Mkrf::Generator.new('string_ext', "#{dir}/*.c")

data/ext/extensions/string_ext/string_ext.c

@@ -0,0 +1,27 @@
+#include "string_ext.h"
+
+static VALUE cString;
+
+void Init_string_ext() {
+  cString = rb_const_get(rb_cObject, rb_intern("String"));
+  rb_define_method(cString, "to_json", (VALUE(*)(ANYARGS)) &to_json, -1);
+}
+
+/**
+ * This string should be encoded with UTF-8 (if JSON unicode support is
+ * enabled). A call to this method returns a JSON string
+ * encoded with UTF16 big endian characters as \u????. If
+ * JSON.support_unicode? is false only control characters are encoded this
+ * way, all 8-bit bytes are just passed through.
+ */
+static VALUE to_json(argc, argv, self)
+  int argc;
+  VALUE *argv;
+  VALUE self;
+{
+  VALUE mJSON = rb_const_get(rb_cObject, rb_intern("JSON"));
+  VALUE json = rb_str_new2("\"");
+  rb_str_append(json, rb_funcall(mJSON, rb_intern("utf8_to_json"), 1, self));
+  rb_str_append(json, rb_str_new2("\""));
+  return json;
+}

data/ext/extensions/string_ext/string_ext.h

@@ -0,0 +1,4 @@
+#include "ruby.h"
+#include <string.h>
+
+static VALUE to_json(int, VALUE*, VALUE);

data/ext/extensions/true_class_ext/extconf.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'mkrf'
+
+dir = File.dirname(__FILE__)
+Mkrf::Generator.new('true_class_ext', "#{dir}/*.c")

data/ext/extensions/true_class_ext/true_class_ext.c

@@ -0,0 +1,19 @@
+#include "true_class_ext.h"
+
+static VALUE cTrueClass;
+
+void Init_true_class_ext() {
+  cTrueClass = rb_const_get(rb_cObject, rb_intern("TrueClass"));
+  rb_define_method(cTrueClass, "to_json", (VALUE(*)(ANYARGS)) &to_json, -1);
+}
+
+/**
+ * Returns a JSON string for true: 'true'.
+ */
+static VALUE to_json(argc, argv, self)
+  int argc;
+  VALUE *argv;
+  VALUE self;
+{
+  return rb_funcall(self, rb_intern("to_s"), 0);
+}

data/ext/extensions/true_class_ext/true_class_ext.h

@@ -0,0 +1,4 @@
+#include "ruby.h"
+#include <string.h>
+
+static VALUE to_json(int, VALUE*, VALUE);

data/ext/json_ext/extconf.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'mkrf'
+
+dir = File.dirname(__FILE__)
+Mkrf::Generator.new('json_ext', "#{dir}/*.c")

data/ext/json_ext/json_ext.c

@@ -0,0 +1,180 @@
+#include "json_ext.h"
+
+static VALUE mJSON;
+static VALUE mJSONModuleMethods;
+static VALUE cStandardError;
+static VALUE cJSONError;
+static VALUE cParserError;
+static VALUE cUnparserError;
+static VALUE cCircularDatastructure;
+
+void Init_json_ext() {
+  mJSON = rb_define_module("JSON");
+  mJSONModuleMethods = rb_define_module_under(mJSON, "ModuleMethods");
+
+  _begin_setup_iconv();
+
+  rb_define_method(mJSONModuleMethods, "utf8_to_json", utf8_to_json, 1);
+  rb_define_method(mJSONModuleMethods, "utf8_to_utf16", utf8_to_utf16, 1);
+
+  cStandardError = rb_const_get(rb_cObject,rb_intern("StandardError"));
+  /**
+   * The base exception for JSON errors.
+   */
+  cJSONError = rb_define_class_under(mJSON, "JSONError", cStandardError);
+
+  /**
+   * This exception is raise, if a parser error occurs.
+   */
+  cParserError = rb_define_class_under(mJSON, "ParserError", cJSONError);
+
+  /**
+   * This exception is raise, if a unparser error occurs.
+   */
+  cUnparserError = rb_define_class_under(mJSON, "UnparserError", cJSONError);
+
+  /**
+   * If a circular data structure is encountered while unparsing this exception is raised.
+   */
+  cCircularDatastructure = rb_define_class_under(mJSON, "CircularDatastructure", cUnparserError);
+}
+
+/**
+ * Convert _string_ from UTF8 encoding to UTF16 (big endian) encoding and return it.
+ */
+static VALUE utf8_to_utf16(self, string)
+  VALUE self, string;
+{
+  VALUE mUTF8toUTF16 = rb_const_get(mJSON, rb_intern("UTF8toUTF16"));
+  VALUE packed_bytes = rb_funcall(mUTF8toUTF16, rb_intern("iconv"), 1, string);
+  VALUE unpacked_bytes = rb_funcall(packed_bytes, rb_intern("unpack"), 1, rb_str_new2("H*"));
+  return rb_ary_entry(unpacked_bytes, 0);
+}
+
+static VALUE utf8_to_json(self, input)
+  VALUE self, input;
+{
+  VALUE length = rb_funcall(input, rb_intern("length"), 0);
+  long c_length = NUM2LONG(length);
+
+  VALUE result = rb_str_new2("");
+
+  int c_increment_length;
+  size_t i = 0;
+  while(i < c_length) {
+    c_increment_length = _convert_utf8_char(input, i, result);
+    i += c_increment_length;
+  }
+
+  return result;
+}
+
+/** private **/
+
+static void _begin_setup_iconv() {
+  rb_require("iconv");
+  VALUE mIconv = rb_const_get(rb_cObject, rb_intern("Iconv"));
+
+  VALUE mUTF8toUTF16 = rb_funcall(mIconv, rb_intern("new"), 2, rb_str_new2("utf-8"), rb_str_new2("utf-16be"));
+  rb_const_set(
+    mJSON,
+    rb_intern("UTF16toUTF8"),
+    mUTF8toUTF16
+  );
+
+  VALUE mUTF16toUTF8 = rb_funcall(mIconv, rb_intern("new"), 2, rb_str_new2("utf-16be"), rb_str_new2("utf-8"));
+  rb_const_set(
+    mJSON,
+    rb_intern("UTF8toUTF16"),
+    mUTF16toUTF8
+  );
+
+  rb_funcall(mUTF16toUTF8, rb_intern("iconv"), 1, rb_str_new2("no bom"));
+}
+
+static long _convert_utf8_char(input, i, result)
+  VALUE input;
+  long i;
+  VALUE result;
+{
+  long c_increment_length = 1;
+  if (i < 0 || RSTRING(input)->len <= i) {
+    return Qnil;
+  }
+  char c_current = (RSTRING(input)->ptr[i] & 0xff);
+
+  if(c_current == 0x08) {
+    rb_str_cat2(result, "\\b");
+  }
+  else if(c_current == 0x09) {
+    rb_str_cat2(result, "\\t");
+  }
+  else if(c_current == 0x0A) {
+    rb_str_cat2(result, "\\n");
+  }
+  else if(c_current == 0x0C) {
+    rb_str_cat2(result, "\\f");
+  }
+  else if(c_current == 0x0D) {
+    rb_str_cat2(result, "\\r");
+  }
+  else if(c_current == '"') {
+    rb_str_cat2(result, "\\\"");
+  }
+  else if(c_current == '\\') {
+    rb_str_cat2(result, "\\\\");
+  }
+  else if(0x00 <= c_current && c_current <= 0x1f) {
+    VALUE format_string =  rb_str_new2("\\u%04x");
+    rb_str_append(result, rb_funcall(format_string, rb_intern("%"), 1, LONG2NUM(c_current)));
+  }
+  else if(0x20 <= c_current && c_current <= 0x7f) {
+    rb_str_concat(result, LONG2NUM(c_current));
+  }
+  else if(
+    !(
+      rb_funcall(mJSON, rb_intern("support_unicode?"), 0) == Qtrue &&
+      rb_equal(rb_gv_get("KCODE"), rb_str_new2("UTF8"))
+    )) {
+    VALUE current = rb_funcall(input, rb_intern("[]"), 1, LONG2NUM(i));
+    rb_str_concat(result, current);
+  }
+//  else if((c_current & 0xe0) == 0xc0) {
+//    c_increment_length = 2;
+//    _convert_utf_8_string_part(result, input, i, c_increment_length);
+//  }
+//  else if((c_current & 0xf0) == 0xe0) {
+//    c_increment_length = 3;
+//    _convert_utf_8_string_part(result, input, i, c_increment_length);
+//  }
+//  else if((c_current & 0xf8) == 0xf0) {
+//    c_increment_length = 4;
+//    _convert_utf_8_string_part(result, input, i, c_increment_length);
+//  }
+//  // TODO: See if these next two steps are valid unicode.
+//  else if((c_current & 0xf8) == 0xf8) {
+//    c_increment_length = 5;
+//    _convert_utf_8_string_part(result, input, i, c_increment_length);
+//  }
+//  else if((c_current & 0xf8) == 0xfc) {
+//    c_increment_length = 6;
+//    _convert_utf_8_string_part(result, input, i, c_increment_length);
+//  }
+  else {
+    VALUE current = rb_funcall(input, rb_intern("[]"), 1, LONG2NUM(i));
+    rb_str_concat(result, current);
+  }
+
+  return c_increment_length;
+}
+
+static VALUE _convert_utf_8_string_part(result, input, i, length)
+  VALUE result, input;
+  long i, length;
+{
+  rb_str_cat2(result, "\\u");
+  VALUE utf_header = rb_funcall(input, rb_intern("[]"), 2, LONG2NUM(i), LONG2NUM(length));
+  rb_str_append(result, utf8_to_utf16(mJSON, utf_header));
+
+  return Qnil;
+}

data/ext/json_ext/json_ext.h

@@ -0,0 +1,9 @@
+#include "ruby.h"
+#include <string.h>
+
+static VALUE utf8_to_utf16(VALUE, VALUE);
+static VALUE _convert_utf_8_string_part(VALUE, VALUE, long, long);
+static long _convert_utf8_char(VALUE, long, VALUE);
+static VALUE utf8_to_json(VALUE, VALUE);
+static void _begin_setup_iconv();
+void Init_json_ext();

data/ext/state_ext/extconf.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'mkrf'
+
+dir = File.dirname(__FILE__)
+Mkrf::Generator.new('state_ext', "#{dir}/*.c")

data/ext/state_ext/state_ext.c

@@ -0,0 +1,169 @@
+#include "state_ext.h"
+
+static VALUE cState;
+static VALUE mClassMethods;
+static VALUE mJSON;
+
+/**
+ * This class is used to create State instances, that are used to hold data
+ * while unparsing a Ruby data structure into a JSON string.
+ */
+void Init_state_ext() {
+  mJSON = rb_const_get(rb_cObject, rb_intern("JSON"));
+  cState = rb_define_class_under(mJSON, "State", rb_cObject);
+  mClassMethods = rb_define_module_under(cState, "ClassMethods");
+
+  rb_define_method(mClassMethods, "from_state", from_state, 1);
+  rb_extend_object(cState, mClassMethods);
+
+  rb_define_method(cState, "initialize", initialize, -1);
+  rb_define_method(cState, "seen?", seen, 1);
+  rb_define_method(cState, "remember", remember, 1);
+  rb_define_method(cState, "forget", forget, 1);
+
+  /*
+   * This string is used to indent levels in the JSON string.
+   */
+   rb_define_method(cState, "indent", get_indent, 0);
+   rb_define_method(cState, "indent=", set_indent, 1);
+
+  /*
+   * This string is used to include a space between the tokens in a JSON string.
+   */
+  rb_define_attr(cState, "space", 1, 1);
+
+  /*
+   * This string is put at the end of a line that holds a JSON object (or Hash).
+   */
+  rb_define_attr(cState, "object_nl", 1, 1);
+
+  /*
+   * This string is put at the end of a line that holds a JSON array.
+   */
+  rb_define_attr(cState, "array_nl", 1, 1);
+}
+
+void rb_json_state_indent(state, json, depth)
+  VALUE state, json;
+  long depth;
+{
+  VALUE indent = rb_funcall(state, rb_intern("indent"), 0);
+  char* c_indent = StringValueCStr(indent);
+  // Incrementing the depth
+  char* full_indent;
+  long i;
+  for(i=0; i<depth; i++) {
+    strcat(full_indent, c_indent);
+  }
+  rb_str_cat2(json, full_indent);
+}
+
+/** Static **/
+
+/**
+ * Instantiates a new State object, configured by _opts_.
+ */
+static VALUE initialize(argc, argv, self)
+  int argc;
+  VALUE *argv;
+  VALUE self;
+{
+  VALUE opts;
+  rb_scan_args(argc, argv, "01", &opts);
+
+  VALUE indent, space, object_nl, array_nl;
+  if(opts == Qnil) {
+    indent = rb_str_new2("");
+    space = rb_str_new2("");
+    object_nl = rb_str_new2("");
+    array_nl = rb_str_new2("");
+  }
+  else {
+    indent = hash_value_or_empty_string_default(opts, "indent");
+    space = hash_value_or_empty_string_default(opts, "space");
+    object_nl = hash_value_or_empty_string_default(opts, "object_nl");
+    array_nl = hash_value_or_empty_string_default(opts, "array_nl");
+  }
+
+  rb_ivar_set(self, rb_intern("@indent"), indent);
+  rb_ivar_set(self, rb_intern("@space"), space);
+  rb_ivar_set(self, rb_intern("@object_nl"), object_nl);
+  rb_ivar_set(self, rb_intern("@array_nl"), array_nl);
+  rb_ivar_set(self, rb_intern("@seen"), rb_hash_new());
+}
+
+static VALUE get_indent(self)
+  VALUE self;
+{
+  return rb_ivar_get(self, rb_intern("@indent"));
+}
+
+static VALUE set_indent(self, indent)
+  VALUE self, indent;
+{
+  rb_ivar_set(self, rb_intern("@indent"), indent);
+}
+
+/**
+ * Creates a State object from _opts_, which ought to be Hash to create a
+ * new State instance configured by opts, something else to create an
+ * unconfigured instance. If _opts_ is a State object, it is just returned.
+ */
+static VALUE from_state(self, opts)
+  VALUE self, opts;
+{
+  if(rb_obj_is_kind_of(opts, cState)) {
+    return opts;
+  }
+  else if(rb_obj_is_kind_of(opts, rb_cHash)) {
+    return rb_funcall(self, rb_intern("new"), 1, opts);
+  }
+  else {
+    return rb_funcall(self, rb_intern("new"), 0);
+  }
+}
+
+/**
+ * Returns _true_, if _object_ was already seen during this Unparsing run.
+ */
+static VALUE seen(self, object)
+  VALUE self, object;
+{
+  VALUE seen_ivar = rb_ivar_get(self, rb_intern("@seen"));
+  return rb_hash_aref(seen_ivar, rb_obj_id(object));
+}
+
+/**
+ * Remember _object_, to find out if it was already encountered (to find out
+ * if a cyclic data structure is unparsed).
+ */
+static VALUE remember(self, object)
+  VALUE self, object;
+{
+  VALUE seen_ivar = rb_ivar_get(self, rb_intern("@seen"));
+  rb_hash_aset(seen_ivar, rb_obj_id(object), Qtrue);
+}
+
+/**
+ * Forget _object_ for this Unparsing run.
+ */
+static VALUE forget(self, object)
+  VALUE self, object;
+{
+  VALUE seen_ivar = rb_ivar_get(self, rb_intern("@seen"));
+  rb_hash_delete(seen_ivar, rb_obj_id(object));
+}
+
+/** private **/
+static VALUE hash_value_or_empty_string_default(hash, cKey)
+  VALUE hash;
+  const char* cKey;
+{
+  VALUE hash_value = rb_hash_aref(hash, ID2SYM(rb_intern(cKey)));
+  if(hash_value == Qnil) {
+    return rb_str_new2("");
+  }
+  else {
+    return hash_value;
+  }
+}