jat 0.0.3 → 0.0.5

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

@@ -1,28 +1,98 @@
 # frozen_string_literal: true
 
-require_relative "./params/parse"
-require_relative "./construct_traversal_map"
-
 class Jat
   module Plugins
     module SimpleApi
       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
           # {
           #   key1 => { key11 => {}, key12 => { ... } },
           #   key2 => { key21 => {}, key22 => { ... } },
           # }
-          def call(jat)
-            params = jat.context[:params]
-            fields = params && (params[:fields] || params["fields"])
-            exposed = jat.context[:exposed] || :default
+          def call(context)
+            exposed = context[:exposed]&.to_sym || :default
+            fields = context[:fields]
+
+            construct_map(exposed, fields)
+          end
+
+          private
+
+          def construct_map(exposed, fields)
+            fields = jat_class::FieldsParamParser.parse(fields) if fields
+            new(exposed, fields).to_h
+          end
+        end
+
+        module InstanceMethods
+          attr_reader :exposed, :fields
+
+          EXPOSED_TYPES = {all: :all, default: :default, none: :none}.freeze
+
+          def initialize(exposed, fields)
+            @exposed = EXPOSED_TYPES.fetch(exposed)
+            @fields = fields
+          end
+
+          def to_h
+            map_for(self.class.jat_class, fields)
+          end
+
+          def map_for(serializer, fields, stack = [])
+            serializer.attributes.each_with_object({}) do |name_attr, result|
+              name = name_attr[0]
+              attribute = name_attr[1]
+              next unless expose?(attribute, fields)
 
-            manually_exposed = Params::Parse.new(fields).parse
+              raise Error, recursive_error_message(stack, name) if stack.any?(name_attr)
+              stack << name_attr
 
-            ConstructTraversalMap.new(jat.class, exposed, manually_exposed: manually_exposed).to_h
+              result[name] =
+                if attribute.relation?
+                  nested_serializer = attribute.serializer.call
+                  nested_fields = fields&.[](name)
+                  map_for(nested_serializer, nested_fields, stack)
+                else
+                  FROZEN_EMPTY_HASH
+                end
+
+              stack.pop
+            end
+          end
+
+          private
+
+          def expose?(attribute, fields)
+            case exposed
+            when :all then true
+            when :none then manually_exposed?(attribute, fields)
+            else attribute.exposed? || manually_exposed?(attribute, fields)
+            end
+          end
+
+          def manually_exposed?(attribute, fields)
+            fields&.include?(attribute.name)
+          end
+
+          def recursive_error_message(stack, name)
+            recursion = (stack.map!(&:first) << name).join(" -> ")
+            "Recursive serialization: #{recursion}"
           end
         end
+
+        extend ClassMethods
+        include InstanceMethods
       end
     end
   end

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

@@ -5,129 +5,118 @@ class Jat
   module Plugins
     module SimpleApi
       class Response
-        attr_reader :jat, :jat_class, :object, :context
+        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
 
-        def initialize(jat)
-          @jat = jat
-          @jat_class = jat.class
-          @object = jat.object
-          @context = jat.context
+          def call(object, context)
+            new(object, context).to_h
+          end
         end
 
-        def response
-          # Add main response
-          result = many? ? many(object) : one(object)
-          result = {root_key => result} if root_key
-          result ||= {}
+        module InstanceMethods
+          attr_reader :object, :context, :jat_class
 
-          # Add metadata to response
-          # We can add metadata to empty response, or to top-level namespace
-          # We should not mix metadata with object attributes
-          metadata.tap do |meta|
-            next if meta.empty?
-            raise Error, "Response must have a root key to add metadata" if !result.empty? && !root_key
-            result[meta_key] = meta
+          def initialize(object, context)
+            @object = object
+            @context = context
+            @jat_class = self.class.jat_class
           end
 
-          result
-        end
+          def to_h
+            # Add main response
+            is_many = many?
+            root = root_key(is_many)
 
-        private
+            response = is_many ? many(object) : one(object)
+            response = {root => response} if root
+            response ||= {}
 
