LazyEnumerable 0.0.3 → 0.0.4

data/lib/lazy/extensions.rb

@@ -18,7 +18,7 @@ end
 module Enumerable
   
   def to_lazy
-    Lazy::LazyEnumerable.new(self)
+    Lazy::LazyEnumerable.new(self.method(:collect))
   end
   
   def to_real

data/lib/lazy/lazy_enumerable.rb

@@ -1,79 +1,103 @@
-### It takes a functional approach to the common Enumerable protocol of select, collect, and reject. 
-### By functional, I mean the collection is not changed nor is a new modified one created. 
-### The blocks are kept around until they are absolutely needed. 
-### I have been wanting this functionality for some time because it's nice for large collections. 
-### If you have a collection in which you are calling a lot selects, rejects, or collects on, 
-### then this will not create the intermediate collections. 
-### It will wait until you ask something of the collection where it can not delay the answer. 
-### This should make these chained operations must faster on large collections. 
-###
-### This was a lot of fun to program and it's not that big. Take whatever you want from it!
-
-module Lazy
-  
-  class LazyEnumerable < AbstractEnumerable
-    @@cached={}
-    
-    ##
-    ## Meta-programming to provide a shorthand for extensions to let themselves
-    ## known so that they can be found on the method_missing.
-    ##
-    def self.define_for(method_name)
-      @@cached[method_name]=self
-    end
-    
-    ##
-    ## Lookup a subclass for the particular method. Basically, this is so that each
-    ## template will provide its own functionality for each
-    ##
-    def self.class_for(method_name)
-      @@cached[method_name]
-    end
-    
-    
-    
-    def initialize(original, block=PLACEBO)
-      @original=original
-      @block=block
-      _freeze
-    end
-    
-    ##
-    ## This is basically the default implementation and should be overriden in
-    ## subclasses. It's because we can create a basic LazyEnumerable (on call to_lazy)
-    ## that simply is a placebo implementation to keep things simple
-    ##
-    
-    def each(&block)
-      @original.each(&block)
-    end
-    
-    ##
-    ## Look up the implementation of the iterator method (for example, :select, :collect:, etc)
-    ## I do define the missing method on this call. The reason is for ease of debugging and
-    ## speed. We don't need to go through this logic. It's on the fly code generation without
-    ## eval
-    ##
-    def method_missing(method_name, *arguments)
-      my_class=self._class.class_for(method_name)
-      if (my_class.nil?)
-        super.method_missing(method_name, *arguments)
-      end
-      
-      proc = lambda {|*args| my_class.new(self, *args)}
-      self._class.send(:define_method, method_name, &proc)
-      proc.call(*arguments)
-    end
-    
-    def respond_to?(symbol,include_private = false)
-      my_class=self._class.class_for(method_name)
-      !my_class.nil?
-    end
-    
-    def to_real
-      _collect(&PLACEBO)
-    end
-    
-  end
-  
+###
+### LazyEnumerable makes the implementation of higher order methods easier. LazyIterator
+### is a simple implemetation of that. It basically works by "stacking" up the method
+### calls until the collection needs to be calculated (realized). It then calls the
+### "stacked up" methods.
+###
+### LazyEnumerable is immutable and I would like LazyIterator to be as well. But,
+### every attempt has made the code ugly and inelegant. I'm still looking for a good
+### solution. Immuntability gives the ability to calculate on different levels.
+###
+module Lazy
+  
+  class LazyEnumerable
+    PLACEBO=lambda {|each| each}
+    
+    ##
+    ## Remove any unnecessary methods so that method_missing is invoked
+    ##
+    def self.wack_all_my_methods
+      to_wack = instance_methods.reject do |each|
+        ['===','method_missing'].include?(each) || each =~ /^__/
+      end
+      to_wack.each do |each|
+        alias_method("_#{each}", each)
+        undef_method(each)
+      end
+    end
+    
+    def self.iterator_creator(*method_names)
+      method_names.each { |every| iterator_creator_for(every) }
+    end
+    
+    def self.iterator_creator_for(method_name)
+      non_lazy_name = /lazy_(.+)/.match(method_name.to_s)[1].to_sym
+      define_method(method_name) { LazyEnumerable.new(_method(non_lazy_name)) }
+    end
+    
+    wack_all_my_methods
+    include Enumerable
+    iterator_creator :lazy_inject, :lazy_select, :lazy_collect, :lazy_reject, :lazy_detect, :lazy_each
+    
+    
+    
+    def initialize(proc)
+      @internal=proc
+      @sends=[]
+    end
+    
+    ##
+    ## Simply make a closure around the method and capturing it's arguments as well
+    ## This is so it can be replayed. Notice again, I cache the method with a define_method
+    ##
+    def method_missing(method_name, *arguments)
+      proc=lambda do |*args|
+        send=lambda {|each| each.send(method_name, *args)}
+        @sends << send
+        self
+      end
+      self._class.send(:define_method, method_name, &proc)
+      proc.call(*arguments)
+    end
+    
+    def respond_to?(symbol,include_private = false)
+      true
+    end
+    
+    ##
+    ## Do a placebo collect to get it to create an array with the elements
+    ##
+    def to_real
+      collect(&PLACEBO)
+    end
+    
+    ##
+    ## Call each member in the original collection and call each "captured" method
+    ## in succession. Notice the use of inject to make this really elegant and succint.
+    ## I do cheat a little and realize the collection and then call each. I want
+    ## to change this in the future. Actually, 1.9 will make this possible. We'll
+    ## be able to use iterators and will make below more lazy.
+    ##
+    def each(&block)
+      answer = @internal.call do |each|
+        @sends.inject(each) do |result, each_send |
+          each_send.call(result)
+        end
+      end
+      answer.each(&block)
+    end
+    
+    ##
+    ## Give me the size. This can be dangerous if you ever wrap an infinite enumerable
+    ##
+    def size
+      inject(0) {|sum,each| sum + 1 }
+    end
+    
+    def to_lazy
+      self
+    end
+    
+  end
+  
 end

