jat 0.0.3 → 0.0.5

data/lib/jat/plugins/json_api/lib/include_param_parser.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApi
+      class IncludeParamParser
+        module ClassMethods
+          COMMA = ","
+          DOT = "."
+
+          # Returns the Jat class that this IncludeParamParser class is namespaced under.
+          attr_accessor :jat_class
+
+          # Since IncludeParamParser is anonymously subclassed when Jat is subclassed,
+          # and then assigned to a constant of the Jat subclass, make inspect
+          # reflect the likely name for the class.
+          def inspect
+            "#{jat_class.inspect}::IncludeParamParser"
+          end
+
+          def parse(includes_string_param)
+            return {} unless includes_string_param
+
+            includes_hash = parse_to_nested_hash(includes_string_param)
+            typed_includes(jat_class, includes_hash, {})
+          end
+
+          private
+
+          def parse_to_nested_hash(includes_string_param)
+            includes_string_param.split(COMMA).each_with_object({}) do |part, obj|
+              includes = parse_part(part)
+              deep_merge!(obj, includes)
+            end
+          end
+
+          def typed_includes(jat_class, includes, result)
+            includes.each do |included_attr_name, nested_includes|
+              add_typed_include(result, jat_class, included_attr_name)
+
+              nested_serializer = jat_class.attributes.fetch(included_attr_name).serializer.call
+              typed_includes(nested_serializer, nested_includes, result)
+            end
+
+            result
+          end
+
+          def add_typed_include(result, serializer, included_attr_name)
+            type = serializer.get_type
+
+            includes = result[type] || []
+            includes |= [included_attr_name]
+
+            result[type] = includes
+          end
+
+          def parse_part(part)
+            val = {}
+
+            part.split(DOT).reverse_each do |inc|
+              val = {inc.to_sym => val}
+            end
+
+            val
+          end
+
+          def deep_merge!(this_hash, other_hash)
+            this_hash.merge!(other_hash) do |_key, this_val, other_val|
+              deep_merge(this_val, other_val)
+            end
+          end
+
+          def deep_merge(this_hash, other_hash)
+            this_hash.merge(other_hash) do |_key, this_val, other_val|
+              deep_merge(this_val, other_val)
+            end
+          end
+        end
+
+        extend ClassMethods
+      end
+    end
+  end
+end

data/lib/jat/plugins/json_api/lib/map.rb

@@ -1,53 +1,118 @@
 # frozen_string_literal: true
 
-require_relative "./params/fields"
-require_relative "./params/include"
-require_relative "./construct_traversal_map"
-
 class Jat
   module Plugins
     module JsonApi
       class Map
-        class << self
+        module ClassMethods
+          # Returns the Jat class that this Map class is namespaced under.
+          attr_accessor :jat_class
+
+          # Since Map is anonymously subclassed when Jat is subclassed,
+          # and then assigned to a constant of the Jat subclass, make inspect
+          # reflect the likely name for the class.
+          def inspect
+            "#{jat_class.inspect}::Map"
+          end
+
           # Returns structure like
           # {
-          #   type => {
+          #   type1 => {
           #     attributes: [attr1, attr2, ...],
           #     relationships: [rel1, rel2, ...]
-          #   }
+          #   },
+          #   type2 => { ... }
           # }
-          def call(jat)
-            params = jat.context[:params]
-            fields = params && (params[:fields] || params["fields"])
-            includes = params && (params[:include] || params["include"])
+          def call(context)
+            exposed = context[:exposed]&.to_sym || :default
+            fields = context[:fields]
+            includes = context[:include]
+
+            construct_map(exposed, fields, includes)
+          end
+
+          private
+
+          def construct_map(exposed, fields, includes)
+            fields = jat_class::FieldsParamParser.parse(fields) if fields
+            includes = jat_class::IncludeParamParser.parse(includes) if includes
+
+            new(exposed, fields, includes).to_h
+          end
+        end
+
+        module InstanceMethods
+          attr_reader :jat_class, :exposed, :includes, :fields
 
-            default_attrs = jat.traversal_map.exposed
-            includes_attrs = requested_includes_fields(jat, includes)
-            fields_attrs = requested_fields(jat, fields)
+          EXPOSED_TYPES = {all: :all, default: :default, none: :none}.freeze
 
