Wraz z dodaniem partial updates pojawila sie nowa funkcjonalnosc w Rails 2.1 mianowicie sledzenie zmian konkretnych atrybutow, jednak samo sledzenie nie wystarcza, przydalo by sie jakies pretty print. Oto co na dzisiejszym kacu stworzylem:P
class ConfigurationItem < ActiveRecord::Base
def print_changes
columns_hash = ConfigurationItem.columns_hash
result = []
self.changes.each do |attribute_name,change|
unless [:created_at, :updated_at].include?(attribute_name)
if ref = ConfigurationItem.reflect_on_all_associations.find { |mr| mr.options[:foreign_key] == attribute_name }
klass = ref.options[:class_name].constantize
real_attribute_name = ref.name
old_value = klass.find_by_id(change.first).fullname(false) rescue nil
new_value = klass.find_by_id(change.last).fullname(false) rescue nil
else
if columns_hash[attribute_name.to_s].type == :date
old_value = (change.first.blank? ? nil : change.first.to_s(:db_date))
new_value = (change.last.blank? ? nil : change.last.to_s(:db_date))
elsif columns_hash[attribute_name.to_s].type == :datetime
old_value = (change.first.blank? ? nil : change.first.to_s(:db_noseconds))
new_value = (change.last.blank? ? nil : change.last.to_s(:db_noseconds))
else
old_value = (change.first.blank? ? nil : change.first)
new_value = (change.last.blank? ? nil : change.last)
end
real_attribute_name = attribute_name
end
real_attribute_name = real_attribute_name.to_s.gsub(/(^|_)(.)/) { " #{$2.upcase}" }
if columns_hash[attribute_name.to_s].type == :boolean
result << "Changed %s to `%s`" % [real_attribute_name, (new_value ? 'true' : 'false')]
else
if old_value && new_value
result << "Changed %s from `%s` to `%s`" % [real_attribute_name, old_value, new_value]
elsif !old_value && new_value
result << "Added %s `%s`" % [real_attribute_name, new_value]
else
result << "Removed %s `%s`" % [real_attribute_name, old_value]
end
end
end
end
result.join("\n") unless result.empty?
end
end
Kod moze nie jest cudowny i nie ma sie czym tak naprawde zachwycac ale dziala bardzo fajnie. Wymagane jest jednak aby kazdy model z asocjacji posiadal metode fullname ktora zwroci jego pelnal nazwe, moze to byc tez wlasna implementacja to_s. Chodzi o te dwie linijki:
old_value = klass.find_by_id(change.first).fullname(false) rescue nil
new_value = klass.find_by_id(change.last).fullname(false) rescue nil
A tak wyglada to w akcji:
A tutaj cos dla tych ktorzy tak jak ja musza jeszcze siedziec w rails 1.2.X port changes (bez without dirty updates) dla tej walsnie wersji rails
[code]module ActiveRecord
Track unsaved attribute changes.
A newly instantiated object is unchanged:
person = Person.find_by_name(‘uncle bob’)
person.changed? # => false
Change the name:
person.name = ‘Bob’
person.changed? # => true
person.name_changed? # => true
person.name_was # => ‘uncle bob’
person.name_change # => [‘uncle bob’, ‘Bob’]
person.name = ‘Bill’
person.name_change # => [‘uncle bob’, ‘Bill’]
Save the changes:
person.save
person.changed? # => false
person.name_changed? # => false
Assigning the same value leaves the attribute unchanged:
person.name = ‘Bill’
person.name_changed? # => false
person.name_change # => nil
Which attributes have changed?
person.name = ‘bob’
person.changed # => [‘name’]
person.changes # => { ‘name’ => [‘Bill’, ‘bob’] }
Before modifying an attribute in-place:
person.name_will_change!
person.name << ‘by’
person.name_change # => [‘uncle bob’, ‘uncle bobby’]
module Dirty
def self.included(base)
base.attribute_method_suffix ‘_changed?’, ‘_change’, ‘_will_change!’, ‘_was’
base.alias_method_chain :write_attribute, :dirty
base.alias_method_chain :save, :dirty
base.alias_method_chain :save!, :dirty
base.alias_method_chain :update, :dirty
end
# Do any attributes have unsaved changes?
# person.changed? # => false
# person.name = ‘bob’
# person.changed? # => true
def changed?
!changed_attributes.empty?
end
# List of attributes with unsaved changes.
# person.changed # => []
# person.name = ‘bob’
# person.changed # => [‘name’]
def changed
changed_attributes.keys
end
# Map of changed attrs => [original value, new value]
# person.changes # => {}
# person.name = ‘bob’
# person.changes # => { ‘name’ => [‘bill’, ‘bob’] }
def changes
changed.inject({}) { |h, attr| h[attr] = attribute_change(attr); h }
end
# Clear changed attributes after they are saved.
def save_with_dirty(*args) #:nodoc:
save_without_dirty(*args)
ensure
changed_attributes.clear
end
# Clear changed attributes after they are saved.
def save_with_dirty!(*args) #:nodoc:
save_without_dirty!(*args)
ensure
changed_attributes.clear
end
def self.partial_updates?
@partial_updates
end
private
# Map of change attr => original value.
def changed_attributes
@changed_attributes ||= {}
end
# Handle *_changed? for method_missing.
def attribute_changed?(attr)
changed_attributes.include?(attr)
end
# Handle *_change for method_missing.
def attribute_change(attr)
[changed_attributes[attr], __send__(attr)] if attribute_changed?(attr)
end
# Handle *_was for method_missing.
def attribute_was(attr)
attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
end
# Handle *_will_change! for method_missing.
def attribute_will_change!(attr)
changed_attributes[attr] = clone_attribute_value(:read_attribute, attr)
end
# Wrap write_attribute to remember original attribute value.
def write_attribute_with_dirty(attr, value)
attr = attr.to_sym
# The attribute already has an unsaved change.
unless changed_attributes.include?(attr)
old = clone_attribute_value(:read_attribute, attr)
# Remember the original value if it's different.
typecasted = if column = column_for_attribute(attr)
column.type_cast(value)
else
value
end
changed_attributes[attr] = old unless old == typecasted
end
# Carry on.
write_attribute_without_dirty(attr, value)
end
def update_with_dirty
update_without_dirty
end
end
end
ActiveRecord::Base.send :include, ActiveRecord::Dirty[/code]
