fields-serializer 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 026a3b888bceb7ead4ec323dfb6a8f5d32b0530c
-  data.tar.gz: 1465d275c0d1999835a1b16306c488343654e20d
+  metadata.gz: d97826f68957ac11395bfc95787ebc4562a49891
+  data.tar.gz: dba35d1851970293eb3fcf3ac8992cb8108bc801
 SHA512:
-  metadata.gz: 72bc247fb4b38e878af011e3fa2a96f4e8bac7b57696dc2b48f9375ff462f04e6b49a9f2966f18a78c939a35720ded20e20b18439ef6d3adddedd2e88e8ba4f9
-  data.tar.gz: 54127c8b3f4e09f5d7c04e01780862ce08de6368ff0dfde49be85f600437022968e0d2ee9167b674acd7e7ceecd51a3ffe734234aa29baf012ba9f32ecce8e5f
+  metadata.gz: 429db7023534cb8168d610708cca7705a3ec3127da0d390d2472b989f0645071f63907c3c21fc12990bacd10bea1c0e29c7535f8e774e2f680c4dbb150594818
+  data.tar.gz: 2a2b8473e52a57245db3333d18603bd759c094917a484391476c47e49de1ca70424e1ec3d6e739d55a34c659dccbfbca181d8e9646fc53d84597378ffd694569

data/lib/fields/serializer/action_controller.rb

@@ -17,10 +17,9 @@ module Fields
         fields      = options.delete(:fields)
         model_class = options.delete(:model_class)
         if fields.present?
-          includes = model_class.fields_to_includes(fields)
-          query    = query.includes(*includes)
-          # options.merge!(include: model_class.fields_to_include(includes).join(","))
-          options.merge!(include: includes)
+          query = query.includes(*model_class.fields_to_includes(fields))
+          options.merge!(each_serializer: model_class.fields_serializer(fields))
+          options.delete(:include)
         end
         render options.merge!(json: query.to_a)
       end

data/lib/fields/serializer/active_record.rb

@@ -1,4 +1,5 @@
 require 'active_record'
+require "active_model_serializers"
 
 module Fields
   module Serializer
@@ -13,57 +14,52 @@ module Fields
         #
         #  BoilerPack.fields_to_includes("id,boiler.gas_safe_code") #=> ["boiler"]
         #
-        def fields_to_includes(fields)
-          nested_fields(fields).inject([{}]) do |result, attribute_structure|
-            if attribute_structure.is_a?(Hash)
-              result.first.deep_merge!(attribute_structure) { |_, u, v| u == v ? u : [u, v] }
-            else
-              result << attribute_structure unless result.first.dig(attribute_structure) || result.include?(attribute_structure)
-            end
-            result
-          end.map(&:presence).compact
+        def fields_to_includes(*fields)
+          fields_to_tree(fields).to_includes
         end
 
-        # Convert a list of fields (json_api notation) in a list of associations to be
-        # added to a ActiveRecord Model.includes call
-        #
-        # Example:
-        #
-        #  BoilerPack.fields_to_includes("id,boiler.gas_safe_code") #=> ["boiler"]
-        #
-        def fields_to_include(fields, root: nil)
-          Array(fields).map do |field|
-            if field.kind_of?(Hash) || field.kind_of?(Array)
-              field.map { |k, v| fields_to_include(v, root: composite_field(root, k)) }
-            else
-              composite_field(root, field)
-            end
-          end.flatten
+        def fields_serializer(*fields)
+          create_serializer_class(fields_to_tree(fields).notation)
         end
 
-        def nested_field(attribute_stack)
-          parent = attribute_stack.first
-          return unless association?(parent)
-          parent_klass = reflections[parent].class_name.constantize
-          { parent => parent_klass.nested_field(attribute_stack[1..-1]) }.compact.presence || parent
+        def create_serializer_class(fields)
+          Class.new(ActiveModel::Serializer) do
+            Array(fields).each do |field|
+              if field.kind_of?(Hash)
+                nested_association(field)
+              else
+                attribute field.to_sym unless association?(field)
+              end
+            end
+          end
         end
 
         private
 
-        def array_fields(fields)
-          Array(fields).map { |str| str.to_s.split(",").map(&:strip) }.flatten
+        def fields_to_tree(*fields)
+          array_fields(fields.flatten).inject(FieldsTree.new(self), &:merge!)
         end
 
-        def association?(key)
-          reflections.keys.include?(key)
+        # Calls:
+        #   has_one :user, serializer: new_serializer_class_for_user_fields
+        #     or
+        #   belongs_to :user, serializer: new_serializer_class_for_user_fields
+        #     or
+        #   has_many :users, serializer: new_serializer_class_for_user_fields
+        #
+        def nested_association(fields)
+          fields.each do |association_name, nested_fields|
+            reflection = reflections[association_name]
+            send(reflection.macro, association_name.to_sym, serializer: reflection.klass.create_serializer_class(nested_fields))
+          end
         end
 
-        def composite_field(*values)
-          values.compact.join(".")
+        def array_fields(fields)
+          Array(fields).map { |str| str.to_s.split(",").map(&:strip) }.flatten.sort
         end
 
-        def nested_fields(fields)
-          array_fields(fields).map { |field| nested_field(field.split(".")) }.compact.uniq
+        def association?(key)
+          reflections.keys.include?(key)
         end
       end
     end

