Making a class instance variable unwritable from outside world - ruby

Question

class Event
#event_list = {}
attr_reader :name, :value
def initialize(name, value)
#name = name
#value = value
end
def to_s
"#{#value}"
end
class << self
def event_list
#event_list
end
def event_list=(value); end
def register_event(name, value)
#event_list[name] = Event.new(name, value)
end
def registered_events
event_list
end
end
end
In the above code snippet I can access #event_list using Event.event_list, interesting thing is I am able to modify this variable from outside
Event.event_list[:name] = "hello"
Event.event_list # => { :name => 'hello' }
How can I avoid this ?, I don't want to modify #event_list from outside.

Answer 1

As far as I know, you can't stop outside code from modifying your instance variables in Ruby. Even if you don't use attr_reader and attr_writer it can still be accessed using Object#instance_variable_set. Ruby doesn't have private variables (or constants), only variables that you are politely asked not to modify.
If you don't define event_list=, that is seen as an indication that #event_list is a private variable. This is the solution to your problem.
Then there is the problem with mutable objects. Since almost all objects in Ruby sadly are mutable, usually if you can just get a reference to an object then you can change it.
This can be solved with Object#freeze which stops an object from being modified. Unfortunately this means that not even you can modify it.
Ruby is simply not very good for locking things down. This openness is a core part of the language that you probably need to learn to work with.

Answer 2

As others have said, just make the methods private:
class Event
#event_list = {a: 'dog'}
class << self
def pub_event_list
#event_list
end
def pub_event_list=(other)
#event_list=other
end
private
def event_list
#event_list
end
def event_list=(value)
#event_list = value
end
end
end
Event.event_list
#=> NoMethodError: private method `event_list' called for Event:Class
Event.pub_event_list
#=> {:a=>"dog"}
Event.event_list= {b: 'cat'}
#=> #NoMethodError: private method `event_list=' called for Event:Class
Event.pub_event_list= {b: 'cat'}
#=> {:b=>"cat"}

Answer 3

You are defining def event_list on your singleton which is providing access to the variable. Make that method private
EDIT:
When you are declaring #event_list it has scope in your singleton methods.
class Event
#event_list = {}
class << self
def event_list
# scoped from above
#event_list
end
end
end
Event.event_list #=> {}
To remove access simply make the method private:
class Event
#event_list = {}
class << self
private
def event_list
# scoped from above
#event_list
end
end
end
Event.event_list #=> NoMethodError: private method `event_list' called for Event:Class

Answer 4

Here is what I done for now, I don't know if it is a good solution
class Event
#event_list = {}
attr_reader :name, :value
def initialize(name, value)
#name = name
#value = value
end
def to_s
"#{#value}"
end
class << self
def register_event(name, value)
#event_list = #event_list.merge(name => Event.new(name, value))
end
def registered_events
#event_list.freeze
end
end
end
Now I can access #event_list without letting others to modify.