Forum: Ruby Class (not instance) initializers

Announcement (2017-05-07): www.ruby-forum.com is now read-only since I unfortunately do not have the time to support and maintain the forum any more. Please see rubyonrails.org/community and ruby-lang.org/en/community for other Rails- und Ruby-related community platforms.
Bhrgunatha Deva (Guest)
on 2006-03-21 12:20
(Received via mailing list)
Newbie question:

Is there an equivalent to a static constructor in ruby?
something like:

class MyClass
   # want this to run before any instances of MyClass are created
   def class_initialize
     self.some_complex_initialisation
   end
end

At the moment I'm using:
class MyClass
   def initialize
     @@init = self.some_complex_initialisation if @@init.nil?
   end
end

I'd love to know if there is a more rubyesque way of doing this

Bhrgunatha.
Robert K. (Guest)
on 2006-03-21 13:03
(Received via mailing list)
Bhrgunatha Deva wrote:
> end
>
> At the moment I'm using:
> class MyClass
>   def initialize
>     @@init = self.some_complex_initialisation if @@init.nil?
>   end
> end
>
> I'd love to know if there is a more rubyesque way of doing this

Just place your code in the class body:

class MyClass
   @class_state = complex_calculation
end

Often one needs to inform a super class of a new child.  This can be
done with #inherited:

class Base
   def self.inherited(cl)
     print Base, " was inherited by ", cl, "\n"
   end
end

 >> class Foo < Base
 >> end
Base was inherited by Foo
=> nil

Kind regards

	robert
Ross B. (Guest)
on 2006-03-21 13:04
(Received via mailing list)
On Tue, 2006-03-21 at 19:20 +0900, Bhrgunatha Deva wrote:
> end
Do you mean something like:

class InitMe
  def self.complex_init
    puts "Initializing #{self}"
  end

  complex_init
end
#(p) Initializing InitMe
# => nil

or even just:

class InitMe
  puts "Initializing #{self}"
end
#(p) Initializing InitMe
# => nil

?
Bhrgunatha Deva (Guest)
on 2006-03-21 13:50
(Received via mailing list)
Ross B. wrote:
> # => nil
>

I'm so dim. I didn't realise I could just call a method from inside the
class body.

Robert K. wrote:
>  >> end
> Base was inherited by Foo
> => nil
>

Whoa, that's very neat!

Thanks.
Dave B. (Guest)
on 2006-03-21 13:51
(Received via mailing list)
I am creating a DSL using Ruby.  A cut down version is below:

class _Box
	attr_accessor		:width

	 def initialize (&block)
                self.width = 20			# some default value
		instance_eval(&block) if block_given?
	end
end

# Helper function to avoid the DSL user having to use .new
def Box(&block)
	_Box.new(&block)
end

I  want to do something like:

     Box {width = 10}

but the only way I can get it to work is

     Box  {self.width = 10}

Having to prefix the ivar with self.  makes the DSL look clunky and
wouldn't be acceptable to my users.

Is there anyway to avoid the self.?  Using {@width = 10} will work
but prevents some necessary validation from taking place.


I have an alternative where width is a method:

class _Box
	def width (val = :no_param)
		if val != :no_param
			@width = val
		end
		@width
	end
end

so with this I can write

     Box {width 10}

which is acceptable from the DSL view point, but makes the getter
operations more expensive.  In the real version a getter operation
takes about 7 statements to allow for evaluation of block if the ivar
had been set to a Proc object and inheritance of values from its
parent object (in a visual hierarchy).  The setter operation is often
only done when the object is created but the getter is done very
frequently so I want to move down the route of separate setters and
getters rather than combining them in the one method as an optimization.

Dave.
Timothy H. (Guest)
on 2006-03-21 15:34
(Received via mailing list)
Dave B. wrote:
>
>
>
>
>
> Dave.
>
>
>
Good article on DSLs and addresses your question:
http://www.artima.com/rubycs/articles/ruby_as_dsl.html
itsme213 (Guest)
on 2006-03-21 16:18
(Received via mailing list)
"Dave B." <removed_email_address@domain.invalid> wrote

> Having to prefix the ivar with self.  makes the DSL look clunky

I agree, though some experienced Rubyists don't see it that way.

> move down the route of separate setters and  getters rather than combining
> them in the one method as an optimization.

