Visibilidade de Métodos em Ruby: http://blog.gbaptista.com/2013/01/29/visibilidade-de-metodos-em-ruby/

method_visibility.rb

# encoding: utf-8

# Ajuda para os comentários e termos:
# http://blog.gbaptista.com/2013/01/29/comentarios-metodos-variaveis-classe-instancia/

# Classe com diversos métodos de instância.
class Daddy

  def public_method
    return 'public'
  end

  def protected_method_access
    return protected_method
  end

  def protected_method_access_dot
    return self.protected_method
  end

  def protected_method_reference(reference)
    reference.protected_method
  end

  def private_method_access
    return private_method
  end

  def private_method_access_dot
    return self.private_method
  end

  def private_method_reference(reference)
    reference.private_method
  end

  def private_method_access_dot_equal
    return self.private_method=('private=')
  end

  def private_method_reference_access_dot_equal(reference)
    return reference.private_method=('private=')
  end

  protected

  def protected_method
    return 'protected'
  end

  private

  def private_method
    return 'private'
  end

  def private_method=(value)
  end

end

# Classe herdando a classe Daddy e definindo novos métodos
# de instância para acessar os métodos da classe Daddy.
class LittleBaby < Daddy

  def h_protected_method_access
    return protected_method
  end

  def h_protected_method_access_dot
    return self.protected_method
  end

  def h_protected_method_reference(reference)
    reference.protected_method
  end

  def h_private_method_access
    return private_method
  end

  def h_private_method_access_dot
    return self.private_method
  end

  def h_private_method_reference(reference)
    reference.private_method
  end

  def h_private_method_access_dot_equal
    return self.private_method=('private=')
  end

  def h_private_method_reference_access_dot_equal(reference)
    return reference.private_method=('private=')
  end

end

# Nesta classe é demonstrada uma outra
# forma de declarar a visibilidade dos métodos e
# como trabalhar com métodos de classe.
class Mammy

  def public_method
    return 'public'
  end

  def self.s_public_method
    return 'public'
  end

  def self.s_public_method_b
    return 'public'
  end

  def protected_method
    return 'protected'
  end

  def private_method
    return 'private'
  end

  def self.s_private_method
    return 'private'
  end

  def self.s_private_method_access
    return s_private_method
  end

  def self.s_private_method_access_dot
    return self.s_private_method
  end

  def self.s_private_method_reference(reference)
    reference.s_private_method
  end

  def self.s_private_method_access_dot_equal
    return self.s_private_method=('private=')
  end

  def self.s_private_method_reference_access_dot_equal(reference)
    return reference.s_private_method=('private=')
  end

  def self.s_private_method=(value)
  end

  protected :protected_method

  private :private_method
  private_class_method :s_private_method, :s_private_method=, :s_public_method_b

  # Caso queira fazer um método [class]
  # privado voltar a ser público:
  public_class_method :s_public_method_b

end

# Herda a classe Mammy e define novos métodos
# de classe para acessar os métodos da classe Mammy.
class Daughter < Mammy

  def self.h_s_private_method_access
    return s_private_method
  end

  def self.h_s_private_method_access_dot
    return self.s_private_method
  end

  def self.h_s_private_method_reference(reference)
    reference.s_private_method
  end

  def self.h_s_private_method_access_dot_equal
    return self.s_private_method=('private=')
  end

  def self.h_s_private_method_reference_access_dot_equal(reference)
    return reference.s_private_method=('private=')
  end

end

method_visibility_test.rb

# encoding: utf-8

# Ajuda para os comentários e termos:
# http://blog.gbaptista.com/2013/01/29/comentarios-metodos-variaveis-classe-instancia/

require 'test/unit'
require './method_visibility'

