active_model_serializers 0.8.3 → 0.10.15

data/cruft.md

@@ -1,19 +0,0 @@
-As of Ruby 1.9.3, it is impossible to dynamically generate a Symbol
-through interpolation without generating garbage. Theoretically, Ruby
-should be able to take care of this by building up the String in C and
-interning the C String.
-
-Because of this, we avoid generating dynamic Symbols at runtime. For
-example, instead of generating the instrumentation event dynamically, we
-have a constant with a Hash of events:
-
-```ruby
-INSTRUMENT = {
-  :serialize => :"serialize.serializer",
-  :associations => :"associations.serializer"
-}
-```
-
-If Ruby ever fixes this issue and avoids generating garbage with dynamic
-symbols, this code can be removed.
-

data/lib/active_model/array_serializer.rb

@@ -1,104 +0,0 @@
-require "active_support/core_ext/class/attribute"
-require 'active_support/dependencies'
-require 'active_support/descendants_tracker'
-
-module ActiveModel
-  # Active Model Array Serializer
-  #
-  # Serializes an Array, checking if each element implements
-  # the +active_model_serializer+ method.
-  #
-  # To disable serialization of root elements:
-  #
-  #     ActiveModel::ArraySerializer.root = false
-  #
-  class ArraySerializer
-    extend ActiveSupport::DescendantsTracker
-
-    attr_reader :object, :options
-
-    class_attribute :root
-
-    class_attribute :cache
-    class_attribute :perform_caching
-
-    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
-
-    def include_meta(hash)
-      hash[meta_key] = @options[:meta] if @options.has_key?(:meta)
-    end
-
-    def as_json(*args)
-      @options[:hash] = hash = {}
-      @options[:unique_values] = {}
-
-      if root = @options[:root]
-        hash.merge!(root => serializable_array)
-        include_meta hash
-        hash
-      else
-        serializable_array
-      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.merge(:root => false))
-
-        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

data/lib/active_model/serializer/associations.rb

