Što rade attr_accessor, attr_reader i attr_writer?

Question

Accepted Answer

Ovo su Ruby metode koje **automatski generiraju getter i/ili setter metode** za instance varijable — eliminirajući boilerplate kod. Budući da su instance varijable (`@name`) privatne i nisu direktno dostupne izvan objekta, trebate accessor metode za čitanje/pisanje, a `attr_*` ih generiše sažeto.

## Problem koji rešavaju

```ruby
# ❌ without attr_* — manually writing getters/setters (tedious boilerplate)
class Person
  def initialize(name)
    @name = name
  end
  def name           # manual getter
    @name
  end
  def name=(value)   # manual setter
    @name = value
  end
end
```

## Tri generatora pristupa

```ruby
class Person
  attr_reader :name      # generates a GETTER only (read-only): person.name
  attr_writer :email     # generates a SETTER only (write-only): person.email = ...
  attr_accessor :age     # generates BOTH getter and setter: person.age / person.age = ...

def initialize(name, age)
    @name = name
    @age = age
  end
end

person = Person.new("Ann", 30)
person.name        # "Ann" — reader
person.age = 31     # writer
person.age          # 31 — reader
person.name = "X"   # ❌ NoMethodError — name is read-only (attr_reader, no setter)
```

- **`attr_reader`** → getter samo (pristup samo za čitanje).
- **`attr_writer`** → setter samo (pristup samo za pisanje).
- **`attr_accessor`** → oba, getter i setter (pristup za čitanje i pisanje).

Svaka prima simbole koji imenuju instance varijable i automatski generiše odgovarajuće metode — jedan red zamenjuje nekoliko ručnih definicija metoda.

## Odabir odgovarajućeg (enkapsulacija)

```ruby
class BankAccount
  attr_reader :balance     # ✅ balance is readable but NOT directly settable (protect it)

def initialize
    @balance = 0
  end
  def deposit(amount)       # changes go through a controlled method, not a raw setter
    @balance += amount if amount > 0
  end
end
```

Odabir `attr_reader` (umesto `attr_accessor`) za polja koja se ne bi trebala proizvolj postavljati iz spoljašnjosti je dobra enkapsulacija — izlaž samo pristup koji namераваш.

## Zašto je važno

Razumevanje `attr_accessor`/`attr_reader`/`attr_writer` je fundamentalno svakodnevno Ruby znanje, jer se pojavljuju u gotovo svakoj Ruby klasi.

Osnovni razlog zašto postoje: instance varijable (`@name`) su **privatne i nisu direktno dostupne** izvan objekta, zato vam trebaju accessor metode da čitate ili pišete — i pisanje tih gettera/settera ručno za svaki atribut je dosadan boilerplate kod.

Ove metode **automatski generišu accessore** (`attr_reader` za samo čitanje, `attr_writer` za samo pisanje, `attr_accessor` za oba), zamenjujući nekoliko definicija metoda jednom sažetom linijom — karakteristika Ruby elegancije i sažetosti.

Razumevanje šta svaka generiše i **odabir odgovarajuće** je takođe pitanje dobra **enkapsulacija**: korišćenje `attr_reader` (samo čitanje) za polja koja se ne bi trebala proizvoljno menjati iz spoljašnjosti, i `attr_accessor` samo gde je pristup za čitanje-pisanje stvarno namenjen, kontroliše kako je stanje objekta izloženo (npr. čini stanje blagajne čitljivim ali samo promenljivim kroz kontrolisane metode).

Budući da su ovi accessori sveprisutni u Ruby klasama (i Rails modelima), znanje kako rade, šta svaka generiše, i kako odabrati za odgovarajuću enkapsulaciju je neophodno, nezamenljivo znanje za pisanje i čitanje Ruby klasa — to je jedno od prvih stvari sa kojima se susrećete pri definisanju Ruby klasa i odražava pristup jezika sažetim, izrazitim rešenjima za čestu potrebu (kontrolisani pristup stanju objekta).