cheap_ams 0.10.5 → 0.10.6

data/lib/active_model/serializable_resource.rb

@@ -1,7 +1,6 @@
 require 'set'
 module ActiveModel
   class SerializableResource
-
     ADAPTER_OPTION_KEYS = Set.new([:include, :fields, :adapter])
 
     def initialize(resource, options = {})
@@ -79,6 +78,5 @@ module ActiveModel
     ActiveModelSerializers.silence_warnings do
     attr_reader :resource, :adapter_opts, :serializer_opts
     end
-
   end
 end

data/lib/active_model/serializer/adapter/fragment_cache.rb

@@ -2,7 +2,6 @@ module ActiveModel
   class Serializer
     class Adapter
       class FragmentCache
-
         attr_reader :serializer
 
         def initialize(adapter, serializer, options)
@@ -35,7 +34,7 @@ module ActiveModel
 
         def cached_attributes(klass, serializers)
           attributes            = serializer.class._attributes
-          cached_attributes     = (klass._cache_only) ? klass._cache_only : attributes.reject {|attr| klass._cache_except.include?(attr) }
+          cached_attributes     = (klass._cache_only) ? klass._cache_only : attributes.reject { |attr| klass._cache_except.include?(attr) }
           non_cached_attributes = attributes - cached_attributes
 
           cached_attributes.each do |attribute|
@@ -60,7 +59,7 @@ module ActiveModel
           Object.const_set cached, Class.new(ActiveModel::Serializer) unless Object.const_defined?(cached)
           Object.const_set non_cached, Class.new(ActiveModel::Serializer) unless Object.const_defined?(non_cached)
 
-          klass._cache_options       ||= {}
+          klass._cache_options ||= {}
           klass._cache_options[:key] = klass._cache_key if klass._cache_key
 
           cached.constantize.cache(klass._cache_options)
@@ -68,7 +67,7 @@ module ActiveModel
           cached.constantize.fragmented(serializer)
           non_cached.constantize.fragmented(serializer)
 
-          serializers = {cached: cached, non_cached: non_cached}
+          serializers = { cached: cached, non_cached: non_cached }
           cached_attributes(klass, serializers)
           serializers
         end

data/lib/active_model/serializer/adapter/json/fragment_cache.rb

@@ -4,11 +4,9 @@ module ActiveModel
     class Adapter
       class Json < Adapter
         class FragmentCache
-
           def fragment_cache(cached_hash, non_cached_hash)
             non_cached_hash.merge cached_hash
           end
-
         end
       end
     end

data/lib/active_model/serializer/adapter/json.rb

@@ -46,7 +46,6 @@ module ActiveModel
         def fragment_cache(cached_hash, non_cached_hash)
           Json::FragmentCache.new().fragment_cache(cached_hash, non_cached_hash)
         end
-
       end
     end
   end

data/lib/active_model/serializer/adapter/json_api/fragment_cache.rb

@@ -4,19 +4,17 @@ module ActiveModel
     class Adapter
       class JsonApi < Adapter
         class FragmentCache
-
           def fragment_cache(root, cached_hash, non_cached_hash)
             hash              = {}
             core_cached       = cached_hash.first
             core_non_cached   = non_cached_hash.first
-            no_root_cache     = cached_hash.delete_if {|key, value| key == core_cached[0] }
-            no_root_non_cache = non_cached_hash.delete_if {|key, value| key == core_non_cached[0] }
+            no_root_cache     = cached_hash.delete_if { |key, value| key == core_cached[0] }
+            no_root_non_cache = non_cached_hash.delete_if { |key, value| key == core_non_cached[0] }
             cached_resource   = (core_cached[1]) ? core_cached[1].deep_merge(core_non_cached[1]) : core_non_cached[1]
             hash = (root) ? { root => cached_resource } : cached_resource
 
             hash.deep_merge no_root_non_cache.deep_merge no_root_cache
           end
-
         end
       end
     end

data/lib/active_model/serializer/adapter/json_api.rb

