LazyEnumerable 0.0.1

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2008 Blaine Buxton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,20 @@
+### Comment Unit Tests
+### Author:: Blaine Buxton  (mailto:altodorado@blainebuxton.com)
+### Copyright:: Copyright (c) 2008
+### License::   See LICENSE
+###
+### 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!
+###
+### Read the tests to see how it works!
+### If you learn anything from this please feel to send me an email!
+###
+### Check out the tests for examples.

data/lib/lazy/collect_enumerable.rb

@@ -0,0 +1,14 @@
+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/extensions.rb

@@ -0,0 +1,28 @@
+###
+### Hack to get the current method off the stack. I hate this.
+### Why can't I reflect on the stack and get the real method 
+### invocation? Grrr...
+###
+module Kernel
+  
+  private
+  def current_method
+    (caller[0] =~ /`([^']*)'/ and $1).to_sym
+  end
+  
+end
+
+###
+### Conversion methods
+###
+module Enumerable
+  
+  def to_lazy
+    Lazy::LazyEnumerable.new(self)
+  end
+  
+  def to_real
+    self
+  end
+  
+end

data/lib/lazy/iterator.rb

@@ -0,0 +1,63 @@
+###
+### 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 Iterator < LazyEnumerable
+    
+    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 { |each| each }
+    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)
+      method_missing(:each, &block) if (block.nil?)
+      answer=@internal.call do |each|
+        result=@sends.inject(each) do |result, each_send |
+          each_send.call(result)
+        end
+      end
+      answer.each(&block)
+    end
+    
+  end
+  
+end

data/lib/lazy/lazy_enumerable.rb

@@ -0,0 +1,123 @@
+### 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
+    ##
+    ## 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
+    
+    ##
+    ## Wack all of my methods, then apply Enumerable and define my constants
+    ## and class variable for cached method calls
+    ##
+    wack_all_my_methods
+    include Enumerable
+    PLACEBO=lambda {|each| each}
+    @@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 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.new(_method(non_lazy_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
+    
+    ##
+    ## 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
+    
+    def to_real
+      _collect(PLACEBO)
+    end
+    
+    ##
+    ## Create the lazy iterators when no block is passed in the methods
+    ## below
+    ##
+    iterator_creator :lazy_select, :lazy_collect, :lazy_reject, :lazy_detect, :lazy_each
+    
+  end
+  
+end

data/lib/lazy/reject_enumerable.rb

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,14 @@
+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

data/lib/lazy_enumerable.rb

@@ -0,0 +1,6 @@
+require 'lazy/extensions'
+require 'lazy/lazy_enumerable'
+require 'lazy/collect_enumerable'
+require 'lazy/reject_enumerable'
+require 'lazy/select_enumerable'
+require 'lazy/iterator'

data/tests/lazy_enumerable_test.rb

@@ -0,0 +1,38 @@
+require 'test/unit'
+class LazyEnumerableTest < Test::Unit::TestCase
+  
+  def test_lazy
+    original=(1..100)
+    modified=original.to_lazy.select { |each| each % 2 == 0 }
+    modified_even=modified
+    modified=modified.reject { |each| (each % 4).zero? }
+    modified=modified.collect { |each| each.to_s }
+    modified=modified.select { |each| each.size == 1 }
+    #force, the collection to be realized
+    realized_collection=modified.to_real
+    assert_equal(['2', '6'], realized_collection)
+    assert_equal(50,modified_even.size)
+    assert(modified_even.to_real.class != Lazy::LazyEnumerable)
+  end
+  
+  def test_iterator
+    original=(1..100)
+    modified=original.to_lazy.lazy_select.even
+    modified_even=modified
+    modified=(modified.lazy_reject % 4).zero?
+    modified=modified.lazy_collect.to_s
+    modified=modified.select { |each| each.size == 1 }
+    #force, the collection to be realized
+    realized_collection=modified.to_real
+    assert_equal(['2', '6'], realized_collection)
+    assert_equal(50,modified_even.size)
+    assert(modified_even.to_real.class != Lazy::LazyEnumerable)
+  end
+  
+end
+
+class Numeric
+  def even
+    self % 2 == 0
+  end
+end

data/tests/lazy_enumerable_test_suite.rb

@@ -0,0 +1,22 @@
+MY_DIR = File.expand_path(File.dirname(__FILE__))
+
+def lib_require(name)
+  begin
+    require name
+  rescue LoadError
+    $LOAD_PATH << File.expand_path(File.join(MY_DIR, '..', 'lib'))
+    require name
+  end
+end
+
+def tests_require(name)
+  begin
+    require name
+  rescue LoadError
+    $LOAD_PATH << MY_DIR
+    require name
+  end
+end
+
+lib_require 'lazy_enumerable'
+tests_require 'lazy_enumerable_test'

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: LazyEnumerable
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Blaine Buxton
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-20 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: 
+email: altodorado@blainebuxton
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- tests/lazy_enumerable_test.rb
+- tests/lazy_enumerable_test_suite.rb
+- lib/lazy
+- lib/lazy/collect_enumerable.rb
+- lib/lazy/extensions.rb
+- lib/lazy/iterator.rb
+- lib/lazy/lazy_enumerable.rb
+- lib/lazy/reject_enumerable.rb
+- lib/lazy/select_enumerable.rb
+- lib/lazy_enumerable.rb
+- README
+- LICENSE
+has_rdoc: true
+homepage: http://lazyenum.rubyforge.org/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: lazyenum
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Functional programming with collections (Higher Order Methods)
+test_files: 
+- tests/lazy_enumerable_test_suite.rb