serega 0.1.0

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class Serega
+  class Attribute
+    class CheckName
+      FORMAT_ONE_CHAR = /\A[a-zA-Z0-9]\z/
+      FORMAT_MANY_CHARS = /\A[a-zA-Z0-9][a-zA-Z0-9_-]*?[a-zA-Z0-9]\z/ # allow '-' and '_' in the middle
+
+      private_constant :FORMAT_ONE_CHAR, :FORMAT_MANY_CHARS
+
+      class << self
+        #
+        # Checks allowed characters.
+        # Globally allowed characters: "a-z", "A-Z", "0-9".
+        # Minus and low line "-", "_" also allowed except as the first or last character.
+        #
+        # @param name [String, Symbol] Attribute name
+        #
+        # @raise [Error] when name has invalid format
+        # @return [void]
+        #
+        def call(name)
+          name = name.to_s
+
+          valid =
+            case name.size
+            when 0 then false
+            when 1 then name.match?(FORMAT_ONE_CHAR)
+            else name.match?(FORMAT_MANY_CHARS)
+            end
+
+          return if valid
+
+          raise Error, message(name)
+        end
+
+        private
+
+        def message(name)
+          %(Invalid attribute name = #{name.inspect}. Globally allowed characters: "a-z", "A-Z", "0-9". Minus and low line "-", "_" also allowed except as the first or last character)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Serega
+  class Attribute
+    class CheckOptHide
+      #
+      # Checks attribute :hide option
+      #
+      # @param opts [Hash] Attribute options
+      #
+      # @raise [Error] Error that option has invalid value
+      #
+      # @return [void]
+      #
+      def self.call(opts)
+        CheckOptIsBool.call(opts, :hide)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Serega
+  class Attribute
+    class CheckOptMany
+      #
+      # Checks attribute :many option
+      #
+      # @param opts [Hash] Attribute options
+      #
+      # @raise [Error] Error that option has invalid value
+      #
+      # @return [void]
+      #
+      def self.call(opts)
+        CheckOptIsBool.call(opts, :many)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Serega
+  class Attribute
+    class CheckOptMethod
+      #
+      # Checks attribute :method option
+      #
+      # @param opts [Hash] Attribute options
+      #
+      # @raise [Error] Error that option has invalid value
+      #
+      # @return [void]
+      #
+      def self.call(opts)
+        return unless opts.key?(:method)
+
+        value = opts[:method]
+        return if value.is_a?(String) || value.is_a?(Symbol)
+
+        raise Error, "Invalid option :method => #{value.inspect}. Must be a String or a Symbol"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Serega
+  class Attribute
+    class CheckOptSerializer
+      class << self
+        #
+        # Checks attribute :serializer option
+        #
+        # @param opts [Hash] Attribute options
+        #
+        # @raise [Error] Error that option has invalid value
+        #
+        # @return [void]
+        #
+        def call(opts)
+          return unless opts.key?(:serializer)
+
+          value = opts[:serializer]
+          return if valid_serializer?(value)
+
+          raise Error, "Invalid option :serializer => #{value.inspect}." \
+            " Can be a Serega subclass, a String or a Proc without arguments"
+        end
+
+        private
+
+        def valid_serializer?(value)
+          value.is_a?(String) ||
+            (value.is_a?(Proc) && (value.parameters.count == 0)) ||
+            (value.is_a?(Class) && (value < Serega))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Serega
+  class Attribute
+    class CheckOpts
+      module ClassMethods
+        #
+        # Validates attribute options
+        # Checks used options are allowed and then checks options values.
+        #
+        # @param opts [Hash] Attribute options
+        # @param attribute_keys [Array<Symbol>] Allowed options keys
+        #
+        # @raise [Error] when attribute has invalid options
+        #
+        # @return [void]
+        #
+        def call(opts, attribute_keys)
+          CheckAllowedKeys.call(opts, attribute_keys)
+          check_each_opt(opts)
+        end
+
+        private
+
+        def check_each_opt(opts)
+          CheckOptHide.call(opts)
+          CheckOptMethod.call(opts)
+          CheckOptMany.call(opts)
+          CheckOptSerializer.call(opts)
+        end
+      end
+
+      extend ClassMethods
+    end
+  end
+end

data/lib/serega/validations/check_allowed_keys.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Serega
+  class CheckAllowedKeys
+    def self.call(opts, allowed_keys)
+      opts.each_key do |key|
+        next if allowed_keys.include?(key)
+
+        raise Error, "Invalid option #{key.inspect}. Allowed options are: #{allowed_keys.map(&:inspect).join(", ")}"
+      end
+    end
+  end
+end

data/lib/serega/validations/check_opt_is_bool.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Serega
+  class CheckOptIsBool
+    def self.call(opts, key)
+      return unless opts.key?(key)
+
+      value = opts[key]
+      return if value.equal?(true) || value.equal?(false)
+
+      raise Error, "Invalid option #{key.inspect} => #{value.inspect}. Must have a boolean value"
+    end
+  end
+end

data/lib/serega/validations/check_opt_is_hash.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Serega
+  class CheckOptIsHash
+    def self.call(opts, key)
+      return unless opts.key?(key)
+
+      value = opts[key]
+      return if value.is_a?(Hash)
+
+      raise Error, "Invalid option #{key.inspect} => #{value.inspect}. Must have a Hash value"
+    end
+  end
+end

data/lib/serega/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Serega
+  VERSION = File.read(File.join(File.dirname(__FILE__), "../../VERSION")).strip
+end

data/lib/serega.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require_relative "serega/version"
+
+# Parent class for your serializers
+class Serega
+  # A generic exception Serega uses.
+  class Error < StandardError; end
+
+  # @return [Hash] frozen hash
+  FROZEN_EMPTY_HASH = {}.freeze
+
+  # @return [Array] frozen array
+  FROZEN_EMPTY_ARRAY = [].freeze
+end
+
+require_relative "serega/helpers/serializer_class_helper"
+require_relative "serega/utils/enum_deep_dup"
+require_relative "serega/utils/to_hash"
+require_relative "serega/utils/to_json"
+require_relative "serega/utils/as_json"
+
+require_relative "serega/attribute"
+require_relative "serega/validations/check_allowed_keys"
+require_relative "serega/validations/check_opt_is_bool"
+require_relative "serega/validations/check_opt_is_hash"
+require_relative "serega/validations/attribute/check_block"
+require_relative "serega/validations/attribute/check_name"
+require_relative "serega/validations/attribute/check_opt_hide"
+require_relative "serega/validations/attribute/check_opt_method"
+require_relative "serega/validations/attribute/check_opt_many"
+require_relative "serega/validations/attribute/check_opt_serializer"
+require_relative "serega/validations/attribute/check_opts"
+
+require_relative "serega/config"
+require_relative "serega/convert"
+require_relative "serega/convert_item"
+require_relative "serega/map"
+require_relative "serega/plugins"
+
+class Serega
+  @config = Config.new(
+    {
+      plugins: [],
+      initiate_keys: %i[only with except],
+      attribute_keys: %i[key value serializer many hide],
+      serialize_keys: %i[context many],
+      max_cached_map_per_serializer_count: 50,
+      to_json: ->(data) { Utils::ToJSON.call(data) }
+    }
+  )
+
+  # Core serializer class methods
+  module ClassMethods
+    # @return [Config] current serializer config
+    attr_reader :config
+
+    private def inherited(subclass)
+      config_class = Class.new(self::Config)
+      config_class.serializer_class = subclass
+      subclass.const_set(:Config, config_class)
+      subclass.instance_variable_set(:@config, subclass::Config.new(config.opts))
+
+      attribute_class = Class.new(self::Attribute)
+      attribute_class.serializer_class = subclass
+      subclass.const_set(:Attribute, attribute_class)
+
+      map_class = Class.new(self::Map)
+      map_class.serializer_class = subclass
+      subclass.const_set(:Map, map_class)
+
+      convert_class = Class.new(self::Convert)
+      convert_class.serializer_class = subclass
+      subclass.const_set(:Convert, convert_class)
+
+      convert_item_class = Class.new(self::ConvertItem)
+      convert_item_class.serializer_class = subclass
+      subclass.const_set(:ConvertItem, convert_item_class)
+
+      # Assign same attributes
+      attributes.each_value do |attr|
+        subclass.attribute(attr.name, **attr.opts, &attr.block)
+      end
+
+      super
+    end
+
+    #
+    # Enables plugin for current serializer
+    #
+    # @param name [Symbol, Class<Module>] Plugin name or plugin module itself
+    # @param opts [Hash>] Plugin options
+    #
+    # @return [class<Module>] Loaded plugin module
+    #
+    def plugin(name, **opts)
+      raise Error, "This plugin is already loaded" if plugin_used?(name)
+
+      plugin = Plugins.find_plugin(name)
+
+      # We split loading of plugin to three parts - before_load, load, after_load:
+      #
+      # - **before_load_plugin** usually used to check requirements and to load additional plugins
+      # - **load_plugin** usually used to include plugin modules
+      # - **after_load_plugin** usually used to add config options
+      plugin.before_load_plugin(self, **opts) if plugin.respond_to?(:before_load_plugin)
+      plugin.load_plugin(self, **opts) if plugin.respond_to?(:load_plugin)
+      plugin.after_load_plugin(self, **opts) if plugin.respond_to?(:after_load_plugin)
+
+      # Store attached plugins, so we can check it is loaded later
+      config[:plugins] << (plugin.respond_to?(:plugin_name) ? plugin.plugin_name : plugin)
+
+      plugin
+    end
+
+    #
+    # Checks plugin is used
+    #
+    # @param name [Symbol, Class<Module>] Plugin name or plugin module itself
+    #
+    # @return [Boolean]
+    #
+    def plugin_used?(name)
+      plugin_name =
+        case name
+        when Module then name.respond_to?(:plugin_name) ? name.plugin_name : name
+        else name
+        end
+
+      config[:plugins].include?(plugin_name)
+    end
+
+    #
+    # Lists attributes
+    #
+    # @return [Hash] attributes list
+    #
+    def attributes
+      @attributes ||= {}
+    end
+
+    #
+    # Adds attribute
+    #
+    # @param name [Symbol] Attribute name. Attribute value will be found by executing `object.<name>`
+    # @param opts [Hash] Options to serialize attribute
+    # @param block [Proc] Custom block to find attribute value. Accepts object and context.
+    #
+    # @return [Serega::Attribute] Added attribute
+    #
+    def attribute(name, **opts, &block)
+      attribute = self::Attribute.new(name: name, opts: opts, block: block)
+      attributes[attribute.name] = attribute
+    end
+
+    #
+    # Adds attribute with forced :serializer option
+    #
+    # @param name [Symbol] Attribute name. Attribute value will be found by executing `object.<name>`
+    # @param serializer [Serega, Proc] Specifies nested serializer for relationship
+    # @param opts [Hash] Options for attribute serialization
+    # @param block [Proc] Custom block to find attribute value. Accepts object and context.
+    #
+    # @return [Serega::Attribute] Added attribute
+    #
+    def relation(name, serializer:, **opts, &block)
+      attribute(name, serializer: serializer, **opts, &block)
+    end
+
+    def to_h(object, opts = FROZEN_EMPTY_HASH)
+      initiate_keys = config[:initiate_keys]
+      new(opts.slice(*initiate_keys)).to_h(object, opts.except(*initiate_keys))
+    end
+
+    def to_json(object, opts = FROZEN_EMPTY_HASH)
+      initiate_keys = config[:initiate_keys]
+      new(opts.slice(*initiate_keys)).to_json(object, opts.except(*initiate_keys))
+    end
+
+    def as_json(object, opts = FROZEN_EMPTY_HASH)
+      initiate_keys = config[:initiate_keys]
+      new(opts.slice(*initiate_keys)).as_json(object, opts.except(*initiate_keys))
+    end
+  end
+
+  #
+  # Core serializer instance methods
+  #
+  module InstanceMethods
+    attr_reader :opts
+
+    #
+    # Instantiates new Serega class
+    #
+    # @param only [Array, Hash, String, Symbol] The only attributes to serialize
+    # @param except [Array, Hash, String, Symbol] Attributes to hide
+    # @param with [Array, Hash, String, Symbol] Attributes (usually hidden) to serialize additionally
+    #
+    def initialize(opts = FROZEN_EMPTY_HASH)
+      CheckAllowedKeys.call(opts, self.class.config[:initiate_keys])
+      opts = prepare_modifiers(opts) if opts && (opts != FROZEN_EMPTY_HASH)
+      @opts = opts
+    end
+
+    #
+    # Serializes provided object to hash
+    #
+    # @param object [Object] Serialized object
+    # @param opts [Hash] Serialization options, like :context and :many
+    #
+    # @return [Hash] Serialization result
+    #
+    def to_h(object, opts = {})
+      CheckAllowedKeys.call(opts, self.class.config[:serialize_keys])
+      CheckOptIsHash.call(opts, :context)
+      CheckOptIsBool.call(opts, :many)
+      opts[:context] ||= {}
+
+      self.class::Convert.call(object, **opts, map: map)
+    end
+
+    #
+    # Serializes provided object to json
+    #
+    # @param object [Object] Serialized object
+    #
+    # @return [Hash] Serialization result
+    #
+    def to_json(object, opts = FROZEN_EMPTY_HASH)
+      hash = to_h(object, opts)
+      self.class.config[:to_json].call(hash)
+    end
+
+    #
+    # Serializes provided object as json (uses only JSON-compatible types)
+    # When you later serialize/deserialize it from JSON you should receive
+    # equal object
+    #
+    # @param object [Object] Serialized object
+    #
+    # @return [Hash] Serialization result
+    #
+    def as_json(object, opts = FROZEN_EMPTY_HASH)
+      hash = to_h(object, opts)
+      Utils::AsJSON.call(hash, to_json: self.class.config[:to_json])
+    end
+
+    private
+
+    def map
+      @map ||= self.class::Map.call(opts)
+    end
+
+    def prepare_modifiers(opts)
+      {
+        only: Utils::ToHash.call(opts[:only]),
+        except: Utils::ToHash.call(opts[:except]),
+        with: Utils::ToHash.call(opts[:with])
+      }
+    end
+  end
+
+  extend ClassMethods
+  include InstanceMethods
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: serega
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrey Glushkov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-07-08 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- aglushkov@shakuro.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- VERSION
+- lib/serega.rb
+- lib/serega/attribute.rb
+- lib/serega/config.rb
+- lib/serega/convert.rb
+- lib/serega/convert_item.rb
+- lib/serega/helpers/serializer_class_helper.rb
+- lib/serega/map.rb
+- lib/serega/plugins.rb
+- lib/serega/plugins/activerecord_preloads/activerecord_preloads.rb
+- lib/serega/plugins/activerecord_preloads/lib/preloader.rb
+- lib/serega/plugins/context_metadata/context_metadata.rb
+- lib/serega/plugins/formatters/formatters.rb
+- lib/serega/plugins/hide_nil/hide_nil.rb
+- lib/serega/plugins/metadata/meta_attribute.rb
+- lib/serega/plugins/metadata/metadata.rb
+- lib/serega/plugins/metadata/validations/check_block.rb
+- lib/serega/plugins/metadata/validations/check_opt_hide_empty.rb
+- lib/serega/plugins/metadata/validations/check_opt_hide_nil.rb
+- lib/serega/plugins/metadata/validations/check_opts.rb
+- lib/serega/plugins/metadata/validations/check_path.rb
+- lib/serega/plugins/preloads/lib/enum_deep_freeze.rb
+- lib/serega/plugins/preloads/lib/format_user_preloads.rb
+- lib/serega/plugins/preloads/lib/main_preload_path.rb
+- lib/serega/plugins/preloads/lib/preloads_constructor.rb
+- lib/serega/plugins/preloads/preloads.rb
+- lib/serega/plugins/preloads/validations/check_opt_preload_path.rb
+- lib/serega/plugins/presenter/presenter.rb
+- lib/serega/plugins/root/root.rb
+- lib/serega/plugins/string_modifiers/parse_string_modifiers.rb
+- lib/serega/plugins/string_modifiers/string_modifiers.rb
+- lib/serega/plugins/validate_modifiers/validate.rb
+- lib/serega/plugins/validate_modifiers/validate_modifiers.rb
+- lib/serega/utils/as_json.rb
+- lib/serega/utils/enum_deep_dup.rb
+- lib/serega/utils/to_hash.rb
+- lib/serega/utils/to_json.rb
+- lib/serega/validations/attribute/check_block.rb
+- lib/serega/validations/attribute/check_name.rb
+- lib/serega/validations/attribute/check_opt_hide.rb
+- lib/serega/validations/attribute/check_opt_many.rb
+- lib/serega/validations/attribute/check_opt_method.rb
+- lib/serega/validations/attribute/check_opt_serializer.rb
+- lib/serega/validations/attribute/check_opts.rb
+- lib/serega/validations/check_allowed_keys.rb
+- lib/serega/validations/check_opt_is_bool.rb
+- lib/serega/validations/check_opt_is_hash.rb
+- lib/serega/version.rb
+homepage: https://github.com/aglushkov/serega
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/aglushkov/serega
+  source_code_uri: https://github.com/aglushkov/serega
+  changelog_uri: https://github.com/aglushkov/serega/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.15
+signing_key: 
+specification_version: 4
+summary: Serializes objects to hash
+test_files: []