quality_extensions 0.1.1

data/lib/qualitysmith_extensions/module/class_methods.rb

@@ -0,0 +1,87 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes!
+# Developer notes::
+#++
+
+class Object
+
+  def class_methods(include_super = true)
+    (
+        methods(include_super) \
+      - instance_methods
+    ).
+      sort
+  end
+  alias_method :module_methods, :class_methods
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+require 'qualitysmith_extensions/test/assert_anything'
+require 'set'
+
+module M
+  def instance_meth; end
+  def self.module_meth; end
+end
+class C
+  def instance_meth; end
+  def self.module_meth; end
+end
+class CSub < C
+  def sub_instance_meth; end
+  def self.sub_module_meth; end
+end
+
+
+class TheTest < Test::Unit::TestCase
+  C_common_instance_methods = ['object_id', 'dup', 'send', 'is_a?']
+  C_common_class_methods = ['instance_methods']
+  def test_class
+    assert_subset? (['instance_meth'] + C_common_instance_methods).to_set,
+      C.instance_methods.to_set
+    assert_subset? (['module_meth'] + C_common_class_methods).to_set,
+      C.class_methods.to_set
+  end
+  def test_class__no_super
+    assert_subset? ['instance_meth'].to_set,
+      C.instance_methods(false).to_set
+    assert_subset? ['module_meth'].to_set,
+      C.class_methods(false).to_set
+  end
+
+  def test_module
+    assert_equal ['instance_meth'], M.instance_methods    # Unlike a class, modules don't have all the common instance methods from Object
+    assert_subset? (['module_meth'] + C_common_class_methods).to_set,
+      M.class_methods.to_set
+  end
+  def test_module__no_super
+    assert_equal ['instance_meth'], M.instance_methods(false)    # Unlike a class, modules don't have all the common instance methods from Object
+    assert_subset? (['module_meth']).to_set,
+      M.class_methods(false).to_set
+  end
+
+  def test_subclass
+    assert_subset? (['instance_meth', 'sub_instance_meth'] + C_common_instance_methods).to_set,
+      CSub.instance_methods.to_set
+    assert_subset? ['module_meth', 'sub_module_meth'].to_set,
+      CSub.class_methods.to_set
+  end
+  def test_subclass__no_super
+    assert_equal ['sub_instance_meth'], CSub.instance_methods(false)
+    assert_equal ['sub_module_meth'],   CSub.class_methods(false)
+  end
+end
+=end
+

data/lib/qualitysmith_extensions/module/create.rb

