active_model_serializers 0.8.3 → 0.9.0.alpha1

data/lib/active_model_serializers.rb

@@ -1,85 +1,8 @@
-require "active_support"
-require "active_support/core_ext/string/inflections"
-require "active_support/notifications"
-require "active_model"
-require "active_model/array_serializer"
-require "active_model/serializer"
-require "active_model/serializer/associations"
-require "set"
-
-if defined?(Rails)
-  module ActiveModel
-    class Railtie < Rails::Railtie
-      generators do |app|
-        app ||= Rails.application # Rails 3.0.x does not yield `app`
-
-        Rails::Generators.configure!(app.config.generators)
-        Rails::Generators.hidden_namespaces.uniq!
-        require_relative "generators/resource_override"
-      end
-
-      initializer "include_routes.active_model_serializer" do |app|
-        ActiveSupport.on_load(:active_model_serializers) do
-          include app.routes.url_helpers
-        end
-      end
-
-      initializer "caching.active_model_serializer" do |app|
-        ActiveModel::Serializer.perform_caching = app.config.action_controller.perform_caching
-        ActiveModel::ArraySerializer.perform_caching = app.config.action_controller.perform_caching
-
-        ActiveModel::Serializer.cache = Rails.cache
-        ActiveModel::ArraySerializer.cache = Rails.cache
-      end
-    end
-  end
-end
-
-module ActiveModel::SerializerSupport
-  extend ActiveSupport::Concern
-
-  module ClassMethods #:nodoc:
-    if "".respond_to?(:safe_constantize)
-      def active_model_serializer
-        "#{self.name}Serializer".safe_constantize
-      end
-    else
-      def active_model_serializer
-        begin
-          "#{self.name}Serializer".constantize
-        rescue NameError => e
-          raise unless e.message =~ /uninitialized constant/
-        end
-      end
-    end
-  end
-
-  # Returns a model serializer for this object considering its namespace.
-  def active_model_serializer
-    self.class.active_model_serializer
-  end
-
-  alias :read_attribute_for_serialization :send
-end
-
-module ActiveModel::ArraySerializerSupport
-  def active_model_serializer
-    ActiveModel::ArraySerializer
-  end
-end
-
-Array.send(:include, ActiveModel::ArraySerializerSupport)
-Set.send(:include, ActiveModel::ArraySerializerSupport)
-
-{
-  :active_record => 'ActiveRecord::Relation',
-  :mongoid => 'Mongoid::Criteria'
-}.each do |orm, rel_class|
-  ActiveSupport.on_load(orm) do
-    include ActiveModel::SerializerSupport
-    rel_class.constantize.send(:include, ActiveModel::ArraySerializerSupport)
-  end
-end
+require 'active_model'
+require 'active_model/serializer'
+require 'active_model/serializer_support'
+require 'active_model/serializer/version'
+require 'active_model/serializer/railtie' if defined?(Rails)
 
 begin
   require 'action_controller'
@@ -88,8 +11,6 @@ begin
   ActiveSupport.on_load(:action_controller) do
     include ::ActionController::Serialization
   end
-rescue LoadError => ex
-  # rails on installed, continuing
+rescue LoadError
+  # rails not installed, continuing
 end
-
-ActiveSupport.run_load_hooks(:active_model_serializers, ActiveModel::Serializer)

data/test/coverage_setup.rb

@@ -0,0 +1,15 @@
+begin
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    add_group "lib", "lib"
+    add_group "test", "test"
+  end
+rescue LoadError
+end

data/test/fixtures/active_record.rb

