multiplexing_delegator 0.1.0 → 0.1.1

data/History.txt

@@ -1,3 +1,9 @@
+== 0.1.1 / 2008-01-26
+
+* Switched the delegation accessor from :on to :across.
+* Included Enumerable and will now treat methods to call on the delegated methods differently than methods Enumerable like #map, #inject, etc.
+* Stopped deciding whether or not return to nils and are just returning whatever is available. User can compact if they do not want nils.
+
 == 0.1.0 / 2008-01-25
 
 * Birth to the MultiplexingDelegator!

data/README.txt

@@ -21,16 +21,19 @@ accessors for a given object instance and aggregating the results.
 Example
  class Foo
    attr_accessor :baz, :bum
-   multiplex :bar, :on => [:baz, :bum]
+   multiplex :bar, :across => [:baz, :bum]
  end
 
  foo = Foo.new
  foo.baz = 1
- foo.bum = ['boo']
+ foo.bum = 'boo'
  foo.bar.map => [1, 'boo']
+ foo.bar.each {|item| puts "Yo yo #{item}"}
+ => Yo yo 1
+ => Yo yo boo
 
 You can also proxy method calls to each of the delegated items and results
-will be aggregated.
+will be aggregated. This was the actual impetus behind writing this little gem.
 
 Example
  class Goo
