How to call a class method when (i.e. in the moment of) inheriting from a class/defining a descendant?

Hi,

This problem maybe results from a bad understanding of what I'm trying to do. Anyway, is it possible to call a method when creating a new class or inheriting from another class?

Currently my code looks somehow like this:

class A
     class << self
         attr_reader :x

         def prepare
             # do something
         end

         def fixate
             # do something
         end

         def foo(a)
             # do something with a and @x
         end
     end
end

class B < A
     prepare

     @x = "something"

     foo("bar")

     def method1
         # do something else
     end

     fixate
end

Now in an ideal world, the definition of class B would be simply:

class B < A
     @x = "something"

     def method1
         # do something
     end
end

and A.setup and A.fixate should be automagically invoked whenever defining a descendant from class A.

Does somebody know a solution for how this can be done? The only possible way of doing this I could come up with is to wrap the definition part into a block and pass this block to a method that calls these functions and evaluates the block using class_eval. Something in the line of (untested):

class C < A
     wrapper do
         @x = "something"

         def method1
             # do something
         end
     end
end

But I'm not sure if this solution really is an advantage.

Cheers,
Thomas.

You must keep in mind that a class instance variable is local for the particular class object. In your case, trying to set @x in B does it locally for class B, not affecting @x in class A in any way, even when B inherits from A. You may want to define "attr_writer :x" in class A and use "self.x = 'something'" in class B.

Gennady.

Thomas wrote:

···

Hi,

This problem maybe results from a bad understanding of what I'm trying to do. Anyway, is it possible to call a method when creating a new class or inheriting from another class?

Currently my code looks somehow like this:

class A
    class << self
        attr_reader :x

        def prepare
            # do something
        end

        def fixate
            # do something
        end

        def foo(a)
            # do something with a and @x
        end
    end
end

class B < A
    prepare

    @x = "something"

    foo("bar")

    def method1
        # do something else
    end

    fixate
end

Now in an ideal world, the definition of class B would be simply:

class B < A
    @x = "something"

    def method1
        # do something
    end
end

and A.setup and A.fixate should be automagically invoked whenever defining a descendant from class A.

Does somebody know a solution for how this can be done? The only possible way of doing this I could come up with is to wrap the definition part into a block and pass this block to a method that calls these functions and evaluates the block using class_eval. Something in the line of (untested):

class C < A
    wrapper do
        @x = "something"

        def method1
            # do something
        end
    end
end

But I'm not sure if this solution really is an advantage.

Cheers,
Thomas.

Thomas ha scritto:

Does somebody know a solution for how this can be done?

see Class#inherited:

>> class A
>> def self.inherited(klass)
>> p "wow I got childs:"+klass.to_s
>> end
>> end
=> nil
>> class A2 < A
>> end
"wow I got childs:A2"
=> nil
>> Class.new(A2)
"wow I got childs:#<Class:0x2bd54e0>"
=> #<Class:0x2bd54e0>

harp:~ > cat a.rb
class A
   class << self
     def setup
       puts "<#{ self }> invoking setup..."
     end
     def inherited klass
       klass.setup
     end
   end
end

class B < A
end

harp:~ > ruby a.rb
<B> invoking setup...

hth.

-a

···

On Mon, 6 Jun 2005, Thomas wrote:

Hi,

This problem maybe results from a bad understanding of what I'm trying to do. Anyway, is it possible to call a method when creating a new class or inheriting from another class?

Currently my code looks somehow like this:

class A
   class << self
       attr_reader :x

       def prepare
           # do something
       end

       def fixate
           # do something
       end

       def foo(a)
           # do something with a and @x
       end
   end
end

class B < A
   prepare

   @x = "something"

   foo("bar")

   def method1
       # do something else
   end

   fixate
end

Now in an ideal world, the definition of class B would be simply:

class B < A
   @x = "something"

   def method1
       # do something
   end
end

and A.setup and A.fixate should be automagically invoked whenever defining a descendant from class A.

Does somebody know a solution for how this can be done? The only possible way of doing this I could come up with is to wrap the definition part into a block and pass this block to a method that calls these functions and evaluates the block using class_eval. Something in the line of (untested):

class C < A
   wrapper do
       @x = "something"

       def method1
           # do something
       end
   end
end

But I'm not sure if this solution really is an advantage.

--

email :: ara [dot] t [dot] howard [at] noaa [dot] gov
phone :: 303.497.6469
My religion is very simple. My religion is kindness.
--Tenzin Gyatso

===============================================================================

class A
  class << self
    def setup
      puts "<#{ self }> invoking setup..."
    end
    def inherited klass
      klass.setup
    end
  end
end

class B < A
end

Thanks for this reference to "inherited" -- I didn't know about this method and its purpose. As so often with ruby, the solution is somehow self-evident/explanatory in retrospect.

Regards,
Thomas.