@@ -0,0 +1,92 @@
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => 'sqlite3',
+  :database => ':memory:'
+)
+
+ActiveRecord::Schema.define do
+  create_table :ar_posts, force: true do |t|
+    t.string     :title
+    t.text       :body
+    t.belongs_to :ar_section, index: true
+    t.timestamps
+  end
+
+  create_table :ar_comments, force: true do |t|
+    t.text       :body
+    t.belongs_to :ar_post, index: true
+    t.timestamps
+  end
+
+  create_table :ar_tags, force: true do |t|
+    t.string :name
+  end
+
+  create_table :ar_sections, force: true do |t|
+    t.string :name
+  end
+
+  create_table :ar_posts_tags, force: true do |t|
+    t.references :ar_post, :ar_tag, index: true
+  end
+
+  create_table :ar_comments_tags, force: true do |t|
+    t.references :ar_comment, :ar_tag, index: true
+  end
+end
+
+class ARPost < ActiveRecord::Base
+  has_many :ar_comments, class_name: 'ARComment'
+  has_and_belongs_to_many :ar_tags, class_name: 'ARTag', join_table: :ar_posts_tags
+  belongs_to :ar_section, class_name: 'ARSection'
+end
+
+class ARComment < ActiveRecord::Base
+  belongs_to :ar_post, class_name: 'ARPost'
+  has_and_belongs_to_many :ar_tags, class_name: 'ARTag', join_table: :ar_comments_tags
+end
+
+class ARTag < ActiveRecord::Base
+end
+
+class ARSection < ActiveRecord::Base
+end
+
+class ARPostSerializer < ActiveModel::Serializer
+  attributes :title, :body
+
+  has_many :ar_comments, :ar_tags
+  has_one  :ar_section
+end
+
+class ARCommentSerializer < ActiveModel::Serializer
+  attributes :body
+
+  has_many :ar_tags
+end
+
+class ARTagSerializer < ActiveModel::Serializer
+  attributes :name
+end
+
+class ARSectionSerializer < ActiveModel::Serializer
+  attributes 'name'
+end
+
+ARPost.create(title: 'New post',
+              body:  'A body!!!',
+              ar_section: ARSection.create(name: 'ruby')).tap do |post|
+
+  short_tag = post.ar_tags.create(name: 'short')
+  whiny_tag = post.ar_tags.create(name: 'whiny')
+  happy_tag = ARTag.create(name: 'happy')
+
+  post.ar_comments.create(body: 'what a dumb post').tap do |comment|
+    comment.ar_tags.concat happy_tag, whiny_tag
+  end
+
+  post.ar_comments.create(body: 'i liked it').tap do |comment|
+    comment.ar_tags.concat happy_tag, short_tag
+  end
+end

data/test/fixtures/poro.rb

@@ -0,0 +1,64 @@
+class Model
+  def initialize(hash={})
+    @attributes = hash
+  end
+
+  def read_attribute_for_serialization(name)
+    if name == :id || name == 'id'
+      object_id
+    else
+      @attributes[name]
+    end
+  end
+end
+
+
+###
+## Models
+###
+class User < Model
+  def profile
+    @profile ||= Profile.new(name: 'N1', description: 'D1')
+  end
+end
+
+class Profile < Model
+end
+
+class Post < Model
+  def comments
+    @comments ||= [Comment.new(content: 'C1'),
+                   Comment.new(content: 'C2')]
+  end
+end
+
+class Comment < Model
+end
+
+###
+## Serializers
+###
+class UserSerializer < ActiveModel::Serializer
+  attributes :name, :email
+
+  has_one :profile
+end
+
+class ProfileSerializer < ActiveModel::Serializer
+  def description
+    description = object.read_attribute_for_serialization(:description)
+    scope ? "#{description} - #{scope}" : description
+  end
+
+  attributes :name, :description
+end
+
+class PostSerializer < ActiveModel::Serializer
+  attributes :title, :body
+
+  has_many :comments
+end
+
+class CommentSerializer < ActiveModel::Serializer
+  attributes :content
+end

data/test/integration/action_controller/serialization_test.rb