data/lib/lazy_enumerable.rb

@@ -1,7 +1,2 @@
 require 'lazy/extensions'
-require 'lazy/abstract_enumerable'
-require 'lazy/lazy_enumerable'
-require 'lazy/collect_enumerable'
-require 'lazy/reject_enumerable'
-require 'lazy/select_enumerable'
-require 'lazy/message_collector'
+require 'lazy/lazy_enumerable'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: LazyEnumerable
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - Blaine Buxton
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-05 00:00:00 -05:00
+date: 2008-10-06 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -26,13 +26,8 @@ files:
 - tests/lazy_enumerable_test.rb
 - tests/lazy_enumerable_test_suite.rb
 - lib/lazy
-- lib/lazy/abstract_enumerable.rb
-- lib/lazy/collect_enumerable.rb
 - lib/lazy/extensions.rb
 - lib/lazy/lazy_enumerable.rb
-- lib/lazy/message_collector.rb
-- lib/lazy/reject_enumerable.rb
-- lib/lazy/select_enumerable.rb
 - lib/lazy_enumerable.rb
 - README
 - LICENSE

data/lib/lazy/abstract_enumerable.rb

@@ -1,50 +0,0 @@
-module Lazy
-  class AbstractEnumerable
-    PLACEBO=lambda {|each| each}
-    
-    ##
-    ## Remove any unnecessary methods so that method_missing is invoked
-    ##
-    def self.wack_all_my_methods
-      to_wack = instance_methods.reject do |each|
-        ['===','method_missing'].include?(each) || each =~ /^__/
-      end
-      to_wack.each do |each|
-        alias_method("_#{each}", each)
-        undef_method(each)
-      end
-    end
-    
-    def self.iterator_creator(*method_names)
-      method_names.each { |every| iterator_creator_for(every) }
-    end
-    
-    def self.iterator_creator_for(method_name)
-      non_lazy_name = /lazy_(.+)/.match(method_name.to_s)[1].to_sym
-      define_method(method_name) { iterator_class.new(_method(non_lazy_name)) }
-    end
-    
-    wack_all_my_methods
-    include Enumerable
-    iterator_creator :lazy_select, :lazy_collect, :lazy_reject, :lazy_detect, :lazy_each
-    
-    ##
-    ## Give me the size. This can be dangerous if you ever wrap an infinite enumerable
-    ##
-    def size
-      inject(0) {|sum,each| sum + 1 }
-    end
-    
-    def to_lazy
-      self
-    end
-    
-    ##
-    ## This should be added with definition of the iterator class
-    ##
-    def iterator_class
-      raise(NotImplementedError, "iterator_class", caller);
-    end
-    
-  end
-end

