= CachingPresenter - an implementation of the presenter pattern in Ruby

== What is the presenter pattern?

The presenter pattern is a technique used to separate presentation logic (aka display logic or view logic) from domain logic and from the view templates themselves. There are a number of reasons this pattern is beneficial when used:

• it stops presentation logic from creeping into domain objects and muddying up their implementation and their business logic
• it stops unnecessary logic from creeping into the views themselves which should be as simple, flexible, and changeable as possible
• it allows you to organize presentation logic in better ways than simply maintaining helper modules that are included everywhere

== Simple Example

class ProjectPresenter < CachingPresenter presents :project

def possible_managers
  if @project.top_secret?
    User.with_area_51_clearance.all
  else
    User.all
  end
end

end

In this example, there is most likely a view template which displays a drop down of possible managers for the project. When the project is top secret then only users with Area 51 clearance will be selectable from the UI, otherwise any user in the system will be selectable.

Without some form of a presenter this logic will either creep up in the view template, be pushed down to a model, or be stuck in an application object (like a Rails controller). None of those spots are a very good home for this logic.

Now, let's say we want to use the presenter in the view when generating the form for creating a project. Here's an example of what they would look like using a Rails html.erb template:

<% form_for @project do |f| %> ... <%= f.collection_select, :manager_id, @project.possible_managers, :id, :name %> ... <% end %>

Now to make this possible we'd have to assign @project to an instance of ProjectPresenter. Here's an example of doing that in a Rails controller:

class ProjectsController < ApplicationController def new @project = present Project.new end

def update
  project = Project.find params[:id]
  @project = present Project.new
end

end

Won't this screw up the views that rely on it being a Project? Nope. That's one of the features of CachingPresenter. It lets you decorate the object you want to present on, but it will behave and act just like that object. This includes delegating any methods it doesn't know about to the object that is being presented on. And it's optimized for the views.

== Optimized

CachingPresenter memoizes all method calls made through it. That is, you call a method once and all subsequent calls return the cached value from the first call. This works with method arguments as well. It will not cache the following types of method calls:

• any assignment method, # ie: #bar=
• any method that takes a block, ie: #each, #map, etc.

Basically, it's designed to cache any read-oriented method call. Here's an example:

class ProjectPresenter < CachingPresenter # writes a constructed for ProjectPresenter.new :project => ... presents :project

def foo(arg)
  # this method is automatically memoized
end

# the 'bar' method is automatically memoized
delegate :bar, :to => :@project

end

presenter = ProjectPresenter.new :project => Project.first

executes the first time, but the second time it returns the cached result

presenter.foo "something" presenter.foo "something"

even though we called #foo, this time its with a different argument

so it executes for the first time, and then returns the cached result

the second time

presenter.foo "anything"
presenter.foo "anything"

the 'id' method doesn't exist on the presenter, but the project

has an 'id' method, so this will automatically memoize that

method call, so it will be execute the first time it is called, but then

it will return the cached result the second time

presenter.id presenter.id

even though we called 'foo' earlier, this time it's called with a block

and CachingPresenter will always execute this. Both of these calls

are executed without caching/memoization techniques.

presenter.foo { do_something } presenter.foo { do_something_else }

== Github

• repos: http://github.com/mhs/caching_presenter/
• wiki: http://github.com/mhs/caching_presenter/wiki

== Developers

• Zach Dennis, [email protected], http://www.continuousthinking.com
• Mark VanHolstyn, [email protected]