attr_accesor currently returns nil. It would be more helpful if it return list of generated methods so that it can become an argument to other methods like :private or :protected. That way private accessors can still be defined at top of the class and be private without changing the visibility of next methods.
class Something
private *attr_accessor :user, :action # IMHO This is nice
# private attr_accessor :user, :action # <-- would be even better if :private method accepted arrays
def initialize(user, action)
self.user = user
self.action = action
end
def public_method
user.do_something(action)
end
end
VS
class Something
private; attr_accessor :user, :action; public # IMHO Hack!!
def initialize(user, action)
self.user = user
self.action = action
end
def public_method
user.do_something(action)
end
end
VS
class Something
def initialize(user, action)
self.user = user
self.action = action
end
def public_method
user.do_something(action)
end
private
attr_accessor :user, :action # IMHO Does not look nice at bottom of the class definition
end
I want to access my private fields also via methods instead of directly via instance variables so refactoring in future is easier. For example instead of finding in class all occurrences of @var = something and changing them into either "@var = something.strip" or extracting it into setter, I already use the private setter defined with attr_accessor everywhere. That way I only need to change the setter implementation in one place and don't need to look for code setting instance variable because there is non such, only calls for the accessor.
So one can use the symmetric foo and foo= in the class, but only the getter would be public.
This is also useful to evolve foo= (e.g., to invalidate some caches if set) and add extra logic in it, without having to change all places from @foo = to self.foo =.
I reopen because I think not all relevant issues have been considered.
In general, I support this feature as it is a general and composable extension which enables many more things such as for def (decorators, debugging, concurrency, etc).
In general I support this request, but in this proposed use-case ...
attr_reader:fooprivateattr_writer:foo
So one can use the symmetric foo and foo= in the class, but only the getter would be public.
This is also useful to evolve foo= (e.g., to invalidate some caches if set) and add extra logic in it, without having to change all places from @foo = to self.foo =.
foo= without @ or self. will assign a local variable. You'd have to change it to foo=(...) or send :foo=, ... anyway, no?
There's no use for private attr_reader, attr_writer, etc.
The intended usage is to ease future refactorings. If you always start with a method then later you can easily redefine just the method.
Initial code
class Something
private attr_accessor :x, :y
def something(a)
self.x = a + y
end
end
Code after refactoring:
class Something
private attr_accessor :y
private attr_reader :x
def something(a)
self.x = a + y
end
private
def x=(new_value)
@x_set_at = Time.now
@x = new_value
end
Notice that nothing setting @x had to be refactored because @x variable was always changed via the self.x= setter.
So when the time comes and cache expiration or additional logic needs to be added, makes it easy to just redefine the setter or getter with additional logic.
That's why I always prefer to use private accessors instead of instance variables. They are more flexible.
Updated by 
Updated by 
Updated by 
Updated by 
Updated by 
Updated by 
Updated by 
Updated by 
Updated by 
Updated by 
Updated by