@@ -1,233 +0,0 @@
-module ActiveModel
-  class Serializer
-    module Associations #:nodoc:
-      class Config #:nodoc:
-        class_attribute :options
-
-        def self.refine(name, class_options)
-          current_class = self
-
-          Class.new(self) do
-            singleton_class.class_eval do
-              define_method(:to_s) do
-                "(subclass of #{current_class.name})"
-              end
-
-              alias inspect to_s
-            end
-
-            self.options = class_options
-
-            # cache the root so we can reuse it without falling back on a per-instance basis
-            begin
-              self.options[:root] ||= self.new(name, nil).root
-            rescue
-              # this could fail if it needs a valid source, for example a polymorphic association
-            end
-
-          end
-        end
-
-        self.options = {}
-
-        def initialize(name, source, options={})
-          @name = name
-          @source = source
-          @options = options
-        end
-
-        def option(key, default=nil)
-          if @options.key?(key)
-            @options[key]
-          elsif self.class.options.key?(key)
-            self.class.options[key]
-          else
-            default
-          end
-        end
-
-        def target_serializer
-          serializer = option(:serializer)
-          serializer.is_a?(String) ? serializer.constantize : serializer
-        end
-
-        def source_serializer
-          @source
-        end
-
-        def key
-          option(:key) || @name
-        end
-
-        def root
-          option(:root) || @name
-        end
-
-        def name
-          option(:name) || @name
-        end
-
-        def associated_object
-          option(:value) || source_serializer.send(name)
-        end
-
-        def embed_ids?
-          [:id, :ids].include? option(:embed, source_serializer._embed)
-        end
-
-        def embed_objects?
-          [:object, :objects].include? option(:embed, source_serializer._embed)
-        end
-
-        def embed_in_root?
-          option(:include, source_serializer._root_embed)
-        end
-
-        def embeddable?
-          !associated_object.nil?
-        end
-
-      protected
-
-        def find_serializable(object)
-          if target_serializer
-            target_serializer.new(object, source_serializer.options)
-          elsif object.respond_to?(:active_model_serializer) && (ams = object.active_model_serializer)
-            ams.new(object, source_serializer.options)
-          else
-            object
-          end
-        end
-      end
-
-      class HasMany < Config #:nodoc:
-        def key
-          if key = option(:key)
-            key
-          elsif embed_ids?
-            "#{@name.to_s.singularize}_ids".to_sym
-          else
-            @name
-          end
-        end
-
-        def embed_key
-          if key = option(:embed_key)
-            key
-          else
-            :id
-          end
-        end
-
-        def serialize
-          associated_object.map do |item|
-            find_serializable(item).serializable_hash
-          end
-        end
-
-        def serializables
-          associated_object.map do |item|
-            find_serializable(item)
-          end
-        end
-
-        def serialize_ids
-          ids_key = "#{@name.to_s.singularize}_ids".to_sym
-          if !option(:embed_key) && !source_serializer.respond_to?(@name.to_s) && source_serializer.object.respond_to?(ids_key)
-            source_serializer.object.read_attribute_for_serialization(ids_key)
-          else
-            associated_object.map do |item|
-              item.read_attribute_for_serialization(embed_key)
-            end
-          end
-        end
-      end
-
-      class HasOne < Config #:nodoc:
-        def embeddable?
-          if polymorphic? && associated_object.nil?
-            false
-          else
-            true
-          end
-        end
-
-        def polymorphic?
-          option :polymorphic
-        end
-
-        def root
-          if root = option(:root)
-            root
-          elsif polymorphic?
-            associated_object.class.to_s.pluralize.demodulize.underscore.to_sym
-          else
-            @name.to_s.pluralize.to_sym
-          end
-        end
-
-        def key
-          if key = option(:key)
-            key
-          elsif embed_ids? && !polymorphic?
-            "#{@name}_id".to_sym
-          else
-            @name
-          end
-        end
-
-        def embed_key
-          if key = option(:embed_key)
-            key
-          else
-            :id
-          end
-        end
-
-        def polymorphic_key
-          associated_object.class.to_s.demodulize.underscore.to_sym
-        end
-
-        def serialize
-          object = associated_object
-
-          if object && polymorphic?
-            {
-              :type => polymorphic_key,
-              polymorphic_key => find_serializable(object).serializable_hash
-            }
-          elsif object
-            find_serializable(object).serializable_hash
-          end
-        end
-
-        def serializables
-          object = associated_object
-          value = object && find_serializable(object)
-          value ? [value] : []
-        end
-
-        def serialize_ids
-          id_key = "#{@name}_id".to_sym
-
-          if polymorphic?
-            if associated_object
-              {
-                :type => polymorphic_key,
-                :id => associated_object.read_attribute_for_serialization(embed_key)
-              }
-            else
-              nil
-            end
-          elsif !option(:embed_key) && !source_serializer.respond_to?(@name.to_s) && source_serializer.object.respond_to?(id_key)
-            source_serializer.object.read_attribute_for_serialization(id_key)
-          elsif associated_object
-            associated_object.read_attribute_for_serialization(embed_key)
-          else
-            nil
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_model/serializers/version.rb

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

data/lib/active_record/serializer_override.rb

@@ -1,16 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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 generate_id_method
-        RUBY_VERSION =~ /1\.8/
-      end
-
-      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]
-        # Only works on 3.2
-        # elsif (n = Rails::Generators.namespace) && n.const_defined?(:ApplicationSerializer)
-        #   "ApplicationSerializer"
-        elsif defined?(::ApplicationSerializer)
-          "ApplicationSerializer"
-        else
-          "ActiveModel::Serializer"
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-<% 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 -%>
-<% 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 -%>

data/test/array_serializer_test.rb

@@ -1,75 +0,0 @@
-require "test_helper"
-require "test_fakes"
-
-class ArraySerializerTest < ActiveModel::TestCase
-
-  def test_array_items_do_not_have_root
-    array = [
-        BasicActiveModel.new(:name => "First model"),
-        BasicActiveModel.new(:name => "Second model")
-    ]
-    expected = { "root" => [
-        { :name => "First model" },
-        { :name => "Second model" }
-    ] }
-
-    default_serializer = array.active_model_serializer.new(array, :root => "root")
-    each_serializer = array.active_model_serializer.new(array, :root => "root", :each_serializer => BasicSerializer)
-
-    default_json = default_serializer.as_json
-    each_json = each_serializer.as_json
-
-    assert_equal(expected, default_json)
-    assert_equal(expected, each_json)
-  end
-
-  # 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_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_seriailizer
-    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
-end