i18nema 0.0.3 → 0.0.4

data/ext/i18nema/i18nema.c

@@ -12,13 +12,20 @@ struct i_key_value;
 static VALUE array_to_rarray(struct i_object *array);
 static VALUE hash_to_rhash(struct i_object *hash);
 static void merge_hash(struct i_object *hash, struct i_object *other_hash);
-static void delete_hash(struct i_key_value **hash);
-static void delete_object(struct i_object *object);
+static void delete_hash(struct i_key_value **hash, int delete_child_objects);
+static void delete_object(struct i_object *object, int delete_child_objects);
 
 enum i_object_type {
+  i_type_none,
   i_type_string,
   i_type_array,
-  i_type_hash
+  i_type_hash,
+  i_type_int,
+  i_type_float,
+  i_type_symbol,
+  i_type_true,
+  i_type_false,
+  i_type_null
 };
 
 union i_object_data {
@@ -42,11 +49,17 @@ typedef struct i_key_value
 } i_key_value_t;
 
 static int current_translation_count = 0;
-static ID s_to_s,
-          s_init_translations;
+static ID s_init_translations,
+          s_to_f,
+          s_to_s,
+          s_to_sym;
+static i_object_t i_object_null,
+                  i_object_true,
+                  i_object_false;
 
 static VALUE
 i_object_to_robject(i_object_t *object) {
+  VALUE s;
   if (object == NULL)
     return Qnil;
   switch (object->type) {
@@ -56,8 +69,20 @@ i_object_to_robject(i_object_t *object) {
     return array_to_rarray(object);
   case i_type_hash:
     return hash_to_rhash(object);
+  case i_type_int:
+    return rb_cstr2inum(object->data.string, 10);
+  case i_type_float:
+    s = rb_str_new(object->data.string, object->size);
+    return rb_funcall(s, s_to_f, 0);
+  case i_type_symbol:
+    return ID2SYM(rb_intern(object->data.string));
+  case i_type_true:
+    return Qtrue;
+  case i_type_false:
+    return Qfalse;
+  default:
+    return Qnil;
   }
-  return Qnil;
 }
 
 static VALUE
@@ -118,49 +143,60 @@ direct_lookup(int argc, VALUE *argv, VALUE self)
 }
 
 static void
-empty_object(i_object_t *object)
+empty_object(i_object_t *object, int delete_child_objects)
 {
   if (object == NULL)
     return;
 
   switch (object->type) {
-  case i_type_string:
-    xfree(object->data.string);
-    break;
   case i_type_array:
-    for (unsigned long i = 0; i < object->size; i++)
-      delete_object(object->data.array[i]);
+    if (delete_child_objects) {
+      for (unsigned long i = 0; i < object->size; i++)
+        delete_object(object->data.array[i], 1);
+    }
     xfree(object->data.array);
     break;
   case i_type_hash:
-    delete_hash(&object->data.hash);
+    delete_hash(&object->data.hash, delete_child_objects);
+    break;
+  case i_type_none:
+    break;
+  default:
+    xfree(object->data.string);
     break;
   }
 }
 
 static void
-delete_object(i_object_t *object)
+delete_object_r(i_object_t *object)
 {
-  empty_object(object);
-  xfree(object);
+  delete_object(object, 1);
+}
+
+static void
+delete_object(i_object_t *object, int delete_child_objects)
+{
+  empty_object(object, delete_child_objects);
+  if (object->type != i_type_null && object->type != i_type_true && object->type != i_type_false)
+    xfree(object);
 }
 
 static void
 delete_key_value(i_key_value_t *kv, int delete_value)
 {
   if (delete_value)
-    delete_object(kv->value);
+    delete_object(kv->value, 1);
   xfree(kv->key);
   xfree(kv);
 }
 
 static void
-delete_hash(i_key_value_t **hash)
+delete_hash(i_key_value_t **hash, int delete_child_objects)
 {
   i_key_value_t *kv, *tmp;
   HASH_ITER(hh, *hash, kv, tmp) {
     HASH_DEL(*hash, kv);
-    delete_key_value(kv, 1);
+    delete_key_value(kv, delete_child_objects);
   }
 }
 
