Getting 'instance' variable from parent metaclass

Here is your code, slightly modified.

class Parent
  def self.create_singleton_variable
    @arr = [1,2,3]
  end 
  def self.arr
    puts "self = #{self} in the getter for @arr"
    @arr
  end
end

class Child < Parent
  def get
    puts self.arr
  end
  def self.get 
    puts self.arr
  end
end

I have written Parent in the more conventional way. Except for the addition of the puts statement, it is equivalent to that contained in the question.

First, a head-slapper: Kernel#puts-anything returns nil. You need to remove puts from both methods:

class Child < Parent
  def get
    self.arr
  end
  def self.get 
    self.arr
  end
end

Parent.create_singleton_variable
  #=> [1, 2, 3] 
Child.get.nil?
self = Child in the getter for @arr
  #=> true

We see that within the getter arr, invoked by Child's class method get, self equals Child, so the method looks for a class instance variable @arr of Child not of Parent. As no such instance variable has been initialized, nil is returned.

You need the following.

class Parent
  class << self
    def create_singleton_variable
      @arr = [1,2,3]
    end
    def arr
      puts "self = #{self} in the getter for @arr"
      @arr
    end
  end
end

class Child < Parent
  def get
    self.class.superclass.arr
  end
  def self.get 
    superclass.arr
  end
end

The crucial difference to that given in the question is that Class#superclass changes the scope (i.e., self) to Parent.

We see the desired result is obtained.

Child.get
self = Parent in the getter for @arr
  #=> [1, 2, 3] 

Child.new.class.superclass.arr
self = Parent in the getter for @arr
  #=> [1, 2, 3] 

A common misconception is that the Child class method defined def self.get; self.arr; end invokes the getter Parent::arr, and therefore returns the value of Parent's instance variable @arr. It is Child::arr that is invoked, however, that method having been inherited from Parent, and it is Child's class instance variable @arr that is being retrieved, a subtle, but important, distinction.

Edit 2

The first observation is that Parent can be written in the more conventional (and completely equivalent) way.

class Parent
  def self.create_singleton_variable
    @arr = [1,2,3]
    puts "arr is initialized #{@arr}"
  end

  def self.arr
    puts "arr is #{@arr.inspect}"
    @arr
  end
end

Regardless of how its written, self will equal Parent when either class method is involked on parent. The first, therefore, will create the class instance variables @arr.

Parent.methods(false)
  #=> [:create_singleton_variable, :arr] 
Parent.instance_variables
  #=> []
Parent.ancestors
  #=> [Parent, Object, Kernel, BasicObject] 

Now let's create a class variable for Parent.

Parent.create_singleton_variable
  # arr is initialized [1, 2, 3]
Parent.instance_variables
  #=> [:@arr]

Now let me change the value of @arr.

Parent.instance_variable_set(:@arr, ['dog', 'cat'])
  #=> ["dog", "cat"]
Parent.arr
  # arr is ["dog", "cat"]
  #=> ["dog", "cat"] 

Next, create the class Child, but do not yet prepend the module.

class Child < Parent
  create_singleton_variable
  arr
end
arr is initialized [1, 2, 3]
arr is [1, 2, 3]

Child.ancestors
  #=> [Child, Parent, Object, Kernel, BasicObject]
Child.instance_variables
  #=> [:@arr] 
Child.instance_variable_get(:@arr)
  #=> [1, 2, 3] 

There are no surprises. Next load the module.

module CompletionGeneration
  def self.prepended(base)
    base.singleton_class.prepend(ClassMethods)
  end

  module ClassMethods
    def completion
      puts "self=#{self}"
      puts "superclass=#{superclass}"
      puts "self.class=#{self.class}"
      puts "self.class.superclass == #{self.class.superclass}" 
      puts "superclass.arr == #{superclass.arr.inspect}"
      puts "self.class.superclass.arr == #{self.class.superclass.arr}" 
      rescue Exception => e
        # do nothing, this is just so you can see arr is actually
        # initialized in the context of the Child
        puts "Exception => e=#{e}"
    end
  end
end

(Note self. is not needed in "superclass.arr == #{superclass.arr.inspect}") Now prepend this module to Parent.

Parent.prepend CompletionGeneration

Parent.ancestors
  #=> [CompletionGeneration, Parent, Object, Kernel, BasicObject] 
Parent.methods.include?(:completion)
  #=> true 
Child.ancestors
  #=> [Child, CompletionGeneration, Parent, Object, Kernel, BasicObject] 
Child.methods.include?(:completion)
  #=> true 

The callback modules method CompletionGeneration::prepended is fired with base equal to Parent, causing Parent's singleton class to prepend ClassMethods, thereby adding the class method Parent::completion. Since Parent did not previously have a method by that name using prepend or include would have the same effect. Further, instead of Parent.singleton_class.include ClassMethods, one could have used the included(base) callback instead, and executed Parent.extend ClassMethods. Perhaps prepend is being used here for a general case where Parent may have a class method by that name.¹

Now execute the following.

Child.completion
self=Child
superclass=Parent
self.class=Class
self.class.superclass == Module
arr is ["dog", "cat"]
superclass.arr == ["dog", "cat"]
Exception => e=undefined method `arr' for Module:Class

The exception was raised when

puts "self.class.superclass.arr == #{self.class.superclass.arr}"

was being executed. As that amounts to

puts "self.class.superclass.arr == #{Module.arr}"

but of course Module has no module method arr.

^{1 In view of Child.ancestors, prepending Parent with the module only causes Parent's children to include (rather than prepend) the module; that is, if a child already has a method completion before the prepending, that method will not be preempted by the the module's method by the same name.}