draper 0.4.1.1 → 0.4.2

data/Readme.markdown

@@ -1,70 +1,114 @@
-## Heads Up!
+# Draper: View Models for Rails
 
-This gem is not yet production ready. The API is sure to change quickly and there could be side-effects I haven't discovered yet.
+## Quick Start
 
-Please only use it if you're playing around and helping me experiment! Thanks :)
+1. Add `gem 'draper'` to your `Gemfile` and `bundle`
+2. Run `rails g draper:model YourModel`
+3. Edit `app/decorators/your_model_decorator.rb` using:
+  1. `h` to proxy to Rails/application helpers like `h.current_user`
+  2. `model` to access the wrapped object like `model.created_at`
+4. Wrap models in your controller with the decorator using:
+  1. `.find` automatic lookup & wrap: `ArticleDecorator.find(1)`
+  2. `.decorate` method with single object or collection: `ArticleDecorator.decorate(Article.all)`
+  3. `.new` method with single object: `ArticleDecorator.new(Article.first)`
+5. Call and output the methods in your view templates as normal
 
-# Draper
+## Goals
 
-This gem makes it easy to apply the decorator pattern to the models in a Rails application. This gives you three wins:
+This gem makes it easy to apply the decorator pattern to the data models in a Rails application. This gives you three wins:
 
 1. Replace most helpers with an object-oriented approach
 2. Filter data at the presentation level
 3. Enforce an interface between your controllers and view templates.
 
-## 1. Object Oriented Helpers
 
-Why hate helpers? In Ruby/Rails we approach everything from an Object-Oriented perspective, then with helpers we get procedural.The job of a helper is to take in data and output a presentation-ready string. We can do that job in an OO style with a decorator.
+### 1. Object Oriented Helpers
 
-In general, a decorator wraps an object with presentation-related accessor methods. For instance, if you had an `Article` object, then a decorator might add instance methods like `.formatted_published_at` or `.formatted_title` that output actual HTML.
+Why hate helpers? In Ruby/Rails we approach everything from an Object-Oriented perspective, then with helpers we get procedural.The job of a helper is to take in data and output a presentation-ready string. We can do that with a decorator.
 
-For example:
+A decorator wraps an object with presentation-related accessor methods. For instance, if you had an `Article` object, then the decorator could override `.published_at` to use formatted output like this:
 
 ```ruby
 class ArticleDecorator < Draper::Base
-  def formatted_published_at
-    date = content_tag(:span, published_at.strftime("%A, %B %e").squeeze(" "), :class => 'date')
-    time = content_tag(:span, published_at.strftime("%l:%M%p"), :class => 'time').delete(" ")
-    content_tag :span, date + time, :class => 'created_at'
+  decorates :article
+  def published_at
+    date = h.content_tag(:span, model.published_at.strftime("%A, %B %e").squeeze(" "), :class => 'date')
+    time = h.content_tag(:span, model.published_at.strftime("%l:%M%p"), :class => 'time').delete(" ")
+    h.content_tag :span, date + time, :class => 'created_at'
   end
 end
 ```
 
-## 2. View-Layer Data Filtering
+### 2. View-Layer Data Filtering
 
-Have you ever written a `to_xml` or `to_json` method in your model? Did it feel weird to put what is essentially view logic in your model?
+Have you ever written a `to_xml` or `to_json` method in your model? Did it feel weird to put presentation logic in your model?
 
 Or, in the course of formatting this data, did you wish you could access `current_user` down in the model? Maybe for guests your `to_json` is only going to show three attributes, but if the user is an admin they get to see them all.
 
 How would you handle this in the model layer? You'd probably pass the `current_user` or some role/flag down to `to_json`. That should still feel slimy.
 
