From e86d1cd621ca62af6f71b04032b1e07a66c06bb6 Mon Sep 17 00:00:00 2001 From: David Heinemeier Hansson Date: Thu, 20 Sep 2007 23:22:30 +0000 Subject: Added ActiveRecord::Base#to_json/from_json (currently does not support :include like to_xml) [DHH]. Added ActiveRecord::Base#from_xml [DHH] git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@7519 5ecf4fe2-1ee6-0310-87b1-e25e094e27de --- activerecord/lib/active_record.rb | 4 +- .../associations/association_collection.rb | 3 +- activerecord/lib/active_record/serialization.rb | 59 ++++ .../active_record/serializers/json_serializer.rb | 18 ++ .../active_record/serializers/xml_serializer.rb | 327 ++++++++++++++++++++ .../lib/active_record/xml_serialization.rb | 340 --------------------- 6 files changed, 408 insertions(+), 343 deletions(-) create mode 100644 activerecord/lib/active_record/serialization.rb create mode 100644 activerecord/lib/active_record/serializers/json_serializer.rb create mode 100644 activerecord/lib/active_record/serializers/xml_serializer.rb delete mode 100644 activerecord/lib/active_record/xml_serialization.rb (limited to 'activerecord/lib') diff --git a/activerecord/lib/active_record.rb b/activerecord/lib/active_record.rb index f1585d640b..73f5229753 100755 --- a/activerecord/lib/active_record.rb +++ b/activerecord/lib/active_record.rb @@ -49,7 +49,7 @@ require 'active_record/locking/pessimistic' require 'active_record/migration' require 'active_record/schema' require 'active_record/calculations' -require 'active_record/xml_serialization' +require 'active_record/serialization' require 'active_record/attribute_methods' ActiveRecord::Base.class_eval do @@ -65,7 +65,7 @@ ActiveRecord::Base.class_eval do include ActiveRecord::Transactions include ActiveRecord::Reflection include ActiveRecord::Calculations - include ActiveRecord::XmlSerialization + include ActiveRecord::Serialization include ActiveRecord::AttributeMethods end diff --git a/activerecord/lib/active_record/associations/association_collection.rb b/activerecord/lib/active_record/associations/association_collection.rb index 460f410cf0..66ee712d7d 100644 --- a/activerecord/lib/active_record/associations/association_collection.rb +++ b/activerecord/lib/active_record/associations/association_collection.rb @@ -158,6 +158,7 @@ module ActiveRecord end end + protected def method_missing(method, *args, &block) if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method)) @@ -218,4 +219,4 @@ module ActiveRecord end end -end +end \ No newline at end of file diff --git a/activerecord/lib/active_record/serialization.rb b/activerecord/lib/active_record/serialization.rb new file mode 100644 index 0000000000..f10d1b3b7e --- /dev/null +++ b/activerecord/lib/active_record/serialization.rb @@ -0,0 +1,59 @@ +module ActiveRecord #:nodoc: + module Serialization + class Serializer #:nodoc: + attr_reader :options + + def initialize(record, options = {}) + @record, @options = record, options.dup + end + + # To replicate the behavior in ActiveRecord#attributes, + # :except takes precedence over :only. If :only is not set + # for a N level model but is set for the N+1 level models, + # then because :except is set to a default value, the second + # level model can have both :except and :only set. So if + # :only is set, always delete :except. + def serializable_attribute_names + attribute_names = @record.attribute_names + + if options[:only] + options.delete(:except) + attribute_names = attribute_names & Array(options[:only]).collect { |n| n.to_s } + else + options[:except] = Array(options[:except]) | Array(@record.class.inheritance_column) + attribute_names = attribute_names - options[:except].collect { |n| n.to_s } + end + + attribute_names + end + + def serializable_method_names + Array(options[:methods]).inject([]) do |method_attributes, name| + method_attributes << :name if @record.respond_to?(name.to_s) + method_attributes + end + end + + def serializable_names + serializable_attribute_names + serializable_method_names + end + + def serializable_record + returning(serializable_record = {}) do + serializable_names.each { |name| serializable_record[name] = @record.send(name) } + end + end + + def serialize + # overwrite to implement + end + + def to_s(&block) + serialize(&block) + end + end + end +end + +require 'active_record/serializers/xml_serializer' +require 'active_record/serializers/json_serializer' \ No newline at end of file diff --git a/activerecord/lib/active_record/serializers/json_serializer.rb b/activerecord/lib/active_record/serializers/json_serializer.rb new file mode 100644 index 0000000000..97025ae4d3 --- /dev/null +++ b/activerecord/lib/active_record/serializers/json_serializer.rb @@ -0,0 +1,18 @@ +module ActiveRecord #:nodoc: + module Serialization + def to_json(options = {}, &block) + JsonSerializer.new(self, options).to_s + end + + def from_json(json) + self.attributes = ActiveSupport::JSON.decode(json) + self + end + + class JsonSerializer < ActiveRecord::Serialization::Serializer #:nodoc: + def serialize + serializable_record.to_json + end + end + end +end diff --git a/activerecord/lib/active_record/serializers/xml_serializer.rb b/activerecord/lib/active_record/serializers/xml_serializer.rb new file mode 100644 index 0000000000..1e4101f183 --- /dev/null +++ b/activerecord/lib/active_record/serializers/xml_serializer.rb @@ -0,0 +1,327 @@ +module ActiveRecord #:nodoc: + module Serialization + # Builds an XML document to represent the model. Some configuration is + # availble through +options+, however more complicated cases should use + # override ActiveRecord's to_xml. + # + # By default the generated XML document will include the processing + # instruction and all object's attributes. For example: + # + # + # + # The First Topic + # David + # 1 + # false + # 0 + # 2000-01-01T08:28:00+12:00 + # 2003-07-16T09:28:00+1200 + # Have a nice day + # david@loudthinking.com + # + # 2004-04-15 + # + # + # This behavior can be controlled with :only, :except, + # :skip_instruct, :skip_types and :dasherize. The :only and + # :except options are the same as for the #attributes method. + # The default is to dasherize all column names, to disable this, + # set :dasherize to false. To not have the column type included + # in the XML output, set :skip_types to true. + # + # For instance: + # + # topic.to_xml(:skip_instruct => true, :except => [ :id, :bonus_time, :written_on, :replies_count ]) + # + # + # The First Topic + # David + # false + # Have a nice day + # david@loudthinking.com + # + # 2004-04-15 + # + # + # To include first level associations use :include + # + # firm.to_xml :include => [ :account, :clients ] + # + # + # + # 1 + # 1 + # 37signals + # + # + # 1 + # Summit + # + # + # 1 + # Microsoft + # + # + # + # 1 + # 50 + # + # + # + # To include any methods on the object(s) being called use :methods + # + # firm.to_xml :methods => [ :calculated_earnings, :real_earnings ] + # + # + # # ... normal attributes as shown above ... + # 100000000000000000 + # 5 + # + # + # To call any Proc's on the object(s) use :procs. The Proc's + # are passed a modified version of the options hash that was + # given to #to_xml. + # + # proc = Proc.new { |options| options[:builder].tag!('abc', 'def') } + # firm.to_xml :procs => [ proc ] + # + # + # # ... normal attributes as shown above ... + # def + # + # + # Alternatively, you can also just yield the builder object as part of the to_xml call: + # + # firm.to_xml do |xml| + # xml.creator do + # xml.first_name "David" + # xml.last_name "Heinemeier Hansson" + # end + # end + # + # + # # ... normal attributes as shown above ... + # + # David + # Heinemeier Hansson + # + # + # + # You may override the to_xml method in your ActiveRecord::Base + # subclasses if you need to. The general form of doing this is + # + # class IHaveMyOwnXML < ActiveRecord::Base + # def to_xml(options = {}) + # options[:indent] ||= 2 + # xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent]) + # xml.instruct! unless options[:skip_instruct] + # xml.level_one do + # xml.tag!(:second_level, 'content') + # end + # end + # end + def to_xml(options = {}, &block) + serializer = XmlSerializer.new(self, options) + block_given? ? serializer.to_s(&block) : serializer.to_s + end + + def from_xml(xml) + self.attributes = Hash.from_xml(xml).values.first + self + end + end + + class XmlSerializer < ActiveRecord::Serialization::Serializer #:nodoc: + def builder + @builder ||= begin + options[:indent] ||= 2 + builder = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent]) + + unless options[:skip_instruct] + builder.instruct! + options[:skip_instruct] = true + end + + builder + end + end + + def root + root = (options[:root] || @record.class.to_s.underscore).to_s + dasherize? ? root.dasherize : root + end + + def dasherize? + !options.has_key?(:dasherize) || options[:dasherize] + end + + + # To replicate the behavior in ActiveRecord#attributes, + # :except takes precedence over :only. If :only is not set + # for a N level model but is set for the N+1 level models, + # then because :except is set to a default value, the second + # level model can have both :except and :only set. So if + # :only is set, always delete :except. + def serializable_attributes + serializable_attribute_names.collect { |name| Attribute.new(name, @record) } + end + + def serializable_method_attributes + Array(options[:methods]).inject([]) do |method_attributes, name| + method_attributes << MethodAttribute.new(name.to_s, @record) if @record.respond_to?(name.to_s) + method_attributes + end + end + + def add_attributes + (serializable_attributes + serializable_method_attributes).each do |attribute| + add_tag(attribute) + end + end + + def add_includes + if include_associations = options.delete(:include) + root_only_or_except = { :except => options[:except], + :only => options[:only] } + + include_has_options = include_associations.is_a?(Hash) + + for association in include_has_options ? include_associations.keys : Array(include_associations) + association_options = include_has_options ? include_associations[association] : root_only_or_except + + opts = options.merge(association_options) + + case @record.class.reflect_on_association(association).macro + when :has_many, :has_and_belongs_to_many + records = @record.send(association).to_a + tag = association.to_s + tag = tag.dasherize if dasherize? + if records.empty? + builder.tag!(tag, :type => :array) + else + builder.tag!(tag, :type => :array) do + association_name = association.to_s.singularize + records.each do |record| + record.to_xml opts.merge( + :root => association_name, + :type => (record.class.to_s.underscore == association_name ? nil : record.class.name) + ) + end + end + end + when :has_one, :belongs_to + if record = @record.send(association) + record.to_xml(opts.merge(:root => association)) + end + end + end + + options[:include] = include_associations + end + end + + def add_procs + if procs = options.delete(:procs) + [ *procs ].each do |proc| + proc.call(options) + end + end + end + + + def add_tag(attribute) + builder.tag!( + dasherize? ? attribute.name.dasherize : attribute.name, + attribute.value.to_s, + attribute.decorations(!options[:skip_types]) + ) + end + + def serialize + args = [root] + if options[:namespace] + args << {:xmlns=>options[:namespace]} + end + + if options[:type] + args << {:type=>options[:type]} + end + + builder.tag!(*args) do + add_attributes + add_includes + add_procs + yield builder if block_given? + end + end + + class Attribute #:nodoc: + attr_reader :name, :value, :type + + def initialize(name, record) + @name, @record = name, record + + @type = compute_type + @value = compute_value + end + + # There is a significant speed improvement if the value + # does not need to be escaped, as #tag! escapes all values + # to ensure that valid XML is generated. For known binary + # values, it is at least an order of magnitude faster to + # Base64 encode binary values and directly put them in the + # output XML than to pass the original value or the Base64 + # encoded value to the #tag! method. It definitely makes + # no sense to Base64 encode the value and then give it to + # #tag!, since that just adds additional overhead. + def needs_encoding? + ![ :binary, :date, :datetime, :boolean, :float, :integer ].include?(type) + end + + def decorations(include_types = true) + decorations = {} + + if type == :binary + decorations[:encoding] = 'base64' + end + + if include_types && type != :string + decorations[:type] = type + end + + decorations + end + + protected + def compute_type + type = @record.class.serialized_attributes.has_key?(name) ? :yaml : @record.class.columns_hash[name].type + + case type + when :text + :string + when :time + :datetime + else + type + end + end + + def compute_value + value = @record.send(name) + + if formatter = Hash::XML_FORMATTING[type.to_s] + value ? formatter.call(value) : nil + else + value + end + end + end + + class MethodAttribute < Attribute #:nodoc: + protected + def compute_type + Hash::XML_TYPE_NAMES[@record.send(name).class.name] || :string + end + end + end +end diff --git a/activerecord/lib/active_record/xml_serialization.rb b/activerecord/lib/active_record/xml_serialization.rb deleted file mode 100644 index e32565745e..0000000000 --- a/activerecord/lib/active_record/xml_serialization.rb +++ /dev/null @@ -1,340 +0,0 @@ -module ActiveRecord #:nodoc: - module XmlSerialization - # Builds an XML document to represent the model. Some configuration is - # availble through +options+, however more complicated cases should use - # override ActiveRecord's to_xml. - # - # By default the generated XML document will include the processing - # instruction and all object's attributes. For example: - # - # - # - # The First Topic - # David - # 1 - # false - # 0 - # 2000-01-01T08:28:00+12:00 - # 2003-07-16T09:28:00+1200 - # Have a nice day - # david@loudthinking.com - # - # 2004-04-15 - # - # - # This behavior can be controlled with :only, :except, - # :skip_instruct, :skip_types and :dasherize. The :only and - # :except options are the same as for the #attributes method. - # The default is to dasherize all column names, to disable this, - # set :dasherize to false. To not have the column type included - # in the XML output, set :skip_types to true. - # - # For instance: - # - # topic.to_xml(:skip_instruct => true, :except => [ :id, :bonus_time, :written_on, :replies_count ]) - # - # - # The First Topic - # David - # false - # Have a nice day - # david@loudthinking.com - # - # 2004-04-15 - # - # - # To include first level associations use :include - # - # firm.to_xml :include => [ :account, :clients ] - # - # - # - # 1 - # 1 - # 37signals - # - # - # 1 - # Summit - # - # - # 1 - # Microsoft - # - # - # - # 1 - # 50 - # - # - # - # To include any methods on the object(s) being called use :methods - # - # firm.to_xml :methods => [ :calculated_earnings, :real_earnings ] - # - # - # # ... normal attributes as shown above ... - # 100000000000000000 - # 5 - # - # - # To call any Proc's on the object(s) use :procs. The Proc's - # are passed a modified version of the options hash that was - # given to #to_xml. - # - # proc = Proc.new { |options| options[:builder].tag!('abc', 'def') } - # firm.to_xml :procs => [ proc ] - # - # - # # ... normal attributes as shown above ... - # def - # - # - # Alternatively, you can also just yield the builder object as part of the to_xml call: - # - # firm.to_xml do |xml| - # xml.creator do - # xml.first_name "David" - # xml.last_name "Heinemeier Hansson" - # end - # end - # - # - # # ... normal attributes as shown above ... - # - # David - # Heinemeier Hansson - # - # - # - # You may override the to_xml method in your ActiveRecord::Base - # subclasses if you need to. The general form of doing this is - # - # class IHaveMyOwnXML < ActiveRecord::Base - # def to_xml(options = {}) - # options[:indent] ||= 2 - # xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent]) - # xml.instruct! unless options[:skip_instruct] - # xml.level_one do - # xml.tag!(:second_level, 'content') - # end - # end - # end - def to_xml(options = {}, &block) - serializer = XmlSerializer.new(self, options) - block_given? ? serializer.to_s(&block) : serializer.to_s - end - end - - class XmlSerializer #:nodoc: - attr_reader :options - - def initialize(record, options = {}) - @record, @options = record, options.dup - end - - def builder - @builder ||= begin - options[:indent] ||= 2 - builder = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent]) - - unless options[:skip_instruct] - builder.instruct! - options[:skip_instruct] = true - end - - builder - end - end - - def root - root = (options[:root] || @record.class.to_s.underscore).to_s - dasherize? ? root.dasherize : root - end - - def dasherize? - !options.has_key?(:dasherize) || options[:dasherize] - end - - - # To replicate the behavior in ActiveRecord#attributes, - # :except takes precedence over :only. If :only is not set - # for a N level model but is set for the N+1 level models, - # then because :except is set to a default value, the second - # level model can have both :except and :only set. So if - # :only is set, always delete :except. - def serializable_attributes - attribute_names = @record.attribute_names - - if options[:only] - options.delete(:except) - attribute_names = attribute_names & Array(options[:only]).collect { |n| n.to_s } - else - options[:except] = Array(options[:except]) | Array(@record.class.inheritance_column) - attribute_names = attribute_names - options[:except].collect { |n| n.to_s } - end - - attribute_names.collect { |name| Attribute.new(name, @record) } - end - - def serializable_method_attributes - Array(options[:methods]).inject([]) do |method_attributes, name| - method_attributes << MethodAttribute.new(name.to_s, @record) if @record.respond_to?(name.to_s) - method_attributes - end - end - - def add_attributes - (serializable_attributes + serializable_method_attributes).each do |attribute| - add_tag(attribute) - end - end - - def add_includes - if include_associations = options.delete(:include) - root_only_or_except = { :except => options[:except], - :only => options[:only] } - - include_has_options = include_associations.is_a?(Hash) - - for association in include_has_options ? include_associations.keys : Array(include_associations) - association_options = include_has_options ? include_associations[association] : root_only_or_except - - opts = options.merge(association_options) - - case @record.class.reflect_on_association(association).macro - when :has_many, :has_and_belongs_to_many - records = @record.send(association).to_a - tag = association.to_s - tag = tag.dasherize if dasherize? - if records.empty? - builder.tag!(tag, :type => :array) - else - builder.tag!(tag, :type => :array) do - association_name = association.to_s.singularize - records.each do |record| - record.to_xml opts.merge( - :root => association_name, - :type => (record.class.to_s.underscore == association_name ? nil : record.class.name) - ) - end - end - end - when :has_one, :belongs_to - if record = @record.send(association) - record.to_xml(opts.merge(:root => association)) - end - end - end - - options[:include] = include_associations - end - end - - def add_procs - if procs = options.delete(:procs) - [ *procs ].each do |proc| - proc.call(options) - end - end - end - - - def add_tag(attribute) - builder.tag!( - dasherize? ? attribute.name.dasherize : attribute.name, - attribute.value.to_s, - attribute.decorations(!options[:skip_types]) - ) - end - - def serialize - args = [root] - if options[:namespace] - args << {:xmlns=>options[:namespace]} - end - - if options[:type] - args << {:type=>options[:type]} - end - - builder.tag!(*args) do - add_attributes - add_includes - add_procs - yield builder if block_given? - end - end - - alias_method :to_s, :serialize - - class Attribute #:nodoc: - attr_reader :name, :value, :type - - def initialize(name, record) - @name, @record = name, record - - @type = compute_type - @value = compute_value - end - - # There is a significant speed improvement if the value - # does not need to be escaped, as #tag! escapes all values - # to ensure that valid XML is generated. For known binary - # values, it is at least an order of magnitude faster to - # Base64 encode binary values and directly put them in the - # output XML than to pass the original value or the Base64 - # encoded value to the #tag! method. It definitely makes - # no sense to Base64 encode the value and then give it to - # #tag!, since that just adds additional overhead. - def needs_encoding? - ![ :binary, :date, :datetime, :boolean, :float, :integer ].include?(type) - end - - def decorations(include_types = true) - decorations = {} - - if type == :binary - decorations[:encoding] = 'base64' - end - - if include_types && type != :string - decorations[:type] = type - end - - decorations - end - - protected - def compute_type - type = @record.class.serialized_attributes.has_key?(name) ? :yaml : @record.class.columns_hash[name].type - - case type - when :text - :string - when :time - :datetime - else - type - end - end - - def compute_value - value = @record.send(name) - - if formatter = Hash::XML_FORMATTING[type.to_s] - value ? formatter.call(value) : nil - else - value - end - end - end - - class MethodAttribute < Attribute #:nodoc: - protected - def compute_type - Hash::XML_TYPE_NAMES[@record.send(name).class.name] || :string - end - end - end -end -- cgit v1.2.3