jat 0.0.3 → 0.0.8

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

@@ -5,234 +5,118 @@ 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
-
-        private
+            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
 
-        def get_attributes
-          attributes_names = map[:attributes]
-          return if attributes_names.empty?
+          private
 
-          attributes_names.each_with_object({}) do |name, attrs|
-            attribute = jat_class.attributes[name]
-            attrs[name] = presenter.public_send(attribute.original_name)
+          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
-        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 many(objects, includes, map)
+            objects.map { |object| one(object, includes, map) }
+          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 one(object, includes, map)
+            jat_class::ResponsePiece.call(object, context, map, includes)
           end
-        end
 
-        def many_relationships_data(rel_serializer, rel_objects)
-          return [] if rel_objects.empty?
+          def many?(data, context)
+            many = context[:many]
+            many.nil? ? data.is_a?(Enumerable) : many
+          end
 
-          rel_objects.map { |rel_object| add_relationship_data(rel_serializer, rel_object) }
-        end
+          def jsonapi_data
+            combine(jat_class.jsonapi_data, context_jsonapi)
+          end
 
-        def one_relationship_data(rel_serializer, rel_object)
-          return unless rel_object
+          def document_links
+            combine(jat_class.document_links, context_links)
+          end
 
-          add_relationship_data(rel_serializer, rel_object)
-        end
+          def document_meta
+            combine(jat_class.added_document_meta, context_meta)
+          end
 
-        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
+          def combine(attributes, context_data)
+            return context_data if attributes.empty?
 
-        def many?(attribute, object)
-          is_many = attribute.many?
+            data = context_data
 
-          # handle boolean
-          return is_many if (is_many == true) || (is_many == false)
+            attributes.each do |name, attribute|
+              next if data.key?(name)
 
-          # handle nil
-          object.is_a?(Enumerable)
-        end
+              value = attribute.value(object, context)
 
