lazy_methods 1.0.6 → 2.0.0

data/.travis.yml

@@ -0,0 +1,5 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - rbx
+  - jruby

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+gem 'rake'
+gem 'rspec', '>=2.6.0'

data/Gemfile.lock

@@ -0,0 +1,20 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    rake (0.9.2)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake
+  rspec (>= 2.6.0)

data/README.rdoc

@@ -1,33 +1,71 @@
-== LazyMethods
+= LazyMethods
 
-This gem adds a virtual lazy version of every method on every class. Lazy methods have the same name as the original method name but prefixed with +lazy_+. A lazy method will return a proxy object that looks and acts just like the result from calling the actual method. The trick is that the actual method will not be called until a method is invoked on the proxy object.
+This adds the ability to declare lazy loading or asynchronous methods.
+
+== Lazy Loading Methods
+
+Lazy methods will return immediately with a proxy object. The proxy object will look and act just like the result from calling the method. However, the original method will only be called when a method is invoked on the proxy object.
 
 This pattern works great with caching. You can have your business logic invoke lazy methods and your view logic sitting behind a cache. If the cache is hit, you won't actually end up invoking any of your business logic.
 
-=== A simple example:
+To define a lazy method, simply include the LazyMethods module in your class definition and then call +define_lazy_methods+ or +define_lazy_class_methods+ with the names of one or more methods defined for your class. This will create lazy versions of the methods with the names prefixed with +lazy_+.
 
-The business logic:
+=== Example
 
-  def my_action
-	  @records = MyResource.find(params[:name])
+  class MyModel
+    include LazyMethods
+    define_lazy_methods :calculate_value
+    define_lazy_class_methods :find
   end
+  
+  object = MyModel.lazy_find           # The find method will not be called yet
+  object.to_s                          # The find will will be called here
+  value = object.lazy_calculate_value  # The calculate_value method will not be called yet
+  sum = value + 1                      # The calculate_value method will be called here
+
+== Asynchronous Methods
 
-And in the view:
+Asynchronouse methods are similar to lazy methods. The method call will return immediately with a proxy object. The difference is that the original method will be invoked immediately in a separate thread. When a method is called on the proxy object, the thread will block until the result is returned. This can be useful if you have methods that wait on IO like web service calls.
 
-	<% cache(params[:names]) -%>
-		<% @records.each do |record| -%>
-			<div><%=record.title%></div>
-		<% end -%>
-	<% end -%>
+=== Example
+
+  class MyModel
+    include LazyMethods
+    define_async_methods :get_related_info
+    define_async_class_methods :find
+  end
+  
+  objects = MyModel.async_find          # The find method will be called in a new thread
+  objects.size                          # Execution will wait until the find thread has finished
+  objects.each do |obj|
+    obj.async_get_related_info          # A new thread will be started for each object to call get_related_info
+  end
 
-Now even if you cache the fragments in your view that use @records, the database will still be hit to select and instantiate all the records. You could remove the resource call from the business logic and add it to the view. However, this just feels wrong and is inherently harder to test. Instead just use a lazy method.
+== Usage Notes
 
-	def my_action
-		@records = MyResource.lazy_find(params[:name])
-	end
+Since lazy methods are not invoked at the time when you call them, there is a chance for the state of you application to change between the time when you invoke a method and when it is actually called.
+
+  # In this example, the value of object.value will be 2 when the do_something method is called.
+  object.value = 1
+  value = object.lazy_do_somthing
+  object.value = 2
+  value.to_s
+
+Similarly, all asynchronous methods must make sure they are thread safe.
+
+Exception handling can also be tricky since exceptions will not be immediately thrown.
+
+  value = nil
+  begin
+    value = object.lazy_do_something
+  rescue => e
+    # Exceptions thrown by do_something won't be caught here.
+  end
+  
+  value.to_s # Exceptions thrown by do_something will be thrown here instead.
 
-Now, as long as no methods are invoked on @records, the original find method will never be called. As soon as the first method is called, the original find method will be called. It will never be called more than once. You can even pass in a block to the lazy method.
+== Upgrade Notes
 
-== Testing
+In version 1.x of this gem, lazy methods were automatically available for every method on every object. You must now define which methods should be defined as lazy methods. This change was made so that the code is less intrusive and the lazy method invocations are slightly faster.
 
