Como implementar uma classe abstrata em ruby?

Eu sei que não há conceito de classe abstrata em rubi. Mas se for necessário implementá-lo, como proceder? Eu tentei algo como ...

class A
  def self.new
    raise 'Doh! You are trying to write Java in Ruby!'
  end
end

class B < A
  ...
  ...
end

Mas quando tento instanciar B, ele vai chamar internamente, o A.newque gerará a exceção.

Além disso, os módulos não podem ser instanciados, mas também não podem ser herdados. tornar o novo método privado também não funcionará. Alguma dica?

Não gosto de usar classes abstratas em Ruby (quase sempre há uma maneira melhor). Se você realmente acha que é a melhor técnica para a situação, pode usar o seguinte snippet para ser mais declarativo sobre quais métodos são abstratos:

module Abstract
  def abstract_methods(*args)
    args.each do |name|
      class_eval(<<-END, __FILE__, __LINE__)
        def #{name}(*args)
          raise NotImplementedError.new("You must implement #{name}.")
        end
      END
      # important that this END is capitalized, since it marks the end of <<-END
    end
  end
end

require 'rubygems'
require 'rspec'

describe "abstract methods" do
  before(:each) do
    @klass = Class.new do
      extend Abstract

      abstract_methods :foo, :bar
    end
  end

  it "raises NoMethodError" do
    proc {
      @klass.new.foo
    }.should raise_error(NoMethodError)
  end

  it "can be overridden" do
    subclass = Class.new(@klass) do
      def foo
        :overridden
      end
    end

    subclass.new.foo.should == :overridden
  end
end

Basicamente, você apenas chama abstract_methodscom a lista de métodos que são abstratos e, quando eles são chamados por uma instância da classe abstrata, uma NotImplementedErrorexceção será gerada.

Apenas para adiar aqui tarde, acho que não há razão para impedir alguém de instanciar a classe abstrata, especialmente porque eles podem adicionar métodos rapidamente .

Linguagens de digitação de pato, como Ruby, usam a presença / ausência ou comportamento de métodos em tempo de execução para determinar se devem ser chamados ou não. Portanto, sua pergunta, como se aplica a um método abstrato , faz sentido

def get_db_name
   raise 'this method should be overriden and return the db name'
end

e isso deve ser sobre o fim da história. O único motivo para usar classes abstratas em Java é insistir que certos métodos sejam "preenchidos" enquanto outros têm seu comportamento na classe abstrata. Em uma linguagem de digitação de pato, o foco está nos métodos, não nas classes / tipos; portanto, você deve mover suas preocupações para esse nível.

Na sua pergunta, você está basicamente tentando recriar a abstractpalavra-chave do Java, que é um cheiro de código para fazer Java no Ruby.

Tente o seguinte:

class A
  def initialize
    raise 'Doh! You are trying to instantiate an abstract class!'
  end
end

class B < A
  def initialize
  end
end

class A
  private_class_method :new
end

class B < A
  public_class_method :new
end

para qualquer pessoa no mundo do Rails, a implementação de um modelo ActiveRecord como uma classe abstrata é feita com esta declaração no arquivo de modelo:

self.abstract_class = true

Meu 2 ¢: opto por uma mixagem DSL simples e leve:

module Abstract
  extend ActiveSupport::Concern

  included do

    # Interface for declaratively indicating that one or more methods are to be
    # treated as abstract methods, only to be implemented in child classes.
    #
    # Arguments:
    # - methods (Symbol or Array) list of method names to be treated as
    #   abstract base methods
    #
    def self.abstract_methods(*methods)
      methods.each do |method_name|

        define_method method_name do
          raise NotImplementedError, 'This is an abstract base method. Implement in your subclass.'
        end

      end
    end

  end

end

# Usage:
class AbstractBaseWidget
  include Abstract
  abstract_methods :widgetify
end

class SpecialWidget < AbstractBaseWidget
end

SpecialWidget.new.widgetify # <= raises NotImplementedError

E, é claro, adicionar outro erro para inicializar a classe base seria trivial nesse caso.

Nos últimos 6 anos e meio de programação do Ruby, eu não precisei de uma aula abstrata nenhuma vez.

Se você pensa que precisa de uma aula abstrata, está pensando demais em uma linguagem que as forneça / exija, não no Ruby.

Como outros sugeriram, um mixin é mais apropriado para coisas que deveriam ser interfaces (como Java as define), e repensar seu design é mais apropriado para coisas que "precisam" de classes abstratas de outras linguagens como C ++.

Atualização 2019: não preciso de aulas abstratas em Ruby em 16 anos e meio de uso. Tudo o que todas as pessoas comentando sobre a minha resposta estão dizendo é abordado aprendendo Ruby e usando as ferramentas apropriadas, como módulos (que até oferecem implementações comuns). Existem pessoas nas equipes que eu gerenciei que criaram classes com implementação básica que falham (como uma classe abstrata), mas essas são principalmente um desperdício de codificação, porque NoMethodErrorproduziriam exatamente o mesmo resultado que AbstractClassErrorna produção.