-        def metadata
-          result = context[:meta] || {}
+            add_metadata(response, root)
 
-          config_meta = jat_class.config[:meta]
-          return result unless config_meta
+            response
+          end
 
-          config_meta.each_with_object(result) do |(key, value), res|
-            next if res.key?(key) # do not overwrite manually added meta
+          private
 
-            value = value.call(object, context) if value.respond_to?(:call)
-            res[key] = value unless value.nil?
+          def many(objects)
+            objects.map { |obj| one(obj) }
           end
-        end
-
-        def many(objects)
-          objects.map { |obj| one(obj) }
-        end
 
-        def one(obj)
-          ResponseData.new(jat_class, obj, context, jat.traversal_map).data
-        end
+          def one(obj)
+            map = jat_class.map(context)
+            jat_class::ResponsePiece.to_h(obj, context, map)
+          end
 
-        def many?
-          @is_many ||= begin
+          def many?
             many = context[:many]
             many.nil? ? object.is_a?(Enumerable) : many
           end
-        end
 
-        # We can provide nil or false to remove root
-        def root_key
-          @root_key ||=
+          # We can provide nil or false to remove root
+          def root_key(is_many)
             if context.key?(:root)
-              context[:root]
+              root = context[:root]
+              root ? root.to_sym : root
             else
-              (many? ? jat_class.root_for_many : jat_class.root_for_one) || jat_class.root
+              config = jat_class.config
+              is_many ? config[:root_many] : config[:root_one]
             end
-        end
+          end
 
-        def meta_key
-          context[:meta_key] || jat_class.meta_key
-        end
-      end
+          # Add metadata to response
+          # We can add metadata whether to empty response or to top-level namespace
+          # We should not mix metadata with object attributes
+          def add_metadata(response, root)
+            meta = metadata
+            return if meta.empty?
 
-      class ResponseData
-        attr_reader :jat_class, :object, :context, :map, :presenter
+            raise Error, "Response must have a root key to add metadata" if !response.empty? && !root
+            response[meta_key] = meta
+          end
 
-        def initialize(jat_class, object, context, map)
-          @jat_class = jat_class
-          @object = object
-          @context = context
-          @map = map
-          @presenter = jat_class::Presenter.new(object, context)
-        end
+          def meta_key
+            context[:meta_key]&.to_sym || jat_class.config[:meta_key]
+          end
+
+          def metadata
+            data = context_metadata
 
-        def data
-          return unless object
+            meta = jat_class.added_meta
+            return data if meta.empty?
 
-          result = {}
+            meta.each do |name, attribute|
+              next if data.key?(name)
 
-          map.each do |key, inner_keys|
-            attribute = jat_class.attributes.fetch(key)
-            value = presenter.public_send(attribute.original_name)
+              value = attribute_value(attribute)
 
-            result[key] =
-              if attribute.relation?
-                if many?(attribute, value)
-                  value.map { |obj| response_data(attribute, obj, inner_keys) }
-                else
-                  response_data(attribute, value, inner_keys)
-                end
-              else
-                value
+              unless value.nil?
+                data = data.dup if data.equal?(FROZEN_EMPTY_HASH)
+                data[name] = value
               end
-          end
+            end
 
-          result
-        end
+            data
+          end
 
-        private
+          def context_metadata
+            context[:meta]&.transform_keys(&:to_sym) || FROZEN_EMPTY_HASH
+          end
 
-        def response_data(attribute, value, map)
-          ResponseData.new(attribute.serializer.call, value, context, map).data
+          def attribute_value(attribute)
+            attribute.block.call(object, context)
+          end
         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
+        extend ClassMethods
+        include InstanceMethods
       end
     end
   end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# Serializes to JSON-API format