-Since the proxy object looks and acts just like the real result object, all your view tests should still pass. Your controller tests should pass will little or no tweaking.
+In addition, version 2.x of this gem includes the functionality of the async_methods 1.x gem. That gem is no longer being maintained.

data/Rakefile

@@ -1,6 +1,5 @@
 require 'rubygems'
 require 'rake'
-require 'rake/rdoctask'
 
 desc 'Default: run unit tests.'
 task :default => :test
@@ -16,20 +15,12 @@ rescue LoadError
   end
 end
 
-desc 'Generate documentation for the gem.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.options << '--title' << 'Lazy Methods' << '--line-numbers' << '--inline-source' << '--main' << 'README.rdoc'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "lazy_methods"
-    gem.summary = %Q{Gem that adds lazy method wrapping to every object. Preceding any method with lazy_ will defer the invocation until the result is actually needed.}
-    gem.description = %Q(Gem that adds lazy method wrapping to every object. Preceding any method with lazy_ will defer the invocation until the result is actually needed. This pattern is useful when used with caching systems.)
+    gem.summary = %Q{Gem that adds lazy method delegation methods. Using this gem you can easily define lazy loading or asynchronous versions of specific methods. Lazy loading is useful when used with caching systems while asynchronous methods can improve throughput on I/O bound processes like making several HTTP calls in row.}
+    gem.description = %Q{Gem that adds lazy method delegation methods. Using this gem you can easily define lazy loading or asynchronous versions of specific methods. Lazy loading is useful when used with caching systems while asynchronous methods can improve throughput on I/O bound processes like making several HTTP calls in row.}
     gem.email = "brian@embellishedvisions.com"
     gem.homepage = "http://github.com/bdurand/lazy_methods"
     gem.authors = ["Brian Durand"]

data/VERSION

@@ -1 +1 @@
-1.0.6
+2.0.0

data/lazy_methods.gemspec

@@ -5,36 +5,40 @@
 
 Gem::Specification.new do |s|
   s.name = %q{lazy_methods}
-  s.version = "1.0.6"
+  s.version = "2.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brian Durand"]
-  s.date = %q{2011-01-24}
-  s.description = %q{Gem that adds lazy method wrapping to every object. Preceding any method with lazy_ will defer the invocation until the result is actually needed. This pattern is useful when used with caching systems.}
+  s.date = %q{2011-08-29}
+  s.description = %q{Gem that adds lazy method delegation methods. Using this gem you can easily define lazy loading or asynchronous versions of specific methods. Lazy loading is useful when used with caching systems while asynchronous methods can improve throughput on I/O bound processes like making several HTTP calls in row.}
   s.email = %q{brian@embellishedvisions.com}
   s.extra_rdoc_files = [
     "README.rdoc"
   ]
   s.files = [
+    ".travis.yml",
+    "Gemfile",
+    "Gemfile.lock",
     "MIT-LICENSE",
     "README.rdoc",
     "Rakefile",
     "VERSION",
     "lazy_methods.gemspec",
     "lib/lazy_methods.rb",
-    "lib/lazy_methods/lazy_methods.rb",
     "spec/lazy_method_spec.rb",
     "spec/method_tester.rb",
+    "spec/proxy_spec.rb",
     "spec/spec_helper.rb"
   ]
   s.homepage = %q{http://github.com/bdurand/lazy_methods}
   s.rdoc_options = ["--charset=UTF-8", "--main", "README.rdoc"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.4.1}
-  s.summary = %q{Gem that adds lazy method wrapping to every object. Preceding any method with lazy_ will defer the invocation until the result is actually needed.}
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Gem that adds lazy method delegation methods. Using this gem you can easily define lazy loading or asynchronous versions of specific methods. Lazy loading is useful when used with caching systems while asynchronous methods can improve throughput on I/O bound processes like making several HTTP calls in row.}
   s.test_files = [
     "spec/lazy_method_spec.rb",
     "spec/method_tester.rb",
+    "spec/proxy_spec.rb",
     "spec/spec_helper.rb"
   ]
 
@@ -42,13 +46,19 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rake>, [">= 0"])
+      s.add_runtime_dependency(%q<rspec>, [">= 2.6.0"])
       s.add_development_dependency(%q<rspec>, [">= 2.0.0"])
       s.add_development_dependency(%q<jeweler>, [">= 0"])
     else
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 2.6.0"])
       s.add_dependency(%q<rspec>, [">= 2.0.0"])
       s.add_dependency(%q<jeweler>, [">= 0"])
     end
   else
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 2.6.0"])
     s.add_dependency(%q<rspec>, [">= 2.0.0"])
     s.add_dependency(%q<jeweler>, [">= 0"])
   end

