serega 0.1.0

data/lib/serega/plugins/preloads/validations/check_opt_preload_path.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class Serega
+  module Plugins
+    module Preloads
+      class CheckOptPreloadPath
+        class << self
+          def call(opts)
+            return unless opts.key?(:preload_path)
+
+            value = opts[:preload_path]
+            raise Error, "Invalid option :preload_path => #{value.inspect}. Can be provided only when :preload option provided" unless opts[:preload]
+            raise Error, "Invalid option :preload_path => #{value.inspect}. Can be provided only when :serializer option provided" unless opts[:serializer]
+
+            path = Array(value).map!(&:to_sym)
+            preloads = FormatUserPreloads.call(opts[:preload])
+            allowed_paths = paths(preloads)
+            raise Error, "Invalid option :preload_path => #{value.inspect}. Can be one of #{allowed_paths.inspect[1..-2]}" unless allowed_paths.include?(path)
+          end
+
+          private
+
+          def paths(preloads, path = [], result = [])
+            preloads.each do |key, nested_preloads|
+              path << key
+              result << path.dup
+
+              paths(nested_preloads, path, result)
+              path.pop
+            end
+
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/serega/plugins/presenter/presenter.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "delegate"
+require "forwardable"
+
+class Serega
+  module Plugins
+    #
+    # Plugin Presenter adds possibility to use declare Presenter for your objects inside serializer
+    #
+    #   class User < Serega
+    #     plugin :presenter
+    #
+    #     attribute :name
+    #
+    #     class Presenter
+    #       def name
+    #         [first_name, last_name].compact_blank.join(' ')
+    #       end
+    #     end
+    #   end
+    module Presenter
+      # @return [Symbol] plugin name
+      def self.plugin_name
+        :presenter
+      end
+
+      #
+      # Loads plugin
+      #
+      # @param serializer_class [Class<Serega>] Current serializer class
+      # @param _opts [Hash] Loaded plugins options
+      #
+      # @return [void]
+      #
+      def self.load_plugin(serializer_class, **_opts)
+        serializer_class.extend(ClassMethods)
+        serializer_class::ConvertItem.extend(ConvertItemClassMethods)
+      end
+
+      #
+      # Adds Presenter to current serializer
+      #
+      # @param serializer_class [Class<Serega>] Current serializer class
+      # @param _opts [Hash] Loaded plugins options
+      #
+      # @return [void]
+      #
+      def self.after_load_plugin(serializer_class, **_opts)
+        presenter_class = Class.new(Presenter)
+        presenter_class.serializer_class = serializer_class
+        serializer_class.const_set(:Presenter, presenter_class)
+      end
+
+      # Presenter class
+      class Presenter < SimpleDelegator
+        # Presenter instance methods
+        module InstanceMethods
+          #
+          # Delegates all missing methods to serialized object.
+          #
+          # Creates delegator method after first #method_missing hit to improve
+          # performance of following serializations.
+          #
+          def method_missing(name, *_args, &_block) # rubocop:disable Style/MissingRespondToMissing (base SimpleDelegator class has this method)
+            super.tap do
+              self.class.def_delegator :__getobj__, name
+            end
+          end
+        end
+
+        extend Helpers::SerializerClassHelper
+        extend Forwardable
+        include InstanceMethods
+      end
+
+      # Overrides class methods of included class
+      module ClassMethods
+        private def inherited(subclass)
+          super
+
+          presenter_class = Class.new(self::Presenter)
+          presenter_class.serializer_class = subclass
+          subclass.const_set(:Presenter, presenter_class)
+        end
+
+        # Overrides {Serega::ClassMethods#attribute} method, additionally adds method
+        # to Presenter to not hit {Serega::Plugins::Presenter::Presenter#method_missing}
+        # @see Serega::ClassMethods#attribute
+        def attribute(_name, **_opts, &_block)
+          super.tap do |attribute|
+            self::Presenter.def_delegator(:__getobj__, attribute.key) unless attribute.block
+          end
+        end
+      end
+
+      # Includes methods to override ConvertItem class
+      module ConvertItemClassMethods
+        #
+        # Replaces serialized object with Presenter.new(object)
+        #
+        def call(object, *)
+          object = serializer_class::Presenter.new(object)
+          super
+        end
+      end
+    end
+
+    register_plugin(Presenter.plugin_name, Presenter)
+  end
+end