@@ -9,7 +9,13 @@ module ActiveModel
           super
           @hash = { data: [] }
 
-          if fields = options.delete(:fields)
+          @options[:include] ||= []
+          if @options[:include].is_a?(String)
+            @options[:include] = @options[:include].split(',')
+          end
+
+          fields = options.delete(:fields)
+          if fields
             @fieldset = ActiveModel::Serializer::Fieldset.new(fields, serializer.json_key)
           else
             @fieldset = options[:fieldset]
@@ -31,151 +37,139 @@ module ActiveModel
 
             add_links(options)
           else
-            @hash[:data] = attributes_for_serializer(serializer, options)
-            add_resource_relationships(@hash[:data], serializer)
+            primary_data = primary_data_for(serializer, options)
+            relationships = relationships_for(serializer)
+            included = included_for(serializer)
+            @hash[:data] = primary_data
+            @hash[:data][:relationships] = relationships if relationships.any?
+            @hash[:included] = included if included.any?
           end
           @hash
         end
 
         def fragment_cache(cached_hash, non_cached_hash)
           root = false if @options.include?(:include)
-          JsonApi::FragmentCache.new().fragment_cache(root, cached_hash, non_cached_hash)
+          JsonApi::FragmentCache.new.fragment_cache(root, cached_hash, non_cached_hash)
         end
 
         private
 
-        def add_relationships(resource, name, serializers)
-          resource[:relationships] ||= {}
-          resource[:relationships][name] ||= { data: [] }
-          resource[:relationships][name][:data] += serializers.map { |serializer| { type: serializer.json_api_type, id: serializer.id.to_s } }
+        def resource_identifier_type_for(serializer)
+          if ActiveModel::Serializer.config.jsonapi_resource_type == :singular
+            serializer.object.class.model_name.singular
+          else
+            serializer.object.class.model_name.plural
+          end
         end
 
-        def add_relationship(resource, name, serializer, val=nil)
-          resource[:relationships] ||= {}
-          resource[:relationships][name] = { data: val }
-
-          if serializer && serializer.object
-            resource[:relationships][name][:data] = { type: serializer.json_api_type, id: serializer.id.to_s }
+        def resource_identifier_id_for(serializer)
+          if serializer.respond_to?(:id)
+            serializer.id
+          else
+            serializer.object.id
           end
         end
 
-        def add_included(resource_name, serializers, parent = nil)
-          unless serializers.respond_to?(:each)
-            return unless serializers.object
-            serializers = Array(serializers)
-          end
-          resource_path = [parent, resource_name].compact.join('.')
-          if include_assoc?(resource_path)
-            @hash[:included] ||= []
+        def resource_identifier_for(serializer)
+          type = resource_identifier_type_for(serializer)
+          id   = resource_identifier_id_for(serializer)
 
-            serializers.each do |serializer|
-              attrs = attributes_for_serializer(serializer, @options)
+          { id: id.to_s, type: type }
+        end
 
-              add_resource_relationships(attrs, serializer, add_included: false)
+        def resource_object_for(serializer, options = {})
+          options[:fields] = @fieldset && @fieldset.fields_for(serializer)
 
-              @hash[:included].push(attrs) unless @hash[:included].include?(attrs)
-            end
+          cache_check(serializer) do
+            result = resource_identifier_for(serializer)
+            attributes = serializer.attributes(options).except(:id)
+            result[:attributes] = attributes if attributes.any?
+            result
           end
+        end
 
-          serializers.each do |serializer|
-            serializer.associations.each do |association|
-              serializer = association.serializer
-
-              add_included(association.key, serializer, resource_path) if serializer
-            end if include_nested_assoc? resource_path
+        def primary_data_for(serializer, options)
+          if serializer.respond_to?(:each)
+            serializer.map { |s| resource_object_for(s, options) }
+          else
+            resource_object_for(serializer, options)
           end
         end
 
