protobuf-mongoid 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1dc8ea63ac8607eb6435e75b8638ff4cf5735c8a0f4d2fdd6df9d72cf2c78c4b
+  data.tar.gz: d6769b7aeaf095e6aa1b68444feea2c073e528b588f64dfc42a7cd2b57c14db2
+SHA512:
+  metadata.gz: b2edf7540ddebb909650e1741fd09b85d5fe517f1768364ffebd04f58929dcbcc2ceef2888f0ae4306a7ef892df87cbf9159ae98e44a1f6f66f0f0808ac9e3bb
+  data.tar.gz: af66b0131bb5e401620b5526ee21831f21c854a33c964c7bcfa64dc9875409a490fe9e22cf7cee0247ee5f0b3affbadec9e8e54f68b797bf3a573baeebe9a15a

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Luilver Garces
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,59 @@
+# protobuf-mongoid
+
+protobuf-mongoid is a Ruby gem that integrates Protocol Buffers with Mongoid, allowing for efficient serialization and deserialization of Mongoid documents using Protocol Buffers.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'protobuf-mongoid'
+```
+
+And then execute:
+
+```
+bundle install
+```
+
+Or install it yourself as:
+
+```
+gem install protobuf-mongoid
+```
+
+## Usage
+
+To use protobuf-mongoid, include the necessary modules in your Mongoid models. Here is a basic example:
+
+```ruby
+class User
+  include Mongoid::Document
+  include Protobuf::Mongoid
+
+  field :name, type: String
+  field :email, type: String
+
+  # Define your Protocol Buffers message here
+end
+```
+
+### Tests
+
+To test protobuf-mongoid, run:
+
+```bash
+rake
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/luilver/protobuf-mongoid/fork )
+2. Create your feature branch (git checkout -b feature/my-new-feature)
+3. Commit your changes (git commit -am 'Add some feature')
+4. Push to the branch (git push origin feature/my-new-feature)
+5. Create a new Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE.txt) file for details.

data/lib/protobuf/mongoid/attribute_methods.rb

