Ruby - Switching dynamically between protocols (with modules)

I would like to allow a person object (instanced from a Person class) to speak a language (which is a collection of public methods stored in Language module):

class Person
  attr_accessor :current_language

  def quit
    # Unselect the current language, if any:
    @current_language = nil
  end
end

Suppose that languages are the following:

module Language
  module Japanese
    def konnichiwa
      "こんにちは！ (from #{@current_language} instance variable)"
    end

    def sayounara
      "さようなら。"
    end
  end

  module French
    def bonjour
     开发者_开发技巧 "Bonjour ! (from #{@current_language} instance variable)"
    end

    def au_revoir
      "Au revoir."
    end
  end

  module English
    def hello
      "Hello! (from #{@current_language} instance variable)"
    end

    def bye
      "Bye."
    end
  end
end

Example of use:

person = Person.new

person.current_language # => nil
person.hello            # => may raise a nice no method error

person.current_language = :english
person.hello    # => "Hello! (from english instance variable)"
person.bonjour  # => may also raise a no method error
person.quit

person.current_language = :french
person.bonjour  # => "Bonjour ! (from french instance variable)"

As you can see, a language is such as a protocol. So a person can switch on a specific protocol, but only one at a time.

For modular reasons, storing each language into a module is friendly. So I think this way is the more logical Ruby way, isn't it.

But, I believe that it is not possible to write something like this:

class Person
  include "Language::#{@current_language}" unless @current_language.nil?
end

According to you, what should be the best practice to do so?

Any comments and messages are welcome. Thank you.

Regards

You can do this pretty elegantly in Ruby if you arrange your modules correctly.

module LanguageProxy
  def method_missing(phrase)
    if @current_language.respond_to?(phrase)
      @current_language.send(phrase)
    else
      super
    end
  end
end

module Language
  module French
    def self.bonjour
      "Bonjour ! (from #{@current_language} instance variable)"
    end

    def self.au_revoir
      "Au revoir."
    end
  end

  module English
    def self.hello
      "Hello! (from #{@current_language} instance variable)"
    end

    def self.bye
      "Bye."
    end
  end
end

class Person
  attr_accessor :current_language

  include LanguageProxy

  def quit
    @current_language = nil
  end
end

person = Person.new

person.current_language # => nil
begin
  p person.hello            # => may raise a nice no method error
rescue 
  puts "Don't know hello"
end

person.current_language = Language::English
p person.hello    # => "Hello! (from english instance variable)"
begin
  p person.bonjour  # => may also raise a no method error
rescue
  puts "Don't know bonjour"
end
person.quit

person.current_language = Language::French
p person.bonjour  # => "Bonjour ! (from french instance variable)"

Essentially, all we are doing here is creating a Proxy class to forward Person's unknown messages to the language module stored in the Person's @current_language instance variable. The "trick" I used here is to make hello, bye, etc. module methods, not instance methods. Then, I assigned the actual module into @current_language.

You'll also notice here that the @current_language instance variable from Person is not available in the Language modules. It gets a little more tricky if you need the language methods to access those variables: the quick fix would probably be to just pass them as parameters.

If you really want to use symbols to denote the language, you'll have to do a little magic with Language.const_get.

Output:

C:\temp\ruby>ruby person.rb
Don't know hello
"Hello! (from  instance variable)"
Don't know bonjour
"Bonjour ! (from  instance variable)"

Just to show that you could do this (not that you should):

include "A::B::C".split("::").inject{|p,c| (p.class == String ? Kernel.const_get(p) : p).const_get(c)}