ruby-dev

成瀬です。

懸案の inspect を、田中さんの示唆を基に変えるパッチです。

意図としては、p と irb で生の文字列が出るようにすることを第一にし、それ
以外のケースでエスケープされてしまうことはやむをえないとしました。

手法としては inspect_accumulate(str) と文字列を与え、その文字列と対象文
字列のエンコーディングが等しければそのまま、異なっていればエスケープしま
す。inspect_accumulate が定義されていなければ、それより先のオブジェクト
では inspect を用います。

-- 
NARUSE, Yui  <naruse@airemix.com>
DBDB A476 FDBD 9450 02CD 0EFC BCE3 C388 472E C1EA

Attachments (1)

inspect.patch (13.7 KB, text/x-diff)

--- array.c	(revision 15560)
+++ array.c	(working copy)
@@ -1307,23 +1307,34 @@ rb_ary_join_m(int argc, VALUE *argv, VAL
 }
 
 static VALUE
-inspect_ary(VALUE ary, VALUE dummy, int recur)
+inspect_ary(VALUE ary, VALUE result, int recur)
 {
     int tainted = OBJ_TAINTED(ary);
     long i;
-    VALUE s, str;
 
-    if (recur) return rb_tainted_str_new2("[...]");
-    str = rb_str_buf_new2("[");
+    if (recur) return rb_str_buf_cat_ascii(result, "[...]");
+    rb_str_buf_cat_ascii(result, "[");
     for (i=0; i<RARRAY_LEN(ary); i++) {
-	s = rb_inspect(RARRAY_PTR(ary)[i]);
-	if (OBJ_TAINTED(s)) tainted = Qtrue;
-	if (i > 0) rb_str_buf_cat2(str, ", ");
-	rb_str_buf_append(str, s);
-    }
-    rb_str_buf_cat2(str, "]");
-    if (tainted) OBJ_TAINT(str);
-    return str;
+	if (i > 0) rb_str_buf_cat_ascii(result, ", ");
+	rb_inspect_accumulate(RARRAY_PTR(ary)[i], result);
+    }
+    rb_str_buf_cat_ascii(result, "]");
+    OBJ_INFECT(result, ary);
+    return result;
+}
+
+/*
+ *  call-seq:
+ *     array.inspect_accumulate(str)  -> string
+ *
+ *  Create a printable version of <i>array</i>.
+ */
+
+static VALUE
+rb_ary_inspect_accumulate(VALUE ary, VALUE result)
+{
+    if (RARRAY_LEN(ary) == 0) return rb_str_buf_cat_ascii(result, "[]");
+    return rb_exec_recursive(inspect_ary, ary, result);
 }
 
 /*
@@ -1337,8 +1348,7 @@ inspect_ary(VALUE ary, VALUE dummy, int 
 static VALUE
 rb_ary_inspect(VALUE ary)
 {
-    if (RARRAY_LEN(ary) == 0) return rb_usascii_str_new2("[]");
-    return rb_exec_recursive(inspect_ary, ary, 0);
+    return rb_ary_inspect_accumulate(ary, rb_str_buf_new(0));
 }
 
 VALUE
@@ -3221,6 +3231,7 @@ Init_Array(void)
 
     rb_define_method(rb_cArray, "to_s", rb_ary_inspect, 0);
     rb_define_method(rb_cArray, "inspect", rb_ary_inspect, 0);
+    rb_define_method(rb_cArray, "inspect_accumulate", rb_ary_inspect_accumulate, 1);
     rb_define_method(rb_cArray, "to_a", rb_ary_to_a, 0);
     rb_define_method(rb_cArray, "to_ary", rb_ary_to_ary_m, 0);
     rb_define_method(rb_cArray, "frozen?",  rb_ary_frozen_p, 0);
--- hash.c	(revision 15560)
+++ hash.c	(working copy)
@@ -1145,37 +1145,50 @@ rb_hash_to_a(VALUE hash)
 }
 
 static int
-inspect_i(VALUE key, VALUE value, VALUE str)
+inspect_i(VALUE key, VALUE value, VALUE result)
 {
     VALUE str2;
 
     if (key == Qundef) return ST_CONTINUE;
-    if (RSTRING_LEN(str) > 1) {
-	rb_str_cat2(str, ", ");
+    if (*(RSTRING_END(result)-1) != '{') {
+	rb_str_buf_cat_ascii(result, ", ");
     }
-    str2 = rb_inspect(key);
-    rb_str_buf_append(str, str2);
-    OBJ_INFECT(str, str2);
-    rb_str_buf_cat2(str, "=>");
-    str2 = rb_inspect(value);
-    rb_str_buf_append(str, str2);
-    OBJ_INFECT(str, str2);
+    rb_inspect_accumulate(key, result);
+    rb_str_buf_cat_ascii(result, "=>");
+    rb_inspect_accumulate(value, result);
 
     return ST_CONTINUE;
 }
 
 static VALUE
-inspect_hash(VALUE hash, VALUE dummy, int recur)
+inspect_hash(VALUE hash, VALUE result, int recur)
 {
-    VALUE str;
 
-    if (recur) return rb_usascii_str_new2("{...}");
-    str = rb_str_buf_new2("{");
-    rb_hash_foreach(hash, inspect_i, str);
-    rb_str_buf_cat2(str, "}");
-    OBJ_INFECT(str, hash);
+    if (recur) return rb_str_buf_cat_ascii(result, "{...}");
+    rb_str_buf_cat_ascii(result, "{");
+    rb_hash_foreach(hash, inspect_i, result);
+    rb_str_buf_cat_ascii(result, "}");
+    OBJ_INFECT(result, hash);
+    return result;
+}
 
-    return str;
+/*
+ * call-seq:
+ *   hsh.to_s   => string
+ *   hsh.inspect  => string
+ *
+ * Return the contents of this hash as a string.
+ *
+ *     h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300  }
+ *     h.to_s   #=> "{\"a\"=>100, \"c\"=>300, \"d\"=>400}"
+ */
+
+static VALUE
+rb_hash_inspect_accumulate(VALUE hash, VALUE result)
+{
+    if (RHASH_EMPTY_P(hash))
+	return rb_str_buf_cat_ascii(result, "{}");
+    return rb_exec_recursive(inspect_hash, hash, result);
 }
 
 /*
@@ -1192,9 +1205,7 @@ inspect_hash(VALUE hash, VALUE dummy, in
 static VALUE
 rb_hash_inspect(VALUE hash)
 {
-    if (RHASH_EMPTY_P(hash))
-	return rb_usascii_str_new2("{}");
-    return rb_exec_recursive(inspect_hash, hash, 0);
+    return rb_hash_inspect_accumulate(hash, rb_str_buf_new(0));
 }
 
 /*
@@ -2560,6 +2571,7 @@ Init_Hash(void)
     rb_define_method(rb_cHash,"to_a", rb_hash_to_a, 0);
     rb_define_method(rb_cHash,"to_s", rb_hash_inspect, 0);
     rb_define_method(rb_cHash,"inspect", rb_hash_inspect, 0);
+    rb_define_method(rb_cHash,"inspect_accumulate", rb_hash_inspect_accumulate, 1);
 
     rb_define_method(rb_cHash,"==", rb_hash_equal, 1);
     rb_define_method(rb_cHash,"[]", rb_hash_aref, 1);
--- io.c	(revision 15560)
+++ io.c	(working copy)
@@ -4556,7 +4556,10 @@ rb_f_puts(int argc, VALUE *argv)
 void
 rb_p(VALUE obj) /* for debug print within C code */
 {
-    rb_io_write(rb_stdout, rb_obj_as_string(rb_inspect(obj)));
+    VALUE str = rb_str_buf_new(0);
+    rb_enc_associate(str, rb_default_external_encoding());
+    rb_inspect_accumulate(obj, str);
+    rb_io_write(rb_stdout, str);
     rb_io_write(rb_stdout, rb_default_rs);
 }
 
