Calling class method from instance

Ruby
1

I was puzzled on this but figured out a way to do it. Figured I’d post
it on here, maybe there’s a better way …

class Test

@c = 2
def self.ctest
puts @c
end

def initialize(i)
@i = i
end

def itest
puts @i

here’s what I was trying to do !!!

puts self.class.ctest
end

end

ob = Test.new(7)

ob.itest
Test.ctest

2

On Tue, Feb 10, 2009 at 5:19 PM, Larz [email protected] wrote:

puts self.class.ctest
IMHO this call syntax is optimal, because agnostic to the class name.
Robert

3

Larz wrote:

puts self.class.ctest

What’s the reason for not simply writing your class like this:

class Test
@c = 20

def Test.a
puts @c
end

def b
Test.a
end

end

t = Test.new
t.b

–output:–
20

4

On Tue, Feb 10, 2009 at 3:27 PM, 7stud – [email protected]
wrote:

def Test.a
t.b

–output:–
20

That’s fine unless you want to, say, override the class method in a
subclass

class TestSub < Test

def TestSub.a
puts “doin my own thang.”
end
end

t = TestSub.new
t.b
–output is still–
20

Rick DeNatale

Blog: http://talklikeaduck.denhaven2.com/
Twitter: http://twitter.com/RickDeNatale

5

On Tue, Feb 10, 2009 at 11:21 PM, Rick DeNatale
[email protected] wrote:

That’s fine unless you want to, say, override the class method in a subclass
Good point, but there is another issue here.
Your project guru comes along and tells you: Nice code, but we should
not use the name Test (for a dumb reason of course).
Now you have to change Test to Check in your source
would you prefer to change it here

class Test
def a # multiply this with n entries
self.class.x
end
def self.a
…

or here

class Test
def a
Test.x
end
def Test.a

end

In other words the second version is not DRY and the worst penalty for
unDRYness is the need to change your code.

Robert

6

Larz wrote:

def itest
puts @i

here’s what I was trying to do !!!

puts self.class.ctest
end

I think Object#class is something to be avoided in most cases. Frankly
it’s none of your business what class was used to create an object. It
doesn’t matter how an object sprang into existence, what matters is
how it quacks.

I want to replace an object with a delegate with no ill effects. Or
with a mock object, or with whatever. But uses of Object#class defeat
this.

I would be inclined to make shared data explicit either with a constant
or a with a passed-in reference to the shared data, rather than implicit
with Object#class.

class Test
SHARED = Struct.new(:ctest).new(2)

def itest
puts SHARED.ctest
end
end

Test.new.itest #=> 2