dunder 0.2.1 → 0.3.0

data/Gemfile

@@ -1,15 +1,11 @@
 source "http://rubygems.org"
-# Add dependencies required to use your gem here.
-# Example:
-gem "activesupport", ">= 3.0.3"
-gem "activerecord", ">= 3.0.3"
 
-
-# Add dependencies to develop your gem here.
-# Include everything needed to run rake, tests, features, etc.
-group :development do
+group :development, :test do
+  gem "activerecord", ">= 3.0.3"
   gem "shoulda", ">= 0"
   gem "bundler", "~> 1.0.0"
   gem "jeweler", "~> 1.5.2"
   gem "rcov", ">= 0"
+  gem 'sqlite3'
+  gem (RUBY_VERSION > "1.9" ? 'ruby-debug19' : 'ruby-debug')
 end

data/Gemfile.lock

@@ -11,17 +11,32 @@ GEM
       arel (~> 2.0.2)
       tzinfo (~> 0.3.23)
     activesupport (3.0.3)
+    archive-tar-minitar (0.5.2)
     arel (2.0.7)
     builder (2.1.2)
+    columnize (0.3.2)
     git (1.2.5)
     i18n (0.5.0)
     jeweler (1.5.2)
       bundler (~> 1.0.0)
       git (>= 1.2.5)
       rake
+    linecache19 (0.5.11)
+      ruby_core_source (>= 0.1.4)
     rake (0.8.7)
     rcov (0.9.9)
+    ruby-debug-base19 (0.11.24)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.4)
+      archive-tar-minitar (>= 0.5.2)
     shoulda (2.11.3)
+    sqlite3 (1.3.3)
     tzinfo (0.3.24)
 
 PLATFORMS
@@ -29,8 +44,9 @@ PLATFORMS
 
 DEPENDENCIES
   activerecord (>= 3.0.3)
-  activesupport (>= 3.0.3)
   bundler (~> 1.0.0)
   jeweler (~> 1.5.2)
   rcov
+  ruby-debug19
   shoulda
+  sqlite3

data/Readme.md

@@ -1,50 +1,66 @@
+Dunder
+=========================
+For tasks that can be started _early_ and evaluated _late_.
+
 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/)
 
-Dunder
-=========================
-For tasks that can be started early and evaluated late.
+#### Introduction
+To increase performance 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 etc.
 
-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.
+What inspired me was the ability to run concurrent database queries within a single request in rails, please read more in the section below. 
+
+How you could lazy load something today in ruby 1.9
+
+	foo = "foo"
+	bar = "bar"
+	t = Thread.start {
+		sleep 1
+		foo + bar
+	}
+	# Other code
+	foobar = t.value
+	
+The Thread.start call would not block and execution would continue and when you need the value you could ask t.value for it
 
-Dunder is a simple way of abstracting this:
-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
+Dunder is a simple way of abstracting this but does infact use threads behind the scenes: you simply pass a block to Dunder.lazy_load 
+When later accessing the returned object, 
+lets say: 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
+Dunder will only be happy under 1.9.* because how blocks changed have changed. There also some caveats that you _should_ read about below
 
-Usage
+#### Usage
 