--- lib/irb.rb	(revision 15560)
+++ lib/irb.rb	(working copy)
@@ -298,7 +298,7 @@ module IRB
 
     def output_value
       if @context.inspect?
-        printf @context.return_format, @context.last_value.inspect
+        printf @context.return_format, @context.last_value.inspect_accumulate("".force_encoding(Encoding.default_external))
       else
         printf @context.return_format, @context.last_value
       end
--- object.c	(revision 15560)
+++ object.c	(working copy)
@@ -32,7 +32,7 @@ VALUE rb_cNilClass;
 VALUE rb_cTrueClass;
 VALUE rb_cFalseClass;
 
-static ID id_eq, id_eql, id_match, id_inspect, id_init_copy;
+static ID id_eq, id_eql, id_match, id_inspect, id_inspect_accumulate, id_init_copy;
 
 /*
  *  call-seq:
@@ -313,6 +313,12 @@ rb_inspect(VALUE obj)
     return rb_obj_as_string(rb_funcall(obj, id_inspect, 0, 0));
 }
 
+VALUE
+rb_inspect_accumulate(VALUE obj, VALUE result)
+{
+    return rb_obj_as_string(rb_funcall(obj, id_inspect_accumulate, 1, result));
+}
+
 static int
 inspect_i(ID id, VALUE value, VALUE str)
 {
@@ -324,16 +330,15 @@ inspect_i(ID id, VALUE value, VALUE str)
     if (!rb_is_instance_id(id)) return ST_CONTINUE;
     if (RSTRING_PTR(str)[0] == '-') { /* first element */
 	RSTRING_PTR(str)[0] = '#';
