dunder 0.1.0 → 0.1.1

data/Rakefile

@@ -16,7 +16,13 @@ Jeweler::Tasks.new do |gem|
   gem.homepage = "http://github.com/Fonsan/dunder"
   gem.license = "MIT"
   gem.summary = %Q{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}
-  gem.description = %Q{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}
+  gem.description = %Q{For tasks that can be started early and evaluated late.
+
+  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}
   gem.email = "fonsan@gmail.com"
   gem.authors = ["Fonsan"]
   # Include your dependencies below. Runtime dependencies are required when using your gem,

data/Readme.md

@@ -5,19 +5,88 @@ Heavily inspired by Adam Sandersons [post](http://endofline.wordpress.com/2011/0
 
 Dunder
 =========================
+For tasks that can be started early and evaluated late.
 
+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
 
 Usage
-=====
-	lazy_bar = LazyLoad.load(String) {
+
+	lazy_foo = Dunder.load(String) {
 		# Simulate heavy IO
 		sleep 2
 		"bar" 
 	}
+	
+	
+	lazy_b = Dunder.load(String) {
+		# Simulate heavy IO
+		sleep 2
+		"bar" 
+	}
+	
 	puts lazy_bar
+	puts lazy_foo
+	# 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
+		sleep 1
+		[1,2,3]
+	end
+	puts lazy_array.length # <- will block here until the above sleep is done
+	sleep 1 # other heavy stuff
+	puts lazy_array # <- will be printed after 2 seconds
+	
+changing the order will fix this though
+
+	lazy_array = Dunder.load(Array) do
+		sleep 1
+		[1,2,3]
+	end
+	sleep 1 # other heavy stuff
+	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
+		Post.all
+	end
+	@lazy_users = Dunder.load(Array) do
+		User.all
+	end
+	
+and then later in views
+
+	<%= @lazyposts.each do %> <- this will block until the posts have been loaded
+	...
+	<% end %>
+	
+
+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
+	
 Install
 =======
-    gem install xxxx
+    gem install dunder
 
 
 (The MIT License)

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

data/dunder.gemspec

@@ -0,0 +1,74 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{dunder}
+  s.version = "0.1.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.description = %q{For tasks that can be started early and evaluated late.
+
+  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}
+  s.email = %q{fonsan@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "Rakefile",
+    "Readme.md",
+    "VERSION",
+    "dunder.gemspec",
+    "lib/dunder.rb",
+    "test/helper.rb",
+    "test/test_dunder.rb"
+  ]
+  s.homepage = %q{http://github.com/Fonsan/dunder}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{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}
+  s.test_files = [
+    "test/helper.rb",
+    "test/test_dunder.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, [">= 3.0.3"])
+      s.add_runtime_dependency(%q<activerecord>, [">= 3.0.3"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 3.0.3"])
+      s.add_dependency(%q<activerecord>, [">= 3.0.3"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 3.0.3"])
+    s.add_dependency(%q<activerecord>, [">= 3.0.3"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/lib/dunder.rb

@@ -3,6 +3,7 @@ require 'delegate'
 
 class FutureArray < DelegateClass(Array ) 
   def initialize(&block)
+    super(Array.new)
     @_thread = Thread.start(&block)
   end
   
@@ -12,6 +13,7 @@ class FutureArray < DelegateClass(Array )
   end
 end
 
+
 class Dunder
   
   def self.create_lazy_class(klass,instance = nil)
@@ -26,16 +28,23 @@ class Dunder
       end
       
       def __getobj__
-        __setobj__(@_thread.value) if @_thread.alive?
-        super
+        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
     end
-    
+
     c
   end
   
@@ -65,20 +74,5 @@ class Dunder
     lazy_class.new(&block)
   end
 end
-=begin
 
-puts Dunder.load(String) {
-  "hello"
-}
-
-puts Dunder.load(Integer) {
-  1
-}
-
-  puts Dunder.load(String) {
-    #Slow
-    sleep 2
-    "fubar"
-  }
 
-=end

data/test/test_dunder.rb

@@ -2,8 +2,15 @@ require 'helper'
 
 class TestDunder < Test::Unit::TestCase
   should "have some simple testing" do
-     assert_equal "bar",Dunder.load(String) {
-       "bar"
-     }
+    
+     b = "bar"
+     
+     lazy_b = Dunder.load(String) {
+        "bar"
+      }
+     
+     assert_equal b,lazy_b
+     puts lazy_b.class
+     assert_equal b.class, lazy_b.class
   end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Fonsan
@@ -103,7 +103,14 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: *id006
-description: 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
+description: |-
+  For tasks that can be started early and evaluated late.
+  
+    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
 email: fonsan@gmail.com
 executables: []
 
@@ -118,6 +125,7 @@ files:
 - Rakefile
 - Readme.md
 - VERSION
+- dunder.gemspec
 - lib/dunder.rb
 - test/helper.rb
 - test/test_dunder.rb
@@ -135,7 +143,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 621904010295938316
+      hash: 2997372027129916411
       segments: 
       - 0
       version: "0"