[Feature #17316] Add Object#instance_variable_set_unless_defined

Author: nobu

object.c

@@ -3046,6 +3046,52 @@ rb_obj_ivar_defined(VALUE obj, VALUE iv)
     return rb_ivar_defined(obj, id);
 }
 
+/*
+ *  call-seq:
+ *     obj.instance_variable_set_unless_defined(symbol, value) -> value
+ *     obj.instance_variable_set_unless_defined(string, value) -> value
+ *     obj.instance_variable_set_unless_defined(symbol) {|symbol| ...} -> value
+ *     obj.instance_variable_set_unless_defined(string) {|symbol| ...} -> value
+ *
+ *  Returns the value of the given instance variable if the instance
+ *  variable is set.  Otherwise if it is not set, sets that instance
+ *  variable to the given +value+ or the result of the given block.
+ *  String arguments are converted to symbols.
+ *
+ *     class Fred
+ *       def initialize(p1, p2)
+ *         @a, @b = p1, p2
+ *       end
+ *     end
+ *     fred = Fred.new('cat', nil)
+ *     fred.instance_variable_set_unless_defined(:@a, "dog")  #=> "cat"
+ *     fred.instance_variable_set_unless_defined(:@b, 99)     #=> nil
+ *     fred.instance_variable_defined?("@c")                  #=> false
+ *     fred.instance_variable_set_unless_defined(:@c, "grey") #=> "grey"
+ *     fred.instance_variable_get("@c")                       #=> "grey"
+ */
+static VALUE
+rb_obj_ivar_set_undef(int argc, VALUE *argv, VALUE obj)
+{
+    int arity = rb_block_given_p() ? 1 : 2;
+    rb_check_arity(argc, arity, arity);
+    VALUE iv = argv[0];
+    VALUE v;
+    ID id = id_for_var(obj, iv, instance);
+
+    if (id) {
+        if (!UNDEF_P(v = rb_ivar_lookup(obj, id, Qundef))) return v;
+        iv = ID2SYM(id);
+    }
+    else if (!id) {
+        iv = rb_str_intern(iv);
+    }
+    v = argc > 1 ? argv[1] : rb_yield(iv);
+    rb_check_frozen(obj);
+    if (!id) id = rb_sym2id(iv);
+    return rb_ivar_set(obj, id, v);
+}
+
 /*
  *  call-seq:
  *     mod.class_variable_get(symbol)    -> obj
@@ -4532,6 +4578,7 @@ InitVM_Object(void)
     rb_define_method(rb_mKernel, "instance_variable_get", rb_obj_ivar_get, 1);
     rb_define_method(rb_mKernel, "instance_variable_set", rb_obj_ivar_set_m, 2);
     rb_define_method(rb_mKernel, "instance_variable_defined?", rb_obj_ivar_defined, 1);
+    rb_define_method(rb_mKernel, "instance_variable_set_unless_defined", rb_obj_ivar_set_undef, -1);
     rb_define_method(rb_mKernel, "remove_instance_variable",
                      rb_obj_remove_instance_variable, 1); /* in variable.c */
 

test/ruby/test_object.rb

@@ -280,6 +280,12 @@ def test_methods_prepend_singleton
     assert_equal([:foo], k.private_methods(false))
   end
 
+  class ToStrCounter
+    def initialize(str = "@foo") @str = str; @count = 0; end
+    def to_str; @count += 1; @str; end
+    def count; @count; end
+  end
+
   def test_instance_variable_get
     o = Object.new
     o.instance_eval { @foo = :foo }
@@ -291,9 +297,7 @@ def test_instance_variable_get
     assert_raise(NameError) { o.instance_variable_get("bar") }
     assert_raise(TypeError) { o.instance_variable_get(1) }
 
-    n = Object.new
-    def n.to_str; @count = defined?(@count) ? @count + 1 : 1; "@foo"; end
-    def n.count; @count; end
+    n = ToStrCounter.new
     assert_equal(:foo, o.instance_variable_get(n))
     assert_equal(1, n.count)
   end
@@ -308,9 +312,7 @@ def test_instance_variable_set
     assert_raise(NameError) { o.instance_variable_set("bar", 1) }
     assert_raise(TypeError) { o.instance_variable_set(1, 1) }
 
-    n = Object.new
-    def n.to_str; @count = defined?(@count) ? @count + 1 : 1; "@foo"; end
-    def n.count; @count; end
+    n = ToStrCounter.new
     o.instance_variable_set(n, :bar)
     assert_equal(:bar, o.instance_eval { @foo })
     assert_equal(1, n.count)
@@ -327,13 +329,33 @@ def test_instance_variable_defined
     assert_raise(NameError) { o.instance_variable_defined?("bar") }
     assert_raise(TypeError) { o.instance_variable_defined?(1) }
 
-    n = Object.new
-    def n.to_str; @count = defined?(@count) ? @count + 1 : 1; "@foo"; end
-    def n.count; @count; end
+    n = ToStrCounter.new
     assert_equal(true, o.instance_variable_defined?(n))
     assert_equal(1, n.count)
   end
 
+  def test_instance_variable_set_unless_defined
+    o = Object.new
+    o.instance_eval { @foo = :foo; @bar = nil }
+    called = nil
+    assert_equal(:foo, o.instance_variable_set_unless_defined(:@foo, :baz))
+    assert_equal(:foo, o.instance_variable_set_unless_defined(:@foo) {|v| called = v; :baz})
+    assert_equal(nil, called)
+    assert_equal(nil, o.instance_variable_set_unless_defined(:@bar, :bar))
+    assert_equal(nil, o.instance_variable_set_unless_defined(:@bar) {|v| called = v; :bar})
+    assert_equal(nil, called)
+    assert_equal(:baz, o.instance_variable_set_unless_defined(:@baz, :baz))
+    assert_equal(:baz, o.instance_variable_get(:@baz))
+    assert_equal(:qux, o.instance_variable_set_unless_defined(:@qux) {|v| called = v; :qux})
+    assert_equal(:qux, o.instance_variable_get(:@qux))
+    assert_equal(:@qux, called)
+    n = ToStrCounter.new("@quux")
+    assert_equal(:quux, o.instance_variable_set_unless_defined(n) {|v| called = v; :quux})
+    assert_equal(:quux, o.instance_variable_get(:@quux))
+    assert_equal(:@quux, called)
+    assert_equal(1, n.count)
+  end
+
   def test_remove_instance_variable
     { 'T_OBJECT' => Object.new,
       'T_CLASS,T_MODULE' => Class.new(Object),