active_model_serializers 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e52d190b9a08bf39665a61da10e5c1103b553016
-  data.tar.gz: 5ca66e11bde1221cee716a40b48b71f3f3600a09
+  metadata.gz: 806e6040b82178f17890aaa7d76e431ebf41fac6
+  data.tar.gz: 68562583b4d96f5e7baf0e35f86d39d6f8267cb1
 SHA512:
-  metadata.gz: 95648244da95ed7a5d69aa91079a89098864d1fe7d4b7d827caeb3b45e019f4e07ddf563c34ee154eb43e9501ac485ba624e6abef6c131cb8fbf79a9bfefc4b8
-  data.tar.gz: 727fb1fa750281605e22c8830212304eb83ac209c2ab2743e7f8695d763eee5635c97d2db6994678b77620385c50899583fd552eb94ffe821c29d1ba10c5d9cb
+  metadata.gz: 33e9ffa81d5121eb929e83e50c80b16fb68a322210dddcaea36396ea18ac4fb1c2862ff025a175fe87e7a70d85bc5208866e7ee2f3aa3093dda503a229652429
+  data.tar.gz: 672a0655b5d4dd8d93003d4c18d6b2606e804d381fbe3d5777d46ec04711ae5a81a26a95b34c9d796c4ceb34abd800f2685f343c33f60a23a544df9db6754ad9

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+*.swp

data/.travis.yml

@@ -1,11 +1,9 @@
 language: ruby
-before_install:
-  - gem install bundler
 rvm:
   - 1.8.7
   - 1.9.2
   - 1.9.3
-  - ruby-head
+  - 2.0.0
   - ree
   - jruby-18mode
   - jruby-19mode
@@ -15,6 +13,8 @@ gemfile:
   - Gemfile
   - Gemfile.edge
 matrix:
+  allow_failures:
+    - gemfile: Gemfile.edge
   exclude:
     # Edge Rails is only compatible with 1.9.3
     - gemfile: Gemfile.edge

data/CHANGELOG.md

@@ -0,0 +1,61 @@
+# UNRELEASED
+
+# VERSION 0.8.0
+
+* Attributes can now have optional types.
+
+* A new DefaultSerializer ensures that POROs behave the same way as ActiveModels.
+
+* If you wish to override ActiveRecord::Base#to_Json, you can now require
+  'active_record/serializer_override'. We don't recommend you do this, but
+  many users do, so we've left it optional.
+
+* Fixed a bug where ActionController wouldn't always have MimeResponds.
+
+* An optinal caching feature allows you to cache JSON & hashes that AMS uses.
+  Adding 'cached true' to your Serializers will turn on this cache.
+
+* URL helpers used inside of Engines now work properly.
+
+* Serializers now can filter attributes with `only` and `except`:
+  
+  UserSerializer.new(user, only: [:first_name, :last_name])
+  UserSerializer.new(user, except: :first_name)
+
+* Basic Mongoid support. We now include our mixins in the right place.
+
+* On Ruby 1.8, we now generate an `id` method that properly serializes `id`
+  columns. See issue #127 for more.
+
+* Add an alias for `scope` method to be the name of the context. By default
+  this is `current_user`. The name is automatically set when using
+  `serialization_scope` in the controller.
+
+* Pass through serialization options (such as `:include`) when a model
+  has no serializer defined.
+
+# VERSION 0.7.0
+
+* ```embed_key``` option to allow embedding by attributes other than IDs
+* Fix rendering nil with custom serializer
+* Fix global ```self.root = false```
+* Add support for specifying the serializer for an association as a String
+* Able to specify keys on the attributes method
+* Serializer Reloading via ActiveSupport::DescendantsTracker
+* Reduce double map to once; Fixes datamapper eager loading.
+
+# VERSION 0.6.0
+
+* Serialize sets properly
+* Add root option to ArraySerializer
+* Support polymorphic associations
+* Support :each_serializer in ArraySerializer
+* Add `scope` method to easily access the scope in the serializer
+* Fix regression with Rails 3.2.6; add Rails 4 support
+* Allow serialization_scope to be disabled with serialization_scope nil
+* Array serializer should support pure ruby objects besides serializers
+
+# VERSION 0.5.0 (May 16, 2012)
+
+* First tagged version
+* Changes generators to always generate an ApplicationSerializer

