ditkrg/active_model_serializers
4
0
Fork 0
mirror of https://github.com/ditkrg/active_model_serializers.git synced 2026-01-22 22:06:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Simplify attributes handling.

Browse Source
This commit is contained in:
Lucas Hosseini 2015-12-11 00:29:38 +01:00
parent 7bc66c5334
commit ee0283cb57
1 changed files with 22 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
lib/active_model/serializer/attributes.rb
View File

@ -1,55 +1,23 @@
module ActiveModel
class Serializer
module Attributes
# @api private
class Attribute
delegate :call, to: :reader
attr_reader :name, :reader
def initialize(name)
@name = name
@reader = :no_reader
end
def self.build(name, block)
if block
AttributeBlock.new(name, block)
else
AttributeReader.new(name)
end
end
end
# @api private
class AttributeReader < Attribute
def initialize(name)
super(name)
@reader = ->(instance) { instance.read_attribute_for_serialization(name) }
end
end
# @api private
class AttributeBlock < Attribute
def initialize(name, block)
super(name)
@reader = ->(instance) { instance.instance_eval(&block) }
end
end
extend ActiveSupport::Concern
included do
with_options instance_writer: false, instance_reader: false do |serializer|
serializer.class_attribute :_attribute_mappings # @api private : maps attribute key names to names to names of implementing methods, @see #attribute
self._attribute_mappings ||= {}
serializer.class_attribute :_attribute_keys # @api private : maps attribute names to keys, @see #attribute
self._attribute_keys ||= {}
end
# Return the +attributes+ of +object+ as presented
# by the serializer.
def attributes(requested_attrs = nil, reload = false)
@attributes = nil if reload
@attributes ||= self.class._attribute_mappings.each_with_object({}) do |(key, attribute_mapping), hash|
@attributes ||= self.class._attribute_keys.each_with_object({}) do |(name, key), hash|
next unless requested_attrs.nil? || requested_attrs.include?(key)
hash[key] = attribute_mapping.call(self)
hash[key] = self.class._attribute_mappings[name].call(self)
end
end
end
@ -58,6 +26,7 @@ module ActiveModel
def inherited(base)
super
base._attribute_mappings = _attribute_mappings.dup
base._attribute_keys = _attribute_keys.dup
end
# @example
@ -84,15 +53,24 @@ module ActiveModel
# object.edits.last(5)
# end
def attribute(attr, options = {}, &block)
key = options.fetch(:key, attr)
_attribute_mappings[key] = Attribute.build(attr, block)
_attribute_keys[attr] = options.fetch(:key, attr)
_attribute_mappings[attr] = _attribute_mapping(attr, block)
end
# @api private
# names of attribute methods
def _attribute_mapping(name, block)
if block
->(instance) { instance.instance_eval(&block) }
else
->(instance) { instance.read_attribute_for_serialization(name) }
end
end
# @api private
# keys of attributes
# @see Serializer::attribute
def _attributes
_attribute_mappings.keys
_attribute_keys.values
end
# @api private
@ -100,10 +78,10 @@ module ActiveModel
# @see Serializer::attribute
# @see Adapter::FragmentCache#fragment_serializer
def _attributes_keys
_attribute_mappings
.each_with_object({}) do |(key, attribute_mapping), hash|
next if key == attribute_mapping.name
hash[attribute_mapping.name] = { key: key }
_attribute_keys
.each_with_object({}) do |(name, key), hash|
next if key == name
hash[name] = { key: key }
end
end
end