Models, they make everything look good
One of the most common best practices in Rails is to keep the controller light weight. This helps maintain the code's readability maintainability, and refactorability (just like coding, I make stuff up). This is often done by pushing as much of the business logic as you can (where it still makes sense) down into a model.
At kaChing, we don't use ActiveModel as our backend layer. Instead, persistence is handled over the wire through RPC requests. However developers often forget (including myself) that models themselves are good encapsulation objects and can be used beyond the ActiveModel layer. Just the other day, I started out by writing the following code sample in a controller method
def some_method
date_string = nil
if params[:param_a] == "false"
begin
date_string = params[:date].to_date.strftime("%Y%m%d")
rescue
raise "Some error"
end
end
array = []
for key, value in params[:param_C]
# initialize array
end
if params[:param_b] == "set"
make_rpc_request(params[:account_id]
end
make_another_rpc_request(params[:account_id], array, date_string)
end
There are some problems with the above code beyond the bloated controller method
a) it makes testing this controller method harder because now it requires the developer to know how to setup the test, which leads to...
b) testing becomes more fragile.
What I ended up doing instead was to refactor the controller by moving the business logic into a param model as follows
class SomeMethodParams
attr_reader :array, :param_b_is_set, :account_id, :date
def initialize(params)
# init params here
@param_a = params[:param_a] == "true" ? true : false
@param_b_is_set = params[:param_b] == "set" ? true : false
@param_c = params[:param_c]
@account_id = params[:account_id]
@date = params[:date]
initialize_date(params)
initialize_array(params)
end
def initalize_date(params)
unless @param_a
@date_string = @date.to_date.strftime("%Y%m%d")
end
rescue
raise "Some error"
end
def initalize_array(params)
for key, value in @param_c
# set array
end
end
end
I can then simplify and refactor the controller code down to
def some_method some_method_params = SomeMethodParams.new(params) make_rpc_request(some_method_params.account_id) if some_method_params.param_b_is_set make_another_rpc_request(some_method_params.account_id, some_method_params.array, some_method_params.date_string) end
What's great now is that not only do I have a super lightweight controller method,
I also have a couple of other additional benefits:
1) the code is easier to read (keep other developers happy)
2) testing becomes easier, less fragile, and more focused (separation of concerns)
