syck 1.5.1.1 → 1.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d9334ff2ab0db4b2d01c78f15fe2b18b8610fa2494157c85f3bbc4c935578cf
-  data.tar.gz: e68f5b83037746d7b69851736e25d000e142ad33a37e7bf1922080d08c251ee7
+  metadata.gz: a6f8be592c6d196af5a6fbf7bdab813819b4303d817f48b2edbc2e3441362382
+  data.tar.gz: 309adadd5621cfecdee15f0e36e39b7c1205df6406ab2521cea915b7509196fb
 SHA512:
-  metadata.gz: 934bd32bbb33044df770a561daf850b29eb3999cfc0163b2a4cbf4a1e21b4854105249844dd49b1225ac991e6b01b45c1eb67e12c761d37744e498121f130eb2
-  data.tar.gz: 866376d0f8aee6cf82e2171f0a29367945012ddd5e36c7522cb221281d9c4465ab666bbdbc07c31ff61ca343122b98843ef48225aa354de1aa5c5552da7dbaa0
+  metadata.gz: ef57afc974162ffda31cf27709ed5bdad7219f0a181a95a833549d575bfd0edd8fb18967ce380120b477107a643f823294ca83092f17b93a518e49ae59961288
+  data.tar.gz: abbdbea1f6eaea32d639b8ea9bcaee50c012c2f362d24d7a49489938eb079eb5c813d437bbf002cdb2ff149d323fd7510db3494075f6bb6c9a0f9884ed87a485

data/README.rdoc

@@ -4,9 +4,14 @@
 
 == DESCRIPTION:
 