-        def attributes_for_serializer(serializer, options)
+        def relationship_value_for(serializer, options = {})
           if serializer.respond_to?(:each)
-            result = []
-            serializer.each do |object|
-              result << resource_object_for(object, options)
-            end
+            serializer.map { |s| resource_identifier_for(s) }
           else
-            result = resource_object_for(serializer, options)
+            if options[:virtual_value]
+              options[:virtual_value]
+            elsif serializer && serializer.object
+              resource_identifier_for(serializer)
+            end
           end
-          result
         end
 
-        def resource_object_for(serializer, options)
-          options[:fields] = @fieldset && @fieldset.fields_for(serializer)
-          options[:required_fields] = [:id, :json_api_type]
+        def relationships_for(serializer)
+          Hash[serializer.associations.map { |association| [association.key, { data: relationship_value_for(association.serializer, association.options) }] }]
+        end
 
-          cache_check(serializer) do
-            attributes = serializer.attributes(options)
+        def included_for(serializer)
+          serializer.associations.flat_map { |assoc| _included_for(assoc.key, assoc.serializer) }.uniq
+        end
 
-            result = {
-              id: attributes.delete(:id).to_s,
-              type: attributes.delete(:json_api_type)
-            }
+        def _included_for(resource_name, serializer, parent = nil)
+          if serializer.respond_to?(:each)
+            serializer.flat_map { |s| _included_for(resource_name, s, parent) }.uniq
+          else
+            return [] unless serializer && serializer.object
+            result = []
+            resource_path = [parent, resource_name].compact.join('.')
 
-            result[:attributes] = attributes if attributes.any?
+            if include_assoc?(resource_path)
+              primary_data = primary_data_for(serializer, @options)
+              relationships = relationships_for(serializer)
+              primary_data[:relationships] = relationships if relationships.any?
+              result.push(primary_data)
+            end
+
+            if include_nested_assoc?(resource_path)
+              non_empty_associations = serializer.associations.select(&:serializer)
+
+              non_empty_associations.each do |association|
+                result.concat(_included_for(association.key, association.serializer, resource_path))
+                result.uniq!
+              end
+            end
             result
           end
         end
 
         def include_assoc?(assoc)
-          return false unless @options[:include]
           check_assoc("#{assoc}$")
         end
 
         def include_nested_assoc?(assoc)
-          return false unless @options[:include]
           check_assoc("#{assoc}.")
         end
 
         def check_assoc(assoc)
