facets 2.9.1 → 2.9.2

data/work/consider/knowself.rb

@@ -0,0 +1,42 @@
+# Of course I'm not sure all of these are "real",
+# but that's okay for now.
+
+class Symbol
+  def self.coercer ; :to_sym ; end
+  def self.convertor ; :intern ; end
+end
+
+class Array
+  def self.coercer ; :to_ary ; end
+  def self.convertor ; :to_a ; end
+end
+
+class Hash
+  def self.coercer ; :to_hash ; end 
+  def self.convertor ; :to_h ; end
+end
+
+class String
+  def self.coercer ; :to_str ; end
+  def self.convertor ; :to_s ; end
+end
+
+class Range
+  def self.coercer ; :to_rng ; end 
+  def self.convertor ; :to_r ; end
+end
+
+class Regexp
+  def self.coercer ; :to_rexp ; end 
+  def self.convertor ; :to_re ; end
+end
+
+class Integer
+  def self.coercer ; :to_int ; end 
+  def self.convertor ; :to_i ; end
+end
+
+class Float
+  def self.coercer ; :to_float ; end
+  def self.convertor ; :to_f ; end
+end

data/work/consider/lib/core/facets.rb

@@ -0,0 +1,37 @@
+# Dynamically load all core libraries.
+
+# Nah... lets do it statically.
+module Facets
+
+  # Libraries to exclude from default require.
+  EXTRANEOUS = %w{
+    succ.rb
+    kernel/autoreload.rb
+    kernel/once.rb
+    kernel/this.rb
+    module/attr_validator.rb
+    module/instance_function.rb
+    object/instance_eval.rb
+    proc/partial.rb
+    string/mask.rb
+    string/obfuscate.rb
+    string/stylize.rb
+    string/words.rb
+  }
+
+  def self.require
+    __DIR__ = File.dirname(__FILE__)
+    list = []
+    Dir.chdir("#{__DIR__}/facets") do
+      list = Dir['**/*']
+      list.reject!{ |d| File.directory?(d) }
+    end
+    list -= EXTRANEOUS
+    list = list.map{ |f| File.join('facets', f) }
+    list.each{ |f| p f; Kernel.require(f) }
+  end
+
+end
+
+Facets.require
+

data/work/consider/lib/core/facets/array/fetch.rb

@@ -0,0 +1,37 @@
+class Array
+
+  # TODO Probably not best to overide store and fetch operators. Rename?
+
+  # Modifies #[] to also accept an array of indexes.
+  #
+  #   a = ['a','b','c','d','e','f']
+  #
+  #   a[[1]]      #=> ['b']
+  #   a[[1,1]]    #=> ['b','b']
+  #   a[[1,-1]]   #=> ['b','f']
+  #   a[[0,2,4]]  #=> ['a','c','e']
+  #
+  def [](*args)
+    return values_at(*args.at(0)) if Array === args.at(0)
+    return slice(*args)
+  end
+
+  # Modifies #[]= to accept an array of indexes for assignment.
+  #
+  #   a = ['a','b','c','d']
+  #
+  #   a[[1,-1]] = ['m','n']    #=> ['m','n']
+  #   a                        #=> ['a','m','c','n']
+  #
+  def []=(*args)
+    if Array === args.at(0)
+      idx,vals = args.at(0),args.at(1)
+      idx.each_with_index{ |a,i| store(a,vals.at(i)) }
+      return values_at( *idx )
+    else
+      return store(*args)
+    end
+  end
+
+end
+

data/work/consider/lib/core/facets/array/op_div.rb

@@ -0,0 +1,23 @@
+class Array
+
+  # Index operator.
+  #
+  #  a = [:a, :b, :c]
+  #  (a/1)  #=> :a
+  alias_method :/, :[]
+
+  # DEPRECATED -- Use 'each_slice(n).to_a' as of 1.9.
+  # Partition an array into parts of given length.
+  #
+  # CREDIT: WhyTheLuckyStiff ...
+  #
+  #   def / len
+  #     inject([]) do |ary, x|
+  #       ary << [] if [*ary.last].nitems % len == 0
+  #       ary.last << x
+  #       ary
+  #     end
+  #   end
+
+end
+

data/work/consider/lib/core/facets/hash/having.rb

