jat 0.0.3 → 0.0.8

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

@@ -1,125 +1,163 @@
 # 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.plugin_name
+        :json_api
+      end
+
+      def self.before_load(jat_class, **_opts)
+        response_plugin = jat_class.config[:response_plugin_loaded]
+        return unless response_plugin
+
+        raise Error, "Response plugin `#{response_plugin}` was already loaded before"
+      end
+
+      def self.load(jat_class, **_opts)
+        jat_class.include(InstanceMethods)
+        jat_class.extend(ClassMethods)
+      end
 
-        jat_class.const_set(:JsonapiPresenter, Class.new(Jat::Presenters::JsonapiPresenter))
-        jat_class::JsonapiPresenter.jat_class = jat_class
+      def self.after_load(jat_class, **opts)
+        jat_class.config[:response_plugin_loaded] = plugin_name
 
-        jat_class.const_set(:LinksPresenter, Class.new(Jat::Presenters::LinksPresenter))
-        jat_class::LinksPresenter.jat_class = jat_class
+        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(:DocumentLinksPresenter, Class.new(Jat::Presenters::DocumentLinksPresenter))
-        jat_class::DocumentLinksPresenter.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(:RelationshipLinksPresenter, Class.new(Jat::Presenters::RelationshipLinksPresenter))
-        jat_class::RelationshipLinksPresenter.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(:MetaPresenter, Class.new(Jat::Presenters::MetaPresenter))
-        jat_class::MetaPresenter.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(:DocumentMetaPresenter, Class.new(Jat::Presenters::DocumentMetaPresenter))
-        jat_class::DocumentMetaPresenter.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.const_set(:RelationshipMetaPresenter, Class.new(Jat::Presenters::RelationshipMetaPresenter))
-        jat_class::RelationshipMetaPresenter.jat_class = jat_class
+        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
 
-          new_type = new_type.to_sym
-          @type = new_type
+        def type(new_type)
+          @type = new_type.to_sym
         end
 
-        def relationship(name, serializer:, **opts, &block)
-          attribute(name, serializer: serializer, **opts, &block)
+        def get_id
+          @id
+        end
+
+        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 +167,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 +179,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 +191,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 +203,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 +215,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,14 +227,25 @@ 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
 
-    register_plugin(:json_api, JsonApi)
+    register_plugin(JsonApi.plugin_name, JsonApi)
   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

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)