tapioca 0.4.20 → 0.4.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 567eff35f7ee24b52dafcd45ceb40ccaf042b6e0661c13cc5dcb87228c21c792
-  data.tar.gz: 0c5143d8407d5583ccd80edbb047fb0b7500b2de8bba1717723a92f97994c045
+  metadata.gz: 832665c6f2a41c3eb5cfda2b0939b4a3f2d29eb624b64de49565b8275f461326
+  data.tar.gz: 29e1f7066050ce4f308b1dc8591dd7de236e19560618a37c9120a4835ac1b295
 SHA512:
-  metadata.gz: d82321ab3b2516a4410825a6dfe4b253d7cccf49abc8c62db0b2a8cdbe13f064aa43df759108685ba06c36073c7a59cfda4ff361cdad1bfc736d7e557ae3ada6
-  data.tar.gz: 0b9bd1ff91ca97cbbb1922e9915a8d046421ff40f3cd2774b4518c979f44635507b48fcce93a904770b1a65e7214a9897ce5444ce26ee6d532523a595e24ec96
+  metadata.gz: a16a1125e343398d7a2190aea74ed2fafc3b9ad5d4aaac8a2b72ae4a75cd65bdb651dcf84528189eec39296eebb42382f847221651190e611f1c7260923653ba
+  data.tar.gz: d636730273b8eb9d828de5609b73c73cb677ec0cf372a1ae5d028604ec53422cbe3c607d557c0b4070dadf704c0023cef1dfb40d09ddb61327d7793db65a0ef0

data/lib/tapioca/compilers/dsl/protobuf.rb

@@ -62,33 +62,99 @@ module Tapioca
       # end
       # ~~~
       class Protobuf < Base
+        # Parlour doesn't support type members out of the box, so adding the
+        # ability to do that here. This should be upstreamed.
+        class TypeMember < Parlour::RbiGenerator::RbiObject
+          extend T::Sig
+
+          sig { params(other: Object).returns(T::Boolean) }
+          def ==(other)
+            TypeMember === other && name == other.name
+          end
+
+          sig do
+            override
+              .params(indent_level: Integer, options: Parlour::RbiGenerator::Options)
+              .returns(T::Array[String])
+          end
+          def generate_rbi(indent_level, options)
+            [options.indented(indent_level, "#{name} = type_member")]
+          end
+
+          sig do
+            override
+              .params(others: T::Array[Parlour::RbiGenerator::RbiObject])
+              .returns(T::Boolean)
+          end
+          def mergeable?(others)
+            others.all? { |other| self == other }
+          end
+
+          sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
+          def merge_into_self(others); end
+
+          sig { override.returns(String) }
+          def describe
+            "Type Member (#{name})"
+          end
+        end
+
+        class Field < T::Struct
+          prop :name, String
+          prop :type, String
+          prop :init_type, String
+          prop :default, String
+
+          extend T::Sig
+
+          sig { returns(Parlour::RbiGenerator::Parameter) }
+          def to_init
+            Parlour::RbiGenerator::Parameter.new("#{name}:", type: init_type, default: default)
+          end
+        end
+
         extend T::Sig
 
         sig do
           override.params(
             root: Parlour::RbiGenerator::Namespace,
-            constant: T.class_of(Google::Protobuf::MessageExts)
+            constant: Module
           ).void
         end
         def decorate(root, constant)
-          descriptor = T.let(T.unsafe(constant).descriptor, Google::Protobuf::Descriptor)
-          return unless descriptor.any?
-
           root.path(constant) do |klass|