data/lib/serega/plugins/root/root.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+class Serega
+  module Plugins
+    module Root
+      # @return [Symbol] Default response root key
+      ROOT_DEFAULT = :data
+
+      def self.plugin_name
+        :root
+      end
+
+      def self.load_plugin(serializer_class, **_opts)
+        serializer_class.extend(ClassMethods)
+        serializer_class::Convert.include(ConvertInstanceMethods)
+      end
+
+      def self.after_load_plugin(serializer_class, **opts)
+        serializer_class.root(opts[:root] || ROOT_DEFAULT, one: opts[:root_one], many: opts[:root_many])
+        serializer_class.config[:serialize_keys] << :root
+      end
+
+      module ClassMethods
+        #
+        # Configures response root key
+        #
+        # @param root [String, Symbol] Specifies common root when serializing one or multiple objects
+        # @param root_one [String, Symbol] Specifies root when serializing one object
+        # @param root_many [String, Symbol] Specifies root when serializing multiple objects
+        #
+        # @return [Hash] Configured root names
+        #
+        def root(root = nil, one: nil, many: nil)
+          one ||= root
+          many ||= root
+
+          one = one.to_sym if one
+          many = many.to_sym if many
+
+          config[:root] = {one: one, many: many}
+        end
+      end
+
+      module ConvertInstanceMethods
+        def to_h
+          hash = super
+          root = build_root(opts)
+          hash = {root => hash} if root
+          hash
+        end
+
+        private
+
+        def build_root(opts)
+          return opts[:root] if opts.key?(:root)
+
+          root_config = self.class.serializer_class.config[:root]
+          many? ? root_config[:many] : root_config[:one]
+        end
+      end
+    end
+
+    register_plugin(Root.plugin_name, Root)
+  end
+end

data/lib/serega/plugins/string_modifiers/parse_string_modifiers.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class Serega
+  module Plugins
+    module StringModifiers
+      class ParseStringModifiers
+        COMMA = ","
+        OPEN_BRACKET = "("
+        CLOSE_BRACKET = ")"
+
+        def self.call(fields)
+          return fields unless fields.is_a?(String)
+
+          new.parse(fields)
+        end
+
+        # user => { user: {} }
+        # user(id) => { user: { id: {} } }
+        # user(id,name) => { user: { id: {}, name: {} } }
+        # user,comments => { user: {}, comments: {} }
+        # user(comments(text)) => { user: { comments: { text: {} } } }
+        def parse(fields)
+          res = {}
+          attribute = +""
+          path_stack = nil
+
+          fields.each_char do |char|
+            case char
+            when COMMA
+              add_attribute(res, path_stack, attribute, FROZEN_EMPTY_HASH)
+            when CLOSE_BRACKET
+              add_attribute(res, path_stack, attribute, FROZEN_EMPTY_HASH)
+              path_stack&.pop
+            when OPEN_BRACKET
+              name = add_attribute(res, path_stack, attribute, {})
+              (path_stack ||= []).push(name) if name
+            else
+              attribute.insert(-1, char)
+            end
+          end
+
+          add_attribute(res, path_stack, attribute, FROZEN_EMPTY_HASH)
+
+          res
+        end
+
+        private
+
+        def add_attribute(res, path_stack, attribute, nested_attributes = FROZEN_EMPTY_HASH)
+          attribute.strip!
+          return if attribute.empty?
+
+          name = attribute.to_sym
+          attribute.clear
+
+          current_attrs = !path_stack || path_stack.empty? ? res : res.dig(*path_stack)
+          current_attrs[name] = nested_attributes
+
+          name
+        end
+      end
+    end
+  end
+end

data/lib/serega/plugins/string_modifiers/string_modifiers.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class Serega
+  module Plugins
+    module StringModifiers
+      def self.plugin_name
+        :string_modifiers
+      end
+
+      def self.load_plugin(serializer_class, **_opts)
+        serializer_class.include(InstanceMethods)
+        require_relative "./parse_string_modifiers"
+      end
+
+      module InstanceMethods
+        private
+
+        def prepare_modifiers(opts)
+          opts = {
+            only: ParseStringModifiers.call(opts[:only]),
+            except: ParseStringModifiers.call(opts[:except]),
+            with: ParseStringModifiers.call(opts[:with])
+          }
+
+          super
+        end
+      end
+    end
+
+    register_plugin(StringModifiers.plugin_name, StringModifiers)
+  end
+end

