pb-serializer 0.2.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d65ab2cd7830751ed61e5cd72eca1d688fac910b544167994780d065e55fa3b
-  data.tar.gz: e991534beffa6fb92b4c23f05bf59b5ba0ef6872cd34dc801148e08ec3f2c075
+  metadata.gz: db5867da46505d0facc08d12c1d6a3c93a87d7ca617110e8a9f2265444df72db
+  data.tar.gz: 594549370135b3237cbdfc2e701554eafa89c87fababd5b64e33476ed2ce11b2
 SHA512:
-  metadata.gz: 0a138f78df718b226cbf65cef851380a941c34306ed80bdc2fb65093f0dec804515d0187d3f0b11e4fcd36bbc339dfca08f2beef49989d6417ccf157ddf9da97
-  data.tar.gz: bf343a1d3f7f055370f652616fc6914dc682f2fdc6840c6975614537d5ecf02241974b8df986505f96a517401b676e0756aa2040d181898e8dc866ee76ab305c
+  metadata.gz: d40d26a27feb02d827068be43c3c93f44146cc7a2314047684bd7290cab34beee1e5930fd9d000922ad768fc00fcd7f544e530a85cf5267f7913a8f7e7f3fe4c
+  data.tar.gz: 7f2e1f146b3f5f466b1d3886b60e70ccc6505a919c7b8ef8c2a8498b2182b441a5695318b27e028f5f4943cdf39ea7f650ddc53370d475ea1385e5e4363dd48b

data/.github/workflows/ci.yml

@@ -9,8 +9,10 @@ jobs:
       fail-fast: false
       matrix:
         os: [ ubuntu-latest, macos-latest ]
-        # ruby: [ 2.5, 2.6, 2.7 ] # TODO: Wait for supporting Ruby 2.7 in google-protobuf
-        ruby: [ 2.5, 2.6 ]
+        # TODO: Wait for supporting Ruby 3.0 in simplecov-cobertura.
+        # See https://github.com/dashingrocket/simplecov-cobertura/pull/16
+        # ruby: [ 2.5, 2.6, 2.7, 3.0 ]
+        ruby: [ 2.5, 2.6, 2.7 ]
     runs-on: ${{ matrix.os }}
 
     steps:
@@ -30,3 +32,9 @@ jobs:
     - run: bundle install --jobs 4 --retry 3
 
     - run: bundle exec rspec
+      env:
+        CI: true
+
+    - uses: codecov/codecov-action@v1
+      with:
+        file: ./coverage/coverage.xml

data/.github/workflows/review.yml

@@ -15,11 +15,9 @@ jobs:
         sudo apt-get update
         sudo apt-get install libsqlite3-dev
 
-    - name: Setup reviewdog
-      run: |
-        mkdir -p $HOME/bin
-        curl -sfL https://raw.githubusercontent.com/reviewdog/reviewdog/master/install.sh | sh -s -- -b $HOME/bin
-        echo ::add-path::$HOME/bin
+    - uses: reviewdog/action-setup@v1
+      with:
+        reviewdog_version: latest
 
     - run: gem install bundler -v 2.1.4
 
@@ -28,6 +26,8 @@ jobs:
     - run: bundle install --jobs 4 --retry 3
 
     - name: Run Rubocop with Reviewdog
+      env:
+        REVIEWDOG_GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       run: |
         bundle exec rubocop --fail-level E \
           | reviewdog -f=rubocop -reporter=github-pr-review

data/CHANGELOG.md

@@ -0,0 +1,50 @@
+## Unreleased
+
+## 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
+
+## 0.4.0
+
+- Make `#initialize` extensible used with `define_primary_loader` https://github.com/wantedly/pb-serializer/pull/31
+- Supoprt `ignore` directive https://github.com/wantedly/pb-serializer/pull/36
+- Support field mask https://github.com/wantedly/pb-serializer/pull/34
+
+## 0.3.0
+
+- Support `if` option https://github.com/wantedly/pb-serializer/pull/24
+- Improve error handling https://github.com/wantedly/pb-serializer/pull/26
+    - raise `MissingMessageTypeError` if `message` declaration is missed
+    - raise `MissingFieldError` if `attribute` declaration is missed
+    - raise `InvalidOptionError` when `attribute` receives invalid params
+- Introduce Pb::Serializer.configure https://github.com/wantedly/pb-serializer/pull/27
+    - Add `missing_field_behavior` config to suppress `MissingFieldError`
+    - Rename `InvalidOptionError` -> `InvalidAttributeOptionError`
+- Skip serializing when a value is already serialized https://github.com/wantedly/pb-serializer/pull/29
+
+
+## 0.2.1
+
+- **BREAKING CHANGE** `required` -> `allow_nil` https://github.com/wantedly/pb-serializer/pull/21
+- Make Serializer's constructors extensible https://github.com/wantedly/pb-serializer/pull/22
+
+## 0.2.0
+
+- **BREAKING CHANGE** https://github.com/wantedly/pb-serializer/pull/17
+  - Support loading and serializing arrays
+  - Bump `computed_model` from 0.1.0 to 0.2.1
+  - Change API
+- Add example specs https://github.com/wantedly/pb-serializer/pull/18
+
+
+## 0.1.0
+
+Initial release.

