jat 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3fdf9f1733a9d7ddcdeced1bcf6b6cbb1f53b9ffa11b8cb1592874dcc55c3bf2
-  data.tar.gz: d8982abf27a244a845ec0147a51e23946a8f6cac66c36d350aef6567253326f8
+  metadata.gz: 405a0677976675d336278af6aa940fe83ac4bdd4f9d69263fb4728f5cb1c8b3e
+  data.tar.gz: 9f7e0ef9238788984a50b677b68876d7301eae6e020df469ec7eba933566dbf0
 SHA512:
-  metadata.gz: f8a9be4d5e0d59922b37763de59a8833b5d3c71ac634f2c3555b6b9ab36e8a4149be04f8b33a68406616cfaeda85f49ed349fe8cc4d47bc44e0a873f0128829a
-  data.tar.gz: 9dcf9433b3d5f40e538db79e082095b54977f8ba8fd885ada3442441c98f374635956d0cd5201c654282954dd24d59e589a181338d2774855b97bd9677fa40d4
+  metadata.gz: dd533f933d3504b8b549ac13f231ee70bfa7a8c00baafe88ab09a8973a6d278d8a727ddbd0e4e783abed34b0e8f22c3ccb314ced10699427de80877865a9ff0d
+  data.tar.gz: 323559cf6470e9c569f919356f2c0c0033b46e51ccb0b9c1b79b9e0d5d397d68b1322a2401788560f1ed5a474cbf19a81720f38ed78291e1c75326ec6f9a7a07

data/lib/jat/attribute.rb

@@ -59,11 +59,43 @@ class Jat
       end
 
       def block
-        @block ||=
-          params.fetch(:block) || begin
-            key_method_name = key
-            -> { object.public_send(key_method_name) }
+        return @block if instance_variable_defined?(:@block)
+
+        current_block = params.fetch(:block).tap { |bl| check_block_valid(bl) if bl }
+        current_block ||= keyword_block
+
+        @block = anonymized_block(current_block)
+      end
+
+      def value(object, context)
+        block.call(object, context)
+      end
+
+      private
+
+      def keyword_block
+        key_method_name = key
+        proc { |object| object.public_send(key_method_name) }
+      end
+
+      def anonymized_block(block)
+        Class.new do
+          private
+
+          define_method(:_doe) do |object, context|
+            block.call(object, context)
           end
+        end.new.method(:_doe)
+      end
+
+      def check_block_valid(block)
+        raise Error, "Block must be a Proc (not lambda)" if block.lambda?
+
+        params = block.parameters
+        raise Error, "Block can have 0-2 parameters" if params.count > 2
+
+        valid_params_types = params.all? { |param| param[0] == :opt }
+        raise Error, "Block parameters must be optional and no keyword parameters" unless valid_params_types
       end
     end
 

data/lib/jat/plugins/_activerecord_preloads/_activerecord_preloads.rb

@@ -5,10 +5,14 @@ require_relative "./lib/preloader"
 class Jat
   module Plugins
     module ActiverecordPreloads
+      def self.load(jat_class, **_opts)
+        jat_class.include(InstanceMethods)
+      end
+
       module InstanceMethods
-        def initialize(*)
+        def to_h(object)
+          object = add_preloads(object)
           super
-          @object = add_preloads(@object)
         end
 
         private
@@ -16,7 +20,7 @@ class Jat
         def add_preloads(obj)
           return obj if obj.nil? || (obj.is_a?(Array) && obj.empty?)
 
-          preloads = self.class.jat_preloads(self)
+          preloads = preloads()
           return obj if preloads.empty?
 
           Preloader.preload(obj, preloads)

data/lib/jat/plugins/_activerecord_preloads/lib/preloader.rb

@@ -27,11 +27,7 @@ class Jat
           end
 
           def preload(object, preloads)
-            # Reset associations that will be preloaded to fix possible bugs with
-            # ActiveRecord::Associations::Preloader
-            preloads.each_key { |key| object.association(key).reset }
             ActiveRecord::Associations::Preloader.new.preload(object, preloads)
-
             object
           end
         end
@@ -46,7 +42,13 @@ class Jat
           end
 
           def preload(objects, preloads)
-            objects.preload(preloads)
+            if objects.loaded?
+              array_objects = objects.to_a
+              ActiverecordArray.preload(array_objects, preloads)
+              objects
+            else
+              objects.preload(preloads).load
+            end
           end
         end
 
