dunder 0.1.1 → 0.2.1

data/Readme.md

@@ -1,4 +1,4 @@
-A simple way of doing heavy work in a background process and when you really need the object it will block until it is done
+A simple way of doing heavy work in a background process and blocking until done when you really need the object.
 
 Preloading using the [proxy pattern](http://sourcemaking.com/design_patterns/proxy)
 Heavily inspired by Adam Sandersons [post](http://endofline.wordpress.com/2011/01/18/ruby-standard-library-delegator/)
@@ -11,30 +11,55 @@ Typically one might want start multiple heavy tasks concurrent.
 This is already solvable with threads or the [reactor-pattern](http://rubyeventmachine.com/) but setting this up could be cumbersome or require direct interactions with threads ex.
 
 Dunder is a simple way of abstracting this:
-you simply pass a block to Dunder.load with the expected class as the argument
+you simply pass a block to Dunder.load and Dunder will execute this in a thread behind the scenes.
+When later accessing the lazy_object will block until the thread is done and has returned or if the thread is done returns the value
+
+The implementation itself relies only on the ruby standard library and is below 50 lines of code
 
 Usage
 
-	lazy_foo = Dunder.load(String) {
+	lazy_object = Dunder.load {
+		# heavy stuff
+		value
+	}
+
+or through dunder_load
+	
+	lazy_sorted_articles = @articles.dunder_load.sort_by do |a|
+		a.title
+	end
+	
+	lazy_sorted_array = array.dunder_load.sort
+	
+	lazy_obj = obj.dunder_load.do_something_heavy(a,b,c) {
+		#maybe something other heavy here
+	}
+	
+Read more further down
+	
+	lazy_foo = Dunder.load {
 		# Simulate heavy IO
 		sleep 2
-		"bar" 
+		"foo" 
 	}
 	
-	
-	lazy_b = Dunder.load(String) {
+	lazy_bar = Dunder.load {
 		# Simulate heavy IO
 		sleep 2
 		"bar" 
 	}
 	
-	puts lazy_bar
-	puts lazy_foo
+	# Do something other heavy
+
+	puts lazy_bar # => "bar"
+	puts lazy_bar.class # => String
+	puts lazy_foo # => "foo"
+	puts lazy_foo.class # => String
 	# Will finish after 2 seconds
 
 worth mentioning is that if you access the variable in someway before that it will block earlier
 ex
-	lazy_array = Dunder.load(Array) do
+	lazy_array = Dunder.load do
 		sleep 1
 		[1,2,3]
 	end
@@ -42,9 +67,9 @@ ex
 	sleep 1 # other heavy stuff
 	puts lazy_array # <- will be printed after 2 seconds
 	
-changing the order will fix this though
+changing the order of the statements will fix this though
 
-	lazy_array = Dunder.load(Array) do
+	lazy_array = Dunder.load do
 		sleep 1
 		[1,2,3]
 	end
@@ -52,20 +77,14 @@ changing the order will fix this though
 	puts lazy_array.length # <- will block here until the above sleep in the block is done
 	puts lazy_array # <- will be printed after 1 second
 	
-API
-	Dunder.load(Klass,instance = nil) {
-		#things to do
-		value
-	}
-Klass must be the class of value
-instance, During the process Dunder will call Klass.new if your class has a mandatory argument in initialize (the constructor) you could create a dummy instance yourself or you could set the return type to Array and return [value] and then use Dunder.load(Array) do [value] end.first
 	
 Rails
+====================
 
-	@lazy_posts = Dunder.load(Array) do
+	@lazy_posts = Dunder.load do
 		Post.all
 	end
-	@lazy_users = Dunder.load(Array) do
+	@lazy_users = Dunder.load do
 		User.all
 	end
 	
@@ -78,11 +97,7 @@ and then later in views
 
 Known problems
 
-it works with most types but has only been tested with 1.9.2
-Integer fails with
-	NotImplementedError: super from singleton method that is defined to multiple classes is not supported; 
-	this will be fixed in 1.9.3 or later	
-Or a SystemStackError: stack level too deep
+	 Has only been tested with 1.9.2
 	
 Install
 =======
@@ -91,7 +106,7 @@ Install
 
 (The MIT License)
 
-Copyright (c) 2001-2006 Erik Fonselius
+Copyright (c) 2011 Erik Fonselius
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.1

data/dunder.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dunder}
-  s.version = "0.1.1"
+  s.version = "0.2.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Fonsan"]
-  s.date = %q{2011-01-26}
+  s.date = %q{2011-01-28}
   s.description = %q{For tasks that can be started early and evaluated late.
 
   Typically one might want start multiple heavy tasks concurrent.

data/lib/dunder.rb

@@ -1,78 +1,50 @@
-# From http://endofline.wordpress.com/2011/01/18/ruby-standard-library-delegator/
 require 'delegate'
-
-class FutureArray < DelegateClass(Array ) 
-  def initialize(&block)
-    super(Array.new)
-    @_thread = Thread.start(&block)
-  end
-  
-  def __getobj__
-    __setobj__(@_thread.value) if @_thread.alive?
-    super
-  end
-end
-
-
 class Dunder
-  
-  def self.create_lazy_class(klass,instance = nil)
-    c = Class.new(DelegateClass(klass)) do 
-      def lazy_instance
-        # Will be filled in later
-      end
-      
-      def initialize(&block)
-        @_thread = Thread.start(&block)
-        super(self.lazy_instance)
-      end
-      
-      def __getobj__
-        result = @_thread.value
-        __setobj__(result) if @_thread.alive?
-        
-        instance_eval do
-          def class
-            __getobj__.class
-          end
-        end
-        result
-      end
-      
-    end
-    instance ||= klass.new
-    def c.lazy_instance
-      instance
+  class Future < SimpleDelegator
+    def initialize(&block)
+      @_thread = Thread.start(&block)
     end
 
-    c
-  end
-  
-  def self.create_lazy_class!(klass, instance = nil)
-    @@lazy_classes[klass] = create_lazy_class(klass,instance)
+    def __getobj__
+      __setobj__(@_thread.value) if @_thread.alive?
+      super
+    end
+    
+    def class
+      __getobj__.class
+    end
   end
   
-  @@lazy_classes = Hash.new do |hash,key|
-    hash[key] = create_lazy_class(key)
+  def self.load(&block)
+    Future.new(&block)
   end
   
-  # All standard klasses with a constructor having mandatory arguments
-  # More to add
-  @@default_instances = {
-    Integer => 0
-  }
-  
-  @@default_instances.each do |k,v|
-    create_lazy_class!(k,v)
+  class Dispacter < SimpleDelegator
+    def initialize(object)
+       @_dunder_obj = object
+    end
+    
+    def class
+      @_dunder_obj.class
+    end
+    
+    def method_missing(method_sym, *arguments,&block)
+       Dunder.load do
+          @_dunder_obj.send(method_sym, *arguments,&block)
+       end
+    end
   end
-  
-  def self.load(klass,instance = nil,&block) 
-    lazy_class = !@@lazy_classes.key?(klass) && instance ?
-       @@lazy_classes[klass] = create_lazy_class(klass,instance)
-       :
-       @@lazy_classes[klass]
-    lazy_class.new(&block)
+end
+
+class Object
+  def dunder_load
+    Dunder::Dispacter.new(self)
   end
 end
 
 
+
+
+
+
+

data/test/test_dunder.rb

@@ -1,16 +1,38 @@
 require 'helper'
-
+require 'timeout'
 class TestDunder < Test::Unit::TestCase
   should "have some simple testing" do
-    
      b = "bar"
-     
-     lazy_b = Dunder.load(String) {
-        "bar"
-      }
-     
+     lazy_b = nil
+     assert_nothing_raised do
+       Timeout::timeout(0.5) do
+       
+       lazy_b = Dunder.load {
+          sleep 1
+          "bar"
+        }
+       end
+     end
      assert_equal b,lazy_b
-     puts lazy_b.class
      assert_equal b.class, lazy_b.class
   end
+  
+  should "respond to dunder_load" do
+    assert Object.public_instance_methods.index(:dunder_load)
+    b = "bar"
+    b.instance_eval do
+      def something_heavy
+        yield
+        self
+      end
+    end
+    res = nil
+    assert_nothing_raised do
+       Timeout::timeout(0.5) do
+       res = b.dunder_load.something_heavy { sleep 1 }
+      end
+    end
+    assert_equal b,res
+    assert_equal b.class,res.class
+  end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 2
   - 1
-  - 1
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors: 
 - Fonsan
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-26 00:00:00 +01:00
+date: 2011-01-28 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -143,7 +143,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 2997372027129916411
+      hash: 1083880034677177238
       segments: 
       - 0
       version: "0"