-            descriptor.each do |desc|
-              create_descriptor_method(klass, desc)
+            if constant == Google::Protobuf::RepeatedField
+              create_type_members(klass, "Elem")
+            elsif constant == Google::Protobuf::Map
+              create_type_members(klass, "Key", "Value")
+            else
+              descriptor = T.let(T.unsafe(constant).descriptor, Google::Protobuf::Descriptor)
+              fields = descriptor.map { |desc| create_descriptor_method(klass, desc) }
+              fields.sort_by!(&:name)
+
+              create_method(klass, "initialize", parameters: fields.map!(&:to_init))
             end
           end
         end
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          classes = T.cast(ObjectSpace.each_object(Class), T::Enumerable[Class])
-          classes.select { |c| c < Google::Protobuf::MessageExts && !c.singleton_class? }
+          marker = Google::Protobuf::MessageExts::ClassMethods
+          results = T.cast(ObjectSpace.each_object(marker).to_a, T::Array[Module])
+          results.any? ? results + [Google::Protobuf::RepeatedField, Google::Protobuf::Map] : []
         end
 
         private
 
+        sig { params(klass: Parlour::RbiGenerator::Namespace, names: String).void }
+        def create_type_members(klass, *names)
+          klass.create_extend("T::Generic")
+
+          names.each do |name|
+            klass.children << TypeMember.new(klass.generator, name)
+          end
+        end
+
         sig do
           params(
             descriptor: Google::Protobuf::FieldDescriptor
@@ -113,30 +179,80 @@ module Tapioca
           end
         end
 
+        sig { params(descriptor: Google::Protobuf::FieldDescriptor).returns(Field) }
+        def field_of(descriptor)
+          if descriptor.label == :repeated
+            # Here we're going to check if the submsg_name is named according to
+            # how Google names map entries.
+            # https://github.com/protocolbuffers/protobuf/blob/f82e26/ruby/ext/google/protobuf_c/defs.c#L1963-L1966
+            if descriptor.submsg_name.to_s.end_with?("_MapEntry_#{descriptor.name}")
+              key = descriptor.subtype.lookup('key')
+              value = descriptor.subtype.lookup('value')
+
+              key_type = type_of(key)
+              value_type = type_of(value)
+              type = "Google::Protobuf::Map[#{key_type}, #{value_type}]"
+
+              default_args = [key.type.inspect, value.type.inspect]
+              default_args << value_type if %i[enum message].include?(value.type)
+
+              Field.new(
+                name: descriptor.name,
+                type: type,
+                init_type: "T.any(#{type}, T::Hash[#{key_type}, #{value_type}])",
+                default: "Google::Protobuf::Map.new(#{default_args.join(', ')})"
+              )
+            else
+              elem_type = type_of(descriptor)
+              type = "Google::Protobuf::RepeatedField[#{elem_type}]"
+
+              default_args = [descriptor.type.inspect]
+              default_args << elem_type if %i[enum message].include?(descriptor.type)
+
+              Field.new(
+                name: descriptor.name,
+                type: type,
+                init_type: "T.any(#{type}, T::Array[#{elem_type}])",
+                default: "Google::Protobuf::RepeatedField.new(#{default_args.join(', ')})"
+              )
+            end
+          else
+            type = type_of(descriptor)
+
+            Field.new(
+              name: descriptor.name,
+              type: type,
+              init_type: type,
+              default: "nil"
+            )
+          end
+        end
+
         sig do
           params(
             klass: Parlour::RbiGenerator::Namespace,
             desc: Google::Protobuf::FieldDescriptor,
-          ).void
+          ).returns(Field)
         end
         def create_descriptor_method(klass, desc)
-          name = desc.name
-          type = type_of(desc)
+          field = field_of(desc)
 
           create_method(
             klass,
-            name,
-            return_type: type
+            field.name,
+            return_type: field.type
           )
 
           create_method(
             klass,
-            "#{name}=",
+            "#{field.name}=",
             parameters: [
-              Parlour::RbiGenerator::Parameter.new("value", type: type),
+              Parlour::RbiGenerator::Parameter.new("value", type: field.type),
             ],
-            return_type: type
+            return_type: field.type
           )
+
+          field
         end
       end
     end

data/lib/tapioca/generator.rb

@@ -145,8 +145,6 @@ module Tapioca
         }
       )
 
