handling multiple IFs in rails - ruby-on-rails

Question

I have the following code on a model, which works, but I'd love to find a way to refactor it to be something a little smaller and neater. I'd also love to only run it under the condition that the state field actually changes. Can someone point me in the right direction. This is rails 3 BTW.
What it does is look at the "state" field on a model called subscription, and if that changes from one condition to another, then makes an update in salesforce. I'm looking for a way to optimise this code.
after_save :update_salesforce
def update_salesforce
if self.state_changed? && salesforce_client
salesforce_client.materialize("Opportunity")
o = Opportunity.find_by_breatheHR_id__c(self.subscriber_id)
if o
old_state = self.state_was
new_state = self.state
#update salesforce when accounts go active
if (old_state =='trial' || old_state == 'suspended') && new_state =='active'
o.update_attribute(:Stage__c, "Active Account")
end
#update salesforce when accounts go active
if old_state =='trial' && new_state =='suspended'
o.update_attribute(:Stage__c, "Trial Suspended")
end
#update salesforce when accounts go active
if old_state =='active' && new_state =='suspended'
o.update_attribute(:Stage__c, "Account Suspended")
end
#update salesforce when accounts go active
if old_state =='active' && new_state =='inactive'
o.update_attribute(:Stage__c, "Account Cancelled")
end
#update salesforce when accounts go active
if old_state =='trial' && new_state =='inactive'
o.update_attribute(:Stage__c, "Trial Cancelled")
end
end_of_day
end
end
In terms of only running it, I tried
after_save :update_salesforce, :if => self.state_changed?
but it doesn't recognise "self" at this point.

Answer 1

Here are several refactorings that you can apply:
Remove unnecessary self
You don't need to write self every time, only when setting values, because otherwise Ruby will create a local variable instead of calling the setter method. In your case, all occurrences of self are superfluous and just add noise.
Flatten nested conditionals
You need to get rid of unnecessary nesting, it makes the code much easier to read and understand. Generally speaking, you can return early when preconditions fail. For example:
def update_salesforce
if state_changed? && salesforce_client
o = Opportunity.find_by_breatheHR_id__c(subscriber_id)
if o
# perform hard work
end
end
end
# becomes
def update_salesforce
return unless state_changed? && salesforce_client
o = Opportunity.find_by_breatheHR_id__c(subscriber_id)
return unless o
# perform hard work
end
Use ActiveRecord's :if option
In the special case of the check whether the state has changed, you can use the :if option on the after_save callback. You were very close, but you either need to supply the method name as symbol, or use a proc. For a simple situation like this one, you can use the symbol form:
after_save :update_salesforce, :if => :state_changed?
Use statement modifiers
The other case is also special in that you can tack the return at the end of the line with a statement modifier or. This is actually the intended use of or, whereas you should always use || for boolean operations. The transformation is
x = do_something
return unless x
# becomes
x = do_something or return
Replace repetitive conditionals with hash access
When you look at the method, most lines repeat over and over again with only slight variation. What you can do about this is to extract the state transition logic into a separate method. In this method you can pull off a trick and put the varying states into a hash, from which you select the appropriate value. The keys are arrays representing the transition, and the values are the new values for the Stage__c field. When nil is returned, Stage__c must not be updated. For example:
def new_stage_from_state_transition(old_state, new_state)
{
['suspended', 'active' ] => 'Active Account',
['trial' , 'active' ] => 'Active Account',
['trial' , 'suspended'] => 'Trial Suspended',
['active' , 'suspended'] => 'Account Suspended',
['active' , 'inactive' ] => 'Account Cancelled',
['trial' , 'inactive' ] => 'Trial Cancelled'
}[[old_state, new_state]]
end
Put everything together
All of this results in much cleaner and less repetitive code:
after_save :update_salesforce, :if => :state_changed?
def update_salesforce
return unless salesforce_client
o = Opportunity.find_by_breatheHR_id__c(subscriber_id) or return
new_stage = new_stage_from_state_transition(state_was, state) or return
o.update_attribute(:Stage__c, new_stage)
end
def new_stage_from_state_transition(old_state, new_state)
{
['suspended', 'active' ] => 'Active Account',
['trial' , 'active' ] => 'Active Account',
['trial' , 'suspended'] => 'Trial Suspended',
['active' , 'suspended'] => 'Account Suspended',
['active' , 'inactive' ] => 'Account Cancelled',
['trial' , 'inactive' ] => 'Trial Cancelled'
}[[old_state, new_state]]
end

Answer 2

#update salesforce when accounts go active
if new_state =='active'
o.update_attribute(:Stage__c, "Active Account")
else
what = old_state == 'active' ? "Account" : "Trial"
change = new_state == 'inactive' ? "Canceled" : "Suspended"
o.update_attribute(:Stage__c, "#{what} #{change}" )
end