-When you use a decorator you have the power of a Ruby object but it's a part of the view layer. This is where your `to_xml` belongs. It has access to the core data from the model, but it also knows about `current_user` because it can see the `ApplicationHelper` where that method is typically defined.
-
-For example:
+When you use a decorator you have the power of a Ruby object but it's a part of the view layer. This is where your `to_xml` belongs. You can access your `current_user` helper method using the `h` proxy available in the decorator:
 
 ```ruby
 class ArticleDecorator < Draper::Base
+  decorates :article
   ADMIN_VISIBLE_ATTRIBUTES = [:title, :body, :author, :status]
   PUBLIC_VISIBLE_ATTRIBUTES = [:title, :body]
 
   def to_xml
-    attr_set = current_user.admin? ? ADMIN_VISIBLE_ATTRIBUTES : PUBLIC_VISIBLE_ATTRIBUTES
-    self.subject.to_xml(:only => attr_set)
+    attr_set = h.current_user.admin? ? ADMIN_VISIBLE_ATTRIBUTES : PUBLIC_VISIBLE_ATTRIBUTES
+    model.to_xml(:only => attr_set)
   end
 end
 ```
 
-## How is it implemented?
+### 3. Enforcing an Interface
+
+Want to strictly control what methods are proxied to the original object? Use `denies` or `allows`.
+
+#### Using `denies`
+
+The `denies` method takes a blacklist approach. For instance:
+
+```ruby
+class ArticleDecorator < Draper::Base
+  decorates :article
+  denies :title
+end
+```
+
+Then, to test it:
+
+```irb
+ruby-1.9.2-p290 :001 > ad = ArticleDecorator.find(1)
+ => #<ArticleDecorator:0x000001020d7728 @model=#<Article id: 1, title: "Hello, World">> 
+ruby-1.9.2-p290 :002 > ad.title
+NoMethodError: undefined method `title' for #<ArticleDecorator:0x000001020d7728>
+``` 
+
+#### Using `allows`
 
-To implement the pattern in Rails we can:
+A better approach is to define a whitelist using `allows`:
 
-1. Write a wrapper class with the decoration methods
-2. Wrap the data object
-3. Utilize those methods within our view layer
+```ruby
+class ArticleDecorator < Draper::Base
+  decorates :article
+  allows :title, :description
+end
+```
+
+```irb
+ruby-1.9.2-p290 :001 > ad = ArticleDecorator.find(1)
+ => #<ArticleDecorator:0x000001020d7728 @model=#<Article id: 1, title: "Hello, World">> 
+ruby-1.9.2-p290 :002 > ad.title
+ => "Hello, World"
+ruby-1.9.2-p290 :003 > ad.created_at
+NoMethodError: undefined method `created_at' for #<ArticleDecorator:0x000001020d7728>
+```
 
-## How do you utilize this gem in your application?
+## Up an Running
 
-Here are the steps to utilizing this gem:
+### Setup
 
 Add the dependency to your `Gemfile`:
 
@@ -78,49 +122,73 @@ Run bundle:
 bundle
 ```
 
-Create a decorator for your model (ex: `Article`)
+### Generate the Decorator
+
+To decorate a model named `Article`:
 
 ```
 rails generate draper:model Article
 ```
 
-Open the decorator model (ex: `app/decorators/article_decorator.rb`)
+### Writing Methods
 
-Add your new formatting methods as normal instance or class methods. You have access to the Rails helpers from the following classes:
+Open the decorator model (ex: `app/decorators/article_decorator.rb`) and add normal instance methods. To access the wrapped source object, use the `model` method:
 
-```
-ActionView::Helpers::TagHelper
-ActionView::Helpers::UrlHelper
-ActionView::Helpers::TextHelper
+```ruby
+class Article < Draper::Base
+  decorates :article
+  
+  def author_name
+    model.author.first_name + " " + model.author.last_name
+  end
+end
 ```
 
-Use the new methods in your views like any other model method (ex: `@article.formatted_published_at`)
 
-## An Interface with Allows/Denies
+### Using Existing Helpers
 
