Ruby: Retrieve local variable from class

The question seems to boil down to this: given the following:

class A
  attr_reader :instance_var
  def initialize
    @instance_var = (@instance_var ||= 0) + 1
    instance_local_var = 33
    puts "instance_local_variables = #{ local_variables }"
    instance_local_var = 33
  end
  class_local_var = 3
  puts "class_local_variables = #{ local_variables }"
  class_local_var = 3
end
  # class_local_variables = [:class_local_var]
  #=> 3

can one determine the values of instance_local_var and class_local_var?

Determine the value of class_local_var

The answer to this question is clearly "no" because class_local_var no longer exists (has been marked for garbage collection) after end is executed¹:

A.send(:local_variables)
  #=> []

Determine the value of instance_local_var

a = A.new
  # instance_local_variables = [:instance_local_var]
  #=> #<A:0x007ff3ea8dbb80 @instance_var=1> 

Note that @instance_var #=> 1.

A.new does not return the value of instance_local_var, but because that variable is assigned a value in the last line of initialize, that value can be obtained by executing initialize once again.²

instance_local_var = a.send(:initialize)
  #=> 33

There is a problem, however:

a.instance_var
  #=> 2

Executing initialize a second time has caused an unwanted side effect. My definition of initialize is artificial, but it highlights the fact that many undesirable side effects could occur by executing initialize a second time.

Now let's obtain a new instance.

b = A.new
  # instance_local_variables = [:instance_local_var]
  #=> #<A:0x007fee0996e7c8 @instance_var=1>

Again, @instance_var=1. One possible workaround to the side-effects of calling initialize twice for a given instance is to subclass A and use super.

class B < A
  attr_reader :b
  def initialize
    @b = super
  end
end

B.new.b
  #=> 33
a.instance_var
  #=> 1

There is no guarantee that undesirable side-effects can be avoided with this approach (e.g., initialize for any instance may perform a database operation that should occur only once), but it appears to leave the initial instance a unaffected. This is of course all hypothetical.

^{1. send must be used because A.private_methods.include?(:local_variables) #=> true}

^{2. A.new.send(:initialize) is required because iniitialize is private.}

Your question is unclear. In the title, you write "local variables", but in the example, you mention only instance- and class-variables.

As for the instance variables, you can use Object#instance_variables to get a list of known instance variables at this point. Note however that instance variables are created dynamically, not at the time of class declaration. For example, given the class

class AA; 
  def initialize; @x=1; end; 
  def f; @y=1; end; 
end

the expression

AA.new.instance_variables

would return [:@x] - the :@y is missing, because it doesn't exist yet.

You don't have a way to automatically (i.e. without modifying the class) retrieve local variables. As mudasobwa explained in his answer, you would have to explictly pass back a binding.

One might get an access to all the local variables of the class by returning it’s binding from the class definition (see Binding#local_variables for details):

a = class A
  v1 = 3.14
  v2 = 42
  binding
end

a.local_variable_get(:v1)
#⇒ 3.14
a.local_variable_get(:v2)
#⇒ 42

But the main question is why would you want to do that? The local variable is meant to remain local. This is how it is supposed to behave. Also, one is unable to modify the local variable in the original binding (what is returned is a read-only copy of an original binding.)