-        def get_links
-          links = jat_class.object_links
-          return links if links.empty?
+              unless value.nil?
+                data = data.dup if data.equal?(FROZEN_EMPTY_HASH)
+                data[name] = value
+              end
+            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
+            data
+          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

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

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApi
+      class ResponsePiece
+        module ClassMethods
+          # Returns the Jat class that this ResponsePiece class is namespaced under.
+          attr_accessor :jat_class
+
+          # Since ResponsePiece 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}::ResponsePiece"
+          end
+
+          def call(object, context, map, includes)
+            new(object, context, map, includes).to_h
+          end
+        end
+
+        module InstanceMethods
+          attr_reader :jat_class, :object, :context, :map, :type_map, :includes
+
+          def initialize(object, context, map, includes)
+            @jat_class = self.class.jat_class
+            @object = object
+            @context = context
+            @map = map
+            @type_map = map.fetch(jat_class.get_type)
+            @includes = includes
+          end
+
+          def to_h
+            return unless object
+
+            attributes = get_attributes
+            relationships = get_relationships
+            links = get_links
+            meta = get_meta
+
+            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: type, id: id}
+          end
+
+          private
+
+          def get_attributes
+            attributes_names = type_map[:attributes]
+            return if attributes_names.empty?
+
+            attributes_names.each_with_object({}) do |name, attrs|
+              attribute = jat_class.attributes[name]
+              attrs[name] = attribute.value(object, context)
+            end
+          end
+
+          def get_relationships
+            relationships_names = type_map[:relationships]
+            return if relationships_names.empty?
+
+            relationships_names.each_with_object({}) do |name, rels|
+              rel_attribute = jat_class.attributes[name]
+              rel_object = rel_attribute.value(object, context)
+
+              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
+
+              result = {}
+              result[:data] = rel_data
+              result[:links] = rel_links if rel_links.any?
+              result[:meta] = rel_meta if rel_meta.any?
+              rels[name] = result
+            end
+          end
+
+          def many_relationships_data(rel_serializer, rel_objects)
+            return FROZEN_EMPTY_ARRAY if rel_objects.empty?
+
+            rel_objects.map { |rel_object| add_relationship_data(rel_serializer, rel_object) }
+          end
+
+          def one_relationship_data(rel_serializer, rel_object)
+            return unless rel_object
+
+            add_relationship_data(rel_serializer, rel_object)
+          end
+
+          def add_relationship_data(rel_serializer, rel_object)
+            rel_response_data = rel_serializer::ResponsePiece.new(rel_object, context, map, includes)
+            rel_uid = rel_response_data.uid
+            simple_uid = "#{rel_uid[:id]}-#{rel_uid[:type]}"
+            includes[simple_uid] ||= rel_response_data.to_h
+            rel_uid
+          end
+
+          def many?(attribute, object)
+            is_many = attribute.many?
+
+            # handle boolean
+            return is_many if (is_many == true) || (is_many == false)
+
+            # handle nil
+            object.is_a?(Enumerable)
+          end
+
+          def get_links
+            jat_class
+              .object_links
+              .transform_values { |attr| attr.value(object, context) }
+              .tap(&:compact!)
+          end
+
+          def get_meta
+            jat_class
+              .added_object_meta
+              .transform_values { |attr| attr.value(object, context) }
+              .tap(&:compact!)
+          end
+
+          def get_relationship_links(rel_serializer, rel_object)
+            links = rel_serializer.relationship_links
+            return FROZEN_EMPTY_HASH if links.empty?
+
+            context[:parent_object] = object
+
+            links
+              .transform_values { |attr| attr.value(rel_object, context) }
+              .tap(&:compact!)
+              .tap { context.delete(:parent_object) }
+          end
+
+          def get_relationship_meta(rel_serializer, rel_object)
+            meta = rel_serializer.added_relationship_meta
+            return FROZEN_EMPTY_HASH if meta.empty?
+
+            context[:parent_object] = object
+
+            meta
+              .transform_values { |attr| attr.value(rel_object, context) }
+              .tap(&:compact!)
+              .tap { context.delete(:parent_object) }
+          end
+
+          def type
+            @type ||= jat_class.get_type
+          end
+
+          def id
+            @id ||= jat_class.get_id.value(object, context)
+          end
+        end
+
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApiActiverecord
+      def self.plugin_name
+        :json_api_activerecord
+      end
+
+      def self.before_load(jat_class, **_opts)
+        return if jat_class.plugin_used?(:json_api)
+        raise Error, "Please load :json_api plugin first"
+      end
+
+      def self.load(jat_class, **opts)
+        jat_class.plugin :json_api_preloads, **opts
+        jat_class.plugin :base_activerecord_preloads, **opts
+      end
+    end
+
+    register_plugin(JsonApiActiverecord.plugin_name, JsonApiActiverecord)
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApiLowerCamelCase
+      def self.plugin_name
+        :json_api_lower_camel_case
+      end
+
+      def self.before_load(jat_class, **_opts)
+        raise Error, "Please load :json_api plugin first" unless jat_class.plugin_used?(:json_api)
+
+        jat_class.plugin :base_lower_camel_case
+      end
+
+      def self.load(jat_class, **_opts)
+        jat_class::Response.include(ResponseInstanceMethods)
+      end
+
+      module ResponseInstanceMethods
+        private
+
+        def context_attr_transform(*)
+          result = super
+          return result if result.empty?
+
+          result.transform_keys! { |key| Jat::LowerCamelCaseTransformation.call(key) }
+        end
+      end
+    end
+
+    register_plugin(JsonApiLowerCamelCase.plugin_name, JsonApiLowerCamelCase)
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApiMapsCache
+      def self.plugin_name
+        :json_api_maps_cache
+      end
+
+      def self.before_load(jat_class, **opts)
+        return if jat_class.plugin_used?(:json_api)
+        raise Error, "Please load :json_api plugin first"
+      end
+
+      def self.load(jat_class, **_opts)
+        jat_class::Map.extend(MapsCacheClassMethods)
+      end
+
+      def self.after_load(jat_class, **opts)
+        jat_class.config[:cached_maps_count] = opts[:cached_maps_count] || 100
+      end
+
+      module MapsCacheClassMethods
+        # Caches up to `:cached_maps_count` maps for each serializer.
+        # Removes earliest value if new value exceeds limit.
+
+        def maps_cache
+          @maps_cache ||= Hash.new do |cache, cache_key|
+            cache.shift if cache.length >= jat_class.config[:cached_maps_count] # protect from memory leak
+            cache[cache_key] = EnumDeepFreeze.call(yield)
+          end
+        end
+
+        private
+
+        def construct_map(exposed, fields, includes)
+          cache = maps_cache { super }
+          cache_key = cache_key(exposed, fields, includes)
+          cache[cache_key]
+        end
+
+        def cache_key(exposed, fields, includes)
+          key = "exposed:#{exposed}:"
+          key += "includes:#{includes}:" if includes
+
+          if fields
+            key += "fields:"
+            fields.each { |type, attrs| key += "#{type}:#{attrs}:" }
+          end
+
+          key
+        end
+      end
+    end
+
+    register_plugin(JsonApiMapsCache.plugin_name, JsonApiMapsCache)
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "./lib/preloads"
+
+class Jat
+  module Plugins
+    module JsonApiPreloads
+      def self.plugin_name
+        :json_api_preloads
+      end
+
+      def self.before_load(jat_class, **opts)
+        raise Error, "Please load :json_api plugin first" unless jat_class.plugin_used?(:json_api)
+
+        jat_class.plugin :base_preloads, **opts
+      end
+
+      def self.load(jat_class, **_opts)
+        jat_class.extend(ClassMethods)
+        jat_class.include(InstanceMethods)
+      end
+
+      module ClassMethods
+        def preloads(context = {})
+          new(context).preloads
+        end
+      end
+
+      module InstanceMethods
+        def preloads
+          @preloads ||= Preloads.call(self)
+        end
+      end
+    end
+
+    register_plugin(JsonApiPreloads.plugin_name, JsonApiPreloads)
+  end
+end