jat 0.0.1 → 0.0.3

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Jat
+  module Presenters
+    class JsonapiPresenter
+      module InstanceMethods
+        # Presented object
+        attr_reader :object
+
+        # Presented context
+        attr_reader :context
+
+        def initialize(object, context)
+          @object = object
+          @context = context
+        end
+      end
+
+      module ClassMethods
+        attr_accessor :jat_class
+
+        def inspect
+          "#{jat_class.inspect}::Presenters::JsonapiPresenter"
+        end
+
+        def add_method(name, block)
+          # Warning-free method redefinition
+          remove_method(name) if method_defined?(name, false)
+          define_method(name, &block_without_args(block))
+        end
+
+        private
+
+        def block_without_args(block)
+          case block.parameters.count
+          when 0 then block
+          when 1 then -> { instance_exec(object, &block) }
+          when 2 then -> { instance_exec(object, context, &block) }
+          else raise Error, "Invalid block arguments count"
+          end
+        end
+      end
+
+      extend ClassMethods
+      include InstanceMethods
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Jat
+  module Presenters
+    class LinksPresenter
+      module InstanceMethods
+        # Presented object
+        attr_reader :object
+
+        # Presented context
+        attr_reader :context
+
+        def initialize(object, context)
+          @object = object
+          @context = context
+        end
+      end
+
+      module ClassMethods
+        attr_accessor :jat_class
+
+        def inspect
+          "#{jat_class.inspect}::Presenters::LinksPresenter"
+        end
+
+        def add_method(name, block)
+          # Warning-free method redefinition
+          remove_method(name) if method_defined?(name, false)
+          define_method(name, &block_without_args(block))
+        end
+
+        private
+
+        def block_without_args(block)
+          case block.parameters.count
+          when 0 then block
+          when 1 then -> { instance_exec(object, &block) }
+          when 2 then -> { instance_exec(object, context, &block) }
+          else raise Error, "Invalid block arguments count"
+          end
+        end
+      end
+
+      extend ClassMethods
+      include InstanceMethods
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Jat
+  module Presenters
+    class MetaPresenter
+      module InstanceMethods
+        # Presented object
+        attr_reader :object
+
+        # Presented context
+        attr_reader :context
+
+        def initialize(object, context)
+          @object = object
+          @context = context
+        end
+      end
+
+      module ClassMethods
+        attr_accessor :jat_class
+
+        def inspect
+          "#{jat_class.inspect}::Presenters::MetaPresenter"
+        end
+
+        def add_method(name, block)
+          # Warning-free method redefinition
+          remove_method(name) if method_defined?(name, false)
+          define_method(name, &block_without_args(block))
+        end
+
+        private
+
+        def block_without_args(block)
+          case block.parameters.count
+          when 0 then block
+          when 1 then -> { instance_exec(object, &block) }
+          when 2 then -> { instance_exec(object, context, &block) }
+          else raise Error, "Invalid block arguments count"
+          end
+        end
+      end
+
+      extend ClassMethods
+      include InstanceMethods
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+class Jat
+  module Presenters
+    class RelationshipLinksPresenter
+      module InstanceMethods
+        # Relationship parent object
+        attr_reader :parent_object
+
+        # Presented relationship
+        attr_reader :object
+
+        # Presented context
+        attr_reader :context
+
+        def initialize(parent_object, object, context)
+          @parent_object = parent_object
+          @object = object
+          @context = context
+        end
+      end
+
+      module ClassMethods
+        attr_accessor :jat_class
+
+        def inspect
+          "#{jat_class.inspect}::Presenters::RelationshipLinksPresenter"
+        end
+
+        def add_method(name, block)
+          # Warning-free method redefinition
+          remove_method(name) if method_defined?(name, false)
+          define_method(name, &block_without_args(block))
+        end
+
+        private
+
+        def block_without_args(block)
+          case block.parameters.count
+          when 0 then block
+          when 1 then -> { instance_exec(parent_object, &block) }
+          when 2 then -> { instance_exec(parent_object, object, &block) }
+          when 3 then -> { instance_exec(parent_object, object, context, &block) }
+          else raise Error, "Invalid block arguments count"
+          end
+        end
+      end
+
+      extend ClassMethods
+      include InstanceMethods
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+class Jat
+  module Presenters
+    class RelationshipMetaPresenter
+      module InstanceMethods
+        # Relationship parent object
+        attr_reader :parent_object
+
+        # Presented relationship
+        attr_reader :object
+
+        # Presented context
+        attr_reader :context
+
+        def initialize(parent_object, object, context)
+          @parent_object = parent_object
+          @object = object
+          @context = context
+        end
+      end
+
+      module ClassMethods
+        attr_accessor :jat_class
+
+        def inspect
+          "#{jat_class.inspect}::Presenters::RelationshipMetaPresenter"
+        end
+
+        def add_method(name, block)
+          # Warning-free method redefinition
+          remove_method(name) if method_defined?(name, false)
+          define_method(name, &block_without_args(block))
+        end
+
+        private
+
+        def block_without_args(block)
+          case block.parameters.count
+          when 0 then block
+          when 1 then -> { instance_exec(parent_object, &block) }
+          when 2 then -> { instance_exec(parent_object, object, &block) }
+          when 3 then -> { instance_exec(parent_object, object, context, &block) }
+          else raise Error, "Invalid block arguments count"
+          end
+        end
+      end
+
+      extend ClassMethods
+      include InstanceMethods
+    end
+  end
+end

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

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+# Serializes to JSON-API format
+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)
+          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)
+          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?
+
+          presenter = jat_class::DocumentMetaPresenter.new(object, context)
+          document_meta.each_key do |key|
+            data[key] = presenter.public_send(key) unless data.key?(key)
+          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
+
+          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
+
+        def get_attributes
+          attributes_names = map[:attributes]
+          return if attributes_names.empty?
+
+          attributes_names.each_with_object({}) do |name, attrs|
+            attribute = jat_class.attributes[name]
+            attrs[name] = presenter.public_send(attribute.original_name)
+          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
+
+            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 [] 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 = 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 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
+          links = jat_class.object_links
+          return links if links.empty?
+
+          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 get_meta
+          meta = jat_class.added_object_meta
+          return meta if meta.empty?
+
+          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 get_relationship_links(rel_serializer, rel_object)
+          links = rel_serializer.relationship_links
+          return links if links.empty?
+
+          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
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "./construct_traversal_map"
+require_relative "./map"
+
+class Jat
+  module Plugins
+    module JsonApi
+      class TraversalMap
+        module InstanceMethods
+          attr_reader :jat
+
+          def initialize(jat)
+            @jat = jat
+          end
+
+          def full
+            @full ||= ConstructTraversalMap.new(jat.class, :all).to_h
+          end
+
+          def exposed
+            @exposed ||= ConstructTraversalMap.new(jat.class, :exposed).to_h
+          end
+
+          def current
+            @current ||= Map.call(jat)
+          end
+        end
+
+        include InstanceMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Combines all serializer and its relations exposed fields into one hash.
+class Jat
+  module Plugins
+    module SimpleApi
+      class ConstructTraversalMap
+        attr_reader :jat_class, :exposed, :manually_exposed
+
+        def initialize(jat_class, exposed, manually_exposed: nil)
+          @jat_class = jat_class
+          @exposed = exposed.to_sym
+          @manually_exposed = manually_exposed || {}
+        end
+
+        def to_h
+          jat_class.attributes.each_with_object({}) do |(name, attribute), result|
+            next unless expose?(attribute)
+
+            result[name] =
+              if attribute.relation?
+                self.class.new(attribute.serializer.call, exposed, manually_exposed: manually_exposed[name]).to_h
+              else
+                {}
+              end
+          end
+        end
+
+        private
+
+        def expose?(attribute)
+          case exposed
+          when :all then true
+          when :none then manually_exposed?(attribute)
+          else attribute.exposed? || manually_exposed?(attribute)
+          end
+        end
+
+        def manually_exposed?(attribute)
+          manually_exposed.include?(attribute.name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "./params/parse"
+require_relative "./construct_traversal_map"
+
+class Jat
+  module Plugins
+    module SimpleApi
+      class Map
+        class << self
+          # 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
+
+            manually_exposed = Params::Parse.new(fields).parse
+
+            ConstructTraversalMap.new(jat.class, exposed, manually_exposed: manually_exposed).to_h
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module SimpleApi
+      module Params
+        class Parse
+          module InstanceMethods
+            COMMA = ","
+            OPEN_BRACKET = "("
+            CLOSE_BRACKET = ")"
+
+            def initialize(fields)
+              @fields = fields
+              @map = []
+              @res = {}
+            end
+
+            # user => { user: {} }
+            # user(id) => { user: { id: true } }
+            # user(id, name) => { user: { id: true, name: true } }
+            # user, comments => { user: {}, comments: {} }
+            # user(comments(text)) => { user: {}, comments: {} }
+            def parse
+              return {} unless fields
+
+              current_attr = nil
+
+              fields.each_char do |char|
+                case char
+                when COMMA
+                  add_attribute(current_attr)
+                  current_attr = nil
+                when CLOSE_BRACKET
+                  add_attribute(current_attr)
+                  map.pop
+                  current_attr = nil
+                when OPEN_BRACKET
+                  add_attribute(current_attr)
+                  map << current_attr.to_sym if current_attr
+                  current_attr = nil
+                else
+                  current_attr = current_attr ? current_attr.insert(-1, char) : char
+                end
+              end
+              add_attribute(current_attr)
+
+              res
+            end
+
+            private
+
+            attr_reader :fields, :map, :res
+
+            def add_attribute(current_attr)
+              return unless current_attr
+
+              current_resource = map.empty? ? res : res.dig(*map)
+              current_resource[current_attr.to_sym] = {}
+            end
+          end
+
+          include InstanceMethods
+        end
+      end
+    end
+  end
+end