serega 0.8.0 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2ebcd147c1714ebb2b4e923ee179c788158b225ac76791817229a82975926ec
-  data.tar.gz: eef2621b3d6b9ac6ee1da3de29d3006ff99a0c2c91082cdc7795e82665ee92e5
+  metadata.gz: 0d467016ac66fcd328919f3d7068dd556ac5a7768f657adb30948c2c316480a1
+  data.tar.gz: 3ae0c46dc6760cdf94299c0edc34b41a8b195cea92dff13b91a4017bb21653f7
 SHA512:
-  metadata.gz: 7891e792121105b7ee566b926347a63d82fb9fae186b7cf97766d4450141538d81dbb3bf7ac571b2ff7ed12bf8567f35d3e769a68e8979e47aad5c1c99be0300
-  data.tar.gz: 3dd972104c307eff809f5c41af005fb75fdd7caa6d6a494b90a8c63e89a0e25dc89de1547b762c6ad1f7ab3aa5e5f5811b470a6f20adaed55c7155c17fc00207
+  metadata.gz: 9f2a9f714be636a26f4ca2de8a5f692455080354f495dc5cc2d69dd874d207ddd0bc3286b47ea600ebf5a0ba2ddfd774d6876da67e82906d35319f4a54614caa
+  data.tar.gz: 766931dbb8aaa415dcc008a477258ba6f63ca35b664267278ee31ab0becc91f124e16eb1f57bd5968df03e333bb59c98a8396f796be84c254a76e674a472d6e1

data/README.md

@@ -150,7 +150,7 @@ UserSerializer.as_json([user]) # => [{"username":"serega"}]
 
   Modifiers can be provided as Hash, Array, String, Symbol or their combinations.
 
-  With plugin [string_modifiers][string_modifiers] we can provide modifiers as single `String` with attributes split by comma `,` and nested values inside brackets `()`, like: `username,enemies(username,email)`. This can be very useful to accept list of field in **GET** requests.
+  With plugin [string_modifiers][string_modifiers] we can provide modifiers as single `String` with attributes split by comma `,` and nested values inside brackets `()`, like: `username,enemies(username,email)`. This can be very useful to accept list of fields in **GET** requests.
 
   When provided non-existing attribute, `Serega::AttributeNotExist` error will be raised. This error can be muted with `check_initiate_params: false` parameter.
 
@@ -258,9 +258,9 @@ Allows to define `:preloads` to attributes and then allows to merge preloads
 from serialized attributes and return single associations hash.
 
 Plugin accepts options:
-- `auto_preload_attributes_with_delegate` - default false
-- `auto_preload_attributes_with_serializer` - default false
-- `auto_hide_attributes_with_preload` - default false
+- `auto_preload_attributes_with_delegate` - default `false`
+- `auto_preload_attributes_with_serializer` - default `false`
+- `auto_hide_attributes_with_preload` - default `false`
 
 This options are very handy if you want to forget about finding preloads manually.
 