data/lib/lazy_methods.rb

@@ -1,2 +1,141 @@
-require File.expand_path('../lazy_methods/lazy_methods', __FILE__)
-Object.send(:include, LazyMethods::InstanceMethods) unless Object.include?(LazyMethods::InstanceMethods)
+require 'thread'
+
+# Include this module in classes you wish to add lazy or asynchronous methods to.
+#
+# To define a lazy or asynchronous methods methods:
+#
+#   class MyClass
+#     include LazyMethods
+#
+#     define_lazy_methods :method_1, :method_2
+#     define_async_methods :method_3, :method_4
+#
+#     define_lazy_class_methods :class_method_1
+#     define_async_class_methods :class_method_2
+#
+#     ...
+#   end
+#
+# This will allow you to call the methods as
+#
+#   obj = MyClass.new
+#
+#   obj.lazy_method_1
+#   obj.lazy_method_2
+#
+#   obj.async_method_3
+#   obj.async_method_4
+#
+#   MyClass.lasy_class_method_1
+#   MyClass.async_class_method_2
+module LazyMethods
+  
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods
+    def define_lazy_methods(*method_names)
+      method_names.flatten.each do |method_name|
+        class_eval <<-EOS
+          def lazy_#{method_name}(*args, &block)
+            LazyProxy.new{ #{method_name}(*args, &block) }
+          end
+        EOS
+      end
+    end
+    
+    def define_async_methods(*method_names)
+      method_names.flatten.each do |method_name|
+        class_eval <<-EOS
+          def async_#{method_name}(*args, &block)
+            AsyncProxy.new{ #{method_name}(*args, &block) }
+          end
+        EOS
+      end
+    end
+    
+    def define_lazy_class_methods(*method_names)
+      method_names.flatten.each do |method_name|
+        class_eval <<-EOS
+          def self.lazy_#{method_name}(*args, &block)
+            LazyProxy.new{ #{method_name}(*args, &block) }
+          end
+        EOS
+      end
+    end
+    
+    def define_async_class_methods(*method_names)
+      method_names.flatten.each do |method_name|
+        class_eval <<-EOS
+          def self.async_#{method_name}(*args, &block)
+            AsyncProxy.new{ #{method_name}(*args, &block) }
+          end
+        EOS
+      end
+    end
+  end
+  
+  # The proxy object does all the heavy lifting.
+  class Proxy #:nodoc:
+    # These methods we don't want to override. All other existing methods will be redefined.
+    PROTECTED_METHODS = %w(initialize method_missing __proxy_result__ __proxy_loaded__ __send__ __id__ object_id)
+    
+    # Override already defined methods on Object to proxy them to the result object
+    instance_methods.each do |m|
+      undef_method(m) unless PROTECTED_METHODS.include?(m.to_s)
+    end
+        
+    # All missing methods are proxied to the original result object.
+    def method_missing(method, *args, &block)
+      __proxy_result__.send(method, *args, &block)
+    end
+  end
+  
+  class LazyProxy < Proxy #:nodoc:
+    def initialize(&block)
+      @method_call = block
+    end
+    
+    # Get the result of the original method call. The original method must only be called once.
+    def __proxy_result__
+      @proxy_result = @method_call.call unless defined?(@proxy_result)
+      @proxy_result
+    end
+    
+    # Helper method that indicates if the proxy has loaded the original method results yet.
+    def __proxy_loaded__
+      !!defined?(@proxy_result)
+    end
+  end
+  
+  class AsyncProxy < Proxy #:nodoc:
+    def initialize(&block)
+      @proxy_result = nil
+      @proxy_exception = nil
+      if defined?(Thread.critical) && Thread.critical
+        @proxy_result = block.call
+      else
+        @thread = Thread.new do
+          begin
+            @proxy_result = block.call
+          rescue Exception => e
+            @proxy_exception = e
+          end
+        end
+      end
+    end
+    
+    # Get the result of the original method call. The original method will only be called once.
+    def __proxy_result__
+      @thread.join if @thread && @thread.alive?
+      @thread = nil
+      raise @proxy_exception if @proxy_exception
+      return @proxy_result
+    end
+    
+    def __proxy_loaded__
+      !(@thread && @thread.alive?)
+    end
+  end
+end

data/spec/lazy_method_spec.rb

@@ -1,107 +1,86 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'lazy_methods', 'lazy_methods'))
-Object.send(:include, LazyMethods::InstanceMethods) unless Object.include?(LazyMethods::InstanceMethods)
-require File.expand_path(File.dirname(__FILE__) + '/method_tester')
+require 'spec_helper'
 
-describe LazyMethods::InstanceMethods do
-  
-  let(:object) { MethodTester.new }
-  
-  it "should inject lazy method handling" do
-    proxy = object.lazy_test("arg")
-    proxy.to_s.should == "ARG"
-    proxy.__proxy_loaded__.should == true
-  end
-  
-  it "should return a proxy object that has not been invoked yet" do
-    proxy = object.lazy_test("arg")
-    proxy.__proxy_loaded__.should == false
-  end
-  
-  it "should remove itself from stacktraces thrown in method_missing" do
-    begin
-      "object".call_a_missing_method_that_does_not_exist
-      raise "should not get here"
-    rescue => e
-      async_source_file = File.expand_path("../../lib/lazy_methods/lazy_methods.rb", __FILE__)
-      File.exist?(async_source_file).should == true
-      e.backtrace.join("\n").should_not include(async_source_file)
+describe LazyMethods do
+  context "lazy methods" do
+    let(:object){ LazyMethods::Tester.new }
+    
+    it "should define a lazy version of a method" do
+      proxy = object.lazy_test_method("woo")
+      object.test_method_called.should == 0
+      proxy.should == "WOO"
+      object.test_method_called.should == 1
+      proxy.to_s
+      object.test_method_called.should == 1
     end
-  end
-end
-
-describe LazyMethods::Proxy do
-  
-  let(:object) { MethodTester.new }
-  
-  it "should be able to wrap a method without executing it" do
-    proxy = object.lazy_test("arg")
-    object.test_called.should == 0
-  end
-  
-  it "should execute the wrapped method when it needs to" do
-    proxy = object.lazy_test("arg")
-    proxy.to_s
-    object.test_called.should == 1
-  end
-  
-  it "should only execute the wrapped method once" do
-    proxy = object.lazy_test("arg")
-    proxy.to_s
-    proxy.to_s
-    object.test_called.should == 1
-  end
-  
-  it "should allow nil as a valid proxied value" do
-    proxy = object.lazy_test(nil)
-    proxy.should_not
-    object.test_called.should == 1
-  end
-  
-  it "should allow blocks in the lazy method" do
-    n = 1
-    proxy = object.lazy_test("arg") do
-      n = 2
+    
+    it "should define a lazy version of a method that takes a block" do
+      block_evaled = false
+      proxy = object.lazy_test_method("woo"){ block_evaled = !block_evaled }
+      object.test_method_called.should == 0
+      block_evaled.should == false
+      proxy.should == "WOO"
+      object.test_method_called.should == 1
+      block_evaled.should == true
+      proxy.to_s
+      object.test_method_called.should == 1
+      block_evaled.should == true
     end
-    n.should == 1
-    proxy.to_s
-    n.should == 2
-  end
-  
-  it "should be indistinguishable from the real object" do
-    proxy = object.lazy_test("arg")
-    proxy.class.should == String
-    proxy.kind_of?(String).should == true
-  end
-  
-  it "should proxy core methods on Object" do
-    proxy = "xxx".lazy_to_s
-    proxy.should == "xxx"
-  end
-  
-  it "should proxy missing methods" do
-    proxy = object.lazy_find_test
-    proxy.to_s.should == "FINDER"
-  end
-  
-  it "should allow blocks in the lazy missing methods" do
-    n = 1
-    proxy = object.lazy_find_test do
-      n = 2
+    
+    it "should define a lazy version of a class method" do
+      LazyMethods::Tester.test_class_method_called = 0
+      block_evaled = false
+      proxy = LazyMethods::Tester.lazy_test_class_method("woo"){ block_evaled = !block_evaled }
+      LazyMethods::Tester.test_class_method_called.should == 0
+      block_evaled.should == false
+      proxy.should == "WOO"
+      LazyMethods::Tester.test_class_method_called.should == 1
+      block_evaled.should == true
+      proxy.to_s
+      LazyMethods::Tester.test_class_method_called.should == 1
+      block_evaled.should == true
     end
-    n.should == 1
-    proxy.to_s
-    n.should == 2
-  end
-  
-  it "should not interfere with the proxied object's method_missing" do
-    real = object.find_test
-    real.to_s.should == "FINDER"
   end
   
-  it "should not interfere with real methods that begin with lazy_" do
-    object.lazy_real_method_called.should == false
-    object.lazy_real_method
-    object.lazy_real_method_called.should == true
+  context "async methods" do
+    let(:object){ LazyMethods::Tester.new }
+    
+    it "should define an asynchronous version of a method" do
+      proxy = object.async_test_method("woo")
+      object.test_method_called.should == 0
+      sleep(0.2)
+      object.test_method_called.should == 1
+      proxy.should == "WOO"
+      proxy.to_s
+      object.test_method_called.should == 1
+    end
+    
+    it "should define an asynchronous version of a method that takes a block" do
+      block_evaled = false
+      proxy = object.async_test_method("woo"){ block_evaled = !block_evaled }
+      object.test_method_called.should == 0
+      block_evaled.should == false
+      sleep(0.2)
+      object.test_method_called.should == 1
+      block_evaled.should == true
+      proxy.should == "WOO"
+      proxy.to_s
+      object.test_method_called.should == 1
+      block_evaled.should == true
+    end
+    
+    it "should define an asynchronous version of a class method" do
+      LazyMethods::Tester.test_class_method_called = 0
+      block_evaled = false
+      proxy = LazyMethods::Tester.async_test_class_method("woo"){ block_evaled = !block_evaled }
+      LazyMethods::Tester.test_class_method_called.should == 0
+      block_evaled.should == false
+      sleep(0.2)
+      LazyMethods::Tester.test_class_method_called.should == 1
+      block_evaled.should == true
+      proxy.should == "WOO"
+      proxy.to_s
+      LazyMethods::Tester.test_class_method_called.should == 1
+      block_evaled.should == true
+    end
   end
-  
 end

data/spec/method_tester.rb

@@ -1,31 +1,35 @@
-# This class is used for testing the lazy_methods plugin functionality.
+# This class is used for testing the lazy_methods functionality.
 
-class MethodTester
+class LazyMethods::Tester
+  include LazyMethods
   
-  attr_reader :test_called, :lazy_real_method_called
+  attr_reader :test_method_called
+  
+  define_lazy_methods :test_method, :to_s
+  define_async_methods :test_method, :to_s
+  define_lazy_class_methods :test_class_method, :to_s
+  define_async_class_methods :test_class_method, :to_s
   
   def initialize
-    @test_called = 0
+    @test_method_called = 0
     @lazy_real_method_called = false
   end
   
-  def test (arg)
-    @test_called += 1
+  def test_method(arg)
+    sleep(0.02)
+    @test_method_called += 1
     yield if block_given?
     arg.upcase if arg
   end
   
-  def lazy_real_method
-    @lazy_real_method_called = true
-  end
-  
-  def method_missing (method, *args, &block)
-    if method.to_s[0, 5] == 'find_'
+  class << self
+    attr_accessor :test_class_method_called
+    
+    def test_class_method(arg)
+      sleep(0.02)
+      @test_class_method_called = (self.test_class_method_called || 0) + 1
       yield if block_given?
-      "FINDER"
-    else
-      super
+      arg.upcase if arg
     end
-  end
-  
+  end  
 end

data/spec/proxy_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe LazyMethods::LazyProxy do
+  it "should wrap a block and proxy all methods to the result" do
+    proxy = LazyMethods::LazyProxy.new{ "xyz" }
+    proxy.size.should == 3
+    proxy.to_sym.should == :xyz
+    proxy.is_a?(String).should == true
+    proxy.should == "xyz"
+  end
+  
+  it "should not evaluate the block until a method is called on it" do
+    value = "test"
+    proxy = LazyMethods::LazyProxy.new{ value << " called" }
+    value.should == "test"
+    proxy.should == "test called"
+    value.should == "test called"
+  end
+  
+  it "should only evaluate the block once" do
+    value = "test"
+    proxy = LazyMethods::LazyProxy.new{ value << " called" }
+    value.should == "test"
+    proxy.should == "test called"
+    proxy.should == "test called"
+    proxy.should == "test called"
+  end
+  
+  it "should be able to wrap nil" do
+    proxy = LazyMethods::LazyProxy.new{ nil }
+    proxy.should == nil
+    proxy.nil?.should == true
+  end
+  
+  it "should tell if the block has been evaluated" do
+    proxy = LazyMethods::LazyProxy.new{ "xyz" }
+    proxy.__proxy_loaded__.should == false
+    proxy.to_s
+    proxy.__proxy_loaded__.should == true
+  end
+end
+
+describe LazyMethods::AsyncProxy do
+  it "should wrap a block and proxy all methods to the result" do
+    proxy = LazyMethods::AsyncProxy.new{ "xyz" }
+    proxy.size.should == 3
+    proxy.to_sym.should == :xyz
+    proxy.is_a?(String).should == true
+    proxy.should == "xyz"
+  end
+  
+  it "should not block on evaluating the block until a method is called on it" do
+    value = "test"
+    proxy = LazyMethods::AsyncProxy.new{ sleep(0.25); value << " called" }
+    proxy.__proxy_loaded__.should == false
+    value.should == "test"
+    proxy.should == "test called"
+    value.should == "test called"
+  end
+  
+  it "should only evaluate the block once" do
+    value = "test"
+    proxy = LazyMethods::AsyncProxy.new{ sleep(0.25); value << " called" }
+    value.should == "test"
+    proxy.should == "test called"
+    proxy.should == "test called"
+    proxy.should == "test called"
+  end
+  
+  it "should be able to wrap nil" do
+    proxy = LazyMethods::AsyncProxy.new{ nil }
+    proxy.should == nil
+    proxy.nil?.should == true
+  end
+  
+  it "should tell if the block has been evaluated" do
+    proxy = LazyMethods::AsyncProxy.new{ sleep(0.25); "xyz" }
+    proxy.__proxy_loaded__.should == false
+    proxy.to_s
+    proxy.__proxy_loaded__.should == true
+  end
+  
+  if defined?(Thread.critical)
+    it "should not open a new thread if Thread.critical is true" do
+      Thread.should_receive(:new)
+      proxy = LazyMethods::AsyncProxy.new{ "abc" }
+      proxy.to_s
+    
+      begin
+        Thread.critical = true
+        Thread.should_not_receive(:new)
+        proxy = LazyMethods::AsyncProxy.new{ "xyz" }
+        proxy.should == "xyz"
+      ensure
+        Thread.critical = false
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,26 +1,2 @@
-# This file is copied to ~/spec when you run 'ruby script/generate rspec'
-# from the project root directory.
-ENV["RAILS_ENV"] ||= "test"
-require File.expand_path(File.dirname(__FILE__) + "/../../../../config/environment")
-require 'spec/rails'
-
-Spec::Runner.configure do |config|
-  config.use_transactional_fixtures = true
-  config.use_instantiated_fixtures  = false
-  config.fixture_path = RAILS_ROOT + '/spec/fixtures'
-  config.before(:each, :behaviour_type => :controller) do
-    raise_controller_errors
-  end
-
-  # You can declare fixtures for each behaviour like this:
-  #   describe "...." do
-  #     fixtures :table_a, :table_b
-  #
-  # Alternatively, if you prefer to declare them only once, you can
-  # do so here, like so ...
-  #
-  #   config.global_fixtures = :table_a, :table_b
-  #
-  # If you declare global fixtures, be aware that they will be declared
-  # for all of your examples, even those that don't use them.
-end
+require File.expand_path("../../lib/lazy_methods.rb", __FILE__)
+require File.expand_path("../method_tester.rb", __FILE__)

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: lazy_methods
 version: !ruby/object:Gem::Version 
-  hash: 27
   prerelease: 
-  segments: 
-  - 1
-  - 0
-  - 6
-  version: 1.0.6
+  version: 2.0.0
 platform: ruby
 authors: 
 - Brian Durand
@@ -15,40 +10,54 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-24 00:00:00 -06:00
+date: 2011-08-29 00:00:00 -05:00
 default_executable: 
 dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: rspec
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.6.0
+  type: :runtime
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 15
-        segments: 
-        - 2
-        - 0
-        - 0
         version: 2.0.0
   type: :development
-  version_requirements: *id001
+  prerelease: false
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: jeweler
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
   type: :development
-  version_requirements: *id002
-description: Gem that adds lazy method wrapping to every object. Preceding any method with lazy_ will defer the invocation until the result is actually needed. This pattern is useful when used with caching systems.
+  prerelease: false
+  version_requirements: *id004
+description: Gem that adds lazy method delegation methods. Using this gem you can easily define lazy loading or asynchronous versions of specific methods. Lazy loading is useful when used with caching systems while asynchronous methods can improve throughput on I/O bound processes like making several HTTP calls in row.
 email: brian@embellishedvisions.com
 executables: []
 
@@ -57,15 +66,18 @@ extensions: []
 extra_rdoc_files: 
 - README.rdoc
 files: 
+- .travis.yml
+- Gemfile
+- Gemfile.lock
 - MIT-LICENSE
 - README.rdoc
 - Rakefile
 - VERSION
 - lazy_methods.gemspec
 - lib/lazy_methods.rb
-- lib/lazy_methods/lazy_methods.rb
 - spec/lazy_method_spec.rb
 - spec/method_tester.rb
+- spec/proxy_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/bdurand/lazy_methods
@@ -83,27 +95,22 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.4.1
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
-summary: Gem that adds lazy method wrapping to every object. Preceding any method with lazy_ will defer the invocation until the result is actually needed.
+summary: Gem that adds lazy method delegation methods. Using this gem you can easily define lazy loading or asynchronous versions of specific methods. Lazy loading is useful when used with caching systems while asynchronous methods can improve throughput on I/O bound processes like making several HTTP calls in row.
 test_files: 
 - spec/lazy_method_spec.rb
 - spec/method_tester.rb
+- spec/proxy_spec.rb
 - spec/spec_helper.rb

data/lib/lazy_methods/lazy_methods.rb

@@ -1,88 +0,0 @@
-# Including this module will provide the lazy method handling for the class where any method can be
-# prefixed with lazy_ to defer execution. By default, the plugin includes it in Object so it is universally
-# available.
-module LazyMethods
-  
-  module InstanceMethods
-    def self.included (base)
-      base.send :alias_method, :method_missing_without_lazy, :method_missing
-      base.send :alias_method, :method_missing, :method_missing_with_lazy
-    end
-    
-    # Override missing method to add the lazy method handling
-    def method_missing_with_lazy (method, *args, &block)
-      method = method.to_s
-      if method[0, 5] == 'lazy_'
-        method = method.to_s
-        called_method = method[5, method.length]
-        return Proxy.new(self, called_method, args, &block)
-      else
-        # Keep track of the current missing method calls to keep out of an infinite loop
-        stack = Thread.current[:lazy_method_missing_methods] ||= []
-        sig = MethodSignature.new(self, method)
-        raise NoMethodError.new("undefined method `#{method}' for #{self}") if stack.include?(sig)
-        begin
-          stack.push(sig)
-          return method_missing_without_lazy(method, *args, &block)
-        rescue Exception => e
-          # Strip this method from the stack trace as it adds confusion
-          e.backtrace.reject!{|line| line.include?(__FILE__)}
-          raise e
-        ensure
-          stack.pop
-        end
-      end
-    end
-  end
-  
-  # This class is used to keep track of methods being called.
-  class MethodSignature
-    
-    attr_reader :object, :method
-    
-    def initialize (obj, method)
-      @object = obj
-      @method = method
-    end
-    
-    def eql? (sig)
-      sig.kind_of(MethodSignature) && sig.object == @object && sig.method == @method
-    end
-    
-  end
-  
-  # The proxy object does all the heavy lifting.
-  class Proxy
-    # These methods we don't want to override. All other existing methods will be redefined.
-    PROTECTED_METHODS = %w(initialize method_missing __proxy_result__ __proxy_loaded__ __send__ __id__ object_id)
-    
-    # Override already defined methods on Object to proxy them to the result object
-    instance_methods.each do |m|
-      undef_method(m) unless PROTECTED_METHODS.include?(m.to_s)
-    end
-    
-    def initialize (obj, method, args = nil, &block)
-      @object = obj
-      @method = method
-      @args = args || []
-      @block = block
-    end
-    
-    # Get the result of the original method call. The original method will only be called once.
-    def __proxy_result__
-      @proxy_result = @object.send(@method, *@args, &@block) unless defined?(@proxy_result)
-      @proxy_result
-    end
-    
-    # Helper method that indicates if the proxy has loaded the original method results yet.
-    def __proxy_loaded__
-      !!defined?(@proxy_result)
-    end
-    
-    # All missing methods are proxied to the original result object.
-    def method_missing (method, *args, &block)
-      __proxy_result__.send(method, *args, &block)
-    end
-  end
-  
-end