@@ -191,12 +227,16 @@ merge_hash(i_object_t *hash, i_object_t *other_hash)
     HASH_DEL(other_hash->data.hash, kv);
     add_key_value(&hash->data.hash, kv);
   }
-  delete_object(other_hash);
+  delete_object(other_hash, 1);
 }
 
 static int
 delete_syck_st_entry(char *key, char *value, char *arg)
 {
+  i_object_t *object = (i_object_t *)value;
+  // key object whose string we have yoinked into a kv
+  if (object->type == i_type_none)
+    delete_object(object, 1);
   return ST_DELETE;
 }
 
@@ -204,7 +244,7 @@ static int
 delete_syck_object(char *key, char *value, char *arg)
 {
   i_object_t *object = (i_object_t *)value;
-  delete_object(object);
+  delete_object(object, 0); // objects are in the syck symbol table, thus we don't want to double-free
   return ST_DELETE;
 }
 
@@ -230,23 +270,52 @@ handle_syck_badanchor(SyckParser *parser, char *anchor)
   return NULL;
 }
 
+static i_object_t*
+new_string_object(char *str, long len)
+{
+  i_object_t *object = ALLOC(i_object_t);
+  object->type = i_type_string;
+  object->size = len;
+  object->data.string = xmalloc(len + 1);
+  strncpy(object->data.string, str, len);
+  object->data.string[len] = '\0';
+  return object;
+}
+
 static SYMID
 handle_syck_node(SyckParser *parser, SyckNode *node)
 {
   i_object_t *result;
-  result = ALLOC(i_object_t);
   SYMID oid;
 
   switch (node->kind) {
   case syck_str_kind:
-    // TODO: why does syck sometimes give us empty string nodes? (small) memory leak, since they never end up in a seq/map
-    result->type = i_type_string;
-    result->size = node->data.str->len;
-    result->data.string = xmalloc(node->data.str->len + 1);
-    strncpy(result->data.string, node->data.str->ptr, node->data.str->len);
-    result->data.string[node->data.str->len] = '\0';
+    if (node->type_id == NULL) {
+      result = new_string_object(node->data.str->ptr, node->data.str->len);
+    } else if (strcmp(node->type_id, "null") == 0) {
+      result = &i_object_null;
+    } else if (strcmp(node->type_id, "bool#yes") == 0) {
+      result = &i_object_true;
+    } else if (strcmp(node->type_id, "bool#no") == 0) {
+      result = &i_object_false;
+    } else if (strcmp(node->type_id, "int") == 0) {
+      syck_str_blow_away_commas(node);
+      result = new_string_object(node->data.str->ptr, node->data.str->len);
+      result->type = i_type_int;
+    } else if (strcmp(node->type_id, "float#fix") == 0 || strcmp(node->type_id, "float#exp") == 0) {
+      syck_str_blow_away_commas(node);
+      result = new_string_object(node->data.str->ptr, node->data.str->len);
+      result->type = i_type_float;
+    } else if (node->data.str->style == scalar_plain && node->data.str->len > 1 && strncmp(node->data.str->ptr, ":", 1) == 0) {
+      result = new_string_object(node->data.str->ptr + 1, node->data.str->len - 1);
+      result->type = i_type_symbol;
+    } else {
+      // legit strings, and everything else get the string treatment (binary, int#hex, timestamp, etc.)
+      result = new_string_object(node->data.str->ptr, node->data.str->len);
+    }
     break;
   case syck_seq_kind:
+    result = ALLOC(i_object_t);
     result->type = i_type_array;
     result->size = node->data.list->idx;
     result->data.array = ALLOC_N(i_object_t*, node->data.list->idx);
@@ -261,6 +330,7 @@ handle_syck_node(SyckParser *parser, SyckNode *node)
     }
     break;
   case syck_map_kind:
+    result = ALLOC(i_object_t);
     result->type = i_type_hash;
     result->data.hash = NULL;
     for (long i = 0; i < node->data.pairs->idx; i++) {
@@ -274,7 +344,7 @@ handle_syck_node(SyckParser *parser, SyckNode *node)
       i_key_value_t *kv;
       kv = ALLOC(i_key_value_t);
       kv->key = key->data.string;
-      xfree(key);
+      key->type = i_type_none; // so we know to free this node in delete_syck_st_entry
       kv->value = value;
       if (value->type == i_type_string)
         current_translation_count++;
@@ -317,7 +387,7 @@ load_yml_string(VALUE self, VALUE yml)
     st_foreach(parser->syms, delete_syck_st_entry, 0);
   syck_free_parser(parser);
   if (new_root_object == NULL || new_root_object->type != i_type_hash) {
-    delete_object(new_root_object);
+    delete_object(new_root_object, 1);
     rb_raise(I18nemaBackendLoadError, "root yml node is not a hash");
   }
   merge_hash(root_object, new_root_object);
@@ -362,7 +432,7 @@ static VALUE
 reload(VALUE self)
 {
   i_object_t *root_object = root_object_get(self);
-  empty_object(root_object);
+  empty_object(root_object, 1);
   rb_iv_set(self, "@initialized", Qfalse);
   root_object = NULL;
   return Qtrue;
@@ -375,7 +445,7 @@ initialize(VALUE self)
   i_object_t *root_object = ALLOC(i_object_t);
   root_object->type = i_type_hash;
   root_object->data.hash = NULL;
-  translations = Data_Wrap_Struct(I18nemaBackend, 0, delete_object, root_object);
+  translations = Data_Wrap_Struct(I18nemaBackend, 0, delete_object_r, root_object);
   rb_iv_set(self, "@translations", translations);
   return self;
 }
@@ -387,8 +457,14 @@ Init_i18nema()
   I18nemaBackend = rb_define_class_under(I18nema, "Backend", rb_cObject);
   I18nemaBackendLoadError = rb_define_class_under(I18nemaBackend, "LoadError", rb_eStandardError);
 
-  s_to_s = rb_intern("to_s");
   s_init_translations = rb_intern("init_translations");
+  s_to_f = rb_intern("to_f");
+  s_to_s = rb_intern("to_s");
+  s_to_sym = rb_intern("to_sym");
+
+  i_object_null.type = i_type_null;
+  i_object_true.type = i_type_true;
+  i_object_false.type = i_type_false;
 
   rb_define_method(I18nemaBackend, "initialize", initialize, 0);
   rb_define_method(I18nemaBackend, "load_yml_string", load_yml_string, 1);

data/test/i18nema_test.rb

@@ -10,7 +10,16 @@ class I18nemaTest < Test::Unit::TestCase
       baz: %w{
         asdf
         qwerty
-      }
+      },
+      stuff: [
+        true,
+        true,
+        false,
+        nil,
+        1,
+        1.1,
+        :foo
+      ]
     }
     @backend = I18nema::Backend.new
     @backend.store_translations :en, @data
@@ -63,11 +72,11 @@ class I18nemaTest < Test::Unit::TestCase
     # i_object_t as the root node, causing delete_object to asplode when
     # it tries to free a garbage pointer
     #
-    #exception = assert_raise(I18nema::Backend::LoadError) {
-    #  backend.load_yml_string("en:\n  foo: \"lol\"\n\tbar: notabs!")
-    #}
-    #assert_match(/TAB found in your indentation/, exception.message)
-    #assert_equal({}, backend.direct_lookup)
+    exception = assert_raise(I18nema::Backend::LoadError) {
+      backend.load_yml_string("en:\n  foo: \"lol\"\n\tbar: notabs!")
+    }
+    assert_match(/syntax error/, exception.message)
+    assert_equal({}, backend.direct_lookup)
 
     exception = assert_raise(I18nema::Backend::LoadError) {
       backend.load_yml_string("en:\n  &a [*a]")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: i18nema
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-29 00:00:00.000000000 Z
+date: 2013-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n