pb-serializer 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b46a686595d5e9e919c21ff7e6902cec71be97d716085dc38b8b2ef0192e7cf1
-  data.tar.gz: c453986c407e5e567bce43f3f45429697c552dedc44356ffee2a8e0b4d5eaea7
+  metadata.gz: db5867da46505d0facc08d12c1d6a3c93a87d7ca617110e8a9f2265444df72db
+  data.tar.gz: 594549370135b3237cbdfc2e701554eafa89c87fababd5b64e33476ed2ce11b2
 SHA512:
-  metadata.gz: c58c5ab0714bd7bee52f3f30ede95b676b849cdf0be482a9de0187287d3ecfd0e758b6cc7c17831965d7e8e54fc13763c6290607330077c3a2135c6fe9cfd439
-  data.tar.gz: 7b3cc2224f7550c72714cc21c1e656182891788b1f0aa67b02dce177ea44cb6dfef5115073aeb08eb130fe40decc15551e73bbb2aa6ec77c0fc997e8fbf3477f
+  metadata.gz: d40d26a27feb02d827068be43c3c93f44146cc7a2314047684bd7290cab34beee1e5930fd9d000922ad768fc00fcd7f544e530a85cf5267f7913a8f7e7f3fe4c
+  data.tar.gz: 7f2e1f146b3f5f466b1d3886b60e70ccc6505a919c7b8ef8c2a8498b2182b441a5695318b27e028f5f4943cdf39ea7f650ddc53370d475ea1385e5e4363dd48b

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## 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

data/lib/pb/serializable.rb

@@ -2,20 +2,20 @@ module Pb
   module Serializable
     extend ActiveSupport::Concern
     include ComputedModel::Model
+
     def self.included(base)
-      base.extend ClassMethods
-      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)},
-    #   Pb::Serializer::NormalizedMask
     # ]
     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.normalize_mask(with)
 
       oneof_set = []
 
@@ -71,79 +71,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)
@@ -152,8 +80,8 @@ module Pb
 
       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.normalize_mask(with)
+        with = __pb_serializer_filter_only_computed_model_attrs(with)
 
         primary_object_name = __pb_serializer_primary_model_name
         if primary_object_name
@@ -164,32 +92,6 @@ 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
-      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

@@ -3,8 +3,9 @@ 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/normalized_mask"
 require "pb/serializer/base"
 require "pb/serializer/attribute"
 require "pb/serializer/oneof"
@@ -90,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

@@ -54,7 +54,7 @@ module Pb
       end
 
       # @param v [Object]
-      # @param with [Pb::Serializer::NormalizedMask]
+      # @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

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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pb-serializer
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - izumin5210
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-07-07 00:00:00.000000000 Z
+date: 2021-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf
@@ -210,7 +210,8 @@ files:
 - lib/pb/serializer.rb
 - lib/pb/serializer/attribute.rb
 - lib/pb/serializer/base.rb
-- lib/pb/serializer/normalized_mask.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

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