node-marshal 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d564a41c56aa30cec81fe572e069cd4734637995
-  data.tar.gz: 28c7a859af9ba4cfa82c2f8138e0a9b1708f3176
+  metadata.gz: 5bed8bdc507d12d26f9b1ed0eb8c969fc05853e3
+  data.tar.gz: ebc554d61f17751f7033c1c666375f383e9cb5c5
 SHA512:
-  metadata.gz: e7a41dbf52db03ccb69a4ccd9641ff740f45c88ba27488e17dea2897655c0920e1880edfcb29ded1801e25287358bd81d77097453e19c97ca2ff55fa46c90fa0
-  data.tar.gz: f31215d9e96c760d21927279162f48627d4bbace53ad66fe43d7335f8de403788e77022570a933fb6b4e5fee65cbd829f26ae9c3d5cd8c63903087ca10048fdd
+  metadata.gz: 2d7c90c64e183b195ebbe6d12ea6f9af7d75ce54955e93b667b1ccbc9a22cc4807a1623c4c3eb0134a044af1c21f4aa94865878f7a93879b250f0d8928357e63
+  data.tar.gz: f25344c304ef5786fd44fc50f14afc177b30698b4db00c2a12055707e10ae8964e7aa6a5d84d1c92877d7a0a418fd779032a5e281d3437adfd1c6493ffcb4cc5

data/README.rdoc

@@ -17,6 +17,19 @@ The key features of node-marshal gem:
 - 2-clause BSD license suitable for creation of custom source code protection system
 
 Changelog:
+- 16.MAR.2016 - 0.2.1
+      - Bugfix: garbage collection of symbols kept in the literals table of the node dump
+        is now prohibited. Such GC caused hardly reproducible bugs after code loading.
+        (thanks to Gregory Siehień for suitable examples)
+      - Bugfix: improved parsing of NODE_ARRAY (correct processing of two cases of
+        not documented pointers (instead of longs) in 2nd child. It affects arrays,
+        NODE_HASH (hashes) and NODE_DSTR (strings in double quotes with #{} inside) ).
+      - Bugfix: now NodeMarshal class methods don't change the state of Ruby 
+        garbage collector
+      - Improved NodeMarshal#dump_tree_short output (addresses of nodes are shown)
+      - Added NodeMarshal#to_h method (alias for NodeMarshal#to_hash)
+      - NodeMarshal#to_a and NodeMarshal#to_ary methods added (they show extended information
+        about Ruby AST including rb_args_info and ID *tbl internals)
 - 11.JAN.2016 - 0.2.0
       - Bugfix: || and && in NODE_OP_ASGN1 (e.g. in x['a'] ||= 'b' or x['b'] &&= false)
         (this bug caused segfaults in some cases)

data/bin/noderbc

@@ -5,7 +5,7 @@ help = <<-EOS
 Ruby source files compiler from node-marshal gem. It is based
 on NodeMarshal class. Source code is irreversibly transformed to the 
 Ruby node (syntax tree) serialized into ASCII string. It can be used
-for for code obfuscation.
+for code obfuscation and Ruby internals exploration.
 
 (C) 2015-2016 Alexey Voskov. License: BSD-2-Clause.
 

data/ext/node-marshal/nodedump.c

@@ -241,6 +241,11 @@ int LeafTableInfo_keyToID(LeafTableInfo *lti, VALUE key)
 	return (id == Qnil) ? -1 : FIX2INT(id);
 }
 
+VALUE LeafTableInfo_keyToValue(LeafTableInfo *lti, VALUE key)
+{
+	return rb_hash_aref(lti->vals, key);
+}
+
 /* The structure keeps information about the node
    that is required for its dumping to the file
    (mainly hashes with relocatable identifiers) */
@@ -253,6 +258,7 @@ typedef struct {
 #endif
 	LeafTableInfo gentries; // Global variables table
 	LeafTableInfo nodes; // Table of nodes
+	LeafTableInfo pnodes; // Table of parent nodes
 } NODEInfo;
 
 void NODEInfo_init(NODEInfo *info)