-A proper interface defines a contract between two objects. One purpose of the decorator pattern is to define an interface between your data model and the view template.
-
-You are provided class methods `allows` and `denies` to control exactly which of the subject's methods are available. By default, *all* of the subject's methods can be accessed.
-
-For example, say you want to prevent access to the `:title` method. You'd use `denies` like this:
+You probably want to make use of Rails helpers and those defined in your application. Use the `helpers` or `h` method proxy:
 
 ```ruby
-  class ArticleDecorator < Draper::Base
-    denies :title
+class Article < Draper::Base
+  decorates :article
+  
+  def published_at
+    date = h.content_tag(:span, model.published_at.strftime("%A, %B %e").squeeze(" "), :class => 'date')
+    time = h.content_tag(:span, model.published_at.strftime("%l:%M%p"), :class => 'time').delete(" ")
+    h.content_tag :span, date + time, :class => 'created_at'
   end
+end
 ```
 
-`denies` uses a blacklist approach. Note that, as of the current version, denying `:title` does not affect related methods like `:title=`, `:title?`, etc.
+### In the Controller
 
-A better idea is a whitelist approach using `allows`:
+When writing your controller actions, you have three options:
 
-```ruby
-  class ArticleDecorator < Draper::Base
-    allows :title, :body, :author
-  end
-```
+* Call `.new` and pass in the object to be wrapped
+
+  ```ruby
+  ArticleDecorator.new(Article.find(params[:id]))`
+  ```
+
+* Call `.decorate` and pass in an object or collection of objects to be wrapped:
+  ```ruby
+  ArticleDecorator.decorate(Article.first) # Returns one instance of ArticleDecorator
+  ArticleDecorator.decorate(Article.all)   # Returns an array of ArticleDecorator instances
+  ```
+  
+* Call `.find` to do automatically do a lookup on the `decorates` class:
+  ```ruby
+  ArticleDecorator.find(1)
+  ```
+  
+### In Your Views
 
-Now only those methods and any defined in the decorator class itself can be accessed directly.
+Use the new methods in your views like any other model method (ex: `@article.published_at`):
+
+```erb
+<h1><%= @article.title %> <%= @article.published_at %></h1>
+```
 
 ## Possible Decoration Methods
 
@@ -132,6 +200,8 @@ Here are some ideas of what you might do in decorator methods:
 
 ## Example Using a Decorator
 
+For a brief tutorial with sample project, check this out: http://tutorials.jumpstartlab.com/rails/topics/decorators.html
+
 Say I have a publishing system with `Article` resources. My designer decides that whenever we print the `published_at` timestamp, it should be constructed like this:
 
 ```html
@@ -143,7 +213,7 @@ Say I have a publishing system with `Article` resources. My designer decides tha
 
 Could we build that using a partial? Yes. A helper? Uh-huh. But the point of the decorator is to encapsulate logic just like we would a method in our models. Here's how to implement it.
 
-First, follow the steps above to add the dependency, update your bundle, then run the `rails generate decorator:setup` to prepare your app.
+First, follow the steps above to add the dependency and update your bundle.
 
 Since we're talking about the `Article` model we'll create an `ArticleDecorator` class. You could do it by hand, but use the provided generator:
 
@@ -154,21 +224,19 @@ rails generate draper:model Article
 Now open up the created `app/decorators/article_decorator.rb` and you'll find an `ArticleDecorator` class. Add this method:
 
 ```ruby
-def formatted_published_at
-  date = content_tag(:span, published_at.strftime("%A, %B %e").squeeze(" "), :class => 'date')
-  time = content_tag(:span, published_at.strftime("%l:%M%p").delete(" "), :class => 'time')
-  content_tag :span, date + time, :class => 'published_at'
+def published_at
+  date = h.content_tag(:span, model.published_at.strftime("%A, %B %e").squeeze(" "), :class => 'date')
+  time = h.content_tag(:span, model.published_at.strftime("%l:%M%p").delete(" "), :class => 'time')
+  h.content_tag :span, date + time, :class => 'published_at'
 end
 ```
 
