rsonal 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ea30b1cb2c0fbe10886a4db0e627107ac94b7fd4
+  data.tar.gz: 1b9a727919135d747cf46fd5af6cc8bc1d71879f
+SHA512:
+  metadata.gz: b851890747ecaf86993928735997b49a16a5bc3fd29977be9d3104da04f58f0d6c29e1c2d87541ec0ecdcaefbdf5255e09659429ab1d8d8a030a514e92181164
+  data.tar.gz: ff7833d9c3c96960f951f37cdd760df6902678c6ffde0c5b3d1a03d15d6bede3af04087fa744c775b99963e81b1629e082f38a40eca4be50544753475f14afa3

data/ext/rsonal/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+extension_name = 'rsonal'
+dir_config(extension_name)
+abort "missing malloc()" unless have_func "malloc"
+abort "missing free()"   unless have_func "free"
+abort "missing ruby.h"   unless have_header "ruby.h"
+create_makefile("rsonal/rsonal")

data/ext/rsonal/rsonal.c

@@ -0,0 +1,236 @@
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <rsonal_string.h>
+
+VALUE Rsonal = Qnil;
+
+void Init_rsonal();
+VALUE rsonal_read_json(VALUE self, VALUE file);
+VALUE rsonal_write_json(VALUE self, VALUE input);
+void process_write_json_data(Rst* str, VALUE input);
+
+
+
+void Init_rsonal() {
+  Rsonal = rb_define_module("Rsonal");
+  rb_define_singleton_method(Rsonal, "write_json", rsonal_write_json, 1);
+}
+
+void
+process_write_json_fixnum(Rst* str, VALUE input)
+{
+  char conv[64];
+  long val = NUM2LONG(input);
+  snprintf(conv, 64, "%ld", val);
+  rst_cat_clen(str, conv);
+}
+
+// int
+// numdigits(double dbl)
+// {
+//   long count = 0;
+//   while(abs(dbl) >= 0.0000001)
+//   {
+//     dbl = dbl * 10;
+//     count = count + 1;
+//     num = num - (int)num;
+//   }
+// }
+
+void
+process_write_json_float(Rst* str, VALUE input)
+{
+  char conv[32];
+  double dbl = NUM2DBL(input);
+  snprintf(conv, 32, "%09e", dbl);
+  rst_cat_clen(str, conv);
+}
+
+void
+process_write_json_bignum(Rst* str, VALUE input)
+{
+  int i;
+  long len;
+  VALUE res;
+  if(FIXNUM_P(input))
+  {
+    process_write_json_fixnum(str, input);
+    return;
+  }
+  res = rb_big2str(input,10);
+  rst_cat_cstr(str, RSTRING_PTR(res), RSTRING_LEN(res));
+}
+
+int
+is_unicode_seq_start(const unsigned char c)
+{
+  return (c >= 0xC0 && c <= 0xFD);
+}
+
+unsigned short arr_numbytes[] = {0, 0x7E, 0x3E, 0x1E, 0x0E, 0x06};
+
+int
+utf_numbytes(const unsigned short inp)
+{
+  unsigned i;
+  for(i=1;i < 6;i++)
+  {
+    if((inp >> i) == arr_numbytes[i])
+      return 6-i;
+  }
+  return 0;
+}
+
+unsigned int
+offset_mask(int offset)
+{
+  return 0xFF >> (offset+1);
+}
+
+void
+process_write_json_utf8(Rst* str, VALUE input)
+{
+  int i, j, off;
+  unsigned long wchar;
+  char conv[8] = {0};
+  const unsigned char* ptr = (unsigned char*)RSTRING_PTR(input);
+  const int siz = RSTRING_LEN(input);
+
+  for(i=0;i < siz;i++)
+  {
+    if(!is_unicode_seq_start(ptr[i]))
+    {
+      rst_add_char(str, ptr[i]);
+      continue;
+    }
+    off = utf_numbytes(ptr[i]);
+    wchar = ptr[i] & offset_mask(off);
+    for(j=0;j < off && (i+j) < siz;j++)
+    {
+      wchar <<= 6;
+      wchar |= (ptr[++i] & 0x3F);
+    };
+    off = snprintf(conv, 8, "\\u%02lx%02lx", (wchar & 0xFF00)>>8, wchar&0xFF);
+    rst_cat_cstr(str, conv, off);
+  }
+}
+
+void
+process_write_json_string(Rst* str, VALUE input)
+{
+  const char* enc_name = rb_enc_get(input)->name;
+  rst_add_char(str, '"');
+  if(!strncmp("US-ASCII", enc_name, 8))
+    rst_cat_cstr(str, RSTRING_PTR(input), RSTRING_LEN(input));
+  else if(!strncmp("UTF-8", enc_name, 5))
+    process_write_json_utf8(str, input);
+  rst_add_char(str, '"');
+}
+
+void
+process_write_json_array(Rst* str, VALUE input)
+{
+  int i;
+  long siz;
+
+  siz = RARRAY_LEN(input);
+  rst_add_char(str, '[');
+  for(i=0;i < siz;i++)
+  {
+    process_write_json_data(str, rb_ary_entry(input, i));
+    if(i + 1 < siz)
+      rst_cat_clen(str, ", ");
+  }
+  rst_add_char(str, ']');
+}
+
+void
+process_write_json_symbol(Rst* str, VALUE input)
+{
+  process_write_json_string(str, rb_sym_to_s(input));
+}
+
+int
+process_write_json_hash_inner(VALUE key, VALUE val, VALUE str)
+{
+  Rst* rst;
+  rst = rst_unwrap(str);
+  process_write_json_data(rst, key);
+  rst_cat_clen(rst, ": ");
+  process_write_json_data(rst, val);
+  rst_add_char(rst, ',');
+  return ST_CONTINUE;
+}
+
+void
+process_write_json_hash(Rst* str, VALUE input)
+{
+  long old_len, new_len;
+  rst_add_char(str, '{');
+
+  old_len = rst_len(str);
+  rb_hash_foreach(input, process_write_json_hash_inner, rst_wrap(str));
+  new_len = rst_len(str);
+
+  if(new_len > old_len)
+    rst_chomp(str);
+  rst_add_char(str, '}');
+}
+
+void
+process_write_json_bool(Rst* str, int bool_input)
+{
+  if(bool_input)
+    rst_cat_clen(str, "true");
+  else
+    rst_cat_clen(str, "false");
+}
+
+void
+process_write_json_null(Rst* str)
+{
+  rst_cat_clen(str, "null");
+}
+
+void
+process_write_json_other(Rst* str, VALUE input)
+{
+  process_write_json_data(str, rb_funcall(input, rb_intern("to_s"), 0));
+}
+
+void
+process_write_json_data(Rst* str, VALUE input)
+{
+  switch(TYPE(input))
+  {
+    case T_FIXNUM: process_write_json_fixnum(str, input);break;
+    case T_STRING: process_write_json_string(str, input);break;
+    case T_ARRAY: process_write_json_array(str, input);break;
+    case T_HASH: process_write_json_hash(str, input);break;
+    case T_SYMBOL: process_write_json_symbol(str, input);break;
+    case T_TRUE: process_write_json_bool(str, 1);break;
+    case T_FALSE: process_write_json_bool(str, 0);break;
+    case T_NIL: process_write_json_null(str); break;
+    case T_FLOAT: process_write_json_float(str, input); break;
+    case T_BIGNUM: process_write_json_bignum(str, input);break;
+    default: process_write_json_other(str, input);
+  }
+}
+
+VALUE
+rsonal_write_json(VALUE self, VALUE input)
+{
+  rb_encoding* utf8;
+  Rst* rst;
+  rst = rst_new();
+
+  process_write_json_data(rst, input);
+
+  utf8 = rb_enc_find("UTF-8");
+  VALUE str = rb_enc_str_new_cstr("", utf8);
+  rb_str_cat(str, rst->ptr, rst->len);
+  rb_str_cat2(str, "");
+  rst_free(rst);
+
+  return str;
+}