@@ -0,0 +1,75 @@
+## THIS IS NOT THUROUGH ENOUGH
+## PROBABY SHOULD MAKE SPECIAL SUBCLASSES
+## OF HASH TO HANDLE THIS CONCEPT.
+#
+# IMPORTANT TODO!!!!
+
+#
+
+class Hash
+
+  attr_accessor :fallback
+
+  # Define a fallback object for #fetch and #[].
+  #
+  #   f = Hash[:b=>2]
+  #   h = Hash[:a=>1].having_aquisition(f)
+  #   h[:b] => 2
+
+  def having_aquisition(fallback)
+
+    @fallback = fallback
+
+    unless @fallsback
+
+      def self.[](key)
+        begin
+          return @fallback[key] if @fallback and not key?(key)
+        rescue
+        end
+        val = super
+p val
+        val.fallback(self) if Hash == val
+        val
+      end
+
+      def self.fetch(key, *args, &blk)
+        begin
+          return @fallback.fetch(key, *args, &blk) if @fallback and not key?(key)
+        rescue
+        end
+        val = super
+        val.fallback(self) if Hash == val
+        val
+      end
+
+      @fallsback = true
+    end
+
+    self
+  end
+
+  # Define a fallback object for #fetch and #[].
+  #
+  #   f = Hash[:b=>2]
+  #   h = Hash[:a=>1].having_fallback(f)
+  #   h[:b] => 2
+
+  def having_fallback(parent=nil)
+    @fallback = parent
+    unless @fallsback
+      def self.[](key)
+        return @fallback[key] if @fallback and not key?(key) rescue super
+        super
+      end
+
+      def self.fetch(key, *args, &blk)
+        return @fallback.fetch(key, *args, &blk) if @fallback and not key?(key) rescue super
+        super
+      end
+      @fallsback = true
+    end
+    self
+  end
+
+end

data/work/consider/lib/core/facets/string/trim.rb