data/DESIGN.textile

@@ -217,7 +217,7 @@ First, we specified the list of included attributes at the top of the class. Thi
 
 NOTE: Internally, +ActiveModel::Serializer+ uses +read_attribute_for_serialization+, which defaults to +read_attribute+, which defaults to +send+. So if you're rolling your own models for use with the serializer, you can use simple Ruby accessors for your attributes if you like.
 
-Next, we use the attributes methood in our +serializable_hash+ method, which allowed us to eliminate the +post+ method we hand-rolled
+Next, we use the attributes method in our +serializable_hash+ method, which allowed us to eliminate the +post+ method we hand-rolled
 earlier. We could also eliminate the +as_json+ method, as +ActiveModel::Serializer+ provides a default +as_json+ method for
 us that calls our +serializable_hash+ method and inserts a root. But we can go a step further!
 
@@ -354,7 +354,7 @@ h4. Modifying Associations
 You can also rename associations if required. Say for example you have an association that
 makes sense to be named one thing in your code, but another when data is serialized.
 You can use the <code:key</code> option to specify a different name for an association.
-Here is an exmaple:
+Here is an example:
 
 <pre lang="ruby">
 class UserSerializer < ActiveModel::Serializer

data/Gemfile

@@ -1,4 +1,6 @@
-source 'http://rubygems.org'
+source 'https://rubygems.org'
 
 # Specify gem dependencies in active_model_serializers.gemspec
 gemspec
+
+gem "coveralls", :require => false

data/README.md

