jat 0.0.1 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c17f2cb00d5dc319df32abc1b0fd41d00adb30f0f8357faf6d74b7d440ef1d9
-  data.tar.gz: 0d638bef47aa94698fa25a5c2dc0f6559e528ef8b5bf525bec07310307dbcda3
+  metadata.gz: e4b14981546d524f665e1d268857bd8b2caafec9af07157a1f57fd2ca8f9c83c
+  data.tar.gz: 1335c436d0e4ae1f70fb70a9ef5757610e09ce3b5a03b87ba356d31625af0ab3
 SHA512:
-  metadata.gz: 369741fcd71f789f49fe0e555db75982fd7758959c59833b1b3d4dd8c55d424cd159f825a9ee6a7d17d5da3c821d44c7052b3ec49910bcf5ab569114916ed6b4
-  data.tar.gz: 25a6235d5ec37e44917f64e0d40a98032bb391120832c0357741b56f98571d5941323b548c501bb4a1c761caf62f6cc0a65a09cb8b05f1376d20ba093799688c
+  metadata.gz: fcaccbe3cb5e5a27cd5700e3677886fb9966ef8ce2775bf2be6638578489747b8a488acbd3f6f7f55752323c40bc92410af1d079dfeefe2d4b41d4f768fbfbfb
+  data.tar.gz: 23a2cbda699f9e8f2a9588dc8cfb4350bbd1a1994603577bd3649a356148ad88d2bd754529bb63905aba59a993cc747c2e5ad762038fb571d5d83b1ecc6d40b4

data/lib/jat/attribute.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "utils/enum_deep_dup"
+require_relative "utils/enum_deep_freeze"
+
+class Jat
+  class Attribute
+    module InstanceMethods
+      attr_reader :params, :opts
+
+      def initialize(name:, opts: {}, block: nil)
+        @opts = EnumDeepDup.call(opts)
+        @params = EnumDeepFreeze.call(name: name, opts: @opts, block: block)
+      end
+
+      # Attribute name that was provided when initializing attribute
+      def original_name
+        @original_name ||= params.fetch(:name).to_sym
+      end
+
+      # Object method name to get attribute value
+      def key
+        @key ||= opts.key?(:key) ? opts[:key].to_sym : original_name
+      end
+
+      # Attribute name that will be used in serialized response
+      def name
+        @name ||= original_name
+      end
+
+      # Checks if attribute is exposed
+      def exposed?
+        return @exposed if instance_variable_defined?(:@exposed)
+
+        @exposed =
+          case self.class.jat_class.config[:exposed]
+          when :all then opts.fetch(:exposed, true)
+          when :none then opts.fetch(:exposed, false)
+          else opts.fetch(:exposed, !relation?)
+          end
+      end
+
+      def many?
+        return @many if instance_variable_defined?(:@many)
+
+        @many = opts[:many]
+      end
+
+      def relation?
+        return @relation if instance_variable_defined?(:@relation)
+
+        @relation = opts.key?(:serializer)
+      end
+
+      def serializer
+        return @serializer if instance_variable_defined?(:@serializer)
+
+        @serializer = opts[:serializer]
+      end
+
+      def block
+        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 = 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 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
+
+    module ClassMethods
+      # Returns the Jat class that this Attribute class is namespaced under.
+      attr_accessor :jat_class
+
+      # Since Attribute 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}::Attribute"
+      end
+    end
+
+    extend ClassMethods
+    include InstanceMethods
+  end
+end

data/lib/jat/config.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require_relative "utils/enum_deep_dup"
+
+class Jat
+  class Config
+    module InstanceMethods
+      extend Forwardable
+
+      attr_reader :opts
+
+      def initialize(opts = {})
+        @opts = EnumDeepDup.call(opts)
+      end
+
+      def_delegators :@opts, :[], :[]=, :fetch
+    end
+
+    module ClassMethods
+      # Returns the Jat class that this config class is namespaced under.
+      attr_accessor :jat_class
+
+      # Since Config 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}::Config"
+      end
+    end
+
+    include InstanceMethods
+    extend ClassMethods
+  end
+end

