Ruby - method_missing

Didn't you just define a named method in

that sent the symbol parameter back to self

?

irb(main):057:0> 5.dollar.in(:euro)
=> 6.46
irb(main):065:0> 5.euro.in(:dollar)
=> 6.46 # Which is wrong, by the way

      

        
        
        
      

    

So, not entirely true, because you don't know what the amount is currently - yours method_missing

assumes everything is in dollars, even if it isn't.

That's why the money stone :)

Instead of using it method_missing

here, it would be easier to iterate over each of the currencies and define single and multiple methods to delegate them to your conversion method.

I am assuming you have ActiveSupport for convenience. You can do any of this without, but things like constantize

problems make it easier.

module DavesMoney
  class BaseMoney
    # your implementation
  end

  class DollarConverter < BaseMoney
    def initialize(value)
      @value = value
    end

    def to(:currency)
      # implemented in `BaseMoney` that gets extended (or included)
    end
  end
end

module CurrencyExtension
  extend ActiveSupport::Concern

  SUPPORTED_CURRENCIES = %w{ dollar yen euro rupee }

  included do
    SUPPORTED_CURRENCIES.each do |currency|
      define_method :"#{currency}" do
        return "#{currency}_converter".constantize.new(self)
      end
      alias :"#{currency.pluralize}" :"#{currency}"
    end
  end
end

# extension
class Numeric
  include CurrencyExtension
end

      

        
        
        
      

    

My approach to this, based on recognizing the limits of the task at hand (extending the implementation of method_missing to Numeric, although as @coreyward points out this is indeed the wrong approach for anything other than a home problem) was as follows:

Understanding what 5.euros.in(:yen)

can be translated into:

eur = 5.send(:euros)
eur.send( :in, yen )

      

        
        
        
      

    

what basically happens is that we send the message euros to the number 5 and then send the method in

to the numerical result 5.euros with the parameter: yen.

In method_missing, you must answer the call euros

and return with the result of converting euros to dollars, and then (also in method_missing) answer the call in

with the results of converting dollars (from the previous call) to the character passed as a parameter to the call in

. This will return the correct value.

Of course, you can convert to / from any currency you want as long as your conversion rates are correct - with gifts for this particular problem, converting to / from dollars seemed the most reasonable.

I am doing this course too and I saw some examples of how to complete the task. Self.send was mentioned at some point and I believe someone else has implemented this, but I found this solution to work for me:

https://gist.github.com/2065412

Here's what I did ...

http://pastebin.com/DpE8VAH4

    class Numeric
      @@ currencies = {'yen' => 0.013, 'euro' => 1.292, 'rupee' => 0.019, 'dollar' => 1}
      def method_missing (method, * arg)
        singular_currency = method.to_s.gsub (/ s $ /, '')
        if @@ currencies.has_key? (singular_currency)
          self * @@ currencies [singular_currency]
        else
          super
        end
      end
      def in (arg)
        singular_currency = arg.to_s.gsub (/ s $ /, '')
        if @@ currencies.has_key? (singular_currency)
          self * @@ currencies [singular_currency]
        end
      end
    end

    puts "5.euro =" + 5.euro.to_s
    puts "5.euros =" + 5.euros.to_s
    puts "5.dollars.in (: euros) =" + 5.dollars.in (: euros) .to_s
    puts "10.euros.in (: rupees) =" + 10.euros.in (: rupees) .to_s

• Add "dollar" => 1 "to currencies
• Add new method argument method_missing ", * args"
• Add new method "in (arg)" to numeric class
• This method multiplies self by the currency specified by the "arg" argument