Você pode tentar 3 rubygems:
interface
resumo
simples resumo

Pessoalmente, levanto NotImplementedError em métodos de classes abstratas. Mas você pode deixar de fora o método 'novo', pelos motivos mencionados.

Se você deseja ir com uma classe instável, no seu método A.new, verifique se self == A antes de gerar o erro.

Mas, na verdade, um módulo parece mais com o que você deseja aqui - por exemplo, Enumerable é o tipo de coisa que pode ser uma classe abstrata em outros idiomas. Tecnicamente, você não pode subclassificá-los, mas chamar include SomeModuleatinge aproximadamente o mesmo objetivo. Existe algum motivo para isso não funcionar para você?

Qual o objetivo que você está tentando servir com uma classe abstrata? Provavelmente existe uma maneira melhor de fazê-lo em rubi, mas você não forneceu detalhes.

Meu ponteiro é esse; use um mixin não herança.

Outra resposta:

module Abstract
  def self.append_features(klass)
    # access an object's copy of its class's methods & such
    metaclass = lambda { |obj| class << obj; self ; end }

    metaclass[klass].instance_eval do
      old_new = instance_method(:new)
      undef_method :new

      define_method(:inherited) do |subklass|
        metaclass[subklass].instance_eval do
          define_method(:new, old_new)
        end
      end
    end
  end
end

Isso depende do #method_missing normal para relatar métodos não implementados, mas evita a implementação de classes abstratas (mesmo se elas tiverem um método de inicialização)

class A
  include Abstract
end
class B < A
end

B.new #=> #<B:0x24ea0>
A.new # raises #<NoMethodError: undefined method `new' for A:Class>

Como os outros pôsteres disseram, você provavelmente deveria estar usando um mixin, em vez de uma aula abstrata.

Eu fiz dessa maneira, por isso redefine o novo na classe filho para encontrar um novo na classe não abstrata. Ainda não vejo nenhuma prática no uso de classes abstratas em ruby.

puts 'test inheritance'
module Abstract
  def new
    throw 'abstract!'
  end
  def inherited(child)
    @abstract = true
    puts 'inherited'
    non_abstract_parent = self.superclass;
    while non_abstract_parent.instance_eval {@abstract}
      non_abstract_parent = non_abstract_parent.superclass
    end
    puts "Non abstract superclass is #{non_abstract_parent}"
    (class << child;self;end).instance_eval do
      define_method :new, non_abstract_parent.method('new')
      # # Or this can be done in this style:
      # define_method :new do |*args,&block|
        # non_abstract_parent.method('new').unbind.bind(self).call(*args,&block)
      # end
    end
  end
end

class AbstractParent
  extend Abstract
  def initialize
    puts 'parent initializer'
  end
end

class Child < AbstractParent
  def initialize
    puts 'child initializer'
    super
  end
end

# AbstractParent.new
puts Child.new

class AbstractChild < AbstractParent
  extend Abstract
end

class Child2 < AbstractChild

end
puts Child2.new

Há também essa pequena abstract_typejóia, que permite declarar classes e módulos abstratos de maneira discreta.

Exemplo (do arquivo README.md ):

class Foo
  include AbstractType

  # Declare abstract instance method
  abstract_method :bar

  # Declare abstract singleton method
  abstract_singleton_method :baz
end

Foo.new  # raises NotImplementedError: Foo is an abstract type
Foo.baz  # raises NotImplementedError: Foo.baz is not implemented

# Subclassing to allow instantiation
class Baz < Foo; end

object = Baz.new
object.bar  # raises NotImplementedError: Baz#bar is not implemented

Nada de errado com sua abordagem. Gerar um erro na inicialização parece bom, desde que todas as suas subclasses substituam a inicialização, é claro. Mas você não quer se definir.novo assim. Aqui está o que eu faria.

class A
  class AbstractClassInstiationError < RuntimeError; end
  def initialize
    raise AbstractClassInstiationError, "Cannot instantiate this class directly, etc..."
  end
end

Outra abordagem seria colocar toda essa funcionalidade em um módulo, que, como você mencionou, nunca pode ser instanciado. Em seguida, inclua o módulo em suas classes em vez de herdar de outra classe. No entanto, isso quebraria coisas como super.

Portanto, depende de como você deseja estruturá-lo. Embora os módulos pareçam uma solução mais limpa para solucionar o problema de "Como eu escrevo algumas coisas que são dignas para outras classes usarem"

Gema de 2 linhas: https://rubygems.org/gems/abstract

Embora isso não pareça Ruby, você pode fazer o seguinte:

class A
  def initialize
    raise 'abstract class' if self.instance_of?(A)

    puts 'initialized'
  end
end

class B < A
end

Os resultados:

>> A.new
  (rib):2:in `main'
  (rib):2:in `new'
  (rib):3:in `initialize'
RuntimeError: abstract class
>> B.new
initialized
=> #<B:0x00007f80620d8358>
>>