lazy_methods 1.0.2 → 1.0.3

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2007 Brian Durand
+Copyright (c) 2010 Brian Durand
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -0,0 +1,33 @@
+== 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 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:
+
+The business logic:
+
+  def my_action
+	  @records = MyResource.find(params[:name])
+  end
+
+And in the view:
+
+	<% cache(params[:names]) -%>
+		<% @records.each do |record| -%>
+			<div><%=record.title%></div>
+		<% end -%>
+	<% 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.
+
+	def my_action
+		@records = MyResource.lazy_find(params[:name])
+	end
+
+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.
+
+== Testing
+
+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.

data/Rakefile

@@ -1,43 +1,45 @@
 require 'rubygems'
 require 'rake'
 require 'rake/rdoctask'
-require 'rake/gempackagetask'
-require 'spec/rake/spectask'
 
 desc 'Default: run unit tests.'
 task :default => :test
 
-desc 'Test the lazy_methods plugin.'
-Spec::Rake::SpecTask.new(:test) do |t|
-  t.spec_files = 'spec/**/*_spec.rb'
+begin
+  require 'spec/rake/spectask'
+  desc 'Test the gem.'
+  Spec::Rake::SpecTask.new(:test) do |t|
+    t.spec_files = FileList.new('spec/**/*_spec.rb')
+  end
+rescue LoadError
+  tast :test do
+    STDERR.puts "You must have rspec >= 1.3.0 to run the tests"
+  end
 end
 
-desc 'Generate documentation for the lazy_methods plugin.'
+desc 'Generate documentation for the gem.'
 Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.options << '--title' << 'LazyMethods' << '--line-numbers' << '--inline-source' << '--main' << 'README'
-  rdoc.rdoc_files.include('README')
+  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
 
-spec = Gem::Specification.new do |s| 
-  s.name = "lazy_methods"
-  s.version = "1.0.2"
-  s.author = "Brian Durand"
-  s.platform = Gem::Platform::RUBY
-  s.summary = "Provide lazy method calls for all methods on every object to aid in caching."
-  s.files = FileList["lib/**/*", "MIT-LICENSE", 'Rakefile'].to_a
-  s.require_path = "lib"
-  s.test_files = FileList["{spec}/**/*.rb"].to_a
-  s.has_rdoc = true
-  s.rdoc_options << '--title' << 'LazyMethods' << '--line-numbers' << '--inline-source' << '--main' << 'README'
-  s.extra_rdoc_files = ["README"]
-  s.homepage = "http://lazymethods.rubyforge.org"
-  s.rubyforge_project = "lazymethods"
-  s.email = 'brian@embellishedvisions.com'
-end
- 
-Rake::GemPackageTask.new(spec) do |pkg| 
-  pkg.need_tar = true 
-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.email = "brian@embellishedvisions.com"
+    gem.homepage = "http://github.com/bdurand/acts_as_revisionable"
+    gem.authors = ["Brian Durand"]
+    gem.rdoc_options = ["--charset=UTF-8", "--main", "README.rdoc"]
+    
+    gem.add_development_dependency('rspec', '>= 1.3.0')
+    gem.add_development_dependency('jeweler')
+  end
 
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.3

data/lazy_methods.gemspec

