Rails AntiPatterns book - Doubts on composition

Question

I'm reading the Rails AntiPatterns book, which I'm enjoying a lot. At one point, the author talks about the goodness of composition and it gives an example where an Order class gives the responsibility of conversion (to other formats) to another class, called OrderConverter. The classes are defined as:

class Order < ActiveRecord::Base
    def converter
        OrderConverter.new(self)
    end
end

class OrderConverter
    attr_reader :order
    def initialize(order)
        @order = order
    end
    def to_xml
        # ...
    end
    def to_json
        # ...
    end
    ...
end

And then the author says: "In this way, you give the conversion methods their own home, inside a separate and easily testable class. Exporting the PDF version of an order is now just a matter of call-ing the following:"

@order.converter.to_pdf

Regarding to this, my questions are:

• Why do you think that order object is preceded by an @? Shouldn't it be created as:

  order = Order.new

And then convert by doing:

order.converter.to_pdf 

• Why is the attr_reader :order line needed in the OrderConverter? It's so we can access the order from an OrderConverter object? Is it needed to be able to do order.converter.to_pdf ? We could do that without that attr_reader right?

Answer 1

An instance of Order is passed to the initialize method and stored as an instance variable (using the @ syntax : @order). This way, this variable can be accessed from other methods in the converter (the variable has the instance scope) :

class OrderConverter
  def to_pdf
    @order.items.each do |item|
       # Write the order items to the PDF
    end
  end
end

The attr_reader is not strictly required, but is a convenient way to access the Order object from other methods :

class OrderConverter
  def to_pdf
    order.items.each do |item|
       # Write the order items to the PDF
    end
  end
end

It will also allow you to get the reference to the order out of any converter instance :

converter.order

Answer 2

The @ on the front of the variable makes it an instance variable. If it wasn't there the variable would just be a local variable. I'm guessing that since this is a book about Rails, it's assuming that this code would be in a controller. Variables that controllers want to share across methods or expose in their views need to be instance variables. If this is the case @order was probably created either via parameters from a request or with values pulled from the database.

This probably isn't that significant though, both his example and your example work - I think the author was just showing how a call to the OrderConverter would look, and ignored how the Order object got created.

attr_reader :order creates a "getter" method for the @order instance variable in OrderConverter - it's not needed for to_pdf - it would be used to get the Order back out of the OrderConverter via converter.order. I don't see any need to have this in the code you've given so far, but maybe there's some need for it later.