blockenspiel 0.2.2-java → 0.3.0-java

data/lib/blockenspiel/impl.rb

@@ -81,11 +81,13 @@ module Blockenspiel
   
   module DSLSetupMethods
     
+    
+    # :stopdoc:
+    
     # Called when DSLSetupMethods extends a class.
     # This sets up the current class, and adds a hook that causes
-    # any subclass of the current class to also be set up.
+    # any subclass of the current class also to be set up.
     
-    # :stopdoc:
     def self.extended(klass_)
       unless klass_.instance_variable_defined?(:@_blockenspiel_module)
         _setup_class(klass_)
@@ -95,6 +97,7 @@ module Blockenspiel
         end
       end
     end
+    
     # :startdoc:
     
     
@@ -175,12 +178,7 @@ module Blockenspiel
       end
       @_blockenspiel_methods[name_] = delegate_
       unless @_blockenspiel_module.public_method_defined?(name_)
-        @_blockenspiel_module.module_eval("
-          def #{name_}(*params_, &block_)
-            val_ = ::Blockenspiel._target_dispatch(self, :#{name_}, params_, block_)
-            val_ == ::Blockenspiel::TARGET_MISMATCH ? super(*params_, &block_) : val_
-          end
-        ")
+        @_blockenspiel_module.module_eval("def #{name_}(*params_, &block_); val_ = ::Blockenspiel._target_dispatch(self, :#{name_}, params_, block_); ::Blockenspiel::NO_VALUE.equal?(val_) ? super(*params_, &block_) : val_; end\n")
       end
     end
     
@@ -229,6 +227,91 @@ module Blockenspiel
       end
     end
     
+    
+    # A DSL-friendly attr_accessor.
+    # 
+    # This creates the usual "name" and "name=" methods in the current
+    # class that can be used in the usual way. However, its implementation
+    # of the "name" method (the getter) also takes an optional parameter
+    # that causes it to behave as a setter. This is done because the usual
+    # setter syntax cannot be used in a parameterless block, since it is
+    # syntactically indistinguishable from a local variable assignment.
+    # The "name" method is exposed as a dsl_method.
+    # 
+    # For example:
+    # 
+    #  dsl_attr_accessor :foo
+    # 
+    # enables the following:
+    # 
+    #  my_block do |param|
+    #    param.foo = 1   # Usual setter syntax works
+    #    param.foo 2     # Alternate setter syntax also works
+    #    puts param.foo  # Usual getter syntax still works
+    #  end
+    #  
+    #  my_block do
+    #    # foo = 1       # Usual setter syntax does NOT work since it
+    #                    #   looks like a local variable assignment
+    #    foo 2           # Alternate setter syntax does work
+    #    puts foo        # Usual getter syntax still works
+    #  end
+    
+    def dsl_attr_accessor(*names_)
+      names_.each do |name_|
+        unless name_.kind_of?(::String) || name_.kind_of?(::Symbol)
+          raise ::TypeError, "#{name_.inspect} is not a symbol"
+        end
+        unless name_.to_s =~ /^[_a-zA-Z]\w+$/
+          raise ::NameError, "invalid attribute name #{name_.inspect}"
+        end
+        module_eval("def #{name_}(value_=::Blockenspiel::NO_VALUE); ::Blockenspiel::NO_VALUE.equal?(value_) ? @#{name_} : @#{name_} = value_; end\n")
+        alias_method("#{name_}=", name_)
+        dsl_method(name_)
+      end
+    end
+    
+    
+    # A DSL-friendly attr_writer.
+    # 
+    # This creates the usual "name=" method in the current class that can
+    # be used in the usual way. However, it also creates the method "name",
+    # which also functions as a setter (but not a getter). This is done
+    # because the usual setter syntax cannot be used in a parameterless
+    # block, since it is syntactically indistinguishable from a local
+    # variable assignment. The "name" method is exposed as a dsl_method.
+    # 
+    # For example:
+    # 
+    #  dsl_attr_writer :foo
+    # 
+    # is functionally equivalent to:
+    # 
+    #  attr_writer :foo
+    #  alias_method :foo, :foo=
+    #  dsl_method :foo
+    # 
+    # which enables the following:
+    # 
+    #  my_block do |param|
+    #    param.foo = 1   # Usual setter syntax works
+    #    param.foo 2     # Alternate setter syntax also works
+    #  end
+    #  my_block do
+    #    # foo = 1       # Usual setter syntax does NOT work since it
+    #                    #   looks like a local variable assignment
+    #    foo(2)          # Alternate setter syntax does work
+    #  end
+    
+    def dsl_attr_writer(*names_)
+      names_.each do |name_|
+        attr_writer(name_)
+        alias_method(name_, "#{name_}=")
+        dsl_method(name_)
+      end
+    end
+    
+    
   end
   
   
@@ -306,11 +389,7 @@ module Blockenspiel
       
       def self._add_methodinfo(name_, block_, yields_)
         (@_blockenspiel_methodinfo ||= ::Hash.new)[name_] = [block_, yields_]
-        module_eval("
-          def #{name_}(*params_, &block_)
-            self.class._invoke_methodinfo(:#{name_}, params_, block_)
-          end
-        ")
+        module_eval("def #{name_}(*params_, &block_); self.class._invoke_methodinfo(:#{name_}, params_, block_); end\n")
       end
       
       
@@ -324,7 +403,7 @@ module Blockenspiel
         when :last
           params_.push(block_)
         end
-        info_[0].call(*params_)
+        info_[0].call(*params_, &block_)
       end
       
     end
@@ -348,24 +427,60 @@ module Blockenspiel
     # === Declare a DSL method.
     # 
     # This call creates a method that can be called from the DSL block.
-    # Provide a name for the method, and a block defining the method's
-    # implementation. You may also provided a list of options as follows:
-    # 
-    # The <tt>:block</tt> option controls how the generated method reports
-    # any block provided by the caller. If set to +false+ or not given, any
-    # caller-provided block is ignored. If set to <tt>:first</tt>, the
-    # block is _prepended_ (as a +Proc+ object) to the parameters passed to
-    # the method's implementing block. If set to <tt>:last</tt>, the block
-    # is _appended_. In either case, if the caller does not provide a block,
-    # a value of +nil+ is pre- or appended to the parameter list. A value of
-    # +true+ is equivalent to <tt>:first</tt>.
-    # (This is a workaround for the fact that blocks cannot themselves take
-    # block parameters in Ruby 1.8.)
+    # Provide a name for the method, a block defining the method's
+    # implementation, and an optional hash of options.
     # 
+    # By default, a method of the same name is also made available to
+    # parameterless blocks. To change the name of the parameterless method,
+    # provide its name as the value of the <tt>:dsl_method</tt> option.
+    # To disable this method for parameterless blocks, set the
+    # <tt>:dsl_method</tt> option to +false+.
+    # 
+    # The <tt>:mixin</tt> option is a deprecated alias for
+    # <tt>:dsl_method</tt>.
+    # 
+    # === Warning about the +return+ keyword
+    # 
+    # Because you are implementing your method using a block, remember the
+    # distinction between <tt>Proc.new</tt> and +lambda+. Invoking +return+
+    # from the former does not return from the block, but returns from the
+    # surrounding method scope. Since normal blocks passed to methods are
+    # of the former type, be very careful about using the +return+ keyword:
+    # 
+    #  add_method(:foo) do |param|
+    #    puts "foo called with parameter "+param.inspect
+    #    return "a return value"   # DOESN'T WORK LIKE YOU EXPECT!
+    #  end
+    # 
+    # To return a value from the method you are creating, set the evaluation
+    # value at the end of the block:
+    # 
+    #  add_method(:foo) do |param|
+    #    puts "foo called with parameter "+param.inspect
+    #    "a return value"    # Returns from method foo
+    #  end
+    # 
+    # If you must use the +return+ keyword, create your block as a lambda
+    # as in this example:
+    # 
+    #  code = lambda do |param|
+    #    puts "foo called with parameter "+param.inspect
+    #    return "a return value"   # Returns from method foo
+    #  end
+    #  add_method(:foo, &code)
+    # 
+    # === Accepting a block argument
+    # 
+    # If you want your method to take a block, you have several options
+    # depending on your Ruby version. If you are running the standard Matz
+    # Ruby interpreter (MRI) version 1.8.7 or later (including 1.9.x), you
+    # can use the standard "&" block argument notation to receive the block.
+    # Note that you must call the passed block using the +call+ method since
+    # Ruby doesn't support invoking such a block with +yield+.
     # For example, to create a method named "foo" that takes one parameter
     # and a block, do this:
     # 
-    #  add_method(:foo, :block => :first) do |block, param|
+    #  add_method(:foo) do |param, &block|
     #    puts "foo called with parameter "+param.inspect
     #    puts "the block returned "+block.call.inspect
     #  end
@@ -374,18 +489,32 @@ module Blockenspiel
     # 
     #  foo("hello"){ "a value" }
     # 
-    # By default, a method of the same name is also made available to
-    # parameterless blocks. To change the name of the parameterless method,
-    # provide its name as the value of the <tt>:dsl_method</tt> option.
-    # To disable this method for parameterless blocks, set the
-    # <tt>:dsl_method</tt> option to +false+.
+    # If you are using MRI 1.8.6, however, the parser does not support
+    # passing a block argument to a block. Oddly, the current version of
+    # JRuby (version 1.4.0 as of this writing) also does not support this
+    # syntax, though it claims MRI 1.8.7 compatibility. (See bug JRUBY-4180
+    # to track this issue.) If your Ruby interpreter doesn't support the
+    # standard way to create a method that takes a block, Blockenspiel
+    # provides an alternative in the form of the <tt>:block</tt> option.
+    # This option causes blocks provided by the caller to be included in
+    # the normal parameter list to your method, instead of as a block
+    # parameter. It can be set to <tt>:first</tt> or <tt>:last</tt> to
+    # prepend or append, respectively, the block (as a +Proc+ object) to
+    # the parameter list. If the caller does not include a block when
+    # calling your DSL method, nil is prepended/appended. For example:
     # 
-    # For historical reasons, the <tt>:mixin</tt> option is an alias for
-    # <tt>:dsl_method</tt>. However, its use is deprecated.
+    #  add_method(:foo, :block => :last) do |param, block|
+    #    puts "foo called with parameter "+param.inspect
+    #    if block
+    #      puts "the block returned "+block.call.inspect
+    #    else
+    #      puts "no block passed"
+    #    end
+    #  end
     # 
-    # The <tt>:receive_block</tt> option is also supported for historical
-    # reasons, but its use is deprecated. Setting <tt>:receive_block</tt> to
-    # +true+ is equivalent to setting <tt>:block</tt> to <tt>:last</tt>.
+    # The <tt>:receive_block</tt> option is a deprecated alternative.
+    # Setting <tt>:receive_block => true</tt> is currently equivalent to
+    # setting <tt>:block => :last</tt>.
     
     def add_method(name_, opts_={}, &block_)
       receive_block_ = opts_[:receive_block] ? :last : opts_[:block]
@@ -402,7 +531,7 @@ module Blockenspiel
   
   
   # :stopdoc:
-  TARGET_MISMATCH = ::Object.new
+  NO_VALUE = ::Object.new
   # :startdoc:
   
   @_target_stacks = ::Hash.new
@@ -411,18 +540,37 @@ module Blockenspiel
   @_mutex = ::Mutex.new
   
   
-  # === Invoke a given block.
+  # === Invoke a given block
   # 
   # This is the meat of Blockenspiel. Call this function to invoke a block
   # provided by the user of your API.
   # 
+  # For example, if you want users of your API to be able to do this:
+  # 
+  #  call_dsl do
+  #    foo(1)
+  #    bar(2)
+  #  end
+  # 
+  # Then you should implement <tt>call_dsl</tt> like this:
+  # 
+  #  def call_dsl(&block)
+  #    my_dsl = create_block_implementation
+  #    Blockenspiel.invoke(block, my_dsl)
+  #    do_something_with(my_dsl)
+  #  end
+  # 
+  # In the above, <tt>create_block_implementation</tt> is a placeholder that
+  # returns an instance of your DSL methods class. This class includes the
+  # Blockenspiel::DSL module and defines the DSL methods +foo+ and +bar+.
+  # 
   # Normally, this method will check the block's arity to see whether it
   # takes a parameter. If so, it will pass the given target to the block.
   # If the block takes no parameter, and the given target is an instance of
   # a class with DSL capability, the DSL methods are made available on the
   # caller's self object so they may be called without a block parameter.
   # 
-  # Recognized options include:
+  # === Recognized options
   # 
   # <tt>:parameterless</tt>::
   #   If set to false, disables parameterless blocks and always attempts to
@@ -471,7 +619,7 @@ module Blockenspiel
   #    add_method(:set_foo) do |value|
   #      my_foo = value
   #    end
-  #    add_method(:set_things_from_block, :block => :last) do |value,blk|
+  #    add_method(:set_things_from_block) do |value, &blk|
   #      my_foo = value
   #      my_bar = blk.call
   #    end
@@ -495,10 +643,10 @@ module Blockenspiel
   # 
   # The obvious advantage of using dynamic object generation is that you are
   # creating methods using closures, which provides the opportunity to, for
-  # example, modify closure variables such as my_foo. This is more difficult
-  # to do when you create a target class since its methods do not have access
-  # to outside data. Hence, in the above example, we hand-waved, assuming the
-  # existence of some method called "set_my_foo_from".
+  # example, modify closure local variables such as my_foo. This is more
+  # difficult to do when you create a target class since its methods do not
+  # have access to outside data. Hence, in the above example, we hand-waved,
+  # assuming the existence of some method called "set_my_foo_from".
   # 
   # The disadvantage is performance. If you dynamically generate a target
   # object, it involves parsing and creating a new class whenever it is
@@ -643,11 +791,11 @@ module Blockenspiel
   # This implements the mapping between DSL module methods and target object methods.
   # We look up the current target object based on the current thread.
   # Then we attempt to call the given method on that object.
-  # If we can't find an appropriate method to call, return the special value TARGET_MISMATCH.
+  # If we can't find an appropriate method to call, return the special value NO_VALUE.
   
   def self._target_dispatch(object_, name_, params_, block_)  # :nodoc:
     target_stack_ = @_target_stacks[[::Thread.current.object_id, object_.object_id]]
-    return ::Blockenspiel::TARGET_MISMATCH unless target_stack_
+    return ::Blockenspiel::NO_VALUE unless target_stack_
     target_stack_.reverse_each do |target_|
       target_class_ = target_.class
       delegate_ = target_class_._get_blockenspiel_delegate(name_)
@@ -655,7 +803,7 @@ module Blockenspiel
         return target_.send(delegate_, *params_, &block_)
       end
     end
-    return ::Blockenspiel::TARGET_MISMATCH
+    return ::Blockenspiel::NO_VALUE
   end
   
   

data/lib/blockenspiel/version.rb

@@ -37,6 +37,6 @@
 module Blockenspiel
   
   # Current gem version, as a frozen string.
-  VERSION_STRING = '0.2.2'.freeze
+  VERSION_STRING = '0.3.0'.freeze
   
 end

data/tests/tc_basic.rb

@@ -74,7 +74,7 @@ module Blockenspiel
       # * Asserts that the specified target object does in fact receive the block messages.
       
       def test_basic_param
-        block_ = proc do |t_|
+        block_ = ::Proc.new do |t_|
           t_.set_value(:a, 1)
           t_.set_value_by_block(:b){ 2 }
           assert(!self.respond_to?(:set_value))
@@ -94,7 +94,7 @@ module Blockenspiel
       # * Asserts that the specified target object still receives the messages.
       
       def test_basic_mixin
-        block_ = proc do
+        block_ = ::Proc.new do
           set_value(:a, 1)
           set_value_by_block(:b){ 2 }
         end
@@ -113,7 +113,7 @@ module Blockenspiel
       # * Asserts that receivers with blocks are handled properly.
       
       def test_basic_builder
-        block_ = proc do
+        block_ = ::Proc.new do
           set_value(:a, 1)
           set_value_by_block(:b){ 2 }
         end

data/tests/tc_behaviors.rb

@@ -89,7 +89,7 @@ module Blockenspiel
         hash_ = ::Hash.new
         context_self_ = self
         @my_instance_variable_test = :hello
-        block_ = proc do
+        block_ = ::Proc.new do
           set_value1('a', 1)
           set_value2('b'){ 2 }
           set_value3('c', 3)
@@ -116,7 +116,7 @@ module Blockenspiel
         hash_ = ::Hash.new
         context_self_ = self
         @my_instance_variable_test = :hello
-        block_ = proc do
+        block_ = ::Proc.new do
           set_value1('a', 1)
           set_value2('b'){ 2 }
           set_value3_dslversion('c', 3)
@@ -140,13 +140,13 @@ module Blockenspiel
       
       def test_disable_parameterless
         hash_ = ::Hash.new
-        block1_ = proc do ||
+        block1_ = ::Proc.new do ||
           set_value1('a', 1)
         end
-        block2_ = proc do |target_|
+        block2_ = ::Proc.new do |target_|
           target_.set_value1('b', 2)
         end
-        block3_ = proc do
+        block3_ = ::Proc.new do
           set_value1('c', 3)
         end
         assert_raise(::Blockenspiel::BlockParameterError) do
@@ -167,13 +167,13 @@ module Blockenspiel
       
       def test_disable_parametered
         hash_ = ::Hash.new
-        block1_ = proc do ||
+        block1_ = ::Proc.new do ||
           set_value1('a', 1)
         end
-        block2_ = proc do |target_|
+        block2_ = ::Proc.new do |target_|
           target_.set_value1('b', 2)
         end
-        block3_ = proc do
+        block3_ = ::Proc.new do
           set_value1('c', 3)
         end
         ::Blockenspiel.invoke(block1_, Target1.new(hash_), :parameter => false)

data/tests/tc_dsl_attrs.rb

@@ -0,0 +1,134 @@
+# -----------------------------------------------------------------------------
+# 
+# Blockenspiel dsl attribute tests
+# 
+# This file contains tests for the dsl attribute directives.
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2008-2009 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+require 'test/unit'
+require ::File.expand_path("#{::File.dirname(__FILE__)}/../lib/blockenspiel.rb")
+
+
+module Blockenspiel
+  module Tests  # :nodoc:
+    
+    class TestDSLAttrs < ::Test::Unit::TestCase  # :nodoc:
+      
+      
+      class WriterTarget < ::Blockenspiel::Base
+        
+        dsl_attr_writer(:attr1, :attr2)
+        
+      end
+      
+      
+      class AccessorTarget < ::Blockenspiel::Base
+        
+        dsl_attr_accessor(:attr1, :attr2)
+        
+      end
+      
+      
+      # Test dsl attr writer in a parametered block
+      # 
+      # * Asserts that the standard setter syntax works
+      # * Asserts that the alternate setter syntax works
+      
+      def test_writer_parametered
+        block_ = ::Proc.new do |param_|
+          param_.attr1 = 1
+          assert_equal(2, param_.attr2(2))
+        end
+        target_ = WriterTarget.new
+        ::Blockenspiel.invoke(block_, target_)
+        assert_equal(1, target_.instance_variable_get(:@attr1))
+        assert_equal(2, target_.instance_variable_get(:@attr2))
+      end
+      
+      
+      # Test dsl attr writer in a parameterless block
+      # 
+      # * Asserts that the alternate setter syntax works
+      
+      def test_writer_parameterless
+        block_ = ::Proc.new do
+          assert_equal(2, attr2(2))
+        end
+        target_ = WriterTarget.new
+        ::Blockenspiel.invoke(block_, target_)
+        assert_nil(target_.instance_variable_get(:@attr1))
+        assert_equal(2, target_.instance_variable_get(:@attr2))
+      end
+      
+      
+      # Test dsl attr accessor in a parametered block
+      # 
+      # * Asserts that the standard setter syntax works
+      # * Asserts that the alternate setter syntax works
+      # * Asserts that the getter syntax works
+      
+      def _test_accessor_parametered
+        block_ = ::Proc.new do |param_|
+          param_.attr1 = 1
+          assert_equal(2, param_.attr2(2))
+          assert_equal(2, param_.attr2)
+        end
+        target_ = AccessorTarget.new
+        ::Blockenspiel.invoke(block_, target_)
+        assert_equal(1, target_.instance_variable_get(:@attr1))
+        assert_equal(2, target_.instance_variable_get(:@attr2))
+      end
+      
+      
+      # Test dsl attr accessor in a parameterless block
+      # 
+      # * Asserts that the alternate setter syntax works
+      # * Asserts that the getter syntax works
+      
+      def test_accessor_parameterless
+        block_ = ::Proc.new do
+          assert_equal(2, attr2(2))
+          assert_equal(2, attr2)
+        end
+        target_ = AccessorTarget.new
+        ::Blockenspiel.invoke(block_, target_)
+        assert_nil(target_.instance_variable_get(:@attr1))
+        assert_equal(2, target_.instance_variable_get(:@attr2))
+      end
+      
+      
+    end
+    
+  end
+end

data/tests/tc_dsl_methods.rb

@@ -203,7 +203,7 @@ module Blockenspiel
       
       def test_default_setting
         hash_ = ::Hash.new
-        block_ = proc do
+        block_ = ::Proc.new do
           set_value1('a', 1)
           set_value2('b'){ 2 }
           assert_raise(::NoMethodError){ _set_value3('c', 3) }
@@ -223,7 +223,7 @@ module Blockenspiel
       
       def test_onoff_switching
         hash_ = ::Hash.new
-        block_ = proc do
+        block_ = ::Proc.new do
           assert_raise(::NoMethodError){ _set_value1('a', 1) }
           set_value2('b'){ 2 }
           _set_value3('c', 3)
@@ -242,7 +242,7 @@ module Blockenspiel
       
       def test_explicit_add
         hash_ = ::Hash.new
-        block_ = proc do
+        block_ = ::Proc.new do
           set_value1('a', 1)
           assert_raise(::NoMethodError){ set_value2('b'){ 2 } }
           renamed_set_value2('c'){ 3 }
@@ -263,7 +263,7 @@ module Blockenspiel
       
       def test_explicit_removing
         hash_ = ::Hash.new
-        block_ = proc do
+        block_ = ::Proc.new do
           assert_raise(::NoMethodError){ set_value1('a', 1) }
           assert_raise(::NoMethodError){ set_value2('b'){ 2 } }
           renamed_set_value2('c'){ 3 }
@@ -282,7 +282,7 @@ module Blockenspiel
       
       def test_subclassing
         hash_ = ::Hash.new
-        block_ = proc do
+        block_ = ::Proc.new do
           set_value1('a', 1)
           set_value2('b'){ 2 }
           assert_raise(::NoMethodError){ set_value3('c', 3) }
@@ -307,7 +307,7 @@ module Blockenspiel
       
       def test_multiple_dsl_methods
         hash_ = ::Hash.new
-        block_ = proc do
+        block_ = ::Proc.new do
           set_value1('a', 1)
           renamed_set_value2('b'){ 2 }
           assert_raise(::NoMethodError){ set_value2('c', 3) }