-*ASIDE*: Unfortunately, due to the current implementation of `content_tag`, you can't use the style of sending the content is as a block or you'll get an error about `undefined method 'output_buffer='`. Passing in the content as the second argument, as above, works fine.
-
 Then you need to perform the wrapping in your controller. Here's the simplest method:
 
 ```ruby
 class ArticlesController < ApplicationController
   def show
-    @article = ArticleDecorator.new( Article.find params[:id] )
+    @article = ArticleDecorator.find params[:id]
   end
 end
 ```
@@ -176,17 +244,19 @@ end
 Then within your views you can utilize both the normal data methods and your new presentation methods:
 
 ```ruby
-<%= @article.formatted_published_at %>
+<%= @article.published_at %>
 ```
 
 Ta-da! Object-oriented data formatting for your view layer. Below is the complete decorator with extra comments removed:
 
 ```ruby
 class ArticleDecorator < Draper::Base
-  def formatted_published_at
-    date = content_tag(:span, published_at.strftime("%A, %B %e").squeeze(" "), :class => 'date')
-    time = content_tag(:span, published_at.strftime("%l:%M%p"), :class => 'time').delete(" ")
-    content_tag :span, date + time, :class => 'created_at'
+  decorates :article
+  
+  def published_at
+    date = h.content_tag(:span, published_at.strftime("%A, %B %e").squeeze(" "), :class => 'date')
+    time = h.content_tag(:span, published_at.strftime("%l:%M%p"), :class => 'time').delete(" ")
+    h.content_tag :span, date + time, :class => 'created_at'
   end
 end
 ```
@@ -194,10 +264,8 @@ end
 ## Issues / Pending
 
 * Test coverage for generators
-* Ability to decorate multiple objects at once, ex: `ArticleDecorator.decorate(Article.all)`
-* Revise readme to better explain interface pattern
+* Keep revising Readme for better organization/clarity
 * Build sample Rails application
-* Consider: `ArticleDecorator.new(1)` does the equivalent of `ArticleDecorator.new(Article.find(1))`
 
 ## License
 

data/lib/draper.rb

@@ -1,2 +1,7 @@
 require "draper/version"
-require 'draper/base'
+require 'draper/system'
+require 'draper/all_helpers'
+require 'draper/base'
+require 'draper/lazy_helpers'
+
+Draper::System.setup

data/lib/draper/all_helpers.rb

@@ -0,0 +1,43 @@
+module Draper
+  module AllHelpers
+    # Provide access to helper methods from outside controllers and views,
+    # such as in Presenter objects. Rails provides ActionController::Base.helpers,
+    # but this does not include any of our application helpers.
+    def all_helpers
+      @all_helpers_proxy ||= begin
+        # Start with just the rails helpers. This is the same method used
+        # by ActionController::Base.helpers
+        # proxy = ActionView::Base.new.extend(_helpers)
+        proxy = ActionController::Base.helpers
+
+        # url_for depends on _routes method being defined
+        proxy.instance_eval do
+          def _routes
+            Rails.application.routes
+          end
+        end
+     
+        # Import all named path methods
+        proxy.extend(Rails.application.routes.named_routes.module)
+
+        # Load all our application helpers to extend
+        modules_for_helpers([:all]).each do |mod|
+          proxy.extend(mod)
+        end
+
+        proxy.instance_eval do
+          # A hack since this proxy doesn't pick up default_url_options from anywhere
+          def url_for(*args)
+            if args.last.is_a?(Hash) && !args.last[:only_path]
+              args = args.dup
+              args << args.pop.merge(host: ActionMailer::Base.default_url_options[:host])
+            end
+            super(*args)
+          end
+        end
+
+        proxy
+      end
+    end
+  end
+end

data/lib/draper/base.rb

@@ -1,23 +1,28 @@
 module Draper
-  class Base  
-    include ActionView::Helpers::TagHelper
-    include ActionView::Helpers::UrlHelper
-    include ActionView::Helpers::TextHelper
-
+  class Base      
     require 'active_support/core_ext/class/attribute'