@@ -0,0 +1,234 @@
+require 'test_helper'
+
+module ActionController
+  module Serialization
+    class ImplicitSerializerTest < ActionController::TestCase
+      class MyController < ActionController::Base
+        def render_using_implicit_serializer
+          render json: Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
+        end
+      end
+
+      tests MyController
+
+      def test_render_using_implicit_serializer
+        get :render_using_implicit_serializer
+        assert_equal 'application/json', @response.content_type
+        assert_equal '{"profile":{"name":"Name 1","description":"Description 1"}}', @response.body
+      end
+    end
+
+    class ImplicitSerializerScopeTest < ActionController::TestCase
+      class MyController < ActionController::Base
+        def render_using_implicit_serializer_and_scope
+          render json: Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
+        end
+
+        private
+
+        def current_user
+          'current_user'
+        end
+      end
+
+      tests MyController
+
+      def test_render_using_implicit_serializer_and_scope
+        get :render_using_implicit_serializer_and_scope
+        assert_equal 'application/json', @response.content_type
+        assert_equal '{"profile":{"name":"Name 1","description":"Description 1 - current_user"}}', @response.body
+      end
+    end
+
+    class DefaultOptionsForSerializerScopeTest < ActionController::TestCase
+      class MyController < ActionController::Base
+        def default_serializer_options
+          { scope: current_admin }
+        end
+
+        def render_using_scope_set_in_default_serializer_options
+          render json: Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
+        end
+
+        private
+
+        def current_user
+          'current_user'
+        end
+
+        def current_admin
+          'current_admin'
+        end
+      end
+
+      tests MyController
+
+      def test_render_using_scope_set_in_default_serializer_options
+        get :render_using_scope_set_in_default_serializer_options
+        assert_equal 'application/json', @response.content_type
+        assert_equal '{"profile":{"name":"Name 1","description":"Description 1 - current_admin"}}', @response.body
+      end
+    end
+
+    class ExplicitSerializerScopeTest < ActionController::TestCase
+      class MyController < ActionController::Base
+        def render_using_implicit_serializer_and_explicit_scope
+          render json: Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' }), scope: current_admin
+        end
+
+        private
+
+        def current_user
+          'current_user'
+        end
+
+        def current_admin
+          'current_admin'
+        end
+      end
+
+      tests MyController
+
+      def test_render_using_implicit_serializer_and_explicit_scope
+        get :render_using_implicit_serializer_and_explicit_scope
+        assert_equal 'application/json', @response.content_type
+        assert_equal '{"profile":{"name":"Name 1","description":"Description 1 - current_admin"}}', @response.body
+      end
+    end
+
+    class OverridingSerializationScopeTest < ActionController::TestCase
+      class MyController < ActionController::Base
+        def render_overriding_serialization_scope
+          render json: Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
+        end
+
+        private
+
+        def current_user
+          'current_user'
+        end
+
+        def serialization_scope
+          'current_admin'
+        end
+      end
+
+      tests MyController
+
+      def test_render_overriding_serialization_scope
+        get :render_overriding_serialization_scope
+        assert_equal 'application/json', @response.content_type
+        assert_equal '{"profile":{"name":"Name 1","description":"Description 1 - current_admin"}}', @response.body
+      end
+    end
+
+    class CallingSerializationScopeTest < ActionController::TestCase
+      class MyController < ActionController::Base
+        def render_calling_serialization_scope
+          render json: Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
+        end
+
+        private
+
+        def current_user
+          'current_user'
+        end
+
+        serialization_scope :current_user
+      end
+
+      tests MyController
+
+      def test_render_calling_serialization_scope
+        get :render_calling_serialization_scope
+        assert_equal 'application/json', @response.content_type
+        assert_equal '{"profile":{"name":"Name 1","description":"Description 1 - current_user"}}', @response.body
+      end
+    end
+
+    class JSONDumpSerializerTest < ActionController::TestCase
+      class MyController < ActionController::Base
+        def render_using_json_dump
+          render json: JSON.dump(hello: 'world')
+        end
+      end
+
+      tests MyController
+
+      def test_render_using_json_dump
+        get :render_using_json_dump
+        assert_equal 'application/json', @response.content_type
+        assert_equal '{"hello":"world"}', @response.body
+      end
+    end
+
+    class RailsSerializerTest < ActionController::TestCase
+      class MyController < ActionController::Base
+        def render_using_rails_behavior
+          render json: [Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })], serializer: false
+        end
+      end
+
+      tests MyController
+
+      def test_render_using_rails_behavior
+        get :render_using_rails_behavior
+        assert_equal 'application/json', @response.content_type
+        assert_equal '[{"attributes":{"name":"Name 1","description":"Description 1","comments":"Comments 1"}}]', @response.body
+      end
+    end
+
+    class ArraySerializerTest < ActionController::TestCase
+      class MyController < ActionController::Base
+        def render_array
+          render json: [Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })]
+        end
+      end
+
+      tests MyController
+
+      def test_render_array
+        get :render_array
+        assert_equal 'application/json', @response.content_type
+        assert_equal '{"my":[{"name":"Name 1","description":"Description 1"}]}', @response.body
+      end
+    end
+
+    class ArrayEmbedingSerializerTest < ActionController::TestCase
+      def setup
+        super
+        @association = UserSerializer._associations[:profile]
+        @old_association = @association.dup
+      end
+
+      def teardown
+        super
+        UserSerializer._associations[:profile] = @old_association
+      end
+
+      class MyController < ActionController::Base
+        def initialize(*)
+          super
+          @user = User.new({ name: 'Name 1', email: 'mail@server.com', gender: 'M' })
+        end
+        attr_reader :user
+
+        def render_array_embeding_in_root
+          render json: [@user]
+        end
+      end
+
+      tests MyController
+
+      def test_render_array_embeding_in_root
+        @association.embed = :ids
+        @association.embed_in_root = true
+
+        get :render_array_embeding_in_root
+        assert_equal 'application/json', @response.content_type
+
+        assert_equal("{\"my\":[{\"name\":\"Name 1\",\"email\":\"mail@server.com\",\"profile_id\":#{@controller.user.profile.object_id}}],\"profiles\":[{\"name\":\"N1\",\"description\":\"D1\"}]}", @response.body)
+      end
+    end
+  end
+end