-	rb_str_cat2(str, " ");
+	rb_str_buf_cat_ascii(str, " ");
     }
     else {
-	rb_str_cat2(str, ", ");
+	rb_str_buf_cat_ascii(str, ", ");
     }
     ivname = rb_id2name(id);
     rb_str_cat2(str, ivname);
-    rb_str_cat2(str, "=");
-    str2 = rb_inspect(value);
-    rb_str_append(str, str2);
+    rb_str_buf_cat_ascii(str, "=");
+    rb_inspect_accumulate(value, str);
     OBJ_INFECT(str, str2);
 
     return ST_CONTINUE;
@@ -343,18 +348,67 @@ static VALUE
 inspect_obj(VALUE obj, VALUE str, int recur)
 {
     if (recur) {
-	rb_str_cat2(str, " ...");
+	rb_str_buf_cat_ascii(str, " ...");
     }
     else {
 	rb_ivar_foreach(obj, inspect_i, str);
     }
-    rb_str_cat2(str, ">");
+    rb_str_buf_cat_ascii(str, ">");
     RSTRING_PTR(str)[0] = '#';
     OBJ_INFECT(str, obj);
 
     return str;
 }
 
+static VALUE
+obj_ivar_inspect(VALUE obj, VALUE result)
+{
+    int has_ivar = 0;
+    VALUE *ptr = ROBJECT_PTR(obj);
+    long len = ROBJECT_LEN(obj);
+    long i;
+
+    for (i = 0; i < len; i++) {
+	if (ptr[i] != Qundef) {
+	    has_ivar = 1;
+	    break;
+	}
+    }
+
+    if (has_ivar) {
+	char *c;
+
+	c = rb_obj_classname(obj);
+	rb_str_append(result, rb_sprintf("-<%s:%p", c, (void*)obj));
+	return rb_exec_recursive(inspect_obj, obj, result);
+    }
+    return 0;
+}
+
+/*
+ *  call-seq:
+ *     obj.inspect_accumulate(str)   => string
+ *  
+ *  Returns a string containing a human-readable representation of
+ *  <i>obj</i>. If not overridden, uses the <code>to_s</code> method to
+ *  generate the string.
+ */
+
+static VALUE
+rb_obj_inspect_accumulate(VALUE obj, VALUE result)
+{
+    if (TYPE(obj) == T_OBJECT) {
+	VALUE meth = rb_obj_method(obj, ID2SYM(id_inspect));
+	VALUE owner = rb_funcall(meth, rb_intern("owner"), 0, 0);
+	if (owner == rb_mKernel) {
+	    VALUE str = obj_ivar_inspect(obj, result);
+	    if (str)
+		return str;
+	}
+    }
+    return rb_str_append(result, rb_funcall(obj, id_inspect, 0, 0));
+}
+
 /*
  *  call-seq:
  *     obj.inspect   => string
@@ -367,37 +421,17 @@ inspect_obj(VALUE obj, VALUE str, int re
  *     Time.new.inspect                 #=> "Wed Apr 09 08:54:39 CDT 2003"
  */
 