data/lib/serega/plugins/validate_modifiers/validate.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class Serega
+  module Plugins
+    module ValidateModifiers
+      class Validate
+        class << self
+          def call(serializer_class, fields)
+            return unless fields
+
+            validate(serializer_class, fields, [])
+          end
+
+          private
+
+          def validate(serializer_class, fields, prev_names)
+            fields.each do |name, nested_fields|
+              attribute = serializer_class.attributes[name]
+
+              raise_error(name, prev_names) unless attribute
+              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])
+            end
+          end
+
+          def raise_error(name, prev_names)
+            field_name = field_name(name, prev_names)
+
+            raise Serega::Error, "Attribute #{field_name} not exists"
+          end
+
+          def raise_nested_error(name, prev_names, nested_fields)
+            field_name = field_name(name, prev_names)
+            first_nested = nested_fields.keys.first
+
+            raise Serega::Error, "Attribute #{field_name} is not a relation to add '#{first_nested}' attribute"
+          end
+
+          def field_name(name, prev_names)
+            res = "'#{name}'"
+            res += " ('#{prev_names.join(".")}.#{name}')" if prev_names.any?
+            res
+          end
+        end
+      end
+    end
+  end
+end

data/lib/serega/plugins/validate_modifiers/validate_modifiers.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class Serega
+  module Plugins
+    module ValidateModifiers
+      def self.plugin_name
+        :validate_modifiers
+      end
+
+      def self.load_plugin(serializer_class, **_opts)
+        serializer_class.include(InstanceMethods)
+        require_relative "./validate"
+      end
+
+      def self.after_load_plugin(serializer_class, **opts)
+        serializer_class.config[:validate_modifiers] = {auto: opts.fetch(:auto, true)}
+      end
+
+      module InstanceMethods
+        # Raises error if some modifiers are invalid
+        def validate_modifiers
+          @modifiers_validated ||= begin
+            Validate.call(self.class, opts[:only])
+            Validate.call(self.class, opts[:except])
+            Validate.call(self.class, opts[:with])
+            true
+          end
+        end
+
+        private
+
+        def initialize(opts)
+          super
+          validate_modifiers if self.class.config[:validate_modifiers][:auto]
+        end
+      end
+
+      module InstanceMethods
+      end
+    end
+
+    register_plugin(ValidateModifiers.plugin_name, ValidateModifiers)
+  end
+end

data/lib/serega/plugins.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class Serega
+  # Module in which all Serega plugins should be stored
+  module Plugins
+    @plugins = {}
+
+    class << self
+      #
+      # Registers given plugin to be able to load it using symbol name.
+      #
+      # @example Register plugin
+      #   Serega::Plugins.register_plugin(:plugin_name, PluginModule)
+      def register_plugin(name, mod)
+        @plugins[name] = mod
+      end
+
+      #
+      # Loads plugin code and returns plugin core module.
+      #
+      # @param name [Symbol, Module] plugin name or plugin itself
+      #
+      # @raise [Error] Raises Error when plugin was not found
+      #
+      # @example Find plugin when providing name
+      #   Serega::Plugins.find_plugin(:presenter) # => Serega::Plugins::Presenter
+      #
+      # @example Find plugin when providing plugin itself
+      #   Serega::Plugins.find_plugin(Presenter) # => Presenter
+      #
+      # @return [Class<Module>] Plugin core module
+      #
+      def find_plugin(name)
+        return name if name.is_a?(Module)
+        return @plugins[name] if @plugins.key?(name)
+
+        require_plugin(name)
+
+        @plugins[name] || raise(Error, "Plugin '#{name}' did not register itself correctly")
+      end
+
+      private
+
+      def require_plugin(name)
+        require "serega/plugins/#{name}/#{name}"
+      rescue LoadError
+        raise Error, "Plugin '#{name}' does not exist"
+      end
+    end
+  end
+end

data/lib/serega/utils/as_json.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class Serega
+  module Utils
+    class AsJSON
+      DOUBLE_QUOTE = '"'
+
+      class << self
+        def call(data, to_json:)
+          case data
+          when Hash
+            data.each_with_object({}) do |(key, value), new_data|
+              new_key = key.to_s
+              new_value = call(value, to_json: to_json)
+              new_data[new_key] = new_value
+            end
+          when Array
+            data.map { |value| call(value, to_json: to_json) }
+          when NilClass, Integer, Float, String, TrueClass, FalseClass
+            data
+          when Symbol
+            data.to_s
+          else
+            res = to_json.call(data)
+            if res.start_with?(DOUBLE_QUOTE) && res.end_with?(DOUBLE_QUOTE)
+              res.delete_prefix!(DOUBLE_QUOTE)
+              res.delete_suffix!(DOUBLE_QUOTE)
+            end
+            res
+          end
+        end
+      end
+    end
+  end
+end