@@ -0,0 +1,58 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{lazy_methods}
+  s.version = "1.0.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Brian Durand"]
+  s.date = %q{2010-06-22}
+  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.email = %q{brian@embellishedvisions.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "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/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/bdurand/acts_as_revisionable}
+  s.rdoc_options = ["--charset=UTF-8", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  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.test_files = [
+    "spec/lazy_method_spec.rb",
+     "spec/method_tester.rb",
+     "spec/spec_helper.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_development_dependency(%q<rspec>, [">= 1.3.0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.3.0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.3.0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+  end
+end
+

data/lib/lazy_methods.rb

@@ -1,2 +1,2 @@
-require 'lazy_methods/lazy_methods'
+require File.expand_path('../lazy_methods/lazy_methods', __FILE__)
 Object.send(:include, LazyMethods::InstanceMethods) unless Object.include?(LazyMethods::InstanceMethods)

data/spec/lazy_method_spec.rb

@@ -4,18 +4,16 @@ require File.expand_path(File.dirname(__FILE__) + '/method_tester')
 
 context "LazyMethods InstanceMethods" do
   
-  setup do
-    @object = MethodTester.new
-  end
+  let(:object) { MethodTester.new }
   
   specify "should inject lazy method handling" do
-    proxy = @object.lazy_test("arg")
+    proxy = object.lazy_test("arg")
     proxy.to_s.should == "ARG"
     proxy.__proxy_loaded__.should == true
   end
   
   specify "should return a proxy object that has not been invoked yet" do
-    proxy = @object.lazy_test("arg")
+    proxy = object.lazy_test("arg")
     proxy.__proxy_loaded__.should == false
   end
   
@@ -23,37 +21,35 @@ end
 
 context "LazyMethods Proxy" do
   
-  setup do
-    @object = MethodTester.new
-  end
+  let(:object) { MethodTester.new }
   
   specify "should be able to wrap a method without executing it" do
-    proxy = @object.lazy_test("arg")
-    @object.test_called.should == 0
+    proxy = object.lazy_test("arg")
+    object.test_called.should == 0
   end
   
   specify "should execute the wrapped method when it needs to" do
-    proxy = @object.lazy_test("arg")
+    proxy = object.lazy_test("arg")
     proxy.to_s
-    @object.test_called.should == 1
+    object.test_called.should == 1
   end
   
   specify "should only execute the wrapped method once" do
-    proxy = @object.lazy_test("arg")
+    proxy = object.lazy_test("arg")
     proxy.to_s
     proxy.to_s
-    @object.test_called.should == 1
+    object.test_called.should == 1
   end
   
   specify "should allow nil as a valid proxied value" do
-    proxy = @object.lazy_test(nil)
+    proxy = object.lazy_test(nil)
     proxy.should_not
-    @object.test_called.should == 1
+    object.test_called.should == 1
   end
   
   specify "should allow blocks in the lazy method" do
     n = 1
-    proxy = @object.lazy_test("arg") do
+    proxy = object.lazy_test("arg") do
       n = 2
     end
     n.should == 1
@@ -62,7 +58,7 @@ context "LazyMethods Proxy" do
   end
   
   specify "should be indistinguishable from the real object" do
-    proxy = @object.lazy_test("arg")
+    proxy = object.lazy_test("arg")
     proxy.class.should == String
     proxy.kind_of?(String).should == true
   end
@@ -73,13 +69,13 @@ context "LazyMethods Proxy" do
   end
   
   specify "should proxy missing methods" do
-    proxy = @object.lazy_find_test
+    proxy = object.lazy_find_test
     proxy.to_s.should == "FINDER"
   end
   
   specify "should allow blocks in the lazy missing methods" do
     n = 1
-    proxy = @object.lazy_find_test do
+    proxy = object.lazy_find_test do
       n = 2
     end
     n.should == 1
@@ -88,14 +84,14 @@ context "LazyMethods Proxy" do
   end
   
   specify "should not interfere with the proxied object's method_missing" do
-    real = @object.find_test
+    real = object.find_test
     real.to_s.should == "FINDER"
   end
   
   specify "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
+    object.lazy_real_method_called.should == false
+    object.lazy_real_method
+    object.lazy_real_method_called.should == true
   end
   
 end

data/spec/method_tester.rb

@@ -20,7 +20,7 @@ class MethodTester
   end
   
   def method_missing (method, *args, &block)
-    if method.to_s.starts_with?('find_')
+    if method.to_s[0, 5] == 'find_'
       yield if block_given?
       "FINDER"
     else

data/spec/spec_helper.rb

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

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: lazy_methods
 version: !ruby/object:Gem::Version 
-  version: 1.0.2
+  hash: 17
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 3
+  version: 1.0.3
 platform: ruby
 authors: 
 - Brian Durand
@@ -9,56 +15,96 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-01-17 00:00:00 -06:00
+date: 2010-06-22 00:00:00 -05:00
 default_executable: 
-dependencies: []
-
-description: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  prerelease: false
+  requirement: &id002 !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.
 email: brian@embellishedvisions.com
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
-- README
+- README.rdoc
 files: 
-- lib/lazy_methods
-- lib/lazy_methods.rb
-- lib/lazy_methods/lazy_methods.rb
+- .gitignore
 - MIT-LICENSE
+- README.rdoc
 - Rakefile
-- README
+- VERSION
+- lazy_methods.gemspec
+- lib/lazy_methods.rb
+- lib/lazy_methods/lazy_methods.rb
+- spec/lazy_method_spec.rb
+- spec/method_tester.rb
+- spec/spec_helper.rb
 has_rdoc: true
-homepage: http://lazymethods.rubyforge.org
+homepage: http://github.com/bdurand/acts_as_revisionable
+licenses: []
+
 post_install_message: 
 rdoc_options: 
-- --title
-- LazyMethods
-- --line-numbers
-- --inline-source
+- --charset=UTF-8
 - --main
-- README
+- README.rdoc
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
-rubyforge_project: lazymethods
-rubygems_version: 1.0.1
+rubyforge_project: 
+rubygems_version: 1.3.7
 signing_key: 
-specification_version: 2
-summary: Provide lazy method calls for all methods on every object to aid in caching.
+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.
 test_files: 
 - spec/lazy_method_spec.rb
 - spec/method_tester.rb
+- spec/spec_helper.rb

data/README

@@ -1,37 +0,0 @@
-== LazyMethods
-
-So your Rails application is successful beyond your wildest dreams and now your meager servers are straining under the load. You figure you'll add some caching to your views and all will be well again. Unfortunately, your controller actions load up all sorts of instance variables with records from the database. The caching won't do you much good if your database is still getting slammed. You could move your query logic to the views behind the caching layer, but that just feels icky. Besides, that will break all your tests and you really don't feel like fixing them.
-
-== Enter LazyMethods.
-
-This plugin 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 way you can continue to set up the business logic in your controller and have it only actually executed only as needed.
-
-If you add fragment caching to your views and the cache returns a value and bypasses your view code, the method will never be invoked. Thanks to the magic of Ruby the proxy object will even act like the class it is proxying in class to class and kind_of?
-
-A simple example:
-
-The normal way to do it (at least according to every tutorial):
-
-  def index
-	  @records = MyRecord.find(:all, :conditions => {:name => params[:name]})
-  end
-
-And in the view:
-
-	<% cache(params[:names]) -%>
-		<% @records.each do |record| -%>
-			<div><%=record.title%></div>
-		<% end -%>
-	<% 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 code from the action and simple add it back into the view. However, this just feels wrong and is inherently harder to test. Instead just use a lazy method.
-
-	def index
-		@records = MyRecord.lazy_find(:all, :conditions => {:name => params[:name]})
-	end
-
-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.
-
-== Testing
-
-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.