-          include_opt = @options[:include]
-          include_opt = include_opt.split(',') if include_opt.is_a?(String)
-          include_opt.any? do |s|
-            s.match(/^#{assoc.gsub('.', '\.')}/)
-          end
-        end
-
-        def add_resource_relationships(attrs, serializer, options = {})
-          options[:add_included] = options.fetch(:add_included, true)
-
-          serializer.associations.each do |association|
-            key = association.key
-            serializer = association.serializer
-            opts = association.options
-
-            attrs[:relationships] ||= {}
-
-            if serializer.respond_to?(:each)
-              add_relationships(attrs, key, serializer)
-            else
-              if opts[:virtual_value]
-                add_relationship(attrs, key, nil, opts[:virtual_value])
-              else
-                add_relationship(attrs, key, serializer)
-              end
-            end
-
-            if options[:add_included]
-              Array(serializer).each do |s|
-                add_included(key, s)
-              end
-            end
-          end
+          @options[:include].any? { |s| s.match(/^#{assoc.gsub('.', '\.')}/) }
         end
 
         def add_links(options)
           links = @hash.fetch(:meta) { {} }
-          resources = serializer.instance_variable_get(:@resource)
-          @hash[:meta] = add_pagination_links(links, resources, options) if is_paginated?(resources)
+          collection = serializer.object
+          @hash[:meta] = add_pagination_links(links, collection, options) if is_paginated?(resources)
         end
 
-        def add_pagination_links(links, resources, options)
-          pagination_links = JsonApi::PaginationLinks.new(resources, options[:context]).serializable_hash(options)
+        def add_pagination_links(links, collection, options)
+          pagination_links = JsonApi::PaginationLinks.new(collection, options[:context]).serializable_hash(options)
           links.update(pagination_links)
         end
 
-        def is_paginated?(resource)
-          resource.respond_to?(:current_page) &&
-            resource.respond_to?(:total_pages) &&
-            resource.respond_to?(:size)
+        def paginated?(collection)
+          collection.respond_to?(:current_page) &&
+            collection.respond_to?(:total_pages) &&
+            collection.respond_to?(:size)
         end
       end
     end

data/lib/active_model/serializer/adapter.rb

@@ -15,7 +15,7 @@ module ActiveModel
       end
 
       def self.adapter_class(adapter)
-        adapter_name = adapter.to_s.classify.sub("API", "Api")
+        adapter_name = adapter.to_s.classify.sub('API', 'Api')
         "ActiveModel::Serializer::Adapter::#{adapter_name}".safe_constantize
       end
 
@@ -68,12 +68,12 @@ module ActiveModel
         parts = []
         parts << object_cache_key
         parts << @klass._cache_digest unless @klass._cache_options && @klass._cache_options[:skip_digest]
-        parts.join("/")
+        parts.join('/')
       end
 
       def object_cache_key
         object_time_safe = @cached_serializer.object.updated_at
-        object_time_safe = object_time_safe.strftime("%Y%m%d%H%M%S%9N") if object_time_safe.respond_to?(:strftime)
+        object_time_safe = object_time_safe.strftime('%Y%m%d%H%M%S%9N') if object_time_safe.respond_to?(:strftime)
         (@klass._cache_key) ? "#{@klass._cache_key}/#{@cached_serializer.object.id}-#{object_time_safe}" : @cached_serializer.object.cache_key
       end
 
@@ -82,7 +82,7 @@ module ActiveModel
       end
 
       def meta_key
-        serializer.meta_key || "meta"
+        serializer.meta_key || 'meta'
       end
 
       def root

data/lib/active_model/serializer/array_serializer.rb

@@ -3,23 +3,22 @@ module ActiveModel
     class ArraySerializer
       NoSerializerError = Class.new(StandardError)
       include Enumerable
-      delegate :each, to: :@objects
+      delegate :each, to: :@serializers
 
-      attr_reader :root, :meta, :meta_key
+      attr_reader :object, :root, :meta, :meta_key
 
-      def initialize(objects, options = {})
+      def initialize(resources, options = {})
         @root = options[:root]
-        @resource = objects
-        @objects  = objects.map do |object|
-          serializer_class = options.fetch(
-            :serializer,
-            ActiveModel::Serializer.serializer_for(object)
-          )
+        @object = resources
+        @serializers = resources.map do |resource|
+          serializer_class = options.fetch(:serializer) {
+            ActiveModel::Serializer.serializer_for(resource)
+          }
 
           if serializer_class.nil?
-            fail NoSerializerError, "No serializer found for object: #{object.inspect}"
+            fail NoSerializerError, "No serializer found for resource: #{resource.inspect}"
           else
-            serializer_class.new(object, options.except(:serializer))
+            serializer_class.new(resource, options.except(:serializer))
           end
         end
         @meta     = options[:meta]
@@ -27,7 +26,7 @@ module ActiveModel
       end
 
       def json_key
-        key = root || @objects.first.try(:json_key) || @resource.try(:name).try(:underscore)
+        key = root || @serializers.first.try(:json_key) || object.try(:name).try(:underscore)
         key.try(:pluralize)
       end
     end

data/lib/active_model/serializer/association.rb

@@ -10,7 +10,6 @@ module ActiveModel
     #  Association.new(:comments, CommentSummarySerializer)
     #
     Association = Struct.new(:name, :serializer, :options) do
-
       # @return [Symbol]
       #
       def key

data/lib/active_model/serializer/fieldset.rb

@@ -1,7 +1,6 @@
 module ActiveModel
   class Serializer
     class Fieldset
-
       def initialize(fields, root = nil)
         @root       = root
         @raw_fields = fields
@@ -16,7 +15,7 @@ module ActiveModel
         fields[key.to_sym] || fields[key.pluralize.to_sym]
       end
 
-    private
+      private
 
       ActiveModelSerializers.silence_warnings do
       attr_reader :raw_fields, :root
@@ -24,7 +23,7 @@ module ActiveModel
 
       def parsed_fields
         if raw_fields.is_a?(Hash)
-          raw_fields.inject({}) { |h,(k,v)| h[k.to_sym] = v.map(&:to_sym); h}
+          raw_fields.inject({}) { |h, (k, v)| h[k.to_sym] = v.map(&:to_sym); h }
         elsif raw_fields.is_a?(Array)
           if root.nil?
             raise ArgumentError, 'The root argument must be specified if the fileds argument is an array.'
@@ -36,7 +35,6 @@ module ActiveModel
           {}
         end
       end
-
     end
   end
 end

data/lib/active_model/serializer/lint.rb

@@ -15,7 +15,6 @@ module ActiveModel::Serializer::Lint
   # always return +{}+, and the tests would pass. It is up to you to ensure
   # that the values are semantically meaningful.
   module Tests
-
     # Passes if the object responds to <tt>serializable_hash</tt> and if it takes
     # zero or one arguments.
     # Fails otherwise.
@@ -23,7 +22,7 @@ module ActiveModel::Serializer::Lint
     # <tt>serializable_hash</tt> returns a hash representation of a object's attributes.
     # Typically, it is implemented by including ActiveModel::Serialization.
     def test_serializable_hash
-      assert_respond_to resource, :serializable_hash, "The resource should respond to serializable_hash"
+      assert_respond_to resource, :serializable_hash, 'The resource should respond to serializable_hash'
       resource.serializable_hash
       resource.serializable_hash(nil)
     end
@@ -35,7 +34,7 @@ module ActiveModel::Serializer::Lint
     # <tt>read_attribute_for_serialization</tt> gets the attribute value for serialization
     # Typically, it is implemented by including ActiveModel::Serialization.
     def test_read_attribute_for_serialization
-      assert_respond_to resource, :read_attribute_for_serialization, "The resource should respond to read_attribute_for_serialization"
+      assert_respond_to resource, :read_attribute_for_serialization, 'The resource should respond to read_attribute_for_serialization'
       actual_arity = resource.method(:read_attribute_for_serialization).arity
       if defined?(::Rubinius)
         #  1 for def read_attribute_for_serialization(name); end
@@ -126,6 +125,5 @@ module ActiveModel::Serializer::Lint
     def assert_instance_of(result, name)
       assert result.instance_of?(name), "#{result} should be an instance of #{name}"
     end
-
   end
 end

data/lib/active_model/serializer/version.rb

@@ -1,5 +1,5 @@
 module ActiveModel
   class Serializer
-    VERSION = "0.10.5"
+    VERSION = "0.10.6"
   end
 end

data/lib/active_model/serializer.rb

@@ -13,7 +13,6 @@ module ActiveModel
     include Configuration
     include Associations
 
-
     # Matches
     #  "c:/git/emberjs/ember-crm-backend/app/serializers/lead_serializer.rb:1:in `<top (required)>'"
     #  AND
@@ -32,7 +31,6 @@ module ActiveModel
     class << self
       attr_accessor :_attributes
       attr_accessor :_attributes_keys
-      attr_accessor :_urls
       attr_accessor :_cache
       attr_accessor :_fragmented
       attr_accessor :_cache_key
@@ -45,7 +43,6 @@ module ActiveModel
     def self.inherited(base)
       base._attributes = self._attributes.try(:dup) || []
       base._attributes_keys = self._attributes_keys.try(:dup) || {}
-      base._urls = []
       base._cache_digest = digest_caller_file(caller.first)
       super
     end
@@ -87,14 +84,6 @@ module ActiveModel
       @_cache_options = (options.empty?) ? nil : options
     end
 
-    def self.url(attr)
-      @_urls.push attr
-    end
-
-    def self.urls(*attrs)
-      @_urls.concat attrs
-    end
-
     def self.serializer_for(resource, options = {})
       if resource.respond_to?(:serializer_class)
         resource.serializer_class
@@ -146,18 +135,6 @@ module ActiveModel
       @root || object.class.model_name.to_s.underscore
     end
 
-    def id
-      object.id if object
-    end
-
-    def json_api_type
-      if config.jsonapi_resource_type == :plural
-        object.class.model_name.plural
-      else
-        object.class.model_name.singular
-      end
-    end
-
     def attributes(options = {})
       attributes =
         if options[:fields]
@@ -166,8 +143,6 @@ module ActiveModel
           self.class._attributes.dup
         end
 
-      attributes += options[:required_fields] if options[:required_fields]
-
       attributes.each_with_object({}) do |name, hash|
         unless self.class._fragmented
           hash[name] = send(name)

data/lib/active_model_serializers.rb

@@ -8,7 +8,6 @@ module ActiveModelSerializers
   ensure
     $VERBOSE = verbose
   end
-
 end
 
 require 'active_model'

data/lib/generators/serializer/serializer_generator.rb

@@ -1,15 +1,15 @@
 module Rails
   module Generators
     class SerializerGenerator < NamedBase
-      source_root File.expand_path("../templates", __FILE__)
-      check_class_collision :suffix => "Serializer"
+      source_root File.expand_path('../templates', __FILE__)
+      check_class_collision :suffix => 'Serializer'
 
-      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+      argument :attributes, :type => :array, :default => [], :banner => 'field:type field:type'
 
-      class_option :parent, :type => :string, :desc => "The parent class for the generated serializer"
+      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")
+        template 'serializer.rb.erb', File.join('app/serializers', class_path, "#{file_name}_serializer.rb")
       end
 
       private
@@ -26,9 +26,9 @@ module Rails
         if options[:parent]
           options[:parent]
         elsif defined?(::ApplicationSerializer)
-          "ApplicationSerializer"
+          'ApplicationSerializer'
         else
-          "ActiveModel::Serializer"
+          'ActiveModel::Serializer'
         end
       end
     end

data/test/action_controller/adapter_selector_test.rb

@@ -33,10 +33,10 @@ module ActionController
         expected = {
           data: {
             id: assigns(:profile).id.to_s,
-            type: "profiles",
+            type: 'profiles',
             attributes: {
-              name: "Name 1",
-              description: "Description 1",
+              name: 'Name 1',
+              description: 'Description 1',
             }
           }
         }

data/test/action_controller/explicit_serializer_test.rb

@@ -100,11 +100,11 @@ module ActionController
         get :render_array_using_explicit_serializer_and_custom_serializers
 
         expected = [
-          { "title" => "New Post",
-            "body" => "Body",
-            "id" => assigns(:post).id,
-            "comments" => [{"id" => 1}, {"id" => 2}],
-            "author" => { "id" => assigns(:author).id }
+          { 'title' => 'New Post',
+            'body' => 'Body',
+            'id' => assigns(:post).id,
+            'comments' => [{ 'id' => 1 }, { 'id' => 2 }],
+            'author' => { 'id' => assigns(:author).id }
           }
         ]
 
@@ -116,13 +116,13 @@ module ActionController
 
         expected = {
           id: 1337,
-          name: "Amazing Place",
+          name: 'Amazing Place',
           locations: [
             {
               id: 42,
-              lat: "-23.550520",
-              lng: "-46.633309",
-              place: "Nowhere" # is a virtual attribute on LocationSerializer
+              lat: '-23.550520',
+              lng: '-46.633309',
+              place: 'Nowhere' # is a virtual attribute on LocationSerializer
             }
           ]
         }