data/test/integration/active_record/active_record_test.rb

@@ -0,0 +1,77 @@
+require 'test_helper'
+require 'fixtures/active_record'
+
+module ActiveModel
+  class Serializer
+    class ActiveRecordTest < ActiveModel::TestCase
+      def setup
+        @post = ARPost.first
+      end
+
+      def test_serialization_embedding_objects
+        post_serializer = ARPostSerializer.new(@post)
+
+        assert_equal({
+          'ar_post' => {
+            title: 'New post', body: 'A body!!!',
+            ar_comments: [{ body: 'what a dumb post', ar_tags: [{ name: 'happy' }, { name: 'whiny' }] },
+                          { body: 'i liked it', ar_tags: [{:name=>"happy"}, {:name=>"short"}] }],
+            ar_tags: [{ name: 'short' }, { name: 'whiny' }],
+            ar_section: { 'name' => 'ruby' }
+          }
+        }, post_serializer.as_json)
+      end
+
+      def test_serialization_embedding_ids
+        post_serializer = ARPostSerializer.new(@post)
+
+        embed(ARPostSerializer, embed: :ids) do
+          assert_equal({
+            'ar_post' => {
+              title: 'New post', body: 'A body!!!',
+              'ar_comment_ids' => [1, 2],
+              'ar_tag_ids' => [1, 2],
+              'ar_section_id' => 1
+            }
+          }, post_serializer.as_json)
+        end
+      end
+
+      def test_serialization_embedding_ids_including_in_root
+        post_serializer = ARPostSerializer.new(@post)
+
+        embed(ARPostSerializer, embed: :ids, embed_in_root: true) do
+          embed(ARCommentSerializer, embed: :ids, embed_in_root: true) do
+            assert_equal({
+              'ar_post' => {
+                title: 'New post', body: 'A body!!!',
+                'ar_comment_ids' => [1, 2],
+                'ar_tag_ids' => [1, 2],
+                'ar_section_id' => 1
+              },
+              ar_comments: [{ body: 'what a dumb post', 'ar_tag_ids' => [3, 2] },
+                            { body: 'i liked it', 'ar_tag_ids' => [3, 1] }],
+              ar_tags: [{ name: 'happy' }, { name: 'whiny' }, { name: 'short' }],
+              'ar_sections' => [{ 'name' => 'ruby' }]
+            }, post_serializer.as_json)
+          end
+        end
+      end
+
+      private
+
+      def embed(serializer_class, options = {})
+        old_assocs = Hash[serializer_class._associations.to_a.map { |(name, association)| [name, association.dup] }]
+
+        serializer_class._associations.each_value do |association|
+          association.embed = options[:embed]
+          association.embed_in_root = options[:embed_in_root]
+        end
+
+        yield
+      ensure
+        serializer_class._associations = old_assocs
+      end
+    end
+  end
+end