-	lazy_object = Dunder.load {
+	lazy_object = Dunder.lazy_load {
 		# heavy stuff
 		value
 	}
-
-or through dunder_load
+	# Later on access lazy_object
+	puts lazy_object
+	puts lazy_object.class # => value.class
 	
-	lazy_sorted_articles = @articles.dunder_load.sort_by do |a|
-		a.title
-	end
+or through chaining with dunder_load which works for both objects and classes
 	
 	lazy_sorted_array = array.dunder_load.sort
 	
+	# With arguments and block
 	lazy_obj = obj.dunder_load.do_something_heavy(a,b,c) {
 		#maybe something other heavy here
 	}
 	
-Read more further down
+Parallel example
 	
-	lazy_foo = Dunder.load {
-		# Simulate heavy IO
+	lazy_foo = Dunder.lazy_load {
+		# Simulate heavy work
 		sleep 2
 		"foo" 
 	}
 	
-	lazy_bar = Dunder.load {
-		# Simulate heavy IO
+	lazy_bar = Dunder.lazy_load {
+		# Simulate heavy work
 		sleep 2
 		"bar" 
 	}
@@ -59,7 +75,8 @@ Read more further down
 
 worth mentioning is that if you access the variable in someway before that it will block earlier
 ex
-	lazy_array = Dunder.load do
+
+	lazy_array = Dunder.lazy_load do
 		sleep 1
 		[1,2,3]
 	end
@@ -69,7 +86,7 @@ ex
 	
 changing the order of the statements will fix this though
 
-	lazy_array = Dunder.load do
+	lazy_array = Dunder.lazy_load do
 		sleep 1
 		[1,2,3]
 	end
@@ -77,27 +94,73 @@ changing the order of the statements 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
 	
-	
-Rails
+WARNING "if-it-quacks-like-a-duck-walks-like-a-duck"
 ====================
+* Don't return symbols
+* And for normal objects be careful with comparing
+
+The reason for this is that the implementation uses the delegation.rb in ruby which makes objects life tricky. Even though the object return quacks like a object it will not always walk in a straight line.
+Ex
+
+	o = Object.new
+	res = Dunder.lazy_load { o }
+	res == o # => true
+	o == res # => false 
+	o == res._thread.value # => true
+
+But Array,String,Fixnum,Hash etc work fine.
 
-	@lazy_posts = Dunder.load do
-		Post.all
+If you want to be sure that nothing fishy is going on please use ._thread.value
+
+Groups
+====================
+So now you might be wondering what would happen if we lazy load more than 10000 objects through some intense calculations. Well our performance would decrease because of the [context switching](http://en.wikipedia.org/wiki/Context_switch), it would actually be better if we only ran a limited number of lazy loads at any one point. 
+
+Dunder::Group has been specifically designed to solve this problem.
+
+For our contrived example note that this example and dunder requires a ruby version of at least 1.9.* . Lets say we have list of tens of thousands of urls that we want to visit and measure the sum content length of all the websites
+
+	require 'open-uri'
+	list = ["http://google.com","http://yahoo.com", .... ]
+	g = Dunder::Group.new(100)
+	results = list.map do |u|
+	  g.lazy_load { open(u) } 
+	  # or dunder_load(g).open(u)
 	end
-	@lazy_users = Dunder.load do
-		User.all
+	
+	sum = 0
+	results.each do |r|
+	  sum += r.length
 	end
+	puts sum
+
+Note that you could use groups by itself and pass blocks 
+
+	g = Dunder::Group.new(4)
+	t = g.start_thread {
+	  # things to do here
+	}
+
+Much depending on what you are doing you will want to pick a higher or lower number. If your task is CPU-bound then around the number of cores on your computer should be optimal, if your task is IO bound which is true for most of my use cases then experimenting is key.
+
+Rails
+====================
+
+	# Will not block
+	@lazy_posts = Post.dunder_load.all
+	
+	@lazy_user = User.dunder_load.first
 	
 and then later in views
 
-	<%= @lazyposts.each do %> <- this will block until the posts have been loaded
+	<%= @user.name %> <-  will block until the user have been loaded
+	<%= @lazyposts.each do %> <- will block until the posts have been loaded
 	...
-	<% end %>
-	
-
-Known problems
+	<% end %
+Be careful not to use the mysql gem which blocks the whole universe on every call. Please use the mysql2 which is the standard adapter for rails since 3.0,
+also the pg gem works fine.
 
-	 Has only been tested with 1.9.2
+For a sample application using mysql checkout [this](https://github.com/Fonsan/dunder-rails-demo)
 	
 Install
 =======

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.3.0

data/dunder.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dunder}
-  s.version = "0.2.1"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Fonsan"]
-  s.date = %q{2011-01-28}
+  s.date = %q{2011-02-16}
   s.description = %q{For tasks that can be started early and evaluated late.
 
   Typically one might want start multiple heavy tasks concurrent.
@@ -22,6 +22,7 @@ Gem::Specification.new do |s|
     "LICENSE.txt"
   ]
   s.files = [
+    ".gemtest",
     "Gemfile",
     "Gemfile.lock",
     "LICENSE.txt",
@@ -31,44 +32,49 @@ Gem::Specification.new do |s|
     "dunder.gemspec",
     "lib/dunder.rb",
     "test/helper.rb",
-    "test/test_dunder.rb"
+    "test/test.sqlite3",
+    "test/test_dunder.rb",
+    "test/test_dunder_group.rb"
   ]
   s.homepage = %q{http://github.com/Fonsan/dunder}
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
+  s.rubygems_version = %q{1.5.2}
   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"
+    "test/test_dunder.rb",
+    "test/test_dunder_group.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<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"])
+      s.add_development_dependency(%q<sqlite3>, [">= 0"])
+      s.add_development_dependency(%q<ruby-debug19>, [">= 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"])
+      s.add_dependency(%q<sqlite3>, [">= 0"])
+      s.add_dependency(%q<ruby-debug19>, [">= 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"])
+    s.add_dependency(%q<sqlite3>, [">= 0"])
+    s.add_dependency(%q<ruby-debug19>, [">= 0"])
   end
 end
 

data/lib/dunder.rb

@@ -1,12 +1,42 @@
 require 'delegate'
+require 'thread'
 class Dunder
+
   class Future < SimpleDelegator
-    def initialize(&block)
-      @_thread = Thread.start(&block)
+    @@threads = {}
+    FORBIDDEN = [Symbol]
+    
+    def self.threads
+      @@threads
+    end
+    
+    def self.ensure_threads_finished(timeout = nil)
+      @@threads.values.each do |t|
+        raise 'Thread did not timeout in time' unless t.join(timeout)
+      end
+    end
+    
+    attr_reader :_thread
+    
+    def initialize(group = nil,&block)
+      raise ArgumentError,"No block was passed for execution" unless block
+      @_thread = group ? group.start_thread(&block) : Thread.start(&block)
+      @@threads[@_thread.object_id] = @_thread
     end
 
     def __getobj__
-      __setobj__(@_thread.value) if @_thread.alive?
+      # Optimizing a bit
+      return super if @delegate_sd_obj
+      __setobj__(@_thread.value)
+      #@delegate_sd_obj = @_thread.value
+      if FORBIDDEN.include?(super.class)
+        error = "Your block returned a #{super.class} and because of how ruby handles #{FORBIDDEN.join(", ")}"
+        error << " the #{super.class} won't behave correctly. There are two known workarounds:"
+        error << " add the suffix ._thread.value or construct the block to return a array of length 1 and say lazy_array.first."
+        error << "Ex: puts lazy_object becomes lazy_object._thread.value"
+        raise ArgumentError,error
+      end
+      @@threads.delete @_thread.object_id
       super
     end
     
@@ -15,36 +45,107 @@ class Dunder
     end
   end
   
-  def self.load(&block)
-    Future.new(&block)
-  end
-  
-  class Dispacter < SimpleDelegator
-    def initialize(object)
-       @_dunder_obj = object
+  class Group
+    attr_reader :name,:max
+    
+    def initialize(max)
+      raise ArgumentError,"You must specify a maximum number of threads for this group #{max}" unless max && max.is_a?(Integer)
+      @max = max
+      @running = 0
+      @waiting = []
+      @mutex = Mutex.new
     end
     
-    def class
-      @_dunder_obj.class
+    def running
+      @mutex.synchronize {
+        @running
+      }
     end
     
-    def method_missing(method_sym, *arguments,&block)
-       Dunder.load do
-          @_dunder_obj.send(method_sym, *arguments,&block)
-       end
+    def waiting
+      @mutex.synchronize {
+        @waiting
+      }
+    end
+    
+    def lazy_load(&block)
+      Future.new(self,&block)
+    end
+    
+    def start_thread(&block)
+      group = self
+      Thread.start {
+        group.init_thread
+        value = block.call
+        group.finish_thread
+        value
+      }
+    end
+    
+    def init_thread
+      thread = Thread.current
+      waiting = false
+      @mutex.synchronize {
+        if waiting = (@running >= @max)
+          @waiting.push(thread)
+        else
+          @running += 1
+        end
+      }
+      Thread.stop if waiting
+    end
+    
+    def finish_thread
+      thread = Thread.current
+      @mutex.synchronize {
+        @running -= 1
+        unless @waiting.empty?
+          # Schedule the next job
+          t = @waiting.shift
+          @running += 1
+          t.wakeup
+        end 
+      }
     end
   end
-end
-
-class Object
-  def dunder_load
-    Dunder::Dispacter.new(self)
+  
+  # Kernel add exit hook to ensure all threads finishing before exiting
+  at_exit do
+     Future.ensure_threads_finished
   end
-end
-
-
-
-
-
-
+  
+  module DunderMethod
+    def self.lazy_load(&block)
+      Future.new(&block)
+    end
+  end
+  
+  def self.lazy_load(&block)
+    DunderMethod.lazy_load(&block)
+  end
+  
+  # There maybe a better way of doing this
+  class Dispacter < (RUBY_VERSION > "1.9" ? BasicObject : Object)
+    def initialize(object,group = nil)
+      @_dunder_group = group
+      @_dunder_obj = object
+    end
 
+    def method_missing(method_sym, *arguments,&block)
+      disp = @_dunder_group ? @_dunder_group : DunderMethod
+      disp.lazy_load do
+        @_dunder_obj.send(method_sym, *arguments,&block)
+      end
+    end
+  end
+  
+  # http://olabini.com/blog/2011/01/safeer-monkey-patching/
+  # This also works for Class methods since: Class.ancestors => [Class, Module, Object, Kernel, BasicObject] 
+  module Instance
+    def dunder_load(group = nil)
+      Dispacter.new(self,group)
+    end
+  end
+  Object.send :include,Instance
+  
+end

data/test/helper.rb

@@ -7,12 +7,52 @@ rescue Bundler::BundlerError => e
   $stderr.puts "Run `bundle install` to install missing gems"
   exit e.status_code
 end
+require 'ruby-debug'
 require 'test/unit'
 require 'shoulda'
-
+require 'timeout'
+require 'active_record'
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'dunder'
 
+
+DBFILE ="test/test.sqlite3"
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => DBFILE)
+
+unless File.exists? DBFILE
+  silence_stream(STDOUT) do 
+    ActiveRecord::Schema.define do
+      create_table "posts", :force => true do |t|
+          t.string "name"
+      end
+    end
+  end
+  class Post < ActiveRecord::Base; end
+  
+  Post.create!(:name => "hello")
+end
+
+
+class Post < ActiveRecord::Base; end
+
+class Moods
+  def sleepy
+    "bar"
+  end
+end
+
 class Test::Unit::TestCase
+  def setup
+
+   end
+
+   def teardown
+     Dunder::Future.threads.values.each do |t|
+       timeout = 0.5
+       unless t.join(timeout)
+         raise "#{t} did not finish in #{timeout} seconds"
+       end
+     end
+   end
 end

data/test/test_dunder.rb

@@ -1,38 +1,135 @@
 require 'helper'
-require 'timeout'
 class TestDunder < Test::Unit::TestCase
+  
   should "have some simple testing" do
      b = "bar"
-     lazy_b = nil
-     assert_nothing_raised do
-       Timeout::timeout(0.5) do
-       
-       lazy_b = Dunder.load {
-          sleep 1
-          "bar"
-        }
-       end
-     end
+     lazy_b = Dunder.lazy_load {
+        "bar"
+     }
      assert_equal b,lazy_b
      assert_equal b.class, lazy_b.class
   end
   
+  should "return a equal object" do
+    objects = [Object.new,2,Class,"string",{:foo => "bar"},[1,5],(3..4)]
+    objects.each do |o|
+      res = Dunder.lazy_load {
+        o
+      }
+      assert_equal o,res._thread.value
+
+      # this works through some serious meta(monkey) programming
+      assert_equal res, o
+      assert_not_equal o,res unless [Fixnum,String,Hash,Array].include?(o.class) 
+    end
+  end
+  
+  should "raise when returning forbidden objects" do
+    assert_raise ArgumentError do
+      res = Dunder.lazy_load {
+        :bar
+      }
+      res.inspect
+    end
+  end
+  
+  should "duplicate objects fine" do
+    objects = ["string",{:foo => "bar"},[1,5]]
+    objects.each do |o|
+      res = Dunder.lazy_load {
+        o
+      }
+      assert_equal o,res.dup
+    end
+  end
+
+  
   should "respond to dunder_load" do
-    assert Object.public_instance_methods.index(:dunder_load)
+    assert Object.methods.include?(:dunder_load)
+    b = Moods.new
+    res = b.dunder_load.sleepy
+    assert_equal b.sleepy,res
+    assert_equal b.sleepy.class,res.class
+  end
+  
+  should "respond to methods" do
+    lazy_block = Dunder.lazy_load {
+      []
+    }
+    assert lazy_block.respond_to?(:each)
+    
     b = "bar"
-    b.instance_eval do
-      def something_heavy
-        yield
-        self
-      end
+    lazy_method = b.dunder_load
+    assert lazy_method.respond_to?(:downcase)
+  end
+  
+  should "respond to class methods" do
+    assert Object.dunder_load.name == Object.name
+  end
+  
+  should "block when exiting until done" do
+    m = Mutex.new
+    m.lock
+    # Lazy Thread
+    lazy = Dunder.lazy_load {
+      m.lock
+    }
+    assert lazy._thread.alive?
+    m2 = Mutex.new
+    
+    #Cleaner thread
+    Thread.start do
+      m2.lock
+      Dunder::Future.ensure_threads_finished(1)
+      m2.unlock
+    end
+    
+    # Block until cleaner thread has started
+    while !m2.locked?
+    end
+    
+    # Let the lazy thread finish
+    m.unlock  
+    
+    # Let the cleaner wait for the lazy thread and wait for the cleaner thread to finish
+    m2.lock
+    assert !lazy._thread.alive?
+  end
+  
+  should "be nonblocking " do
+    m = Mutex.new
+    m.lock
+    lazy = Dunder.lazy_load {
+      m.lock
+      m.unlock
+      "bar"
+    }
+    m.unlock
+    assert_equal "bar",lazy
+  end
+  
+  should "still work if block finishes before access" do
+    m = Mutex.new
+    m.lock
+    lazy = Dunder.lazy_load {
+      m.lock
+      "bar"
+    }
+    m.unlock
+    while lazy._thread.alive?
     end
-    res = nil
-    assert_nothing_raised do
-       Timeout::timeout(0.5) do
-       res = b.dunder_load.something_heavy { sleep 1 }
-      end
+    assert lazy == "bar"
+  end
+  
+  should "respond to rails" do
+    posts = Post.all
+    lazy = Dunder.lazy_load do 
+      Post.all 
     end
-    assert_equal b,res
-    assert_equal b.class,res.class
+    
+    assert posts == lazy
+    assert Post.scoped.dunder_load.all == posts
+    assert Post.dunder_load.all == posts
   end
+  
 end

data/test/test_dunder_group.rb

@@ -0,0 +1,101 @@
+require 'helper'
+class TestDunderGroup < Test::Unit::TestCase
+  
+  should "run threads in a group" do
+    g = Dunder::Group.new 1
+    b = "bar"
+    
+    lazy = g.lazy_load {
+      b
+    }
+    assert lazy == b
+    assert g.running == 0
+  end
+  
+  should "be able to run just normal threads" do
+    g = Dunder::Group.new(2)
+    b = "bar"
+    t = g.start_thread {
+      b
+    }
+    assert b,t.value
+  end
+  
+  should "queue threads in group" do
+    # When reading the code below it is recommended to reserve 30 min and a coffee
+    
+    # Create a group with a maximum of 2 threads running
+    g = Dunder::Group.new 2
+    # Create a mutex control array [[m1,m2],[m1,m2], ... ]
+    array = 4.times.map do [Mutex.new,Mutex.new] end
+      
+    # Lock all the second mutexes
+    array.map(&:second).each &:lock
+    
+    # Start four jobs that try to each lock their specific locks
+    results = array.map do |first,second|
+      g.lazy_load do
+        first.lock
+        second.lock
+        first
+      end
+    end
+    
+    # Wait until 2 of the first locks have been locked
+    while array.map(&:first).reject(&:locked?).length != 2 || g.waiting.length != 2
+    end
+    
+    # Assert that only 2 of the threads are running
+    assert_equal 2,g.running
+    assert_equal 2,g.waiting.length
+    
+    # Find a the second lock for one of the already locked jobs
+    mutex_to_unlock = nil
+    for first,second in array
+      if first.locked?
+        mutex_to_unlock = second
+        break
+      end
+    end
+    
+    # Unlock the second lock and whatch how a one job finishes and another one gets scheduled
+    mutex_to_unlock.unlock
+    while g.waiting.length == 2
+    end
+    assert_equal 1,g.waiting.length
+    assert_equal 2,g.running
+    
+    # Unlock the rest of the second locks
+    array.map(&:second).reject do |m|
+      m == mutex_to_unlock 
+    end.each &:unlock
+    
+    # Wait for all threads to finish
+    assert_not_equal array.map(&:first), results
+    assert_equal results,array.map(&:first)
+    assert g.waiting.length == 0
+    assert g.running == 0
+  end
+  
+  should "limit number of running threads in a Group" do
+    g = Dunder::Group.new 1
+    srand 123
+    count = 32
+    enum = 10.times
+    result = []
+    array = enum.map do |i|
+      Dunder.lazy_load {
+        sleep(rand * 0.001)
+        result << i
+        i
+      }
+    end  
+    assert_equal enum.to_a,array 
+    # Since we are only running one thread at a time they should come in order
+    assert_not_equal enum.to_a,result, "Since we seeded srand this should not happen but could because of thread scheduling"
+    assert g.running == 0
+    assert g.waiting.length == 0
+    
+  end
+  
+end

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: dunder
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 2
-  - 1
-  version: 0.2.1
+  prerelease: 
+  version: 0.3.0
 platform: ruby
 authors: 
 - Fonsan
@@ -14,95 +10,86 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-28 00:00:00 +01:00
+date: 2011-02-16 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: activesupport
+  name: activerecord
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 3
-        - 0
-        - 3
         version: 3.0.3
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: activerecord
+  name: shoulda
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 3
-        - 0
-        - 3
-        version: 3.0.3
-  type: :runtime
+        version: "0"
+  type: :development
   prerelease: false
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: shoulda
+  name: bundler
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
+        version: 1.0.0
   type: :development
   prerelease: false
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: bundler
+  name: jeweler
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 0
-        - 0
-        version: 1.0.0
+        version: 1.5.2
   type: :development
   prerelease: false
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: jeweler
+  name: rcov
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 5
-        - 2
-        version: 1.5.2
+        version: "0"
   type: :development
   prerelease: false
   version_requirements: *id005
 - !ruby/object:Gem::Dependency 
-  name: rcov
+  name: sqlite3
   requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
   type: :development
   prerelease: false
   version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug19
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id007
 description: |-
   For tasks that can be started early and evaluated late.
   
@@ -119,6 +106,7 @@ extensions: []
 extra_rdoc_files: 
 - LICENSE.txt
 files: 
+- .gemtest
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -128,7 +116,9 @@ files:
 - dunder.gemspec
 - lib/dunder.rb
 - test/helper.rb
+- test/test.sqlite3
 - test/test_dunder.rb
+- test/test_dunder_group.rb
 has_rdoc: true
 homepage: http://github.com/Fonsan/dunder
 licenses: 
@@ -143,7 +133,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 1083880034677177238
+      hash: -2028411122079561584
       segments: 
       - 0
       version: "0"
@@ -152,16 +142,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.5.2
 signing_key: 
 specification_version: 3
 summary: 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
 test_files: 
 - test/helper.rb
 - test/test_dunder.rb
+- test/test_dunder_group.rb