@@ -62,20 +64,12 @@ class Jat
           end
 
           def preload(objects, preloads)
-            # Reset associations that will be preloaded to fix possible bugs with
-            # ActiveRecord::Associations::Preloader
-            preloads.each_key { |key| reset_association(objects, key) }
             ActiveRecord::Associations::Preloader.new.preload(objects, preloads)
-
             objects
           end
 
           private
 
-          def reset_association(objects, key)
-            objects.each { |object| object.association(key).reset }
-          end
-
           def same_kind?(objects)
             first_object_class = objects.first.class
             objects.all? { |object| object.instance_of?(first_object_class) }

data/lib/jat/plugins/_lower_camel_case/_lower_camel_case.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module LowerCamelCase
+      def self.load(jat_class, **_opts)
+        jat_class::Attribute.include(AttributeInstanceMethods)
+      end
+
+      module AttributeInstanceMethods
+        def name
+          LowerCamelCaseTransformation.call(original_name)
+        end
+      end
+    end
+
+    register_plugin(:_lower_camel_case, LowerCamelCase)
+  end
+
+  class LowerCamelCaseTransformation
+    SEPARATOR = "_"
+
+    def self.call(string)
+      first_word, *others = string.to_s.split(SEPARATOR)
+
+      first_word[0] = first_word[0].downcase
+      last_words = others.each(&:capitalize!).join
+
+      :"#{first_word}#{last_words}"
+    end
+  end
+end

data/lib/jat/plugins/_preloads/_preloads.rb

@@ -7,6 +7,10 @@ require_relative "./lib/preloads_with_path"
 class Jat
   module Plugins
     module Preloads
+      def self.load(jat_class, **_opts)
+        jat_class::Attribute.include(AttributeMethods)
+      end
+
       module AttributeMethods
         NULL_PRELOADS = [nil, [].freeze].freeze
 
@@ -28,7 +32,7 @@ class Jat
         # we don't know which entity is main (:user or :profile in this example) but
         # we need to know main value to add nested preloads to it.
         # User can specify main preloaded entity by adding "!" suffix
-        # ({ user!: [:profile] } for example), othervice the latest key will be considered main.
+        # ({ user!: [:profile] } for example), otherwise the latest key will be considered main.
         def get_preloads_with_path
           preloads_provided = opts.key?(:preload)
           preloads =
@@ -43,7 +47,9 @@ class Jat
           return NULL_PRELOADS if preloads_provided && !preloads
 
           preloads = FormatUserPreloads.to_hash(preloads)
-          PreloadsWithPath.call(preloads)
+          preloads, path = PreloadsWithPath.call(preloads)
+
+          [EnumDeepFreeze.call(preloads), path.freeze]
         end
       end
     end

data/lib/jat/plugins/cache/cache.rb

@@ -7,25 +7,29 @@ class Jat
         jat_class.plugin :to_str, **opts
       end
 
+      def self.load(jat_class, **_opts)
+        jat_class.include(InstanceMethods)
+      end
+
       module InstanceMethods
         FORMAT_TO_STR = :to_str
         FORMAT_TO_H = :to_h
 
-        def to_h
+        def to_h(object)
           return super if context[:_format] == FORMAT_TO_STR
 
           context[:_format] = FORMAT_TO_H
-          cached { super }
+          cached(object) { super }
         end
 
-        def to_str
+        def to_str(object)
           context[:_format] = FORMAT_TO_STR
-          cached { super }
+          cached(object) { super }
         end
 
         private
 
-        def cached(&block)
+        def cached(object, &block)
           cache = context[:cache]
           return yield unless cache
 

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

@@ -1,125 +1,159 @@
 # frozen_string_literal: true
 
+require_relative "./lib/fields_param_parser"
+require_relative "./lib/include_param_parser"
+require_relative "./lib/map"
 require_relative "./lib/response"
-require_relative "./lib/traversal_map"
-require_relative "./lib/presenters/document_links_presenter"
-require_relative "./lib/presenters/document_meta_presenter"
-require_relative "./lib/presenters/jsonapi_presenter"
-require_relative "./lib/presenters/links_presenter"
-require_relative "./lib/presenters/meta_presenter"
-require_relative "./lib/presenters/relationship_links_presenter"
-require_relative "./lib/presenters/relationship_meta_presenter"
+require_relative "./lib/response_piece"
 
 # Serializes to JSON-API format
 class Jat
   module Plugins
     module JsonApi
