在基类中实现工厂时，从派生类封装工厂方法的正确方法是什么？

Question

I am trying to create simple class with ability to register derived classes for creation from base class. However I cannot find a good way to encapsulate this functionality from descendants.

Class variables looks for me a bad idea because they available everywhere in inheritance chain. So I try do something with class instance variables. Perfectly it will be that all class methods will be inaccessible except register_as

class A
  @registered = {}
  class << self
    def register_as(name)
      A.registered[name] = self
    end

    def known
      A.registered
    end

    protected
    attr_accessor :registered
  end

  def helpful_method
  end

end

class B < A
  class << self
    def reg_trash
      A.registered[:trash] = :trash
    end
  end
  B.register_as :b
end

B.reg_trash
p A.known

However registered is still accessible from B class. Currently looks like the only one possible option is to split A class to dedicated Factory class and A class will hold only helpful instance methods. Maybe it is possible to do something via .inherited and .undef_method, isn't it?

Answer 1

Maybe it is possible to do something via .inherited and .undef_method, isn't it?

Yes, it is possible. But the idea smells, as for me - you're going to break substitutability.

If you don't want the "derived" classes to inherit the behavior of the parent, why do you use inheritance at all? Try composition instead and mix in only the behavior you need. For example, something like this could work ( very dirty example, but I hope you got the idea):

class A
  module Registry
    def register_as(name)
      A.register_as(name, self)
    end
  end

  @registered = {}

  def self.register_as(name, klass)
    @registered[name] = klass
  end

  def self.known
    @registered
  end
end

class B
  extend A::Registry
  register_as :b  
end

class C
  extend A::Registry
  register_as :c
end

A.known # => {:b => B, :c => C}