@@ -1,4 +1,4 @@
-[![Build Status](https://secure.travis-ci.org/rails-api/active_model_serializers.png)](http://travis-ci.org/rails-api/active_model_serializers)
+[![Build Status](https://api.travis-ci.org/rails-api/active_model_serializers.png)](https://travis-ci.org/rails-api/active_model_serializers) [![Code Climate](https://codeclimate.com/github/rails-api/active_model_serializers.png)](https://codeclimate.com/github/rails-api/active_model_serializers) [![Coverage Status](https://coveralls.io/repos/rails-api/active_model_serializers/badge.png?branch=master)](https://coveralls.io/r/rails-api/active_model_serializers) 
 
 # Purpose
 
@@ -10,16 +10,16 @@ Serializers know about both a model and the `current_user`, so you can
 customize serialization based upon whether a user is authorized to see the
 content.
 
-In short, **serializers replaces hash-driven development with object-oriented
+In short, **serializers replace hash-driven development with object-oriented
 development.**
 
 # Installing Serializers
 
-For now, the easiest way to install `ActiveModel::Serializers` is to add it
-to your `Gemfile`:
+The easiest way to install `ActiveModel::Serializers` is to add it to your
+`Gemfile`:
 
 ```ruby
-gem "active_model_serializers", "~> 0.6.0"
+gem "active_model_serializers", "~> 0.7.0"
 ```
 
 Then, install it on the command line:
@@ -48,10 +48,14 @@ $ rails g serializer post
 ### Support for PORO's and other ORM's.
 
 Currently `ActiveModel::Serializers` adds serialization support to all models
-that descend from `ActiveRecord`. If you are using another ORM or if you are
-using objects that are `ActiveModel` compliant, but do not descend from
-`ActiveRecord`. You must add an include statement for
-`ActiveModel::SerializerSupport`.
+that descend from `ActiveRecord` or include `Mongoid::Document`. If you are
+using another ORM, or if you are using objects that are `ActiveModel`
+compliant but do not descend from `ActiveRecord` or include
+`Mongoid::Document`, you must add an include statement for
+`ActiveModel::SerializerSupport` to make models serializable. If you
+also want to make collections serializable, you should include
+`ActiveModel::ArraySerializationSupport` into your ORM's
+relation/criteria class.
 
 # ActiveModel::Serializer
 
@@ -135,7 +139,7 @@ render :json => @posts, :root => "some_posts"
 ```
 
 You may disable the root element for arrays at the top level, which will result in
-more concise json. To disable the root element for arrays, you have 3 options:
+more concise json. To disable the root element for arrays, you have 4 options:
 
 #### 1. Disable root globally for in `ArraySerializer`. In an initializer:
 
@@ -181,7 +185,7 @@ render :json => @posts, :each_serializer => FancyPostSerializer
 
 If you define `default_serializer_options` method in your controller,
 all serializers in actions of this controller and it's children will use them.
-One of options may be `root: false`
+One of the options may be `root: false`
 
 ```ruby
 def default_serializer_options
@@ -232,22 +236,36 @@ end
 Within a serializer's methods, you can access the object being
 serialized as `object`.
 
-You can also access the `scope` method, which provides an
-authorization context to your serializer. By default, scope
+You can also access the `current_user` method, which provides an
+authorization context to your serializer. By default, the context
 is the current user of your application, but this
 [can be customized](#customizing-scope).
 
 Serializers will check for the presence of a method named
 `include_[ATTRIBUTE]?` to determine whether a particular attribute should be
 included in the output. This is typically used to customize output
-based on `scope`. For example:
+based on `current_user`. For example:
 
 ```ruby
 class PostSerializer < ActiveModel::Serializer
   attributes :id, :title, :body, :author
 
   def include_author?
-    scope.admin?
+    current_user.admin?
+  end
+end
+```
+
+The type of a computed attribute (like :full_name above) is not easily
+calculated without some sophisticated static code analysis. To specify the
+type of a computed attribute:
+
+```ruby
+class PersonSerializer < ActiveModel::Serializer
+  attributes :first_name, :last_name, {:full_name => :string}
+
+  def full_name
+    "#{object.first_name} #{object.last_name}"
   end
 end
 ```
@@ -311,7 +329,7 @@ class PersonSerializer < ActiveModel::Serializer
 
   def attributes
     hash = super
-    if scope.admin?
+    if current_user.admin?
       hash["ssn"] = object.ssn
       hash["secret"] = object.mothers_maiden_name
     end
@@ -339,7 +357,7 @@ class PostSerializer < ActiveModel::Serializer
 
   # only let the user see comments he created.
   def comments
-    object.comments.where(:created_by => scope)
+    object.comments.where(:created_by => current_user)
   end
 end
 ```
@@ -381,7 +399,7 @@ class PostSerializer < ActiveModel::Serializer
   has_many :comments
 
   def include_associations!
-    include! :author if scope.admin?
+    include! :author if current_user.admin?
     include! :comments unless object.comments_disabled?
   end
 end
@@ -394,6 +412,8 @@ You may also use the `:serializer` option to specify a custom serializer class a
   has_one :reviewer, :polymorphic => true
 ```
 
+Serializers are only concerned with multiplicity, and not ownership. `belongs_to` ActiveRecord associations can be included using `has_one` in your serializer.
+
 ## Embedding Associations
 
 By default, associations will be embedded inside the serialized object. So if
@@ -573,7 +593,7 @@ Ajax requests, you probably just want to use the default embedded behavior.
 
 ## Customizing Scope
 
-In a serializer, `scope` is the current authorization scope which the controller
+In a serializer, `current_user` is the current authorization scope which the controller
 provides to the serializer when you call `render :json`. By default, this is
 `current_user`, but can be customized in your controller by calling
 `serialization_scope`:
@@ -584,6 +604,9 @@ class ApplicationController < ActionController::Base
 end
 ```
 
+The above example will also change the scope name from `current_user` to
+`current_admin`.
+
 Please note that, until now, `serialization_scope` doesn't accept a second
 object with options for specifying which actions should or should not take a
 given scope in consideration.
@@ -612,12 +635,12 @@ class CitiesController < ApplicationController
   def show
     @city = City.find(params[:id])
 
-    render :json => @city, :scope => current_admin?
+    render :json => @city, :scope => current_admin, :scope_name => :current_admin
   end
 end
 ```
 
-Assuming that the `current_admin?` method needs to make a query in the database
+Assuming that the `current_admin` method needs to make a query in the database
 for the current user, the advantage of this approach is that, by setting
 `serialization_scope` to `nil`, the `index` action no longer will need to make
 that query, only the `show` action will.

data/Rakefile

@@ -10,4 +10,9 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = true
 end
 
+desc 'Benchmark'
+task :bench do
+  load 'bench/perf.rb' 
+end
+
 task :default => :test

data/active_model_serializers.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |gem|
   gem.email         = ["jose.valim@gmail.com", "wycats@gmail.com"]
   gem.description   = %q{Making it easy to serialize models for client-side use}
   gem.summary       = %q{Bringing consistency and object orientation to model serialization. Works great for client-side MVC frameworks!}
-  gem.homepage      = "https://github.com/josevalim/active_model_serializers"
+  gem.homepage      = "https://github.com/rails-api/active_model_serializers"
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   gem.files         = `git ls-files`.split("\n")
@@ -21,4 +21,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency "rails", ">= 3.0"
   gem.add_development_dependency "pry"
   gem.add_development_dependency "simplecov"
+  gem.add_development_dependency "coveralls"
 end

data/bench/perf.rb

@@ -0,0 +1,43 @@
+require "rubygems"
+require "bundler/setup"
+require "active_model_serializers"
+require "active_support/json"
+require "benchmark"
+
+class User < Struct.new(:id,:name,:age,:about) 
+  include ActiveModel::SerializerSupport
+  
+  def fast_hash
+    h = { 
+      id: read_attribute_for_serialization(:id), 
+      name: read_attribute_for_serialization(:name), 
+      about: read_attribute_for_serialization(:about)
+    }
+    h[:age] = read_attribute_for_serialization(:age) if age > 18
+    h
+  end
+end
+
+class UserSerializer < ActiveModel::Serializer
+  attributes :id, :name, :age, :about
+
+  def include_age?
+    object.age > 18
+  end
+end
+
+
+
+u = User.new(1, "sam", 10, "about")
+s = UserSerializer.new(u)
+
+n = 100000
+
+Benchmark.bmbm {|x| 
+  x.report("init") { n.times { UserSerializer.new(u) } }
+  x.report("fast_hash") { n.times { u.fast_hash } }
+  x.report("attributes") { n.times { UserSerializer.new(u).attributes } } 
+  x.report("serializable_hash") { n.times { UserSerializer.new(u).serializable_hash } }
+}   
+
+

data/lib/action_controller/serialization.rb

@@ -2,7 +2,7 @@ module ActionController
   # Action Controller Serialization
   #
   # Overrides render :json to check if the given object implements +active_model_serializer+
-  # as a method. If so, use the returned serializer instead of calling +to_json+ in the object.
+  # as a method. If so, use the returned serializer instead of calling +to_json+ on the object.
   #
   # This module also provides a serialization_scope method that allows you to configure the
   # +serialization_scope+ of the serializer. Most apps will likely set the +serialization_scope+
@@ -33,37 +33,20 @@ module ActionController
     end
 
     def serialization_scope
-      send(_serialization_scope) if _serialization_scope && respond_to?(_serialization_scope)
+      send(_serialization_scope) if _serialization_scope && respond_to?(_serialization_scope, true)
     end
 
     def default_serializer_options
     end
 
-    def _render_option_json(json, options)
-      options = default_serializer_options.merge(options) if default_serializer_options
+    def _render_option_json(resource, options)
+      json = ActiveModel::Serializer.build_json(self, resource, options)
 
-      serializer = options.delete(:serializer) ||
-        (json.respond_to?(:active_model_serializer) && json.active_model_serializer)
-
-      if json.respond_to?(:to_ary)
-        unless serializer <= ActiveModel::ArraySerializer
-          raise ArgumentError.new("#{serializer.name} is not an ArraySerializer. " +
-             "You may want to use the :each_serializer option instead.")
-        end
-
-        if options[:root] != false && serializer.root != false
-          # default root element for arrays is serializer's root or the controller name
-          # the serializer for an Array is ActiveModel::ArraySerializer
-          options[:root] ||= serializer.root || controller_name
-        end
-      end
-
-      if serializer
-        options[:scope] = serialization_scope unless options.has_key?(:scope)
-        options[:url_options] = url_options
-        json = serializer.new(json, options)
+      if json
+        super(json, options)
+      else
+        super
       end
-      super
     end
 
     module ClassMethods

data/lib/active_model/array_serializer.rb

@@ -5,7 +5,7 @@ require 'active_support/descendants_tracker'
 module ActiveModel
   # Active Model Array Serializer
   #
-  # It serializes an Array, checking if each element that implements
+  # Serializes an Array, checking if each element implements
   # the +active_model_serializer+ method.
   #
   # To disable serialization of root elements:
@@ -19,28 +19,20 @@ module ActiveModel
 
     class_attribute :root
 
-    def initialize(object, options={})
-      @object, @options = object, options
-    end
-
-    def serializable_array
-      @object.map do |item|
-        if @options.has_key? :each_serializer
-          serializer = @options[:each_serializer]
-        elsif item.respond_to?(:active_model_serializer)
-          serializer = item.active_model_serializer
-        end
+    class_attribute :cache
+    class_attribute :perform_caching
 
-        serializable = serializer ? serializer.new(item, @options) : item
-
-        if serializable.respond_to?(:serializable_hash)
-          serializable.serializable_hash
-        else
-          serializable.as_json
-        end
+    class << self
+      # set perform caching like root
+      def cached(value = true)
+        self.perform_caching = value
       end
     end
 
+    def initialize(object, options={})
+      @object, @options = object, options
+    end
+
     def meta_key
       @options[:meta_key].try(:to_sym) || :meta
     end
@@ -61,6 +53,52 @@ module ActiveModel
         serializable_array
       end
     end
-  end
 
+    def to_json(*args)
+      if perform_caching?
+        cache.fetch expand_cache_key([self.class.to_s.underscore, cache_key, 'to-json']) do
+          super
+        end
+      else
+        super
+      end
+    end
+
+    def serializable_array
+      if perform_caching?
+        cache.fetch expand_cache_key([self.class.to_s.underscore, cache_key, 'serializable-array']) do
+          _serializable_array
+        end
+      else
+        _serializable_array
+      end
+    end
+
+    private
+    def _serializable_array
+      @object.map do |item|
+        if @options.has_key? :each_serializer
+          serializer = @options[:each_serializer]
+        elsif item.respond_to?(:active_model_serializer)
+          serializer = item.active_model_serializer
+        end
+
+        serializable = serializer ? serializer.new(item, @options) : DefaultSerializer.new(item, @options)
+
+        if serializable.respond_to?(:serializable_hash)
+          serializable.serializable_hash
+        else
+          serializable.as_json
+        end
+      end
+    end
+
+    def expand_cache_key(*args)
+      ActiveSupport::Cache.expand_cache_key(args)
+    end
+
+    def perform_caching?
+      perform_caching && cache && respond_to?(:cache_key)
+    end
+  end
 end