Come implementare una classe astratta in ruby?

So che non esiste il concetto di classe astratta in Ruby. Ma se è necessario implementarlo, come farlo? Ho provato qualcosa come ...

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

class B < A
  ...
  ...
end

Ma quando provo a istanziare B, internamente chiamerà A.newche solleverà l'eccezione.

Inoltre, i moduli non possono essere istanziati ma anche loro non possono essere ereditati. anche rendere privato il nuovo metodo non funzionerà. Qualche suggerimento?

Non mi piace usare classi astratte in Ruby (c'è quasi sempre un modo migliore). Se pensi davvero che sia la tecnica migliore per la situazione, puoi usare il seguente frammento per essere più dichiarativo su quali metodi sono astratti:

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

Fondamentalmente, si chiama semplicemente abstract_methodscon l'elenco dei metodi astratti e quando vengono chiamati da un'istanza della classe astratta, NotImplementedErrorverrà sollevata un'eccezione.

Solo per intervenire in ritardo qui, penso che non ci sia motivo per impedire a qualcuno di istanziare la classe astratta, soprattutto perché possono aggiungere metodi al volo .

I linguaggi di battitura a papera, come Ruby, utilizzano la presenza / assenza o il comportamento dei metodi in fase di esecuzione per determinare se devono essere chiamati o meno. Quindi la tua domanda, in quanto si applica a un metodo astratto , ha senso

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

e quella dovrebbe essere la fine della storia. L'unico motivo per utilizzare classi astratte in Java è insistere sul fatto che alcuni metodi vengono "riempiti" mentre altri hanno il loro comportamento nella classe astratta. In un linguaggio di battitura a papera, l'attenzione è sui metodi, non sulle classi / tipi, quindi dovresti spostare le tue preoccupazioni a quel livello.

Nella tua domanda, stai fondamentalmente cercando di ricreare la abstractparola chiave da Java, che è un odore di codice per fare Java in Ruby.

Prova questo:

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

per chiunque nel mondo rails, l'implementazione di un modello ActiveRecord come classe astratta viene eseguita con questa dichiarazione nel file del modello:

self.abstract_class = true

Il mio 2 ¢: opto per un mixin DSL semplice e leggero:

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, ovviamente, l'aggiunta di un altro errore per l'inizializzazione della classe base sarebbe banale in questo caso.

Negli ultimi 6 anni e mezzo di programmazione in Ruby, non ho avuto bisogno di una lezione astratta nemmeno una volta.

Se stai pensando di aver bisogno di una classe astratta, stai pensando troppo in un linguaggio che li fornisce / li richiede, non in Ruby in quanto tale.

Come altri hanno suggerito, un mixin è più appropriato per cose che dovrebbero essere interfacce (come le definisce Java), e ripensare il tuo design è più appropriato per cose che "necessitano" di classi astratte da altri linguaggi come C ++.

Aggiornamento 2019: non ho bisogno di lezioni astratte in Ruby in 16 anni e mezzo di utilizzo. Tutto ciò che dicono tutte le persone che commentano la mia risposta viene affrontato imparando effettivamente Ruby e utilizzando gli strumenti appropriati, come i moduli (che forniscono anche implementazioni comuni). Ci sono persone nei team che ho gestito che hanno creato classi che hanno un'implementazione di base che fallisce (come una classe astratta), ma questi sono principalmente uno spreco di codifica perché NoMethodErrorprodurrebbe lo stesso identico risultato di una AbstractClassErrorin produzione.

Puoi provare 3 rubygems:
interface
abstract
simple abstract

Personalmente sollevo NotImplementedError nei metodi delle classi astratte. Ma potresti lasciarlo fuori dal "nuovo" metodo, per i motivi che hai menzionato.

Se vuoi andare con una classe non istanziabile, nel tuo metodo A.new, controlla se self == A prima di lanciare l'errore.

Ma in realtà, un modulo sembra più come quello che vuoi qui - per esempio, Enumerable è il tipo di cosa che potrebbe essere una classe astratta in altri linguaggi. Tecnicamente non puoi sottoclassarli, ma la chiamata include SomeModuleraggiunge più o meno lo stesso obiettivo. C'è qualche motivo per cui questo non funzionerà per te?

Che scopo stai cercando di servire con una classe astratta? Probabilmente c'è un modo migliore per farlo in ruby, ma non hai fornito alcun dettaglio.

Il mio suggerimento è questo; utilizzare un mixin non ereditarietà.

Un'altra risposta:

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

Si basa sul normale #method_missing per segnalare metodi non implementati, ma impedisce l'implementazione di classi astratte (anche se hanno un metodo di inizializzazione)

class A
  include Abstract
end
class B < A
end

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

Come hanno detto gli altri poster, probabilmente dovresti usare un mixin, piuttosto che una classe astratta.

L'ho fatto in questo modo, quindi ridefinisce la nuova classe figlio per trovare una nuova classe non astratta. Non vedo ancora alcuna pratica nell'utilizzo di classi astratte in 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

C'è anche questo piccolo abstract_type gioiello, che consente di dichiarare classi e moduli astratti in modo discreto.

Esempio (dal file 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

Niente di sbagliato nel tuo approccio. Sollevare un errore in initialize sembra corretto, a patto che tutte le tue sottoclassi sovrascrivano l'inizializzazione, ovviamente. Ma non vuoi definire il sé. Nuovo in questo modo. Ecco cosa farei.

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

Un altro approccio sarebbe mettere tutte quelle funzionalità in un modulo, che come hai detto non può mai essere istanziato. Quindi includi il modulo nelle tue classi piuttosto che ereditare da un'altra classe. Tuttavia, questo romperebbe cose come super.

Quindi dipende da come vuoi strutturarlo. Sebbene i moduli sembrino una soluzione più pulita per risolvere il problema di "Come scrivo qualcosa che è degno di essere utilizzato da altre classi"

Gemma a 2 righe: https://rubygems.org/gems/abstract

Anche se non sembra Ruby, puoi farlo:

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

    puts 'initialized'
  end
end

class B < A
end

I risultati:

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