-            default_attrs.merge!(includes_attrs).merge!(fields_attrs)
+          def initialize(exposed, fields, includes)
+            @jat_class = self.class.jat_class
+            @exposed = EXPOSED_TYPES.fetch(exposed)
+            @fields = fields
+            @includes = includes
+          end
+
+          def to_h
+            map = {}
+            append_map(map, jat_class)
+            map
           end
 
           private
 
-          def requested_includes_fields(jat, includes)
-            return {} unless includes
+          def append_map(map, jat_class)
+            type = jat_class.get_type
+            return map if map.key?(type)
+
+            type_map = {serializer: jat_class}
+            map[type] = type_map
+
+            fill_type_map(map, type_map, type, jat_class)
+
+            type_map[:attributes] ||= FROZEN_EMPTY_ARRAY
+            type_map[:relationships] ||= FROZEN_EMPTY_ARRAY
+          end
+
+          def fill_type_map(map, type_map, type, jat_class)
+            jat_class.attributes.each_value do |attribute|
+              next unless expose?(type, attribute)
 
-            include_types = Params::Include.call(jat, includes)
-            ConstructTraversalMap
-              .new(jat.class, :exposed, manually_exposed: include_types)
-              .to_h
+              fill_attr(map, type_map, attribute)
+            end
           end
 
-          def requested_fields(jat, fields)
-            return {} unless fields
+          def fill_attr(map, type_map, attribute)
+            name = attribute.name
 
-            fields_types = Params::Fields.call(jat, fields)
-            ConstructTraversalMap
-              .new(jat.class, :manual, manually_exposed: fields_types)
-              .to_h
+            if attribute.relation?
+              (type_map[:relationships] ||= []) << name
+              append_map(map, attribute.serializer.call)
+            else
+              (type_map[:attributes] ||= []) << name
+            end
+          end
+
+          def expose?(type, attribute)
+            attribute_name = attribute.name
+            fields_attribute_names = fields && fields[type]
+            return fields_attribute_names.include?(attribute_name) if fields_attribute_names
+
+            includes_attribute_names = includes && includes[type]
+            includes_attribute_names&.include?(attribute_name) || attribute_exposed?(attribute)
+          end
+
+          def attribute_exposed?(attribute)
+            case exposed
+            when :all then true
+            when :none then false
+            else attribute.exposed?
+            end
           end
         end
+
+        extend ClassMethods
+        include InstanceMethods
       end
     end
   end

data/lib/jat/plugins/json_api/lib/params/fields/validate.rb

@@ -8,17 +8,20 @@ class Jat
           class Validate
             class << self
               def call(jat, fields)
+                full_map = jat.maps.full
+
                 fields.each do |type, attributes_names|
-                  new(jat, type).validate(attributes_names)
+                  new(jat, type, full_map).validate(attributes_names)
                 end
               end
             end
 
-            attr_reader :jat, :type
+            attr_reader :jat, :type, :full_map
 
-            def initialize(jat, type)
+            def initialize(jat, type, full_map)
               @jat = jat
               @type = type
+              @full_map = full_map
             end
 
             def validate(attributes_names)
@@ -29,7 +32,7 @@ class Jat
             private
 
             def check_fields_type
-              return if jat.traversal_map.full.key?(type)
+              return if full_map.key?(type)
 
               raise Error, "#{jat.class} and its children have no requested type `#{type}`"
             end
@@ -41,7 +44,7 @@ class Jat
             end
 
             def check_attribute_name(attribute_name)
-              type_data = jat.traversal_map.full.fetch(type)
+              type_data = full_map.fetch(type)
               type_serializer = type_data.fetch(:serializer)
               return if type_serializer.attributes.key?(attribute_name)
 

data/lib/jat/plugins/json_api/lib/response.rb

@@ -5,234 +5,122 @@ class Jat
   module Plugins
     module JsonApi
       class Response
