"Geert Fannes" <Geert.Fannes / ikanconsulting.com> writes:

> I'm trying to create a derived class (ruby class) from a C-implemented
> class. Everything works fine, until I tried to add a parameter to the
> derived class. When I derive from a pure ruby base class, everything
> works as should be, extra parameter or not. Does someone know what is
> going on or what I am doing wrong?

Your C code does not do:

  class Base
    def initialize()
      puts("base")
    end
  end

It's more like:

  class Base
    def self.new
      ...
    end
    def self.initialize
      ...
    end
  end

Thus, Derived.new(arg) is an error, since it calls Base.new, which
you've defined to take no args.

Note that Blah.new is a completely different method to
Blah#initialize.  Blah.new would be a singleton method of the Class
instance Blah, but you usually don't want that, as the standard
Class#new is sufficiently magical to do everything you need.  In
pseudoruby, it looks like:

  class Class
    def new(*args)
      object = self.alloc_func
      object.initialize(*args)
      return object
    end
  end

Object#dup and Object#clone are similar:

  class Object
    def dup(other)
      object = self.alloc_func
      object.initialize_copy(other)
      return object
    end
    def clone(other)
      object = self.alloc_func
      object.singleton_class = other.singleton_class.copy
      # ... some other diddly bits ...
      object.initialize_copy(other)
      return object
    end
  end

So what you normally do is:

  -- define the alloc func to alloc a ruby object from heap memory:
     VALUE Thingy_allocate(VALUE klass) {
       struct Thingy *thingy;
       return Data_Make_Struct(klass, struct Thingy,
                               Thingy_mark, Thingy_free, thingy);
     }

  -- define an #initialize method:
     VALUE Thingy_initialize(VALUE self, ...args...) {
       ...
     }

  -- define an #initialize_copy method:
     VALUE Thingy_initialize_copy(VALUE self, VALUE other) {
       ...
     }

  -- bind 'em:
     void Init_libthingies {
       VALUE cThingy;
       cThingy = rb_define_class("Thingy", rb_cObject);
       rb_define_alloc_func(cThingy, Thingy_allocate);
       rb_define_method(cThingy, "initialize", Thingy_initialize, num_args);
       rb_define_method(cThingy, "initialize", Thingy_initialize_copy, 1);
       ...
     }

Of course, #initialize_copy is optional (in fact, so is #initialize),
but the point is that doing things this way means you only have to do
the malloc-ing once (in the alloc func), and everywhere else you're
dealing with a perfectly valid ruby object.  No need to call
#initialize or obj_call_init() or worry about your object not being
allocated if #initialize is overriden or gets interrupted by an
exception... just let the standard methods call your hooks and lie
back. :-)