Ruby - method_missing

Peut-être cela va être de plus d'aide. C'est un exemple de travail (remarque, je m'attends à ce que vous ayez ActiveSupport [partie des Rails] et Ruby 1.9.2+):

require 'rubygems'

# This is allowing us to do the `pluralize` calls below
require 'active_support/inflector'

module Currency
  CONVERSION_TABLE = { dollars: { dollars: 1, euros: 0.75 }, euros: { dollars: 1.3333334, euros: 1 } }.freeze
  attr_accessor :currency

  def method_missing(method_name, *args, &block)
    # standardize on pluralized currency names internally so both singular
    # and plural methods are handled
    method_name = method_name.to_s.pluralize.to_sym

    # Use the "from" keys in the conversion table to verify this is a valid 
    # source currency
    if CONVERSION_TABLE.key?(method_name)
      @currency = method_name
      self # return self so a call to `1.dollar` returns `1` and not `:dollars`
    else
      super
    end
  end

  # Convert `self` from type of `@currency` to type of `destination_currency`, mark the result with
  # the appropriate currency type, and return. Example:
  def to(destination_currency)
    # Again, standardize on plural currency names internally
    destination_currency = destination_currency.to_s.pluralize.to_sym

    # Do some sanity checking
    raise UnspecifiedSourceCurrency unless defined?(@currency)
    raise UnsupportedDestinationCurrency unless CONVERSION_TABLE.key?(destination_currency)

    # Do the actual conversion, and round for sanity, though a better
    # option would be to use BigDecimal which is more suited to handling money
    result = (self * CONVERSION_TABLE[@currency][destination_currency]).round(2)

    # note that this is setting @currency through the accessor that
    # was created by calling `attr_accessor :currency` above
    result.currency = destination_currency
    result
  end
end

class Numeric
  # Take all the functionality from Currency and mix it into Numeric
  # 
  # Normally this would help us encapsulate, but right now it's just making
  # for cleaner reading. My original example contained more encapsulation
  # that avoided littering the Numeric clas, but it's harder for a beginner
  # to understand. For now, just start here and you will learn more later.
  include Currency
end

p 5.euros.to(:dollars)                #=> 6.67
p 0.25.dollars.to(:euro)              #=> 0.19
p 1.dollar.to(:euros).to(:dollar)     #=> 1.0

OriginalL'auteur coreyward

Ce n'est plus un problème mathématique de calcul.

Chacun des @@currencies valeurs de hachage est normalisé à 'dollars': leurs unités sont yen/dollar, euro/dollar, roupie/dollar. Pour 5.euro.in(:yen), vous avez seulement besoin de diviser euro/dollar par yen/dollar pour exprimer la réponse en euro, en Yen.

Pour le calcul de ce à l'aide de Ruby, vous quittez le method_missing méthode inchangée et mise à jour de la constante de classe pour inclure 'dollar' => 1. Ajouter un Numeric#in méthode avec une seule ligne de calcul pour résoudre ce problème. Que le calcul doit s'appliquer à la division dans la séquence correcte d'un nombre à virgule flottante.

Pour 5.euro.in(:yen) exemple, rappelez-vous que 5.euro est calculée à la première, mais aura unités de euro/dollar. Le (: yen) méthode qui vient suivant doit être appliqué à l'inverse de ce nombre. Cela vous donnera un certain nombre d'unités dans yen/euro, la réciproque de votre résultat souhaité.

OriginalL'auteur Jon Jaroker

Plutôt que d'utiliser method_missing ici, il serait plus facile de faire une itération sur chaque devises et de définir le singulier et le pluriel de méthodes de déléguer à votre méthode de conversion.

Je suis en supposant que vous avez ActiveSupport ici par souci de commodité. Vous pourriez faire tout cela sans, mais des choses comme constantize et les préoccupations de la rendre plus facile.

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

OriginalL'auteur coreyward

Je le fais aussi et j'ai vu quelques exemples de la façon d'accomplir la tâche. À un certain point de l'auto.envoyer a mentionné et je crois que quelqu'un d'autre a mis en œuvre ce aussi mais j'ai trouvé que cette solution fonctionne pour moi:

https://gist.github.com/2065412

OriginalL'auteur Hard-Boiled Wonderland

Tout d'abord, installer mes unités de la bibliothèque: gem install sy. Ensuite, définir:

require 'sy'
Money = SY::Quantity.dimensionless      #=> #<Quantity:Money>
USD = SY::Unit.standard of: Money       #=> #<Unit:USD of Money >
YEN = SY::Unit.of Money, amount: 0.013  #=> #<Unit:YEN of Money >
EUR = SY::Unit.of Money, amount: 1.292  #=> #<Unit:EUR of Money >
INR = SY::Unit.of Money, amount: 0.019  #=> #<Unit:INR of Money >

Et maintenant vous pouvez calculer:

10 * 10.usd => #<Magnitude: 100 >
100.yen.in :usd #=> #<Magnitude: 1.3 >
1.eur + 1.usd #=> #<Magnitude: 2.29 >

Vous pouvez également définir

CENT = SY::Unit.of Money, amount: 0.01.usd
EUROCENT = SY::Unit.of Money, amount: 0.01.eur

Et puis

12.usd + 90.cent #=> #<Magnitude: 12.9 >

OriginalL'auteur Boris Stitnicky