-        attr_reader :jat, :jat_class, :object, :context
-
-        def initialize(jat)
-          @jat = jat
-          @jat_class = jat.class
-          @object = jat.object
-          @context = jat.context
-        end
-
-        def response
-          data, includes = data_with_includes
-          meta = document_meta
-          links = document_links
-          jsonapi = jsonapi_data
-
-          result = {}
-          result[:links] = links if links.any?
-          result[:data] = data if data
-          result[:included] = includes.values if includes.any?
-          result[:meta] = meta if meta.any?
-          result[:jsonapi] = jsonapi if jsonapi.any?
-          result
-        end
-
-        private
-
-        def data_with_includes
-          includes = {}
-          data = many?(object, context) ? many(object, includes) : one(object, includes)
-          [data, includes]
-        end
-
-        def many(objs, includes)
-          objs.map { |obj| one(obj, includes) }
-        end
-
-        def one(obj, includes)
-          ResponseData.new(jat_class, obj, context, full_map, includes).data
-        end
-
-        def many?(data, context)
-          many = context[:many]
-          many.nil? ? data.is_a?(Enumerable) : many
-        end
-
-        def full_map
-          @full_map ||= jat.traversal_map.current
-        end
-
-        def jsonapi_data
-          data = context[:jsonapi]&.transform_keys(&:to_sym) || {}
-          jsonapi_data = jat_class.jsonapi_data
-          return data if jsonapi_data.empty?
-
-          presenter = jat_class::JsonapiPresenter.new(object, context)
-          jsonapi_data.each_key do |key|
-            data[key] = presenter.public_send(key) unless data.key?(key)
+        module ClassMethods
+          # Returns the Jat class that this Response class is namespaced under.
+          attr_accessor :jat_class
+
+          # Since Response is anonymously subclassed when Jat is subclassed,
+          # and then assigned to a constant of the Jat subclass, make inspect
+          # reflect the likely name for the class.
+          def inspect
+            "#{jat_class.inspect}::Response"
           end
-          data.compact!
-          data
-        end
 
-        def document_links
-          data = context[:links]&.transform_keys(&:to_sym) || {}
-          document_links = jat_class.document_links
-          return data if document_links.empty?
-
-          presenter = jat_class::DocumentLinksPresenter.new(object, context)
-          document_links.each_key do |key|
-            data[key] = presenter.public_send(key) unless data.key?(key)
+          def call(object, context)
+            new(object, context).to_h
           end
-          data.compact!
-          data
         end
 
-        def document_meta
-          data = context[:meta]&.transform_keys(&:to_sym) || {}
-          document_meta = jat_class.added_document_meta
-          return data if document_meta.empty?
+        module InstanceMethods
+          attr_reader :jat_class, :object, :context
 
-          presenter = jat_class::DocumentMetaPresenter.new(object, context)
-          document_meta.each_key do |key|
-            data[key] = presenter.public_send(key) unless data.key?(key)
+          def initialize(object, context)
+            @object = object
+            @context = context
+            @jat_class = self.class.jat_class
           end
-          data.compact!
-          data
-        end
-      end
 
-      class ResponseData
-        attr_reader :jat_class, :object, :context, :full_map, :map, :includes, :presenter
-
-        def initialize(jat_class, object, context, full_map, includes)
-          @jat_class = jat_class
-          @object = object
-          @context = context
-          @includes = includes
-          @full_map = full_map
-          @map = full_map.fetch(jat_class.type)
-          @presenter = jat_class::Presenter.new(object, context)
-        end
-
-        def data
-          return unless object
-
-          attributes = get_attributes
-          relationships = get_relationships
-          links = get_links
-          meta = get_meta
+          def to_h
+            data, includes = data_with_includes
+            meta = document_meta
+            links = document_links
+            jsonapi = jsonapi_data
 
-          result = uid
-          result[:attributes] = attributes if attributes
-          result[:relationships] = relationships if relationships
-          result[:links] = links if links.any?
-          result[:meta] = meta if meta.any?
-          result
-        end
-
-        def uid
-          {type: jat_class.type, id: presenter.id}
-        end
+            result = {}
+            result[:links] = links if links.any?
+            result[:data] = data if data
+            result[:included] = includes.values if includes.any?
+            result[:meta] = meta if meta.any?
+            result[:jsonapi] = jsonapi if jsonapi.any?
+            result
+          end
 
-        private
+          private
 
-        def get_attributes
-          attributes_names = map[:attributes]
-          return if attributes_names.empty?
+          def data_with_includes
+            includes = {}
+            map = jat_class::Map.call(context)
+            data = many?(object, context) ? many(object, includes, map) : one(object, includes, map)
+            [data, includes]
+          end
 
-          attributes_names.each_with_object({}) do |name, attrs|
-            attribute = jat_class.attributes[name]
-            attrs[name] = presenter.public_send(attribute.original_name)
+          def many(objects, includes, map)
+            objects.map { |object| one(object, includes, map) }
           end
-        end
 
