Law of Demeter and the delegate method

The Law of Demeter, or Principle of Least Knowledge is a fairly simple design pattern, which, simply put means that an object should only talk to it’s immediate “friends”

The law states that a method M of and object O may only invoke the methods of the following kind:

1. a method on O itself
2. any parameters passed to M
3. any objects instantiated within M
4. any direct components of O

The classic example coined by David Bock used a Paperboy (one object) delivering a paper, then extracting money from a Customer’s (another object) Wallet (and another):

In the “real world” the Paperboy would ask the customer for the money who would then take it out for them, rather then the Paperboy reaching into the customer’s back pocket and getting it for themself.

Really we want something as follows:

This may all seem trivial and a waste of time, but what happens if some Customers want to pay by cheque? Those decisions should have an impact on the Paperboy, otherwise we end up with:

Where as it makes more sense for the change to be contained within the Customer:

So what does this have to do with Rails and the delegate method? The delegate method adds a quick and simple way of following the Law of Demeter without having to do very much at all.

This setup means to get an Order’s payment we would have to say:

But if we simply change our objects as such:

Now all we have to say is:

So at any time, the details of how a payment  is to be decided can be contained with the Customer. This is of course a simplistic example, but hopefully explains how you chould be using this handy feature.

  • So to use withdraw_payment, you have to also create a withdraw method too in the Customer model right. not a big deal, but maybe you could add withdraw to your example, just to give the full story and show how the method jumps from one model to the next too.

    • You don’t have to. I should have been a bit clearer, but what I’ve done is renamed withdraw into withdraw_payment, just so it makes a bit more sense in terms of the chain of calls. But withdraw_payment on the Customer object *can* be called withdraw:

      So the final call is:

        @order.withdraw(amount)

      In this case it’s now a bit unclear *what* I’m withdrawing.

      So Customer becomes:

        class Customer
          has_many :orders
          has_one :credit_card
          has_one :bank_account
          def withdraw(amount)
            if pay_by_card?
              credit_card.withdraw(amount)
            elsif pay_by_account?
              bank_account.withdraw(amount)
            end
          end
        end

      Or if there is only credit cards supported the chain can just be:

        class Customer
          has_many :orders
          has_one :credit_card
          delegate :withdraw, :to => :credit_card
        end

  • “if pay_by_card”

    Where does the pay_by_card come from?

    • Sorry, my bad. They are other methods on the Customer model which I didn’t provide implementations for. I should have provided them , but it’s a bad example in this case as the decision as to which payment method to use shouldn’t be done with ifs as I’m doing. Going by Open Closed principle, the decision making should be extensible.