Default method for Ruby class

Question

Is there a way to specify a class method such that when the object is used as if it were a function, that method is called? Something like this:

class MyClass

  def some_magic_method(*args)
    # stuff happens
  end

end

# create object
myob = MyClass.new

# implicitly call some_magic_method
myob 'x'

`some_magic_method` is written as an instance method, not a class method. `myob 'x'` raises an "undefined method 'myob'" exception. If you mean `myob.x` you could use [BasicObject#method_missing](https://ruby-doc.org/core-2.4.0/BasicObject.html#method-i-method_missing), but that is an instance method. — Cary Swoveland, Jun 25 '17 at 00:12
This makes no sense. There is absolutely no relationship between the message `myob` and the variable `myob`. How do you expect `myob` to know about the message? — Jörg W Mittag, Jun 26 '17 at 00:46
@JörgWMittag maybe the question looks strange for a Ruby programmer but the concept is perfectly valid and supported by other languages (C++ and PHP are the ones I know). I have to admit, however, that neither C++ nor PHP are as elegant as Ruby regarding the OOP. — axiac, Jun 26 '17 at 14:42

score 3 · Answer 1 · edited Sep 27 '17 at 17:07

As mentioned by @CarySwoveland in the comments you can use method_missing. A basic example is as follows:

class MyClass

  def method_missing(method_name, *args)
    if method_name.match?(/[xyz]/)
      send(:magic_method, args.first) 
    else
      super
    end
  end

  def magic_method(a)
    a = 'none' if a.nil?
    "xyz-magic method; argument(s): #{a}"
  end

end

myob = MyClass.new
myob.x    #=> "xyz-magic method; argument(s): none"
myob.x(1) #=> "xyz-magic method; argument(s): 1"

myob.y    #=> "xyz-magic method; argument(s): none"
myob.z    #=> "xyz-magic method; argument(s): none"

This captures all methods named x, y or z. Our else branch sends all other undefined methods to the original method_missing:

myob.v    #=> test.rb:7:in `method_missing': undefined method `v' for
              #<MyClass:0x000000021914f8> (NoMethodError)
              #from test.rb:25:in `<main>'

What methods you capture is up to you and is determined by the regex /[xyz]/ in this case.

Key methods: BasicObject#method_missing, Object#send. For further info check out this question, read Eloquent Ruby by Russ Olsen (from which this answer references)

score 3 · Answer 2 · answered Jun 25 '17 at 17:05

3

You could write a command class and make use of a ruby shortcut

class MyClass
  def self.call(text)
    puts text
  end
end

MyClass.('x')

Here MyClass.() defaults to the call class method.

answered Jun 25 '17 at 17:05

S.Spencer

581
3
8

score 0 · Answer 3 · answered Jun 26 '17 at 14:34

You meant to invoke some class' instance method when the object is invoked as a function. This is already supported: instance method call gets called when you "invoke" an object via the functional invocation method () (for more details, see here How do I reference a function in Ruby?).

class C
  def call(x)
    puts "Called with #{x}"
  end
end

obj = C.new
obj.(88) # Called with 88 => nil
obj (88) # NoMethodError: undefined method `obj' for main:Object

If you do want the latter syntax, a horrible trick is the following one (but works only at the top-level, unless you carry along the bindings):

module Kernel
  def method_missing(name,*args)
    obj = begin
      TOPLEVEL_BINDING.local_variable_get(name)
    rescue
      nil
    end
    return super if obj.nil? 
    obj.send :call, *args
  end
end

obj = C.new

obj 88 # Called with OK => nil

This example also wants to communicate that you should always keep in mind who is the receiver of your method calls, and what syntaxes are available for calling methods (especially when you leave out dots and parentheses).

class D
  def obj; C.new end
  def f
    #(obj) 88 # BAD 
    (obj).(88) 
    #obj() 88 # BAD 
    obj().(88) 
  end
end

The point is that you do not actually have functions, but methods that get called on objects. If you omit the receiver of a method call, the receiver defaults to self, the current object. But in your example, myob does not appear as an explicit receiver (since there is not following dot as in myob.), hence the current object is looked for a method myob.

Default method for Ruby class

3 Answers3