My previous post talked about how to make form_for(@non_arb) work. When we need it for multiple classes, we came up with a little bit meta-programming so that classes that needs such ability can simply say:

polymorphic_routes_for :person,
:update_path => :admin_person_path,
:create_path => :admin_people_path


As you can see, it also takes options, update_path and create_path, if you don’t specify the paths, it will infer from the first param, which would make update path to person_path and create path to people_path.

The magic behind the scene is in the following, it can be in a module that you can mix in, or in our situation, in a superclass, Presenter where all presenters inherit from.

class Presenter
  class << self
    def polymorphic_routes_for(symbol, options = {})
      self.class_eval "def id; #{symbol}.id; end"
      self.class_eval "def to_param; #{symbol}.to_param; end"
      self.class_eval "def new_record?; #{symbol}.new_record?; end"
      update_path = options[:update_path] || "#{symbol}_path"
      ActionView::Base.send :alias_method, "#{self.name.underscore}_path", update_path

      create_path = options[:create_path] || "#{symbol.to_s.pluralize}_path"
      ActionView::Base.send :alias_method, "#{self.name.underscore.pluralize}_path", create_path
    end

  end

and here is the specs for it:

describe Presenter, "when specifying the polymorphic routes for a model" do
  before :each do
    ActionView::Base.class_eval("def test_model_path;end")
    ActionView::Base.class_eval("def test_models_path;end")
    class A < Presenter
      polymorphic_routes_for :test_model
      attr_reader :test_model
    end

    @presenter = A.new :test_model => mock("Model")
  end

  it "should generate id method" do
    @presenter.test_model.should_receive(:id).and_return "id"
    @presenter.id.should == "id"
  end

  it "should generate to_param method" do
    @presenter.test_model.should_receive(:to_param).and_return "to param"
    @presenter.to_param.should == "to param"
  end

  it "should generate new_record? method" do
    @presenter.test_model.should_receive(:new_record?).and_return "new record"
    @presenter.new_record?.should == "new record"
  end

  it "should alias update named route method to ActionView::Base" do
    ActionView::Base.new.should respond_to(:a_path)
  end

  it "should alias create named route method to ActionView::Base" do
    ActionView::Base.new.should respond_to(:as_path)
  end
end

describe Presenter, "when specifying the polymorphic routes for a model and specifying update_path option" do
  before :each do
    ActionView::Base.class_eval("def test_update_path; 'customized update path'; end")
    ActionView::Base.class_eval("def test_models_path;end")

    class A < Presenter
      polymorphic_routes_for :test_model, :update_path => :test_update_path
      attr_reader :test_model
    end

    @presenter = A.new :test_model => mock("Model")
  end

  it "should alias update named route method given by update_path option to ActionView::Base" do
    ActionView::Base.new.a_path.should == 'customized update path'
  end

end

describe Presenter, "when specifying the polymorphic routes for a model and specifying create_path option" do
  before :each do
    ActionView::Base.class_eval("def test_model_path; end")
    ActionView::Base.class_eval("def test_create_path; 'customized create path'; end")

    class A < Presenter
      polymorphic_routes_for :test_model, :create_path => :test_create_path
      attr_reader :test_model
    end

    @presenter = A.new :test_model => mock("Model")
  end

  it "should alias create named route method given by update_path option to ActionView::Base" do
    ActionView::Base.new.as_path.should == 'customized create path'
  end

end

In an erb template, you can have your form written as:

form_for(@arb)

where @arb is a ActiveRecord::Base object. form_for will smartly realize which url to generate based-on @arb’s state. For example, if I have

form_for(@person)

in the template and @person is a new record, the form_for helper will correctly infer that this form is for creating, thus generates the form submission url as people_path with POST. And if @person is not a new record, the helper will generate the url as person_path(@person) with a “PUT”. Benefits you can get from this are less code, and you can even merge new and edit forms all together.

In one instance, we want to use Jay Fields’ Presenter Pattern. So instead of @person, we use @person_presenter, and we still want to keep the simple syntax on the view, like form_for(@person_presenter). To make it work, we need to do the followings:

In your PersonPresenter class, we need to forward new_record? and to_param to person, something like this, or just use Ruby’s Forwardable.

def new_record?
person.new_record?
end


def to_param
person.to_param
end


Now the form_for method will generate person_presenters_path and person_presenter_path respectively. So we need to add two routes in routes.rb:


map.person_presenters 'people', :controller => 'people', :action => 'create', :conditions => { :method => :post }
map.person_presenter 'people/:id', :controller => 'people', :action => 'update', :conditions => { :method => :put }


Now the system works just fine.

]]>