classe Aggiornamento Rubino attribuisce hash quando una proprietà cambia

Question

Sto cercando di scrivere una classe di Ruby che funziona in modo simile al modello di Rails AactiveRecord nel modo in cui vengono gestiti gli attributi:

class Person 
    attr_accessor :name, :age 

    # init with Person.new(:name => 'John', :age => 30) 
    def initialize(attributes={}) 
    attributes.each { |key, val| send("#{key}=", val) if respond_to?("#{key}=") } 
    @attributes = attributes 
    end 

    # read attributes 
    def attributes 
    @attributes 
    end 

    # update attributes 
    def attributes=(attributes) 
    attributes.each do |key, val| 
     if respond_to?("#{key}=") 
     send("#{key}=", val) 
     @attributes[key] = name 
     end 
    end 
    end 
end 

Quello che voglio dire è che quando ho init della classe, un "attributi" hash viene aggiornato con i relativi attributi:

>>> p = Person.new(:name => 'John', :age => 30) 
>>> p.attributes 
=> {:age=>30, :name=>"John"} 
>>> p.attributes = { :name => 'charles' } 
>>> p.attributes 
=> {:age=>30, :name=>"charles"} 

Fin qui tutto bene. Quello che voglio che accada è per gli attributi di hash per aggiornare quando ho impostato una proprietà individuale:

>>> p.attributes 
=> {:age=>30, :name=>"John"} 
>>> p.name 
=> "John" 
>>> p.name = 'charles' # <--- update an individual property 
=> "charles" 
>>> p.attributes 
=> {:age=>30, :name=>"John"} # <--- should be {:age=>30, :name=>"charles"} 

potevo farlo scrivendo un setter e getter per ogni attributo invece di utilizzare attr_accessor, ma che ti succhiano per un modello che ha molti campi. Qualche modo veloce per realizzare questo?

Answer 1

Il problema è che si mantengono gli attributi sia come ivars separati, sia all'interno di un hash @attributes. Dovresti scegliere e usare solo un modo.

Se si desidera utilizzare un hash, si dovrebbe rendere il vostro modo di creare funzioni di accesso, che avrebbe "reindirizzare" loro di un unico metodo che impostare e ottenere da un hash:

class Class 
def my_attr_accessor(*accessors) 
    accessors.each do |m| 

    define_method(m) do 
     @attributes[m] 
    end   

    define_method("#{m}=") do |val| 
     @attributes[m]=val 
    end 
    end 
end 
end 

class Foo 
    my_attr_accessor :foo, :bar 

    def initialize 
    @attributes = {} 
    end 
end 

foo = Foo.new 

foo.foo = 123 
foo.bar = 'qwe' 
p foo 
#=> #<Foo:0x1f855c @attributes={:foo=>123, :bar=>"qwe"}> 

Se vuoi usare ivars, dovresti, ancora, lanciare il tuo metodo attr_accessor che dovrebbe, inoltre, ricordare quali ivars dovrebbero essere "attributi", e usare quell'elenco nel metodo attributes. E il metodo attributes creerebbe un hash al volo e lo restituirà.

Here è possibile trovare un bell'articolo sull'implementazione degli accessor.