@@ -373,13 +373,12 @@ Added new `:batch` attribute option, example:
 attribute :name, batch: { key: :id, loader: :name_loader, default: '' }
 ```
 
-`:batch` option must be a hash with this keys:
-- :key (required) [Symbol, Proc, callable] - Defines identifier of current object
-- :loader (required) [Symbol, Proc, callable] - Defines how to fetch values for batch of keys. Accepts 3 parameters: keys, context, point.
-- :default (optional) - Default value used when loader does not return value for current key. By default it is `nil` or `[]` when attribute has additional option `many: true` (`attribute :name, many: true, batch: { ... }`).
+Attribute `:batch` option must be a hash with this keys:
+- `key` (required) [Symbol, Proc, callable] - Defines identifier of current object
+- `loader` (required) [Symbol, Proc, callable] - Defines how to fetch values for batch of keys. Accepts 3 parameters: keys, context, point.
+- `default` (optional) - Default value used when loader does not return value for current key. By default it is `nil` or `[]` when attribute has additional option `many: true` (ex: `attribute :name, many: true, batch: { ... }`).
 
-If `:loader` was defined via Symbol then batch loader must be defined using `config.batch_loaders.define(:loader_name) { ... }` method.
-Result of this block must be a Hash where keys are - provided keys, and values are - batch loaded values for according keys.
+If `:loader` was defined using name (as Symbol) then batch loader must be defined using `config.batch_loaders.define(:loader_name) { ... }` method. Result of this block must be a Hash where keys are - provided keys, and values are - batch loaded values for according keys.
 
 Batch loader works well with [`activerecord_preloads`][activerecord_preloads] plugin.
 

data/VERSION

@@ -1 +1 @@
-0.8.0
+0.8.2

data/lib/serega/attribute.rb

@@ -136,7 +136,9 @@ class Serega
 
       def keyword_block
         key_method_name = key
-        proc { |object| object.public_send(key_method_name) }
+        proc do |object|
+          handle_no_method_error { object.public_send(key_method_name) }
+        end
       end
 
       def delegate_block
@@ -147,11 +149,25 @@ class Serega
         delegate_to = delegate[:to]
 
         if delegate[:allow_nil]
-          proc { |object| object.public_send(delegate_to)&.public_send(key_method_name) }
+          proc do |object|
+            handle_no_method_error do
+              object.public_send(delegate_to)&.public_send(key_method_name)
+            end
+          end
         else
-          proc { |object| object.public_send(delegate_to).public_send(key_method_name) }
+          proc do |object|
+            handle_no_method_error do
+              object.public_send(delegate_to).public_send(key_method_name)
+            end
+          end
         end
       end
+
+      def handle_no_method_error
+        yield
+      rescue NoMethodError => error
+        raise error, "NoMethodError when serializing '#{name}' attribute in #{self.class.serializer_class}\n\n#{error.message}", error.backtrace
+      end
     end
 
     extend Serega::SeregaHelpers::SerializerClassHelper

data/lib/serega/plugins/batch/batch.rb

@@ -50,6 +50,7 @@ class Serega
       # @return [void]
       #
       def self.load_plugin(serializer_class, **_opts)
+        require_relative "./lib/batch_option_model"
         require_relative "./lib/loader"
         require_relative "./lib/loaders"
         require_relative "./lib/validations/check_batch_opt_key"
@@ -87,14 +88,19 @@ class Serega
         serializer_class.const_set(:SeregaBatchLoader, batch_loader_class)
 
         if serializer_class.plugin_used?(:activerecord_preloads)
-          require_relative "./lib/plugins_extensions"
+          require_relative "./lib/plugins_extensions/activerecord_preloads"
           serializer_class::SeregaBatchLoader.include(PluginsExtensions::ActiveRecordPreloads::BatchLoaderInstanceMethods)
         end
 
         if serializer_class.plugin_used?(:formatters)
-          require_relative "./lib/plugins_extensions"
+          require_relative "./lib/plugins_extensions/formatters"
           serializer_class::SeregaBatchLoader.include(PluginsExtensions::Formatters::BatchLoaderInstanceMethods)
         end
+
+        if serializer_class.plugin_used?(:preloads)
+          require_relative "./lib/plugins_extensions/preloads"
+          serializer_class::SeregaAttribute.include(PluginsExtensions::Preloads::AttributeInstanceMethods)
+        end
       end
 
       #
@@ -140,56 +146,6 @@ class Serega
         end
       end
 
-      #
-      # Stores batch config for specific attribute
-      #
-      class BatchModel
-        attr_reader :opts, :loaders, :many
-
-        #
-        # Initializes batch model
-        #
-        # @param opts [Hash] Attribute :batch option
-        # @param loaders [Array] Array of all loaders defined in serialize class
-        # @param many [Boolean] Option :many, defined on attribute
-        #
-        # @return [void]
-        def initialize(opts, loaders, many)
-          @opts = opts
-          @loaders = loaders
-          @many = many
-        end
-
-        # Returns proc that will be used to batch load registered keys values
-        # @return [#call] batch loader
-        def loader
-          @batch_loader ||= begin
-            loader = opts[:loader]
-            loader = loaders.fetch(loader) if loader.is_a?(Symbol)
-            loader
-          end
-        end
-
-        # Returns proc that will be used to find batch_key for current attribute.
-        # @return [Object] key (uid) of batch loaded object
-        def key
-          @batch_key ||= begin
-            key = opts[:key]
-            key.is_a?(Symbol) ? proc { |object| object.public_send(key) } : key
-          end
-        end
-
-        # Returns default value to use if batch loader does not return value for some key
-        # @return [Object] default value for missing key
-        def default_value
-          if opts.key?(:default)
-            opts[:default]
-          elsif many
-            FROZEN_EMPTY_ARRAY
-          end
-        end
-      end
-
       #
       # Config class additional/patched instance methods
       #
@@ -263,16 +219,16 @@ class Serega
       #
       module MapPointInstanceMethods
         #
-        # Returns BatchModel, an object that encapsulates all batch_loader methods for current point
+        # Returns BatchOptionModel, an object that combines options and methods needed to load batch
         #
-        # @return [BatchModel] batch model that encapsulates everything needed to load current batch
+        # @return [BatchOptionModel] Class that combines options and methods needed to load batch.
         #
         def batch
           return @batch if instance_variable_defined?(:@batch)
 
           @batch = begin
             opts = attribute.batch
-            BatchModel.new(opts, self.class.serializer_class.config.batch_loaders, many) if opts
+            BatchOptionModel.new(attribute) if opts
           end
         end
       end

data/lib/serega/plugins/batch/lib/batch_option_model.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    module Batch
+      #
+      # Combines options and methods needed to load batch for specific attribute
+      #
+      class BatchOptionModel
+        attr_reader :attribute, :opts, :loaders, :many
+
+        #
+        # Initializes BatchOptionModel
+        #
+        # @param map_point [Serega::SeregaMapPoint] Map point for attribute with :batch option
+        # @param loaders [Array] Array of all loaders defined in serialize class
+        # @param many [Boolean] Option :many, defined on attribute
+        #
+        # @return [void]
+        def initialize(attribute)
+          @attribute = attribute
+          @opts = attribute.batch
+          @loaders = attribute.class.serializer_class.config.batch_loaders
+          @many = attribute.many
+        end
+
+        # Returns proc that will be used to batch load registered keys values
+        # @return [#call] batch loader
+        def loader
+          @batch_loader ||= begin
+            loader = opts[:loader]
+            loader = loaders.fetch(loader) if loader.is_a?(Symbol)
+            loader
+          end
+        end
+
+        # Returns proc that will be used to find batch_key for current attribute.
+        # @return [Object] key (uid) of batch loaded object
+        def key
+          @batch_key ||= begin
+            key = opts[:key]
+
+            if key.is_a?(Symbol)
+              proc do |object|
+                handle_no_method_error { object.public_send(key) }
+              end
+            else
+              key
+            end
+          end
+        end
+
+        # Returns default value to use if batch loader does not return value for some key
+        # @return [Object] default value for missing key
+        def default_value
+          if opts.key?(:default)
+            opts[:default]
+          elsif many
+            FROZEN_EMPTY_ARRAY
+          end
+        end
+
+        private
+
+        def handle_no_method_error
+          yield
+        rescue NoMethodError => error
+          raise error, "NoMethodError when serializing '#{attribute.name}' attribute in #{attribute.class.serializer_class}\n\n#{error.message}", error.backtrace
+        end
+      end
+    end
+  end
+end

data/lib/serega/plugins/batch/lib/plugins_extensions/activerecord_preloads.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    module Batch
+      #
+      # Extensions (mini-plugins) that are enabled when :batch plugin used with other plugins
+      #
+      module PluginsExtensions
+        #
+        # Extension that is used when :batch plugin used with :active_record_preloads plugin
+        #
+        module ActiveRecordPreloads
+          #
+          # BatchLoader additional/patched instance methods
+          #
+          # @see Serega::SeregaPlugins::Batch::SeregaBatchLoader
+          #
+          module BatchLoaderInstanceMethods
+            private
+
+            # Preloads required associations to batch-loaded records
+            def keys_values(*)
+              data = super
+
+              if point.has_nested_points?
+                associations = point.preloads
+                return data if associations.empty?
+
+                records = data.values
+                records.flatten!(1)
+
+                ActiverecordPreloads::Preloader.preload(records, associations)
+              end
+
+              data
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/serega/plugins/batch/lib/plugins_extensions/formatters.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    module Batch
+      #
+      # Extensions (mini-plugins) that are enabled when :batch plugin used with other plugins
+      #
+      module PluginsExtensions
+        #
+        # Extension that is used when batch plugin used with :formatters plugin
+        #
+        module Formatters
+          #
+          # BatchLoader additional/patched instance methods
+          #
+          # @see Serega::SeregaPlugins::Batch::SeregaBatchLoader
+          #
+          module BatchLoaderInstanceMethods
+            private
+
+            # Format values after they are prepared
+            def keys_values(*)
+              data = super
+
+              formatter = point.attribute.formatter
+              data.transform_values! { |value| formatter.call(value) } if formatter
+
+              data
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/serega/plugins/batch/lib/plugins_extensions/preloads.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    module Batch
+      #
+      # Extensions (mini-plugins) that are enabled when :batch plugin used with other plugins
+      #
+      module PluginsExtensions
+        #
+        # Extension that is used when :preloads plugin is loaded
+        #
+        module Preloads
+          #
+          # Attribute additional/patched instance methods
+          #
+          # @see Serega::SeregaPlugins::Preloads::AttributeInstanceMethods
+          #
+          module AttributeInstanceMethods
+            private
+
+            # Do not add any preloads automatically when batch option provided
+            def get_preloads
+              return if batch && !opts.key?(:preload)
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/serega/validations/check_initiate_params.rb

@@ -39,9 +39,7 @@ class Serega
         end
 
         def check_modifiers
-          Initiate::CheckModifiers.call(serializer_class, opts[:only])
-          Initiate::CheckModifiers.call(serializer_class, opts[:except])
-          Initiate::CheckModifiers.call(serializer_class, opts[:with])
+          Initiate::CheckModifiers.new.call(serializer_class, opts[:only], opts[:with], opts[:except])
         end
 
         def serializer_class

data/lib/serega/validations/initiate/check_modifiers.rb

@@ -10,55 +10,72 @@ class Serega
       # Modifiers validation
       #
       class CheckModifiers
-        class << self
-          # Validates provided fields names are existing attributes
-          #
-          # @param serializer_class [Serega]
-          # @param fields [Hash] validated fields
-          #
-          # @raise [Serega::AttributeNotExist] when modifier not exist as attribute
-          #
-          # @return [void]
-          #
-          def call(serializer_class, fields)
-            return unless fields
+        #
+        # Validates provided fields names are existing attributes
+        #
+        # @param serializer_class [Serega]
+        # @param only [Hash, nil] `only` modifier
+        # @param with [Hash, nil] `with` modifier
+        # @param except [Hash, nil] `except` modifier
+        #
+        # @raise [Serega::AttributeNotExist] when some checked modifier has not existing attribute
+        #
+        # @return [void]
+        #
+        def call(serializer_class, only, with, except)
+          validate(serializer_class, only) if only
+          validate(serializer_class, with) if with
+          validate(serializer_class, except) if except
 
-            validate(serializer_class, fields, [])
-          end
+          raise_errors if any_error?
+        end
 
-          private
+        private
 
-          def validate(serializer_class, fields, prev_names)
-            fields.each do |name, nested_fields|
-              attribute = serializer_class.attributes[name]
+        def validate(serializer_class, fields)
+          fields.each do |name, nested_fields|
+            attribute = serializer_class && serializer_class.attributes[name]
+
+            # Save error when no attribute with checked name exists
+            unless attribute
+              save_error(name)
+              next
+            end
 
-              raise_error(name, prev_names) unless attribute
-              next if nested_fields.empty?
+            # Return when attribute has no nested fields
+            next if nested_fields.empty?
 
-              raise_nested_error(name, prev_names, nested_fields) unless attribute.relation?
-              nested_serializer = attribute.serializer
-              validate(nested_serializer, nested_fields, prev_names + [name])
+            with_parent_name(name) do
+              validate(attribute.serializer, nested_fields)
             end
           end
+        end
 
-          def raise_error(name, prev_names)
-            field_name = field_name(name, prev_names)
+        def parents_names
+          @parents_names ||= []
+        end
 
-            raise Serega::AttributeNotExist, "Attribute #{field_name} not exists"
-          end
+        def with_parent_name(name)
+          parents_names << name
+          yield
+          parents_names.pop
+        end
 
-          def raise_nested_error(name, prev_names, nested_fields)
-            field_name = field_name(name, prev_names)
-            first_nested = nested_fields.keys.first
+        def error_attributes
+          @error_attributes ||= []
+        end
 
-            raise Serega::AttributeNotExist, "Attribute #{field_name} has no :serializer option specified to add nested '#{first_nested}' attribute"
-          end
+        def save_error(name)
+          full_attribute_name = [*parents_names, name].join(".")
+          error_attributes << full_attribute_name
+        end
 
-          def field_name(name, prev_names)
-            res = "'#{name}'"
-            res += " ('#{prev_names.join(".")}.#{name}')" if prev_names.any?
-            res
-          end
+        def raise_errors
+          raise Serega::AttributeNotExist, "Not existing attributes: #{error_attributes.join(", ")}"
+        end
+
+        def any_error?
+          defined?(@error_attributes)
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: serega
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.2
 platform: ruby
 authors:
 - Andrey Glushkov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-12-08 00:00:00.000000000 Z
+date: 2022-12-20 00:00:00.000000000 Z
 dependencies: []
 description: |
   JSON Serializer
@@ -42,9 +42,12 @@ files:
 - lib/serega/plugins/activerecord_preloads/activerecord_preloads.rb
 - lib/serega/plugins/activerecord_preloads/lib/preloader.rb
 - lib/serega/plugins/batch/batch.rb
+- lib/serega/plugins/batch/lib/batch_option_model.rb
 - lib/serega/plugins/batch/lib/loader.rb
 - lib/serega/plugins/batch/lib/loaders.rb
-- lib/serega/plugins/batch/lib/plugins_extensions.rb
+- lib/serega/plugins/batch/lib/plugins_extensions/activerecord_preloads.rb
+- lib/serega/plugins/batch/lib/plugins_extensions/formatters.rb
+- lib/serega/plugins/batch/lib/plugins_extensions/preloads.rb
 - lib/serega/plugins/batch/lib/validations/check_batch_opt_key.rb
 - lib/serega/plugins/batch/lib/validations/check_batch_opt_loader.rb
 - lib/serega/plugins/batch/lib/validations/check_opt_batch.rb
@@ -93,8 +96,8 @@ homepage: https://github.com/aglushkov/serega
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/aglushkov/serega
   source_code_uri: https://github.com/aglushkov/serega
+  documentation_uri: https://www.rubydoc.info/gems/serega
   changelog_uri: https://github.com/aglushkov/serega/blob/master/CHANGELOG.md
 post_install_message: 
 rdoc_options: []

data/lib/serega/plugins/batch/lib/plugins_extensions.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Batch
-      # Extensions (mini-plugins) that are enabled when Batch plugin used with other plugins
-      module PluginsExtensions
-        #
-        # Extension that is used when batch plugin used with :active_record_preloads plugin
-        #
-        module ActiveRecordPreloads
-          #
-          # BatchLoader additional/patched instance methods
-          #
-          # @see Serega::SeregaPlugins::Batch::SeregaBatchLoader
-          #
-          module BatchLoaderInstanceMethods
-            private
-
-            # Preloads required associations to batch-loaded records
-            def keys_values(*)
-              data = super
-
-              if point.has_nested_points?
-                associations = point.preloads
-                return data if associations.empty?
-
-                ActiverecordPreloads::Preloader.preload(data.values.flatten(1), associations)
-              end
-
-              data
-            end
-          end
-        end
-
-        #
-        # Extension that is used when batch plugin used with :formatters plugin
-        #
-        module Formatters
-          #
-          # BatchLoader additional/patched instance methods
-          #
-          # @see Serega::SeregaPlugins::Batch::SeregaBatchLoader
-          #
-          module BatchLoaderInstanceMethods
-            private
-
-            # Format values after they are prepared
-            def keys_values(*)
-              data = super
-
-              formatter = point.attribute.formatter
-              data.transform_values! { |value| formatter.call(value) } if formatter
-
-              data
-            end
-          end
-        end
-      end
-    end
-  end
-end