If you peruse the Factory Girl docs, it mentions associations, but only how to handle a simple “belongs to” or maybe “has one” sort of association. My good friend led me to this thread on StackOverflow.

Basically, the user fowlduck came up with the solution of having an “after_build” block.

My problem couldn’t be solved with a simple “has_many/belongs_to” association, because in this case I needed to ensure the invoice seller matched the producer of the product being invoiced. Here was my solution:

Factory.define :invoice do |i|
  i.after_build do |invoice|
    invoice.buyer = Factory.create :consumer unless invoice.buyer
    next if invoice.seller
    invoice.line_items = [Factory.create(:line_item)]
    invoice.seller = invoice.line_items.first.product.producer
  end
end

So first, notice the “unless invoice.buyer” and “next if invoice.seller” these allow me to override these values in my tests. You’re gonna wanna keep that in mind. Next, I create a LineItem, which automatically creates a product, which in turn, creates a producer. After that I can just set the seller to be the producer of the product in the first line item. Voila, product line_item producer matches invoice seller.

I’ve found this tremendously useful. Here’s another example of how I’ve used it:

Factory.define :user do |a|
  name = Faker::Name.name
  a.real_name { name }
  a.username { Faker::Internet.user_name(name) }
  a.password 'secret-1'
  a.password_confirmation 'secret-1'
  a.email_address { Faker::Internet.email(name) }
  a.after_build do |login|
    next if login.valid?
    next unless login.errors.invalid?(:username)
    login.username = Faker::Internet.user_name(login.real_name)+String.random(4)
  end
end

I did this because, everyone once in a great while my tests would fail because the same username is used more than once. But now, if this happens, I just tack on 4 random characters. Since i did this, I haven’t had the test fail.

From the description and the “Polymorphic” section of the docs it seemed like it would do what I need, so I set out to figure out how to use it. I was looking for an easy clear description of how it’s used, but several Google searches produced nothing. So I decided to make one myself.

We’ll start off with a little project used to track items in a “media library,” e.g. Books, Music, and Movies. Given the following models:

script/generate model Book author:string title:string summary:string isbn:string
script/generate model Album artist:string title:string track_listing:string
script/generate model Movie director:string title:string summary:string
script/generate model Artwork library_item_id:integer library_item_type:string

We want our Book, Album, and Movie objects to have one or more “Artwork” objects to represent covers or movie posters. First let’s tell the Artwork class it belongs to the other objects:

class Artwork < ActiveRecord::Base
  belongs_to :library_item, :polymorphic => true
end

Notice how the :library_item corresponds to the columns we defined: library_item_id and library_item_type. ActiveRecord is going to store the Book#id, Album#id, or Movie#id in the library_item_id. In the library_item_type column ActiveRecord will put "Book", "Album", or "Movie", as appropriate. For example, if you do this:

>> Artwork.new(:library_item => Book.create)
=> #<Artwork id: nil, library_item_id: 1, library_item_type: "Book", created_at: nil, updated_at: nil>

The library_item_id and library_item_type columns will have Book#id, in this case ’1′, and Book#class, which is Book, respectively.

Now here’s how the Book, Album, and Movie classes are tied to the “artwork”:

class Book < ActiveRecord::Base
  has_one :cover_image, :class_name => 'Artwork', :as => :library_item
end
class Album < ActiveRecord::Base
  has_one :cover_art, :class_name => 'Artwork', :as => :library_item
end
class Movie < ActiveRecord::Base
  has_one :poster_image, :class_name => 'Artwork', :as => :library_item
end

This gives us methods like Album#cover_art we can use to reference the Artwork object from the Album object.

So there you go, hopefully this proves useful…

We all (hopefully) know you should always use integers to do your currency calculations. But users like to have dollars and cents to work with. Somewhere is going to live some code that handles that conversion. One post I found gave the following solution: add a before_filter to go through and convert anything that looked like it might be a currency amount:

def filter_units (input)
 if [Array, Hash, HashWithIndifferentAccess].include?(input.class)
  input.each do |key, value|
   #recurse through the data structure
   input[key] = self.filter_units(value)
  end
 #match the string format for a major unit
 elsif not input.nil? and input.match(/^\d+\.\d\d)$/)
  #convert to a minor unit integer
  (input.to_f * 100.0).to_i
 else
  #return the value unchanged
  input
 end
end

No offense John, but that is a terrible way of dealing with it. #1. I couldn’t even get the code to work, it gave all kinds of errors. #2. What if you have another field the contains a float, e.g. tax_percent or weight_in_lbs, which aren’t currency, but could match the format above? #3. What about when a user decides to put in 9.5 instead of 9.50, or include a dollar sign themselves ($9.50)? Finally, this still leaves you having to deal the conversion to a float by hand when it comes time to display the amount.

Here was my solution. I just added some virtual attributes to my models:

class Subscription < ActiveRecord::Base
  def price_dollars
    (self.price / 100).round
  end
  def price_dollars=(price)
    self.price = (price.to_f * 100).to_i
  end
end

*Poof!* No cumbersome code! But the above quickly becomes painful when you have several attributes, especially when they're spread across models. So extracted the above into a plugin, which I, with a complete lack of creativity, named CurrencyMagic.

class Subscription < ActiveRecord::Base
  currency_magic :dollars, :price, :cost, :sales_price, :etc
end

Now, I'm not in love with the plugin idea, but I wanted to have a way to test the code and share it across projects, so that's what I did. I originally made it a module that could be included, so there's really nothing more than re-organizing the code for it to work outside ActiveRecord, though I imagine that would diminish it's value somewhat.

Anywho, there you go, my solution to converting dollars to cents and back in Rails.