data/lib/serega/utils/enum_deep_dup.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class Serega
+  module Utils
+    # Duplicates nested hashes and arrays
+    class EnumDeepDup
+      DUP = {
+        Hash => ->(data) { dup_hash_values(data) },
+        Array => ->(data) { dup_array_values(data) }
+      }.freeze
+      private_constant :DUP
+
+      class << self
+        #
+        # Deeply duplicate provided data
+        #
+        # @param data [Hash, Array] Data to duplicate
+        #
+        # @return [Hash, Array] Duplicated data
+        #
+        def call(data)
+          duplicate_data = data.dup
+          DUP.fetch(duplicate_data.class).call(duplicate_data)
+          duplicate_data
+        end
+
+        private
+
+        def dup_hash_values(duplicate_data)
+          duplicate_data.each do |key, value|
+            duplicate_data[key] = call(value) if value.is_a?(Enumerable)
+          end
+        end
+
+        def dup_array_values(duplicate_data)
+          duplicate_data.each_with_index do |value, index|
+            duplicate_data[index] = call(value) if value.is_a?(Enumerable)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/serega/utils/to_hash.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+class Serega
+  module Utils
+    class ToHash
+      module ClassMethods
+        def call(value)
+          case value
+          when Array then array_to_hash(value)
+          when Hash then hash_to_hash(value)
+          when NilClass, FalseClass then nil_to_hash(value)
+          when String then string_to_hash(value)
+          when Symbol then symbol_to_hash(value)
+          else raise Error, "Cant convert #{value.class} class object to hash"
+          end
+        end
+
+        private
+
+        def array_to_hash(values)
+          return Serega::FROZEN_EMPTY_HASH if values.empty?
+
+          values.each_with_object({}) do |value, obj|
+            obj.merge!(call(value))
+          end
+        end
+
+        def hash_to_hash(values)
+          return Serega::FROZEN_EMPTY_HASH if values.empty?
+
+          values.each_with_object({}) do |(key, value), obj|
+            obj[key.to_sym] = call(value)
+          end
+        end
+
+        def nil_to_hash(_value)
+          Serega::FROZEN_EMPTY_HASH
+        end
+
+        def string_to_hash(value)
+          symbol_to_hash(value.to_sym)
+        end
+
+        def symbol_to_hash(value)
+          {value => Serega::FROZEN_EMPTY_HASH}
+        end
+      end
+
+      extend ClassMethods
+    end
+  end
+end

data/lib/serega/utils/to_json.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Serega
+  module Utils
+    class ToJSON
+      class << self
+        def call(data)
+          json_adapter.dump(data)
+        end
+
+        private
+
+        def json_adapter
+          @json_adapter ||= begin
+            require "json"
+            ::JSON
+          end
+        end
+      end
+    end
+  end
+end

data/lib/serega/validations/attribute/check_block.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+class Serega
+  class Attribute
+    class CheckBlock
+      class << self
+        #
+        # Checks :value option or a block provided with attribute
+        # Must have up to two arguments - object and context.
+        # It should not have any *rest or **key arguments
+        #
+        # @example without arguments
+        #   attribute(:email) { CONSTANT_EMAIL }
+        #
+        # @example with one argument
+        #   attribute(:email) { |obj| obj.confirmed_email }
+        #
+        # @example with two arguments
+        #   attribute(:email) { |obj, context| context['is_current'] ? obj.email : nil }
+        #
+        # @param opts [Proc] Attribute opts, we will check :value option
+        # @param block [Proc] Block that returns serialized attribute value
+        #
+        # @raise [Error] Error that block has invalid arguments
+        #
+        # @return [void]
+        #
+        def call(opts, block)
+          check_both_provided(opts, block)
+
+          if block
+            check_block(block)
+          elsif opts.key?(:value)
+            check_value(opts[:value])
+          end
+        end
+
+        private
+
+        def check_both_provided(opts, block)
+          if opts.key?(:value) && block
+            raise Error, both_error
+          end
+        end
+
+        def check_block(block)
+          params = block.parameters
+          return if (params.count <= 2) && params.all? { |par| par[0] == :opt }
+
+          raise Error, block_error
+        end
+
+        def check_value(value)
+          raise Error, value_error unless value.is_a?(Proc)
+
+          params = value.parameters
+
+          if value.lambda?
+            return if (params.count == 2) && params.all? { |par| par[0] == :req }
+          elsif (params.count <= 2) && params.all? { |par| par[0] == :opt }
+            return
+          end
+
+          raise Error, value_error
+        end
+
+        def block_error
+          "Block can have maximum two regular parameters (no **keyword or *array args)"
+        end
+
+        def value_error
+          "Option :value must be a Proc that is able to accept two parameters (no **keyword or *array args)"
+        end
+
+        def both_error
+          "Block and a :value option can not be provided together"
+        end
+      end
+    end
+  end
+end