gpi-active_model_serializers 0.8.2

data/lib/active_model/serializer/associations.rb

@@ -0,0 +1,191 @@
+module ActiveModel
+  class Serializer
+    class Association #:nodoc:
+      # name: The name of the association.
+      #
+      # options: A hash. These keys are accepted:
+      #
+      #   value: The object we're associating with.
+      #
+      #   serializer: The class used to serialize the association.
+      #
+      #   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.
+      #
+      #   include: Used in conjunction with embed :ids. Includes the objects in the root.
+      #
+      #   root: Used in conjunction with include: true. Defines the key used to embed the objects.
+      #
+      #   key: Key name used to store the ids in.
+      #
+      #   embed_key: Method used to fetch ids. Defaults to :id.
+      #
+      #   polymorphic: Is the association is polymorphic?. Values: true or false.
+      def initialize(name, options={}, serializer_options={})
+        @name          = name
+        @object        = options[:value]
+
+        embed          = options[:embed]
+        @embed_ids     = embed == :id || embed == :ids
+        @embed_objects = embed == :object || embed == :objects
+        @embed_key     = options[:embed_key] || :id
+        @embed_in_root = options[:include]
+
+        serializer = options[:serializer]
+        @serializer_class = serializer.is_a?(String) ? serializer.constantize : serializer
+
+        @options = options
+        @serializer_options = serializer_options
+      end
+
+      attr_reader :object, :root, :name, :embed_ids, :embed_objects, :embed_in_root
+      alias embeddable? object
+      alias embed_objects? embed_objects
+      alias embed_ids? embed_ids
+      alias use_id_key? embed_ids?
+      alias embed_in_root? embed_in_root
+
+      def key
+        if key = options[:key]
+          key
+        elsif use_id_key?
+          id_key
+        else
+          name
+        end
+      end
+
+      private
+
+      attr_reader :embed_key, :serializer_class, :options, :serializer_options
+
+      def find_serializable(object)
+        if serializer_class
+          serializer_class.new(object, serializer_options)
+        elsif object.respond_to?(:active_model_serializer) && (ams = object.active_model_serializer)
+          options = serializer_options.except(:only, :include)
+
+          if serializer_options.key?(:include) && serializer_options[:include].include?(name)
+            options.merge!(serializer_options[:include][name])
+          end
+
+          ams.new(object, options)
+        else
+          object
+        end
+      end
+
+      class HasMany < Association #:nodoc:
+        def root
+          options[:root] || name
+        end
+
+        def id_key
+          "#{name.to_s.singularize}_ids".to_sym
+        end
+
+        def serializables
+          object.map do |item|
+            find_serializable(item)
+          end
+        end
+
+        def serialize
+          object.map do |item|
+            find_serializable(item).serializable_hash
+          end
+        end
+
+        def serialize_ids
+          object.map do |item|
+            serializer = find_serializable(item)
+            if serializer.respond_to?(embed_key)
+              serializer.send(embed_key)
+            else
+              item.read_attribute_for_serialization(embed_key)
+            end
+          end
+        end
+      end
+
+      class HasOne < Association #:nodoc:
+        def initialize(name, options={}, serializer_options={})
+          super
+          @polymorphic = options[:polymorphic]
+        end
+
+        def root
+          if root = options[:root]
+            root
+          elsif polymorphic?
+            object.class.to_s.pluralize.demodulize.underscore.to_sym
+          else
+            name.to_s.pluralize.to_sym
+          end
+        end
+
+        def id_key
+          "#{name}_id".to_sym
+        end
+
+        def embeddable?
+          super || !polymorphic?
+        end
+
+        def serializables
+          value = object && find_serializable(object)
+          value ? [value] : []
+        end
+
+        def serialize
+          if object
+            if polymorphic?
+              {
+                :type => polymorphic_key,
+                polymorphic_key => find_serializable(object).serializable_hash
+              }
+            else
+              find_serializable(object).serializable_hash
+            end
+          end
+        end
+
+        def serialize_ids
+          if object
+            serializer = find_serializable(object)
+            id =
+              if serializer.respond_to?(embed_key)
+                serializer.send(embed_key)
+              else
+                object.read_attribute_for_serialization(embed_key)
+              end
+
+            if polymorphic?
+              {
+                type: polymorphic_key,
+                id: id
+              }
+            else
+              id
+            end
+          end
+        end
+
+        private
+
+        attr_reader :polymorphic
+        alias polymorphic? polymorphic
+
+        def use_id_key?
+          embed_ids? && !polymorphic?
+        end
+
+        def polymorphic_key
+          object.class.to_s.demodulize.underscore.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/caching.rb

@@ -0,0 +1,37 @@
+module ActiveModel
+  class Serializer
+    module Caching
+      def to_json(*args)
+        if caching_enabled?
+          key = expand_cache_key([self.class.to_s.underscore, cache_key, 'to-json'])
+          cache.fetch key do
+            super
+          end
+        else
+          super
+        end
+      end
+
+      def serialize(*args)
+        if caching_enabled?
+          key = expand_cache_key([self.class.to_s.underscore, cache_key, 'serialize'])
+          cache.fetch key do
+            serialize_object
+          end
+        else
+          serialize_object
+        end
+      end
+
+      private
+
+      def caching_enabled?
+        perform_caching && cache && respond_to?(:cache_key)
+      end
+
+      def expand_cache_key(*args)
+        ActiveSupport::Cache.expand_cache_key(args)
+      end
+    end
+  end
+end