-        def get_relationships
-          relationships_names = map[:relationships]
-          return if relationships_names.empty?
-
-          relationships_names.each_with_object({}) do |name, rels|
-            rel_attribute = jat_class.attributes[name]
-            rel_object = presenter.public_send(rel_attribute.original_name)
-
-            rel_serializer = rel_attribute.serializer.call
-            rel_links = get_relationship_links(rel_serializer, rel_object)
-            rel_meta = get_relationship_meta(rel_serializer, rel_object)
-            rel_data =
-              if many?(rel_attribute, rel_object)
-                many_relationships_data(rel_serializer, rel_object)
-              else
-                one_relationship_data(rel_serializer, rel_object)
-              end
+          def one(object, includes, map)
+            jat_class::ResponsePiece.call(object, context, map, includes)
+          end
 
-            result = {}
-            result[:data] = rel_data
-            result[:links] = rel_links if rel_links.any?
-            result[:meta] = rel_meta if rel_meta.any?
-            rels[name] = result
+          def many?(data, context)
+            many = context[:many]
+            many.nil? ? data.is_a?(Enumerable) : many
           end
-        end
 
-        def many_relationships_data(rel_serializer, rel_objects)
-          return [] if rel_objects.empty?
+          def jsonapi_data
+            combine(jat_class.jsonapi_data, context_jsonapi)
+          end
 
-          rel_objects.map { |rel_object| add_relationship_data(rel_serializer, rel_object) }
-        end
+          def document_links
+            combine(jat_class.document_links, context_links)
+          end
 
-        def one_relationship_data(rel_serializer, rel_object)
-          return unless rel_object
+          def document_meta
+            combine(jat_class.added_document_meta, context_meta)
+          end
 
-          add_relationship_data(rel_serializer, rel_object)
-        end
+          def combine(attributes, context_data)
+            return context_data if attributes.empty?
 
-        def add_relationship_data(rel_serializer, rel_object)
-          rel_response_data = self.class.new(rel_serializer, rel_object, context, full_map, includes)
-          rel_uid = rel_response_data.uid
-          includes[rel_uid] ||= rel_response_data.data
-          rel_uid
-        end
+            data = context_data
 
-        def many?(attribute, object)
-          is_many = attribute.many?
+            attributes.each do |name, attribute|
+              next if data.key?(name)
 
-          # handle boolean
-          return is_many if (is_many == true) || (is_many == false)
+              value = attribute_value(attribute)
 
-          # handle nil
-          object.is_a?(Enumerable)
-        end
+              unless value.nil?
+                data = data.dup if data.equal?(FROZEN_EMPTY_HASH)
+                data[name] = value
+              end
+            end
 
-        def get_links
-          links = jat_class.object_links
-          return links if links.empty?
+            data
+          end
 
-          presenter = jat_class::LinksPresenter.new(object, context)
-          result = links.each_key.each_with_object({}) { |key, data| data[key] = presenter.public_send(key) }
-          result.compact!
-          result
-        end
+          def attribute_value(attribute)
+            attribute.block.call(object, context)
+          end
 
-        def get_meta
-          meta = jat_class.added_object_meta
-          return meta if meta.empty?
+          def context_jsonapi
+            context_attr_transform(:jsonapi)
+          end
 
-          presenter = jat_class::MetaPresenter.new(object, context)
-          result = meta.each_key.each_with_object({}) { |key, data| data[key] = presenter.public_send(key) }
-          result.compact!
-          result
-        end
+          def context_links
+            context_attr_transform(:links)
+          end
 
-        def get_relationship_links(rel_serializer, rel_object)
-          links = rel_serializer.relationship_links
-          return links if links.empty?
+          def context_meta
+            context_attr_transform(:meta)
+          end
 
-          presenter = rel_serializer::RelationshipLinksPresenter.new(object, rel_object, context)
-          result = links.each_key.each_with_object({}) { |key, data| data[key] = presenter.public_send(key) }
-          result.compact!
-          result
+          def context_attr_transform(key)
+            context[key]&.transform_keys(&:to_sym) || FROZEN_EMPTY_HASH
+          end
         end
 
-        def get_relationship_meta(rel_serializer, rel_object)
-          meta = rel_serializer.added_relationship_meta
-          return meta if meta.empty?
-
-          presenter = rel_serializer::RelationshipMetaPresenter.new(object, rel_object, context)
-          result = meta.each_key.each_with_object({}) { |key, data| data[key] = presenter.public_send(key) }
-          result.compact!
-          result
-        end
+        extend ClassMethods
+        include InstanceMethods
       end
     end
   end