pb-serializer 0.5.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b46a686595d5e9e919c21ff7e6902cec71be97d716085dc38b8b2ef0192e7cf1
-  data.tar.gz: c453986c407e5e567bce43f3f45429697c552dedc44356ffee2a8e0b4d5eaea7
+  metadata.gz: b06e7d595d2212e0d8c6d36bc652acccb3020094b6370c9494476eb0de483487
+  data.tar.gz: 13efc77cdd5a595a0763b16989f7064a5c1f79ebd3bdff7330964eadd7569db7
 SHA512:
-  metadata.gz: c58c5ab0714bd7bee52f3f30ede95b676b849cdf0be482a9de0187287d3ecfd0e758b6cc7c17831965d7e8e54fc13763c6290607330077c3a2135c6fe9cfd439
-  data.tar.gz: 7b3cc2224f7550c72714cc21c1e656182891788b1f0aa67b02dce177ea44cb6dfef5115073aeb08eb130fe40decc15551e73bbb2aa6ec77c0fc997e8fbf3477f
+  metadata.gz: 936b879ffebc21afb812bb8763cfc57132c19db685138ba0b69c74ab156c70909a2f35482464c0c35ed776e5b2ff02546b1f55699bc48b5f44568890771da0b8
+  data.tar.gz: 6da97182764357672107dbacf6184e723f55ad203078dc9c660e53741d861ae39e210cf5d7ecb6a9b4155e618273e0963a97bc322bba7e579faa8f066b36a5bb

data/.yardopts

@@ -0,0 +1,8 @@
+--no-private
+--hide-api private
+lib/**/*.rb
+-
+README.ja.md
+docs/examples.md
+CHANGELOG.md
+LICENSE.txt

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## Unreleased
 
+## 0.5.2
+
+- Generate the default mask lazily to prevent infinite recursions https://github.com/wantedly/pb-serializer/pull/52
+
+## 0.5.1
+
+- Improving interoperability with `computed_model`
+  - Simplify field mask normalizer and add `Pb::Serializer.parse_field_mask` method https://github.com/wantedly/pb-serializer/pull/40
+  - Stop defining accessor methods in `attribute` DSL if the method of the same name already existss https://github.com/wantedly/pb-serializer/pull/42
+- Refactoring
+  - Extract Dsl and Hook from Serializable module https://github.com/wantedly/pb-serializer/pull/41
+
 ## 0.5.0
 
 - Bump `computed_model` from 0.2.2 to 0.3.0 https://github.com/wantedly/pb-serializer/pull/38

data/README.ja.md