-      constant_lookup = {}
-
       compiler.run do |constant, contents|
         constant_name = Module.instance_method(:name).bind(constant).call
 
@@ -159,13 +157,12 @@ module Tapioca
 
         if filename
           rbi_files_to_purge.delete(filename)
-          constant_lookup[filename.relative_path_from(outpath)] = constant_name
         end
       end
       say("")
 
       if should_verify
-        perform_dsl_verification(outpath, constant_lookup)
+        perform_dsl_verification(outpath)
       else
         purge_stale_dsl_rbi_files(rbi_files_to_purge)
 
@@ -596,17 +593,15 @@ module Tapioca
       end.sort
     end
 
-    sig { params(dir: Pathname, constant_lookup: T::Hash[String, String]).void }
-    def perform_dsl_verification(dir, constant_lookup)
+    sig { params(dir: Pathname).void }
+    def perform_dsl_verification(dir)
       diff = verify_dsl_rbi(tmp_dir: dir)
 
       if diff.empty?
         say("Nothing to do, all RBIs are up-to-date.")
       else
-        constants = T.unsafe(constant_lookup).values_at(*diff.keys).join(" ")
-
         say("RBI files are out-of-date, please run:")
-        say("  `#{Config::DEFAULT_COMMAND} dsl #{constants}`")
+        say("  `#{Config::DEFAULT_COMMAND} dsl`")
 
         say("")
 

data/lib/tapioca/generic_type_registry.rb

@@ -100,7 +100,7 @@ module Tapioca
           # the generic class `Foo[Bar]` is still a `Foo`. That is:
           # `Foo[Bar].new.is_a?(Foo)` should be true, which isn't the case
           # if we just clone the class. But subclassing works just fine.
-          create_sealed_safe_subclass(constant)
+          create_safe_subclass(constant)
         else
           # This can only be a module and it is fine to just clone modules
           # since they can't have instances and will not have `is_a?` relationships.
@@ -151,28 +151,31 @@ module Tapioca
       end
 
       sig { params(constant: Class).returns(Class) }
-      def create_sealed_safe_subclass(constant)
-        # If the constant is not sealed let's just bail early.
-        # We just return a subclass of the constant.
-        return Class.new(constant) unless T::Private::Sealed.sealed_module?(constant)
-
-        # Since sealed classes can normally not be subclassed, we need to trick
-        # sealed classes into thinking that the generic type we are
-        # creating by subclassing is actually safe for sealed types.
-        #
-        # Get the filename the sealed class was declared in
-        decl_file = constant.instance_variable_get(:@sorbet_sealed_module_decl_file)
+      def create_safe_subclass(constant)
+        # Lookup the "inherited" class method
+        inherited_method = constant.method(:inherited)
+        # and the module that defines it
+        owner = inherited_method.owner
+
+        # If no one has overriden the inherited method yet, just subclass
+        return Class.new(constant) if Class == owner
+
         begin
-          # Clear the current declaration filename on the class
-          constant.remove_instance_variable(:@sorbet_sealed_module_decl_file)
-          # Make this file be the declaration filename so that Sorbet runtime
-          # does not shout at us for an invalid subclassing.
-          T.cast(constant, T::Helpers).sealed!
+          # Otherwise, some inherited method could be preventing us
+          # from creating subclasses, so let's override it and rescue
+          owner.send(:define_method, :inherited) do |s|
+            begin
+              inherited_method.call(s)
+            rescue
+              # Ignoring errors
+            end
+          end
+
           # return a subclass
           Class.new(constant)
         ensure
-          # Reinstate the original declaration filename
-          constant.instance_variable_set(:@sorbet_sealed_module_decl_file, decl_file)
+          # Reinstate the original inherited method back.
+          owner.send(:define_method, :inherited, inherited_method)
         end
       end
 

data/lib/tapioca/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Tapioca
-  VERSION = "0.4.20"
+  VERSION = "0.4.21"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.4.20
+  version: 0.4.21
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-04-01 00:00:00.000000000 Z
+date: 2021-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler