self.inherited but wait until subclass is fully defined?

[matt neuburg]

Howdy. I am a class. There are certain rules for what you are supposed
to do when you subclass me, so as a sanity check I wish to introspect
your subclass to make sure it's obeying the contract.

However, my problem is that self.inherited is called too early.

class C # this is me
def self.inherited(p)
#whatever
super
end
end

class B < C # this is you
# C's self.inherited is called right here
def yourFirstMethod
# etc.
end
end

So I can't, in my self.inherited, ask about what methods you have
defined, because you haven't defined them yet. This must have come up
before; is there an easy solution? Thx - m.

 

[Robert Klemme]

Howdy. I am a class. There are certain rules for what you are supposed
to do when you subclass me, so as a sanity check I wish to introspect
your subclass to make sure it's obeying the contract.

However, my problem is that self.inherited is called too early.

class C # this is me
def self.inherited(p)
#whatever
super
end
end

class B < C # this is you
# C's self.inherited is called right here
def yourFirstMethod
# etc.
end
end

So I can't, in my self.inherited, ask about what methods you have
defined, because you haven't defined them yet. This must have come up
before; is there an easy solution? Thx - m.

Even after the class definition methods can be added. You could catch
that with method_added but if you require a minimum set of methods to be
defined before class is used (e.g. instantiated) this will be difficult
to track. One option would be to define method initialize in your class
and do the check there. But this is still fragile because it might not
be guaranteed that sub classes invoke it from their initialize...

Another option would be to override the sub class's method "new" so you
can do the check there. This might be a bit more robust but even "new"
can be overridden by subclasses (although it isn't generally).

I'd probably just omit the check. If any of your superclass methods
invokes a method that is not defined you'll see this at runtime anyway.

Kind regards

robert

 

[Ryan Davis]

Even after the class definition methods can be added. You could
catch that with method_added but if you require a minimum set of
methods to be defined before class is used (e.g. instantiated) this
will be difficult to track. One option would be to define method
initialize in your class and do the check there. But this is still
fragile because it might not be guaranteed that sub classes invoke
it from their initialize...

Another option would be to override the sub class's method "new" so
you can do the check there. This might be a bit more robust but
even "new" can be overridden by subclasses (although it isn't
generally).

I'd probably just omit the check. If any of your superclass methods
invokes a method that is not defined you'll see this at runtime
anyway.

I agree with this in general for Matt's particular problem. The
smalltalk pattern of defining all contracted methods and having them
raise SubclassResponsibility is a good one to use in this situation.

BUT... There have been many times where I've wanted a "class closed"
hook to go along with inherited (essentially a "class opened" hook).
Having both makes it very easy for me to do lots of things with my
language tools. I can instrument added methods quite easily with that
mechanism. It'd be nice to have this extra hook.

 

[James Coglan]

[Note: parts of this message were removed to make it a legal post.]

On Mar 20, 2009, at 09:37 , Robert Klemme wrote:



I agree with this in general for Matt's particular problem. The smalltalk
pattern of defining all contracted methods and having them raise
SubclassResponsibility is a good one to use in this situation.

So, maybe a little helper:

class Module
def abstract_methods(*names)
names.each do |name|
define_method(name) { raise SubclassResponsibility }
end
end
end

For example

class MyClass
abstract_methods :foo, :bar
end

class Whizz < MyClass
def foo; "foo!"; end
end

w = Whizz.new
w.foo #=> "foo!"
w.bar #=> error: SubclassResponsibility

 

[matt neuburg]

Another option would be to override the sub class's method "new" so you
can do the check there. This might be a bit more robust but even "new"
can be overridden by subclasses (although it isn't generally).

That's a good idea, I'll look into it - thanks! m.

 

[Dan Wineman]

Howdy. I am a class. There are certain rules for what you are supposed
to do when you subclass me, so as a sanity check I wish to introspect
your subclass to make sure it's obeying the contract.

Is this even a good idea?

What if I wanted to create an abstract subclass that doesn't obey the
contract -- which is OK because it won't be instantiated -- but whose
own subclasses do?

 

[Robert Dober]

BUT... There have been many times where I've wanted a "class closed" hook to
go along with inherited (essentially a "class opened" hook). Having both
makes it very easy for me to do lots of things with my language tools. I can
instrument added methods quite easily with that mechanism. It'd be nice to
have this extra hook.

I am not sure I understand. Do you mean "class frozen hook"? I do not
really know when a "class closed" hook should be triggered.

Robert