@@ -0,0 +1,315 @@
+#--
+# Author::    Aaron Pfeifer, Neil Abraham, Tyler Rick 
+# Copyright:: Copyright (c) 2006-2007 Aaron Pfeifer & Neil Abraham
+# License::   MIT License
+# Submit to Facets?:: Yes!
+# Developer notes::
+# * Why are we calling it create? Why not just new? Would that cause any problems?
+# To do::
+# * Submit to pluginaweek mailing list
+# Changes:
+#   r2964 (Tyler):
+#   * Started from http://svn.pluginaweek.org/trunk/plugins/ruby/module/module_creation_helper/ (Last Changed Rev: 320)
+#   * Renamed :parent option to :namespace. (:parent is still allowed for backwards compatibility)
+#   * Changed examples and tests to pass in the name as a symbol instead of a string.
+#   * Made it so you can pass in the namespace as part of the name if you want: Module.create(:'Foo::Bar') instead of Module.create(:Foo, :parent => Bar)
+#   * Added to the documentation
+#   * Added new tests
+#     * test_with_block_2
+#     * test_nested_class_with_superclass_with_same_name
+#     * test_referencing_a_namespace_that_isnt_defined
+#     * test_creating_a_class_more_than_once
+#     * test_using_return_value_of_one_create_within_another_create
+#   * Added __FILE__, __LINE__ to class_eval so that error messages would be more helpful.
+#++
+
+require 'rubygems'
+require 'facets/core/hash/assert_has_only_keys'
+require 'facets/core/hash/reverse_merge'
+require 'facets/core/kernel/constant'
+require 'facets/core/symbol/to_proc'
+require 'qualitysmith_extensions/module/split'
+require 'qualitysmith_extensions/module/basename'
+require 'qualitysmith_extensions/module/dirname'
+
+class Module
+  # Creates a new module with the specified name.  This is essentially the
+  # same as actually defining the module like so:
+  # 
+  #   module NewModule
+  #   end
+  # 
+  # or as a class:
+  # 
+  #   class NewClass < SuperKlass
+  #   end
+  # 
+  # Configuration options:
+  # <tt>superclass</tt> - The class to inherit from.  This only applies when using Class#create.  Default is Object.
+  # <tt>namespace</tt>/<tt>parent</tt> - The class/module namespace that contains this module.  Default is Object.
+  #
+  # You can also include the namespace in the +name+ if you'd prefer. For instance, name = <tt>:'Foo::Bar'</tt> is the same as specifying <tt>name = :Bar, :namespace => Foo</tt>. (Note: The namespace module specified must already be defined, just like it would have to be defined if you used the <tt>:namespace</tt> option.)
+  #
+  # Examples:
+  # 
+  #   Module.create(:Foo)                                                      # => Foo
+  #   Module.create(:'Foo::Bar', :namespace => Foo)                            # => Foo::Bar
+  #   Module.create(:Bar, :namespace => Foo)                                   # => Foo::Bar
+  #
+  #   Class.create(:Base)                                                      # => Base
+  #   Class.create(:'Foo::Klass', :superclass => Base)                         # => Foo::Klass
+  #
+  # Unlike the built-in Ruby +module+/+class+ directive, this actually returns the newly created module/class as the return value. So, for example, you can do things like this:
+  # 
+  #   klass = Class.create(:'Foo::Klass', :superclass => Class.create(:Base))  # => Foo::Klass
+  #   klass.name                                                               # => Foo::Klass
+  #   klass.superclass                                                         # => Base
+  #
+  # You can also pass a block to create. This:
+  #
+  #   Class.create(:ClassWithBlock, :superclass => BaseClass) do
+  #     def self.say_hello
+  #       'hello'
+  #     end
+  #   end
+  #
+  # is equivalent to this:
+  #
+  #   class ClassWithBlock < BaseClass do
+  #     def self.say_hello
+  #       'hello'
+  #     end
+  #   end
+  #
+  def create(name, options = {}, &block)
+    # Validate arguments
+    raise ArgumentError unless name.respond_to?(:to_s)
+    options[:namespace] = options.delete(:parent) if options.has_key?(:parent)
+    options.assert_has_only_keys(
+      :superclass,
+      :namespace
+    )
+    module_or_class = self.to_s.downcase
+    raise ArgumentError, 'Modules cannot have superclasses' if options[:superclass] && module_or_class == 'module'
+
+    # Set defaults
+    namespace_module, superclass =
+      options[:namespace]  || ::Object, 
+      options[:superclass] || ::Object
+
+    # Determine the namespace to create it in
+    nesting = Module.split_name(name)
+    if nesting.size > 1
+      namespace_module = Module.namespace_of(name) # For example, would be A::B for A::B::C
+      base_name = Module.basename(name)            # For example, would be :C   for A::B::C
+    else
+      base_name = name
+    end
+    
+    # Actually create the new module
+    if superclass != ::Object
+      superclass = " < ::#{superclass}"
+    else
+      superclass = ''
+    end
+    namespace_module.class_eval <<-end_eval, __FILE__, __LINE__
+      #{module_or_class} #{base_name}#{superclass}
+        # Empty
+      end
+    end_eval
+    our_new_module = namespace_module.const_get(base_name)
+    
+    our_new_module.class_eval(&block) if block_given?
+    our_new_module
+  end
+end
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+require 'rubygems'
+require 'qualitysmith_extensions/module/attribute_accessors'
+require 'qualitysmith_extensions/module/namespace'
+require 'qualitysmith_extensions/symbol/constantize'
+require 'facets/core/module/basename'
+
+module Namespace
+end
+
+class BaseClass
+  cattr_accessor :test_name
+  cattr_accessor :test_inspect
+  cattr_accessor :test_to_s
+  
+  def self.inherited(base)
+    self.test_name = base.name
+    self.test_inspect = base.inspect
+    self.test_to_s = base.to_s
+  end
+end
+
+class ModuleCreationHelperTest < Test::Unit::TestCase
+  def setup
+    BaseClass.test_name = nil
+    BaseClass.test_inspect = nil
+    BaseClass.test_to_s = nil
+  end
+  
+  def test_no_options_for_class
+    klass = Class.create(:Foo)
+    assert_equal Object, klass.superclass
+    assert_equal Object, klass.namespace_module
+    assert Object.const_defined?('Foo')
+  end
+  
+  def test_no_options_for_module
+    mod = Module.create(:FooMod)
+    assert_equal Object, mod.namespace_module
+    assert Object.const_defined?('FooMod')
+  end
+  
+  def test_invalid_option
+    assert_raise(ArgumentError) {Class.create(nil, :invalid => true)}
+  end
+  
+  def test_superclass_for_module
+    assert_raise(ArgumentError) {Module.create(nil, :superclass => Object)}
+  end
+  
+  def test_superclass
+    klass = Class.create(:Bar, :superclass => BaseClass)
+    assert_equal BaseClass, klass.superclass
+    assert_equal Object, klass.namespace_module
+    assert Object.const_defined?('Bar')
+  end
+  
+  def test_namespace_for_class
+    klass = Class.create(:Baz, :namespace => Namespace)
+    assert_equal Object, klass.superclass
+    assert_equal Namespace, klass.namespace_module
+    assert Namespace.const_defined?('Baz')
+  end
+  
+  def test_namespace_for_class__namespace_as_part_of_name
+    klass = Class.create(:'Namespace::Baz')
+    assert_equal Object, klass.superclass
+    assert_equal Namespace, klass.namespace_module
+    assert Namespace.const_defined?('Baz')
+  end
+  
+  def test_namespace_for_module
+    mod = Module.create(:BazMod, :namespace => Namespace)
+    assert_equal Namespace, mod.namespace_module
+    assert Namespace.const_defined?('BazMod')
+  end
+  
+  def test_superclass_and_namespace
+    klass = Class.create(:Biz, :superclass => BaseClass, :namespace => Namespace)
+    assert_equal BaseClass, klass.superclass
+    assert_equal Namespace, klass.namespace_module
+    assert Namespace.const_defined?('Biz')
+  end
+  
+  def test_name_before_evaluated
+    klass = Class.create(:Waddle, :superclass => BaseClass)
+    assert_equal 'Waddle', BaseClass.test_name
+  end
+  
+  def test_inspect_before_evaluated
+    klass = Class.create(:Widdle, :superclass => BaseClass)
+    assert_equal 'Widdle', BaseClass.test_inspect
+  end
+  
+  def test_to_s_before_evaluated
+    klass = Class.create(:Wuddle, :superclass => BaseClass)
+    assert_equal 'Wuddle', BaseClass.test_to_s
+  end
+  
+  def test_name_before_evaluated_with_namespace
+    klass = Class.create(:Waddle, :superclass => BaseClass, :namespace => Namespace)
+    assert_equal 'Namespace::Waddle', BaseClass.test_name
+  end
+  
+  def test_inspect_before_evaluated_with_namespace
+    klass = Class.create(:Widdle, :superclass => BaseClass, :namespace => Namespace)
+    assert_equal 'Namespace::Widdle', BaseClass.test_inspect
+  end
+  
+  def test_to_s_before_evaluated_with_namespace
+    klass = klass = Class.create(:Wuddle, :superclass => BaseClass, :namespace => Namespace)
+    assert_equal 'Namespace::Wuddle', BaseClass.test_to_s
+  end
+  
+  def test_subclass_of_dynamic_class
+    klass = Class.create(:Foobar)
+    subclass = Class.create(:Foobaz, :superclass => klass)
+    
+    assert_equal klass, subclass.superclass
+    assert_equal 'Foobaz', subclass.name
+    assert_equal 'Foobaz', subclass.inspect
+    assert_equal 'Foobaz', subclass.to_s
+  end
+  
+  def test_with_block_1
+    klass = Class.create(:ClassWithBlock, :superclass => BaseClass) do
+      def self.say_hello
+        'hello'
+      end
+    end
+    assert_equal 'hello', ClassWithBlock.say_hello
+  end
+
+  def test_with_block_2
+    klass = Class.create(:ClassWithBlock, :superclass => BaseClass) do
+      def say_hello
+        'hello'
+      end
+    end
+    assert_equal 'hello', ClassWithBlock.new.say_hello
+  end
+  
+  def test_nested_class_with_superclass_with_same_name
+    klass = Class.create(:Employee)
+    nested_class = Class.create(:Employee, :superclass => klass, :namespace => Namespace)
+    assert_equal klass, nested_class.superclass
+    assert_equal klass.basename, nested_class.basename
+  end
+  
+  def test_nested_class_with_superclass_with_same_name
+    klass = Class.create(:Employee)
+    nested_class = Class.create(:Employee, :superclass => klass, :namespace => Namespace)
+    assert_equal klass, nested_class.superclass
+    assert_equal klass.basename, nested_class.basename
+  end
+
+  def test_referencing_a_namespace_that_isnt_defined
+    assert_raise(NameError) { Class.create(:'Zzt::Klass') }
+  end
+
+  def test_creating_a_class_more_than_once
+    klass = Class.create(:'Foo')
+    klass = Class.create(:'Foo')
+  end
+
+  def test_using_return_value_of_one_create_within_another_create
+    klass = Class.create(:'Foo')
+    klass = Class.create(:'Base')
+    klass = Class.create(:'Foo::Klass', 
+             :superclass => Class.create(:Base)
+            )
+    assert_equal 'Foo::Klass', klass.name
+    assert_equal Base, klass.superclass
+  end
+
+  
+end
+=end
+