class MethodVisibilityTest < Test::Unit::TestCase

  def test_daddy_visibility

    # Daddy Public ==========================================

    # Métodos [instance public] são acessíveis.
    assert_equal('public', Daddy.new.public_method)

    # Daddy protected =======================================

    # Métodos [instance protected] não são acessíveis externamente.
    assert_match(/protected method/, assert_raise(NoMethodError){
      Daddy.new.protected_method
    }.message)

    # Métodos [instance protected] não são acessíveis através do public_send.
    assert_match(/protected method/, assert_raise(NoMethodError){
      Daddy.new.public_send(:protected_method)
    }.message)

    # Métodos [instance protected] são acessíveis através do send.
    assert_equal('protected', Daddy.new.send(:protected_method))

    # Métodos [instance protected] são acessíveis através do instance_eval.
    assert_equal('protected', Daddy.new.instance_eval('protected_method'))

    # Métodos [instance protected] são acessíveis internamente.
    assert_equal('protected', Daddy.new.protected_method_access)

    # Métodos [instance protected] são acessíveis internamente com self.
    assert_equal('protected', Daddy.new.protected_method_access_dot)

    # Métodos [instance protected] são acessíveis por referência (se referência == self).
    assert_equal('protected', Daddy.new.protected_method_reference(Daddy.new))
    assert_equal('protected', Daddy.new.protected_method_reference(LittleBaby.new))

    # Daddy private =========================================

    # Métodos [instance private] não são acessíveis externamente.
    assert_match(/private method/, assert_raise(NoMethodError){
      Daddy.new.private_method
    }.message)

    # Métodos [instance private] não são acessíveis através do public_send.
    assert_match(/private method/, assert_raise(NoMethodError){
      Daddy.new.public_send(:private_method)
    }.message)

    # Métodos [instance private] são acessíveis através do send.
    assert_equal('private', Daddy.new.send(:private_method))

    # Métodos [instance private] são acessíveis através do instance_eval.
    assert_equal('private', Daddy.new.instance_eval('private_method'))

    # Métodos [instance private] são acessíveis internamente.
    assert_equal('private', Daddy.new.private_method_access)

    # Métodos [instance private] não são acessíveis internamente com self.
    assert_match(/private method/, assert_raise(NoMethodError){
      Daddy.new.private_method_access_dot
    }.message)

    # Métodos [instance private] não são acessíveis por referência (por causa do .).
    assert_match(/private method/, assert_raise(NoMethodError){
      Daddy.new.private_method_reference(Daddy.new)
    }.message)

    # Métodos [instance private] não são acessíveis por referência (por causa do .).
    assert_match(/private method/, assert_raise(NoMethodError){
      Daddy.new.private_method_reference(LittleBaby.new)
    }.message)

    # Métodos [instance private] terminados em '=' são acessíveis internamente com self.
    assert_equal('private=', Daddy.new.private_method_access_dot_equal)

    # Métodos [instance private] terminados em '=' não são acessíveis por referência (por causa do .).
    assert_match(/private method/, assert_raise(NoMethodError){
      Daddy.new.private_method_reference_access_dot_equal(Daddy.new)
    }.message)

    # Métodos [instance private] terminados em '=' não são acessíveis por referência (por causa do .).
    assert_match(/private method/, assert_raise(NoMethodError){
      Daddy.new.private_method_reference_access_dot_equal(LittleBaby.new)
    }.message)

  end

  def test_little_baby_visibility

    # LittleBaby < Daddy Public =============================

    # Métodos [inherit instance public] são acessíveis.
    assert_equal('public', LittleBaby.new.public_method)

    # LittleBaby < Daddy protected ==========================

    # Métodos [inherit instance protected] não são acessíveis externamente.
    assert_match(/protected method/, assert_raise(NoMethodError){
      LittleBaby.new.protected_method
    }.message)

    # Métodos [inherit instance protected] não são acessíveis através do public_send.
    assert_match(/protected method/, assert_raise(NoMethodError){
      LittleBaby.new.public_send(:protected_method)
    }.message)

    # Métodos [inherit instance protected] são acessíveis através do send.
    assert_equal('protected', LittleBaby.new.send(:protected_method))

    # Métodos [inherit instance protected] são acessíveis através do instance_eval.
    assert_equal('protected', LittleBaby.new.instance_eval('protected_method'))

    # Métodos [inherit instance protected] são acessíveis internamente.
    assert_equal('protected', LittleBaby.new.h_protected_method_access)

    # Métodos [inherit instance protected] são acessíveis internamente com self.
    assert_equal('protected', LittleBaby.new.h_protected_method_access_dot)

    # Métodos [inherit instance protected] são acessíveis por referência (se referência == self).
    assert_equal('protected', LittleBaby.new.h_protected_method_reference(Daddy.new))
    assert_equal('protected', LittleBaby.new.h_protected_method_reference(LittleBaby.new))

    # LittleBaby < Daddy private ============================

    # Métodos [inherit instance private] não são acessíveis externamente.
    assert_match(/private method/, assert_raise(NoMethodError){
      LittleBaby.new.private_method
    }.message)

    # Métodos [inherit instance private] não são acessíveis através do public_send.
    assert_match(/private method/, assert_raise(NoMethodError){
      LittleBaby.new.public_send(:private_method)
    }.message)

    # Métodos [inherit instance private] são acessíveis através do send.
    assert_equal('private', LittleBaby.new.send(:private_method))

    # Métodos [inherit instance private] são acessíveis através do instance_eval.
    assert_equal('private', LittleBaby.new.instance_eval('private_method'))

    # Métodos [inherit instance private] são acessíveis internamente.
    assert_equal('private', LittleBaby.new.h_private_method_access)

    # Métodos [inherit instance private] não são acessíveis internamente com self.
    assert_match(/private method/, assert_raise(NoMethodError){
      LittleBaby.new.h_private_method_access_dot
    }.message)

    # Métodos [inherit instance private] não são acessíveis por referência (por causa do .).
    assert_match(/private method/, assert_raise(NoMethodError){
      LittleBaby.new.h_private_method_reference(Daddy.new)
    }.message)

    # Métodos [inherit instance private] não são acessíveis por referência (por causa do .).
    assert_match(/private method/, assert_raise(NoMethodError){
      LittleBaby.new.h_private_method_reference(LittleBaby.new)
    }.message)

    # Métodos [inherit instance private] terminados em '='' são acessíveis internamente com self.
    assert_equal('private=', LittleBaby.new.h_private_method_access_dot_equal)

    # Métodos [inherit instance private] terminados em '='' não são acessíveis por referência (por causa do .).
    assert_match(/private method/, assert_raise(NoMethodError){
      LittleBaby.new.h_private_method_reference_access_dot_equal(LittleBaby.new)
    }.message)

    # Métodos [inherit instance private] terminados em '='' não são acessíveis por referência (por causa do .).
    assert_match(/private method/, assert_raise(NoMethodError){
      LittleBaby.new.h_private_method_reference_access_dot_equal(Daddy.new)
    }.message)

  end

  def test_mammy_visibility

    # Métodos [instance public] são acessíveis.
    assert_equal('public', Mammy.new.public_method)

    # Métodos [class public] são acessíveis.
    assert_equal('public', Mammy.s_public_method)
    assert_equal('public', Mammy.s_public_method_b)

    # Métodos [instance protected] não são acessíveis externamente.
    assert_match(/protected method/, assert_raise(NoMethodError){
      Mammy.new.protected_method
    }.message)

    # Métodos [instance private] não são acessíveis externamente.
    assert_match(/private method/, assert_raise(NoMethodError){
      Mammy.new.private_method
    }.message)

    # Métodos [class private] não são acessíveis externamente.
    assert_match(/private method/, assert_raise(NoMethodError){
      Mammy.s_private_method
    }.message)

    # Métodos [class private] não são acessíveis através do public_send.
    assert_match(/private method/, assert_raise(NoMethodError){
      Mammy.public_send(:s_private_method)
    }.message)

    # Métodos [class private] são acessíveis através do send.
    assert_equal('private', Mammy.send(:s_private_method))

    # Métodos [class private] são acessíveis através do instance_eval.
    assert_equal('private', Mammy.instance_eval('s_private_method'))

    # Métodos [class private] são acessíveis internamente.
    assert_equal('private', Mammy.s_private_method_access)

    # Métodos [class private] não são acessíveis internamente com self.
    assert_match(/private method/, assert_raise(NoMethodError){
      Mammy.s_private_method_access_dot
    }.message)

    # Métodos [class private] não são acessíveis por referência (por causa do .).
    assert_match(/private method/, assert_raise(NoMethodError){
      Mammy.s_private_method_reference(Mammy)
    }.message)

    # Métodos [class private] terminados em '=' são acessíveis internamente com self.
    assert_equal('private=', Mammy.s_private_method_access_dot_equal)

    # Métodos [class private] terminados em '=' não são acessíveis por referência (por causa do .).
    assert_match(/private method/, assert_raise(NoMethodError){
      Mammy.s_private_method_reference_access_dot_equal(Mammy)
    }.message)

  end

  def test_daughter_visibility

    # Métodos [instance public] herdados são acessíveis.
    assert_equal('public', Daughter.new.public_method)

    # Métodos [instance public] herdados são acessíveis.
    assert_equal('public', Daughter.s_public_method)
    assert_equal('public', Daughter.s_public_method_b)

    # Métodos [inherit instance protected] não são acessíveis externamente.
    assert_match(/protected method/, assert_raise(NoMethodError){
      Daughter.new.protected_method
    }.message)

    # Métodos [inherit instance private] não são acessíveis externamente.
    assert_match(/private method/, assert_raise(NoMethodError){
      Daughter.new.private_method
    }.message)

    # Métodos [inherit class private] não são acessíveis externamente.
    assert_match(/private method/, assert_raise(NoMethodError){
      Daughter.s_private_method
    }.message)

    # Métodos [inherit class private] não são acessíveis através do public_send.
    assert_match(/private method/, assert_raise(NoMethodError){
      Daughter.public_send(:s_private_method)
    }.message)

    # Métodos [inherit class private] são acessíveis através do send.
    assert_equal('private', Daughter.send(:s_private_method))

    # Métodos [inherit class private] são acessíveis através do instance_eval.
    assert_equal('private', Daughter.instance_eval('s_private_method'))

    # Métodos [inherit class private] são acessíveis internamente.
    assert_equal('private', Daughter.h_s_private_method_access)

    # Métodos [inherit class private] não são acessíveis internamente com self.
    assert_match(/private method/, assert_raise(NoMethodError){
      Daughter.h_s_private_method_access_dot
    }.message)

    # Métodos [inherit class private] não são acessíveis por referência (por causa do .).
    assert_match(/private method/, assert_raise(NoMethodError){
      Daughter.h_s_private_method_reference(Mammy)
    }.message)

    # Métodos [inherit class private] não são acessíveis por referência (por causa do .).
    assert_match(/private method/, assert_raise(NoMethodError){
      Daughter.h_s_private_method_reference(Daughter)
    }.message)

    # Métodos [inherit class private] terminados em '=' são acessíveis internamente com self.
    assert_equal('private=', Daughter.h_s_private_method_access_dot_equal)

    # Métodos [inherit class private] terminados em '=' não são acessíveis por referência (por causa do .).
    assert_match(/private method/, assert_raise(NoMethodError){
      Daughter.h_s_private_method_reference_access_dot_equal(Mammy)
    }.message)

    # Métodos [inherit class private] terminados em '=' não são acessíveis por referência (por causa do .).
    assert_match(/private method/, assert_raise(NoMethodError){
      Daughter.h_s_private_method_reference_access_dot_equal(Daughter)
    }.message)

  end

end