data/lib/fields/serializer/fields_tree.rb

@@ -0,0 +1,92 @@
+require 'active_record'
+require "active_model_serializers"
+
+module Fields
+  module Serializer
+
+    class FieldsTree
+      attr_reader :klass, :fields, :associations
+
+      def initialize(klass)
+        @klass        = klass
+        @fields       = []
+        @associations = {}
+      end
+      
+      def presence
+        self if fields.present? || associations.present?
+      end
+      
+      def merge!(join_field)
+        return self unless join_field.present?
+        parent, rest = join_field.to_s.split(".", 2)
+        if rest.blank?
+          fields << parent if !(existing_field?(parent) || association?(parent))
+        else
+          existing_association?(parent) ? associations[parent].merge!(rest) : add_association!(parent, rest)
+        end
+        self
+      end
+      
+      def notation
+        if fields.present?
+          if associations.present?
+            fields.dup << associations_to_notation
+          else
+            fields.one? ? fields.first.dup : fields.dup
+          end
+        else
+          associations_to_notation.presence
+        end
+      end
+      
+      def to_includes
+        to_includes = associations.inject([]) do |result, (k, v)|
+          v_includes = v.to_includes
+          if v_includes.present?
+            new_has_entry = { k => v_includes }
+            hash = result.find { |e| e.is_a?(Hash) }
+            hash ? hash.merge!(new_has_entry) : (result << new_has_entry)
+            result
+          else
+            result << k
+          end
+        end.presence
+        Array(to_includes).one? ? to_includes.first : to_includes
+      end
+      
+      def to_s
+        notation.to_s
+      end
+      
+      private
+      
+      def add_association!(parent, rest)
+        if association?(parent)
+          nested_class       = klass.reflections[parent].klass
+          nested_fields_tree = FieldsTree.new(nested_class).merge!(rest).presence
+          new_association    = { parent => nested_fields_tree } if nested_fields_tree
+          associations.merge!(new_association) if new_association
+        end
+      end
+      
+      def associations_to_notation
+        associations.inject({}) do |result, (k, v)|
+          result.merge!(k => v.notation)
+        end
+      end
+      
+      def existing_association?(value)
+        !!associations[value]
+      end
+      
+      def existing_field?(value)
+        fields.include?(value)
+      end
+
+      def association?(value)
+        klass.reflections.keys.include?(value)
+      end
+    end
+  end
+end

data/lib/fields/serializer/version.rb

@@ -1,5 +1,5 @@
 module Fields
   module Serializer
-    VERSION = "0.4.0"
+    VERSION = "0.5.0"
   end
 end

data/lib/fields/serializer.rb

@@ -4,7 +4,7 @@ require 'active_support/concern'
 require "fields/serializer/version"
 require "fields/serializer/active_record"
 require "fields/serializer/action_controller"
-require "fields/serializer/field_serializer"
+require "fields/serializer/fields_tree"
 
 module Fields
   module Serializer

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fields-serializer
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Stuart Chinery
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-19 00:00:00.000000000 Z
+date: 2017-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -145,7 +145,7 @@ files:
 - lib/fields/serializer.rb
 - lib/fields/serializer/action_controller.rb
 - lib/fields/serializer/active_record.rb
-- lib/fields/serializer/field_serializer.rb
+- lib/fields/serializer/fields_tree.rb
 - lib/fields/serializer/version.rb
 homepage: https://github.com/ltello/fields-serializer
 licenses:

data/lib/fields/serializer/field_serializer.rb

@@ -1,56 +0,0 @@
-require "active_model_serializers"
-
-# This is a generic serializer intended to return a subset of a model's attributes.
-# It can be used with any model but does not currently support associations.
-#
-# Example usage:
-#   render json: @region, serializer: FieldSerializer, fields: [:id, :title]
-#
-#   > { "id": "5f19582d-ee28-4e89-9e3a-edc42a8b59e5", "title": "London" }
-#
-class FieldSerializer < ActiveModel::Serializer
-  def attributes(*args)
-    fields = Array(args.first).map { |str| str.to_s.split(",").map(&:strip) }.flatten
-    adding_id do
-      merging_attributes do
-        fields.map { |field| create_attribute_structure(field.split("."), object) }
-      end
-    end
-  end
-
-  private
-
-  def adding_id(&block)
-    block.call.merge(id: object.id)
-  end
-
-  def create_attribute_structure(attribute_stack, model)
-    return model unless model.present?
-    if model.kind_of?(ActiveRecord::Relation)
-      collection_attribute_structure(model, attribute_stack)
-    else
-      parent = attribute_stack.first
-      if attribute_stack.count > 1
-        attribute_structure(model, attribute_stack[1..-1], parent)
-      else
-        value_structure(model, parent)
-      end
-    end
-  end
-
-  def attribute_structure(model, attribute_stack, parent)
-    { parent => create_attribute_structure(attribute_stack, model.send(parent)) }
-  end
-
-  def collection_attribute_structure(models, attribute_stack)
-    models.map { |model| create_attribute_structure(attribute_stack, model) }.compact
-  end
-
-  def merging_attributes(&block)
-    block.call.inject(:deep_merge!)
-  end
-
-  def value_structure(model, attribute_name)
-    { attribute_name => model.send(attribute_name) }
-  end
-end