data/lib/qualitysmith_extensions/module/create_setter.rb

@@ -0,0 +1,9 @@
+#create_setter/constructor :_F, :filename
+#create_setter/constructor :initialize, :filename do
+#  extra constructor stuff
+#end
+#
+#      def _F(filename)
+#        @filename = filename
+#      end
+#

data/lib/qualitysmith_extensions/module/dirname.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+# Alias for:
+require 'qualitysmith_extensions/module/namespace'
+

data/lib/qualitysmith_extensions/module/guard_method.rb

@@ -0,0 +1,312 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes!
+# Developer notes::
+# * Is it thread-safe?? Probably not, as it stands...
+#   But the whole thing that prompted me to create a guard method in the first place was to try to avoid a deadlock that was
+#   caused by recursively calling a method with a synchronize in it (in other words, someone else's attempt at thread-safety
+#   resulted in me getting into a deadlock, which is why I wrote this method to begin with). So I'm not even sure if it's
+#   possible to make it thread-safe?
+#++
+
+require 'rubygems'
+require 'qualitysmith_extensions/module/attribute_accessors'
+require 'facets/core/kernel/require_local'
+require_local 'bool_attr_accessor'
+#require 'qualitysmith_extensions/module/bool_attr_accessor'
+require 'qualitysmith_extensions/symbol/match'
+
+
+class Module
+  # A guard method (by this definition anyway) is a method that sets a flag, executes a block, and then returns the flag to its
+  # previous value. It ensures that the flag is set during the execution of the block.
+  #
+  # In the simplest case, you'd use it like this:
+  #   class A
+  #     guard_method :disable_stupid_stuff!, :@stupid_stuff_disabled
+  #   end
+  #   a = A.new
+  #   a.disable_stupid_stuff! do   # Causes @stupid_stuff_disabled to be set to true
+  #     # Section of code during which you don't want any stupid stuff to happen
+  #   end                          # Causes @stupid_stuff_disabled to be set back to false
+  #   # Okay, a, you can resume doing stupid stuff again...
+  #   
+  # If you want your guard method to *disable* the flag rather than *enable* it, simply pass false to the guard method.
+  #
+  # These calls can be nested however you wish:
+  #   a.guard_the_fruit! do
+  #     a.guard_the_fruit!(false) do
+  #       assert_equal false, a.guarding_the_fruit?
+  #     end
+  #     assert_equal true, a.guarding_the_fruit?
+  #   end
+  #
+  # You can also use the guard methods as normal flag setter/clearer methods by simply not passing a block to it. Hence
+  #   a.guard_the_fruit!
+  # will simply set @guarding_the_fruit to true, and
+  #   a.guard_the_fruit!(false)
+  # will set @guarding_the_fruit to false.
+  #
+  def guard_method(guard_method_name, guard_variable)
+    raise ArgumentError.new("Expected an instance variable name but got #{guard_variable}") if guard_variable !~ /^@([\w_]+)$/
+    guard_variable.to_s =~ /^@([\w_]+)$/    # Why didn't the regexp above set $1 ??
+    class_eval do
+      bool_attr_accessor $1.to_sym
+    end
+    module_eval <<-End, __FILE__, __LINE__+1
+      def #{guard_method_name}(new_value = true, &block)
+        old_guard_state, #{guard_variable} = #{guard_variable}, new_value
+        if block_given?
+          begin
+            returning = yield
+          ensure
+            #{guard_variable} = old_guard_state
+            returning
+          end
+        end
+      end
+    End
+  end
+
+  # See the documentation for guard_method. mguard_method does the same thing, only it creates a _class_ (or _module_) method
+  # rather than an instance method and it uses a _class_ (or _module_) variable rather than an instance variable to store the
+  # guard state.
+  #
+  # Example:
+  #   mguard_method :guard_the_fruit!, :@@guarding_the_fruit
+  #   mguard_method :use_assert_equal_with_highlight!, :@@always_use_assert_equal_with_highlight
+  def mguard_method(guard_method_name, guard_variable)
+    raise ArgumentError.new("Expected a class variable name but got #{guard_variable}") if guard_variable !~ /^@@[\w_]+$/
+    guard_variable.to_s =~ /^@@([\w_]+)$/
+    class_eval do
+      mbool_attr_accessor $1.to_sym
+    end
+    module_eval <<-End, __FILE__, __LINE__+1
+      class << self
+        def #{guard_method_name}(new_value = true, &block)
+          old_guard_state, #{guard_variable} = #{guard_variable}, new_value
+          if block_given?
+            begin
+              returning = yield
+            ensure
+              #{guard_variable} = old_guard_state
+              returning
+            end
+          end
+        end
+      end
+    End
+  end
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class GuardMethodTest_Simple < Test::Unit::TestCase
+  class A
+    guard_method :guard_the_fruit!, :@guarding_the_fruit
+  end
+  def test_guard_method
+    a = A.new
+    assert_equal nil, a.guarding_the_fruit?
+    a.guard_the_fruit! do
+      # Call it recursively!
+      a.guard_the_fruit! do
+        assert_equal true, a.guarding_the_fruit?
+      end
+      assert_equal true, a.guarding_the_fruit?   # This is the reason why we have to save the 'old_guard_state'. So that we don't stupidly set it back to false if we still haven't exited from the outermost call to the guard black.
+    end
+    assert_equal nil, a.guarding_the_fruit?
+  end
+  def test_guard_method_error
+    assert_raise(ArgumentError) do
+      self.class.class_eval do
+        guard_method :guard_the_fruit!, :@@guarding_the_fruit
+      end
+    end
+  end
+  def test_return_value
+    assert_equal 'special return value', A.new.guard_the_fruit! { 'special return value' }
+  end
+
+  def try_to_return_prematurely(a)
+    a.guard_the_fruit! do
+      assert_equal true, a.guarding_the_fruit?
+      return 'prematurely'
+    end
+  end
+  def test_guard_method_for_block_that_tries_to_return_prematurely
+    a = A.new
+    assert_equal nil, a.guarding_the_fruit?
+    try_to_return_prematurely(a)
+    assert_equal nil, a.guarding_the_fruit?
+  end
+end
+
+class GuardMethodTest_WithUnguard < Test::Unit::TestCase    # (By "unguard" here I mean passing false to the guard method...)
+  class A
+    guard_method :guard_the_fruit!, :@guarding_the_fruit
+  end
+  def test_guard_method
+    a = A.new
+    assert_equal nil, a.guarding_the_fruit?
+    a.guard_the_fruit! do
+      a.guard_the_fruit! do
+        assert_equal true, a.guarding_the_fruit?
+
+        a.guard_the_fruit! false do
+          assert_equal false, a.guarding_the_fruit?
+          a.guard_the_fruit! do
+            assert_equal true, a.guarding_the_fruit?
+          end
+          assert_equal false, a.guarding_the_fruit?
+        end
+
+        assert_equal true, a.guarding_the_fruit?
+      end
+      assert_equal true, a.guarding_the_fruit?
+    end
+    assert_equal nil, a.guarding_the_fruit?
+  end
+
+  def test_guard_method_with_simple_blockless_toggles
+    a = A.new
+    assert_equal nil, a.guarding_the_fruit?
+    a.guard_the_fruit!
+    assert_equal true, a.guarding_the_fruit?
+
+    a.guarding_the_fruit? do
+      assert_equal false, a.guarding_the_fruit?
+      a.guard_the_fruit! do
+        assert_equal true, a.guarding_the_fruit?
+        a.guard_the_fruit! false
+        assert_equal false, a.guarding_the_fruit?
+        a.guard_the_fruit!
+        assert_equal true, a.guarding_the_fruit?
+      end
+      assert_equal false, a.guarding_the_fruit?
+    end
+
+    assert_equal true, a.guarding_the_fruit?
+  end
+
+  def test_return_value
+    assert_equal nil, A.new.guard_the_fruit!
+    assert_equal nil, A.new.guard_the_fruit!(false)
+    assert_equal 'special return value', A.new.guard_the_fruit!        { 'special return value' }
+    assert_equal 'special return value', A.new.guard_the_fruit!(false) { 'special return value' }
+  end
+end
+
+#---------------------------------------------------------------------------------------------------------------------------------
+# Begin duplication
+# The following TestCases are simply duplicates of the previous except that they test mguard_method rather than guard_method
+# The main differenes/substitutions:
+# * @@guarding_the_fruit, rather than @guarding_the_fruit
+# * :'<,'>s/A.new/B/g
+# * :'<,'>s/\<a\>/B/g
+
+class MGuardMethodTest_Simple < Test::Unit::TestCase
+  class B
+    mguard_method :guard_the_fruit!, :@@guarding_the_fruit
+  end
+  def test_mguard_method
+    assert_equal nil, B.guarding_the_fruit?
+    B.guard_the_fruit! do
+      # Call it recursively!
+      B.guard_the_fruit! do
+        assert_equal true, B.guarding_the_fruit?
+      end
+      assert_equal true, B.guarding_the_fruit?   # This is the reason why we have to save the 'old_guard_state'. So that we don't stupidly set it back to false if we still haven't exited from the outermost call to the guard black.
+    end
+    assert_equal nil, B.guarding_the_fruit?
+  end
+  def test_mguard_method_error
+    assert_raise(ArgumentError) do
+      self.class.class_eval do
+        mguard_method :guard_the_fruit!, :@guarding_the_fruit
+      end
+    end
+  end
+  def test_return_value
+    assert_equal 'special return value', B.guard_the_fruit! { 'special return value' }
+  end
+
+  def try_to_return_prematurely
+    B.guard_the_fruit! do
+      assert_equal true, B.guarding_the_fruit?
+      return 'prematurely'
+    end
+  end
+  def test_guard_method_for_block_that_tries_to_return_prematurely
+    assert_equal nil, B.guarding_the_fruit?
+    try_to_return_prematurely
+    assert_equal nil, B.guarding_the_fruit?
+  end
+end
+
+class MGuardMethodTest_WithUnguard < Test::Unit::TestCase
+  class B
+    mguard_method :guard_the_fruit!, :@@guarding_the_fruit
+  end
+  def test_guard_method
+    assert_equal nil, B.guarding_the_fruit?
+    B.guard_the_fruit! do
+      B.guard_the_fruit! do
+        assert_equal true, B.guarding_the_fruit?
+
+        B.guard_the_fruit!(false) do
+          assert_equal false, B.guarding_the_fruit?
+          B.guard_the_fruit! do
+            assert_equal true, B.guarding_the_fruit?
+          end
+          assert_equal false, B.guarding_the_fruit?
+        end
+
+        assert_equal true, B.guarding_the_fruit?
+      end
+      assert_equal true, B.guarding_the_fruit?
+    end
+    assert_equal nil, B.guarding_the_fruit?
+  end
+
+  def test_guard_method_with_simple_blockless_toggles
+    assert_equal nil, B.guarding_the_fruit?
+    B.guard_the_fruit!
+    assert_equal true, B.guarding_the_fruit?
+
+    B.guard_the_fruit!(false) do
+      assert_equal false, B.guarding_the_fruit?
+      B.guard_the_fruit! do
+        assert_equal true, B.guarding_the_fruit?
+        B.guard_the_fruit!(false)
+        assert_equal false, B.guarding_the_fruit?
+        B.guard_the_fruit!
+        assert_equal true, B.guarding_the_fruit?
+      end
+      assert_equal false, B.guarding_the_fruit?
+    end
+
+    assert_equal true, B.guarding_the_fruit?
+  end
+
+  def test_return_value
+    assert_equal nil, B.guard_the_fruit!
+    assert_equal nil, B.guard_the_fruit!(false)
+    assert_equal 'special return value', B.guard_the_fruit!         { 'special return value' }
+    assert_equal 'special return value', B.guard_the_fruit!(false) { 'special return value' }
+  end
+end
+# End duplication
+#---------------------------------------------------------------------------------------------------------------------------------
+=end
+