CODEWITHSUNDEEP
ruby-on-railsruby-on-rails-4
Dan Barron
Dan Barron

Reputation: 1104

Rails 4: Create object only in a factory method?

Going to simplify a bit here, but assume an app that has Users and UserRecords. A User must have one or more UserRecords. I want to limit the creation of UserRecords to a method in User, namely #create_new_user_record.

In other words, I don't want to allow UserRecord.new or UserRecords.create anywhere else in the application. I need to control the creation of these records, and perform some logic around them (for example, setting the new one current and any others to not current), and I don't want any orphaned UserRecords in the database.

I tried the after_initialize callback and checking if the object is new and raising an error there, but of course I do need to call UserRecord.new in User#create_new_user_record. If I could somehow flag in #create_new_user_record that I am calling new from that method, and pick that up in after_intialize, that would work, but how?

I might be over thinking it. I can certainly create a that method on User, and just 'know' to always call it. But others will eventually work on this app, and I will go away and come back to it as some point.

I suppose I could raise the error and just rescue from it in #create_new_user_record. Then at least, if another develop tries it elsewhere they will find out why I did it when they pursue the error.

Anyway, wondering what the Rails gurus here had to say about it.

Upvotes: 0

Views: 741

Answers (2)

Dan Barron
Dan Barron

Reputation: 1104

Ok, here's what I did. Feel free to tell me if this is bad idea or, if it's an ok idea, if there's a better way. For what it's worth, this does accomplish my goal.

In the factory method in the User model, I send a custom parameter in the optional options hash defined on the new method in the API. Then I in the UserRecord#new override, I check for this parameter. If it's true, I create and return the object, otherwise I raise in custom error.

In my way of thinking, creating a UserRecord object any other way is an error. And a developer who innocently attempts it would be lead to explanatory comments in the two methods.

One thing that's not clear to me is why I need to leave off the options hash when I call super. Calling super with it causes the ArgumentError I posted in my earlier comment. Calling super without it seems to work fine.

class User < ActiveRecord::Base
  ...
  def create_new_user_record
    # do fancy stuff here
    user_record = UserRecord.new( { owner_id: self.id, is_current: true }, called_from_factory: true )
    user_record.save
  end
  ...
end

class UserRecord < ActiveRecord::Base
  ...
  def UserRecord.new(attributes = nil, options = {})
    if options[:called_from_factory] == true
      super(attributes)
    else
      raise UseFactoryError, "You must use factory method (User#create_new_user_record) to create UserRecords"
    end
  end
  ...
end

Upvotes: 1

Ivan Denysov
Ivan Denysov

Reputation: 1502

super method is what you are looking for. Though you'll need some workaround (maybe simple check for value of option only you know about) to fit your needs class User < ActiveRecord:Base

   def .new(attributes = nil, options = {})
     do_your_fancy_stuff
     if option[:my_secret_new_method]
       super # call AR's .new method and automatically pass all the arguments
   end

 end

Upvotes: 1

Related Questions