data/lib/active_model/serializer/version.rb

@@ -0,0 +1,5 @@
+module ActiveModel
+  class Serializer
+    VERSION = "0.8.2"
+  end
+end

data/lib/active_model_serializers.rb

@@ -0,0 +1,95 @@
+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|
+        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 AbstractController::UrlFor
+          extend ::AbstractController::Railties::RoutesHelpers.with(app.routes)
+          include app.routes.mounted_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
+
+begin
+  require 'action_controller'
+  require 'action_controller/serialization'
+
+  ActiveSupport.on_load(:action_controller) do
+    include ::ActionController::Serialization
+  end
+rescue LoadError => ex
+  # rails on installed, continuing
+end
+
+ActiveSupport.run_load_hooks(:active_model_serializers, ActiveModel::Serializer)

data/lib/active_record/serializer_override.rb

@@ -0,0 +1,16 @@
+# We do not recommend that you use AM::S in this way, but if you must, here
+# is a mixin that overrides ActiveRecord::Base#to_json and #as_json.
+
+module ActiveRecord
+  module SerializerOverride
+    def to_json options = {}
+      active_model_serializer.new(self).to_json options
+    end
+
+    def as_json options={}
+      active_model_serializer.new(self).as_json options
+    end
+  end
+
+  Base.send(:include, SerializerOverride)
+end

data/lib/generators/resource_override.rb

@@ -0,0 +1,13 @@
+require "rails/generators"
+require "rails/generators/rails/resource/resource_generator"
+
+module Rails
+  module Generators
+    ResourceGenerator.class_eval do
+      def add_serializer
+        invoke "serializer"
+      end
+    end
+  end
+end
+

data/lib/generators/serializer/USAGE

@@ -0,0 +1,9 @@
+Description:
+    Generates a serializer for the given resource with tests.
+
+Example:
+    `rails generate serializer Account name created_at`
+
+    For TestUnit it creates:
+        Serializer:  app/serializers/account_serializer.rb
+        TestUnit:    test/unit/account_serializer_test.rb

data/lib/generators/serializer/serializer_generator.rb

@@ -0,0 +1,36 @@
+module Rails
+  module Generators
+    class SerializerGenerator < NamedBase
+      source_root File.expand_path("../templates", __FILE__)
+      check_class_collision suffix: "Serializer"
+
+      argument :attributes, type: :array, default: [], banner: "field:type field:type"
+
+      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")
+      end
+
+      private
+
+      def attributes_names
+        [:id] + attributes.select { |attr| !attr.reference? }.map { |a| a.name.to_sym }
+      end
+
+      def association_names
+        attributes.select { |attr| attr.reference? }.map { |a| a.name.to_sym }
+      end
+
+      def parent_class_name
+        if options[:parent]
+          options[:parent]
+        elsif defined?(::ApplicationSerializer)
+          "ApplicationSerializer"
+        else
+          "ActiveModel::Serializer"
+        end
+      end
+    end
+  end
+end

data/lib/generators/serializer/templates/serializer.rb

@@ -0,0 +1,8 @@
+<% module_namespacing do -%>
+class <%= class_name %>Serializer < <%= parent_class_name %>
+  attributes <%= attributes_names.map(&:inspect).join(", ") %>
+<% association_names.each do |attribute| -%>
+  has_one :<%= attribute %>
+<% end -%>
+end
+<% end -%>

data/test/array_serializer_test.rb

@@ -0,0 +1,85 @@
+require "test_helper"
+require "test_fakes"
+
+class ArraySerializerTest < ActiveModel::TestCase
+  # serialize different typed objects
+  def test_array_serializer
+    model    = Model.new
+    user     = User.new
+    comments = Comment.new(title: "Comment1", id: 1)
+
+    array = [model, user, comments]
+    serializer = array.active_model_serializer.new(array, scope: { scope: true })
+    assert_equal([
+      { model: "Model" },
+      { last_name: "Valim", ok: true, first_name: "Jose", scope: true },
+      { title: "Comment1" }
+    ], serializer.as_json)
+  end
+
+  def test_array_serializer_with_root
+    comment1 = Comment.new(title: "Comment1", id: 1)
+    comment2 = Comment.new(title: "Comment2", id: 2)
+
+    array = [ comment1, comment2 ]
+
+    serializer = array.active_model_serializer.new(array, root: :comments)
+
+    assert_equal({ comments: [
+      { title: "Comment1" },
+      { title: "Comment2" }
+    ]}, serializer.as_json)
+  end
+
+  def test_active_model_with_root
+    comment1 = ModelWithActiveModelSerializer.new(title: "Comment1")
+    comment2 = ModelWithActiveModelSerializer.new(title: "Comment2")
+
+    array = [ comment1, comment2 ]
+
+    serializer = array.active_model_serializer.new(array, root: :comments)
+
+    assert_equal({ comments: [
+      { title: "Comment1" },
+      { title: "Comment2" }
+    ]}, serializer.as_json)
+  end
+
+  def test_array_serializer_with_hash
+    hash = { value: "something" }
+    array = [hash]
+    serializer = array.active_model_serializer.new(array, root: :items)
+    assert_equal({ items: [hash.as_json] }, serializer.as_json)
+  end
+
+  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)
+
+    array = [ post1, post2 ]
+
+    serializer = array.active_model_serializer.new array, each_serializer: CustomPostSerializer
+
+    assert_equal([
+      { title: "Post1" },
+      { 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