-      def self.after_load(jat_class, **opts)
-        jat_class.plugin(:_json_api_activerecord, **opts) if opts[:activerecord]
+      def self.before_load(jat_class, **_opts)
+        response_plugin = jat_class.config[:response_plugin_loaded]
+        return unless response_plugin
 
-        jat_class.const_set(:JsonapiPresenter, Class.new(Jat::Presenters::JsonapiPresenter))
-        jat_class::JsonapiPresenter.jat_class = jat_class
+        raise Error, "Response plugin `#{response_plugin}` was already loaded before"
+      end
 
-        jat_class.const_set(:LinksPresenter, Class.new(Jat::Presenters::LinksPresenter))
-        jat_class::LinksPresenter.jat_class = jat_class
+      def self.load(jat_class, **_opts)
+        jat_class.include(InstanceMethods)
+        jat_class.extend(ClassMethods)
+      end
 
-        jat_class.const_set(:DocumentLinksPresenter, Class.new(Jat::Presenters::DocumentLinksPresenter))
-        jat_class::DocumentLinksPresenter.jat_class = jat_class
+      def self.after_load(jat_class, **opts)
+        fields_parser_class = Class.new(FieldsParamParser)
+        fields_parser_class.jat_class = jat_class
+        jat_class.const_set(:FieldsParamParser, fields_parser_class)
 
-        jat_class.const_set(:RelationshipLinksPresenter, Class.new(Jat::Presenters::RelationshipLinksPresenter))
-        jat_class::RelationshipLinksPresenter.jat_class = jat_class
+        includes_parser_class = Class.new(IncludeParamParser)
+        includes_parser_class.jat_class = jat_class
+        jat_class.const_set(:IncludeParamParser, includes_parser_class)
 
-        jat_class.const_set(:MetaPresenter, Class.new(Jat::Presenters::MetaPresenter))
-        jat_class::MetaPresenter.jat_class = jat_class
+        map_class = Class.new(Map)
+        map_class.jat_class = jat_class
+        jat_class.const_set(:Map, map_class)
 
-        jat_class.const_set(:DocumentMetaPresenter, Class.new(Jat::Presenters::DocumentMetaPresenter))
-        jat_class::DocumentMetaPresenter.jat_class = jat_class
+        response_class = Class.new(Response)
+        response_class.jat_class = jat_class
+        jat_class.const_set(:Response, response_class)
 
-        jat_class.const_set(:RelationshipMetaPresenter, Class.new(Jat::Presenters::RelationshipMetaPresenter))
-        jat_class::RelationshipMetaPresenter.jat_class = jat_class
+        response_piece_class = Class.new(ResponsePiece)
+        response_piece_class.jat_class = jat_class
+        jat_class.const_set(:ResponsePiece, response_piece_class)
+
+        jat_class.config[:response_plugin_loaded] = :json_api
+        jat_class.plugin(:json_api_activerecord, **opts) if opts[:activerecord]
+        jat_class.id
       end
 
       module InstanceMethods
-        def to_h
-          Response.new(self).response
+        def to_h(object)
+          self.class::Response.call(object, context)
         end
 
-        def traversal_map
-          @traversal_map ||= TraversalMap.new(self)
+        def map
+          @map ||= self.class.map(context)
         end
       end
 
       module ClassMethods
         def inherited(subclass)
+          super
+
+          fields_parser_class = Class.new(self::FieldsParamParser)
+          fields_parser_class.jat_class = subclass
+          subclass.const_set(:FieldsParamParser, fields_parser_class)
+
+          includes_parser_class = Class.new(self::IncludeParamParser)
+          includes_parser_class.jat_class = subclass
+          subclass.const_set(:IncludeParamParser, includes_parser_class)
+
+          map_class = Class.new(self::Map)
+          map_class.jat_class = subclass
+          subclass.const_set(:Map, map_class)
+
+          response_class = Class.new(self::Response)
+          response_class.jat_class = subclass
+          subclass.const_set(:Response, response_class)
+
+          response_piece_class = Class.new(self::ResponsePiece)
+          response_piece_class.jat_class = subclass
+          subclass.const_set(:ResponsePiece, response_piece_class)
+
           subclass.type(@type) if defined?(@type)
+          subclass.id(&get_id.params[:block])
 