@@ -265,6 +271,7 @@ void NODEInfo_init(NODEInfo *info)
 #endif
 	LeafTableInfo_init(&(info->gentries));
 	LeafTableInfo_init(&(info->nodes));
+	LeafTableInfo_init(&(info->pnodes));
 }
 
 void NODEInfo_mark(NODEInfo *info)
@@ -277,6 +284,7 @@ void NODEInfo_mark(NODEInfo *info)
 #endif
 	LeafTableInfo_mark(&(info->gentries));
 	LeafTableInfo_mark(&(info->nodes));
+	LeafTableInfo_mark(&(info->pnodes));
 }
 
 void NODEInfo_free(NODEInfo *info)
@@ -340,9 +348,10 @@ static int dump_node_value(NODEInfo *info, char *ptr, NODE *node, int type, VALU
 		}
 		else if (TYPE(value) != T_NODE)
 		{
-			rb_raise(rb_eArgError, "dump_node_value, parent node %s: child node %d (ADR 0x%s): is not a node\n"
+			rb_raise(rb_eArgError, "dump_node_value, parent node %s (ADR 0x%s): child node %d (ADR 0x%s): is not a node\n"
 				"  Type: %s (%d), Value: %s",
-				ruby_node_name(nd_type(node)), child_id, RSTRING_PTR(value_to_str(value)),
+				ruby_node_name(nd_type(node)), RSTRING_PTR(value_to_str((VALUE) node)),
+				child_id, RSTRING_PTR(value_to_str(value)),
 				RSTRING_PTR(rb_funcall(rb_funcall(value, rb_intern("class"), 0), rb_intern("to_s"), 0)),
 				TYPE(value),
 				RSTRING_PTR(rb_funcall(value, rb_intern("to_s"), 0)) );
@@ -352,8 +361,9 @@ static int dump_node_value(NODEInfo *info, char *ptr, NODE *node, int type, VALU
 			VALUE id = LeafTableInfo_keyToID(&info->nodes, value_to_str(value));
 			if (id == (VALUE) -1)
 			{
-				rb_raise(rb_eArgError, "dump_node_value, parent node %s: child node %d (ADR 0x%s) not found",
-					ruby_node_name(nd_type(node)), child_id, RSTRING_PTR(value_to_str(value)));
+				rb_raise(rb_eArgError, "dump_node_value, parent node %s (ADR 0x%s): child node %d (ADR 0x%s) not found",
+					ruby_node_name(nd_type(node)), RSTRING_PTR(value_to_str((VALUE) node)),
+					child_id, RSTRING_PTR(value_to_str(value)));
 				return VL_RAW;
 			}
 			else
@@ -421,6 +431,13 @@ static int dump_node_value(NODEInfo *info, char *ptr, NODE *node, int type, VALU
 	}
 }
 
+/*
+ * Converts information about nodes to the binary string.
+ * It uses dump_node_value function for the low-level conversion
+ * of node "leaves" to the actual binary data.
+ *
+ * See load_nodes_from_str for the descrpition of the binary string format.
+ */
 static VALUE dump_nodes(NODEInfo *info)
 {
 	int node_size = sizeof(int) + sizeof(VALUE) * 4;
@@ -462,6 +479,40 @@ static VALUE dump_nodes(NODEInfo *info)
 			if (node->u2.value == 0) ut[1] = NT_NULL;
 			if (node->u3.value == 0) ut[2] = NT_NULL;
 		}
+		
+		if (nt = NODE_ARRAY)
+		{
+			/* Special undocumented cases:
+			 * 1) the second child of the second element of an array
+			 * contains reference to the last element (NT_NODE) not
+			 * length (NT_LONG)
+			 * 2) NODE_HASH: every second element in NODE_ARRAY chain
+			 * contains pointers to NODES (instead of lengths)
+			 * 3) NODE_DSTR: first node in NODE_ARRAY chain contains
+			 * pointer to NODE (instead of lengths) */
+			NODE *pnode1, *pnode2;
+			pnode1 = (NODE *) str_to_value(LeafTableInfo_keyToValue(&info->pnodes, value_to_str((VALUE) node)));
+			if (pnode1 != NULL && nd_type(pnode1) == NODE_ARRAY &&
+				(NODE *) pnode1->u3.value == node)
+			{
+				int nt2;
+				pnode2 = (NODE *) str_to_value(LeafTableInfo_keyToValue(&info->pnodes, value_to_str((VALUE) pnode1)));
+				nt2 = nd_type(pnode2);
+				if ( (nt2 != NODE_ARRAY && nt2 != NODE_DSTR) ||
+				    (NODE *) pnode2->u1.value == pnode1 )
+				{
+					ut[1] = NT_NODE;
+				}
+				else if (pnode1->u2.value == 2 && node == (NODE *) node->u2.value)
+				{
+					ut[1] = NT_NODE;
+				}
+			}
+			else if (pnode1 != NULL && nd_type(pnode1) == NODE_DSTR)
+			{
+				ut[1] = NT_NODE;
+			}
+		}
 
 		rtypes[0] = dump_node_value(info, ptr, node, ut[0], node->u1.value, 1);
 		ptr += (rtypes[0] & 0xF0) >> 4;
@@ -584,6 +635,28 @@ static void NODEInfo_addValue(NODEInfo *info, VALUE value)
 	}
 }
 