+class Jat
+  module Plugins
+    module SimpleApi
+      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 to_h(object, context, map)
+            new(object, context).piece(map)
+          end
+        end
+
+        module InstanceMethods
+          attr_reader :jat_class, :object, :context
+
+          def initialize(object, context)
+            @object = object
+            @context = context
+            @jat_class = self.class.jat_class
+          end
+
+          def piece(map)
+            return unless object
+
+            result = {}
+
+            map.each do |key, inner_map|
+              attribute = jat_class.attributes.fetch(key)
+              value = attribute_value(attribute)
+
+              result[key] =
+                if attribute.relation?
+                  if many?(attribute, value)
+                    value.map { |obj| inner_piece(attribute, obj, inner_map) }
+                  else
+                    inner_piece(attribute, value, inner_map)
+                  end
+                else
+                  value
+                end
+            end
+
+            result
+          end
+
+          private
+
+          def attribute_value(attribute)
+            attribute.block.call(object, context)
+          end
+
+          def inner_piece(attribute, value, inner_map)
+            serializer = attribute.serializer.call
+            serializer::ResponsePiece.to_h(value, context, inner_map)
+          end
+
+          def many?(attribute, nested_object)
+            is_many = attribute.many?
+
+            # handle boolean
+            return is_many if (is_many == true) || (is_many == false)
+
+            # handle nil
+            nested_object.is_a?(Enumerable)
+          end
+        end
+
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+  end
+end

data/lib/jat/plugins/simple_api/simple_api.rb

@@ -1,61 +1,120 @@
 # frozen_string_literal: true
 
+require_relative "./lib/fields_param_parser"
 require_relative "./lib/map"
 require_relative "./lib/response"
+require_relative "./lib/response_piece"
 
-# Serializes to JSON-API format
 class Jat
   module Plugins
     module SimpleApi
       DEFAULT_META_KEY = :meta
 
+      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
+
       def self.after_load(jat_class, **opts)
-        jat_class.plugin(:_json_api_activerecord, **opts) if opts[:activerecord]
+        jat_class.config[:response_plugin_loaded] = :simple_api
+        jat_class.plugin(:simple_api_activerecord, **opts) if opts[:activerecord]
+
+        jat_class.meta_key(DEFAULT_META_KEY)
+
+        fields_parser_class = Class.new(FieldsParamParser)
+        fields_parser_class.jat_class = jat_class
+        jat_class.const_set(:FieldsParamParser, fields_parser_class)
+
+        map_class = Class.new(Map)
+        map_class.jat_class = jat_class
+        jat_class.const_set(:Map, map_class)
+
+        response_class = Class.new(Response)
+        response_class.jat_class = jat_class
+        jat_class.const_set(:Response, response_class)
+
+        response_piece_class = Class.new(ResponsePiece)
+        response_piece_class.jat_class = jat_class
+        jat_class.const_set(:ResponsePiece, response_piece_class)
       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 ||= Map.call(self)
+        def map
+          @map ||= self.class.map(context)
         end
       end
 
       module ClassMethods
         def inherited(subclass)
-          subclass.root(@root) if defined?(@root)
-
           super
+
+          fields_parser_class = Class.new(self::FieldsParamParser)
+          fields_parser_class.jat_class = subclass
+          subclass.const_set(:FieldsParamParser, fields_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)
+
+          # Assign same meta
+          added_meta.each_value do |attribute|
+            params = attribute.params
+            subclass.attribute(params[:name], **params[:opts], &params[:block])
+          end
         end
 
-        def root(new_root = nil)
-          return (defined?(@root) && @root) unless new_root
+        def root(default = nil, one: nil, many: nil)
+          root_one = one || default
+          root_many = many || default
+
+          config[:root_one] = root_one ? root_one.to_sym : nil
+          config[:root_many] = root_many ? root_many.to_sym : nil
 
-          new_root = new_root.to_sym
-          @root = new_root
+          {root_one: root_one, root_many: root_many}
         end
 
-        def root_for_one(new_root_for_one = nil)
-          return (defined?(@root_for_one) && @root_for_one) unless new_root_for_one
+        def meta_key(new_meta_key)
+          config[:meta_key] = new_meta_key.to_sym
+        end
 
-          new_root_for_one = new_root_for_one.to_sym
-          @root_for_one = new_root_for_one
+        def added_meta
+          @added_meta ||= {}
         end
 