@@ -0,0 +1,70 @@
+class String
+	  def rtrim(char)
+		      dump.rtrim!(char)
+		        end
+
+	    def rtrim!(char)
+		        gsub!(/#{Regexp.escape(char)}+$/, '')
+				  end
+
+	      def ltrim(char)
+		          dump.ltrim!(char)
+			    end
+
+	        def ltrim!(char)
+			    gsub!(/^#{Regexp.escape(char)}+/, '')
+			      end
+
+
+=begin
+Trims a string:
+
+    * removes one initial blank line
+    * removes trailing spaces on each line
+    * if margin is given, removes initial spaces up to and including the margin on each line, plus one space
+
+This is designed specifically for working with inline documents. Here-documents are great, except they tend to go against the indentation of your code. This method allows a convenient way of using %{}-style documents. For instance:
+
+  USAGE = %{
+    | usage: prog [-o dir] -h file...
+    |   where
+    |     -o dir         outputs to DIR
+    |     -h             prints this message
+  }.trim("|")
+
+  # USAGE == "usage: prog [-o dir] -h file...\n  where"...
+  # (note single space to right of margin is deleted)
+
+Note carefully that if no margin string is given, then there is no clipping at the beginning of each line and your string will remain indented. You can use tabto(0) to align it with the left of screen (while preserving relative indentation).
+
+  USAGE = %{
+    usage: prog [-o dir] -h file...
+      where
+        -o dir         outputs to DIR
+        -h             prints this message
+  }.trim.tabto(0)
+
+  # USAGE == (same as last example)
+
+[Source]
+=end
+
+# File lib/extensions/string.rb, line 194
+    def trim(margin=nil)
+      s = self.dup
+      # Remove initial blank line.
+      s.sub!(/\A[ \t]*\n/, "")
+      # Get rid of the margin, if it's specified.
+      unless margin.nil?
+        margin_re = Regexp.escape(margin || "")
+        margin_re = /^[ \t]*#{margin_re} ?/
+        s.gsub!(margin_re, "")
+      end
+      # Remove trailing whitespace on each line
+      s.gsub!(/[ \t]+$/, "")
+      s
+    end
+
+
+end 
+

data/work/consider/lib/more/facets/argv.rb

@@ -0,0 +1,47 @@
+
+ARG = ARGV.dup
+
+class << ARG
+
+  def arguments
+    @arguments ||= select{ |e| e !~ /^-/ && e !~ /=/ }
+  end
+
+  def options
+    @options ||= (
+      pms = {}
+      select{ |e| /[=]/ =~ e }.each do |e|
+        k,v = e.split('=')
+        k.sub!(/^[-]{1,2}/,'')
+        pms.store(k,v)
+      end
+      select{ |e| e =~ /^-/ || e !~ /=/ }.each do |k|
+        k.sub!(/^[-]{1,2}/,'')
+        pms.store(k,true)
+      end
+      pms
+    )
+  end
+
+  def flags
+    @flags ||= select{ |e| e =~ /^-/ || e !~ /=/ }
+  end
+
+  # Have specific flag?
+
+  def flag?(flag)
+    flags.include?(flag)
+  end
+
+  #
+
+  def [](x)
+    case x
+    when Integer
+      arguments[x]
+    else
+      options[x.to_s]
+    end
+  end
+
+end

data/work/consider/lib/more/facets/extension.rb

@@ -0,0 +1,30 @@
+# Extension mixin
+
+module Extension
+
+  def self.included(base)
+    name = base.name.split('::').last
+    core = eval("::#{name}")
+    core.send(:include, base)
+  end
+
+end
+
+
+if __FILE__ == $0
+
+  module Facets
+    module String
+      include Extension
+
+      def drippy
+        puts "Drippy #{self}"
+      end
+    end
+  end
+
+  "Hello".drippy
+
+end
+
+

data/work/consider/lib/more/facets/fixnum.rb

@@ -0,0 +1,55 @@
+#--
+# Fixnum Constants
+# Copyright (c) 2005 Thomas Sawyer
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+#++
+
+# = Fixnum Constants
+#
+# Constants providing the numerical limitations of Fixnum class.
+#
+# == Synopsis
+#
+#   require 'mega/fixnum-constants'
+#
+#   puts Fixnum::MAX  #=>
+#
+
+class Fixnum
+  N_BYTES = [42].pack('i').size
+  N_BITS = N_BYTES * 8
+  MAX = 2 ** (N_BITS - 2) - 1
+  MIN = -MAX - 1
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+# TODO
+
+=begin testing
+
+  require 'test/unit'
+
+  class TC_FixnumConst < Test::Unit::TestCase
+
+    def test_01
+    end
+
+  end
+
+=end

data/work/consider/lib/more/facets/forwardable_chain.patch

@@ -0,0 +1,448 @@
+Index: lib/more/facets/forwardable_chain.rb
+===================================================================
+--- lib/more/facets/forwardable_chain.rb	(revision 0)
++++ lib/more/facets/forwardable_chain.rb	(revision 0)
+@@ -0,0 +1,162 @@
++# The ForwardableChain module is a superset of the capabilities of Forwardable.
++# It provides delegation of specified methods to a chain of designated objects,
++# using the class method _def_delegator_chain_. This class method becomes
++# available to your module when ForwardableChain is included in your module as
++# in the example below. (Note: *include* rather than _extend_.) Your module will
++# reveal ForwardableChain to be in its type hierarchy (see Module#ancestors),
++# which can be useful for debugging.
++# 
++# The pattern implemented by ForwardableChain is useful in creating presenter
++# classes and facade classes whose purpose is to abstract away the complexity of
++# working with graphs of objects.
++# 
++# For example, say you have a class _AccountFacade_ which has attributes
++# _current_ and _legacy_ representing two distinct but analogous system
++# interfaces. You can use ForwardableChain to define methods of AccountFacade
++# which call methods deep in the object graph of _current_ and _legacy_.
++# 
++#   class AccountPresenter
++#     
++#     include ForwardableChain
++#     
++#     # Define a #name method that looks first in #current and then in
++#     # #legacy for an account name -- that is, #current overrides #legacy.
++#     def_delegator_chain :name, {:current => {:account => :name}},
++#                                {:legacy => {:account => {:name_info => :acct_name}}}
++#     
++#     # Define a #primary_ssn method that returns
++#     # current.account.primary_holder.ssn unless any of the intermediate return
++#     # values are nil.
++#     def_delegator_chain :primary_ssn, :current => {:account => {:primary_holder => :ssn}}
++#     
++#     # Define an #aggregate_balance method that returns current.grand_total
++#     # unless #current is nil.
++#     def_delegator_chain :aggregate_balance, :current => :grand_total
++#     
++#   end
++# 
++# The following is the sequence of method calls triggered by a call to
++# <em>AccountPresenter#name</em> defined above:
++# 
++# - <em>name</em> -- which calls ...
++#   - <em>current</em> -- if it returns +nil+ then _legacy_ is called, otherwise ...
++#     - <em>current.account</em> -- on which, unless it returns +nil+, is called ...
++#       - <em>current.account.name</em> -- if it returns +nil+, then is called ...
++#   - <em>legacy</em> -- unless it returns +nil+ ...
++#     - <em>legacy.account</em> -- on which, unless it returns +nil+, is called ...
++#       - <em>legacy.account.name_info</em> -- on which, unless it returns +nil+, is called ...
++#         - <em>legacy.account.name_info.acct_name</em>
++# 
++# Methods with arguments are also supported, but be sure that all the methods in
++# the chain can receive the same arguments, or else an ArgumentError will occur
++# when you call your delegator method.
++# 
++# You can also use instance variables as links in a delegate chain as follows.
++# 
++#   class AccountPresenter
++#     
++#     include ForwardableChain
++#     
++#     # Define an #aggregate_balance method that returns the @grand_total
++#     # variable of @current unless @current is nil.
++#     def_delegator_chain :aggregate_balance, :@current => :@grand_total
++#     
++#   end
++# 
++# Instance variables and methods both can appear in a chain. As you might
++# expect, arguments are ignored when accessing instance variables.
++module ForwardableChain
++  
++  module ClassMethods
++    
++    # Alias for #def_instance_delegator_chain.
++    def def_delegator_chain(method, *delegates)
++      def_instance_delegator_chain method, *delegates
++    end
++    
++    # Defines a method _method_ which delegates to a series of method calls
++    # described by one or more Hash objects provided as _delegates_.
++    # 
++    # See the examples at ForwardableChain.
++    def def_instance_delegator_chain(method, *delegates)
++      delegates.each do |delegate|
++        DelegateExtension.extend_recursive delegate
++        unless delegate.valid_recursive?
++          raise ArgumentError,
++                'expected the name of a new method to be defined, followed ' +
++                'by an argument array of zero or more hashes -- possibly '   +
++                'nested, each containing a single key -- representing a '    +
++                'chain of method calls and/or instance variables used to '   +
++                'supply the return value of the method'
++        end
++      end
++      define_method(method) do |*args|
++        result = nil
++        delegates.each do |delegate|
++          unless (value = delegate.call_recursive(self, *args)).nil?
++            result = value
++            break
++          end
++        end
++        result
++      end
++    end
++    
++  end
++  
++  module DelegateExtension #:nodoc:
++    
++    class << self
++      
++      def extend_recursive(hash)
++        return false unless hash.kind_of?(Hash)
++        hash.extend self
++        hash.each_pair { |key, value| extend_recursive value }
++        true
++      end
++      
++      def send_message_or_get_instance_variable(receiver,
++                                                message_or_instance_variable,
++                                                *args)
++        if message_or_instance_variable.to_s[0..0] == '@'
++          receiver.instance_variable_get message_or_instance_variable
++        else
++          receiver.send message_or_instance_variable, *args
++        end
++      end
++      
++    end
++    
++    def call_recursive(receiver, *args)
++      next_receiver_name = keys.first
++      next_receiver = DelegateExtension.send_message_or_get_instance_variable(receiver,
++                                                                              next_receiver_name,
++                                                                              *args)
++      return nil if next_receiver.nil?
++      next_message_or_delegate = self[next_receiver_name]
++      if next_message_or_delegate.respond_to?(:call_recursive)
++        return next_message_or_delegate.call_recursive(next_receiver, *args)
++      end
++      DelegateExtension.send_message_or_get_instance_variable next_receiver,
++                                                              next_message_or_delegate,
++                                                              *args
++    end
++    
++    def valid_recursive?
++      return false unless (length == 1)
++      next_receiver = self[keys.first]
++      return true if next_receiver.kind_of?(Symbol)
++      if next_receiver.respond_to?(:valid_recursive?)
++        return next_receiver.valid_recursive?
++      end
++      false
++    end
++    
++  end
++  
++  # Extends _other_module_ with the instance methods of ClassMethods.
++  def self.included(other_module)
++    other_module.extend ClassMethods
++  end
++  
++end
+Index: test/more/test_forwardable_chain.rb
+===================================================================
+--- test/more/test_forwardable_chain.rb	(revision 0)
++++ test/more/test_forwardable_chain.rb	(revision 0)
+@@ -0,0 +1,276 @@
++require 'test/unit'
++require 'rubygems'
++require 'mocha'
++require 'facets/forwardable_chain'
++
++module ForwardableChainTest #:nodoc: all
++  
++  class MethodWithNoDelegates < Test::Unit::TestCase
++    
++    class Foo
++      
++      include ForwardableChain
++      
++      def_instance_delegator_chain :no_delegates
++      
++    end
++    
++    def test_should_return_nil
++      assert_nil Foo.new.no_delegates
++    end
++    
++  end
++  
++  class MethodWithOneDelegateThatIsInvalidBecauseItContainsMoreThanOneKeyValuePair < Test::Unit::TestCase
++    
++    def test_should_raise_argument_error_from_definition
++      assert_raise(ArgumentError) do
++        self.class.class_eval <<-end_class_eval
++          class Foo
++            include ForwardableChain
++            def_instance_delegator_chain :one_invalid_delegate, :bar => :baz,
++                                                                :bat => :pwop
++          end
++        end_class_eval
++      end
++    end
++    
++  end
++  
++  class MethodWithOneSimpleMethodDelegate < Test::Unit::TestCase
++    
++    class Foo
++      
++      include ForwardableChain
++      
++      def_instance_delegator_chain :one_simple_delegate, :bar => :baz
++      
++    end
++    
++    def test_should_call_first_delegate_with_no_args
++      foo = Foo.new
++      
++      mock_bar = mock
++      mock_bar.expects(:baz).with().returns 'baz'
++      foo.expects(:bar).with().returns mock_bar
++      
++      assert_equal 'baz', foo.one_simple_delegate
++    end
++    
++  end
++  
++  class MethodWithOneSimpleVariableDelegate < Test::Unit::TestCase
++    
++    class Foo
++      
++      include ForwardableChain
++      
++      def_instance_delegator_chain :one_simple_delegate, :@bar => :@baz
++      
++    end
++    
++    def test_should_access_first_delegate
++      foo = Foo.new
++      
++      mock_bar = mock
++      mock_bar.expects(:instance_variable_get).with(:@baz).returns 'baz'
++      foo.expects(:instance_variable_get).with(:@bar).returns mock_bar
++      
++      assert_equal 'baz', foo.one_simple_delegate
++    end
++    
++  end
++  
++  class MethodWithOneComplexMethodDelegate < Test::Unit::TestCase
++    
++    class Foo
++      
++      include ForwardableChain
++      
++      def_instance_delegator_chain :one_complex_delegate, :bar => {:baz => :bat}
++      
++    end
++    
++    def setup
++      @foo = Foo.new
++    end
++    
++    def test_should_call_delegate_with_no_arguments
++      mock_baz = mock
++      mock_baz.expects(:bat).with().returns 'bat'
++      mock_bar = mock
++      mock_bar.expects(:baz).with().returns mock_baz
++      @foo.expects(:bar).with().returns mock_bar
++      
++      assert_equal 'bat', @foo.one_complex_delegate
++    end
++    
++    def test_should_call_delegate_with_one_argument
++      mock_baz = mock
++      mock_baz.expects(:bat).with(:an_arg).returns 'bat'
++      mock_bar = mock
++      mock_bar.expects(:baz).with(:an_arg).returns mock_baz
++      @foo.expects(:bar).with(:an_arg).returns mock_bar
++      
++      assert_equal 'bat', @foo.one_complex_delegate(:an_arg)
++    end
++    
++    def test_should_call_delegate_with_no_arguments_and_return_nil_if_delegate_has_nil_intermediate_value
++      mock_bar = mock
++      mock_bar.expects(:baz).with().returns nil
++      @foo.expects(:bar).with().returns mock_bar
++      
++      assert_nil @foo.one_complex_delegate
++    end
++    
++    def test_should_call_delegate_with_one_argument_and_return_nil_if_delegate_has_nil_intermediate_value
++      mock_bar = mock
++      mock_bar.expects(:baz).with(:an_arg).returns nil
++      @foo.expects(:bar).with(:an_arg).returns mock_bar
++      
++      assert_nil @foo.one_complex_delegate(:an_arg)
++    end
++    
++  end
++  
++  class MethodWithOneComplexVariableDelegate < Test::Unit::TestCase
++    
++    class Foo
++      
++      include ForwardableChain
++      
++      def_instance_delegator_chain :one_complex_delegate, :@bar => {:@baz => :@bat}
++      
++    end
++    
++    def setup
++      @foo = Foo.new
++    end
++    
++    def test_should_access_delegate
++      mock_baz = mock
++      mock_baz.expects(:instance_variable_get).with(:@bat).returns 'bat'
++      mock_bar = mock
++      mock_bar.expects(:instance_variable_get).with(:@baz).returns mock_baz
++      @foo.expects(:instance_variable_get).with(:@bar).returns mock_bar
++      
++      assert_equal 'bat', @foo.one_complex_delegate
++    end
++    
++    def test_should_access_delegate_and_return_nil_if_delegate_has_nil_intermediate_value
++      mock_bar = mock
++      mock_bar.expects(:instance_variable_get).with(:@baz).returns nil
++      @foo.expects(:instance_variable_get).with(:@bar).returns mock_bar
++      
++      assert_nil @foo.one_complex_delegate
++    end
++    
++  end
++  
++  class MethodWithTwoJaggedComplexMethodDelegates < Test::Unit::TestCase
++    
++    class Foo
++      
++      include ForwardableChain
++      
++      def_instance_delegator_chain :two_jagged_complex_delegates, {:bar => {:baz => :bat}},
++                                                                  {:pwop => {:ding => {:dit => :dat}}}
++      
++    end
++    
++    def setup
++      @foo = Foo.new
++    end
++    
++    def test_should_call_only_first_delegate_with_no_arguments
++      mock_baz = mock
++      mock_baz.expects(:bat).with().returns 'bat'
++      mock_bar = mock
++      mock_bar.expects(:baz).with().returns mock_baz
++      @foo.expects(:bar).with().returns mock_bar
++      
++      assert_equal 'bat', @foo.two_jagged_complex_delegates
++    end
++    
++    def test_should_call_only_first_delegate_with_one_argument
++      mock_baz = mock
++      mock_baz.expects(:bat).with(:an_arg).returns 'bat'
++      mock_bar = mock
++      mock_bar.expects(:baz).with(:an_arg).returns mock_baz
++      @foo.expects(:bar).with(:an_arg).returns mock_bar
++      
++      assert_equal 'bat', @foo.two_jagged_complex_delegates(:an_arg)
++    end
++    
++    def test_should_call_both_delegates_with_no_arguments_and_return_nil_if_both_delegates_have_nil_intermediate_values
++      mock_bar = mock
++      mock_bar.expects(:baz).with().returns nil
++      @foo.expects(:bar).with().returns mock_bar
++      
++      mock_ding = mock
++      mock_ding.expects(:dit).with().returns nil
++      mock_pwop = mock
++      mock_pwop.expects(:ding).with().returns mock_ding
++      @foo.expects(:pwop).with().returns mock_pwop
++      
++      assert_nil @foo.two_jagged_complex_delegates
++    end
++    
++    def test_should_call_both_delegates_with_one_argument_and_return_nil_if_both_delegates_have_nil_intermediate_values
++      mock_bar = mock
++      mock_bar.expects(:baz).with(:an_arg).returns nil
++      @foo.expects(:bar).with(:an_arg).returns mock_bar
++      
++      mock_ding = mock
++      mock_ding.expects(:dit).with(:an_arg).returns nil
++      mock_pwop = mock
++      mock_pwop.expects(:ding).with(:an_arg).returns mock_ding
++      @foo.expects(:pwop).with(:an_arg).returns mock_pwop
++      
++      assert_nil @foo.two_jagged_complex_delegates(:an_arg)
++    end
++    
++  end
++  
++  class MethodWithTwoJaggedComplexVariableDelegates < Test::Unit::TestCase
++    
++    class Foo
++      
++      include ForwardableChain
++      
++      def_instance_delegator_chain :two_jagged_complex_delegates, {:@bar => {:@baz => :@bat}},
++                                                                  {:@pwop => {:@ding => {:@dit => :@dat}}}
++      
++    end
++    
++    def setup
++      @foo = Foo.new
++    end
++    
++    def test_should_access_only_first_delegate
++      mock_baz = mock
++      mock_baz.expects(:instance_variable_get).with(:@bat).returns 'bat'
++      mock_bar = mock
++      mock_bar.expects(:instance_variable_get).with(:@baz).returns mock_baz
++      @foo.expects(:instance_variable_get).with(:@bar).returns mock_bar
++      
++      assert_equal 'bat', @foo.two_jagged_complex_delegates
++    end
++    
++    def test_should_access_both_delegates_and_return_nil_if_both_delegates_have_nil_intermediate_values
++      mock_bar = mock
++      mock_bar.expects(:instance_variable_get).with(:@baz).returns nil
++      @foo.expects(:instance_variable_get).with(:@bar).returns mock_bar
++      
++      mock_ding = mock
++      mock_ding.expects(:instance_variable_get).with(:@dit).returns nil
++      mock_pwop = mock
++      mock_pwop.expects(:instance_variable_get).with(:@ding).returns mock_ding
++      @foo.expects(:instance_variable_get).with(:@pwop).returns mock_pwop
++      
++      assert_nil @foo.two_jagged_complex_delegates
++    end
++    
++  end
++  
++end