active_model_serializers 0.8.3 → 0.9.1

data/lib/active_model/serializer_support.rb

@@ -0,0 +1,5 @@
+module ActiveModel
+  module SerializerSupport
+    alias read_attribute_for_serialization send
+  end
+end

data/lib/active_model_serializers.rb

@@ -1,95 +1,20 @@
-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'
   require 'action_controller/serialization'
+  require 'action_controller/serialization_test_case'
 
   ActiveSupport.on_load(:action_controller) do
-    include ::ActionController::Serialization
+    if ::ActionController::Serialization.enabled
+      ActionController::Base.send(:include, ::ActionController::Serialization)
+      ActionController::TestCase.send(:include, ::ActionController::SerializationAssertions)
+    end
   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/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,184 @@
+class Model
+  def initialize(hash = {})
+    @attributes = hash
+  end
+
+  def read_attribute_for_serialization(name)
+    if name == :id || name == 'id'
+      object_id
+    elsif respond_to?(name)
+      send name
+    else
+      @attributes[name]
+    end
+  end
+end
+
+
+###
+## Models
+###
+class User < Model
+  def profile
+    @profile ||= Profile.new(name: 'N1', description: 'D1')
+  end
+end
+
+class UserInfo < Model
+  def user
+    @user ||= User.new(name: 'N1', email: 'E1')
+  end
+end
+
+class Profile < Model
+end
+
+class Category < Model
+  def posts
+    @posts ||= [Post.new(title: 'T1', body: 'B1'),
+                Post.new(title: 'T2', body: 'B2')]
+  end
+end
+
+class Post < Model
+  def comments
+    @comments ||= [Comment.new(content: 'C1'),
+                   Comment.new(content: 'C2')]
+  end
+end
+
+class SpecialPost < Post
+  def special_comment
+    @speical_comment ||= Comment.new(content: 'special')
+  end
+end
+
+class Comment < Model
+end
+
+class WebLog < Model
+end
+
+class Interview < Model
+  def attachment
+    @attachment ||= Image.new(url: 'U1')
+  end
+end
+
+class Mail < Model
+  def attachments
+    @attachments ||= [Image.new(url: 'U1'),
+                      Video.new(html: 'H1')]
+  end
+end
+
+class Image < Model
+end
+
+class Video < Model
+end
+
+###
+## Serializers
+###
+class UserSerializer < ActiveModel::Serializer
+  attributes :name, :email
+
+  has_one :profile
+end
+
+class UserInfoSerializer < ActiveModel::Serializer
+  has_one :user
+end
+
+class ProfileSerializer < ActiveModel::Serializer
+  def description
+    description = object.read_attribute_for_serialization(:description)
+    scope ? "#{description} - #{scope}" : description
+  end
+
+  attributes :name, :description
+end
+
+class DifferentProfileSerializer < ActiveModel::Serializer
+  attributes :name
+end
+
+class CategorySerializer < ActiveModel::Serializer
+  attributes :name
+
+  has_many :posts
+end
+
+class PostSerializer < ActiveModel::Serializer
+  attributes :title, :body
+
+  has_many :comments
+end
+
+class SpecialPostSerializer < ActiveModel::Serializer
+  attributes :title, :body
+  has_many :comments, root: :comments, embed_in_root: true, embed: :ids
+  has_one :special_comment, root: :comments, embed_in_root: true, embed: :ids
+end
+
+class CommentSerializer < ActiveModel::Serializer
+  attributes :content
+end
+
+class WebLogSerializer < ActiveModel::Serializer
+  attributes :name, :display_name
+end
+
+class WebLogLowerCamelSerializer < WebLogSerializer
+  format_keys :lower_camel
+end
+
+class InterviewSerializer < ActiveModel::Serializer
+  attributes :text
+
+  has_one :attachment, polymorphic: true
+end
+
+class MailSerializer < ActiveModel::Serializer
+  attributes :body
+
+  has_many :attachments, polymorphic: true
+end
+
+class ImageSerializer < ActiveModel::Serializer
+  attributes :url
+end
+
+class VideoSerializer < ActiveModel::Serializer
+  attributes :html
+end
+
+class ShortProfileSerializer < ::ProfileSerializer; end
+
+module TestNamespace
+  class ProfileSerializer < ::ProfileSerializer; end
+  class UserSerializer    < ::UserSerializer;    end
+end
+
+ActiveModel::Serializer.setup do |config|
+  config.default_key_type = :name
+end
+
+class NameKeyUserSerializer < ActiveModel::Serializer
+  attributes :name, :email
+
+  has_one :profile
+end
+
+class NameKeyPostSerializer < ActiveModel::Serializer
+  attributes :title, :body
+  
+  has_many :comments
+end
+
+ActiveModel::Serializer.setup do |config|
+  config.default_key_type = nil
+end
+
+

data/test/fixtures/template.html.erb

@@ -0,0 +1 @@
+<p>Hello.</p>

data/test/integration/action_controller/namespaced_serialization_test.rb

@@ -0,0 +1,96 @@
+require 'test_helper'
+
+module ActionController
+  module Serialization
+    class NamespacedSerializationTest < ActionController::TestCase
+      class TestNamespace::MyController < ActionController::Base
+        def render_profile_with_namespace
+          render json: Profile.new({ name: 'Name 1', description: 'Description 1'})
+        end
+
+        def render_profiles_with_namespace
+          render json: [Profile.new({ name: 'Name 1', description: 'Description 1'})]
+        end
+
+        def render_comment
+          render json: Comment.new(content: 'Comment 1')
+        end
+
+        def render_comments
+          render json: [Comment.new(content: 'Comment 1')]
+        end
+      end
+
+      tests TestNamespace::MyController
+
+      def test_render_profile_with_namespace
+        get :render_profile_with_namespace
+        assert_serializer TestNamespace::ProfileSerializer
+      end
+
+      def test_render_profiles_with_namespace
+        get :render_profiles_with_namespace
+        assert_serializer TestNamespace::ProfileSerializer
+      end
+
+      def test_fallback_to_a_version_without_namespace
+        get :render_comment
+        assert_serializer CommentSerializer
+      end
+
+      def test_array_fallback_to_a_version_without_namespace
+        get :render_comments
+        assert_serializer CommentSerializer
+      end
+    end
+
+    class OptionNamespacedSerializationTest < ActionController::TestCase
+      class MyController < ActionController::Base
+        def default_serializer_options
+          {
+            namespace: TestNamespace
+          }
+        end
+
+        def render_profile_with_namespace_option
+          render json: Profile.new({ name: 'Name 1', description: 'Description 1'})
+        end
+
+        def render_profiles_with_namespace_option
+          render json: [Profile.new({ name: 'Name 1', description: 'Description 1'})]
+        end
+
+        def render_comment
+          render json: Comment.new(content: 'Comment 1')
+        end
+
+        def render_comments
+          render json: [Comment.new(content: 'Comment 1')]
+        end
+      end
+
+      tests MyController
+
+      def test_render_profile_with_namespace_option
+        get :render_profile_with_namespace_option
+        assert_serializer TestNamespace::ProfileSerializer
+      end
+
+      def test_render_profiles_with_namespace_option
+        get :render_profiles_with_namespace_option
+        assert_serializer TestNamespace::ProfileSerializer
+      end
+
+      def test_fallback_to_a_version_without_namespace
+        get :render_comment
+        assert_serializer CommentSerializer
+      end
+
+      def test_array_fallback_to_a_version_without_namespace
+        get :render_comments
+        assert_serializer CommentSerializer
+      end
+    end
+
+  end
+end