-
 static VALUE
 rb_obj_inspect(VALUE obj)
 {
-
     if (TYPE(obj) == T_OBJECT) {
-        int has_ivar = 0;
-        VALUE *ptr = ROBJECT_PTR(obj);
-        long len = ROBJECT_LEN(obj);
-        long i;
-
-        for (i = 0; i < len; i++) {
-            if (ptr[i] != Qundef) {
-                has_ivar = 1;
-                break;
-            }
-        }
-
-        if (has_ivar) {
-            VALUE str;
-            char *c;
-
-            c = rb_obj_classname(obj);
-            str = rb_sprintf("-<%s:%p", c, (void*)obj);
-            return rb_exec_recursive(inspect_obj, obj, str);
-        }
+        VALUE str = obj_ivar_inspect(obj, rb_str_buf_new(0));
+        if (str)
+	    return str;
     }
     return rb_funcall(obj, rb_intern("to_s"), 0, 0);
 }
 
-
 /*
  *  call-seq:
  *     obj.instance_of?(class)    => true or false
@@ -2403,6 +2437,7 @@ Init_Object(void)
 
     rb_define_method(rb_mKernel, "to_s", rb_any_to_s, 0);
     rb_define_method(rb_mKernel, "inspect", rb_obj_inspect, 0);
+    rb_define_method(rb_mKernel, "inspect_accumulate", rb_obj_inspect_accumulate, 1);
     rb_define_method(rb_mKernel, "methods", rb_obj_methods, -1);
     rb_define_method(rb_mKernel, "singleton_methods", rb_obj_singleton_methods, -1); /* in class.c */
     rb_define_method(rb_mKernel, "protected_methods", rb_obj_protected_methods, -1);
@@ -2524,5 +2559,6 @@ Init_Object(void)
     id_eql = rb_intern("eql?");
     id_match = rb_intern("=~");
     id_inspect = rb_intern("inspect");
+    id_inspect_accumulate = rb_intern("inspect_accumulate");
     id_init_copy = rb_intern("initialize_copy");
 }