+/*
+ * Adds the information about Ruby NODE to the NODEInfo struct.
+ * It keeps the addresses of the node and its parents
+ */
+static void NODEInfo_addNode(NODEInfo *info, NODE *node, NODE *pnode)
+{
+	VALUE node_adr = value_to_str((VALUE) node);
+	VALUE pnode_adr = value_to_str((VALUE) pnode);
+	LeafTableInfo_addEntry(&info->nodes, node_adr, node_adr);
+	LeafTableInfo_addEntry(&info->pnodes, node_adr, pnode_adr);
+}
+
+/*
+ * Returns ID of the node using its address (VALUE)
+ * It is used during the process of dumping Ruby AST to disk
+ * for replacing of memory addresses into ordinals
+ */
+static int NODEInfo_nodeAdrToID(NODEInfo *info, VALUE adr)
+{
+	return LeafTableInfo_keyToID(&info->nodes, adr);
+}
+
 /*
  * Function counts number of nodes and fills NODEInfo struct
  * that is neccessary for the node saving to the HDD
@@ -638,7 +711,7 @@ static int count_num_of_nodes(NODE *node, NODE *parent, NODEInfo *info)
 		}
 		/* Save the ID of the node */
 		num = 1;
-		LeafTableInfo_addEntry(&info->nodes, value_to_str((VALUE) node), value_to_str((VALUE) node));
+		NODEInfo_addNode(info, node, parent);
 		/* Analyze node childs */
 		/* a) child 1 */
 		if (ut[0] == NT_NODE)