@@ -0,0 +1,66 @@
+<!--
+# @title 日本語版 README
+-->
+
+# Pb::Serializer
+
+`Pb::Serializer` はRuby オブジェクトの Protocol Buffers シリアライザです。
+
+[English version](./README.md)
+
+## Features
+
+- [ActiveModelSerializers](https://github.com/rails-api/active_model_serializers) のような宣言的な API 
+- [Well-Known Types](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf) への自動変換（例 `google.protobuf.Uint64Value`）
+- [`google.protobuf.FieldMask`](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#fieldmask) を利用した、GraphQL のような選択的フィールド取得のサポート
+  - [ComputedModel](https://github.com/wantedly/computed_model) と組み合わせることで、複雑なロジックと依存関係を持つ API も宣言的に実装できます
+
+
+## Usage
+
+以下のような Protocol Buffers のメッセージ定義および ActiveRecord モデルを例にします。
+
+```proto
+syntax = "proto3";
+
+package example;
+
+option ruby_package = "ExamplesPb";
+
+message User {
+  uint64 id = 1;
+  string name = 2;
+}
+```
+
+```ruby
+# Schema: [id(integer), name(string)]
+class User < ActiveRecord::Base
+end
+```
+
+`.proto` で定義された `User` メッセージに対応する PbSerializer を実装します。
+生成されたクラスと定義されているフィールドすべてを PbSerializer に宣言する必要があります。
+
+```ruby
+class UserPbSerializer < Pb::Serializer::Base
+  message ExamplesPb::User
+
+  attribute :id
+  attribute :name
+end
+```
+
+実装した PbSerializer で、Ruby オブジェクトを protobuf message object にシリアライズできます。
+
+```ruby
+user = User.find(123)
+UserPbSerializer.new(user).to_pb
+# => <ExamplesPb::User: id: 123, name: "someuser">
+```
+
+各 attribute の値は、PbSerializer インスタンス、もしくはコンストラクタに渡されたオブジェクト から決定されます。
+
+## Next read
+
+- [Examples](./docs/examples.md)

data/README.md

@@ -4,62 +4,66 @@
 [![Gem Version](https://badge.fury.io/rb/pb-serializer.svg)](https://badge.fury.io/rb/pb-serializer)
 [![License](https://img.shields.io/github/license/wantedly/pb-serializer)](./LICENSE)
 
-```rb
-class UserSerializer < Pb::Serializer::Base
-  message YourApp::User
+`Pb::Serializer` is Protocol Buffers serializer for Ruby objects.
 
-  attribute :id
-  attribute :name
-  attribute :posts
+[日本語版 README](./README.ja.md)
+
+## Features
+
+- Declarative APIs such as [ActiveModelSerializers](https://github.com/rails-api/active_model_serializers)
+- Automatic conversion to [Well-Known Types](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf) (e.g. `google.protobuf.Uint64Value`)
+- Support for GraphQL-like selective field fetching using [`google.protobuf.FieldMask`](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#fieldmask).
+  - When combined with [ComputedModel](https://github.com/wantedly/computed_model), APIs with complex logic and dependencies can be implemented declaratively.
+
+
+## Usage
+
+The following is an example of a message definition and ActiveRecord model for Protocol Buffers.
+
+```proto
+syntax = "proto3";
 
-  define_primary_loader :user do |subdeps, ids:, **|
-    User.where(id: ids).preload(subdeps).map { |u| new(u) }
-  end
+package example;
 
-  define_loader :posts, key: -> { id } do |user_ids, subdeps, **|
-    PostSerializer.bulk_load(user_id: user_ids, with: subdeps).group_by { |s| s.post.user_id }
-  end
+option ruby_package = "ExamplesPb";
 
-  dependency :posts
-  computed def post_count
-    posts.count
-  end
+message User {
+  uint64 id = 1;
+  string name = 2;
+}
+```
+
+```ruby
+# Schema: [id(integer), name(string)]
+class User < ActiveRecord::Base
 end
+```
 
-class PostSerializer < Pb::Serializer::Base
-  message YourApp::Post
+Implements a PbSerializer for the `User` message defined in `.proto`.
+You need to declare the generated class and all defined fields in the PbSerializer.
 
-  define_primary_loader :post do |subdeps, user_ids:, **|
-    Post.where(user_id: user_ids).preload(subdeps).map { |p| new(p) }
-  end
+```ruby
+class UserPbSerializer < Pb::Serializer::Base
+  message ExamplesPb::User
 
   attribute :id
-  attribute :title
-  attribute :body
+  attribute :name
 end
+```
 
-class UserGrpcService < YourApp::UserService::Service
-  # @param req [YourApp::GetUserRequest]
-  # @param call [GRPC::ActiveCall::SingleReqView]
-  # @return [YourApp::User]
-  def get_users(req, call)
-    UserSerializer.bulk_load_and_serialize(ids: [req.user_id], with: req.field_mask)[0]
-  end
-
-  # @param req [YourApp::ListFriendUsersRequest]
-  # @param call [GRPC::ActiveCall::SingleReqView]
-  # @return [YourApp::ListFriendUsersResponse]
-  def list_friend_users(req, call)
-    current_user = User.find(current_user_id)
-    YourApp::ListFriendUsersResponse.new(
-      users: UserSerializer.bulk_load_and_serialize(ids: current_user.friend_ids, with: req.field_mask)
-    )
-  end
-end
+You can serialize Ruby objects to protobuf message object with the implemented PbSerializer.
+
+```ruby
+user = User.find(123)
+UserPbSerializer.new(user).to_pb
+# => <ExamplesPb::User: id: 123, name: "someuser">
 ```
 
-More examples are available under [./spec/examples](./spec/examples).
+The value of each attribute is determined from the PbSerializer instance or the object passed to the constructor.
+
+## Next read
 
+- [Examples](./docs/examples.md)
 
 ## Installation
 
@@ -77,10 +81,6 @@ Or install it yourself as:
 
     $ gem install pb-serializer
 
-## Usage
-
-TODO: Write usage instructions here
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/docs/examples.md

@@ -0,0 +1,236 @@
+# Examples
+
+## Sub messages
+
+```proto
+message Post {
+  uint64 id = 1;
+  string title = 2;
+  User author = 3;
+}
+
+message User {
+  uint64 id = 1;
+  string name = 2;
+}
+```
+
+```ruby
+# Schema: [id(integer), title(string), author_id(integer)]
+class Book < ActiveRecord::Base
+  belongs_to :author, class_name: 'User'
+end
+
+# Schema: [id(integer), name(string)]
+class User < ActiveRecord::Base
+end
+```
+
+```ruby
+class BookPbSerializer < Pb::Serializer::Base
+  message ExamplesPb::Book
+
+  attribute :id
+  attribute :title
+  attribute :author, serializer: UserPbSerializer
+end
+
+class UserPbSerializer < Pb::Serializer::Base
+  message ExamplesPb::User
+
+  attribute :id
+  attribute :name
+end
+```
+
+## Enum
+
+```proto
+message Conversation {
+  uint64 id = 1;
+  Status status = 3;
+
+  enum Status {
+    STATUS_UNSPECIFIED = 0;
+    ARCHIVED = 1;
+    ACTIVE = 2;
+  }
+}
+```
+
+```ruby
+# https://api.rubyonrails.org/classes/ActiveRecord/Enum.html
+
+# Schema: [id(integer), status(integer)]
+class Conversation < ApplicationRecord
+  enum status: { active: 0, archived: 1 }, _prefix: true
+end
+```
+
+```ruby
+# @!attribute [r] object
+#   @return [Conversation]
+class ConversationPbSerializer < Pb::Serializer::Base
+  message ExamplesPb::Conversation
+
+  attribute :status
+
+  def status
+    object.status.upcase.to_sym
+  end
+end
+```
+
+## Oneof
+
+```proto
+message Entry {
+  oneof entry {
+    Message message = 1;
+    Comment comment = 2;
+  }
+}
+
+message Message {
+  // ...
+}
+
+message Comment {
+  // ...
+}
+```
+
+```ruby
+# see https://api.rubyonrails.org/classes/ActiveRecord/DelegatedType.html
+
+class Entry < ApplicationRecord
+  delegated_type :entryable, types: %w[Message Comment]
+end
+
+class Message < ApplicationRecord
+  # ...
+end
+
+class Comment < ApplicationRecord
+  # ...
+end
+```
+
+```ruby
+# @!attribute [r] object
+#   @return [Entry]
+class EntryPbSerializer < Pb::Serializer::Base
+  message ExamplesPb::Entry
+
+  oneof :entry do
+    attribute :message, if: -> { object.message? }, serializer: MessagePbSerializer
+    attribute :comment, if: -> { object.comment? }, serializer: CommentPbSerializer
+  end
+end
+
+# @!attribute [r] object
+#   @return [Message]
+class MessagePbSerializer < Pb::Serializer::Base
+  message ExamplesPb::Message
+
+  # ...
+end
+
+# @!attribute [r] object
+#   @return [Comment]
+class CommentPbSerializer < Pb::Serializer::Base
+  message ExamplesPb::Comment
+
+  # ...
+end
+```
+
+## Serializable model
+
+```proto
+message User {
+  uint64 id = 1;
+  string first_name = 2;
+  string last_name = 3;
+}
+```
+
+```ruby
+# Schema: [id(integer), first_name(string), last_name(string)]
+class User < ActiveRecord::Base
+  include Pb::Serializable
+
+  message ExamplesPb::User
+
+  attribute :id
+  attribute :first_name
+  attribute :last_name
+end
+```
+
+```ruby
+User.find(123).to_pb
+# => <ExamplesPb::User: id: 123, first_name: 'Masayuki', last_name: 'Izumi'>
+```
+
+## With FieldMask and ComputedModel
+
+```proto
+message User {
+  uint64 id = 1;
+  string first_name = 2;
+  string last_name = 3;
+  string full_name = 4;
+}
+```
+
+```ruby
+# Schema: [id(integer), first_name(string), last_name(string)]
+class RawUser < ActiveRecord::Base
+  self.table_name = 'users'
+end
+
+class User
+  include ComputedModel::Model
+
+  def initialize(raw_user)
+    @raw_user = user
+  end
+
+  def self.batch_get(ids, with:)
+    bulk_load_and_compute([*Array(with), :id], ids: ids)
+  end
+
+  define_primary_loader :raw_user do |subfields, ids:, **|
+    RawUser.where(id: ids).select(subfields).map { new(_1) }
+  end
+
+  delegate_dependency :id, :first_name, :last_name,
+    to: :raw_user, include_subfields: true
+
+  dependency :first_name, :last_name
+  computed def full_name
+    [first_name, last_name].compact.join(' ')
+  end
+end
+```
+
+```ruby
+class UserPbSerializer < Pb::Serializer::Base
+  message ExamplesPb::User
+
+  attribute :id
+  attribute :first_name
+  attribute :last_name
+  attribute :full_name
+end
+```
+
+```ruby
+# req.read_mask # => <Google::Protobuf::FieldMask: paths: ['id', 'full_name']>
+mask = Pb::Serializer.parse_field_mask(req.read_mask)
+
+user = User.batch_get([123], with: mask)[0]
+UserPbSerializer.new(user).to_pb(with: mask)
+# => <ExamplesPb::User: id: 123, first_name: '', last_name: '', full_name: "Masayuki Izumi">
+```

data/lib/pb/serializable/computed_model_support.rb

@@ -0,0 +1,52 @@
+module Pb
+  module Serializable
+    # @private
+    module ComputedModelSupport
+      def self.included(base)
+        base.singleton_class.prepend Hook
+      end
+
+      private def primary_object
+        primary_object_name = self.class.__pb_serializer_primary_model_name
+        if primary_object_name
+          send(primary_object_name)
+        elsif kind_of?(Serializer::Base)
+          send(:object)
+        else
+          self
+        end
+      end
+
+      module Hook
+        attr_accessor :__pb_serializer_primary_model_name
+
+        def define_primary_loader(name)
+          self.__pb_serializer_primary_model_name = name
+
+          super
+        end
+
+        def computed(name)
+          __pb_serializer_attrs << name
+
+          super
+        end
+
+        def define_loader(name, **)
+          __pb_serializer_attrs << name
+
+          super
+        end
+
+        # @param with [Array]
+        private def __pb_serializer_filter_only_computed_model_attrs(with)
+          with.reject { |c| (__pb_serializer_attrs & (c.kind_of?(Hash) ? c.keys : [c])).empty? }
+        end
+
+        private def __pb_serializer_attrs
+          @__pb_serializer_attrs ||= Set.new
+        end
+      end
+    end
+  end
+end

data/lib/pb/serializable/dsl/attribute.rb

@@ -0,0 +1,94 @@
+module Pb
+  module Serializable
+    module Dsl
+      # @api private
+      class Attribute < Struct.new(
+        :name,
+        :options,
+        :field_descriptor,
+        :oneof,
+        keyword_init: true,
+      )
+
+        ALLOWED_OPTIONS = Set[:allow_nil, :if, :serializer, :ignore].freeze
+
+        def initialize(options:, **)
+          super
+
+          unknown_options = options.keys.to_set - ALLOWED_OPTIONS
+          unless unknown_options.empty?
+            raise ::Pb::Serializer::InvalidAttributeOptionError, "unknown options are specified in #{name} attribute: #{unknown_options.to_a}"
+          end
+        end
+
+        # @return [Boolean]
+        def allow_nil?
+          options.fetch(:allow_nil, false)
+        end
+
+        # @return [Class]
+        def serializer_class
+          options[:serializer]
+        end
+
+        # @return [Boolean]
+        def repeated?
+          field_descriptor.label == :repeated
+        end
+
+        # @return [Boolean]
+        def serializable?(s)
+          return false if options[:ignore]
+
+          cond = options[:if]
+
+          return true unless cond
+
+          case cond
+          when String, Symbol; then s.send(cond)
+          when Proc;           then s.instance_exec(&cond)
+          else raise ::Pb::Serializer::InvalidAttributeOptionError, "`if` option can accept only Symbol, String or Proc. but got #{cond.class}"
+          end
+        end
+
+        def oneof?
+          !oneof.nil?
+        end
+
+        # @param v [Object]
+        # @param with [Hash, Array]
+        def convert_to_pb(v, with: nil, should_repeat: repeated?)
+          return nil if v.nil?
+          return v.map { |i| convert_to_pb(i, should_repeat: false, with: with) } if should_repeat
+
+          case field_descriptor.type
+          when :message
+            if v.class < Google::Protobuf::MessageExts && v.class.descriptor.name == field_descriptor.submsg_name
+              return v
+            end
+
+            case field_descriptor.submsg_name
+            when "google.protobuf.Timestamp"   then Pb.to_timestamp(v)
+            when "google.protobuf.StringValue" then Pb.to_strval(v)
+            when "google.protobuf.Int32Value"  then Pb.to_int32val(v)
+            when "google.protobuf.Int64Value"  then Pb.to_int64val(v)
+            when "google.protobuf.UInt32Value" then Pb.to_uint32val(v)
+            when "google.protobuf.UInt64Value" then Pb.to_uint64val(v)
+            when "google.protobuf.FloatValue"  then Pb.to_floatval(v)
+            when "google.protobuf.DoubleValue" then Pb.to_doubleval(v)
+            when "google.protobuf.BoolValue"   then Pb.to_boolval(v)
+            when "google.protobuf.BytesValue"  then Pb.to_bytesval(v)
+            else
+              return serializer_class.new(v).to_pb(with: with) if serializer_class
+              return v.to_pb(with: with) if v.kind_of?(::Pb::Serializable)
+
+              raise "serializer was not found for #{field_descriptor.submsg_name}"
+            end
+          else
+            v.nil? ? field_descriptor.default : v
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pb/serializable/dsl/oneof.rb

@@ -0,0 +1,18 @@
+module Pb
+  module Serializable
+    module Dsl
+      # @api private
+      class Oneof < Struct.new(
+        :name,
+        :allow_nil,
+        :attributes,
+        keyword_init: true,
+      )
+        # @return [Boolean]
+        def allow_nil?
+          allow_nil
+        end
+      end
+    end
+  end
+end

data/lib/pb/serializable/dsl.rb

@@ -0,0 +1,75 @@
+require 'pb/serializable/dsl/attribute'
+require 'pb/serializable/dsl/oneof'
+
+module Pb
+  module Serializable
+    module Dsl
+      # @param klass [Class] Protobuf message class
+      # @return [void]
+      def message(klass)
+        self.__pb_serializer_message_class = klass
+      end
+
+      # @param name [Symbol] An attribute name
+      # @param opts [Hash] options
+      # @option opts [Boolean] :allow_nil Set true if this attribute allow to be nil
+      # @option opts [Class] :serializer A serializer class for this attribute
+      # @option opts [String, Symbol, Proc] :if A method, proc or string to call to determine to serialize this field
+      # @return [void]
+      # @raise [Pb::Serializer::MissingMessageTypeError] if this class has not been called {#message}
+      # @raise [Pb::Serializer::UnknownFieldError] if the field does not defined in .proto
+      # @raise [Pb::Serializer::InvalidAttributeOptionError] if unknown options are passed
+      def attribute(name, opts = {})
+        raise ::Pb::Serializer::MissingMessageTypeError, "message specificaiton is missed" unless __pb_serializer_message_class
+
+        fd = __pb_serializer_message_class.descriptor.find { |fd| fd.name.to_sym == name }
+
+        raise ::Pb::Serializer::UnknownFieldError, "#{name} is not defined in #{ __pb_serializer_message_class.name}" unless fd
+
+        attr = Attribute.new(
+          name: name,
+          options: opts,
+          field_descriptor: fd,
+          oneof: @current_oneof&.name,
+        )
+
+        __pb_serializer_attr_by_name[name] = attr
+
+        unless method_defined?(attr.name)
+          define_method attr.name do
+            primary_object.public_send(attr.name)
+          end
+        end
+      end
+
+      # @param names [Array<Symbol>] Attribute names to be ignored
+      # @return [void]
+      # @example Ignore attributes
+      #   ignore :deprecated_field, :not_implemented_field
+      def ignore(*names)
+        names.each do |name|
+          attribute name, ignore: true
+        end
+      end
+
+      # @param name [Symbol] An oneof attribute name
+      # @param allow_nil [Boolean] Set true if this oneof attribute allow to be nil
+      # @return [void]
+      # @example Define oneof attributes
+      #   oneof :test_oneof do
+      #     attribute :name
+      #     attribute :sub_message
+      #   end
+      def oneof(name, allow_nil: false)
+        @current_oneof = Oneof.new(
+          name: name,
+          allow_nil: allow_nil,
+          attributes: [],
+        )
+        yield
+        __pb_serializer_oneof_by_name[name] = @current_oneof
+        @current_oneof = nil
+      end
+    end
+  end
+end

data/lib/pb/serializable.rb

@@ -1,30 +1,39 @@
+require "pb/serializable/computed_model_support"
+require "pb/serializable/dsl"
+
 module Pb
   module Serializable
     extend ActiveSupport::Concern
     include ComputedModel::Model
+
+    # @!parse extend Dsl
+    # @!parse extend ClassMethods
+
     def self.included(base)
-      base.extend ClassMethods
-      base.singleton_class.prepend Hook
+      base.include ComputedModelSupport
+      base.extend Dsl
     end
 
     # @param with [
     #   Google::Protobuf::FieldMask,
     #   Array<(Symbol, Hash)>,
-    #   Hash{Symbol=>(Array,Symbol,Hash)},
-    #   Pb::Serializer::NormalizedMask
-    # ]
+    #   Hash{Symbol=>(Array,Symbol,Hash,Proc)},
+    #   ]
+    #   Specifies the list of fields to be serialized in the Proto message object.
+    #   `nil` means that all fields defined in .proto will be serialized.
+    # @return [Object] a protobuf message object
     def to_pb(with: nil)
-      with ||= ::Pb::Serializer.build_default_mask(self.class.message_class.descriptor)
-      with = ::Pb::Serializer::NormalizedMask.build(with)
+      with ||= ::Pb::Serializer.build_default_mask(self.class.__pb_serializer_message_class.descriptor)
+      with = ::Pb::Serializer.normalize_mask(with)
 
       oneof_set = []
 
-      o = self.class.message_class.new
-      self.class.message_class.descriptor.each do |fd|
-        attr = self.class.find_attribute_by_field_descriptor(fd)
+      o = self.class.__pb_serializer_message_class.new
+      self.class.__pb_serializer_message_class.descriptor.each do |fd|
+        attr = self.class.__pb_serializer_attr_by_field_descriptor(fd)
 
         unless attr
-          msg = "#{self.class.message_class.name}.#{fd.name} is missed in #{self.class.name}"
+          msg = "#{self.class.__pb_serializer_message_class.name}.#{fd.name} is missed in #{self.class.name}"
 
           case Pb::Serializer.configuration.missing_field_behavior
           when :raise then raise ::Pb::Serializer::MissingFieldError, msg
@@ -62,7 +71,7 @@ module Pb
         end
       end
 
-      self.class.oneofs.each do |oneof|
+      self.class.__pb_serializer_oneof_by_name.values.each do |oneof|
         next if oneof_set.include?(oneof.name)
         next if oneof.allow_nil?
         raise ::Pb::Serializer::ValidationError, "#{primary_object.class.name}##{oneof.name} is required"
@@ -71,79 +80,7 @@ module Pb
       o
     end
 
-    private def primary_object
-      primary_object_name = self.class.__pb_serializer_primary_model_name
-      if primary_object_name
-        send(primary_object_name)
-      elsif kind_of?(Serializer::Base)
-        send(:object)
-      else
-        self
-      end
-    end
-
-    module Hook
-      def define_primary_loader(name)
-        self.__pb_serializer_primary_model_name = name
-
-        super
-      end
-
-      def computed(name)
-        __pb_serializer_attrs << name
-
-        super
-      end
-
-      def define_loader(name, **)
-        __pb_serializer_attrs << name
-
-        super
-      end
-    end
-
     module ClassMethods
-      attr_reader :message_class
-      attr_accessor :__pb_serializer_primary_model_name
-
-      def message(klass)
-        @message_class = klass
-      end
-
-      # @param name [Symbol] An attribute name
-      # @param [Hash] opts options
-      # @option opts [Boolean] :allow_nil Set true if this attribute allow to be nil
-      # @option opts [Class] :serializer A serializer class for this attribute
-      # @option opts [String, Symbol, Proc] :if A method, proc or string to call to determine to serialize this field
-      def attribute(name, opts = {})
-        raise ::Pb::Serializer::MissingMessageTypeError, "message specificaiton is missed" unless message_class
-
-        fd = message_class.descriptor.find { |fd| fd.name.to_sym == name }
-
-        raise ::Pb::Serializer::UnknownFieldError, "#{name} is not defined in #{message_class.name}" unless fd
-
-        attr = ::Pb::Serializer::Attribute.new(
-          name: name,
-          options: opts,
-          field_descriptor: fd,
-          oneof: @current_oneof&.name,
-        )
-
-        @attr_by_name ||= {}
-        @attr_by_name[name] = attr
-
-        define_method attr.name do
-          primary_object.public_send(attr.name)
-        end
-      end
-
-      # @param names [Array<Symbol>] Attribute names to be ignored
-      def ignore(*names)
-        names.each do |name|
-          attribute name, ignore: true
-        end
-      end
-
       # @param with [Array, Hash, Google::Protobuf::FieldMask, nil]
       # @return [Array]
       def bulk_load_and_serialize(with: nil, **args)
@@ -151,9 +88,9 @@ module Pb
       end
 
       def bulk_load(with: nil, **args)
-        with ||= ::Pb::Serializer.build_default_mask(message_class.descriptor)
-        with = ::Pb::Serializer::NormalizedMask.build(with)
-        with = with.reject { |c| (__pb_serializer_attrs & (c.kind_of?(Hash) ? c.keys : [c])).empty? }
+        with ||= ::Pb::Serializer.build_default_mask(__pb_serializer_message_class.descriptor)
+        with = ::Pb::Serializer.normalize_mask(with)
+        with = __pb_serializer_filter_only_computed_model_attrs(with)
 
         primary_object_name = __pb_serializer_primary_model_name
         if primary_object_name
@@ -165,30 +102,26 @@ module Pb
         bulk_load_and_compute(with, **args)
       end
 
-      def oneof(name, allow_nil: false)
-        @oneof_by_name ||= {}
-        @current_oneof = ::Pb::Serializer::Oneof.new(
-          name: name,
-          allow_nil: allow_nil,
-          attributes: [],
-        )
-        yield
-        @oneof_by_name[name] = @current_oneof
-        @current_oneof = nil
+      # @api private
+      attr_accessor :__pb_serializer_message_class
+
+      # @api private
+      # @return [Hash{Symbol=>::Pb::Serializer::Attribute}]
+      def __pb_serializer_attr_by_name
+        @__pb_serializer_attr_by_name ||= {}
       end
 
-      private def __pb_serializer_attrs
-        @__pb_serializer_attrs ||= Set.new
+      # @api private
+      # @return [Hash{Symbol=>::Pb::Serializer::Oneof}]
+      def __pb_serializer_oneof_by_name
+        @__pb_serializer_oneof_by_name ||= {}
       end
 
+      # @api private
       # @param fd [Google::Protobuf::FieldDescriptor] a field descriptor
       # @return [Pb::Serializer::Attribute, nil]
-      def find_attribute_by_field_descriptor(fd)
-        (@attr_by_name || {})[fd.name.to_sym]
-      end
-
-      def oneofs
-        @oneof_by_name&.values || []
+      def __pb_serializer_attr_by_field_descriptor(fd)
+        __pb_serializer_attr_by_name[fd.name.to_sym]
       end
     end
   end

data/lib/pb/serializer/base.rb

@@ -1,6 +1,8 @@
 module Pb
   module Serializer
     class Base
+      # @!parse include Pb::Serializable
+
       def self.inherited(base)
         base.include ::Pb::Serializable
         base.singleton_class.prepend Hook
@@ -12,6 +14,7 @@ module Pb
         @object = object
       end
 
+      # @private
       module Hook
         def define_primary_loader(name, &block)
           class_eval <<~RUBY

data/lib/pb/serializer/version.rb

@@ -1,5 +1,5 @@
 module Pb
   module Serializer
-    VERSION = "0.5.0".freeze
+    VERSION = "0.5.2".freeze
   end
 end

data/lib/pb/serializer.rb

@@ -4,10 +4,7 @@ require "computed_model"
 require "google/protobuf/field_mask_pb"
 
 require "pb/serializable"
-require "pb/serializer/normalized_mask"
 require "pb/serializer/base"
-require "pb/serializer/attribute"
-require "pb/serializer/oneof"
 
 module Pb
   module Serializer
@@ -34,6 +31,7 @@ module Pb
       end
 
       # @param v [:raise, :warn, :ignore]
+      # @return [void]
       def missing_field_behavior=(v)
         @missing_field_behavior = v
 
@@ -50,6 +48,7 @@ module Pb
       #   end
       # @yield [c]
       # @yieldparam [Configuration] config
+      # @return [void]
       def configure
         yield configuration
       end
@@ -64,7 +63,7 @@ module Pb
         configuration.logger
       end
 
-      # @param [Google::Protobuf::Descriptor]
+      # @param descriptor [Google::Protobuf::Descriptor]
       def build_default_mask(descriptor)
         set =
           descriptor.each_with_object(Set[]) do |fd, m|
@@ -82,7 +81,7 @@ module Pb
                 "google.protobuf.BoolValue"  ,
                 "google.protobuf.BytesValue" then m << fd.name.to_sym
               else
-                m << { fd.name.to_sym => build_default_mask(fd.subtype) }
+                m << { fd.name.to_sym => -> { build_default_mask(fd.subtype) } }
               end
             else
               m << fd.name.to_sym
@@ -90,6 +89,48 @@ module Pb
           end
         set.to_a
       end
+
+      # @param field_mask [Google::Protobuf::FieldMask]
+      # @return [Array]
+      def parse_field_mask(field_mask)
+        unless field_mask.kind_of?(Google::Protobuf::FieldMask)
+          raise ArgumentError, "expected Google::Protobuf::FieldMask, but got #{field_mask.class}"
+        end
+
+        field_mask.paths.map do |path|
+          path.split(".").reverse.inject(nil) { |h, key| h.nil? ? key.to_sym : { key.to_sym => [h].compact } }
+        end
+      end
+
+      # @param input [Google::Protobuf::FieldMask, Symbol, Array<(Symbol,Hash)>, Hash{Symbol=>(Array,Symbol,Hash,Proc)}, Proc]
+      # @return [Hash{Symbol=>(Array,Hash,Proc)}]
+      def normalize_mask(input)
+        if input.kind_of?(Google::Protobuf::FieldMask)
+          input = parse_field_mask(input)
+        end
+
+        input = input.call if input.kind_of?(Proc)
+        input = [input] if input.kind_of?(Hash)
+
+        normalized = {}
+        Array(input).each do |el|
+          case el
+          when Symbol
+            normalized[el] ||= []
+          when Hash
+            el.each do |k, v|
+              v = v.call if v.kind_of?(Proc)
+              v = [v] if v.kind_of?(Hash)
+              normalized[k] ||= []
+              normalized[k].push(*Array(v))
+            end
+          else
+            raise "not supported field mask type: #{input.class}"
+          end
+        end
+
+        normalized
+      end
     end
   end
 end

data/pb-serializer.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = "Serialize objects into Protocol Buffers messages"
   spec.description   = spec.summary
-  spec.homepage      = "https://github.com/izumin5210/pb-serializer"
+  spec.homepage      = "https://github.com/wantedly/pb-serializer"
   spec.license       = "MIT"
 
   spec.metadata["homepage_uri"] = spec.homepage
@@ -34,7 +34,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "activerecord", rails_versions
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "onkcop", "~> 0.53"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rubocop", "0.67.2" # for onkcop
   spec.add_development_dependency "sqlite3", "~> 1.4"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pb-serializer
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.2
 platform: ruby
 authors:
 - izumin5210
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-07-07 00:00:00.000000000 Z
+date: 2023-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf
@@ -106,14 +106,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -197,30 +197,34 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
+- ".yardopts"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
+- README.ja.md
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
 - codecov.yml
+- docs/examples.md
 - lib/pb/serializable.rb
+- lib/pb/serializable/computed_model_support.rb
+- lib/pb/serializable/dsl.rb
+- lib/pb/serializable/dsl/attribute.rb
+- lib/pb/serializable/dsl/oneof.rb
 - lib/pb/serializer.rb
-- lib/pb/serializer/attribute.rb
 - lib/pb/serializer/base.rb
-- lib/pb/serializer/normalized_mask.rb
-- lib/pb/serializer/oneof.rb
 - lib/pb/serializer/version.rb
 - pb-serializer.gemspec
-homepage: https://github.com/izumin5210/pb-serializer
+homepage: https://github.com/wantedly/pb-serializer
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/izumin5210/pb-serializer
-  source_code_uri: https://github.com/izumin5210/pb-serializer
-  changelog_uri: https://github.com/izumin5210/pb-serializer
+  homepage_uri: https://github.com/wantedly/pb-serializer
+  source_code_uri: https://github.com/wantedly/pb-serializer
+  changelog_uri: https://github.com/wantedly/pb-serializer
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -236,7 +240,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.33
 signing_key:
 specification_version: 4
 summary: Serialize objects into Protocol Buffers messages

data/lib/pb/serializer/attribute.rb

@@ -1,91 +0,0 @@
-module Pb
-  module Serializer
-    class Attribute < Struct.new(
-      :name,
-      :options,
-      :field_descriptor,
-      :oneof,
-      keyword_init: true,
-    )
-
-      ALLOWED_OPTIONS = Set[:allow_nil, :if, :serializer, :ignore].freeze
-
-      def initialize(options:, **)
-        super
-
-        unknown_options = options.keys.to_set - ALLOWED_OPTIONS
-        unless unknown_options.empty?
-          raise InvalidAttributeOptionError, "unknown options are specified in #{name} attribute: #{unknown_options.to_a}"
-        end
-      end
-
-      # @return [Boolean]
-      def allow_nil?
-        options.fetch(:allow_nil, false)
-      end
-
-      # @return [Class]
-      def serializer_class
-        options[:serializer]
-      end
-
-      # @return [Boolean]
-      def repeated?
-        field_descriptor.label == :repeated
-      end
-
-      # @return [Boolean]
-      def serializable?(s)
-        return false if options[:ignore]
-
-        cond = options[:if]
-
-        return true unless cond
-
-        case cond
-        when String, Symbol; then s.send(cond)
-        when Proc;           then s.instance_exec(&cond)
-        else raise InvalidAttributeOptionError, "`if` option can accept only Symbol, String or Proc. but got #{cond.class}"
-        end
-      end
-
-      def oneof?
-        !oneof.nil?
-      end
-
-      # @param v [Object]
-      # @param with [Pb::Serializer::NormalizedMask]
-      def convert_to_pb(v, with: nil, should_repeat: repeated?)
-        return nil if v.nil?
-        return v.map { |i| convert_to_pb(i, should_repeat: false, with: with) } if should_repeat
-
-        case field_descriptor.type
-        when :message
-          if v.class < Google::Protobuf::MessageExts && v.class.descriptor.name == field_descriptor.submsg_name
-            return v
-          end
-
-          case field_descriptor.submsg_name
-          when "google.protobuf.Timestamp"   then Pb.to_timestamp(v)
-          when "google.protobuf.StringValue" then Pb.to_strval(v)
-          when "google.protobuf.Int32Value"  then Pb.to_int32val(v)
-          when "google.protobuf.Int64Value"  then Pb.to_int64val(v)
-          when "google.protobuf.UInt32Value" then Pb.to_uint32val(v)
-          when "google.protobuf.UInt64Value" then Pb.to_uint64val(v)
-          when "google.protobuf.FloatValue"  then Pb.to_floatval(v)
-          when "google.protobuf.DoubleValue" then Pb.to_doubleval(v)
-          when "google.protobuf.BoolValue"   then Pb.to_boolval(v)
-          when "google.protobuf.BytesValue"  then Pb.to_bytesval(v)
-          else
-            return serializer_class.new(v).to_pb(with: with) if serializer_class
-            return v.to_pb(with: with) if v.kind_of?(::Pb::Serializable)
-
-            raise "serializer was not found for #{field_descriptor.submsg_name}"
-          end
-        else
-          v.nil? ? field_descriptor.default : v
-        end
-      end
-    end
-  end
-end

data/lib/pb/serializer/normalized_mask.rb

@@ -1,57 +0,0 @@
-module Pb::Serializer
-  class NormalizedMask < ::Hash
-    class << self
-      # @param [Google::Protobuf::FieldMask, Symbol, Array<(Symbol,Hash)>, Hash{Symbol=>(Array,Symbol,Hash)}]
-      # @return [Hash{Symbol=>Hash}]
-      def build(input)
-        return input if input.kind_of? self
-
-        normalized = new
-
-        case input
-        when Google::Protobuf::FieldMask
-          normalized = normalize_mask_paths(input.paths)
-        when Array
-          input.each do |v|
-            deep_merge!(normalized, build(v))
-          end
-        when Hash
-          input.each do |k, v|
-            normalized[k] ||= new
-            deep_merge!(normalized[k], build(v))
-          end
-        when Symbol
-          normalized[input] ||= new
-        else
-          raise "not supported field mask type: #{input.class}"
-        end
-
-        normalized
-      end
-
-      private
-
-      # @param [Array<String>]
-      # @return [Hash{Symbol=>Hash}]
-      def normalize_mask_paths(paths)
-        paths_by_key = {}
-
-        paths.each do |path|
-          key, rest = path.split('.', 2)
-          paths_by_key[key.to_sym] ||= []
-          paths_by_key[key.to_sym].push(rest) if rest && !rest.empty?
-        end
-
-        paths_by_key.keys.each_with_object(new) do |key, normalized|
-          normalized[key] = normalize_mask_paths(paths_by_key[key])
-        end
-      end
-
-      def deep_merge!(h1, h2)
-        h1.merge!(h2) do |_k, v1, v2|
-          deep_merge!(v1, v2)
-        end
-      end
-    end
-  end
-end

data/lib/pb/serializer/oneof.rb

@@ -1,15 +0,0 @@
-module Pb
-  module Serializer
-    class Oneof < Struct.new(
-      :name,
-      :allow_nil,
-      :attributes,
-      keyword_init: true,
-    )
-      # @return [Boolean]
-      def allow_nil?
-        allow_nil
-      end
-    end
-  end
-end