data/ext/rsonal/rsonal_string.c

@@ -0,0 +1,113 @@
+#include <stdlib.h>
+#include <rsonal_string.h>
+
+VALUE rst_class = 0;
+
+Rst*
+rst_new()
+{
+  Rst *rst;
+  rst = malloc(sizeof(Rst));
+  rst->ptr = malloc(sizeof(char)*64);
+  rst->free_space = 64;
+  rst->max_size = 64;
+  rst->len = 0;
+  return rst;
+}
+
+void
+rst_free(Rst* ptr)
+{
+  free(ptr->ptr);
+  free(ptr);
+}
+
+void
+rst_ptr_free(RstPtr* ptr)
+{
+  free(ptr);
+}
+
+Rst*
+rst_unwrap(VALUE rst)
+{
+  RstPtr *ptr;
+  Data_Get_Struct(rst, RstPtr, ptr);
+  return ptr->ptr;
+}
+
+VALUE
+rst_wrap(Rst* rst)
+{
+  RstPtr* ptr;
+  RstPtr unwrap_ptr;
+  if(rst_class == 0)
+    rst_init();
+
+  ptr = malloc(sizeof(RstPtr));
+  ptr->ptr = rst;
+  return Data_Wrap_Struct(rst_class, 0, rst_ptr_free, ptr);
+}
+
+void
+rst_init()
+{
+  rst_class = rb_define_class("RST", rb_cString);
+}
+
+void
+rst_resize(Rst* ptr, long len)
+{
+  long n_len;
+  char* nptr;
+
+  n_len = 64;
+  while(n_len < len)
+    n_len *= 2;
+
+  nptr = realloc(ptr->ptr, sizeof(char)*(ptr->max_size + n_len));
+  ptr->ptr = nptr;
+  ptr->max_size += n_len;
+  ptr->free_space += n_len;
+}
+
+long
+rst_len(Rst* ptr)
+{
+  return ptr->len;
+}
+
+void
+rst_cat_cstr(Rst* dst, const char* input, long len)
+{
+  if(dst->free_space <= (len+8))
+    rst_resize(dst, len);
+
+  memcpy(&(dst->ptr[sizeof(char)*dst->len]), (void*)input, len*sizeof(char));
+  dst->free_space -= len;
+  dst->len += len;
+}
+
+void
+rst_add_char(Rst* dst, const char chr)
+{
+  if(dst->free_space < 8)
+    rst_resize(dst, 8);
+
+  dst->ptr[sizeof(char)*dst->len] = chr;
+  dst->len += 1;
+  dst->free_space -= 1;
+}
+
+void
+rst_cat_clen(Rst* dst, const char* input)
+{
+  rst_cat_cstr(dst, input, strlen(input));
+}
+
+void
+rst_chomp(Rst* ptr)
+{
+  ptr->free_space += 1;
+  ptr->len -= 1;
+}