-          # Initialize JsonApi data Presenters
-          jsonapi_data_presenter_class = Class.new(self::Presenters::JsonapiPresenter)
-          jsonapi_data_presenter_class.jat_class = subclass
-          subclass.const_set(:JsonapiPresenter, jsonapi_data_presenter_class)
-          jsonapi_data.each { |key, block| subclass.jsonapi(key, &block) }
-
-          # Initialize Links Presenters
-          links_presenter_class = Class.new(self::Presenters::LinksPresenter)
-          links_presenter_class.jat_class = subclass
-          subclass.const_set(:LinksPresenter, links_presenter_class)
-          object_links.each { |key, block| subclass.object_link(key, &block) }
-
-          # Initialize DocumentLinks Presenters
-          document_links_presenter_class = Class.new(self::Presenters::DocumentLinksPresenter)
-          document_links_presenter_class.jat_class = subclass
-          subclass.const_set(:DocumentLinksPresenter, document_links_presenter_class)
-          document_links.each { |key, block| subclass.document_link(key, &block) }
-
-          # Initialize RelationshipLinks Presenters
-          relationship_links_presenter_class = Class.new(self::Presenters::RelationshipLinksPresenter)
-          relationship_links_presenter_class.jat_class = subclass
-          subclass.const_set(:RelationshipLinksPresenter, relationship_links_presenter_class)
-          relationship_links.each { |key, block| subclass.relationship_link(key, &block) }
-
-          # Initialize Meta Presenters
-          meta_presenter_class = Class.new(self::Presenters::MetaPresenter)
-          meta_presenter_class.jat_class = subclass
-          subclass.const_set(:MetaPresenter, meta_presenter_class)
-          added_object_meta.each { |key, block| subclass.object_meta(key, &block) }
-
-          # Initialize DocumentMeta Presenters
-          document_meta_presenter_class = Class.new(self::Presenters::DocumentMetaPresenter)
-          document_meta_presenter_class.jat_class = subclass
-          subclass.const_set(:DocumentMetaPresenter, document_meta_presenter_class)
-          added_document_meta.each { |key, block| subclass.document_meta(key, &block) }
-
-          # Initialize RelationshipMeta Presenters
-          relationship_meta_presenter_class = Class.new(self::Presenters::RelationshipMetaPresenter)
-          relationship_meta_presenter_class.jat_class = subclass
-          subclass.const_set(:RelationshipMetaPresenter, relationship_meta_presenter_class)
-          added_relationship_meta.each { |key, block| subclass.relationship_meta(key, &block) }
+          # Assign same jsonapi_data
+          jsonapi_data.each_value do |attribute|
+            params = attribute.params
+            subclass.jsonapi(params[:name], **params[:opts], &params[:block])
+          end
 
-          super
+          # Assign same object_links
+          object_links.each_value do |attribute|
+            params = attribute.params
+            subclass.object_link(params[:name], **params[:opts], &params[:block])
+          end
+
+          # Assign same document_links
+          document_links.each_value do |attribute|
+            params = attribute.params
+            subclass.document_link(params[:name], **params[:opts], &params[:block])
+          end
+
+          # Assign same relationship_links
+          relationship_links.each_value do |attribute|
+            params = attribute.params
+            subclass.relationship_link(params[:name], **params[:opts], &params[:block])
+          end
+
+          # Assign same added_object_meta
+          added_object_meta.each_value do |attribute|
+            params = attribute.params
+            subclass.object_meta(params[:name], **params[:opts], &params[:block])
+          end
+
+          # Assign same added_document_meta
+          added_document_meta.each_value do |attribute|
+            params = attribute.params
+            subclass.document_meta(params[:name], **params[:opts], &params[:block])
+          end
+
+          # Assign same added_relationship_meta
+          added_relationship_meta.each_value do |attribute|
+            params = attribute.params
+            subclass.relationship_meta(params[:name], **params[:opts], &params[:block])
+          end
         end
 
-        def type(new_type = nil)
-          return (defined?(@type) && @type) || raise(Error, "#{self} has no defined type") unless new_type
+        def get_type
+          (defined?(@type) && @type) || raise(Error, "#{self} has no defined type")
+        end
+
+        def type(new_type)
+          @type = new_type.to_sym
+        end
 
-          new_type = new_type.to_sym
-          @type = new_type
+        def get_id
+          @id
         end
 
-        def relationship(name, serializer:, **opts, &block)
-          attribute(name, serializer: serializer, **opts, &block)
+        def id(**opts, &block)
+          @id = self::Attribute.new(name: :id, opts: opts, block: block)
         end
 
         # JSON API block values
         #
         # https://jsonapi.org/format/#document-jsonapi-object