data/test/integration/generators/resource_generator_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+require 'rails'
+require 'active_model/serializer/railtie'
+require 'test_app'
+
+class ResourceGeneratorTest < Rails::Generators::TestCase
+  destination File.expand_path('../../../tmp', __FILE__)
+  setup :prepare_destination, :copy_routes
+
+  tests Rails::Generators::ResourceGenerator
+  arguments %w(account)
+
+  def test_serializer_file_is_generated
+    run_generator
+
+    assert_file 'app/serializers/account_serializer.rb', /class AccountSerializer < ActiveModel::Serializer/
+  end
+
+  private
+
+  def copy_routes
+    config_dir = File.join(destination_root, 'config')
+    FileUtils.mkdir_p(config_dir)
+    File.write(File.join(config_dir, 'routes.rb'), 'Rails.application.routes.draw { }')
+  end
+end

data/test/integration/generators/scaffold_controller_generator_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+require 'rails'
+require 'active_model/serializer/railtie'
+require 'test_app'
+
+class ScaffoldControllerGeneratorTest < Rails::Generators::TestCase
+  destination File.expand_path('../../../tmp', __FILE__)
+  setup :prepare_destination
+
+  tests Rails::Generators::ScaffoldControllerGenerator
+  arguments %w(account name:string description:text business:references)
+
+  def test_generated_controller
+    return true if Rails::VERSION::MAJOR < 4
+
+    run_generator
+
+    assert_file 'app/controllers/accounts_controller.rb' do |content|
+      
+      assert_instance_method :index, content do |m|
+        assert_match /@accounts = Account\.all/, m
+        assert_match /format.html/, m
+        assert_match /format.json \{ render json: @accounts \}/, m
+      end
+
+      assert_instance_method :show, content do |m|
+        assert_match /format.html/, m
+        assert_match /format.json \{ render json: @account \}/, m
+      end
+
+      assert_instance_method :new, content do |m|
+        assert_match /@account = Account\.new/, m
+      end
+
+      assert_instance_method :edit, content do |m|
+        assert m.blank?
+      end
+
+      assert_instance_method :create, content do |m|
+        assert_match /@account = Account\.new\(account_params\)/, m
+        assert_match /@account\.save/, m
+        assert_match /format\.html \{ redirect_to @account, notice: 'Account was successfully created\.' \}/, m
+        assert_match /format\.json \{ render json: @account, status: :created \}/, m
+        assert_match /format\.html \{ render action: 'new' \}/, m
+        assert_match /format\.json \{ render json: @account\.errors, status: :unprocessable_entity \}/, m
+      end
+
+      assert_instance_method :update, content do |m|
+        assert_match /format\.html \{ redirect_to @account, notice: 'Account was successfully updated\.' \}/, m
+        assert_match /format\.json \{ head :no_content \}/, m
+        assert_match /format\.html \{ render action: 'edit' \}/, m
+        assert_match /format\.json \{ render json: @account.errors, status: :unprocessable_entity \}/, m
+      end
+
+      assert_instance_method :destroy, content do |m|
+        assert_match /@account\.destroy/, m
+        assert_match /format\.html { redirect_to accounts_url \}/, m
+        assert_match /format\.json \{ head :no_content \}/, m
+      end
+
+      assert_match(/def account_params/, content)
+      assert_match(/params\.require\(:account\)\.permit\(:name, :description, :business_id\)/, content)
+
+    end
+
+  end
+end