-    class_attribute :denied, :allowed, :source_class
-    attr_accessor   :source
+    class_attribute :denied, :allowed, :model_class
+    attr_accessor :model
     
     DEFAULT_DENIED = Object.new.methods << :method_missing
+    FORCED_PROXY = [:to_param]
     self.denied = DEFAULT_DENIED
 
-    def initialize(subject)
-      subject.inspect
-      self.class.source_class = subject.class
-      self.source = subject      
+    def initialize(input)
+      input.inspect
+      self.class.model_class = input.class if model_class.nil?
+      @model = input      
       build_methods
     end
     
+    def self.find(input)
+      self.new(model_class.find(input))
+    end
+    
+    def self.decorates(input)
+      self.model_class = input.to_s.classify.constantize
+    end
+    
     def self.denies(*input_denied)
       raise ArgumentError, "Specify at least one method (as a symbol) to exclude when using denies" if input_denied.empty?
       raise ArgumentError, "Use either 'allows' or 'denies', but not both." if self.allowed?
@@ -35,25 +40,29 @@ module Draper
     end
     
     def helpers
-      ActionController::Base.helpers
+      @helpers ||= ApplicationController::all_helpers
     end
+    alias :h :helpers
     
     def self.model_name
       ActiveModel::Name.new(source_class)
     end
-        
-  private
+    
+    def to_model
+      @model
+    end
+            
+  private  
     def select_methods
-      self.allowed || (source.public_methods - denied)
+      specified = self.allowed || (model.public_methods - denied)
+      (specified - self.public_methods) + FORCED_PROXY
     end
 
     def build_methods
       select_methods.each do |method|
-        unless self.respond_to?(method)
-          (class << self; self; end).class_eval do
-            define_method method do |*args, &block|
-              source.send method, *args, &block
-            end
+        (class << self; self; end).class_eval do
+          define_method method do |*args, &block|
+            model.send method, *args, &block
           end
         end
       end  

data/lib/draper/lazy_helpers.rb

@@ -0,0 +1,11 @@
+module Draper
+  module LazyHelpers
+    def method_missing(method_name, *args, &block)
+      begin
+        helpers.send method_name, *args, &block
+      rescue NoMethodError
+        super
+      end
+    end
+  end
+end

data/lib/draper/system.rb

@@ -0,0 +1,7 @@
+module Draper
+  class System    
+    def self.setup
+      ActionController::Base.send(:extend, Draper::AllHelpers) if defined?(ActionController::Base)
+    end
+  end
+end

data/lib/draper/version.rb

@@ -1,3 +1,3 @@
 module Draper
-  VERSION = "0.4.1.1"
+  VERSION = "0.4.2"
 end

data/lib/generators/draper/model/templates/model.rb

@@ -1,24 +1,28 @@
 class <%= singular_name.camelize %>Decorator < Draper::Base
+  decorates :<%= singular_name.to_sym %>
 
-  # Rails Helpers
-  #   Rails helpers like content_tag, link_to, and pluralize are already
-  #   available to you. If you need access to other helpers, include them
-  #   like this:
-  #     include ActionView::Helpers::TextHelper
-  #   Or pull in the whole kitchen sink:
-  #     include ActionView::Helpers
+  # Helpers from Rails an Your Application
+  #   You can access any helper via a proxy to ApplicationController
+  #
+  #   Normal Usage: helpers.number_to_currency(2)
+  #   Abbreviated : h.number_to_currency(2)
+  #   
+  #   You can optionally enable "lazy helpers" by including this module:
+  #     include Draper::LazyHelpers
+  #   Then use the helpers with no prefix:
+  #     number_to_currency(2)
 
   # Wrapper Methods
   #   Control access to the wrapped subject's methods using one of the following:
   #
-  #   To allow _only_ the listed methods:
+  #   To allow only the listed methods (whitelist):
   #     allows :method1, :method2
   #
-  #   To allow everything _except_ the listed methods:
+  #   To allow everything except the listed methods (blacklist):
   #     denies :method1, :method2
 
   # Presentation Methods