data/lib/jat/plugins/activerecord/activerecord.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module Activerecord
+      def self.plugin_name
+        :activerecord
+      end
+
+      def self.load(jat_class, **opts)
+        if jat_class.plugin_used?(:json_api)
+          jat_class.plugin :json_api_activerecord, **opts
+        elsif jat_class.plugin_used?(:simple_api)
+          jat_class.plugin :simple_api_activerecord, **opts
+        else
+          raise Error, "Please load :json_api or :simple_api plugin first"
+        end
+      end
+    end
+
+    register_plugin(Activerecord.plugin_name, Activerecord)
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module Cache
+      def self.plugin_name
+        :cache
+      end
+
+      def self.before_load(jat_class, **opts)
+        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(object)
+          return super if context[:_format] == FORMAT_TO_STR
+
+          context[:_format] = FORMAT_TO_H
+          cached(object) { super }
+        end
+
+        def to_str(object)
+          context[:_format] = FORMAT_TO_STR
+          cached(object) { super }
+        end
+
+        private
+
+        def cached(object, &block)
+          cache = context[:cache]
+          return yield unless cache
+
+          cache.call(object, context, &block)
+        end
+      end
+    end
+
+    register_plugin(Cache.plugin_name, Cache)
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "./lib/preloader"
+
+class Jat
+  module Plugins
+    module ActiverecordPreloads
+      def self.plugin_name
+        :_activerecord_preloads
+      end
+
+      def self.load(jat_class, **_opts)
+        jat_class.include(InstanceMethods)
+      end
+
+      module InstanceMethods
+        def to_h(object)
+          object = add_preloads(object)
+          super
+        end
+
+        private
+
+        def add_preloads(obj)
+          return obj if obj.nil? || (obj.is_a?(Array) && obj.empty?)
+
+          # preloads() method comes from simple_api_activerecord or json_api_activerecord plugin
+          preloads = preloads()
+          return obj if preloads.empty?
+
+          Preloader.preload(obj, preloads)
+        end
+      end
+    end
+
+    register_plugin(ActiverecordPreloads.plugin_name, ActiverecordPreloads)
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module ActiverecordPreloads
+      class Preloader
+        module ClassMethods
+          def preload(object, preloads)
+            preload_handler = handlers.find { |handler| handler.fit?(object) }
+            raise Error, "Can't preload #{preloads.inspect} to #{object.inspect}" unless preload_handler
+
+            preload_handler.preload(object, preloads)
+          end
+
+          def handlers
+            @handlers ||= [ActiverecordRelation, ActiverecordObject, ActiverecordArray].freeze
+          end
+        end
+
+        extend ClassMethods
+      end
+
+      class Loader
+        def self.call(records, associations)
+          if ActiveRecord::VERSION::MAJOR >= 7
+            ActiveRecord::Associations::Preloader.new(records: records, associations: associations).call
+          else
+            ActiveRecord::Associations::Preloader.new.preload(records, associations)
+          end
+        end
+      end
+
+      class ActiverecordObject
+        module ClassMethods
+          def fit?(object)
+            object.is_a?(ActiveRecord::Base)
+          end
+
+          def preload(object, preloads)
+            Loader.call([object], preloads)
+            object
+          end
+        end
+
+        extend ClassMethods
+      end
+
+      class ActiverecordRelation
+        module ClassMethods
+          def fit?(objects)
+            objects.is_a?(ActiveRecord::Relation)
+          end
+
+          def preload(objects, preloads)
+            if objects.loaded?
+              array_objects = objects.to_a
+              Loader.call(array_objects, preloads)
+              objects
+            else
+              objects.preload(preloads).load
+            end
+          end
+        end
+
+        extend ClassMethods
+      end
+
+      class ActiverecordArray
+        module ClassMethods
+          def fit?(objects)
+            objects.is_a?(Array) &&
+              ActiverecordObject.fit?(objects.first) &&
+              same_kind?(objects)
+          end
+
+          def preload(objects, preloads)
+            Loader.call(objects, preloads)
+            objects
+          end
+
+          private
+
+          def same_kind?(objects)
+            first_object_class = objects.first.class
+            objects.all? { |object| object.instance_of?(first_object_class) }
+          end
+        end
+
+        extend ClassMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module LowerCamelCase
+      def self.plugin_name
+        :_lower_camel_case
+      end
+
+      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(LowerCamelCase.plugin_name, 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/common/_preloads/_preloads.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "./lib/format_user_preloads"
+require_relative "./lib/preloads_with_path"
+
+# This plugin adds attribute methods #preloads, #preloads_path
+class Jat
+  module Plugins
+    module Preloads
+      def self.plugin_name
+        :_preloads
+      end
+
+      def self.load(jat_class, **_opts)
+        jat_class::Attribute.include(AttributeMethods)
+      end
+
+      module AttributeMethods
+        NULL_PRELOADS = [nil, [].freeze].freeze
+
+        def preloads
+          return @preloads if defined?(@preloads)
+
+          @preloads, @preloads_path = get_preloads_with_path
+          @preloads
+        end
+
+        def preloads_path
+          return @preloads_path if defined?(@preloads_path)
+
+          @preloads, @preloads_path = get_preloads_with_path
+          @preloads_path
+        end
+
+        # When provided multiple values in preloads, such as { user: [:profile] },
+        # 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), otherwise the latest key will be considered main.
+        def get_preloads_with_path
+          preloads_provided = opts.key?(:preload)
+          preloads =
+            if preloads_provided
+              opts[:preload]
+            elsif relation?
+              key
+            end
+
+          # Nulls and empty hash differs as we can preload nested results to
+          # empty hash, but we will skip nested preloading if null or false provided
+          return NULL_PRELOADS if preloads_provided && !preloads
+
+          preloads = FormatUserPreloads.to_hash(preloads)
+          preloads, path = PreloadsWithPath.call(preloads)
+
+          [EnumDeepFreeze.call(preloads), path.freeze]
+        end
+      end
+    end
+
+    register_plugin(Preloads.plugin_name, Preloads)
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module Preloads
+      class FormatUserPreloads
+        METHODS = {
+          Array => :array_to_hash,
+          FalseClass => :nil_to_hash,
+          Hash => :hash_to_hash,
+          NilClass => :nil_to_hash,
+          String => :string_to_hash,
+          Symbol => :symbol_to_hash
+        }.freeze
+
+        module ClassMethods
+          def to_hash(value)
+            send(METHODS.fetch(value.class), value)
+          end
+
+          private
+
+          def array_to_hash(values)
+            values.each_with_object({}) do |value, obj|
+              obj.merge!(to_hash(value))
+            end
+          end
+
+          def hash_to_hash(values)
+            values.each_with_object({}) do |(key, value), obj|
+              obj[key.to_sym] = to_hash(value)
+            end
+          end
+
+          def nil_to_hash(_value)
+            {}
+          end
+
+          def string_to_hash(value)
+            symbol_to_hash(value.to_sym)
+          end
+
+          def symbol_to_hash(value)
+            {value => {}}
+          end
+        end
+
+        extend ClassMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module Preloads
+      class PreloadsWithPath
+        module ClassMethods
+          BANG = "!"
+          NO_PRELOADS = [{}.freeze, [].freeze].freeze
+
+          # @param preload<Hash> Formatted user provided preloads hash
+          def call(preloads)
+            return NO_PRELOADS if preloads.empty?
+
+            path = main_path(preloads)
+            return [preloads, path] unless has_bang?(path)
+
+            # We should remove bangs from last key in path and from associated preloads key.
+            # We use mutable methods here.
+            remove_bangs(preloads, path)
+            [preloads, path]
+          end
+
+          private
+
+          # Generates path (Array) to main included resource.
+          # We need to know main included resource to include nested associations.
+          #
+          # User should mark main included resource with "!"
+          # When nothing marked, last included resource is considered main.
+          #
+          #  main_path(a: { b!: { c: {} }, d: {} }) # => [:a, :b]
+          #  main_path(a: { b: { c: {} }, d: {} }) # => [:a, :d]
+          #
+          def main_path(hash, path = [])
+            current_level = path.size
+
+            hash.each do |key, data|
+              path.pop(path.size - current_level)
+              path << key
+              return path if key[-1] == BANG
+
+              main_path(data, path)
+              return path if path.last[-1] == BANG
+            end
+
+            path
+          end
+
+          def remove_bangs(preloads, path)
+            # Remove last path with bang
+            bang_key = path.pop
+
+            # Delete bang from key
+            key = bang_key.to_s.delete_suffix!(BANG).to_sym
+
+            # Navigate to main resource and replace key with BANG
+            nested_preloads = empty_dig(preloads, path)
+            nested_preloads[key] = nested_preloads.delete(bang_key)
+
+            # Add cleared key to path
+            path << key
+          end
+
+          def empty_dig(hash, path)
+            path.empty? ? hash : hash.dig(*path)
+          end
+
+          def has_bang?(path)
+            path.last[-1] == BANG
+          end
+        end
+
+        extend ClassMethods
+      end
+    end
+  end
+end