aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorEmilio Tagua <miloops@gmail.com>2009-07-06 10:29:05 -0300
committerEmilio Tagua <miloops@gmail.com>2009-07-06 10:29:05 -0300
commitfb46d00fdfa724dc0c252a46ec13c4ee4cda4708 (patch)
tree0ba1f359515d1054a286d754992db0fa70dec9c8
parent6d4b6a247ef4119f9657293c552ae71459a3665a (diff)
parent783db25e0c640c1588732967a87d65c10fddc08e (diff)
downloadrails-fb46d00fdfa724dc0c252a46ec13c4ee4cda4708.tar.gz
rails-fb46d00fdfa724dc0c252a46ec13c4ee4cda4708.tar.bz2
rails-fb46d00fdfa724dc0c252a46ec13c4ee4cda4708.zip
Merge commit 'rails/master'
-rw-r--r--activemodel/lib/active_model.rb2
-rw-r--r--activemodel/lib/active_model/attributes.rb8
-rw-r--r--activemodel/lib/active_model/serializer.rb60
-rw-r--r--activemodel/lib/active_model/serializers/json.rb101
-rw-r--r--activemodel/lib/active_model/serializers/xml.rb168
-rw-r--r--activemodel/test/cases/serializeration/json_serialization_test.rb (renamed from activemodel/test/cases/json_serialization_test.rb)25
-rw-r--r--activemodel/test/cases/serializeration/xml_serialization_test.rb81
-rw-r--r--activemodel/test/models/contact.rb3
-rw-r--r--activerecord/lib/active_record/serialization.rb68
-rw-r--r--activerecord/lib/active_record/serializers/json_serializer.rb85
-rw-r--r--activerecord/lib/active_record/serializers/xml_serializer.rb12
11 files changed, 451 insertions, 162 deletions
diff --git a/activemodel/lib/active_model.rb b/activemodel/lib/active_model.rb
index 544121c593..f988cd71b8 100644
--- a/activemodel/lib/active_model.rb
+++ b/activemodel/lib/active_model.rb
@@ -34,6 +34,7 @@ module ActiveModel
autoload :Naming, 'active_model/naming'
autoload :Observer, 'active_model/observing'
autoload :Observing, 'active_model/observing'
+ autoload :Serializer, 'active_model/serializer'
autoload :StateMachine, 'active_model/state_machine'
autoload :TestCase, 'active_model/test_case'
autoload :Validations, 'active_model/validations'
@@ -41,6 +42,7 @@ module ActiveModel
module Serializers
autoload :JSON, 'active_model/serializers/json'
+ autoload :Xml, 'active_model/serializers/xml'
end
end
diff --git a/activemodel/lib/active_model/attributes.rb b/activemodel/lib/active_model/attributes.rb
index 4665525281..ea8c8d5f72 100644
--- a/activemodel/lib/active_model/attributes.rb
+++ b/activemodel/lib/active_model/attributes.rb
@@ -2,6 +2,14 @@ require 'active_support/core_ext/object/instance_variables'
module ActiveModel
module Attributes
+ def self.append_features(base)
+ unless base.instance_methods.include?('attributes')
+ super
+ else
+ false
+ end
+ end
+
def attributes
instance_values
end
diff --git a/activemodel/lib/active_model/serializer.rb b/activemodel/lib/active_model/serializer.rb
new file mode 100644
index 0000000000..5b603bdbd7
--- /dev/null
+++ b/activemodel/lib/active_model/serializer.rb
@@ -0,0 +1,60 @@
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/hash/slice'
+
+module ActiveModel
+ class Serializer
+ attr_reader :options
+
+ def initialize(serializable, options = nil)
+ @serializable = serializable
+ @options = options ? options.dup : {}
+
+ @options[:only] = Array.wrap(@options[:only]).map { |n| n.to_s }
+ @options[:except] = Array.wrap(@options[:except]).map { |n| n.to_s }
+ end
+
+ def serialize
+ raise NotImplemented
+ end
+
+ def to_s(&block)
+ serialize(&block)
+ end
+
+ # To replicate the behavior in ActiveRecord#attributes,
+ # <tt>:except</tt> takes precedence over <tt>:only</tt>. If <tt>:only</tt> is not set
+ # for a N level model but is set for the N+1 level models,
+ # then because <tt>:except</tt> is set to a default value, the second
+ # level model can have both <tt>:except</tt> and <tt>:only</tt> set. So if
+ # <tt>:only</tt> is set, always delete <tt>:except</tt>.
+ def serializable_attribute_names
+ attribute_names = @serializable.attributes.keys.sort
+
+ if options[:only].any?
+ attribute_names &= options[:only]
+ elsif options[:except].any?
+ attribute_names -= options[:except]
+ end
+
+ attribute_names
+ end
+
+ def serializable_method_names
+ Array.wrap(options[:methods]).inject([]) do |methods, name|
+ methods << name if @serializable.respond_to?(name.to_s)
+ methods
+ end
+ end
+
+ def serializable_names
+ serializable_attribute_names + serializable_method_names
+ end
+
+ def serializable_hash
+ serializable_names.inject({}) { |hash, name|
+ hash[name] = @serializable.send(name)
+ hash
+ }
+ end
+ end
+end
diff --git a/activemodel/lib/active_model/serializers/json.rb b/activemodel/lib/active_model/serializers/json.rb
index 60b5cbe948..adf200597d 100644
--- a/activemodel/lib/active_model/serializers/json.rb
+++ b/activemodel/lib/active_model/serializers/json.rb
@@ -1,7 +1,5 @@
require 'active_support/json'
require 'active_support/core_ext/class/attribute_accessors'
-require 'active_support/core_ext/hash/except'
-require 'active_support/core_ext/hash/slice'
module ActiveModel
module Serializers
@@ -10,29 +8,102 @@ module ActiveModel
include ActiveModel::Attributes
included do
+ extend ActiveModel::Naming
+
cattr_accessor :include_root_in_json, :instance_writer => false
end
- def encode_json(encoder)
- options = encoder.options || {}
-
- hash = if options[:only]
- only = Array.wrap(options[:only]).map { |attr| attr.to_s }
- attributes.slice(*only)
- elsif options[:except]
- except = Array.wrap(options[:except]).map { |attr| attr.to_s }
- attributes.except(*except)
- else
- attributes
+ class Serializer < ActiveModel::Serializer
+ def serializable_hash
+ model = super
+ @serializable.include_root_in_json ?
+ { @serializable.class.model_name.element => model } :
+ model
end
- hash = { self.class.model_name.element => hash } if include_root_in_json
- ActiveSupport::JSON.encode(hash)
+ def serialize
+ ActiveSupport::JSON.encode(serializable_hash)
+ end
+ end
+
+ # Returns a JSON string representing the model. Some configuration is
+ # available through +options+.
+ #
+ # The option <tt>ActiveRecord::Base.include_root_in_json</tt> controls the
+ # top-level behavior of to_json. In a new Rails application, it is set to
+ # <tt>true</tt> in initializers/new_rails_defaults.rb. When it is <tt>true</tt>,
+ # to_json will emit a single root node named after the object's type. For example:
+ #
+ # konata = User.find(1)
+ # ActiveRecord::Base.include_root_in_json = true
+ # konata.to_json
+ # # => { "user": {"id": 1, "name": "Konata Izumi", "age": 16,
+ # "created_at": "2006/08/01", "awesome": true} }
+ #
+ # ActiveRecord::Base.include_root_in_json = false
+ # konata.to_json
+ # # => {"id": 1, "name": "Konata Izumi", "age": 16,
+ # "created_at": "2006/08/01", "awesome": true}
+ #
+ # The remainder of the examples in this section assume include_root_in_json is set to
+ # <tt>false</tt>.
+ #
+ # Without any +options+, the returned JSON string will include all
+ # the model's attributes. For example:
+ #
+ # konata = User.find(1)
+ # konata.to_json
+ # # => {"id": 1, "name": "Konata Izumi", "age": 16,
+ # "created_at": "2006/08/01", "awesome": true}
+ #
+ # The <tt>:only</tt> and <tt>:except</tt> options can be used to limit the attributes
+ # included, and work similar to the +attributes+ method. For example:
+ #
+ # konata.to_json(:only => [ :id, :name ])
+ # # => {"id": 1, "name": "Konata Izumi"}
+ #
+ # konata.to_json(:except => [ :id, :created_at, :age ])
+ # # => {"name": "Konata Izumi", "awesome": true}
+ #
+ # To include any methods on the model, use <tt>:methods</tt>.
+ #
+ # konata.to_json(:methods => :permalink)
+ # # => {"id": 1, "name": "Konata Izumi", "age": 16,
+ # "created_at": "2006/08/01", "awesome": true,
+ # "permalink": "1-konata-izumi"}
+ #
+ # To include associations, use <tt>:include</tt>.
+ #
+ # konata.to_json(:include => :posts)
+ # # => {"id": 1, "name": "Konata Izumi", "age": 16,
+ # "created_at": "2006/08/01", "awesome": true,
+ # "posts": [{"id": 1, "author_id": 1, "title": "Welcome to the weblog"},
+ # {"id": 2, author_id: 1, "title": "So I was thinking"}]}
+ #
+ # 2nd level and higher order associations work as well:
+ #
+ # konata.to_json(:include => { :posts => {
+ # :include => { :comments => {
+ # :only => :body } },
+ # :only => :title } })
+ # # => {"id": 1, "name": "Konata Izumi", "age": 16,
+ # "created_at": "2006/08/01", "awesome": true,
+ # "posts": [{"comments": [{"body": "1st post!"}, {"body": "Second!"}],
+ # "title": "Welcome to the weblog"},
+ # {"comments": [{"body": "Don't think too hard"}],
+ # "title": "So I was thinking"}]}
+ def encode_json(encoder)
+ Serializer.new(self, encoder.options).to_s
end
def as_json(options = nil)
self
end
+
+ def from_json(json)
+ self.attributes = ActiveSupport::JSON.decode(json)
+ self
+ end
end
end
end
diff --git a/activemodel/lib/active_model/serializers/xml.rb b/activemodel/lib/active_model/serializers/xml.rb
new file mode 100644
index 0000000000..d187859b44
--- /dev/null
+++ b/activemodel/lib/active_model/serializers/xml.rb
@@ -0,0 +1,168 @@
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/hash/conversions'
+
+module ActiveModel
+ module Serializers
+ module Xml
+ extend ActiveSupport::Concern
+ include ActiveModel::Attributes
+
+ class Serializer < ActiveModel::Serializer #:nodoc:
+ class Attribute #:nodoc:
+ attr_reader :name, :value, :type
+
+ def initialize(name, serializable)
+ @name, @serializable = name, serializable
+ @type = compute_type
+ @value = compute_value
+ end
+
+ 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
+
+ if value.nil?
+ decorations[:nil] = true
+ end
+
+ decorations
+ end
+
+ protected
+ def compute_type
+ value = @serializable.send(name)
+ type = Hash::XML_TYPE_NAMES[value.class.name]
+ type ||= :string if value.respond_to?(:to_str)
+ type ||= :yaml
+ type
+ end
+
+ def compute_value
+ value = @serializable.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[@serializable.send(name).class.name] || :string
+ end
+ end
+
+ def builder
+ @builder ||= begin
+ require 'builder' unless defined? ::Builder
+ 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] || @serializable.class.to_s.underscore).to_s
+ reformat_name(root)
+ end
+
+ def dasherize?
+ !options.has_key?(:dasherize) || options[:dasherize]
+ end
+
+ def camelize?
+ options.has_key?(:camelize) && options[:camelize]
+ end
+
+ def serializable_attributes
+ serializable_attribute_names.collect { |name| Attribute.new(name, @serializable) }
+ end
+
+ def serializable_method_attributes
+ Array(options[:methods]).inject([]) do |methods, name|
+ methods << MethodAttribute.new(name.to_s, @serializable) if @serializable.respond_to?(name.to_s)
+ methods
+ end
+ end
+
+ def add_attributes
+ (serializable_attributes + serializable_method_attributes).each do |attribute|
+ add_tag(attribute)
+ 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!(
+ reformat_name(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
+ procs = options.delete(:procs)
+ options[:procs] = procs
+ add_procs
+ yield builder if block_given?
+ end
+ end
+
+ private
+ def reformat_name(name)
+ name = name.camelize if camelize?
+ dasherize? ? name.dasherize : name
+ end
+ end
+
+ def to_xml(options = {}, &block)
+ serializer = Serializer.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
+ end
+end
diff --git a/activemodel/test/cases/json_serialization_test.rb b/activemodel/test/cases/serializeration/json_serialization_test.rb
index abcec67a85..3e69db110e 100644
--- a/activemodel/test/cases/json_serialization_test.rb
+++ b/activemodel/test/cases/serializeration/json_serialization_test.rb
@@ -1,12 +1,11 @@
require 'cases/helper'
+require 'models/contact'
-class JsonSerializationTest < ActiveModel::TestCase
- class Contact
- extend ActiveModel::Naming
- include ActiveModel::Serializers::JSON
- attr_accessor :name, :age, :created_at, :awesome, :preferences
- end
+class Contact
+ include ActiveModel::Serializers::JSON
+end
+class JsonSerializationTest < ActiveModel::TestCase
def setup
@contact = Contact.new
@contact.name = 'Konata Izumi'
@@ -61,4 +60,18 @@ class JsonSerializationTest < ActiveModel::TestCase
assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
assert_match %r{"preferences":\{"shows":"anime"\}}, json
end
+
+ test "methds are called on object" do
+ # Define methods on fixture.
+ def @contact.label; "Has cheezburger"; end
+ def @contact.favorite_quote; "Constraints are liberating"; end
+
+ # Single method.
+ assert_match %r{"label":"Has cheezburger"}, @contact.to_json(:only => :name, :methods => :label)
+
+ # Both methods.
+ methods_json = @contact.to_json(:only => :name, :methods => [:label, :favorite_quote])
+ assert_match %r{"label":"Has cheezburger"}, methods_json
+ assert_match %r{"favorite_quote":"Constraints are liberating"}, methods_json
+ end
end
diff --git a/activemodel/test/cases/serializeration/xml_serialization_test.rb b/activemodel/test/cases/serializeration/xml_serialization_test.rb
new file mode 100644
index 0000000000..57792e900e
--- /dev/null
+++ b/activemodel/test/cases/serializeration/xml_serialization_test.rb
@@ -0,0 +1,81 @@
+require 'cases/helper'
+require 'models/contact'
+
+class Contact
+ include ActiveModel::Serializers::Xml
+end
+
+class XmlSerializationTest < ActiveModel::TestCase
+ def setup
+ @contact = Contact.new
+ @contact.name = 'aaron stack'
+ @contact.age = 25
+ @contact.created_at = Time.utc(2006, 8, 1)
+ @contact.awesome = false
+ @contact.preferences = { :gem => 'ruby' }
+ end
+
+ test "should serialize default root" do
+ @xml = @contact.to_xml
+ assert_match %r{^<contact>}, @xml
+ assert_match %r{</contact>$}, @xml
+ end
+
+ test "should serialize default root with namespace" do
+ @xml = @contact.to_xml :namespace => "http://xml.rubyonrails.org/contact"
+ assert_match %r{^<contact xmlns="http://xml.rubyonrails.org/contact">}, @xml
+ assert_match %r{</contact>$}, @xml
+ end
+
+ test "should serialize custom root" do
+ @xml = @contact.to_xml :root => 'xml_contact'
+ assert_match %r{^<xml-contact>}, @xml
+ assert_match %r{</xml-contact>$}, @xml
+ end
+
+ test "should allow undasherized tags" do
+ @xml = @contact.to_xml :root => 'xml_contact', :dasherize => false
+ assert_match %r{^<xml_contact>}, @xml
+ assert_match %r{</xml_contact>$}, @xml
+ assert_match %r{<created_at}, @xml
+ end
+
+ test "should allow camelized tags" do
+ @xml = @contact.to_xml :root => 'xml_contact', :camelize => true
+ assert_match %r{^<XmlContact>}, @xml
+ assert_match %r{</XmlContact>$}, @xml
+ assert_match %r{<CreatedAt}, @xml
+ end
+
+ test "should allow skipped types" do
+ @xml = @contact.to_xml :skip_types => true
+ assert %r{<age>25</age>}.match(@xml)
+ end
+
+ test "should include yielded additions" do
+ @xml = @contact.to_xml do |xml|
+ xml.creator "David"
+ end
+ assert_match %r{<creator>David</creator>}, @xml
+ end
+
+ test "should serialize string" do
+ assert_match %r{<name>aaron stack</name>}, @contact.to_xml
+ end
+
+ test "should serialize integer" do
+ assert_match %r{<age type="integer">25</age>}, @contact.to_xml
+ end
+
+ test "should serialize datetime" do
+ assert_match %r{<created-at type=\"datetime\">2006-08-01T00:00:00Z</created-at>}, @contact.to_xml
+ end
+
+ test "should serialize boolean" do
+ assert_match %r{<awesome type=\"boolean\">false</awesome>}, @contact.to_xml
+ end
+
+ test "should serialize yaml" do
+ assert_match %r{<preferences type=\"yaml\">--- \n:gem: ruby\n</preferences>}, @contact.to_xml
+ end
+end
diff --git a/activemodel/test/models/contact.rb b/activemodel/test/models/contact.rb
new file mode 100644
index 0000000000..7d69c91996
--- /dev/null
+++ b/activemodel/test/models/contact.rb
@@ -0,0 +1,3 @@
+class Contact
+ attr_accessor :name, :age, :created_at, :awesome, :preferences
+end
diff --git a/activerecord/lib/active_record/serialization.rb b/activerecord/lib/active_record/serialization.rb
index 23d085bea9..94f1e8f1fd 100644
--- a/activerecord/lib/active_record/serialization.rb
+++ b/activerecord/lib/active_record/serialization.rb
@@ -1,42 +1,9 @@
module ActiveRecord #:nodoc:
module Serialization
- class Serializer #:nodoc:
- attr_reader :options
-
- def initialize(record, options = nil)
- @record = record
- @options = options ? options.dup : {}
- end
-
- # To replicate the behavior in ActiveRecord#attributes,
- # <tt>:except</tt> takes precedence over <tt>:only</tt>. If <tt>:only</tt> is not set
- # for a N level model but is set for the N+1 level models,
- # then because <tt>:except</tt> is set to a default value, the second
- # level model can have both <tt>:except</tt> and <tt>:only</tt> set. So if
- # <tt>:only</tt> is set, always delete <tt>:except</tt>.
- def serializable_attribute_names
- attribute_names = @record.attribute_names
-
- if options[:only]
- options.delete(:except)
- attribute_names = attribute_names & Array.wrap(options[:only]).collect { |n| n.to_s }
- else
- options[:except] = Array.wrap(options[:except]) | Array.wrap(@record.class.inheritance_column)
- attribute_names = attribute_names - options[:except].collect { |n| n.to_s }
- end
-
- attribute_names
- end
-
- def serializable_method_names
- Array.wrap(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
+ module RecordSerializer #:nodoc:
+ def initialize(*args)
+ super
+ options[:except] |= Array.wrap(@serializable.class.inheritance_column)
end
# Add associations specified via the <tt>:includes</tt> option.
@@ -53,11 +20,11 @@ module ActiveRecord #:nodoc:
associations = include_has_options ? include_associations.keys : Array.wrap(include_associations)
for association in associations
- records = case @record.class.reflect_on_association(association).macro
+ records = case @serializable.class.reflect_on_association(association).macro
when :has_many, :has_and_belongs_to_many
- @record.send(association).to_a
+ @serializable.send(association).to_a
when :has_one, :belongs_to
- @record.send(association)
+ @serializable.send(association)
end
unless records.nil?
@@ -71,28 +38,19 @@ module ActiveRecord #:nodoc:
end
end
- def serializable_record
- record = {}
- serializable_names.each { |name| record[name] = @record.send(name) }
+ def serializable_hash
+ hash = super
add_includes do |association, records, opts|
- record[association] =
+ hash[association] =
if records.is_a?(Enumerable)
- records.collect { |r| self.class.new(r, opts).serializable_record }
+ records.collect { |r| self.class.new(r, opts).serializable_hash }
else
- self.class.new(records, opts).serializable_record
+ self.class.new(records, opts).serializable_hash
end
end
- record
- end
-
- def serialize
- # overwrite to implement
- end
-
- def to_s(&block)
- serialize(&block)
+ hash
end
end
end
diff --git a/activerecord/lib/active_record/serializers/json_serializer.rb b/activerecord/lib/active_record/serializers/json_serializer.rb
index 21afcd6e5c..63bf42c09d 100644
--- a/activerecord/lib/active_record/serializers/json_serializer.rb
+++ b/activerecord/lib/active_record/serializers/json_serializer.rb
@@ -1,91 +1,14 @@
-require 'active_support/json'
-require 'active_model/naming'
-
module ActiveRecord #:nodoc:
module Serialization
extend ActiveSupport::Concern
+ include ActiveModel::Serializers::JSON
- included do
- cattr_accessor :include_root_in_json, :instance_writer => false
+ class JSONSerializer < ActiveModel::Serializers::JSON::Serializer
+ include Serialization::RecordSerializer
end
- # Returns a JSON string representing the model. Some configuration is
- # available through +options+.
- #
- # The option <tt>ActiveRecord::Base.include_root_in_json</tt> controls the
- # top-level behavior of to_json. In a new Rails application, it is set to
- # <tt>true</tt> in initializers/new_rails_defaults.rb. When it is <tt>true</tt>,
- # to_json will emit a single root node named after the object's type. For example:
- #
- # konata = User.find(1)
- # ActiveRecord::Base.include_root_in_json = true
- # konata.to_json
- # # => { "user": {"id": 1, "name": "Konata Izumi", "age": 16,
- # "created_at": "2006/08/01", "awesome": true} }
- #
- # ActiveRecord::Base.include_root_in_json = false
- # konata.to_json
- # # => {"id": 1, "name": "Konata Izumi", "age": 16,
- # "created_at": "2006/08/01", "awesome": true}
- #
- # The remainder of the examples in this section assume include_root_in_json is set to
- # <tt>false</tt>.
- #
- # Without any +options+, the returned JSON string will include all
- # the model's attributes. For example:
- #
- # konata = User.find(1)
- # konata.to_json
- # # => {"id": 1, "name": "Konata Izumi", "age": 16,
- # "created_at": "2006/08/01", "awesome": true}
- #
- # The <tt>:only</tt> and <tt>:except</tt> options can be used to limit the attributes
- # included, and work similar to the +attributes+ method. For example:
- #
- # konata.to_json(:only => [ :id, :name ])
- # # => {"id": 1, "name": "Konata Izumi"}
- #
- # konata.to_json(:except => [ :id, :created_at, :age ])
- # # => {"name": "Konata Izumi", "awesome": true}
- #
- # To include any methods on the model, use <tt>:methods</tt>.
- #
- # konata.to_json(:methods => :permalink)
- # # => {"id": 1, "name": "Konata Izumi", "age": 16,
- # "created_at": "2006/08/01", "awesome": true,
- # "permalink": "1-konata-izumi"}
- #
- # To include associations, use <tt>:include</tt>.
- #
- # konata.to_json(:include => :posts)
- # # => {"id": 1, "name": "Konata Izumi", "age": 16,
- # "created_at": "2006/08/01", "awesome": true,
- # "posts": [{"id": 1, "author_id": 1, "title": "Welcome to the weblog"},
- # {"id": 2, author_id: 1, "title": "So I was thinking"}]}
- #
- # 2nd level and higher order associations work as well:
- #
- # konata.to_json(:include => { :posts => {
- # :include => { :comments => {
- # :only => :body } },
- # :only => :title } })
- # # => {"id": 1, "name": "Konata Izumi", "age": 16,
- # "created_at": "2006/08/01", "awesome": true,
- # "posts": [{"comments": [{"body": "1st post!"}, {"body": "Second!"}],
- # "title": "Welcome to the weblog"},
- # {"comments": [{"body": "Don't think too hard"}],
- # "title": "So I was thinking"}]}
def encode_json(encoder)
- hash = Serializer.new(self, encoder.options).serializable_record
- hash = { self.class.model_name.element => hash } if include_root_in_json
- ActiveSupport::JSON.encode(hash)
- end
-
- def as_json(options = nil) self end #:nodoc:
-
- def from_json(json)
- self.attributes = ActiveSupport::JSON.decode(json)
- self
+ JSONSerializer.new(self, encoder.options).to_s
end
end
end
diff --git a/activerecord/lib/active_record/serializers/xml_serializer.rb b/activerecord/lib/active_record/serializers/xml_serializer.rb
index 4eaf9531e2..c3811caa53 100644
--- a/activerecord/lib/active_record/serializers/xml_serializer.rb
+++ b/activerecord/lib/active_record/serializers/xml_serializer.rb
@@ -164,7 +164,9 @@ module ActiveRecord #:nodoc:
end
end
- class XmlSerializer < ActiveRecord::Serialization::Serializer #:nodoc:
+ class XmlSerializer < ActiveModel::Serializer #:nodoc:
+ include Serialization::RecordSerializer
+
def builder
@builder ||= begin
require 'builder' unless defined? ::Builder
@@ -181,7 +183,7 @@ module ActiveRecord #:nodoc:
end
def root
- root = (options[:root] || @record.class.to_s.underscore).to_s
+ root = (options[:root] || @serializable.class.to_s.underscore).to_s
reformat_name(root)
end
@@ -199,12 +201,12 @@ module ActiveRecord #:nodoc:
end
def serializable_attributes
- serializable_attribute_names.collect { |name| Attribute.new(name, @record) }
+ serializable_attribute_names.collect { |name| Attribute.new(name, @serializable) }
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 << MethodAttribute.new(name.to_s, @serializable) if @serializable.respond_to?(name.to_s)
method_attributes
end
end
@@ -254,7 +256,7 @@ module ActiveRecord #:nodoc:
end
end
else
- if record = @record.send(association)
+ if record = @serializable.send(association)
record.to_xml(opts.merge(:root => association))
end
end