serega 0.10.0 → 0.11.0

data/lib/serega/map.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  #
-  # Constructs map of attributes that should be serialized.
-  # We will traverse this map to construct serialized response.
-  #
-  class SeregaMap
-    #
-    # SeregaMap class methods
-    #
-    module ClassMethods
-      #
-      # Constructs map of attributes that should be serialized.
-      #
-      # @param opts Serialization parameters
-      # @option opts [Hash] :only The only attributes to serialize
-      # @option opts [Hash] :except Attributes to hide
-      # @option opts [Hash] :with Attributes (usually hidden) to serialize additionally
-      #
-      # @return [Array<Serega::SeregaMapPoint>] map
-      #
-      def call(opts)
-        max_cache_size = serializer_class.config.max_cached_map_per_serializer_count
-        return map_for(opts) if max_cache_size.zero?
-
-        cached_map_for(opts, max_cache_size)
-      end
-
-      private
-
-      def map_for(opts)
-        construct_map(serializer_class, **modifiers(opts))
-      end
-
-      def cached_map_for(opts, max_cache_size)
-        @cache ||= {}
-        cache_key = construct_cache_key(opts)
-
-        map = @cache[cache_key] ||= map_for(opts)
-        @cache.shift if @cache.length > max_cache_size
-        map
-      end
-
-      def modifiers(opts)
-        {
-          only: opts[:only] || FROZEN_EMPTY_HASH,
-          except: opts[:except] || FROZEN_EMPTY_HASH,
-          with: opts[:with] || FROZEN_EMPTY_HASH
-        }
-      end
-
-      def construct_map(serializer_class, only:, except:, with:)
-        map = []
-        serializer_class.attributes.each do |name, attribute|
-          next unless attribute.visible?(only: only, except: except, with: with)
-
-          nested_points =
-            if attribute.relation?
-              construct_map(
-                attribute.serializer,
-                only: only[name] || FROZEN_EMPTY_HASH,
-                with: with[name] || FROZEN_EMPTY_HASH,
-                except: except[name] || FROZEN_EMPTY_HASH
-              )
-            end
-
-          map << serializer_class::SeregaMapPoint.new(attribute, nested_points)
-        end
-        map
-      end
-
-      def construct_cache_key(opts, cache_key = nil)
-        return nil if opts.empty?
-
-        cache_key ||= +""
-
-        opts.each do |key, nested_opts|
-          cache_key.insert(-1, SeregaUtils::SymbolName.call(key))
-          cache_key.insert(-1, "-")
-          construct_cache_key(nested_opts, cache_key)
-        end
-
-        cache_key
-      end
-    end
-
-    extend ClassMethods
-    extend Serega::SeregaHelpers::SerializerClassHelper
-  end
-end

data/lib/serega/map_point.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  #
-  # Combines attribute and nested attributes
-  #
-  class SeregaMapPoint
-    #
-    # SeregaMapPoint instance methods
-    #
-    module InstanceMethods
-      extend Forwardable
-
-      # Shows current attribute
-      # @return [Serega::SeregaAttribute] Current attribute
-      attr_reader :attribute
-
-      # Shows nested points
-      # @return [NilClass, Array<Serega::SeregaMapPoint>] Nested points or nil
-      attr_reader :nested_points
-
-      # @!method name
-      #   Attribute `name`
-      #   @see Serega::SeregaAttribute::AttributeInstanceMethods#name
-      # @!method value
-      #   Attribute `value` block
-      #   @see Serega::SeregaAttribute::AttributeInstanceMethods#value
-      # @!method many
-      #   Attribute `many` option
-      #   @see Serega::SeregaAttribute::AttributeInstanceMethods#many
-      def_delegators :@attribute, :name, :value, :many
-
-      #
-      # Initializes map point
-      #
-      # @param attribute [Serega::SeregaAttribute] Attribute to construct map point
-      # @param nested_points [NilClass, Array<Serega::SeregaMapPoint>] Nested map points for provided attribute
-      #
-      # @return [Serega::SeregaMapPoint] New map point
-      #
-      def initialize(attribute, nested_points)
-        @attribute = attribute
-        @nested_points = nested_points
-      end
-
-      #
-      # Checks if attribute has nested points (is a link to another serializer)
-      #
-      # @return [Boolean] whether attribute has nested points
-      #
-      def has_nested_points?
-        !nested_points.nil?
-      end
-
-      #
-      # @return [Serega::SeregaObjectSerializer] object serializer for nested points
-      #
-      def nested_object_serializer
-        attribute.serializer::SeregaObjectSerializer
-      end
-    end
-
-    extend Serega::SeregaHelpers::SerializerClassHelper
-    include InstanceMethods
-  end
-end

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

@@ -1,73 +0,0 @@
-# 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/preloads/lib/enum_deep_freeze.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Preloads
-      #
-      # Utility to freeze nested hashes and arrays
-      #
-      class EnumDeepFreeze
-        class << self
-          #
-          # Freezes nested enumerable data
-          #
-          # @param data[Hash, Array] data to freeze
-          #
-          # @return [Hash, Array] same deeply frozen data
-          #
-          def call(data)
-            data.each_entry { |entry| call(entry) } if data.is_a?(Enumerable)
-            data.freeze
-          end
-        end
-      end
-    end
-  end
-end