-  #   Define presentation-related instance methods. Ex:
+  #   Define your own instance methods. Ex:
   #     def formatted_created_at
   #       content_tag :span, created_at.strftime("%A")
   #     end

data/spec/base_spec.rb

@@ -3,19 +3,67 @@ require 'draper'
 
 describe Draper::Base do
   subject{ Draper::Base.new(source) }
-  let(:source){ "Sample String" }    
-    
-  it "should return the wrapped object when asked for source" do
-    subject.source.should == source
+  let(:source){ Product.new }    
+
+  context(".decorates") do
+    it "sets the model class for the decorator" do
+      ProductDecorator.new(source).model_class == Product
+    end
   end
   
+  context(".model / .to_model") do
+    it "should return the wrapped object" do
+      subject.to_model.should == source
+      subject.model.should == source
+    end
+  end
+    
+  context("selecting methods") do
+    it "echos the methods of the wrapped class except default exclusions" do
+      source.methods.each do |method|
+        unless Draper::Base::DEFAULT_DENIED.include?(method)
+          subject.should respond_to(method)
+        end
+      end
+    end
+    
+    it "should not override a defined method with a source method" do
+      DecoratorWithApplicationHelper.new(source).length.should == "overridden"
+    end
+    
+    it "should always proxy to_param" do
+      source.send :class_eval, "def to_param; 1; end"
+      Draper::Base.new(source).to_param.should == 1
+    end
+    
+    it "should not copy the .class, .inspect, or other existing methods" do
+      source.class.should_not == subject.class
+      source.inspect.should_not == subject.inspect
+      source.to_s.should_not == subject.to_s
+    end
+  end  
+
   it "should wrap source methods so they still accept blocks" do
-    subject.gsub("Sample"){|match| "Super"}.should == "Super String"
+    subject.block{"marker"}.should == "marker"
+  end
+  
+  context ".find" do
+    it "should lookup the associated model when passed an integer" do
+      pd = ProductDecorator.find(1)
+      pd.should be_instance_of(ProductDecorator)
+      pd.model.should be_instance_of(Product)
+    end
+  
+    it "should lookup the associated model when passed a string" do
+      pd = ProductDecorator.find("1")
+      pd.should be_instance_of(ProductDecorator)
+      pd.model.should be_instance_of(Product)
+    end
   end
   
-  context ".draper" do
+  context ".decorate" do
     it "should return a collection of wrapped objects when given a collection of source objects" do
-      sources = ["one", "two", "three"]
+      sources = [Product.new, Product.new]
       output = Draper::Base.decorate(sources)
       output.should respond_to(:each)
       output.size.should == sources.size
@@ -27,49 +75,25 @@ describe Draper::Base do
       output.should be_instance_of(Draper::Base)
     end
   end
-  
-  it "echos the methods of the wrapped class" do
-    source.methods.each do |method|
-      subject.should respond_to(method)
-    end
-  end
-  
-  it "should not copy the .class, .inspect, or other existing methods" do
-    source.class.should_not == subject.class
-    source.inspect.should_not == subject.inspect
-    source.to_s.should_not == subject.to_s
-  end
-  
-  describe "a sample usage with denies" do
-    before(:all) do
-    end
     
+  describe "a sample usage with denies" do    
     let(:subject_with_denies){ DecoratorWithDenies.new(source) }
     
+    it "should proxy methods not listed in denies" do
+      subject_with_denies.should respond_to(:hello_world)
+    end
+    
     it "should not echo methods specified with denies" do
-      subject_with_denies.should_not respond_to(:upcase)
+      subject_with_denies.should_not respond_to(:goodnight_moon)
     end
 
     it "should not clobber other decorators' methods" do
-      subject.should respond_to(:upcase)
+      subject.should respond_to(:hello_world)
     end    
     