@@ -43,6 +46,22 @@ Example
  foo.bum = Goo.new('world')
  foo.bar.car => ['hello, 'world']
 
+A feature of multiplex that you may not expect is that it will flatten
+arrays to one-level deep so as to simulate a single stream of results. For
+instance, using Foo from above:
+
+ foo = Foo.new
+ foo.baz = 'hello world'
+ foo.bum = ['how', 'are', 'you]
+ foo.bar.map => ['hello world', 'how', 'are', 'you']
+
+However, multiplex will not flatten more than one level deep. For example:
+
+ foo = Foo.new
+ foo.baz = [['hello', 'world']]
+ foo.bum = [['how', 'are', 'you]]
+ foo.bar.map => [['hello', 'world'], ['how', 'are', 'you']]
+
 == REQUIREMENTS:
 
 Ruby 1.8.6 and above

data/lib/multiplexing_delegator.rb

@@ -1,9 +1,6 @@
-# class MultiplexingDelegator
-#   VERSION = '0.1.0'
-# end
 module Glomp #:nodoc:
   module MultiplexingDelegator #:nodoc:
-    VERSION = '0.1.0'
+    VERSION = '0.1.1'
 
     # The multiplex class method is used to define a delegator method that
     # multiplexes calls to a method across many methods for an instance of an
@@ -16,12 +13,12 @@ module Glomp #:nodoc:
     # Example
     #  class Foo
     #    attr_accessor :baz, :bum
-    #    multiplex :bar, :on => [:baz, :bum]
+    #    multiplex :bar, :across => [:baz, :bum]
     #  end
     #
     #  foo = Foo.new
     #  foo.baz = 1
-    #  foo.bum = ['boo']
+    #  foo.bum = 'boo'
     #  foo.bar.map => [1, 'boo']
     #  foo.bar.each {|item| puts "Yo yo #{item}"}
     #  => Yo yo 1
@@ -41,9 +38,25 @@ module Glomp #:nodoc:
     #  foo.bum = Goo.new('world')
     #  foo.bar.car => ['hello, 'world']
     #
+    # A feature of multiplex that you may not expect is that it will flatten
+    # arrays to one-level deep so as to simulate a single stream of results. For
+    # instance, using Foo from above:
+    #
+    #  foo = Foo.new
+    #  foo.baz = 'hello world'
+    #  foo.bum = ['how', 'are', 'you]
+    #  foo.bar.map => ['hello world', 'how', 'are', 'you']
+    #
+    # However, multiplex will not flatten more than one level deep. For example:
+    #
+    #  foo = Foo.new
+    #  foo.baz = [['hello', 'world']]
+    #  foo.bum = [['how', 'are', 'you]]
+    #  foo.bar.map => [['hello', 'world'], ['how', 'are', 'you']]
+    #
     def multiplex(method, opts={})
       define_method(method) do
-        @multiplexer ||= Multiplexer.new(method, self, opts[:on])
+        @multiplexer ||= Multiplexer.new(method, self, opts[:across])
       end
     end
 
@@ -52,6 +65,8 @@ module Glomp #:nodoc:
     end
 
     class Multiplexer < BlankSlate
+      include Enumerable
+
       def initialize(name, target, on=[])
         @target = target
         @multiplexed = (array?(on) ? on : [on]).compact
@@ -61,18 +76,30 @@ module Glomp #:nodoc:
         end
       end
 
-      def method_missing(sym, *args, &block)
-        @multiplexed.inject([]) do |acc, proxy_to|
-          proxy_target = @target.send(proxy_to)
-          if proxy_target
-            val = proxy_target.send(sym, *args, &block)
-            acc = acc.send((array?(val) ? :+ : :<<), val)
+      def each(&block)
+        multiplexed_each do |proxy_target|
+          if array?(proxy_target)
+            proxy_target.each {|proxied_value| yield(proxied_value)}
+          else
+            yield(proxy_target)
           end
-          acc
         end
       end
+
+      def method_missing(sym, *args, &block)
+        results = []
+        multiplexed_each do |proxy_target|
+          proxy_value = proxy_target.send(sym, *args, &block) if proxy_target
+          results.send((array?(proxy_value) ? :+ : :<<), proxy_value)
+        end
+        results
+      end
       
     private
+      def multiplexed_each(&block)
+        @multiplexed.each { |proxy_to| yield(@target.send(proxy_to))}
+      end
+
       def array?(obj) obj.kind_of?(Array); end
     end
 

data/test/test_multiplexing_delegator.rb

@@ -1,6 +1,9 @@
 require 'multiplexing_delegator'
 require 'test/unit'
 
+require 'rubygems'
+require 'mocha'
+
 class Foo
   attr_accessor :bar
   def initialize(bar) @bar = bar; end
@@ -12,14 +15,29 @@ end
 
 class Family
   attr_accessor :adults, :children, :pets
-  multiplex :members, :on => [:adults, :children, :pets]
+  multiplex :members, :across => [:adults, :children, :pets]
 end
 
 class TestMultiplexingDelegator < Test::Unit::TestCase
 
-  def test_multiplex_returns_empty_array_when_nothing_to_aggregate
+  def test_should_only_create_one_multiplex_instance_per_object_instance
+    family = Family.new
+    assert_same family.members.__id__, family.members.__id__
+    assert_not_equal Family.new.members.__id__, family.members.__id__
+  end
+
+  def test_multiplexer_should_include_single_element_number_returns
+    family = Family.new
+    family.adults = 1; family.children = 2; family.pets = 3
+    assert_equal [1, 2, 3], family.members.map
+  end
+
+  def test_should_include_single_element_returns
     family = Family.new
-    assert_equal [], family.members.map
+    family.adults = 'mom'
+    family.children = ['thing 1', 'thing 2']
+    family.pets = 'dog'
+    assert_equal ['mom'] + family.children + ['dog'], family.members.map
   end
 
   def test_multiplex_returns_flat_array_when_aggregating
@@ -31,26 +49,17 @@ class TestMultiplexingDelegator < Test::Unit::TestCase
       family.members.map
   end
 
-  def test_should_only_create_one_multiplex_instance_per_object_instance
+  def test_multiplex_returns_array_of_nils_when_nothing_to_aggregate
     family = Family.new
-    assert_same family.members.__id__, family.members.__id__
-    assert_not_equal Family.new.members.__id__, family.members.__id__
+    assert_equal [nil, nil, nil], family.members.map
   end
 
-  def test_should_include_single_element_returns
-    family = Family.new
-    family.adults = 'mom'
-    family.children = ['thing 1', 'thing 2']
-    family.pets = 'dog'
-    assert_equal ['mom'] + family.children + ['dog'], family.members.map
-  end
-
-  def test_should_ignore_nil_values
+  def test_should_not_ignore_nil_values_when_enumerable_kicks_in
     family = Family.new
     family.adults = nil
     family.children = ['superfudge']
     family.pets = 'dog'
-    assert_equal ['superfudge', 'dog'], family.members.map
+    assert_equal [nil, 'superfudge', 'dog'], family.members.map
   end
 
   def test_should_accept_nil_array_values
@@ -58,7 +67,7 @@ class TestMultiplexingDelegator < Test::Unit::TestCase
     family.adults = [nil]
     family.children = [nil]
     family.pets = nil
-    assert_equal [nil, nil], family.members.map
+    assert_equal [nil, nil, nil], family.members.map
   end
 
   def test_should_throw_no_method_found_when_calling_unknown_method_on_assoc
@@ -82,10 +91,18 @@ class TestMultiplexingDelegator < Test::Unit::TestCase
     assert_equal [1, 2, 3], family.members.bar
   end
 
+  def test_should_not_ignore_nil_proxies
+    family = Family.new
+    family.adults = Foo.new(1)
+    family.children = nil
+    family.pets = Foo.new(3)
+    assert_equal [1, nil, 3], family.members.bar
+  end
+
   def test_should_accept_non_array_values_for_on
     family = Family.new
     class << family
-      multiplex :foo, :on => :children
+      multiplex :foo, :across => :children
     end
     family.children = Foo.new('howdy')
     assert_equal ['howdy'], family.foo.bar
@@ -94,7 +111,7 @@ class TestMultiplexingDelegator < Test::Unit::TestCase
   def test_should_bail_with_a_nil_on
     family = Family.new
     class << family
-      multiplex :foo, :on => nil
+      multiplex :foo, :across => nil
     end
     assert_raise(::ArgumentError) do
       family.foo.map

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: multiplexing_delegator
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - Justin Knowlden