Calling a method of a Ruby Singleton without the reference of 'instance'

Question

I would like to call a method of a Singleton Object without the reference to its instance

SingletonKlass.my_method

instead of

SingletonKlass.instance.my_method

i've came up with this solution (using method_missing in the class):

require 'singleton'    

class SingletonKlass
  include Singleton

  def self.method_missing(method, *args, &block)
    self.instance.send(method, *args)
  end

  def my_method
     puts "hi there!!"
  end
end

is there any drawback to this ? is there any better solution ? any recommendation from you ?

thank you.

UPDATE:

my aim is to have a module to be mixed-in with singleton classes:

module NoInstanceSingleton
   def method_missing(method, *args)
      self.instance.send(method, *args)
   end
end

end then use it in the class:

class SingletonKlass
   include Singleton
   extend NoInstanceSingleton

  def method1; end
  def method2; end
  ...
  def methodN; end
end

i want to be able to directly call:

SingletonKlass.method1

Andrew Grimm · Accepted Answer · 2011-03-15T21:47:23.780

13

Using forwardable and def_delegators:

require 'singleton'    
require 'forwardable'

class SingletonKlass
  include Singleton
  class << self
    extend Forwardable
    def_delegators :instance, :my_method
  end

  def my_method
     puts "hi there!!"
  end
end

SingletonKlass.my_method

Edit: If you want to include all the methods you've defined yourself, you could do

require 'singleton'    
require 'forwardable'

class SingletonKlass
  include Singleton

  def my_method
     puts "hi there!!"
  end

  class << self
    extend Forwardable
    def_delegators :instance, *SingletonKlass.instance_methods(false)
  end
end

SingletonKlass.my_method

edited Mar 15 '11 at 21:47

answered Mar 15 '11 at 04:12

Andrew Grimm

78,473
57
200
338

this way it is mandatory to specify every single delegator method. i was searching for a general solution, maybe to be mixed-in as a module for every Singleton i wanted to create... – ALoR Mar 15 '11 at 19:53
@ALoR: How is the second version? – Andrew Grimm Mar 15 '11 at 21:47
so in a module i can use: `def_delegators :instance, *self.instance_methods(false)` and include in the SingletonKlass, am i right ? – ALoR Mar 16 '11 at 08:41
@ALoR: Can you edit your question to include your new requirements so I can understand them fully? That being said, give it a go, and if it doesn't work, then you may want to use [Module#included](http://apidock.com/ruby/Module/included) to access `SingletonKlass`. – Andrew Grimm Mar 16 '11 at 12:10
1

I really like this and does exactly what I want it to do. Just a note. If you want to use this with an inherited class (class here < AnotherClass) the parent class also needs this defined or you cannot access its instance methods either. – ZeroInputCtrl Jun 03 '16 at 16:37

Aaa · Answer 2 · 2011-03-16T23:59:04.013

2

The problem with your method_missing solution is that it will only redirect calls to instance if there does not exist a method of that name on SingletonKlass, which will cause problems if people want to access, for example, instance.__id__ through this interface you provide. There is not much of a problem with accessing SingletonKlass.instance the normal way, but if you really want to make a shortcut, the safest would be a constant:

KlassInstance = SingletonKlass.instance

If you want to define the constant dynamically, use Module#const_set:

const_set :KlassInstance, SingletonKlass.instance

You can extend upon this, too. For example, you can create a method that will create constants like this for you:

def singleton_constant(singleton_class)
  const_set singleton_class.name, singleton_class.instance
end

Of course, because Module#const_set is a method of a module, this specific technique can only be performed in the context of a module or class. Another possibility is by a mixin module with an overloaded hook method:

module SingletonInstance
  def included(base_class)
    const_set base_class.name, base_class.instance
    super
  end
end

edited Mar 16 '11 at 23:59

answered Mar 15 '11 at 02:53

Aaa

1,854
12
18

i thought of a global variable, but the constant is probably better. my scenario is that i want a module to be mixed-in to create the "singleton_no_instance" classes. how can i define global constants dynamically ? – ALoR Mar 15 '11 at 20:00
the const_set work if you specify it explicitly. how would you code it in a module to be mixed-in with a class and automatically create the alias and do the trick? thank you – ALoR Mar 16 '11 at 08:34
1

@ALoR: I updated my answer again. Being more specific about your problem would be very helpful: not in comments, but in the question description. – Aaa Mar 17 '11 at 00:00
This is so full of good ideas but doesn't all work as written. 1) You must define `self.included` instead of `included`. 2) To replace the constant, the original constant must be removed to avoid warning, and `const_set` must be called on `Object`, not `base_class`, or the new constant is namespaced under the original constant (e.g. `KlassInstance::KlassInstance`), though this only works for top-level constants. – Edward Anderson Mar 28 '18 at 23:43

score 1 · Answer 3 · answered Mar 17 '11 at 00:28

1

Here is an alternative that does not really fall under the scope of my first answer. You can create a mixin module that undefines all the methods of the base class and then uses the method_missing technique:

module SingletonRedirect
  def included(base_class)
    instance = base_class.instance
    base_class.class_eval do
      methods.each &undef_method

      define_method :method_missing do |name, *arguments|
        instance.public_send name, *arguments
      end
    end
  end
end

To implement the idea, instance is a local variable that is passed via closure to the blocks in the calls to Class#class_eval and Module#define_method. Then, we do not need to refer to it by base_class.instance, so we can clear out all the methods, including that one (a technique known as a blank slate). Then, we define a method redirection system that takes advantage of the flat scope to refer to instance as a variable and call only methods that are publicly available via Object#public_send.

answered Mar 17 '11 at 00:28

Aaa

1,854
12
18

I think "blank slate" is mentioned in the book "Metaprogramming Ruby". – Andrew Grimm Mar 17 '11 at 02:35
@Andrew Grimm: That's where I first heard the term! – Aaa Mar 17 '11 at 02:53
what are the advantage of clearing all the methods before the redirection over the solution proposed by @Andrew Grimm with the delegators? – ALoR Mar 17 '11 at 10:41
@ALoR: The two systems are about the same, but I know mine will forward any method call it receives because it has no methods of its own, whereas the delegator system only forwards method calls if the method was explicitly masked already by a delegator. Also, because my system forwards all calls dynamically, it is compatible with instances that use their own ghost methods (also from "Metaprogramming Ruby"; it means method behavior from overriding `method_missing`). – Aaa Mar 17 '11 at 23:35

score 0 · Answer 4 · answered Mar 28 '18 at 23:49

Instead of SingletonKlass, I'll use the name UrlHelper as a more concrete example.

require 'singleton'    

class UrlHelperSingleton
  include Singleton

  def my_method
     ...
  end
end

UrlHelper = UrlHelperSingleton.instance

# then elsewhere
UrlHelper.my_method

score -1 · Answer 5 · answered Mar 25 '11 at 18:39

-1

Why don't you use a "static" class? e.g.:

class StaticKlass

  class << self
    def method1; end
    def method2; end
    ...
    def methodN; end
  end

end

StaticKlass.method1

answered Mar 25 '11 at 18:39

Sony Santos

5,435
30
41

In my case, this doesn't work because my singleton `include`s a module. Unfortunately the module doesn't work with `extend` on another module like `StaticKlass`. – Edward Anderson Mar 28 '18 at 23:21

Calling a method of a Ruby Singleton without the reference of 'instance'

5 Answers5

Linked

Related