-        def jsonapi_data(value = nil)
+        def jsonapi_data(_value = nil)
           @jsonapi_data ||= {}
         end
 
-        def jsonapi(key, &block)
-          jsonapi_data[key.to_sym] = block
-          self::JsonapiPresenter.add_method(key, block)
-          block
+        def jsonapi(name, **opts, &block)
+          new_attr = self::Attribute.new(name: name, opts: opts, block: block)
+          jsonapi_data[new_attr.name] = new_attr
         end
 
         # Links related to the resource
@@ -129,10 +163,9 @@ class Jat
           @object_links ||= {}
         end
 
-        def object_link(key, &block)
-          object_links[key.to_sym] = block
-          self::LinksPresenter.add_method(key, block)
-          block
+        def object_link(name, **opts, &block)
+          new_attr = self::Attribute.new(name: name, opts: opts, block: block)
+          object_links[new_attr.name] = new_attr
         end
 
         # Top-level document links
@@ -142,10 +175,9 @@ class Jat
           @document_links ||= {}
         end
 
-        def document_link(key, &block)
-          document_links[key.to_sym] = block
-          self::DocumentLinksPresenter.add_method(key, block)
-          block
+        def document_link(name, **opts, &block)
+          new_attr = self::Attribute.new(name: name, opts: opts, block: block)
+          document_links[new_attr.name] = new_attr
         end
 
         # Relationship links
@@ -155,10 +187,9 @@ class Jat
           @relationship_links ||= {}
         end
 
-        def relationship_link(key, &block)
-          relationship_links[key.to_sym] = block
-          self::RelationshipLinksPresenter.add_method(key, block)
-          block
+        def relationship_link(name, **opts, &block)
+          new_attr = self::Attribute.new(name: name, opts: opts, block: block)
+          relationship_links[new_attr.name] = new_attr
         end
 
         # Object meta
@@ -168,10 +199,9 @@ class Jat
           @added_object_meta ||= {}
         end
 
-        def object_meta(key, &block)
-          added_object_meta[key.to_sym] = block
-          self::MetaPresenter.add_method(key, block)
-          block
+        def object_meta(name, **opts, &block)
+          new_attr = self::Attribute.new(name: name, opts: opts, block: block)
+          added_object_meta[new_attr.name] = new_attr
         end
 
         # Top-level document meta
@@ -181,10 +211,9 @@ class Jat
           @added_document_meta ||= {}
         end
 
-        def document_meta(key, &block)
-          added_document_meta[key.to_sym] = block
-          self::DocumentMetaPresenter.add_method(key, block)
-          block
+        def document_meta(name, **opts, &block)
+          new_attr = self::Attribute.new(name: name, opts: opts, block: block)
+          added_document_meta[new_attr.name] = new_attr
         end
 
         # Relationship meta
@@ -194,10 +223,21 @@ class Jat
           @added_relationship_meta ||= {}
         end
 
-        def relationship_meta(key, &block)
-          added_relationship_meta[key.to_sym] = block
-          self::RelationshipMetaPresenter.add_method(key, block)
-          block
+        def relationship_meta(name, **opts, &block)
+          new_attr = self::Attribute.new(name: name, opts: opts, block: block)
+          added_relationship_meta[new_attr.name] = new_attr
+        end
+
+        def map(context)
+          self::Map.call(context)
+        end
+
+        def map_full
+          @map_full ||= self::Map.call(exposed: :all)
+        end
+
+        def map_exposed
+          @map_exposed ||= self::Map.call(exposed: :default)
         end
       end
     end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApi
+      class FieldsParamParser
+        module ClassMethods
+          COMMA = ","
+
+          # Returns the Jat class that this FieldsParamParser class is namespaced under.
+          attr_accessor :jat_class
+
+          # Since FieldsParamParser 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}::FieldsParamParser"
+          end
+
+          def parse(fields)
+            return FROZEN_EMPTY_HASH unless fields
+
+            parse_to_nested_hash(fields)
+          end
+
+          private
+
+          def parse_to_nested_hash(fields)
+            fields.each_with_object({}) do |(type, attrs_string), obj|
+              attrs = attrs_string.split(COMMA).map!(&:to_sym)
+              obj[type.to_sym] = attrs
+            end
+          end
+        end
+
+        extend ClassMethods
+      end
+    end
+  end
+end