@@ -836,8 +909,9 @@ static void print_node(VALUE str, NODE *node, int tab, int show_offsets)
 
 	if (show_offsets)
 	{
-		rbstr_printf(str, "@ %s | %16"PRIxPTR " %16"PRIxPTR " %16"PRIxPTR " (line %d)\n",
+		rbstr_printf(str, "@ %s | %16"PRIxPTR " | %16"PRIxPTR " %16"PRIxPTR " %16"PRIxPTR " (line %d)\n",
 			ruby_node_name(type),
+			(intptr_t) node,
 			(intptr_t) node->u1.value, (intptr_t) node->u2.value, (intptr_t) node->u3.value,
 			nd_line(node));
 	}
@@ -967,7 +1041,7 @@ void resolve_syms_ords(VALUE data, NODEObjAddresses *relocs)
 	{
 		VALUE r_sym = RARRAY_PTR(tbl_val)[i];
 		if (TYPE(r_sym) == T_STRING)
-		{
+		{	/* Created symbol will be immune to garbage collector */
 			relocs->syms_adr[i] = rb_intern(RSTRING_PTR(r_sym));
 		}
 		else if (TYPE(r_sym) == T_FIXNUM)
@@ -984,6 +1058,7 @@ void resolve_syms_ords(VALUE data, NODEObjAddresses *relocs)
 void resolve_lits_ords(VALUE data, NODEObjAddresses *relocs)
 {
 	VALUE tbl_val = rb_hash_aref(data, ID2SYM(rb_intern("literals")));
+	int i;
 	if (tbl_val == Qnil)
 	{
 		rb_raise(rb_eArgError, "Cannot find literals table");
@@ -994,6 +1069,18 @@ void resolve_lits_ords(VALUE data, NODEObjAddresses *relocs)
 	}
 	relocs->lits_adr = RARRAY_PTR(tbl_val);
 	relocs->lits_len = RARRAY_LEN(tbl_val);
+	/* Mark all symbols as "immortal" (i.e. not collectable
+	   by Ruby GC): some of them can be used in the syntax tree!
+	   See the presentation of Narihiro Nakamura, author of 
+	   symbol GC in Ruby 2.x for details
+	   http://www.slideshare.net/authorNari/symbol-gc  */
+	for (i = 0; i < relocs->lits_len; i++)
+	{
+		if (TYPE(relocs->lits_adr[i]) == T_SYMBOL)
+		{
+			SYM2ID(relocs->lits_adr[i]);
+		}
+	}
 }
 
 void resolve_gvars_ords(VALUE data, NODEObjAddresses *relocs)
@@ -1309,11 +1396,12 @@ static VALUE check_hash_magic(VALUE data)
 static VALUE m_nodedump_from_memory(VALUE self, VALUE dump)
 {
 	VALUE cMarshal, data, val, val_relocs;
+	VALUE gc_was_disabled;
 	int num_of_nodes;
 	NODEObjAddresses *relocs;
 	/* DISABLE GARBAGE COLLECTOR (required for stable loading
 	   of large node trees */
-	rb_gc_disable();
+	gc_was_disabled = rb_gc_disable();
 	/* Wrap struct for relocations */
 	val_relocs = Data_Make_Struct(cNodeObjAddresses, NODEObjAddresses,
 		NULL, NODEObjAddresses_free, relocs); // This data envelope cannot exist without NODE
@@ -1368,8 +1456,11 @@ static VALUE m_nodedump_from_memory(VALUE self, VALUE dump)
 	rb_iv_set(self, "@node", (VALUE) relocs->nodes_adr[0]);
 	rb_iv_set(self, "@num_of_nodes", INT2FIX(num_of_nodes));
 	rb_iv_set(self, "@obj_addresses", val_relocs);
-	rb_gc_enable();
-	rb_gc_start();
+	if (gc_was_disabled == Qfalse)
+	{
+		rb_gc_enable();
+		rb_gc_start();
+	}
 	return self;
 }
 
@@ -1542,10 +1633,10 @@ static VALUE m_nodedump_compile(VALUE self)
  */
 static VALUE m_nodedump_from_source(VALUE self, VALUE file)
 {
-	VALUE line = INT2FIX(1), f, node, filepath;
+	VALUE line = INT2FIX(1), f, node, filepath, gc_was_disabled;
 	const char *fname;
 
-	rb_gc_disable();
+	gc_was_disabled = rb_gc_disable();
 	rb_secure(1);
 	FilePathValue(file);
 	fname = StringValueCStr(file);
@@ -1557,12 +1648,15 @@ static VALUE m_nodedump_from_source(VALUE self, VALUE file)
 	/* Create node from the source */
 	f = rb_file_open_str(file, "r");
 	node = (VALUE) rb_compile_file(fname, f, NUM2INT(line));
-	rb_gc_enable();
-	rb_iv_set(self, "@node", node);
+	rb_iv_set(self, "@node", node);	
 	if ((void *) node == NULL)
 	{
 		rb_raise(rb_eArgError, "Error during string parsing");
 	}
+	if (gc_was_disabled == Qfalse)
+	{
+		rb_gc_enable();
+	}
 	return self;
 }
 
@@ -1571,9 +1665,10 @@ static VALUE m_nodedump_from_source(VALUE self, VALUE file)
  */
 static VALUE m_nodedump_from_string(VALUE self, VALUE str)
 {
-	VALUE line = INT2FIX(1), node;
+	VALUE line = INT2FIX(1), node, gc_was_disabled;
 	const char *fname = "STRING";
 	Check_Type(str, T_STRING);
+	gc_was_disabled = rb_gc_disable();	
 	rb_secure(1);
 	/* Create empty information about the file */
 	rb_iv_set(self, "@nodename", rb_str_new2("<main>"));
@@ -1588,11 +1683,13 @@ static VALUE m_nodedump_from_string(VALUE self, VALUE str)
 		rb_iv_set(self, "@filepath", rb_str_new2("<compiled>"));
 	}
 	/* Create node from the string */
-	rb_gc_disable();
 	node = (VALUE) rb_compile_string(fname, str, NUM2INT(line));
 	rb_iv_set(self, "@node", node);
-	rb_gc_enable();
-	rb_gc_start();
+	if (gc_was_disabled == Qfalse)
+	{
+		rb_gc_enable();
+		rb_gc_start();
+	}
 	if ((void *) node == NULL)
 	{
 		rb_raise(rb_eArgError, "Error during string parsing");
@@ -1744,9 +1841,9 @@ static VALUE m_nodedump_to_hash(VALUE self)
 {
 	NODE *node = RNODE(rb_iv_get(self, "@node"));
 	NODEInfo *info;
-	VALUE ans, num, val_info;
+	VALUE ans, num, val_info, gc_was_disabled;
 	// DISABLE GARBAGE COLLECTOR (important for dumping)
-	rb_gc_disable();
+	gc_was_disabled = rb_gc_disable();
 	// Convert the node to the form with relocs (i.e. the information about node)
 	// if such form is not present
 	val_info = rb_iv_get(self, "@nodeinfo");
@@ -1771,10 +1868,153 @@ static VALUE m_nodedump_to_hash(VALUE self)
 		ans = rb_iv_get(self, "@nodehash");
 	}
 	// ENABLE GARBAGE COLLECTOR (important for dumping)
-	rb_gc_enable();
+	if (gc_was_disabled == Qfalse)
+	{
+		rb_gc_enable();
+	}
 	return ans;
 }
 
+
+VALUE m_node_to_ary(NODE *node)
+{
+	int i, type, ut[3];
+	VALUE uref[3];
+	VALUE entry = rb_ary_new();
+	/* Special case: NULL node */
+	if (node == NULL)
+	{
+		return Qnil;
+	}
+	/* Save node name */
+	type = nd_type(node);
+	rb_ary_push(entry, ID2SYM(rb_intern(ruby_node_name(type))));
+
+	ut[0] = nodes_ctbl[type * 3];
+	ut[1] = nodes_ctbl[type * 3 + 1];
+	ut[2] = nodes_ctbl[type * 3 + 2];
+
+	uref[0] = node->u1.value;
+	uref[1] = node->u2.value;
+	uref[2] = node->u3.value;
+
+
+	for (i = 0; i < 3; i++)
+	{
+		if (ut[i] == NT_NODE)
+		{
+			if (nd_type(node) != NODE_OP_ASGN2 || i != 2)
+			{
+				rb_ary_push(entry, m_node_to_ary(RNODE(uref[i])));
+			}
+			else
+			{
+				VALUE child = rb_ary_new();
+				if (ut[i] != 0 && TYPE(ut[i]) != T_NODE)
+					rb_raise(rb_eArgError, "print_node: broken node 0x%s", RSTRING_PTR(value_to_str(ut[i])));
+				rb_ary_push(child, ID2SYM(rb_intern("NODE_OP_ASGN2")));
+				rb_ary_push(child, LONG2NUM((intptr_t) RNODE(uref[i])->u1.value));
+				rb_ary_push(child, LONG2NUM((intptr_t) RNODE(uref[i])->u2.value));
+				rb_ary_push(child, LONG2NUM((intptr_t) RNODE(uref[i])->u3.value));
+				rb_ary_push(entry, child);
+			}
+		}
+		else if (ut[i] == NT_VALUE)
+		{
+			rb_ary_push(entry, uref[i]);
+		}
+		else if (ut[i] == NT_ID)
+		{
+			rb_ary_push(entry, ID2SYM( (ID) uref[i]));
+		}
+		else if (ut[i] == NT_LONG)
+		{
+			rb_ary_push(entry, LONG2NUM( (intptr_t) uref[i]));
+		}
+		else if (ut[i] == NT_NULL)
+		{
+			rb_ary_push(entry, Qnil);
+		}
+		else if (ut[i] == NT_ARGS)
+		{
+			VALUE rargs = rb_hash_new();
+			VALUE rargs_env = rb_ary_new();
+#ifdef USE_RB_ARGS_INFO
+			ID id;
+			struct rb_args_info *args = (void *) uref[i];
+
+			rb_hash_aset(rargs, ID2SYM(rb_intern("pre_init")), m_node_to_ary(args->pre_init));
+			rb_hash_aset(rargs, ID2SYM(rb_intern("post_init")), m_node_to_ary(args->post_init));
+
+			id = args->first_post_arg;
+			rb_hash_aset(rargs, ID2SYM(rb_intern("first_post_arg")), (id) ? ID2SYM(id) : Qnil);
+			id = args->rest_arg;
+			rb_hash_aset(rargs, ID2SYM(rb_intern("rest_arg")), (id) ? ID2SYM(id) : Qnil);
+			id = args->block_arg;
+			rb_hash_aset(rargs, ID2SYM(rb_intern("block_arg")), (id) ? ID2SYM(id) : Qnil);
+
+			rb_hash_aset(rargs, ID2SYM(rb_intern("kw_args")), m_node_to_ary(args->kw_args));
+			rb_hash_aset(rargs, ID2SYM(rb_intern("kw_rest_arg")), m_node_to_ary(args->kw_rest_arg));
+			rb_hash_aset(rargs, ID2SYM(rb_intern("opt_args")), m_node_to_ary(args->opt_args));
+#endif
+			rb_ary_push(rargs_env, ID2SYM(rb_intern("ARGS")));
+			rb_ary_push(rargs_env, rargs);
+			rb_ary_push(entry, rargs_env);
+		}
+		else if (ut[i] == NT_IDTABLE)
+		{
+			VALUE ridtbl = rb_ary_new();
+			VALUE idtbl_ary = rb_ary_new();
+			int j, len;
+
+			ID *idtbl = (ID *) uref[i];
+			len = (uref[i]) ? *idtbl++ : 0;
+			for (j = 0; j < len; j++)
+			{
+				ID sym = *idtbl++;
+				VALUE val = ID2SYM(sym);
+				rb_ary_push(idtbl_ary, val);
+			}
+			rb_ary_push(ridtbl, ID2SYM(rb_intern("IDTABLE")));
+			rb_ary_push(ridtbl, idtbl_ary);
+			rb_ary_push(entry, ridtbl);
+		}
+		else if (ut[i] == NT_ENTRY)
+		{
+			struct rb_global_entry *gentry;
+			gentry = (struct rb_global_entry *) uref[i];
+			rb_ary_push(entry, ID2SYM(gentry->id));
+		}
+		else
+		{
+			rb_ary_push(entry, ID2SYM(rb_intern("UNKNOWN")));
+		}
+	}
+	return entry;
+}
+
+/*
+ * call-seq:
+ *   obj.to_a
+ *
+ * Converts node to the array (mainly to allow exploration of AST
+ * by the user). It shows information about rb_args_info and
+ * ID *tbl that are not displayed by NodeMarshal#dump_tree and
+ * NodeMarshal#dump_tree_short.
+ */
+static VALUE m_nodedump_to_a(VALUE self)
+{
+	NODE *node = RNODE(rb_iv_get(self, "@node"));
+	VALUE gc_was_disabled = rb_gc_disable();
+	VALUE ary = m_node_to_ary(node);
+	if (gc_was_disabled == Qfalse)
+	{
+		rb_gc_enable();
+	}
+	return ary;
+}
+
+
 /*
  * call-seq:
  *   obj.to_bin
@@ -1839,6 +2079,7 @@ static VALUE m_nodedump_inspect(VALUE self)
 			"      idtabs hash len (ID tables):     %d\n"
 			"      gentries hash len (Global vars): %d\n"
 			"      nodes hash len (Nodes):          %d\n"
+			"      pnodes hash len (Parent nodes):  %d\n"			
 #ifdef USE_RB_ARGS_INFO
 			"      args hash len (args info):       %d\n"
 #endif
@@ -1847,7 +2088,8 @@ static VALUE m_nodedump_inspect(VALUE self)
 			FIX2INT(rb_funcall(ninfo->lits.vals, rb_intern("length"), 0)),
 			FIX2INT(rb_funcall(ninfo->idtabs.vals, rb_intern("length"), 0)),
 			FIX2INT(rb_funcall(ninfo->gentries.vals, rb_intern("length"), 0)),
-			FIX2INT(rb_funcall(ninfo->nodes.vals, rb_intern("length"), 0))
+			FIX2INT(rb_funcall(ninfo->nodes.vals, rb_intern("length"), 0)),
+			FIX2INT(rb_funcall(ninfo->pnodes.vals, rb_intern("length"), 0))			
 #ifdef USE_RB_ARGS_INFO
 			,
 			FIX2INT(rb_funcall(ninfo->args.vals, rb_intern("length"), 0))
@@ -2024,8 +2266,11 @@ void Init_nodemarshal()
 
 	rb_define_method(cNodeMarshal, "initialize", RUBY_METHOD_FUNC(m_nodedump_init), 2);
 	rb_define_method(cNodeMarshal, "to_hash", RUBY_METHOD_FUNC(m_nodedump_to_hash), 0);
+	rb_define_method(cNodeMarshal, "to_h", RUBY_METHOD_FUNC(m_nodedump_to_hash), 0);
 	rb_define_method(cNodeMarshal, "to_bin", RUBY_METHOD_FUNC(m_nodedump_to_bin), 0);
 	rb_define_method(cNodeMarshal, "to_text", RUBY_METHOD_FUNC(m_nodedump_to_text), 0);
+	rb_define_method(cNodeMarshal, "to_a", RUBY_METHOD_FUNC(m_nodedump_to_a), 0);
+	rb_define_method(cNodeMarshal, "to_ary", RUBY_METHOD_FUNC(m_nodedump_to_a), 0);
 	rb_define_method(cNodeMarshal, "dump_tree", RUBY_METHOD_FUNC(m_nodedump_parser_dump_tree), 0);
 	rb_define_method(cNodeMarshal, "dump_tree_short", RUBY_METHOD_FUNC(m_nodedump_dump_tree_short), 0);
 	rb_define_method(cNodeMarshal, "compile", RUBY_METHOD_FUNC(m_nodedump_compile), 0);

data/ext/node-marshal/nodeinfo.c

@@ -18,7 +18,18 @@
 #include <ruby/version.h>
 #include "nodedump.h"
 
-// Information about nodes types
+/* Information about nodes types
+
+   NODE_ARRAY contains an undocumented feature: if an array contains
+   more than 1 element the 2nd child of 2nd element will contain
+   a reference to the last element of the array (and have NT_NODE
+   not NT_LONG type)
+   Another case is Hash: every 2nd element of NODE_ARRAY chain
+   has NT_NODE type (see nodedump.c for details)
+
+   Such child is ignored by GC because there is a reference to it
+   from another place of Ruby AST.
+ */
 static int nodes_child_info[][4] = 
 {
 	{NODE_BLOCK,    NT_NODE, NT_NULL, NT_NODE},
@@ -77,7 +88,7 @@ static int nodes_child_info[][4] =
 
 	{NODE_SUPER, NT_NULL, NT_NULL, NT_NODE},
 	{NODE_ZSUPER, NT_NULL, NT_NULL, NT_NULL},
-	{NODE_ARRAY,  NT_NODE, NT_LONG, NT_NODE},
+	{NODE_ARRAY,  NT_NODE, NT_LONG, NT_NODE}, /* 2nd child has undocumented variants (see above) */
 	{NODE_VALUES, NT_NODE, NT_LONG, NT_NODE},
 	{NODE_ZARRAY, NT_NULL, NT_NULL, NT_NULL},
 
@@ -582,7 +593,7 @@ void init_nodes_table(int *nodes_ctbl, int num_of_entries)
 		check_nodes_child_info(pos);
 	}
 	/* Initialize output array by NT_UNKNOWN (if node is not defined
-      in the input table the types of its childs are unknown) */	
+	   in the input table the types of its childs are unknown) */	
 	for (i = 0; i < num_of_entries * 3; i++)
 	{
 		nodes_ctbl[i] = NT_UNKNOWN;

data/lib/node-marshal.rb

@@ -84,8 +84,8 @@ EOS
 
 	# call-seq:
 	#   NodeMarshal::compile_rb_file(outfile, inpfile, opts)
-	# 
-   # Reads +.rb+ file (Ruby source) and compiles it to .rb file containing
+	#
+	# Reads +.rb+ file (Ruby source) and compiles it to .rb file containing
 	# compressed AST node and its loader. This functions is an envelope for
 	# NodeMarshal#to_compiled_rb
 	def self.compile_rb_file(outfile, inpfile, *args)
@@ -167,7 +167,7 @@ EOS
 				"q#{pos}"
 			end
 		end
-		[symbols_ary, aliases_ary].transpose.to_h		
+		[symbols_ary, aliases_ary].transpose.to_h
 	end
 
 	# call-seq:

data/test/test_base.rb

@@ -36,7 +36,7 @@ def fact(n)
 end
 ni.map {|x| fact(x) }
 EOS
-		assert_node_compiler(program)		
+		assert_node_compiler(program)
 	end
 
 	# Simple ROT13 task that combines several language construction
@@ -183,6 +183,13 @@ EOS
 		assert_node_compiler(program)
 	end
 
+	# Tests correct processing of nodes with "#{expr}"--style strings
+	# (correct processing of NODE_ARRAY chain inside NODE_DSTR node)
+	def test_dstr
+		program = 'a = "#{1} and #{2*2} and #{3*3} and #{4*4}"'
+		assert_node_compiler(program)
+	end
+
 	# Check the reaction on the parsing errors during the node creation
 	# In the case of syntax error ArgumentError exception should be generated
 	def test_syntax_error
@@ -203,7 +210,7 @@ EOS
 		rescue ArgumentError
 			test_passed = true
 		end
-		assert_equal(test_passed, true);	
+		assert_equal(test_passed, true);
 	end
 
 	# Part of the tests: compare result of direct usage of eval

data/test/test_complex.rb

@@ -120,6 +120,7 @@ class TestComplex < Test::Unit::TestCase
 		tree_str = tree_src.to_s
 		node = NodeMarshal.new(:srcmemory, tree_str)
 		tree_bin = node.to_bin
+		puts node.inspect
 
 		File.open('node.bin', 'wb') {|fp| fp << tree_bin }
 		puts "  Source code size: %d bytes" % tree_str.length

data/test/test_qcall.rb

@@ -39,13 +39,14 @@ puts "'#{b&.owner_info&.address}'"
 		ver = (ver[0] + ver[2] + ver[4]).to_i
 		if ver >= 230
 			node = NodeMarshal.new(:srcmemory, qcall_program)
+			node.show_offsets = true
 			bindump =  node.to_bin
 			node = NodeMarshal.new(:binmemory, bindump)
 			res_node = node.compile.eval
 			res_text = eval(qcall_program)
 			assert_equal(res_text, res_node)
 		else
-			assert_true(false, "Ruby 2.3 or higher is required for &. operator test")
+			assert_equal(false, true, "Ruby 2.3 or higher is required for &. operator test")
 		end
 	end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: node-marshal
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Alexey Voskov
@@ -9,7 +9,7 @@ autorequire:
 bindir:
 - bin
 cert_chain: []
-date: 2016-01-11 00:00:00.000000000 Z
+date: 2016-03-16 00:00:00.000000000 Z
 dependencies: []
 description: "This gem is designed for transformation of Ruby source code (eiher in
   the form of files or strings) to the \nRuby nodes (syntax trees) used by Ruby MRI
@@ -68,7 +68,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Transforms Ruby sources to binary nodes (trees) that can be saved and loaded