data/lib/lazy/collect_enumerable.rb

@@ -1,14 +0,0 @@
-module Lazy
-  
-  class CollectEnumerable < LazyEnumerable
-    define_for(:lazy_collect)
-    
-    def each(&each_block)
-      @original.each do |every|
-        each_block.call(@block.call(every))
-      end
-    end
-    
-  end
-  
-end

data/lib/lazy/message_collector.rb

@@ -1,68 +0,0 @@
-###
-### LazyEnumerable makes the implementation of higher order methods easier. LazyIterator
-### is a simple implemetation of that. It basically works by "stacking" up the method
-### calls until the collection needs to be calculated (realized). It then calls the
-### "stacked up" methods.
-###
-### LazyEnumerable is immutable and I would like LazyIterator to be as well. But,
-### every attempt has made the code ugly and inelegant. I'm still looking for a good
-### solution. Immuntability gives the ability to calculate on different levels.
-###
-module Lazy
-  
-  class MessageCollector < AbstractEnumerable
-    
-    def initialize(proc)
-      @internal=proc
-      @sends=[]
-    end
-    
-    ##
-    ## Simply make a closure around the method and capturing it's arguments as well
-    ## This is so it can be replayed. Notice again, I cache the method with a define_method
-    ##
-    def method_missing(method_name, *arguments)
-      proc=lambda do |*args|
-        send=lambda {|each| each.send(method_name, *args)}
-        @sends << send
-        self
-      end
-      self._class.send(:define_method, method_name, &proc)
-      proc.call(*arguments)
-    end
-    
-    def respond_to?(symbol,include_private = false)
-      true
-    end
-    
-    ##
-    ## Do a placebo collect to get it to create an array with the elements
-    ##
-    def to_real
-      collect(&PLACEBO)
-    end
-    
-    ##
-    ## Call each member in the original collection and call each "captured" method
-    ## in succession. Notice the use of inject to make this really elegant and succint.
-    ## I do cheat a little and realize the collection and then call each. I want
-    ## to change this in the future.
-    ##
-    def each(&block)
-      answer = @internal.call do |each|
-        @sends.inject(each) do |result, each_send |
-          each_send.call(result)
-        end
-      end
-      answer.each(&block)
-    end
-    
-  end
-  
-  class AbstractEnumerable
-    def iterator_class
-      MessageCollector
-    end
-  end
-  
-end

data/lib/lazy/reject_enumerable.rb

@@ -1,14 +0,0 @@
-module Lazy
-  
-  class RejectEnumerable < LazyEnumerable
-    define_for(:lazy_reject)
-    
-    def each(&each_block)
-      @original.each do |every|
-        each_block.call(every) unless @block.call(every)
-      end
-    end
-    
-  end
-  
-end

data/lib/lazy/select_enumerable.rb

@@ -1,14 +0,0 @@
-module Lazy
-  
-  class SelectEnumerable < LazyEnumerable
-    define_for(:lazy_select)
-    
-    def each(&each_block)
-      @original.each do |every|
-        each_block.call(every) if @block.call(every)
-      end
-    end
-    
-  end
-  
-end