If you have some guarantees about the ordering of getters and setters,
you
can dynamically (re)define the getter and setter at the instance level.
The
attached worked for the case of instance variables being initialized
only
once, but being read at any time (the context for this was some kind of
lazy
creation of an object graph including forward references). Perhaps some
bits
of it will apply to your case.

class Object
 def singleton_class
  class << self; self; end
 end
end

module LazyForwardRef
 UNDEFINED = nil
 def forward_ref(attr)
  getter = attr
  setter = (attr.to_s + '=').intern
  ivar = ('@' + attr.to_s).intern
  suspension = lambda { self.send getter }
  self.singleton_class.send :define_method, getter, lambda {
   v = instance_variable_get ivar
   if v == UNDEFINED
    suspension
   elsif v.is_a?(Proc)
    current = v.call
    self.send(setter, current) if current != v
    current
   else v
   end
  }
  self.singleton_class.send :define_method, setter, lambda {|val|
   self.instance_variable_set ivar, val
  }
 end
end


require 'pp'

x = Object.new
x.extend LazyForwardRef

begin
 p x.foo
rescue NoMethodError => detail
 pp detail
 pp [__LINE__, x, x.methods.sort - Object.instance_methods]
end

x.forward_ref(:foo)
pp [__LINE__, x, x.methods.sort - Object.instance_methods]

x.foo
pp [__LINE__, x, x.foo]

x.foo = 'Something else'
pp [__LINE__, x, x.foo]

y = Object.new
y.extend LazyForwardRef

y.forward_ref(:bar)
pp [__LINE__, y, y.methods.sort - Object.instance_methods]

z = Object.new
z.extend LazyForwardRef
z.forward_ref(:baz)

y.bar = z.baz
pp [__LINE__, x, y, z, x.foo, y.bar, z.baz, x.foo==z.baz]

x.foo = y.bar
pp [__LINE__, x, y, x.foo, y.bar]

z.baz= 10
pp [__LINE__, x, y, z]

pp [__LINE__, x.foo, y.bar, z.baz]

pp [__LINE__, x, y, z]
unknown (Guest)
on 2006-03-21 17:44
(Received via mailing list)
On Tue, 21 Mar 2006, Dave B. wrote:

> # Helper function to avoid the DSL user having to use .new
>    Box  {self.width = 10}
> class _Box
>    Box {width 10}
>
> which is acceptable from the DSL view point, but makes the getter operations
> more expensive.  In the real version a getter operation takes about 7
> statements to allow for evaluation of block if the ivar had been set to a
> Proc object and inheritance of values from its parent object (in a visual
> hierarchy).  The setter operation is often only done when the object is
> created but the getter is done very frequently so I want to move down the
> route of separate setters and getters rather than combining them in the one
> method as an optimization.

here is one simple way:

     harp:~ > cat a.rb
     class OpenStruct
       alias_method "__eval__", "instance_eval"
       alias_method "__set__", "instance_variable_set"
       alias_method "__get__", "instance_variable_get"
       instance_methods.each{ |m| undef_method m unless m =~ /^__/ }
       def initialize(&block) __eval__ &block end
       def method_missing m, *a, &b
         m = m.to_s.delete "=?"
         a.size == 0 ? __get__("@#{ m }") : __set__("@#{ m }", a.shift)
       end
     end

     module Initializable
       def initialize &block
         os = OpenStruct.new &block
         attributes.each{|a| instance_variable_set "@#{ a }",
os.__send__(a)}
       end
       def to_s
         require "yaml"
         attributes.inject({}){|h,a| h.update a => send(a)}.to_yaml
       end
       def attributes
         self.class::ATTRIBUTES
       end
     end

     class Box
       ATTRIBUTES = %w[ width height ]
       ATTRIBUTES.each{|a| attr a}
       include Initializable
     end

     def Box(*a, &b) Box.new(*a, &b) end

     puts Box {
       width 42
       height 42
     }



     harp:~ > ruby a.rb
     ---
     height: 42
     width: 42


the idea is to initialize another object, the OpenStruct in this case,
and then
relay the properties.  this object can have any 'slow' but convenient
behaviour
your desire, leaving the Box class to have normal 'fast' attributes.

hth.

-a
This topic is locked and can not be replied to.