-    it "should be able to use the content_tag helper" do
-      subject_with_denies.sample_content.to_s.should == "<span>Hello, World!</span>"
-    end
-    
-    it "should be able to use the link_to helper" do
-      subject_with_denies.sample_link.should == "<a href=\"/World\">Hello</a>"
-    end
-    
-    it "should be able to use the pluralize helper" do
-      pending("Figure out odd interaction when the wrapped source object already has the text_helper methods (ie: a String)")
-      subject_with_denies.sample_truncate.should == "Once..."
-    end
-    
-    it "should nullify method_missing to prevent AR from being cute" do
-      pending("How to test this without AR? Ugh.")
-    end
+    it "should not allow method_missing to circumvent a deny" do
+      expect{subject_with_denies.title}.to raise_error(NoMethodError)
+    end    
   end
   
   describe "a sample usage with allows" do
@@ -99,15 +123,15 @@ describe Draper::Base do
     
     let(:using_allows_then_denies){
       class DecoratorWithAllowsAndDenies < Draper::Base  
-        allows :upcase
-        denies :downcase
+        allows :hello_world
+        denies :goodnight_moon
       end
     }    
     
     let(:using_denies_then_allows){
       class DecoratorWithDeniesAndAllows < Draper::Base  
-        denies :downcase
-        allows :upcase        
+        denies :goodnight_moon
+        allows :hello_world        
       end
     }
 
@@ -129,10 +153,22 @@ describe Draper::Base do
   end
   
   context "in a Rails application" do
-    it "should include ApplicationHelper if one exists" do
-      pending
-      decorator = DecoratorApplicationHelper.decorate(Object.new)
-      decorator.uses_hello == "Hello, World!"
+    let(:decorator){ DecoratorWithApplicationHelper.decorate(Object.new) }
+    
+    it "should have access to ApplicationHelper helpers" do
+      decorator.uses_hello_world == "Hello, World!"
+    end
+    
+    it "should be able to use the content_tag helper" do
+      decorator.sample_content.to_s.should == "<span>Hello, World!</span>"
+    end
+    
+    it "should be able to use the link_to helper" do
+      decorator.sample_link.should == "<a href=\"/World\">Hello</a>"
+    end
+    
+    it "should be able to use the pluralize helper" do
+      decorator.sample_truncate.should == "Once..."
     end
   end
 end

data/spec/samples/active_record.rb

@@ -0,0 +1,7 @@
+module ActiveRecord
+  class Base
+    def method_missing(name, *args)
+      name
+    end
+  end
+end

data/spec/samples/application_controller.rb

@@ -0,0 +1,10 @@
+class ApplicationController
+  extend ActionView::Helpers
+  extend ActionView::Helpers::TagHelper
+  extend ActionView::Helpers::UrlHelper
+  extend ApplicationHelper
+
+  def self.all_helpers
+    self
+  end
+end

data/spec/samples/application_helper.rb

@@ -1,5 +1,5 @@
 module ApplicationHelper
-  def hello
+  def hello_world
     "Hello, World!"
   end
 end

data/spec/samples/decorator_with_application_helper.rb

@@ -0,0 +1,21 @@
+class DecoratorWithApplicationHelper < Draper::Base  
+  def uses_hello_world
+    h.hello_world
+  end
+  
+  def sample_content
+    h.content_tag :span, "Hello, World!"
+  end
+  
+  def sample_link
+    h.link_to "Hello", "/World"
+  end
+  
+  def sample_truncate
+    h.truncate("Once upon a time", :length => 7)
+  end
+  
+  def length
+    "overridden"
+  end
+end

data/spec/samples/decorator_with_denies.rb

@@ -1,15 +1,3 @@
 class DecoratorWithDenies < Draper::Base  
-  denies :upcase
-  
-  def sample_content
-    content_tag :span, "Hello, World!"
-  end
-  
-  def sample_link
-    link_to "Hello", "/World"
-  end
-  
-  def sample_truncate
-    ActionView::Helpers::TextHelper.truncate("Once upon a time", :length => 7)
-  end
+  denies :goodnight_moon, :title
 end