data/ext/rsonal/rsonal_string.h

@@ -0,0 +1,23 @@
+#include <ruby.h>
+
+typedef struct _struct_rst {
+  char* ptr;
+  long len;
+  long max_size;
+  long free_space;
+} Rst;
+
+typedef struct _struct_rst_rb_ptr {
+  Rst* ptr;
+} RstPtr;
+
+Rst* rst_new();
+void rst_free(Rst* ptr);
+Rst* rst_unwrap(VALUE rst);
+VALUE rst_wrap(Rst* rst);
+void rst_init();
+void rst_cat_cstr(Rst* dst, const char* input, long len);
+void rst_cat_clen(Rst* dst, const char* input);
+long rst_len(Rst* ptr);
+void rst_chomp(Rst* ptr);
+void rst_add_char(Rst* dst, const char chr);

data/ext/rsonal/test.rb

@@ -0,0 +1,4 @@
+require './rsonal.bundle'
+require 'json'
+
+p Rsonal.write_json 42**1000

data/lib/rsonal.rb

@@ -0,0 +1,5 @@
+module Rsonal
+  VERSION=0.1
+end
+
+require "rsonal/rsonal"

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: rsonal
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Martin Hauser
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  rsonal is a simple and efficient JSON writer for Ruby. It is designed
+  to allow passing of a ruby object to it's only function, 'json_write'
+  which will return specification conforming JSON with as much speed
+  as possible.
+email: mh@wrongexit.de
+executables: []
+extensions:
+- ext/rsonal/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/rsonal/extconf.rb
+- ext/rsonal/rsonal.c
+- ext/rsonal/rsonal_string.c
+- ext/rsonal/rsonal_string.h
+- ext/rsonal/test.rb
+- lib/rsonal.rb
+homepage: https://github.com/mbbh/rsonal
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Simple fast JSON writer
+test_files: []