--- string.c	(revision 15560)
+++ string.c	(working copy)
@@ -3639,24 +3639,19 @@ prefix_escape(VALUE str, int c, rb_encod
 
 /*
  * call-seq:
- *   str.inspect   => string
+ *   str.inspect_accumulate(str)   => string
  *
  * Returns a printable version of _str_, surrounded by quote marks,
  * with special characters escaped.
- *
- *    str = "hello"
- *    str[3] = "\b"
- *    str.inspect       #=> "\"hel\bo\""
  */
 
 VALUE
-rb_str_inspect(VALUE str)
+rb_str_inspect_accumulate(VALUE str, VALUE result)
 {
-    rb_encoding *enc = STR_ENC_GET(str);
+    rb_encoding *enc = STR_ENC_GET(result);
     char *p, *pend;
-    VALUE result = rb_str_buf_new2("");
 
-    rb_enc_associate(result, enc);
+    if (!enc || enc != STR_ENC_GET(str)) enc = rb_usascii_encoding();
     str_cat_char(result, '"', enc);
     p = RSTRING_PTR(str); pend = RSTRING_END(str);
     while (p < pend) {
@@ -3731,6 +3726,23 @@ rb_str_inspect(VALUE str)
     OBJ_INFECT(result, str);
     return result;
 }
+/*
+ * call-seq:
+ *   str.inspect   => string
+ *
+ * Returns a printable version of _str_, surrounded by quote marks,
+ * with special characters escaped.
+ *
+ *    str = "hello"
+ *    str[3] = "\b"
+ *    str.inspect       #=> "\"hel\bo\""
+ */
+
+VALUE
+rb_str_inspect(VALUE str)
+{
+    return rb_str_inspect_accumulate(str, rb_str_buf_new(0));
+}
 
 #define IS_EVSTR(p,e) ((p) < (e) && (*(p) == '$' || *(p) == '@' || *(p) == '{'))
 
@@ -6427,6 +6439,7 @@ Init_String(void)
     rb_define_method(rb_cString, "to_s", rb_str_to_s, 0);
     rb_define_method(rb_cString, "to_str", rb_str_to_s, 0);
     rb_define_method(rb_cString, "inspect", rb_str_inspect, 0);
+    rb_define_method(rb_cString, "inspect_accumulate", rb_str_inspect_accumulate, 1);
     rb_define_method(rb_cString, "dump", rb_str_dump, 0);
 
     rb_define_method(rb_cString, "upcase", rb_str_upcase, 0);
--- struct.c	(revision 15560)
+++ struct.c	(working copy)
@@ -477,45 +477,59 @@ rb_struct_each_pair(VALUE s)
 }
 
 static VALUE
-inspect_struct(VALUE s, VALUE dummy, int recur)
+inspect_struct(VALUE s, VALUE result, int recur)
 {
     char *cname = rb_class2name(rb_obj_class(s));
-    VALUE str, members;
+    VALUE members;
     long i;
 
     if (recur) {
-	return rb_sprintf("#<struct %s:...>", cname);
+	return rb_str_append(result, rb_sprintf("#<struct %s:...>", cname));
     }
 
     members = rb_struct_members(s);
     if (cname[0] == '#') {
-	str = rb_str_new2("#<struct ");
+	rb_str_buf_cat_ascii(result, "#<struct ");
     }
     else {
-	str = rb_sprintf("#<struct %s ", cname);
+	rb_str_append(result, rb_sprintf("#<struct %s ", cname));
     }
     for (i=0; i<RSTRUCT_LEN(s); i++) {
 	VALUE slot;
 	ID id;
 
 	if (i > 0) {
-	    rb_str_cat2(str, ", ");
+	    rb_str_buf_cat_ascii(result, ", ");
 	}
 	slot = RARRAY_PTR(members)[i];
 	id = SYM2ID(slot);
 	if (rb_is_local_id(id) || rb_is_const_id(id)) {
-	    rb_str_append(str, rb_id2str(id));
+	    rb_str_append(result, rb_id2str(id));
 	}
 	else {
-	    rb_str_append(str, rb_inspect(slot));
+	    rb_str_append(result, rb_inspect_accumulate(slot));
 	}
-	rb_str_cat2(str, "=");
-	rb_str_append(str, rb_inspect(RSTRUCT_PTR(s)[i]));
+	rb_str_buf_cat_ascii(result, "=");
+	rb_str_append(result, rb_inspect_accumulate(RSTRUCT_PTR(s)[i]));
     }
-    rb_str_cat2(str, ">");
-    OBJ_INFECT(str, s);
+    rb_str_buf_cat_ascii(result, ">");
+    OBJ_INFECT(result, s);
+
+    return result;
+}
+
+/*
+ * call-seq:
+ *   struct.to_s      => string
+ *   struct.inspect   => string
+ *
+ * Describe the contents of this struct in a string.
+ */
 
-    return str;
+static VALUE
+rb_struct_inspect_accumulate(VALUE s, VALUE result)
+{
+    return rb_exec_recursive(inspect_struct, s, result);
 }
 
 /*
@@ -529,7 +543,7 @@ inspect_struct(VALUE s, VALUE dummy, int
 static VALUE
 rb_struct_inspect(VALUE s)
 {
-    return rb_exec_recursive(inspect_struct, s, 0);
+    return rb_struct_inspect_accumulate(s, rb_str_buf_new(0));
 }
 
 /*

Thread

Prev Next

In This Thread

Prev Next