data/spec/samples/product.rb

@@ -0,0 +1,21 @@
+class Product < ActiveRecord::Base
+  def self.find(id)
+    return Product.new
+  end
+  
+  def hello_world
+    "Hello, World"
+  end
+  
+  def goodnight_moon
+    "Goodnight, Moon"
+  end
+  
+  def title
+    "Sample Title"
+  end
+  
+  def block
+    yield
+  end
+end

data/spec/samples/product_decorator.rb

@@ -0,0 +1,3 @@
+class ProductDecorator < Draper::Base
+  decorates :product
+end

metadata

@@ -2,7 +2,7 @@
 name: draper
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.4.1.1
+  version: 0.4.2
 platform: ruby
 authors: 
 - Jeff Casimir
@@ -10,11 +10,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-12 00:00:00 -04:00
+date: 2011-07-26 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rake
+  prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -22,10 +23,10 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.8.7
   type: :development
-  prerelease: false
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: rspec
+  prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -33,10 +34,10 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 2.0.1
   type: :development
-  prerelease: false
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: activesupport
+  prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -44,10 +45,10 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 3.0.9
   type: :development
-  prerelease: false
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: actionpack
+  prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -55,10 +56,10 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 3.0.9
   type: :development
-  prerelease: false
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
   name: ruby-debug19
+  prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -66,10 +67,10 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
   type: :development
-  prerelease: false
   version_requirements: *id005
 - !ruby/object:Gem::Dependency 
   name: guard
+  prerelease: false
   requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -77,10 +78,10 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
   type: :development
-  prerelease: false
   version_requirements: *id006
 - !ruby/object:Gem::Dependency 
   name: guard-rspec
+  prerelease: false
   requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -88,10 +89,10 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
   type: :development
-  prerelease: false
   version_requirements: *id007
 - !ruby/object:Gem::Dependency 
   name: rb-fsevent
+  prerelease: false
   requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -99,7 +100,6 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
   type: :development
-  prerelease: false
   version_requirements: *id008
 description: Draper reimagines the role of helpers in the view layer of a Rails application, allowing an object-oriented approach rather than procedural.
 email: 
@@ -118,16 +118,23 @@ files:
 - Readme.markdown
 - draper.gemspec
 - lib/draper.rb
+- lib/draper/all_helpers.rb
 - lib/draper/base.rb
+- lib/draper/lazy_helpers.rb
+- lib/draper/system.rb
 - lib/draper/version.rb
 - lib/generators/draper/model/USAGE
 - lib/generators/draper/model/model_generator.rb
 - lib/generators/draper/model/templates/model.rb
 - spec/base_spec.rb
+- spec/samples/active_record.rb
+- spec/samples/application_controller.rb
 - spec/samples/application_helper.rb
-- spec/samples/decorator_application_helper.rb
 - spec/samples/decorator_with_allows.rb
+- spec/samples/decorator_with_application_helper.rb
 - spec/samples/decorator_with_denies.rb
+- spec/samples/product.rb
+- spec/samples/product_decorator.rb
 - spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/jcasimir/draper
@@ -143,18 +150,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 4442743917446124071
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 4442743917446124071
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
@@ -165,8 +166,12 @@ specification_version: 3
 summary: Decorator pattern implmentation for Rails.
 test_files: 
 - spec/base_spec.rb
+- spec/samples/active_record.rb
+- spec/samples/application_controller.rb
 - spec/samples/application_helper.rb
-- spec/samples/decorator_application_helper.rb
 - spec/samples/decorator_with_allows.rb
+- spec/samples/decorator_with_application_helper.rb
 - spec/samples/decorator_with_denies.rb
+- spec/samples/product.rb
+- spec/samples/product_decorator.rb
 - spec/spec_helper.rb

data/spec/samples/decorator_application_helper.rb

@@ -1,5 +0,0 @@
-class DecoratorApplicationHelper < Draper::Base  
-  def uses_hello
-    self.hello
-  end
-end