data/README.md

@@ -1,12 +1,16 @@
 # Pb::Serializer
+[![CI](https://github.com/wantedly/pb-serializer/workflows/CI/badge.svg?branch=master)](https://github.com/wantedly/pb-serializer/actions?query=workflow%3ACI+branch%3Amaster)
+[![codecov](https://codecov.io/gh/wantedly/pb-serializer/branch/master/graph/badge.svg)](https://codecov.io/gh/wantedly/pb-serializer)
+[![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
 
-  attribute :id,    required: true
-  attribute :name,  required: true
-  attribute :posts, required: true
+  attribute :id
+  attribute :name
+  attribute :posts
 
   define_primary_loader :user do |subdeps, ids:, **|
     User.where(id: ids).preload(subdeps).map { |u| new(u) }
@@ -29,9 +33,9 @@ class PostSerializer < Pb::Serializer::Base
     Post.where(user_id: user_ids).preload(subdeps).map { |p| new(p) }
   end
 
-  attribute :id,    required: true
-  attribute :title, required: true
-  attribute :body,  required: true
+  attribute :id
+  attribute :title
+  attribute :body
 end
 
 class UserGrpcService < YourApp::UserService::Service

data/codecov.yml

@@ -0,0 +1,6 @@
+coverage:
+  status:
+    project:
+      default:
+        target: 95%
+    patch: off

data/lib/pb/serializable.rb

@@ -1,13 +1,21 @@
 module Pb
   module Serializable
+    extend ActiveSupport::Concern
+    include ComputedModel::Model
+
     def self.included(base)
-      base.extend ClassMethods
-      base.include ComputedModel
-      base.singleton_class.prepend Hook
+      base.include Pb::Serializer::ComputedModelSupport
+      base.extend Pb::Serializer::Dsl
     end
 
+    # @param with [
+    #   Google::Protobuf::FieldMask,
+    #   Array<(Symbol, Hash)>,
+    #   Hash{Symbol=>(Array,Symbol,Hash)},
+    # ]
     def to_pb(with: nil)
-      # TODO: apply masks
+      with ||= ::Pb::Serializer.build_default_mask(self.class.message_class.descriptor)
+      with = ::Pb::Serializer.normalize_mask(with)
 
       oneof_set = []
 
@@ -15,26 +23,38 @@ module Pb
       self.class.message_class.descriptor.each do |fd|
         attr = self.class.find_attribute_by_field_descriptor(fd)
 
-        next unless attr # TODO
+        unless attr
+          msg = "#{self.class.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
+          when :warn  then Pb::Serializer.logger.warn msg
+          end
+
+          next
+        end
+
+        next unless with.key?(attr.name)
+        next unless attr.serializable?(self)
 
         raise "#{self.name}.#{attr.name} is not defined" unless respond_to?(attr.name)
 
         v = public_send(attr.name)
-        v = attr.convert_to_pb(v)
+        v = attr.convert_to_pb(v, with: with[attr.name])
 
-        if attr.required && attr.field_descriptor.default == v
+        if attr.oneof?
+          if !v.nil?
+            if oneof_set.include?(attr.oneof)
+              raise ::Pb::Serializer::ConflictOneofError, "#{primary_object.class.name}##{attr.name} is oneof attribute"
+            end
+            oneof_set << attr.oneof
+          end
+        elsif !attr.allow_nil? && v.nil?
           raise ::Pb::Serializer::ValidationError, "#{primary_object.class.name}##{attr.name} is required"
         end
 
         next if v.nil?
 
-        if attr.oneof?
-          if oneof_set.include?(attr.oneof)
-            raise ::Pb::Serializer::ConflictOneofError, "#{primary_object.class.name}##{attr.name} is oneof attribute"
-          end
-          oneof_set << attr.oneof
-        end
-
         if attr.repeated?
           o.public_send(attr.name).push(*v)
         else
@@ -44,76 +64,15 @@ module Pb
 
       self.class.oneofs.each do |oneof|
         next if oneof_set.include?(oneof.name)
-        next unless oneof.required?
+        next if oneof.allow_nil?
         raise ::Pb::Serializer::ValidationError, "#{primary_object.class.name}##{oneof.name} is required"
       end
 
       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 required [Boolean] Set true if this attribute should not zero-value
-      # @param serializer [Class] A serializer class for this attribute
-      def attribute(name, required: false, serializer: nil)
-        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,
-          required: required,
-          serializer_class: serializer,
-          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 with [Array, Google::Protobuf::FieldMask, nil]
+      # @param with [Array, Hash, Google::Protobuf::FieldMask, nil]
       # @return [Array]
       def bulk_load_and_serialize(with: nil, **args)
         bulk_load(with: with, **args).map { |s| s.to_pb(with: with) }
@@ -121,36 +80,18 @@ module Pb
 
       def bulk_load(with: nil, **args)
         with ||= ::Pb::Serializer.build_default_mask(message_class.descriptor)
-        with = with.reject { |c| (__pb_serializer_attrs & (c.kind_of?(Hash) ? c.keys : [c])).empty? }
+        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
+          (with[primary_object_name] ||= []) << true
+        elsif self < Serializer::Base
+          (with[:object] ||= []) << true
+        end
 
         bulk_load_and_compute(with, **args)
       end
-
-      def oneof(name, required: true)
-        @oneof_by_name ||= {}
-        @current_oneof = ::Pb::Serializer::Oneof.new(
-          name: name,
-          required: required,
-          attributes: [],
-        )
-        yield
-        @oneof_by_name[name] = @current_oneof
-        @current_oneof = nil
-      end
-
-      private def __pb_serializer_attrs
-        @__pb_serializer_attrs ||= Set.new
-      end
-
-      # @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 || []
-      end
     end
   end
 end

data/lib/pb/serializer.rb

@@ -1,7 +1,10 @@
 require "pb/serializer/version"
 require "the_pb"
 require "computed_model"
+require "google/protobuf/field_mask_pb"
 
+require "pb/serializer/dsl"
+require "pb/serializer/computed_model_support"
 require "pb/serializable"
 require "pb/serializer/base"
 require "pb/serializer/attribute"
@@ -10,11 +13,58 @@ require "pb/serializer/oneof"
 module Pb
   module Serializer
     class Error < StandardError; end
+    class InvalidConfigurationError < Error; end
+    class MissingMessageTypeError < Error; end
     class UnknownFieldError < Error; end
     class ValidationError < Error; end
     class ConflictOneofError < Error; end
+    class InvalidAttributeOptionError < Error; end
+    class MissingFieldError < Error; end
+
+    class Configuration
+      # @!attribute logger
+      #   @return [Logger]
+      attr_accessor :logger
+      # @!attribute [r] missing_field_behavior
+      #   @return [:raise, :warn, :ignore] default: `:raise`
+      attr_reader :missing_field_behavior
+
+      def initialize
+        self.missing_field_behavior = :raise
+        self.logger = Logger.new(STDOUT)
+      end
+
+      # @param v [:raise, :warn, :ignore]
+      def missing_field_behavior=(v)
+        @missing_field_behavior = v
+
+        unless %i(raise warn ignore).include?(v)
+          raise InvalidConfigurationError, "missing_field_behavior #{v} is not allowed"
+        end
+      end
+    end
 
     class << self
+      # @example
+      #   Pb::Serializer.configuration do |c|
+      #     c.missing_field_behavior = :raise  # :raise, :warn or :ignore (defualt: :raise)
+      #   end
+      # @yield [c]
+      # @yieldparam [Configuration] config
+      def configure
+        yield configuration
+      end
+
+      # @return [Pb::Serializer::Configuration]
+      def configuration
+        @configuraiton ||= Configuration.new
+      end
+
+      # @return [Logger]
+      def logger
+        configuration.logger
+      end
+
       # @param [Google::Protobuf::Descriptor]
       def build_default_mask(descriptor)
         set =
@@ -41,6 +91,46 @@ module Pb
           end
         set.to_a
       end
+
+      # @param [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 [Google::Protobuf::FieldMask, Symbol, Array<(Symbol,Hash)>, Hash{Symbol=>(Array,Symbol,Hash)}]
+      # @return [Hash{Symbol=>(Array,Hash)}]
+      def normalize_mask(input)
+        if input.kind_of?(Google::Protobuf::FieldMask)
+          input = parse_field_mask(input)
+        end
+
+        normalized = {}
+
+        input = [input] if input.kind_of?(Hash)
+        Array(input).each do |el|
+          case el
+          when Symbol
+            normalized[el] ||= []
+          when Hash
+            el.each do |k, v|
+              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/lib/pb/serializer/attribute.rb

@@ -2,16 +2,31 @@ module Pb
   module Serializer
     class Attribute < Struct.new(
       :name,
-      :required,
-      :serializer_class,
+      :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 required?
-        required
+      def allow_nil?
+        options.fetch(:allow_nil, false)
+      end
+
+      # @return [Class]
+      def serializer_class
+        options[:serializer]
       end
 
       # @return [Boolean]
@@ -19,16 +34,37 @@ module Pb
         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]
-      def convert_to_pb(v, should_repeat: repeated?)
-        return v.map { |i| convert_to_pb(i, should_repeat: false) } if should_repeat
+      # @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)
@@ -41,9 +77,8 @@ module Pb
           when "google.protobuf.BoolValue"   then Pb.to_boolval(v)
           when "google.protobuf.BytesValue"  then Pb.to_bytesval(v)
           else
-            return nil if v.nil?
-            return serializer_class.new(v).to_pb if serializer_class
-            return v.to_pb if v.kind_of?(::Pb::Serializable)
+            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

data/lib/pb/serializer/base.rb

@@ -8,16 +8,21 @@ module Pb
 
       attr_reader :object
 
-      def initialize(object)
+      def initialize(object, *)
         @object = object
       end
 
       module Hook
         def define_primary_loader(name, &block)
           class_eval <<~RUBY
-            def initialize(object)
-              @#{name} = object
+            module PbSerializerDefinePrimaryLoaderPrependMethods
+              def initialize(*args)
+                super
+                @#{name} = object
+              end
             end
+
+            prepend PbSerializerDefinePrimaryLoaderPrependMethods
           RUBY
 
           super

data/lib/pb/serializer/computed_model_support.rb

@@ -0,0 +1,51 @@
+module Pb
+  module Serializer
+    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/serializer/dsl.rb

@@ -0,0 +1,69 @@
+module Pb
+  module Serializer
+    module Dsl
+      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
+
+        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
+      def ignore(*names)
+        names.each do |name|
+          attribute name, ignore: true
+        end
+      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
+      end
+
+      attr_reader :message_class
+
+      # @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 || []
+      end
+    end
+  end
+end

data/lib/pb/serializer/oneof.rb

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

data/lib/pb/serializer/version.rb

@@ -1,5 +1,5 @@
 module Pb
   module Serializer
-    VERSION = "0.2.0".freeze
+    VERSION = "0.5.1".freeze
   end
 end

data/pb-serializer.gemspec

@@ -29,7 +29,7 @@ Gem::Specification.new do |spec|
   rails_versions = [">= 5.2", "< 6.1"]
   spec.add_runtime_dependency "google-protobuf", "~> 3.0"
   spec.add_runtime_dependency "the_pb", "~> 0.0.1"
-  spec.add_runtime_dependency "computed_model", "~> 0.2.1"
+  spec.add_runtime_dependency "computed_model", "~> 0.3.0"
 
   spec.add_development_dependency "activerecord", rails_versions
   spec.add_development_dependency "bundler", "~> 2.0"
@@ -38,4 +38,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rubocop", "0.67.2" # for onkcop
   spec.add_development_dependency "sqlite3", "~> 1.4"
+  spec.add_development_dependency "simplecov", "~> 0.18.5"
+  spec.add_development_dependency "simplecov-cobertura", "~> 1.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pb-serializer
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.5.1
 platform: ruby
 authors:
 - izumin5210
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-03-29 00:00:00.000000000 Z
+date: 2021-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.3.0
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -156,6 +156,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.18.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.18.5
+- !ruby/object:Gem::Dependency
+  name: simplecov-cobertura
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 description: Serialize objects into Protocol Buffers messages
 email:
 - m@izum.in
@@ -169,6 +197,7 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -176,10 +205,13 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- codecov.yml
 - lib/pb/serializable.rb
 - lib/pb/serializer.rb
 - lib/pb/serializer/attribute.rb
 - lib/pb/serializer/base.rb
+- lib/pb/serializer/computed_model_support.rb
+- lib/pb/serializer/dsl.rb
 - lib/pb/serializer/oneof.rb
 - lib/pb/serializer/version.rb
 - pb-serializer.gemspec
@@ -190,7 +222,7 @@ 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
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -205,8 +237,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: Serialize objects into Protocol Buffers messages
 test_files: []