-        def root_for_many(new_root_for_many = nil)
-          return (defined?(@root_for_many) && @root_for_many) unless new_root_for_many
+        def meta(name, **opts, &block)
+          new_attr = self::Attribute.new(name: name, opts: opts, block: block)
+          added_meta[new_attr.name] = new_attr
+        end
 
-          new_root_for_many = new_root_for_many.to_sym
-          @root_for_many = new_root_for_many
+        def map(context)
+          self::Map.call(context)
         end
 
-        def meta_key(new_meta_key = nil)
-          return ((defined?(@meta_key) && @meta_key) || DEFAULT_META_KEY) unless new_meta_key
+        def map_full
+          @map_full ||= self::Map.call(exposed: :all)
+        end
 
-          new_meta_key = new_meta_key.to_sym
-          @meta_key = new_meta_key
+        def map_exposed
+          @map_exposed ||= self::Map.call(exposed: :default)
         end
       end
     end

data/lib/jat/plugins/simple_api_activerecord/lib/preloads.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module SimpleApiActiverecord
+      class Preloads
+        module ClassMethods
+          def call(jat)
+            result = {}
+            append_many(result, jat.class, jat.map)
+            result
+          end
+
+          private
+
+          def append_many(result, jat_class, keys)
+            keys.each do |key, inner_keys|
+              attribute = jat_class.attributes.fetch(key)
+              preloads = attribute.preloads
+              next unless preloads
+
+              append_one(result, jat_class, preloads)
+              next if inner_keys.empty?
+
+              path = attribute.preloads_path
+              nested_result = nested(result, path)
+              nested_serializer = attribute.serializer.call
+
+              append_many(nested_result, nested_serializer, inner_keys)
+            end
+          end
+
+          def append_one(result, jat_class, preloads)
+            return if preloads.empty?
+
+            preloads = EnumDeepDup.call(preloads)
+            merge(result, preloads)
+          end
+
+          def merge(result, preloads)
+            result.merge!(preloads) do |_key, value_one, value_two|
+              merge(value_one, value_two)
+            end
+          end
+
+          def nested(result, path)
+            !path || path.empty? ? result : result.dig(*path)
+          end
+        end
+
+        extend ClassMethods
+      end
+    end
+  end
+end

data/lib/jat/plugins/simple_api_activerecord/simple_api_activerecord.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "./lib/preloads"
+
+class Jat
+  module Plugins
+    module SimpleApiActiverecord
+      def self.before_load(jat_class, **_opts)
+        return if jat_class.plugin_used?(:simple_api)
+        raise Error, "Please load :simple_api plugin first"
+      end
+
+      def self.load(jat_class, **_opts)
+        jat_class.include(InstanceMethods)
+      end
+
+      def self.after_load(jat_class, **opts)
+        jat_class.plugin :_preloads, **opts
+        jat_class.plugin :_activerecord_preloads, **opts
+      end
+
+      module InstanceMethods
+        def preloads
+          @preloads ||= Preloads.call(self)
+        end
+      end
+    end
+
+    register_plugin(:simple_api_activerecord, SimpleApiActiverecord)
+  end
+end

data/lib/jat/plugins/simple_api_lower_camel_case/simple_api_lower_camel_case.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module SimpleApiLowerCamelCase
+      def self.before_load(jat_class, **_opts)
+        raise Error, "Please load :simple_api plugin first" unless jat_class.plugin_used?(:simple_api)
+
+        jat_class.plugin :_lower_camel_case
+      end
+
+      def self.load(jat_class, **_opts)
+        jat_class::Response.include(ResponseInstanceMethods)
+      end
+
+      module ResponseInstanceMethods
+        private
+
+        def context_metadata
+          metadata = super
+          return metadata if metadata.empty?
+
+          metadata.transform_keys! { |key| Jat::LowerCamelCaseTransformation.call(key) }
+        end
+      end
+    end
+
+    register_plugin(:simple_api_lower_camel_case, SimpleApiLowerCamelCase)
+  end
+end