Is it right to use @variable in class scope in Ruby?

A Ruby object is:

1. Data - A map of instance variable and the values associated. Note that instance variables are private to the instance itself.
2. Behavior - A pointer to a class where the methods this instance responds to are defined. Note methods may be inherited from parent class.

Class is an object in Ruby. By writing:

class Foo
  @bar = 8
  def self.get_bar
    @bar
  end
end

You get the following data model (not exactly, the hierarchy of Foo's ancestors and their eigen classes have been removed):

                             Class
                               |
Foo        class ptr    [eigenclass of Foo]
@bar = 8   --------->   method - get_bar 

The instance variable at class scope defines the private data for that class object. From the model above, this instance variable is accessible through instance methods defined in the eigenclass of Foo, and in its ancestor chain Class, Module, Object, Kernel, BasicObject. These instance variables defined some data associated with the class object Foo.

By writing:

class FooChild < Foo
end

You have

                             Class
                               |
Foo         class ptr    [eigenclass of Foo]
@bar = 8    --------->   method - get_bar
    |                          |
FooChild    class ptr    [eigenclass of FooChild]
<Nothing>   --------->   <Nothing>

Class object FooChild inherits the method get_bar from the eigen class of Foo, so you can call FooChild.get_bar. However, since the receiver is FooChild, and no instance variable @bar is associated with FooChild, the default value nil will be returned.

The above analysis is more detailed in the book Meta-programming Ruby.

Class variable (@@bar2), IMO is a scoped variable with strange resolving order. By refering @@bar2 in Foo's class scope, it will lookup in the ancestor chain of Foo for the definition of @@bar2, FROM TOP TO BOTTOM. So it will first lookup in BasicObject, then Kernel, then Object, and finally Foo.

Have a play with the following example:

class Foo
  @@bar = 1
  def self.show
    puts @@bar
  end
end

Foo.show  #=> 1

class Object
  @@bar = "hahaha"
end

Foo.show  #=> hahaha

Instance variable defined inside the class but outside an instance method called also class instance variable.

Advantage of using class instance variables vs class variables is when you use inheritance. You can use class instance variables in subclasses as well, but it's looks confusing.

It's not exactly an inheritance. Ruby implementation is a little bit tricky. Instance variables in Ruby are created when value assignment happens.

Any subclass can alter the value of shared class variable but class instance variable will be created for particular class only. So pay attention on what behaviour you need for variables in your class.

Disadvantage of class instance variables comparing to class variables is they cannot be used inside instance methods. And in addition to it you can confuse them with regular instance variables.

  class Foo
    @class_instance_var_1 = 0
    @class_instance_var_2 = 0
    @@class_var = 10

    def initialize
      @class_instance_var_1 = 1 # cannot change it here
      @@class_var = 100
    end

    def self.change
      @class_instance_var_2 = 2 # can change here
      @@class_var = 200
    end

    def self.echo_var
      p 'class_instance_var_1=' + @class_instance_var_1.to_s
      p 'class_instance_var_2=' + @class_instance_var_2.to_s
      p 'class_var=' + @@class_var.to_s
    end
  end

  puts '--- initial status of Foo'
  Foo.echo_var
  puts '--- initialized Foo'
  Foo.new
  Foo.echo_var
  puts '--- changed Foo'
  Foo.change
  Foo.echo_var

  class Foo2 < Foo
    @class_instance_var_2 = 22 # can set here only but not in Foo
    @@class_var = 20 # can change here and everywhere
  end

  puts '--- after Foo2 implementation'
  puts '--- Foo'
  Foo.echo_var
  puts '--- Foo2'
  Foo2.echo_var

  class Foo3 < Foo2
    @class_instance_var_2 = 33 # can set here only but not in Foo
    @@class_var = 30 # can change here and everywhere
  end

  puts '--- after Foo3 implementation'
  puts '--- Foo'
  Foo.echo_var
  puts '--- Foo2'
  Foo2.echo_var
  puts '--- Foo3'
  Foo3.echo_var

Outputs this

--- initial status of Foo
"class_instance_var_1=0"
"class_instance_var_2=0"
"class_var=10"
--- initialized Foo
"class_instance_var_1=0"
"class_instance_var_2=0"
"class_var=100"
--- changed Foo
"class_instance_var_1=0"
"class_instance_var_2=2"
"class_var=200"
--- after Foo2 implementation
--- Foo
"class_instance_var_1=0"
"class_instance_var_2=2"
"class_var=20"
--- Foo2
"class_instance_var_1="
"class_instance_var_2=22"
"class_var=20"
--- after Foo3 implementation
--- Foo
"class_instance_var_1=0"
"class_instance_var_2=2"
"class_var=30"
--- Foo2
"class_instance_var_1="
"class_instance_var_2=22"
"class_var=30"
--- Foo3
"class_instance_var_1="
"class_instance_var_2=33"
"class_var=30"