-A gemified version of Syck from Ruby's stdlib.  Syck has been removed from
-Ruby's stdlib, and this gem is meant to bridge the gap for people that haven't
-updated their YAML yet.
+This Gem is a wrapper around {Syck}[https://github.com/indeyets/syck] (a.k.a.
+Scripters' YAML Cobble-Yourself-a-Parser Kit), used for parsing YAML.
+
+Syck has been removed from Ruby's stdlib, and this gem is meant to bridge the
+gap for people that haven't updated their YAML yet.
+
+If you are starting a new project, you probably should use
+{Psych}[https://github.com/ruby/psych] instead.
 
 == FEATURES/PROBLEMS:
 

data/ext/syck/implicit.c

@@ -11,7 +11,7 @@
 #include "ruby/ruby.h"
 #include "syck.h"
 
-#define YYCTYPE     char
+#define YYCTYPE     unsigned char
 #define YYCURSOR    cursor
 #define YYMARKER    marker
 #define YYLIMIT     limit

data/ext/syck/rubyext.c

@@ -13,29 +13,6 @@
 #include <sys/types.h>
 #include <time.h>
 
-typedef struct RVALUE {
-    union {
-#if 0
-    struct {
-        unsigned long flags;    /* always 0 for freed obj */
-        struct RVALUE *next;
-    } free;
-#endif
-    struct RBasic  basic;
-    struct RObject object;
-    /*struct RClass  klass;*/
-    /*struct RFloat  flonum;*/
-    /*struct RString string;*/
-    struct RArray  array;
-    /*struct RRegexp regexp;*/
-    /*struct RHash   hash;*/
-    /*struct RData   data;*/
-    /*struct RStruct rstruct;*/
-    /*struct RBignum bignum;*/
-    /*struct RFile   file;*/
-    } as;
-} RVALUE;
-
 typedef struct {
    long hash;
    char *buffer;
@@ -93,6 +70,75 @@ struct emitter_xtra {
     VALUE port;
 };
 
+/*
+ * The untyped Data API (Data_Wrap_Struct / Data_Get_Struct) has been
+ * removed from current Ruby, so every wrapper here uses the TypedData
+ * API and the rb_data_type_t definitions below.
+ */
+
+static void syck_node_mark(SyckNode *n);
+static void syck_mark_parser(SyckParser *parser);
+void rb_syck_free_parser(SyckParser *p);
+static void syck_mark_emitter(SyckEmitter *emitter);
+void rb_syck_free_emitter(SyckEmitter *e);
+
+static const rb_data_type_t syck_parser_type = {
+    "syck/parser",
+    {
+        (void (*)(void *))syck_mark_parser,
+        (void (*)(void *))rb_syck_free_parser,
+        0,
+    },
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static const rb_data_type_t syck_node_type = {
+    "syck/node",
+    {
+        (void (*)(void *))syck_node_mark,
+        (void (*)(void *))syck_free_node,
+        0,
+    },
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+/*
+ * Nodes owned by the parser must not be freed by the GC.  syck_node_type
+ * is set as the parent so a single &syck_node_type accepts either kind
+ * of node in the accessors below.
+ */
+static const rb_data_type_t syck_node_type_nofree = {
+    "syck/node",
+    {
+        (void (*)(void *))syck_node_mark,
+        0,
+        0,
+    },
+    &syck_node_type, 0, RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static const rb_data_type_t syck_emitter_type = {
+    "syck/emitter",
+    {
+        (void (*)(void *))syck_mark_emitter,
+        (void (*)(void *))rb_syck_free_emitter,
+        0,
+    },
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+/*
+ * The taint API (OBJ_TAINT / OBJ_TAINTED) has also been removed from
+ * current Ruby, while older supported versions still provide it; shim
+ * it to a no-op where Ruby no longer defines it.
+ */
+#ifndef OBJ_TAINT
+#define OBJ_TAINT(obj) ((void)(obj))
+#endif
+#ifndef OBJ_TAINTED
+#define OBJ_TAINTED(obj) (0)
+#endif
+
 /*
  * Convert YAML to bytecode
  */
@@ -636,6 +682,99 @@ yaml_org_handler( SyckNode *n, VALUE *ref )
 }
 
 static void syck_node_mark( SyckNode *n );
+static VALUE id_hash_new(void);
+
+/*
+ * Rewrite every reference to `from` inside `obj` so it points at `to`.
+ *
+ * A self-referential anchor (`--- &a\n- *a\n`) is aliased before the anchored
+ * node is finished, so the parser hands out a BadAlias placeholder and only
+ * later learns which object the anchor really is.  Only containers can hold a
+ * placeholder, so the walk stops at anything else.  `seen` must compare by
+ * identity, otherwise equal-but-distinct nodes collapse and cycles that are
+ * already in place would recurse forever.
+ */
+static void
+syck_swap_placeholder(VALUE obj, VALUE from, VALUE to, VALUE seen)
+{
+    long i;
+    VALUE ivars;
+
+    if ( SPECIAL_CONST_P( obj ) || OBJ_FROZEN( obj ) ) return;
+
+    switch ( BUILTIN_TYPE( obj ) )
+    {
+        case T_ARRAY:
+        case T_HASH:
+        case T_STRUCT:
+        case T_OBJECT:
+        break;
+
+        default:
+        return;
+    }
+
+    if ( RTEST( rb_hash_lookup( seen, obj ) ) ) return;
+    rb_hash_aset( seen, obj, Qtrue );
+
+    switch ( BUILTIN_TYPE( obj ) )
+    {
+        case T_ARRAY:
+            for ( i = 0; i < RARRAY_LEN( obj ); i++ )
+            {
+                VALUE v = rb_ary_entry( obj, i );
+                if ( v == from ) rb_ary_store( obj, i, to );
+                else syck_swap_placeholder( v, from, to, seen );
+            }
+        break;
+
+        case T_HASH:
+        {
+            VALUE keys = rb_funcall( obj, s_keys, 0 );
+            for ( i = 0; i < RARRAY_LEN( keys ); i++ )
+            {
+                VALUE key = rb_ary_entry( keys, i );
+                VALUE val = rb_hash_aref( obj, key );
+
+                if ( key == from || val == from )
+                {
+                    VALUE new_key = key == from ? to : key;
+                    VALUE new_val = val == from ? to : val;
+
+                    if ( new_key != key ) rb_hash_delete( obj, key );
+                    rb_hash_aset( obj, new_key, new_val );
+                    key = new_key;
+                    val = new_val;
+                }
+
+                syck_swap_placeholder( key, from, to, seen );
+                syck_swap_placeholder( val, from, to, seen );
+            }
+        }
+        break;
+
+        case T_STRUCT:
+            for ( i = 0; i < RSTRUCT_LEN( obj ); i++ )
+            {
+                VALUE v = rb_struct_aref( obj, LONG2NUM( i ) );
+                if ( v == from ) rb_struct_aset( obj, LONG2NUM( i ), to );
+                else syck_swap_placeholder( v, from, to, seen );
+            }
+        break;
+
+        default:
+        break;
+    }
+
+    ivars = rb_obj_instance_variables( obj );
+    for ( i = 0; i < RARRAY_LEN( ivars ); i++ )
+    {
+        ID name = SYM2ID( rb_ary_entry( ivars, i ) );
+        VALUE v = rb_ivar_get( obj, name );
+        if ( v == from ) rb_ivar_set( obj, name, to );
+        else syck_swap_placeholder( v, from, to, seen );
+    }
+}
 
 /*
  * {native mode} node handler
@@ -645,6 +784,7 @@ SYMID
 rb_syck_load_handler(SyckParser *p, SyckNode *n)
 {
     VALUE obj = Qnil;
+    VALUE node_wrapper;
     struct parser_xtra *bonus = (struct parser_xtra *)p->bonus;
     VALUE resolver = bonus->resolver;
     if ( NIL_P( resolver ) )
@@ -655,16 +795,32 @@ rb_syck_load_handler(SyckParser *p, SyckNode *n)
     /*
      * Create node,
      */
-    obj = rb_funcall( resolver, s_node_import, 1, Data_Wrap_Struct( cNode, syck_node_mark, NULL, n ) );
+    node_wrapper = TypedData_Wrap_Struct( cNode, &syck_node_type_nofree, n );
+    obj = rb_funcall( resolver, s_node_import, 1, node_wrapper );
+
+    /*
+     * syck_hdlr_add_node frees `n` as soon as we return (handler.c:25, when
+     * the node has no anchor). Ruby may still keep `node_wrapper` reachable
+     * via a conservative GC root on the machine stack, so the next GC would
+     * call syck_node_mark() with a dangling SyckNode*. Zero the wrapper's
+     * data pointer to make the mark a no-op. See ruby/syck#50.
+     */
+    DATA_PTR( node_wrapper ) = NULL;
 
     /*
-     * ID already set, let's alter the symbol table to accept the new object
+     * A placeholder was handed out for this node while it was still being
+     * parsed.  Syck used to fuse the two by copying the real object over the
+     * placeholder's heap slot, which is wrong on every count the GC cares
+     * about: the slot is sized for the placeholder, the copied flags carry
+     * the source object's age bits, no write barrier fires, and zeroing the
+     * source turns a live object into T_NONE behind the GC's back.  The heap
+     * then stays corrupted until some unrelated allocation crashes.  Rewrite
+     * the references instead.
      */
     if (n->id > 0 && !NIL_P(obj))
     {
-        MEMCPY((void *)n->id, (void *)obj, RVALUE, 1);
-        MEMZERO((void *)obj, RVALUE, 1);
-        obj = n->id;
+        syck_swap_placeholder( obj, (VALUE)n->id, obj, id_hash_new() );
+        n->id = obj;
     }
 
     if ( bonus->taint)      OBJ_TAINT( obj );
@@ -701,7 +857,7 @@ rb_syck_bad_anchor_handler(SyckParser *p, char *a)
 {
     VALUE anchor_name = rb_str_new2( a );
     SyckNode *badanc = syck_new_map( rb_str_new2( "name" ), anchor_name );
-    badanc->type_id = syck_strndup( "tag:ruby.yaml.org,2002:object:YAML::Syck::BadAlias", 53 );
+    badanc->type_id = syck_strndup( "tag:ruby.yaml.org,2002:object:YAML::Syck::BadAlias", 50 );
     return badanc;
 }
 
@@ -712,7 +868,7 @@ void
 syck_set_model(VALUE p, VALUE input, VALUE model)
 {
     SyckParser *parser;
-    Data_Get_Struct(p, SyckParser, parser);
+    TypedData_Get_Struct(p, SyckParser, &syck_parser_type, parser);
     syck_parser_handler( parser, rb_syck_load_handler );
     /* WARN: gonna be obsoleted soon!! */
     if ( model == sym_generic )
@@ -791,7 +947,7 @@ syck_parser_s_alloc(VALUE class)
     parser->bonus = S_ALLOC( struct parser_xtra );
     S_MEMZERO( parser->bonus, struct parser_xtra, 1 );
 
-    pobj = Data_Wrap_Struct( class, syck_mark_parser, rb_syck_free_parser, parser );
+    pobj = TypedData_Wrap_Struct( class, &syck_parser_type, parser );
 
     syck_parser_set_root_on_error( parser, Qnil );
 
@@ -828,7 +984,7 @@ syck_parser_bufsize_set(VALUE self, VALUE size)
 
     if ( rb_respond_to( size, s_to_i ) ) {
         int n = NUM2INT(rb_funcall(size, s_to_i, 0));
-        Data_Get_Struct(self, SyckParser, parser);
+        TypedData_Get_Struct(self, SyckParser, &syck_parser_type, parser);
         parser->bufsize = n;
     }
     return self;
@@ -842,7 +998,7 @@ syck_parser_bufsize_get(VALUE self)
 {
     SyckParser *parser;
 
-    Data_Get_Struct(self, SyckParser, parser);
+    TypedData_Get_Struct(self, SyckParser, &syck_parser_type, parser);
     return INT2FIX( parser->bufsize );
 }
 
@@ -860,7 +1016,7 @@ syck_parser_load(int argc, VALUE *argv, VALUE self)
 
     input = rb_hash_aref( rb_attr_get( self, s_options ), sym_input );
     model = rb_hash_aref( rb_attr_get( self, s_options ), sym_model );
-    Data_Get_Struct(self, SyckParser, parser);
+    TypedData_Get_Struct(self, SyckParser, &syck_parser_type, parser);
     syck_set_model( self, input, model );
 
     bonus = (struct parser_xtra *)parser->bonus;
@@ -887,7 +1043,7 @@ syck_parser_load_documents(int argc, VALUE *argv, VALUE self)
 
     input = rb_hash_aref( rb_attr_get( self, s_options ), sym_input );
     model = rb_hash_aref( rb_attr_get( self, s_options ), sym_model );
-    Data_Get_Struct(self, SyckParser, parser);
+    TypedData_Get_Struct(self, SyckParser, &syck_parser_type, parser);
     syck_set_model( self, input, model );
 
     bonus = (struct parser_xtra *)parser->bonus;
@@ -973,7 +1129,7 @@ syck_resolver_node_import(VALUE self, VALUE node)
     SyckNode *n;
     VALUE obj = Qnil;
     int i = 0;
-    Data_Get_Struct(node, SyckNode, n);
+    TypedData_Get_Struct(node, SyckNode, &syck_node_type, n);
 
     switch (n->kind)
     {
@@ -1264,7 +1420,7 @@ syck_defaultresolver_node_import(VALUE self, VALUE node)
 {
     SyckNode *n;
     VALUE obj;
-    Data_Get_Struct( node, SyckNode, n );
+    TypedData_Get_Struct( node, SyckNode, &syck_node_type, n );
     if ( !yaml_org_handler( n, &obj ) )
     {
         obj = rb_funcall( self, s_transfer, 2, rb_str_new2( n->type_id ), obj );
@@ -1281,7 +1437,7 @@ syck_genericresolver_node_import(VALUE self, VALUE node)
     SyckNode *n;
     int i = 0;
     VALUE t = Qnil, obj = Qnil, v = Qnil, style = Qnil;
-    Data_Get_Struct(node, SyckNode, n);
+    TypedData_Get_Struct(node, SyckNode, &syck_node_type, n);
 
     if ( n->type_id != NULL )
     {
@@ -1413,6 +1569,7 @@ static void
 syck_node_mark(SyckNode *n)
 {
     int i;
+    if ( n == NULL ) return;
     rb_gc_mark_maybe( n->id );
     switch ( n->kind )
     {
@@ -1448,7 +1605,7 @@ VALUE
 syck_scalar_alloc(VALUE class)
 {
     SyckNode *node = syck_alloc_str();
-    VALUE obj = Data_Wrap_Struct( class, syck_node_mark, syck_free_node, node );
+    VALUE obj = TypedData_Wrap_Struct( class, &syck_node_type, node );
     node->id = obj;
     return obj;
 }
@@ -1473,7 +1630,7 @@ VALUE
 syck_scalar_style_set(VALUE self, VALUE style)
 {
     SyckNode *node;
-    Data_Get_Struct( self, SyckNode, node );
+    TypedData_Get_Struct( self, SyckNode, &syck_node_type, node );
 
     if ( NIL_P( style ) )
     {
@@ -1511,7 +1668,7 @@ VALUE
 syck_scalar_value_set(VALUE  self, VALUE val)
 {
     SyckNode *node;
-    Data_Get_Struct( self, SyckNode, node );
+    TypedData_Get_Struct( self, SyckNode, &syck_node_type, node );
 
     StringValue( val );
     node->data.str->ptr = syck_strndup( RSTRING_PTR(val), RSTRING_LEN(val) );
@@ -1531,7 +1688,7 @@ syck_seq_alloc(VALUE class)
     SyckNode *node;
     VALUE obj;
     node = syck_alloc_seq();
-    obj = Data_Wrap_Struct( class, syck_node_mark, syck_free_node, node );
+    obj = TypedData_Wrap_Struct( class, &syck_node_type, node );
     node->id = obj;
     return obj;
 }
@@ -1543,7 +1700,7 @@ VALUE
 syck_seq_initialize(VALUE self, VALUE type_id, VALUE val, VALUE style)
 {
     SyckNode *node;
-    Data_Get_Struct( self, SyckNode, node );
+    TypedData_Get_Struct( self, SyckNode, &syck_node_type, node );
 
     rb_iv_set( self, "@kind", sym_seq );
     rb_funcall( self, s_type_id_set, 1, type_id );
@@ -1559,7 +1716,7 @@ VALUE
 syck_seq_value_set(VALUE self, VALUE val)
 {
     SyckNode *node;
-    Data_Get_Struct( self, SyckNode, node );
+    TypedData_Get_Struct( self, SyckNode, &syck_node_type, node );
 
     val = rb_check_array_type( val );
     if ( !NIL_P( val ) ) {
@@ -1583,7 +1740,7 @@ syck_seq_add_m(VALUE self, VALUE val)
 {
     SyckNode *node;
     VALUE emitter = rb_ivar_get( self, s_emitter );
-    Data_Get_Struct( self, SyckNode, node );
+    TypedData_Get_Struct( self, SyckNode, &syck_node_type, node );
 
     if ( rb_respond_to( emitter, s_node_export ) ) {
         val = rb_funcall( emitter, s_node_export, 1, val );
@@ -1601,7 +1758,7 @@ VALUE
 syck_seq_style_set(VALUE self, VALUE style)
 {
     SyckNode *node;
-    Data_Get_Struct( self, SyckNode, node );
+    TypedData_Get_Struct( self, SyckNode, &syck_node_type, node );
 
     if ( style == sym_inline )
     {
@@ -1625,7 +1782,7 @@ syck_map_alloc(VALUE class)
     SyckNode *node;
     VALUE obj;
     node = syck_alloc_map();
-    obj = Data_Wrap_Struct( class, syck_node_mark, syck_free_node, node );
+    obj = TypedData_Wrap_Struct( class, &syck_node_type, node );
     node->id = obj;
     return obj;
 }
@@ -1637,7 +1794,7 @@ VALUE
 syck_map_initialize(VALUE self, VALUE type_id, VALUE val, VALUE style)
 {
     SyckNode *node;
-    Data_Get_Struct( self, SyckNode, node );
+    TypedData_Get_Struct( self, SyckNode, &syck_node_type, node );
 
     if ( !NIL_P( val ) )
     {
@@ -1671,7 +1828,7 @@ VALUE
 syck_map_value_set(VALUE self, VALUE val)
 {
     SyckNode *node;
-    Data_Get_Struct( self, SyckNode, node );
+    TypedData_Get_Struct( self, SyckNode, &syck_node_type, node );
 
     if ( !NIL_P( val ) )
     {
@@ -1704,7 +1861,7 @@ syck_map_add_m(VALUE self, VALUE key, VALUE val)
 {
     SyckNode *node;
     VALUE emitter = rb_ivar_get( self, s_emitter );
-    Data_Get_Struct( self, SyckNode, node );
+    TypedData_Get_Struct( self, SyckNode, &syck_node_type, node );
 
     if ( rb_respond_to( emitter, s_node_export ) ) {
         key = rb_funcall( emitter, s_node_export, 1, key );
@@ -1723,7 +1880,7 @@ VALUE
 syck_map_style_set(VALUE self, VALUE style)
 {
     SyckNode *node;
-    Data_Get_Struct( self, SyckNode, node );
+    TypedData_Get_Struct( self, SyckNode, &syck_node_type, node );
 
     if ( style == sym_inline )
     {
@@ -1756,8 +1913,8 @@ syck_node_init_copy(VALUE copy, VALUE orig)
         rb_raise( rb_eTypeError, "wrong argument type" );
     }
 
-    Data_Get_Struct( orig, SyckNode, orig_n );
-    Data_Get_Struct( copy, SyckNode, copy_n );
+    TypedData_Get_Struct( orig, SyckNode, &syck_node_type, orig_n );
+    TypedData_Get_Struct( copy, SyckNode, &syck_node_type, copy_n );
     MEMCPY( copy_n, orig_n, SyckNode, 1 );
     return copy;
 }
@@ -1770,7 +1927,7 @@ VALUE
 syck_node_type_id_set(VALUE self, VALUE type_id)
 {
     SyckNode *node;
-    Data_Get_Struct( self, SyckNode, node );
+    TypedData_Get_Struct( self, SyckNode, &syck_node_type, node );
 
     S_FREE( node->type_id );
 
@@ -1792,8 +1949,8 @@ syck_node_transform(VALUE self)
     VALUE t;
     SyckNode *n = NULL;
     SyckNode *orig_n;
-    Data_Get_Struct(self, SyckNode, orig_n);
-    t = Data_Wrap_Struct( cNode, syck_node_mark, syck_free_node, 0 );
+    TypedData_Get_Struct(self, SyckNode, &syck_node_type, orig_n);
+    t = TypedData_Wrap_Struct( cNode, &syck_node_type, 0 );
 
     switch (orig_n->kind)
     {
@@ -1846,7 +2003,7 @@ void
 rb_syck_emitter_handler(SyckEmitter *e, st_data_t data)
 {
     SyckNode *n;
-    Data_Get_Struct((VALUE)data, SyckNode, n);
+    TypedData_Get_Struct((VALUE)data, SyckNode, &syck_node_type, n);
 
     switch (n->kind)
     {
@@ -1907,7 +2064,7 @@ syck_out_mark(VALUE emitter, VALUE node)
 {
     SyckEmitter *emitterPtr;
     struct emitter_xtra *bonus;
-    Data_Get_Struct(emitter, SyckEmitter, emitterPtr);
+    TypedData_Get_Struct(emitter, SyckEmitter, &syck_emitter_type, emitterPtr);
     bonus = (struct emitter_xtra *)emitterPtr->bonus;
     rb_ivar_set( node, s_emitter, emitter );
     /* syck_emitter_mark_node( emitterPtr, (st_data_t)node ); */
@@ -1951,7 +2108,7 @@ syck_emitter_s_alloc(VALUE class)
     emitter->bonus = S_ALLOC( struct emitter_xtra );
     S_MEMZERO( emitter->bonus, struct emitter_xtra, 1 );
 
-    pobj = Data_Wrap_Struct( class, syck_mark_emitter, rb_syck_free_emitter, emitter );
+    pobj = TypedData_Wrap_Struct( class, &syck_emitter_type, emitter );
     syck_emitter_handler( emitter, rb_syck_emitter_handler );
     syck_output_handler( emitter, rb_syck_output_handler );
 
@@ -1978,7 +2135,7 @@ syck_emitter_reset(int argc, VALUE *argv, VALUE self)
     SyckEmitter *emitter;
     struct emitter_xtra *bonus;
 
-    Data_Get_Struct(self, SyckEmitter, emitter);
+    TypedData_Get_Struct(self, SyckEmitter, &syck_emitter_type, emitter);
     bonus = (struct emitter_xtra *)emitter->bonus;
 
     bonus->oid = Qnil;
@@ -2024,7 +2181,7 @@ syck_emitter_emit(int argc, VALUE *argv, VALUE self)
     rb_ivar_set(self, s_level, INT2FIX(level));
 
     rb_scan_args(argc, argv, "1&", &oid, &proc);
-    Data_Get_Struct(self, SyckEmitter, emitter);
+    TypedData_Get_Struct(self, SyckEmitter, &syck_emitter_type, emitter);
     bonus = (struct emitter_xtra *)emitter->bonus;
 
     /* Calculate anchors, normalize nodes, build a simpler symbol table */

data/ext/syck/yaml2byte.c

@@ -115,9 +115,7 @@ void bytestring_extend(bytestring_t *str, bytestring_t *ext)
 
 /* convert SyckNode into yamlbyte_buffer_t objects */
 SYMID
-syck_yaml2byte_handler(p, n)
-    SyckParser *p;
-    SyckNode *n;
+syck_yaml2byte_handler(SyckParser *p, SyckNode *n)
 {
     SYMID oid;
     long i;

data/lib/syck/constants.rb

@@ -6,7 +6,7 @@ module Syck
 	#
 	# Constants
 	#
-	VERSION = '1.5.1.1'
+	VERSION = '1.6.1'
 	SUPPORTED_YAML_VERSIONS = ['1.0']
 
 	#

data/test/test_boolean.rb

@@ -32,5 +32,17 @@ module Syck
       assert_equal "n", Syck.load("--- n")
       assert_equal "N", Syck.load("--- N")
     end
+
+    ###
+    # https://github.com/ruby/syck/issues/22
+    # A boolean-like prefix followed by a non-ASCII byte must not be
+    # matched as a boolean
+    def test_bool_prefix_with_non_ascii
+      assert_equal "Noémie", Syck.load("--- Noémie")
+      assert_equal ["Noémie"], Syck.load("--- [Noémie]")
+      assert_equal "Yeså", Syck.load("--- Yeså")
+      assert_equal "trueé", Syck.load("--- trueé")
+      assert_equal "nullé", Syck.load("--- nullé")
+    end
   end
 end

data/test/test_gc.rb

@@ -0,0 +1,33 @@
+require_relative "helper"
+
+# Regression test for ruby/syck#50 - heap-use-after-free in syck_node_mark
+# when GC runs between syck_hdlr_add_node freeing a SyckNode and the Ruby
+# Data wrapper that pointed at it being collected.
+#
+# GC.stress forces a full GC on every allocation, so if the fix regresses
+# this test will segfault (or fire under ASAN/valgrind).
+class TestGC < Test::Unit::TestCase
+  def test_load_under_gc_stress
+    yaml = ({}.tap { |h| 50.times { |i| h["k#{i}"] = "v" * 64 } }).to_yaml
+
+    GC.stress = true
+    begin
+      3.times { Syck.load(yaml) }
+    ensure
+      GC.stress = false
+    end
+  end
+
+  def test_load_many_documents_under_gc_stress
+    docs = Array.new(5) do |i|
+      ({}.tap { |h| 30.times { |k| h["k_#{i}_#{k}"] = "v_#{i}_#{k}" } }).to_yaml
+    end
+
+    GC.stress = true
+    begin
+      docs.each { |d| Syck.load(d) }
+    ensure
+      GC.stress = false
+    end
+  end
+end

data/test/test_yaml.rb

@@ -1337,6 +1337,40 @@ EOY
         assert_equal( inspect_str, Syck::load( a.to_yaml ).inspect )
     end
 
+    #
+    # A self-referential anchor is aliased before the anchored node exists, so
+    # the parser hands out a placeholder and patches it up afterwards.  That
+    # used to be done by overwriting the placeholder's heap slot, which left
+    # the GC heap corrupted and crashed at some later allocation.
+    #
+    def test_self_referential_anchor
+        [ 1, 3, 6, 50 ].each do |n|
+            seq = Syck::load( "--- &id001\n" + "- *id001\n" * n )
+            assert_equal( n, seq.size )
+            seq.each { |item| assert_same( seq, item ) }
+        end
+
+        map = Syck::load( "--- &id001\nself: *id001\n" )
+        assert_same( map, map["self"] )
+
+        keyed = Syck::load( "--- &id001\n? *id001\n: 1\n" )
+        assert_same( keyed, keyed.keys.first )
+
+        # The alias appears as a key and again below the matching value, so
+        # rewriting the key must not stop the walk from reaching the rest.
+        both = Syck::load( "--- &id001\n? *id001\n: \n  - *id001\n" )
+        key, value = both.first
+        assert_same( both, key )
+        assert_same( both, value[0] )
+
+        nested = Syck::load( "--- &id001\n- &id002\n  - *id001\n- *id002\n" )
+        assert_same( nested, nested[0][0] )
+        assert_same( nested[0], nested[1] )
+
+        GC.start
+        assert_nothing_raised { GC.verify_internal_consistency }
+    end
+
     #
     # Test Symbol cycle
     #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: syck
 version: !ruby/object:Gem::Version
-  version: 1.5.1.1
+  version: 1.6.1
 platform: ruby
 authors:
 - Hiroshi SHIBATA
@@ -9,7 +9,7 @@ authors:
 - Mat Brown
 bindir: bin
 cert_chain: []
-date: 2024-08-19 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -100,12 +100,12 @@ files:
 - lib/syck/yamlnode.rb
 - lib/syck/ypath.rb
 - lib/yaml/syck.rb
-- syck.gemspec
 - test/helper.rb
 - test/test_array.rb
 - test/test_boolean.rb
 - test/test_class.rb
 - test/test_exception.rb
+- test/test_gc.rb
 - test/test_hash.rb
 - test/test_null.rb
 - test/test_omap.rb
@@ -136,7 +136,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 0.9.5
 requirements: []
-rubygems_version: 3.6.0.dev
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A gemified version of Syck from Ruby's stdlib
 test_files:
@@ -145,6 +145,7 @@ test_files:
 - test/test_boolean.rb
 - test/test_class.rb
 - test/test_exception.rb
+- test/test_gc.rb
 - test/test_hash.rb
 - test/test_null.rb
 - test/test_omap.rb

data/syck.gemspec

@@ -1,26 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = "syck"
-  s.version = "1.5.1.1"
-
-  s.summary = "A gemified version of Syck from Ruby's stdlib"
-  s.description = "A gemified version of Syck from Ruby's stdlib.  Syck has been removed from\nRuby's stdlib, and this gem is meant to bridge the gap for people that haven't\nupdated their YAML yet."
-  s.authors = ["Hiroshi SHIBATA", "Aaron Patterson", "Mat Brown"]
-  s.email = ["hsbt@ruby-lang.org", "aaron@tenderlovemaking.com"]
-  s.homepage = "https://github.com/ruby/syck"
-  s.license = "MIT"
-  s.require_paths = ["lib"]
-  s.extensions = ["ext/syck/extconf.rb"]
-  s.files = Dir["[A-Z]*", "ext/**/*", "lib/**/*.rb", "test/**/*.rb"] - %w[Gemfile.lock ext/syck/gram.y]
-  s.extra_rdoc_files = ["README.rdoc"]
-  s.test_files = Dir["test/**/*.rb"]
-  s.rdoc_options = ["--main", "README.rdoc"]
-  s.required_ruby_version = Gem::Requirement.new(">= 2.0.0")
-  s.required_rubygems_version = Gem::Requirement.new(">= 0.9.5")
-  s.rubygems_version = "2.0.3"
-
-  s.add_development_dependency(%q<bundler>)
-  s.add_development_dependency(%q<test-unit>)
-  s.add_development_dependency(%q<rake-compiler>)
-end