@@ -0,0 +1,33 @@
+module Protobuf
+  module Mongoid
+    module AttributeMethods
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def alias_field(field_alias, attribute)
+          alias_attribute field_alias, attribute
+
+          attribute_from_proto attribute, fetch_attribute_alias_from_proto(attribute, field_alias)
+          field_from_document field_alias, fetch_field_alias_from_document(attribute, field_alias)
+        end
+
+        def fetch_attribute_alias_from_proto(attribute, field_alias)
+          lambda do |proto|
+            value = proto.__send__(:"#{field_alias}!")
+            value ||= proto.__send__(:"#{attribute}!") if proto.respond_to?(attribute)
+
+            self._protobuf_convert_fields_to_attributes(attribute, value)
+          end
+        end
+
+        def fetch_field_alias_from_document(attribute, _field_aliasd)
+          lambda do |document|
+            value = document.__send__(field_alias)
+
+            self._protobuf_convert_attributes_to_fields(attribute, value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/mongoid/errors.rb

@@ -0,0 +1,50 @@
+module Protobuf
+  module Mongoid
+    # = Protobuf Mongoid errors
+    #
+    # Generic Protobuf Mongoid exception class
+    class ProtobufMongoidError < StandardError
+    end
+
+    # Raised by `attribute_from_proto` when the transformer method
+    # given is not callable.
+    class AttributeTransformerError < ProtobufMongoidError
+      def message
+        "Attribute transformers must be called with a callable or block!"
+      end
+    end
+
+    # Raised by `field_from_document` when the convert method
+    # given not callable.
+    class FieldTransformerError < ProtobufMongoidError
+      def message
+        "Field transformers must be called with a callable or block!"
+      end
+    end
+
+    # Raised by `to_proto` when no protobuf message is defined.
+    class MessageNotDefined < ProtobufMongoidError
+      attr_reader :class_name
+
+      def initialize(klass)
+        @class_name = klass.name
+      end
+
+      def message
+        "#{class_name} does not define a protobuf message"
+      end
+    end
+
+    # Raised by `field_scope` when given scope is not defined.
+    class SearchScopeError < ProtobufMongoidError
+    end
+
+    # Raised by `upsert_scope` when a given scope is not defined
+    class UpsertScopeError < ProtobufMongoidError
+    end
+
+    # Raised by `for_upsert` when no valid upsert_scopes are found
+    class UpsertNotFoundError < ProtobufMongoidError
+    end
+  end
+end

data/lib/protobuf/mongoid/fields.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Protobuf
+  module Mongoid
+    # A key-value pair within a document
+    module Fields
+      include ::Heredity
+      extend ::ActiveSupport::Concern
+
+      FIELD_TYPE_MAP_MUTEX = ::Mutex.new
+      DATE_OR_TIME_TYPES = ::Set.new(%i[date datetime time timestamp])
+
+      inheritable_attributes :_protobuf_fields,
+                             :_protobuf_field_types,
+                             :_protobuf_date_datetime_time_or_timestamp_field,
+                             :_protobuf_mapped_fields
+
+      ##
+      # Class Methods
+      #
+      module ClassMethods
+        def _protobuf_fields
+          _protobuf_map_fields unless _protobuf_mapped_fields?
+
+          @_protobuf_fields
+        end
+
+        def _protobuf_field_types
+          _protobuf_map_fields unless _protobuf_mapped_fields?
+
+          @_protobuf_field_types
+        end
+
+        def _protobuf_date_datetime_time_or_timestamp_field
+          _protobuf_map_fields unless _protobuf_mapped_fields?
+
+          @_protobuf_date_datetime_time_or_timestamp_field
+        end
+
+        # :nodoc:
+        def _protobuf_date_field?(key)
+          _protobuf_field_types[:date].include?(key)
+        end
+
+        # :nodoc:
+        def _protobuf_date_datetime_time_or_timestamp_field?(key)
+          _protobuf_date_datetime_time_or_timestamp_field.include?(key)
+        end
+
+        # :nodoc:
+        def _protobuf_datetime_field?(key)
+          _protobuf_field_types[:datetime].include?(key)
+        end
+
+        # Map out the fields for future reference on type conversion
+        # :nodoc:
+        # TODO: Check if collection exists
+        # collection_exists? is not a Mongoid method. We need to check $exists?
+        # return unless collection_exists?
+        def _protobuf_map_fields(force = false)
+          FIELD_TYPE_MAP_MUTEX.synchronize do
+            @_protobuf_mapped_fields = false if force
+            return if _protobuf_mapped_fields?
+
+            initialize_protobuf_field_containers
+            map_protobuf_fields
+
+            @_protobuf_mapped_fields = true
+          end
+        end
+
+        def _protobuf_mapped_fields?
+          @_protobuf_mapped_fields
+        end
+
+        # :nodoc:
+        def _protobuf_time_field?(key)
+          _protobuf_field_types[:time].include?(key)
+        end
+
+        # :nodoc:
+        def _protobuf_timestamp_field?(key)
+          _protobuf_field_types[:timestamp].include?(key)
+        end
+
+        private
+
+        def initialize_protobuf_field_containers
+          @_protobuf_fields = {}
+          @_protobuf_field_types = ::Hash.new { |h, k| h[k] = ::Set.new }
+          @_protobuf_date_datetime_time_or_timestamp_field = ::Set.new
+        end
+
+        def map_protobuf_fields
+          fields.each do |field|
+            field_name_symbol = field[0].to_sym
+            field_type_symbol = field[1].options[:type].to_s.to_sym
+
+            @_protobuf_fields[field_name_symbol] = field
+            @_protobuf_field_types[field_type_symbol] << field_name_symbol
+
+            if DATE_OR_TIME_TYPES.include?(field_type_symbol)
+              @_protobuf_date_datetime_time_or_timestamp_field << field_name_symbol
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/mongoid/model.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'protobuf/mongoid/attribute_methods'
+require 'protobuf/mongoid/errors'
+require 'protobuf/mongoid/fields'
+require 'protobuf/mongoid/nested_attributes'
+require 'protobuf/mongoid/persistence'
+require 'protobuf/mongoid/scope'
+require 'protobuf/mongoid/serialization'
+require 'protobuf/mongoid/transformation'
+require 'protobuf/mongoid/validations'
+
+module Protobuf
+  module Mongoid
+    # Base for Protobuf-Mongoid models
+    module Model
+      extend ::ActiveSupport::Concern
+
+      included do
+        include Protobuf::Mongoid::AttributeMethods
+        include Protobuf::Mongoid::Fields
+        include Protobuf::Mongoid::NestedAttributes
+        include Protobuf::Mongoid::Persistence
+        include Protobuf::Mongoid::Serialization
+        include Protobuf::Mongoid::Scope
+        include Protobuf::Mongoid::Transformation
+        include Protobuf::Mongoid::Validations
+      end
+    end
+  end
+end

data/lib/protobuf/mongoid/nested_attributes.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Protobuf
+  module Mongoid
+    # Nested Attributes
+    module NestedAttributes
+      extend ::ActiveSupport::Concern
+
+      included do
+        include ::Heredity::InheritableClassInstanceVariables
+
+        class << self
+          attr_accessor :_protobuf_nested_attributes
+        end
+
+        @_protobuf_nested_attributes = []
+
+        inheritable_attributes :_protobuf_nested_attributes
+      end
+
+      ##
+      # Class Methods
+      #
+      module ClassMethods
+        # :nodoc:
+        def accepts_nested_attributes_for(*attr_names)
+          attribute_names = attr_names.dup
+          attribute_names.extract_options!
+          attribute_names.map!(&:to_s)
+
+          super
+
+          self._protobuf_nested_attributes += attribute_names
+        end
+      end
+
+      # :nodoc:
+      def assign_nested_attributes_for_collection_association(association_name, attributes_collection)
+        if attributes_collection.first.is_a?(::Protobuf::Message)
+          reflection = self.class._reflect_on_association(association_name)
+          attributes_collection = attributes_collection.map do |attributes|
+            reflection.klass.attributes_from_proto(attributes)
+          end
+        end
+
+        super(association_name, attributes_collection)
+      end
+
+      # :nodoc:
+      def assign_nested_attributes_for_one_to_one_association(association_name, attributes)
+        if attributes.is_a?(::Protobuf::Message)
+          reflection = self.class._reflect_on_association(association_name)
+          attributes = reflection.klass.attributes_from_proto(attributes)
+        end
+
+        super(association_name, attributes)
+      end
+    end
+  end
+end

data/lib/protobuf/mongoid/persistence.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Protobuf
+  module Mongoid
+    # Persistence methods
+    module Persistence
+      extend ::ActiveSupport::Concern
+
+      ##
+      # Class Methods
+      #
+      module ClassMethods
+        # :nodoc:
+        def create(attributes = {}, &block)
+          attributes = attributes_from_proto(attributes) if attributes.is_a?(::Protobuf::Message)
+
+          super(attributes, &block)
+        end
+
+        # :nodoc:
+        def create!(attributes = {}, &block)
+          attributes = attributes_from_proto(attributes) if attributes.is_a?(::Protobuf::Message)
+
+          super(attributes, &block)
+        end
+      end
+
+      # Override Mongoid's initialize method so it can accept a protobuf
+      # message as it's attributes.
+      # :noapi:
+      def initialize(*args, &block)
+        args[0] = attributes_from_proto(args.first) if args.first.is_a?(::Protobuf::Message)
+        super(*args, &block)
+      end
+
+      # :nodoc:
+      def assign_attributes(attributes)
+        attributes = attributes_from_proto(attributes) if attributes.is_a?(::Protobuf::Message)
+
+        super(attributes)
+      end
+
+      # :nodoc:
+      def update(attributes)
+        attributes = attributes_from_proto(attributes) if attributes.is_a?(::Protobuf::Message)
+
+        super(attributes)
+      end
+
+      # :nodoc:
+      def update!(attributes)
+        attributes = attributes_from_proto(attributes) if attributes.is_a?(::Protobuf::Message)
+
+        super(attributes)
+      end
+    end
+  end
+end

data/lib/protobuf/mongoid/scope.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module Protobuf
+  module Mongoid
+    # Scope methods
+    module Scope
+      extend ::ActiveSupport::Concern
+
+      included do
+        class << self
+          alias_method :by_fields, :search_scope
+          alias_method :scope_from_proto, :search_scope
+        end
+      end
+
+      ##
+      # Class Methods
+      #
+      module ClassMethods
+        # Define fields that should be searchable via `search_scope`. Accepts a
+        # protobuf field and an already defined scope. If no scope is specified,
+        # the scope will be the field name, prefixed with `by_` (e.g. when the
+        # field is :guid, the scope will be :by_guid).
+        #
+        # Optionally, a parser can be provided that will be called, passing the
+        # field value as an argument. This allows custom data parsers to be used
+        # so that they don't have to be handled by scopes. Parsers can be procs,
+        # lambdas, or symbolized method names and must accept the value of the
+        # field as a parameter.
+        #
+        # Examples:
+        #
+        #   class User
+        #     include Mongoid::Base
+        #
+        #     scope :by_guid, lambda { |*guids| where(:guid => guids) }
+        #     scope :custom_guid_scope, lambda { |*guids| where(:guid => guids) }
+        #
+        #     # Equivalent to `field_scope :guid, :by_guid`
+        #     field_scope :guid
+        #
+        #     # With a custom scope
+        #     field_scope :guid, :scope => :custom_guid_scope
+        #
+        #     # With a custom parser that converts the value to an integer
+        #     field_scope :guid, :scope => :custom_guid_scope, :parser => lambda { |value| value.to_i }
+        #   end
+        #
+        def field_scope(field, options = {})
+          scope_name = if options.include?(:scope)
+                         options[:scope]
+                       else
+                         # When no scope is defined, assume the scope is the field, prefixed with `by_`
+                         :"by_#{field}"
+                       end
+          searchable_fields[field] = scope_name
+
+          searchable_field_parsers[field] = options[:parser] if options[:parser]
+        end
+
+        # :noapi:
+        def model_scope
+          all
+        end
+
+        # :noapi:
+        def parse_search_values(proto, field)
+          value = proto.__send__(field)
+
+          if searchable_field_parsers[field]
+            parser = searchable_field_parsers[field]
+
+            if parser.respond_to?(:to_sym)
+              value = self.__send__(parser.to_sym, value)
+            else
+              value = parser.call(value)
+            end
+          end
+
+          values = [value].flatten
+          values.map!(&:to_i) if proto.class.get_field(field, true).enum?
+          values
+        end
+
+        # Builds and returns a Arel relation based on the fields that are present
+        # in the given protobuf message using the searchable fields to determine
+        # what scopes to use. Provides several aliases for variety.
+        #
+        # Examples:
+        #
+        #   # Search starting with the default scope and searchable fields
+        #   User.search_scope(request)
+        #   User.by_fields(request)
+        #   User.scope_from_proto(request)
+        #
+        def search_scope(proto)
+          search_relation = model_scope
+
+          searchable_fields.each do |field, scope_name|
+            next unless proto.respond_to_and_has_and_present?(field)
+
+            search_values = parse_search_values(proto, field)
+            search_relation = search_relation.__send__(scope_name, *search_values)
+          end
+
+          search_relation
+        end
+
+        # :noapi:
+        def searchable_fields
+          @_searchable_fields ||= {}
+        end
+
+        # :noapi:
+        def searchable_field_parsers
+          @_searchable_field_parsers ||= {}
+        end
+
+        # Defines a scope that is eligible for upsert. The scope will be
+        # used to initialize a document with first_or_initialize. An upsert scope
+        # declariation must specify one or more fields that are required to
+        # be present on the request and also must have a field_scope defined.
+        #
+        # If multiple upsert scopes are specified, they will be searched in
+        # the order they are declared for the first valid scope.
+        #
+        # Examples:
+        #
+        #   class User
+        #     include Mongoid::Base
+        #
+        #     scope :by_guid, lambda { |*guids| where(:guid => guids) }
+        #     scope :by_external_guid, lambda { |*external_guids|
+        #       where(:external_guid => exteranl_guids)
+        #     }
+        #     scope :by_client_guid, lambda { |*client_guids|
+        #       joins(:client).where(
+        #         :clients => { :guid => client_guids }
+        #        )
+        #     }
+        #
+        #     field_scope :guid
+        #     field_scope :client_guid
+        #     field_scope :external_guid
+        #
+        #     upsert_scope :external_guid, :client_guid
+        #     upsert_scope :guid
+        #
+        #   end
+        #
+        def upsert_key(*fields)
+          fields = fields.flatten
+
+          fields.each do |field|
+            fail UpsertScopeError unless searchable_fields[field].present?
+          end
+
+          upsert_keys << fields
+        end
+
+        def upsert_keys
+          @_upsert_keys ||= []
+        end
+
+        def for_upsert(proto)
+          valid_upsert = upsert_keys.find do |upsert_key|
+            upsert_key.all? do |field|
+              proto.respond_to_and_has_and_present?(field)
+            end
+          end
+
+          fail UpsertNotFoundError unless valid_upsert.present?
+
+          upsert_scope = model_scope
+          valid_upsert.each do |field|
+            value = proto.__send__(field)
+            upsert_scope = upsert_scope.__send__(searchable_fields[field], value)
+          end
+
+          upsert_scope.first_or_initialize
+        end
+
+        def upsert(proto)
+          document = for_upsert(proto)
+          document.assign_attributes(proto)
+          document.save
+          document
+        end
+
+        def upsert!(proto)
+          document = for_upsert(proto)
+          document.assign_attributes(proto)
+          document.save!
+          document
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/mongoid/serialization.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+module Protobuf
+  module Mongoid
+    # Serialization methods
+    module Serialization
+      extend ActiveSupport::Concern
+
+      included do
+        class << self
+          attr_writer :_protobuf_field_symbol_transformers,
+                      :_protobuf_field_transformers,
+                      :_protobuf_field_options,
+                      :protobuf_message
+        end
+      end
+
+      ##
+      # Class Methods
+      #
+      module ClassMethods
+        def _protobuf_field_objects
+          @_protobuf_field_objects ||= {}
+        end
+
+        def _protobuf_field_options
+          @_protobuf_field_options ||= {}
+        end
+
+        def _protobuf_field_symbol_transformers
+          @_protobuf_field_symbol_transformers ||= {}
+        end
+
+        def _protobuf_field_transformers
+          @_protobuf_field_transformers ||= {}
+        end
+
+        def _protobuf_message_deprecated_fields
+          @_protobuf_message_deprecated_fields ||=
+            protobuf_message.all_fields.map do |field|
+              next if field.nil?
+              next unless field.deprecated?
+
+              field.name.to_sym
+            end
+        end
+
+        def _protobuf_message_non_deprecated_fields
+          @_protobuf_message_non_deprecated_fields ||=
+            protobuf_message.all_fields.map do |field|
+              next if field.nil?
+              next if field.deprecated?
+
+              field.name.to_sym
+            end
+        end
+
+        def field_from_document(field, transformer = nil, &block)
+          if transformer.is_a?(Symbol)
+            _protobuf_field_symbol_transformers[field] = transformer
+            return
+          end
+
+          transformer ||= block
+          callable = transformer
+
+          raise FieldTransformerError unless callable.respond_to?(:call)
+
+          _protobuf_field_transformers[field.to_sym] = callable
+        end
+
+        def protobuf_fields(*fields)
+          options = fields.extract_options!
+          options[:only] = fields if fields.present?
+
+          self._protobuf_field_options = options
+        end
+
+        def protobuf_message(message = nil, options = {})
+          unless message.nil?
+            @protobuf_message = message.to_s.classify.constantize
+            self._protobuf_field_options = options
+          end
+
+          @protobuf_message
+        end
+
+        class CollectionAssociationCaller
+          def initialize(method_name)
+            @method_name = method_name
+          end
+
+          def call(selph)
+            selph.__send__(@method_name).to_a
+          rescue NameError
+            nil
+          end
+        end
+
+        def _protobuf_collection_association_object(field)
+          CollectionAssociationCaller.new(field)
+        end
+
+        class DateCaller
+          def initialize(field)
+            @field = field
+          end
+
+          def call(selph)
+            value = selph.__send__(@field)
+
+            value&.to_time&.utc&.to_i
+          rescue NameError
+            nil
+          end
+        end
+
+        class DateTimeCaller
+          def initialize(field)
+            @field = field
+          end
+
+          def call(selph)
+            value = selph.__send__(@field)
+
+            value&.to_i
+          rescue NameError
+            nil
+          end
+        end
+
+        class NoConversionCaller
+          def initialize(field)
+            @field = field
+          end
+
+          def call(selph)
+            selph.__send__(@field)
+          rescue NameError
+            nil
+          end
+        end
+
+        def _protobuf_convert_to_fields_object(field)
+          is_datetime_time_or_timestamp_field = _protobuf_date_datetime_time_or_timestamp_field?(field)
+          is_date_field = _protobuf_date_field?(field)
+
+          if is_datetime_time_or_timestamp_field
+            if is_date_field
+              DateCaller.new(field)
+            else
+              DateTimeCaller.new(field)
+            end
+          else
+            NoConversionCaller.new(field)
+          end
+        end
+
+        def _protobuf_field_transformer_object(field)
+          _protobuf_field_transformers[field]
+        end
+
+        class NilMethodCaller
+          def initialize; end
+
+          def call(_selph)
+            nil
+          end
+        end
+
+        def _protobuf_nil_object(_field)
+          NilMethodCaller.new
+        end
+
+        class FieldSymbolTransformerCaller
+          def initialize(instance_class, method_name)
+            @instance_class = instance_class
+            @method_name = method_name
+          end
+
+          def call(selph)
+            @instance_class.__send__(@method_name, selph)
+          end
+        end
+
+        def _protobuf_symbol_transformer_object(field)
+          FieldSymbolTransformerCaller.new(self, _protobuf_field_symbol_transformers[field])
+        end
+      end
+
+      def _filter_field_attributes(options = {})
+        options = _normalize_options(options)
+
+        fields = _filtered_fields(options)
+        fields &= [options[:only]].flatten if options[:only].present?
+        fields -= [options[:except]].flatten if options[:except].present?
+
+        fields
+      end
+
+      def _filtered_fields(options = {})
+        include_deprecated = options.fetch(:deprecated, true)
+
+        fields = []
+        fields.concat(self.class._protobuf_message_non_deprecated_fields)
+        fields.concat(self.class._protobuf_message_deprecated_fields) if include_deprecated
+        fields.concat([options[:include]].flatten) if options[:include].present?
+        fields.compact!
+        fields.uniq!
+
+        fields
+      end
+
+      def _is_collection_association?(field)
+        reflection = self.class.relations[field.to_s]
+        return false unless reflection
+
+        reflection.class.name.split('::').last.to_sym == :has_many
+      end
+
+      def _normalize_options(options)
+        options ||= {}
+        options[:only] ||= [] if options.fetch(:except, false)
+        options[:except] ||= [] if options.fetch(:only, false)
+
+        self.class._protobuf_field_options.merge(options)
+      end
+
+      def fields_from_document(options = {})
+        hash = {}
+        field_attributes = _filter_field_attributes(options)
+
+        if options[:include].present?
+          field_attributes.concat([options[:include]].flatten)
+          field_attributes.compact!
+          field_attributes.uniq!
+        end
+
+        field_attributes.each do |field|
+          field_object = _protobuf_field_objects(field)
+          hash[field] = field_object.call(self)
+        end
+
+        hash
+      end
+
+      # TODO: Assignment Branch Condition size for _protobuf_field_objects is too high. [<1, 19, 7> 20.27/17]
+      def _protobuf_field_objects(field)
+        self.class._protobuf_field_objects[field] ||=
+          if _protobuf_field_symbol_transformers.key?(field)
+            self.class._protobuf_symbol_transformer_object(field)
+          elsif _protobuf_field_transformers.key?(field)
+            self.class._protobuf_field_transformer_object(field)
+          elsif respond_to?(field)
+            if _is_collection_association?(field)
+              self.class._protobuf_collection_association_object(field)
+            else
+              self.class._protobuf_convert_to_fields_object(field)
+            end
+          else
+            self.class._protobuf_nil_object(field)
+          end
+      end
+
+      def _protobuf_field_symbol_transformers
+        self.class._protobuf_field_symbol_transformers
+      end
+
+      def _protobuf_field_transformers
+        self.class._protobuf_field_transformers
+      end
+
+      def _protobuf_message
+        self.class.protobuf_message
+      end
+
+      def to_proto(options = {})
+        raise MessageNotDefined, self.class if _protobuf_message.nil?
+
+        fields = fields_from_document(options)
+        _protobuf_message.new(fields)
+      end
+    end
+  end
+end

data/lib/protobuf/mongoid/transformation.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require 'protobuf/mongoid/transformer'
+
+module Protobuf
+  module Mongoid
+    # Transformation methods
+    module Transformation
+      extend ::ActiveSupport::Concern
+
+      included do
+        include ::Heredity::InheritableClassInstanceVariables
+
+        class << self
+          attr_accessor :_protobuf_attribute_transformers
+        end
+
+        @_protobuf_attribute_transformers = {}
+
+        inheritable_attributes :_protobuf_attribute_transformers
+      end
+
+      ##
+      # Class Methods
+      #
+      module ClassMethods
+        # Filters accessible attributes that exist in the given protobuf message's
+        # fields or have attribute transformers defined for them.
+        #
+        # Returns a hash of attribute fields with their respective values.
+        #
+        # :nodoc:
+        # TODO: Assignment Branch Condition size for _filter_attribute_fields is too high. [<13, 26, 9> 30.43/17]
+        # TODO: Use `each_with_object` instead of `inject`.
+        def _filter_attribute_fields(proto)
+          fields = proto.to_hash
+          fields.select! do |key, _value|
+            field = proto.class.get_field(key, true)
+            proto.field?(key) && !field.repeated?
+          end
+
+          filtered_attributes = _filtered_attributes + _protobuf_attribute_transformers.keys
+
+          attribute_fields = filtered_attributes.inject({}) do |hash, field_name|
+            symbolized_field = field_name.to_sym
+
+            if fields.key?(symbolized_field) || _protobuf_attribute_transformers.key?(symbolized_field)
+              hash[symbolized_field] = fields[symbolized_field]
+            end
+
+            hash
+          end
+
+          _protobuf_nested_attributes.each do |attribute_name|
+            nested_attribute_name = "#{attribute_name}_attributes".to_sym
+            value = if proto.field?(nested_attribute_name)
+                      proto.__send__(nested_attribute_name)
+                    elsif proto.field?(attribute_name)
+                      proto.__send__(attribute_name)
+                    end
+
+            next unless value
+
+            attribute_fields[nested_attribute_name] = value
+          end
+
+          attribute_fields
+        end
+
+        # Overidden by mass assignment security when protected attributes is loaded.
+        #
+        # :nodoc:
+        def _filtered_attributes
+          return self.attribute_names
+        end
+
+        # :nodoc:
+        def _protobuf_convert_fields_to_attributes(key, value)
+          return nil if value.nil?
+          return value unless _protobuf_date_datetime_time_or_timestamp_field?(key)
+
+          value = case
+                  when _protobuf_datetime_field?(key) then
+                    convert_int64_to_datetime(value)
+                  when _protobuf_timestamp_field?(key) then
+                    convert_int64_to_time(value)
+                  when _protobuf_time_field?(key) then
+                    convert_int64_to_time(value)
+                  when _protobuf_date_field?(key) then
+                    convert_int64_to_date(value)
+                  end
+
+          return value
+        end
+
+        # Define an attribute transformation from protobuf. Accepts a Symbol,
+        # callable, or block.
+        #
+        # When given a callable or block, it is directly used to convert the field.
+        #
+        # When a symbol is given, it extracts the method with the same name.
+        #
+        # The callable or method must accept a single parameter, which is the
+        # proto message.
+        #
+        # Examples:
+        #   attribute_from_proto :public_key, :extract_public_key_from_proto
+        #   attribute_from_proto :status, lambda { |proto| # Do some stuff... }
+        #   attribute_from_proto :status do |proto|
+        #     # Do some blocky stuff...
+        #   end
+        #
+        #   attribute_from_proto :status, lambda { |proto| nil }, :nullify_on => :status
+        #   attribute_from_proto :status, :nullify_on => :status do |proto|
+        #     nil
+        #   end
+        #
+        def attribute_from_proto(attribute, *args, &block)
+          options = args.extract_options!
+          symbol_or_block = args.first || block
+
+          if symbol_or_block.is_a?(Symbol)
+            callable = lambda { |value| self.__send__(symbol_or_block, value) }
+          else
+            raise AttributeTransformerError unless symbol_or_block.respond_to?(:call)
+            callable = symbol_or_block
+          end
+
+          if options[:nullify_on]
+            field = protobuf_message.get_field(:nullify)
+            unless field&.is_a?(::Protobuf::Field::StringField) && field&.repeated?
+              ::Protobuf::Logging.logger.warn "Message: #{protobuf_message} is not compatible with :nullify_on option"
+            end
+          end
+
+          transformer = ::Protobuf::Mongoid::Transformer.new(callable, options)
+          _protobuf_attribute_transformers[attribute.to_sym] = transformer
+        end
+
+        # Creates a hash of attributes from a given protobuf message.
+        #
+        # It converts and transforms field values using the field converters and
+        # attribute transformers, ignoring repeated and nil fields.
+        #
+        def attributes_from_proto(proto)
+          attribute_fields = _filter_attribute_fields(proto)
+
+          attributes = attribute_fields.inject({}) do |hash, (key, value)|
+            if _protobuf_attribute_transformers.key?(key)
+              transformer = _protobuf_attribute_transformers[key]
+              attribute = transformer.call(proto)
+              hash[key] = attribute unless attribute.nil?
+              hash[key] = nil if transformer.nullify?(proto)
+            else
+              hash[key] = _protobuf_convert_fields_to_attributes(key, value)
+            end
+
+            hash
+          end
+
+          return attributes unless proto.field?(:nullify) && proto.nullify.is_a?(Array)
+
+          proto.nullify.each do |attribute_name|
+            attributes[attribute_name.to_sym] = nil if attribute_names.include?(attribute_name.to_s)
+          end
+
+          attributes
+        end
+
+        # :nodoc:
+        def convert_int64_to_time(int64)
+          Time.at(int64.to_i)
+        end
+
+        # :nodoc:
+        def convert_int64_to_date(int64)
+          convert_int64_to_time(int64).utc.to_date
+        end
+
+        # :nodoc:
+        def convert_int64_to_datetime(int64)
+          convert_int64_to_time(int64).to_datetime
+        end
+      end
+
+      # Calls up to the class version of the method.
+      #
+      def attributes_from_proto(proto)
+        self.class.attributes_from_proto(proto)
+      end
+    end
+  end
+end

data/lib/protobuf/mongoid/transformer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Protobuf
+  module Mongoid
+    # Transformer class
+    class Transformer
+      attr_accessor :callable, :options
+
+      def initialize(callable, options = {})
+        @callable = callable
+        @options = options
+      end
+
+      def call(proto)
+        return unless proto
+
+        callable.call(proto)
+      end
+
+      def nullify?(proto)
+        return false unless options[:nullify_on]
+        return false unless proto.field?(:nullify) && proto.nullify.is_a?(Array)
+        return false if proto.nullify.empty?
+
+        proto.nullify.include?(options[:nullify_on].to_s)
+      end
+    end
+  end
+end

data/lib/protobuf/mongoid/validations.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Protobuf
+  module Mongoid
+    # Validation methods
+    module Validations
+      extend ::ActiveSupport::Concern
+
+      ##
+      # Class Methods
+      #
+      module ClassMethods
+        # Validates whether the value of the specified attribute is available in
+        # the given Protobuf Enum. The enumeration should be passed as a class
+        # that defines the enumeration:
+        #
+        # ```
+        # class User < Mongoid::Base
+        #   include ::Protobuf::Mongoid::Model
+        #
+        #   validates_enumeration_of :role_type, :with => RoleType, :allow_nil => true
+        # end
+        # ```
+        #
+        # In this example, RoleType is a defined as a protobuf enum.
+        #
+        # It accepts the same options as `validates_inclusion_of` (the :in option
+        # is automatically set and will be overwritten).
+        #
+        def validates_enumeration_of(*args)
+          options = args.extract_options!
+          enumerable = options.delete(:with)
+
+          raise ArgumentError, ':with must be specified' if enumerable.nil?
+
+          options[:in] = enumerable.all_tags if enumerable < ::Protobuf::Enum
+
+          args << options
+
+          validates_inclusion_of(*args)
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/mongoid/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Protobuf
+  module Mongoid
+    VERSION = '0.0.1'
+  end
+end

data/lib/protobuf/mongoid.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'heredity'
+
+require 'protobuf/mongoid/model'
+require 'protobuf/mongoid/version'
+
+module Protobuf
+  # Main module for Protobuf-Mongoid integration
+  module Mongoid
+  end
+end

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification
+name: protobuf-mongoid
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Luilver Garces
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-04-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: google-protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.30.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.30.0
+- !ruby/object:Gem::Dependency
+  name: heredity
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 9.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 9.0.0
+- !ruby/object:Gem::Dependency
+  name: protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.10.0
+- !ruby/object:Gem::Dependency
+  name: securerandom
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.15.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.15.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+description: This gem provides functionality to serialize and deserialize Mongoid
+  documents using Protocol Buffers.
+email:
+- luilver@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/protobuf/mongoid.rb
+- lib/protobuf/mongoid/attribute_methods.rb
+- lib/protobuf/mongoid/errors.rb
+- lib/protobuf/mongoid/fields.rb
+- lib/protobuf/mongoid/model.rb
+- lib/protobuf/mongoid/nested_attributes.rb
+- lib/protobuf/mongoid/persistence.rb
+- lib/protobuf/mongoid/scope.rb
+- lib/protobuf/mongoid/serialization.rb
+- lib/protobuf/mongoid/transformation.rb
+- lib/protobuf/mongoid/transformer.rb
+- lib/protobuf/mongoid/validations.rb
+- lib/protobuf/mongoid/version.rb
+homepage: https://github.com/yourusername/protobuf-mongoid
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.6
+signing_key:
+specification_version: 4
+summary: A gem to integrate Protocol Buffers with Mongoid.
+test_files: []