Benjamin Fleischer
43a2fd2596
Document 0.9 rewrite and unreleased changes [ci skip]
...
Demonstrates that there was unreleased code in 0-8 that does not
exist on 0-8-stable 919bb38401/CHANGELOG.md731528e1f6...919bb38401919bb38401https://gist.github.com/bf4/c8eb0475a39700794b36
```patch
From 64ed05c4840e876624ec76fead041faaa08c25eff179a27ed71a8709d71c460a2509845017fb686aea3566955ca41de0286f9f5e8726210917148617baa690a01ac1e710aae1c04d452823e273a2fb370b9f69529f251fdc7ba42b22acff5303669a74bc85bf3d2f3df9e189e9d70b648fceac2dd0090f13ea6d712cc8eb5b27de69ecbb8bf6a6296970415afeaefeeef31c3f14407ccd9e106640e295af2e2bbbd3c8b15736feb5d44f0b6326eb35787b7cf24a055f8fe33c35608a8550fd8cb67b856c6bc8872d3e27110df724923722d42252e8fe6d87eadd09b979a6e13e8f5cbf931705f5de334ddf3dd422d99ebbc3ae44cc18313df12d6c6bc8872d3e27110df7ee846f39af258248d6c09521e912fec023052df8f5de334ddf3dd422d99e8795f2bc1ehttps://github.com/rails-api/active_model_serializers/issues ).
+
+Please discuss new features or ask for feedback about a new feature [on
+rails-api-core](https://groups.google.com/forum/#!forum/rails-api-core ).
+
+If you want a feature implemented, the best way to get it done is to submit a
+pull request that implements it. Tests and docs would be nice.
+
+Please include a CHANGELOG with all entries that change behavior.
+
+❤️ 💖 ❤️
+
From c97acfd9ba64ed05c484Fixes #318
---
lib/active_model/array_serializer.rb | 3 +--
test/array_serializer_test.rb | 19 ++++++++++++++++++-
2 files changed, 19 insertions(+), 3 deletions(-)
diff --git a/lib/active_model/array_serializer.rb b/lib/active_model/array_serializer.rb
index 144bfe8..a1b92c4 100644
--- a/lib/active_model/array_serializer.rb
+++ b/lib/active_model/array_serializer.rb
@@ -49,9 +49,8 @@ def serializable_array
serializer = options[:each_serializer]
elsif item.respond_to?(:active_model_serializer)
serializer = item.active_model_serializer
- else
- serializer = DefaultSerializer
end
+ serializer ||= DefaultSerializer
serializable = serializer.new(item, options.merge(:root => nil))
diff --git a/test/array_serializer_test.rb b/test/array_serializer_test.rb
index 11bec6c..f335382 100644
--- a/test/array_serializer_test.rb
+++ b/test/array_serializer_test.rb
@@ -52,7 +52,7 @@ def test_array_serializer_with_hash
assert_equal({ :items => [ hash.as_json ]}, serializer.as_json)
end
- def test_array_serializer_with_specified_seriailizer
+ def test_array_serializer_with_specified_serializer
post1 = Post.new(:title => "Post1", :author => "Author1", :id => 1)
post2 = Post.new(:title => "Post2", :author => "Author2", :id => 2)
@@ -65,4 +65,21 @@ def test_array_serializer_with_specified_seriailizer
{ :title => "Post2" }
], serializer.as_json)
end
+
+ def test_array_serializer_using_default_serializer
+ hash = { "value" => "something" }
+ class << hash
+ def active_model_serializer
+ nil
+ end
+ end
+
+ array = [hash]
+
+ serializer = array.active_model_serializer.new array
+
+ assert_equal([
+ { "value" => "something" }
+ ], serializer.as_json)
+ end
end
From 1b142a23f12c563eaace143e5d9866https://github.com/rails-api/active_model_serializers/issues/127
for original motivation
---
lib/generators/serializer/serializer_generator.rb | 3 ---
lib/generators/serializer/templates/serializer.rb | 11 -----------
test/generators_test.rb | 12 ------------
3 files changed, 26 deletions(-)
diff --git a/lib/generators/serializer/serializer_generator.rb b/lib/generators/serializer/serializer_generator.rb
index b7096f8..0da6c87 100644
--- a/lib/generators/serializer/serializer_generator.rb
+++ b/lib/generators/serializer/serializer_generator.rb
@@ -13,9 +13,6 @@ def create_serializer_file
end
private
- def generate_id_method
- RUBY_VERSION =~ /1\.8/
- end
def attributes_names
[:id] + attributes.select { |attr| !attr.reference? }.map { |a| a.name.to_sym }
diff --git a/lib/generators/serializer/templates/serializer.rb b/lib/generators/serializer/templates/serializer.rb
index 6c25609..4ebb004 100644
--- a/lib/generators/serializer/templates/serializer.rb
+++ b/lib/generators/serializer/templates/serializer.rb
@@ -4,16 +4,5 @@ class <%= class_name %>Serializer < <%= parent_class_name %>
<% association_names.each do |attribute| -%>
has_one :<%= attribute %>
<% end -%>
-<% if generate_id_method %>
-
- # due to the difference between 1.8 and 1.9 with respect to #id and
- # #object_id, we recommend that if you wish to serialize id columns, you
- # do this. Feel free to remove this if you don't feel that it's appropriate.
- #
- # For more: https://github.com/rails-api/active_model_serializers/issues/127
- def id
- object.read_attribute_for_serialization(:id)
- end
-<% end -%>
end
<% end -%>
diff --git a/test/generators_test.rb b/test/generators_test.rb
index b1938ce..b1a05b3 100644
--- a/test/generators_test.rb
+++ b/test/generators_test.rb
@@ -36,18 +36,6 @@ def test_uses_application_serializer_if_one_exists
Object.send :remove_const, :ApplicationSerializer
end
- def test_serializer_gets_id
- run_generator
-
- assert_file "app/serializers/account_serializer.rb" do |content|
- if RUBY_VERSION =~ /1.8/
- assert_match /def id/, content
- else
- assert_no_match /def id/, content
- end
- end
- end
-
# def test_uses_namespace_application_serializer_if_one_exists
# Object.const_set(:SerializerNamespace, Module.new)
# SerializerNamespace.const_set(:ApplicationSerializer, Class.new)
From 62167d243ba857952d12b686b73edf6c6bc8872d3e27110df724923722d42252e8fe6d87eadd09b92252e8fe6d87eadd09b979a6e13e8f5cbf931705f5de334ddff5de334ddf3dd422d99e74ba9dc76chttps://rubygems.org '
# Specify gem dependencies in active_model_serializers.gemspec
gemspec
-gem "coveralls", :require => false
+gem "coveralls", require: false
diff --git a/Rakefile b/Rakefile
index 23f17c4..8c5bd75 100644
--- a/Rakefile
+++ b/Rakefile
@@ -15,4 +15,4 @@ task :bench do
load 'bench/perf.rb'
end
-task :default => :test
+task default: :test
diff --git a/lib/active_model/array_serializer.rb b/lib/active_model/array_serializer.rb
index a1b92c4..e752c81 100644
--- a/lib/active_model/array_serializer.rb
+++ b/lib/active_model/array_serializer.rb
@@ -52,7 +52,7 @@ def serializable_array
end
serializer ||= DefaultSerializer
- serializable = serializer.new(item, options.merge(:root => nil))
+ serializable = serializer.new(item, options.merge(root: nil))
if serializable.respond_to?(:serializable_hash)
serializable.serializable_hash
diff --git a/lib/active_model/serializer.rb b/lib/active_model/serializer.rb
index c3768f7..e2a6228 100644
--- a/lib/active_model/serializer.rb
+++ b/lib/active_model/serializer.rb
@@ -13,7 +13,7 @@ module ActiveModel
# it expects two objects as arguments, a resource and options. For example,
# one may do in a controller:
#
- # PostSerializer.new(@post, :scope => current_user).to_json
+ # PostSerializer.new(@post, scope: current_user).to_json
#
# The object to be serialized is the +@post+ and the current user is passed
# in for authorization purposes.
@@ -30,7 +30,7 @@ module ActiveModel
#
# def attributes
# hash = super
- # hash.merge!(:email => post.email) if author?
+ # hash.merge!(email: post.email) if author?
# hash
# end
#
@@ -46,7 +46,7 @@ class Serializer
include ActiveModel::Serializer::Caching
INCLUDE_METHODS = {}
- INSTRUMENT = { :serialize => :"serialize.serializer", :associations => :"associations.serializer" }
+ INSTRUMENT = { serialize: :"serialize.serializer", associations: :"associations.serializer" }
class IncludeError < StandardError
attr_reader :source, :association
@@ -86,7 +86,7 @@ def attributes(*attrs)
attrs.each do |attr|
if Hash === attr
- attr.each {|attr_real, key| attribute attr_real, :key => key }
+ attr.each {|attr_real, key| attribute(attr_real, key: key) }
else
attribute attr
end
@@ -172,20 +172,20 @@ def has_one(*attrs)
#
# The +attributes+ hash looks like this:
#
- # { :name => :string, :age => :integer }
+ # { name: :string, age: :integer }
#
# The +associations+ hash looks like this:
- # { :posts => { :has_many => :posts } }
+ # { posts: { has_many: :posts } }
#
# If :key is used:
#
# class PostsSerializer < ActiveModel::Serializer
- # has_many :posts, :key => :my_posts
+ # has_many :posts, key: :my_posts
# end
#
# the hash looks like this:
#
- # { :my_posts => { :has_many => :posts }
+ # { my_posts: { has_many: :posts }
#
# This information is extracted from the serializer's model class,
# which is provided by +SerializerClass.model_class+.
@@ -232,7 +232,7 @@ def schema
end
end
- { :attributes => attrs, :associations => associations }
+ { attributes: attrs, associations: associations }
end
# The model class associated with this serializer.
@@ -244,7 +244,7 @@ def model_class
#
# embed :objects # Embed associations as full objects
# embed :ids # Embed only the association ids
- # embed :ids, :include => true # Embed the association ids and include objects in the root
+ # embed :ids, include: true # Embed the association ids and include objects in the root
#
def embed(type, options={})
self._embed = type
@@ -323,7 +323,7 @@ def url_options
# Returns a json representation of the serializable
# object including the root.
def as_json(args={})
- super(:root => args.fetch(:root, options.fetch(:root, root_name)))
+ super(root: args.fetch(:root, options.fetch(:root, root_name)))
end
def serialize_object
@@ -451,8 +451,8 @@ def instrument(name, payload = {}, &block)
def default_embed_options
{
- :embed => _embed,
- :include => _root_embed
+ embed: _embed,
+ include: _root_embed
}
end
end
diff --git a/lib/active_model/serializer/associations.rb b/lib/active_model/serializer/associations.rb
index 888b94f..1f2b0b5 100644
--- a/lib/active_model/serializer/associations.rb
+++ b/lib/active_model/serializer/associations.rb
@@ -12,7 +12,7 @@ class Association #:nodoc:
# embed: Define how associations should be embedded.
# - :objects # Embed associations as full objects.
# - :ids # Embed only the association ids.
- # - :ids, :include => true # Embed the association ids and include objects in the root.
+ # - :ids, include: true # Embed the association ids and include objects in the root.
#
# include: Used in conjunction with embed :ids. Includes the objects in the root.
#
@@ -158,8 +158,8 @@ def serialize_ids
if polymorphic?
{
- :type => polymorphic_key,
- :id => id
+ type: polymorphic_key,
+ id: id
}
else
id
diff --git a/lib/active_model_serializers.rb b/lib/active_model_serializers.rb
index a708585..c1357c7 100644
--- a/lib/active_model_serializers.rb
+++ b/lib/active_model_serializers.rb
@@ -74,8 +74,8 @@ def active_model_serializer
Set.send(:include, ActiveModel::ArraySerializerSupport)
{
- :active_record => 'ActiveRecord::Relation',
- :mongoid => 'Mongoid::Criteria'
+ active_record: 'ActiveRecord::Relation',
+ mongoid: 'Mongoid::Criteria'
}.each do |orm, rel_class|
ActiveSupport.on_load(orm) do
include ActiveModel::SerializerSupport
diff --git a/lib/generators/serializer/serializer_generator.rb b/lib/generators/serializer/serializer_generator.rb
index 0da6c87..129da44 100644
--- a/lib/generators/serializer/serializer_generator.rb
+++ b/lib/generators/serializer/serializer_generator.rb
@@ -2,11 +2,11 @@ module Rails
module Generators
class SerializerGenerator < NamedBase
source_root File.expand_path("../templates", __FILE__)
- check_class_collision :suffix => "Serializer"
+ check_class_collision suffix: "Serializer"
- argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+ argument :attributes, type: :array, default: [], banner: "field:type field:type"
- class_option :parent, :type => :string, :desc => "The parent class for the generated serializer"
+ class_option :parent, type: :string, desc: "The parent class for the generated serializer"
def create_serializer_file
template 'serializer.rb', File.join('app/serializers', class_path, "#{file_name}_serializer.rb")
From c3fa96456chttp://example.com/logo.png ', :attachable => email
+ attachment = Attachment.new name: 'logo.png', url: 'http://example.com/logo.png ', attachable: email
actual = attachment_serializer.new(attachment, {}).as_json
assert_equal({
- :name => 'logo.png',
- :url => 'http://example.com/logo.png ',
- :attachable => {
- :type => :email,
- :email => { :subject => 'foo', :body => 'bar' }
+ name: 'logo.png',
+ url: 'http://example.com/logo.png ',
+ attachable: {
+ type: :email,
+ email: { subject: 'foo', body: 'bar' }
}
}, actual)
end
@@ -1142,21 +1142,21 @@ def self.to_s
attachment_serializer = Class.new(ActiveModel::Serializer) do
embed :ids
attributes :name, :url
- has_one :attachable, :polymorphic => true
+ has_one :attachable, polymorphic: true
end
- email = email_class.new :id => 1
+ email = email_class.new id: 1
- attachment = Attachment.new :name => 'logo.png', :url => 'http://example.com/logo.png ', :attachable => email
+ attachment = Attachment.new name: 'logo.png', url: 'http://example.com/logo.png ', attachable: email
actual = attachment_serializer.new(attachment, {}).as_json
assert_equal({
- :name => 'logo.png',
- :url => 'http://example.com/logo.png ',
- :attachable => {
- :type => :email,
- :id => 1
+ name: 'logo.png',
+ url: 'http://example.com/logo.png ',
+ attachable: {
+ type: :email,
+ id: 1
}
}, actual)
end
@@ -1178,29 +1178,29 @@ def self.to_s
attachment_serializer = Class.new(ActiveModel::Serializer) do
root :attachment
- embed :ids, :include => true
+ embed :ids, include: true
attributes :name, :url
- has_one :attachable, :polymorphic => true
+ has_one :attachable, polymorphic: true
end
- email = email_class.new :id => 1, :subject => "Hello", :body => "World"
+ email = email_class.new id: 1, subject: "Hello", body: "World"
- attachment = Attachment.new :name => 'logo.png', :url => 'http://example.com/logo.png ', :attachable => email
+ attachment = Attachment.new name: 'logo.png', url: 'http://example.com/logo.png ', attachable: email
actual = attachment_serializer.new(attachment, {}).as_json
assert_equal({
- :attachment => {
- :name => 'logo.png',
- :url => 'http://example.com/logo.png ',
- :attachable => {
- :type => :email,
- :id => 1
+ attachment: {
+ name: 'logo.png',
+ url: 'http://example.com/logo.png ',
+ attachable: {
+ type: :email,
+ id: 1
}},
- :emails => [{
- :id => 1,
- :subject => "Hello",
- :body => "World"
+ emails: [{
+ id: 1,
+ subject: "Hello",
+ body: "World"
}]
}, actual)
end
@@ -1211,10 +1211,10 @@ def test_multiple_polymorphic_associations
end
orange_serializer = Class.new(ActiveModel::Serializer) do
- embed :ids, :include => true
+ embed :ids, include: true
attributes :plu, :id
- has_one :readable, :polymorphic => true
+ has_one :readable, polymorphic: true
end
email_class = Class.new(Model) do
@@ -1243,47 +1243,47 @@ def readable
attachment_serializer = Class.new(ActiveModel::Serializer) do
root :attachment
- embed :ids, :include => true
+ embed :ids, include: true
attributes :name, :url
- has_one :attachable, :polymorphic => true
- has_one :readable, :polymorphic => true
- has_one :edible, :polymorphic => true
+ has_one :attachable, polymorphic: true
+ has_one :readable, polymorphic: true
+ has_one :edible, polymorphic: true
end
- email = email_class.new :id => 1, :subject => "Hello", :body => "World"
- orange = orange_class.new :id => 1, :plu => "3027", :readable => email
+ email = email_class.new id: 1, subject: "Hello", body: "World"
+ orange = orange_class.new id: 1, plu: "3027", readable: email
attachment = Attachment.new({
- :name => 'logo.png',
- :url => 'http://example.com/logo.png ',
- :attachable => email,
- :readable => email,
- :edible => orange
+ name: 'logo.png',
+ url: 'http://example.com/logo.png ',
+ attachable: email,
+ readable: email,
+ edible: orange
})
actual = attachment_serializer.new(attachment, {}).as_json
assert_equal({
- :emails => [{
- :subject => "Hello",
- :body => "World",
- :id => 1
+ emails: [{
+ subject: "Hello",
+ body: "World",
+ id: 1
}],
- :oranges => [{
- :plu => "3027",
- :id => 1,
- :readable => { :type => :email, :id => 1 }
+ oranges: [{
+ plu: "3027",
+ id: 1,
+ readable: { type: :email, id: 1 }
}],
- :attachment => {
- :name => 'logo.png',
- :url => 'http://example.com/logo.png ',
- :attachable => { :type => :email, :id => 1 },
- :readable => { :type => :email, :id => 1 },
- :edible => { :type => :orange, :id => 1 }
+ attachment: {
+ name: 'logo.png',
+ url: 'http://example.com/logo.png ',
+ attachable: { type: :email, id: 1 },
+ readable: { type: :email, id: 1 },
+ edible: { type: :orange, id: 1 }
}
}, actual)
end
@@ -1294,8 +1294,8 @@ def test_raises_an_error_when_a_child_serializer_includes_associations_when_the_
end
fruit_serializer = Class.new(ActiveModel::Serializer) do
- embed :ids, :include => true
- has_one :attachment, :serializer => attachment_serializer
+ embed :ids, include: true
+ has_one :attachment, serializer: attachment_serializer
attribute :color
end
@@ -1337,24 +1337,24 @@ def initialize(base, flavor)
smoothie_serializer = Class.new(ActiveModel::Serializer) do
root false
- embed :ids, :include => true
+ embed :ids, include: true
- has_one :base, :polymorphic => true
- has_one :flavor, :polymorphic => true
+ has_one :base, polymorphic: true
+ has_one :flavor, polymorphic: true
end
banana_attachment = Attachment.new({
- :name => 'banana_blending.md',
- :id => 3,
+ name: 'banana_blending.md',
+ id: 3,
})
strawberry_attachment = Attachment.new({
- :name => 'strawberry_cleaning.doc',
- :id => 4
+ name: 'strawberry_cleaning.doc',
+ id: 4
})
- banana = banana_class.new :color => "yellow", :id => 1, :attachment => banana_attachment
- strawberry = strawberry_class.new :color => "red", :id => 2, :attachment => strawberry_attachment
+ banana = banana_class.new color: "yellow", id: 1, attachment: banana_attachment
+ strawberry = strawberry_class.new color: "red", id: 2, attachment: strawberry_attachment
smoothie = smoothie_serializer.new(smoothie.new(banana, strawberry))
@@ -1366,19 +1366,19 @@ def initialize(base, flavor)
def tests_includes_does_not_include_nil_polymoprhic_associations
post_serializer = Class.new(ActiveModel::Serializer) do
root :post
- embed :ids, :include => true
- has_one :author, :polymorphic => true
+ embed :ids, include: true
+ has_one :author, polymorphic: true
attributes :title
end
- post = Post.new(:title => 'Foo')
+ post = Post.new(title: 'Foo')
actual = post_serializer.new(post).as_json
assert_equal({
- :post => {
- :title => 'Foo',
- :author => nil
+ post: {
+ title: 'Foo',
+ author: nil
}
}, actual)
end
@@ -1401,30 +1401,30 @@ def name
serializable_array = Class.new(Array)
array = serializable_array.new
- array << tag_class.new(:name => 'Rails')
- array << tag_class.new(:name => 'Sinatra')
+ array << tag_class.new(name: 'Rails')
+ array << tag_class.new(name: 'Sinatra')
- actual = array.active_model_serializer.new(array, :root => :tags, :meta => {:total => 10}).as_json
+ actual = array.active_model_serializer.new(array, root: :tags, meta: {total: 10}).as_json
assert_equal({
- :meta => {
- :total => 10,
+ meta: {
+ total: 10,
},
- :tags => [
- { :name => "Rails" },
- { :name => "Sinatra" },
+ tags: [
+ { name: "Rails" },
+ { name: "Sinatra" },
]
}, actual)
- actual = array.active_model_serializer.new(array, :root => :tags, :meta => {:total => 10}, :meta_key => 'meta_object').as_json
+ actual = array.active_model_serializer.new(array, root: :tags, meta: {total: 10}, meta_key: 'meta_object').as_json
assert_equal({
- :meta_object => {
- :total => 10,
+ meta_object: {
+ total: 10,
},
- :tags => [
- { :name => "Rails" },
- { :name => "Sinatra" },
+ tags: [
+ { name: "Rails" },
+ { name: "Sinatra" },
]
}, actual)
end
@@ -1447,9 +1447,9 @@ def test_inheritance_does_not_used_cached_attributes
item.body = "body"
2.times do
- assert_equal({:title => "title"},
+ assert_equal({title: "title"},
parent.new(item).attributes)
- assert_equal({:body => "body", :title => "title"},
+ assert_equal({body: "body", title: "title"},
child.new(item).attributes)
end
@@ -1464,36 +1464,36 @@ def has_permission?
user = User.new
user.superuser = true
- post = Post.new(:title => 'Foo')
+ post = Post.new(title: 'Foo')
- a_serializer = serializer.new(post, :scope => user, :scope_name => :current_user)
+ a_serializer = serializer.new(post, scope: user, scope_name: :current_user)
assert a_serializer.has_permission?
end
def test_only_option_filters_attributes_and_associations
- post = Post.new(:title => "New Post", :body => "Body of new post")
- comments = [Comment.new(:title => "Comment1")]
+ post = Post.new(title: "New Post", body: "Body of new post")
+ comments = [Comment.new(title: "Comment1")]
post.comments = comments
- post_serializer = PostSerializer.new(post, :only => :title)
+ post_serializer = PostSerializer.new(post, only: :title)
assert_equal({
- :post => {
- :title => "New Post"
+ post: {
+ title: "New Post"
}
}, post_serializer.as_json)
end
def test_except_option_filters_attributes_and_associations
- post = Post.new(:title => "New Post", :body => "Body of new post")
- comments = [Comment.new(:title => "Comment1")]
+ post = Post.new(title: "New Post", body: "Body of new post")
+ comments = [Comment.new(title: "Comment1")]
post.comments = comments
- post_serializer = PostSerializer.new(post, :except => [:body, :comments])
+ post_serializer = PostSerializer.new(post, except: [:body, :comments])
assert_equal({
- :post => {
- :title => "New Post"
+ post: {
+ title: "New Post"
}
}, post_serializer.as_json)
end
@@ -1501,11 +1501,11 @@ def test_except_option_filters_attributes_and_associations
def test_only_option_takes_precedence_over_custom_defined_include_methods
user = User.new
- post = Post.new(:title => "New Post", :body => "Body of new post", :author => "Sausage King")
- comments = [Comment.new(:title => "Comment")]
+ post = Post.new(title: "New Post", body: "Body of new post", author: "Sausage King")
+ comments = [Comment.new(title: "Comment")]
post.comments = comments
- post_serializer = PostWithMultipleConditionalsSerializer.new(post, :scope => user, :only => :title)
+ post_serializer = PostWithMultipleConditionalsSerializer.new(post, scope: user, only: :title)
# comments enabled
post.comments_disabled = false
@@ -1513,8 +1513,8 @@ def test_only_option_takes_precedence_over_custom_defined_include_methods
user.superuser = true
assert_equal({
- :post => {
- :title => "New Post"
+ post: {
+ title: "New Post"
}
}, post_serializer.as_json)
end
diff --git a/test/test_fakes.rb b/test/test_fakes.rb
index 30ce34b..a0a244c 100644
--- a/test/test_fakes.rb
+++ b/test/test_fakes.rb
@@ -8,7 +8,7 @@ def read_attribute_for_serialization(name)
end
def as_json(*)
- { :model => "Model" }
+ { model: "Model" }
end
end
@@ -26,7 +26,7 @@ class User
attr_accessor :superuser
def initialize(hash={})
- @attributes = hash.merge(:first_name => "Jose", :last_name => "Valim", :password => "oh noes yugive my password")
+ @attributes = hash.merge(first_name: "Jose", last_name: "Valim", password: "oh noes yugive my password")
end
def read_attribute_for_serialization(name)
@@ -58,31 +58,31 @@ class UserSerializer < ActiveModel::Serializer
attributes :first_name, :last_name
def serializable_hash
- attributes.merge(:ok => true).merge(options[:scope])
+ attributes.merge(ok: true).merge(options[:scope])
end
end
class UserAttributesWithKeySerializer < ActiveModel::Serializer
- attributes :first_name => :f_name, :last_name => :l_name
+ attributes first_name: :f_name, last_name: :l_name
def serializable_hash
- attributes.merge(:ok => true).merge(options[:scope])
+ attributes.merge(ok: true).merge(options[:scope])
end
end
class UserAttributesWithSomeKeySerializer < ActiveModel::Serializer
- attributes :first_name, :last_name => :l_name
+ attributes :first_name, last_name: :l_name
def serializable_hash
- attributes.merge(:ok => true).merge(options[:scope])
+ attributes.merge(ok: true).merge(options[:scope])
end
end
class UserAttributesWithUnsymbolizableKeySerializer < ActiveModel::Serializer
- attributes :first_name, :last_name => :"last-name"
+ attributes :first_name, last_name: :"last-name"
def serializable_hash
- attributes.merge(:ok => true).merge(options[:scope])
+ attributes.merge(ok: true).merge(options[:scope])
end
end
@@ -95,7 +95,7 @@ class MyUserSerializer < ActiveModel::Serializer
def serializable_hash
hash = attributes
- hash = hash.merge(:super_user => true) if object.super_user?
+ hash = hash.merge(super_user: true) if object.super_user?
hash
end
end
@@ -108,7 +108,7 @@ def initialize(comment, options={})
attr_reader :object
def serializable_hash
- { :title => @object.read_attribute_for_serialization(:title) }
+ { title: @object.read_attribute_for_serialization(:title) }
end
def as_json(options=nil)
@@ -116,20 +116,20 @@ def as_json(options=nil)
if options[:root] == false
serializable_hash
else
- { :comment => serializable_hash }
+ { comment: serializable_hash }
end
end
end
class PostSerializer < ActiveModel::Serializer
attributes :title, :body
- has_many :comments, :serializer => CommentSerializer
+ has_many :comments, serializer: CommentSerializer
end
class PostWithConditionalCommentsSerializer < ActiveModel::Serializer
root :post
attributes :title, :body
- has_many :comments, :serializer => CommentSerializer
+ has_many :comments, serializer: CommentSerializer
def include_associations!
include! :comments unless object.comments_disabled
@@ -139,7 +139,7 @@ def include_associations!
class PostWithMultipleConditionalsSerializer < ActiveModel::Serializer
root :post
attributes :title, :body, :author
- has_many :comments, :serializer => CommentSerializer
+ has_many :comments, serializer: CommentSerializer
def include_comments?
!object.comments_disabled
@@ -159,7 +159,7 @@ class AuthorSerializer < ActiveModel::Serializer
end
class BlogSerializer < ActiveModel::Serializer
- has_one :author, :serializer => AuthorSerializer
+ has_one :author, serializer: AuthorSerializer
end
class BlogWithRootSerializer < BlogSerializer
@@ -175,8 +175,8 @@ class CustomBlog < Blog
end
class CustomBlogSerializer < ActiveModel::Serializer
- has_many :public_posts, :key => :posts, :serializer => PostSerializer
- has_one :public_user, :key => :user, :serializer => UserSerializer
+ has_many :public_posts, key: :posts, serializer: PostSerializer
+ has_one :public_user, key: :user, serializer: UserSerializer
end
class SomeSerializer < ActiveModel::Serializer
From d10b5f6ac0fixes #310
---
README.md | 14 ++++++++++++--
1 file changed, 12 insertions(+), 2 deletions(-)
diff --git a/README.md b/README.md
index 908bf30..a538677 100644
--- a/README.md
+++ b/README.md
@@ -13,13 +13,13 @@ content.
In short, **serializers replace hash-driven development with object-oriented
development.**
-# Installing Serializers
+# Installing
The easiest way to install `ActiveModel::Serializers` is to add it to your
`Gemfile`:
```ruby
-gem "active_model_serializers", "~> 0.8.0"
+gem "active_model_serializers"
```
Then, install it on the command line:
@@ -28,6 +28,16 @@ Then, install it on the command line:
$ bundle install
. ```
+ #### Ruby 1.8 is no longer supported!
+
+If you must use a ruby 1.8 version (MRI 1.8.7, REE, Rubinius 1.8, or JRuby 1.8), you need to use version 0.8.x.
+Versions after 0.9.0 do not support ruby 1.8. To specify version 0.8, include this in your Gemfile:
+
+```ruby
+gem "active_model_serializers", "~> 0.8.0"
+```
+
+
# Creating a Serializer
The easiest way to create a new serializer is to generate a new resource, which
From 31e1dab69f725952c8620d674369ff173f3f2a1774af00f17a88ff42ebc854ce37b956027aa38138a62680c88323748e7f2bhttps://api.travis-ci.org/rails-api/active_model_serializers.png )](https://travis-ci.org/rails-api/active_model_serializers ) [](https://codeclimate.com/github/rails-api/active_model_serializers ) [](https://coveralls.io/r/rails-api/active_model_serializers )
+[](https://travis-ci.org/rails-api/active_model_serializers ) [](https://codeclimate.com/github/rails-api/active_model_serializers ) [](https://coveralls.io/r/rails-api/active_model_serializers )
# Purpose
@@ -13,7 +13,7 @@ content.
In short, **serializers replace hash-driven development with object-oriented
development.**
-# Installing
+# Installing
The easiest way to install `ActiveModel::Serializers` is to add it to your
`Gemfile`:
@@ -28,7 +28,7 @@ Then, install it on the command line:
$ bundle install
```
-#### Ruby 1.8 is no longer supported!
+#### Ruby 1.8 is no longer supported!
If you must use a ruby 1.8 version (MRI 1.8.7, REE, Rubinius 1.8, or JRuby 1.8), you need to use version 0.8.x.
Versions after 0.9.0 do not support ruby 1.8. To specify version 0.8, include this in your Gemfile:
@@ -177,7 +177,7 @@ In an initializer:
ActiveSupport.on_load(:active_model_serializers) do
# Disable for all serializers (except ArraySerializer)
ActiveModel::Serializer.root = false
-
+
# Disable for ArraySerializer
ActiveModel::ArraySerializer.root = false
end
@@ -693,3 +693,24 @@ end
```
The caching interface uses `Rails.cache` under the hood.
+
+# Design and Implementation
+
+## Keep it Simple
+
+ActiveModel::Serializers is capable of producing complex JSON views/large object
+trees, and it may be tempting to design in this way so that your client can make
+fewer requests to get data and so that related querying can be optimized.
+However, keeping things simple in your serializers and controllers may
+significantly reduce complexity and maintenance over the long-term development
+of your application. Please consider reducing the complexity of the JSON views
+you provide via the serializers as you build out your application, so that
+controllers/services can be more easily reused without a lot of complexity
+later.
+
+## Performance
+
+As you develop your controllers or other code that utilizes serializers, try to
+avoid n+1 queries by ensuring that data loads in an optimal fashion, e.g. if you
+are using ActiveRecord, you might want to use query includes or joins as needed
+to make the data available that the serializer(s) need.
```
2016-03-11 09:45:19 -06:00
Ben Mills
Benjamin Fleischer
Benjamin Fleischer
L. Preston Sego III
Eric Guo
Yohan Robert
Ben Morrall
João Moura
Tomasz Korzeniowski
