Permalink
Browse files

Merge commit 'rails/master'

  • Loading branch information...
2 parents 6d4b6a2 + 783db25 commit fb46d00fdfa724dc0c252a46ec13c4ee4cda4708 @miloops miloops committed Jul 6, 2009
@@ -34,13 +34,15 @@ 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'
autoload :ValidationsRepairHelper, 'active_model/validations_repair_helper'
module Serializers
autoload :JSON, 'active_model/serializers/json'
+ autoload :Xml, 'active_model/serializers/xml'
end
end
@@ -2,6 +2,14 @@
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
@@ -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
@@ -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 JSON
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
@@ -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
Oops, something went wrong.

0 comments on commit fb46d00

Please sign in to comment.