Question

Say for example I pass the following two HTTP POST parameters to my Rails application:

fname=john&lname=doe

And within my application a controller will pass the params hash to the ‘Person’ model class defined as:

Class Person
  attr_accessor :fname, :lname

  def initialize(params)
    @fname = params[:fname]
    @lname = params[:lname]
  end
end

As you can see I initialise a Person object with the values contained in the params hash. Note the name of properties and parameters are identical.

Obviously, in a real-world example I would have many more properties in my object, and so to use the above initialisation method could become tedious.

Therefore, I was wondering if there is a way to dynamically populate properties of an object with HTTP parameters of the same name?

Answer 1

You can do what you’re asking for in both controllers and models. First, an example of how this would work with a controller:

class PeopleController < ActionController::Base
  attr_accessor :fname, :lname, :phone, :email

  def some_action
    params.each_pair do |key, value|
      send(:"#{key}=", value) if respond_to?(:"#{key}=")
    end
  end
end

However, this is not a very practical application; there is very little reason to have accessor instance variables on a controller, much less enough that you would need to use this method.

Instead, what you seem to want to do is to create an instance of the Person model and mass-assign attributes from params. Rails already does this, hence the default create action:

class PeopleController < ActionController::Base
  def create
    @person = Person.new(params[:person])
    if @person.save
      redirect_to @person, :flash => "Person created successfully."
    else
      render :action => :new
    end
  end
end

Note that by default, all model attributes are mass assignable. This can be a security issue when it becomes possible for users to manipulate certain fields (like associations). In this case, you can either whitelist or blacklist attributes on your models to prevent this type of security breach:

class Person < ActiveRecord::Base
  attr_accessible :fname, :lname, :phone, :email
  # or
  attr_protected :non_user_changeable_attribute
end

You can read more about mass assignment security here.

---

If you want to add this behavior to a group of non-ActiveRecord classes (without the protector attributes), you can snag this module and just do an include MassAssignment in your class definition (doesn’t rely on Rails):

module MassAssignment
  def initialize(attributes = {})
    mass_assign(attributes)
  end

  def mass_assign(attributes)
    attributes.each do |attribute, value|
      respond_to?(:"#{attribute}=") && send(:"#{attribute}=", value)
    end
  end
end

This avoids duplicating somewhat “ugly” code in every initializer.

Via: https://github.com/coreyward/typekit/blob/master/lib/typekit/base.rb