rbs_protobuf 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36689cc81f238ec33c07f1485ab4ff50f73fe365c1e84fcb925d34b0159859d3
-  data.tar.gz: a149120654ab2387721383d723bf3c54923385a66feff3a755ebce1056bf014c
+  metadata.gz: bcaf6201c92331c28b9fa7d1791711def79ccb4803d81692a220b60d08e640a6
+  data.tar.gz: 93651dffc7e86d657f5ed5298b3ab43042a7e663fd07a502b25fe968ede6cef2
 SHA512:
-  metadata.gz: f2bc3a51198e70d9617edf6df9c40e9fbfbac8061d3b849d6cf2ec21b839bd379bea6bf94d5a63dc134af173c773338f7b937b53597906e1bb3e85dd6c965c3c
-  data.tar.gz: 349c294046f6c7665dad74a0461311bf4c7edb58d9c8f804bd70b6c6ed11442d295086a59b9990465d478195c87c96e54180237e8fdd1a73c202e48ffde73b60
+  metadata.gz: '09835d51dd74b278a376dc721bbde2527f6e501596dd5239b29a0da5aa96af69cfc08831e2dafc7b6ac67491ef3e5c35b2ec2dca536fbc66864291b3a2109e6a'
+  data.tar.gz: 42b4c2d53a767f7b8732f8d4ee7a74d724ba334280cf006326a1ebfcd5f1dc4031d44404d149ee63e8c66f46da5dee2f519eaa6539d7789fb8b9b5e5a9dfb863

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # CHANGELOG
 
+## 1.2.0 (2023-09-06)
+
+* Add `RBS_PROTOBUF_CONCAT_LEVEL` option ([#38](https://github.com/square/rbs_protobuf/pull/38))
+* Generate rpc method types and interfaces ([#37](https://github.com/square/rbs_protobuf/pull/37))
+* Generate `record` type of each proto message ([#36](https://github.com/square/rbs_protobuf/pull/36))
+* Add filter ([#34](https://github.com/square/rbs_protobuf/pull/34))
+
 ## 1.1.0 (2023-08-16)
 
 * Support optional fields in proto3 ([\#32](https://github.com/square/rbs_protobuf/pull/32))

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    rbs_protobuf (1.1.0)
+    rbs_protobuf (1.2.0)
       activesupport (>= 4.0)
       rbs (>= 2.2.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (7.0.7)
+    activesupport (7.0.7.2)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)

data/README.md

@@ -82,21 +82,6 @@ Run `protoc` with `--rbs_out` option.
 
 You may need `bundle exec protoc ...` to let bundler set up PATH.
 
-## Type checking
-
-To type check the output, you need to configure your tools to import [gem_rbs_collection](https://github.com/ruby/gem_rbs_collection) with `rbs collection` command.
-
-```yaml
-# Add the dependency in rbs_collection.yaml
-gems:
-  - name: rbs_protobuf
-```
-
-We assume that you don't type check the generated `.pb.rb` code.
-If you want to type check them, you need the definition of `Google::Protobuf`, which can be generated from [`descriptor.proto`](https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/descriptor.proto).
-
-Note: `rbs_protobuf` generates RBS files assuming some types added in [this PR](https://github.com/ruby/gem_rbs_collection/pull/145). Make sure you are using one of the newer versions of `rbs_gem_collection` definitions.
-
 ### Options
 
 * `RBS_PROTOBUF_BACKEND` specifies the Ruby code generator gem. Supported value is `protobuf`. (We will add `google-protobuf` for `google-protobuf` gem.)
@@ -104,6 +89,20 @@ Note: `rbs_protobuf` generates RBS files assuming some types added in [this PR](
 * `RBS_PROTOBUF_NO_NESTED_NAMESPACE` is to make the RBS declarations flat.
 * `RBS_PROTOBUF_EXTENSION` specifies what to do for extensions.
 * `RBS_PROTOBUF_ACCEPT_NIL_ATTR_WRITER` is to allow passing `nil` to required fields.
+* `RBS_PROTOBUF_FILTERS` contains filter Ruby script paths separated by `File::PATH_SEPARATOR`
+* `RBS_PROTOBUF_CONCAT_LEVEL` contains the number of dir levels that groups generated RBS files to concat
+
+## Type checking
+
+To type check the output, make sure your type checker configuration loads type definitions of `protobuf` gem.
+
+```ruby
+# Declare in Gemfile and load it with rbs-collection
+gem 'protobuf'
+```
+
+We assume that you don't type check the generated `.pb.rb` code.
+If you want to type check them, you need the definition of `Google::Protobuf`, which can be generated from [`descriptor.proto`](https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/descriptor.proto).
 
 ## Supported features
 
@@ -118,7 +117,7 @@ Note: `rbs_protobuf` generates RBS files assuming some types added in [this PR](
 | Services                | Only generates classes     |
 | Oneof                   | No support in `protobuf` gem |
 
-### Extensions
+## Extensions
 
 Adding extensions may cause problems if the name of new attribute conflicts.
 
@@ -144,6 +143,27 @@ You can control the behavior with `RBS_PROTOBUF_EXTENSION` environment variable.
 * Any value else: Generates RBS for extensions.
 * undefined: Ignores extensions but print messages to ask you to specify a value.
 
+## Filters
+
+You can apply filters that modifies generated RBS files.
+
+A filter is a proc object with type of `^(String rbs_name, String rbs_content, untyped proto_file) -> [String, String]`:
+It receives the file name of RBS file, the content of RBS file, the source protobuf object, and returns a pair of RBS file name and content.
+
+```ruby
+# example_fitler.rb: It adds a warning comment at the top of the RBS content.
+->(rbs_name, rbs_content, _proto_file) {
+  [
+    rbs_name,
+    "# Don't modify this file. This is generated with rbs_protobuf.\n\n" + rbs_content
+  ]
+}
+```
+
+You can apply filters by setting `RBS_PROTOBUF_FILTERS` environment variable.
+
+    $ RBS_PROTOBUF_BACKEND=protobuf RBS_PROTOBUF_FILTERS=example_filter.rb protoc ...
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test example:typecheck` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/bin/setup

@@ -9,13 +9,4 @@ echo ">>> Checking if protoc is available... 👀"
 protoc --version
 
 echo ">>> Setting up gem_rbs_collection... 💎"
-REPODIR=$(cd $(dirname $0)/..; pwd)/tmp/rbs/gem_rbs_collection
-if [ -e $REPODIR ]; then
-  echo "      ${REPODIR} exists"
-else
-  echo "      Cloning git repo into ${REPODIR}..."
-  mkdir -p $REPODIR/..
-  git clone https://github.com/ruby/gem_rbs_collection.git ${REPODIR}
-fi
-
 bundle exec rbs collection install

data/exe/protoc-gen-rbs

@@ -13,6 +13,20 @@ unless backend
   exit 1
 end
 
+filters = []
+
+if string = ENV["RBS_PROTOBUF_FILTERS"]
+  string.split(File::PATH_SEPARATOR).each do |file|
+    filter = Module.new.instance_eval(File.read(file), file)
+
+    if filter.respond_to?(:call)
+      filters << filter
+    else
+      raise "A filter `#{file}` returns `#{filter.inspect}`, but a proc object of type `^(String rbs_name, String rbs_content, untyped proto_file) -> [String, String]` is expected"
+    end
+  end
+end
+
 input = Google::Protobuf::Compiler::CodeGeneratorRequest.decode(STDIN.read)
 
 translator = case backend
@@ -34,6 +48,7 @@ translator = case backend
 
                RBSProtobuf::Translator::ProtobufGem.new(
                  input,
+                 filters,
                  upcase_enum: upcase_enum,
                  nested_namespace: !no_nested_namespace,
                  extension: extension,
@@ -43,6 +58,9 @@ translator = case backend
                raise NotImplementedError
              end
 
+if level = ENV["RBS_PROTOBUF_CONCAT_LEVEL"]
+  translator.rbs_concat_level = level.to_i
+end
 translator.generate_rbs!
 
 response = translator.response

data/lib/rbs_protobuf/rbs_factory.rb

@@ -46,6 +46,7 @@ module RBSProtobuf
     end
 
     def union_type(type, *types)
+      types = types.compact
       if types.empty?
         type
       else

data/lib/rbs_protobuf/translator/base.rb

@@ -3,10 +3,19 @@ module RBSProtobuf
     class Base
       FieldDescriptorProto = Google::Protobuf::FieldDescriptorProto
 
-      attr_reader :input
+      attr_reader :input, :filters
 
-      def initialize(input)
+      attr_accessor :rbs_concat_level
+
+      def initialize(input, filters = [])
         @input = input
+        @filters = filters
+      end
+
+      def apply_filter(rbs_name, rbs_content, proto_files)
+        filters.inject([rbs_name, rbs_content]) do |(rbs_name, rbs_content), filter| #$ [String, String]
+          filter[rbs_name, rbs_content, proto_files] or return
+        end
       end
 
       def factory
@@ -18,14 +27,61 @@ module RBSProtobuf
       end
 
       def generate_rbs!
+        rbs_decls = {} #: Hash[Pathname, [Array[RBS::AST::Declarations::t], untyped]]
+
         input.proto_file.each do |file|
-          response.file << Google::Protobuf::Compiler::CodeGeneratorResponse::File.new(
-            name: rbs_name(file.name),
-            content: rbs_content(file)
-          )
+          path = Pathname(file.name).sub_ext(".rbs")
+          decls = rbs_content(file)
+          rbs_decls[path] = [decls, file]
+        end
+
+        rbs_contents = {} #: Hash[Pathname, [String, Array[untyped]]]
+
+        if (level = rbs_concat_level)&.nonzero?
+          groups = rbs_decls.each_key.group_by do |path|
+            path.sub_ext("").to_s.split(File::SEPARATOR).take(level).join(File::SEPARATOR)
+          end
+
+          groups.each do |prefix, paths|
+            path = Pathname(prefix).sub_ext(".rbs")
+
+            decls = [] #: Array[RBS::AST::Declarations::t]
+            files = [] #: Array[untyped]
+
+            paths.each do |path|
+              ds, file = rbs_decls.fetch(path)
+              decls.concat(ds)
+              files.push(file)
+            end
+
+            rbs_contents[path] = [
+              format_rbs(decls: decls),
+              files
+            ]
+          end
+        else
+          rbs_decls.each do |path, (decls, file)|
+            content = format_rbs(decls: decls)
+            rbs_contents[path] = [content, [file]]
+          end
+        end
+
+        rbs_contents.each do |path, (content, files)|
+          if (name, content = apply_filter(path.to_s, content, files))
+            response.file << Google::Protobuf::Compiler::CodeGeneratorResponse::File.new(
+              name: name,
+              content: content
+            )
+          end
         end
       end
 
+      def format_rbs(dirs: [], decls: [])
+        StringIO.new.tap do |io|
+          RBS::Writer.new(out: io).write(dirs + decls)
+        end.string
+      end
+
       def rbs_name(proto_name)
         dirname = File.dirname(proto_name)
         basename = File.basename(proto_name, File.extname(proto_name))
@@ -120,6 +176,15 @@ module RBSProtobuf
           )
         )
       end
+
+      def optional_type(type)
+        case type
+        when RBS::Types::Optional
+          type
+        else
+          RBS::Types::Optional.new(type: type, location: nil)
+        end
+      end
     end
   end
 end

data/lib/rbs_protobuf/translator/protobuf_gem.rb

@@ -19,8 +19,8 @@ module RBSProtobuf
 
       attr_reader :accept_nil_writer
 
-      def initialize(input, upcase_enum:, nested_namespace:, extension:, accept_nil_writer:, stderr: STDERR)
-        super(input)
+      def initialize(input, filters=[], upcase_enum:, nested_namespace:, extension:, accept_nil_writer:, stderr: STDERR)
+        super(input, filters)
         @upcase_enum = upcase_enum
         @nested_namespace = nested_namespace
         @extension = extension
@@ -49,7 +49,7 @@ module RBSProtobuf
       end
 
       def rbs_content(file)
-        decls = []
+        decls = [] #: Array[RBS::AST::Declarations::t]
 
         source_code_info = file.source_code_info
 
@@ -127,9 +127,7 @@ module RBSProtobuf
           end
         end
 
-        StringIO.new.tap do |io|
-          RBS::Writer.new(out: io).write(decls)
-        end.string
+        decls
       end
 
       def message_to_decl(message, prefix:, message_path:, source_code_info:, path:)
@@ -200,7 +198,17 @@ module RBSProtobuf
                 ),
                 annotations: []
               ),
-            ],
+              unless field_types.empty?
+                RBS::AST::Members::MethodDefinition::Overload.new(
+                  method_type: factory.method_type(
+                    type: factory.function().update(
+                      required_positionals: [factory.param(factory.alias_type("record"))]
+                    )
+                  ),
+                  annotations: []
+                )
+              end,
+            ].compact,
             annotations: [],
             comment: nil,
             location: nil,
@@ -352,7 +360,11 @@ module RBSProtobuf
           class_decl.members << RBS::AST::Declarations::TypeAlias.new(
             name: TypeName("init"),
             type_params: [],
-            type: factory.union_type(class_instance_type, TO_PROTO[]),
+            type: factory.union_type(
+              class_instance_type,
+              TO_PROTO[],
+              field_types.empty? ? nil : factory.alias_type("record")
+            ),
             annotations: [],
             comment: RBS::AST::Comment.new(string: "The type of `#initialize` parameter.", location: nil),
             location: nil
@@ -403,6 +415,18 @@ module RBSProtobuf
             comment: nil,
             location: nil
           )
+
+          class_decl.members << RBS::AST::Declarations::TypeAlias.new(
+            name: TypeName("record"),
+            type_params: [],
+            type: RBS::Types::Record.new(
+              fields: field_types.transform_values {|_, _, type| optional_type(type) },
+              location: nil
+              ),
+            annotations: [],
+            location: nil,
+            comment: nil
+          )
         end
       end
 
@@ -896,11 +920,81 @@ module RBSProtobuf
       def service_to_decl(service, prefix:, source_code_info:, path:)
         service_name = ActiveSupport::Inflector.camelize(service.name)
 
+        members = [] #: Array[RBS::AST::Declarations::Class::member]
+
+        service.method.each do |method|
+          method_name = ActiveSupport::Inflector.underscore(method.name).to_sym #: Symbol
+
+          interface_name = "_#{ActiveSupport::Inflector.camelize(method.name)}Method"
+
+          members << RBS::AST::Declarations::Interface.new(
+            name: factory.type_name(interface_name),
+            type_params: [],
+            members: [
+              RBS::AST::Members::MethodDefinition.new(
+                name: :request,
+                kind: :instance,
+                overloads: [
+                  RBS::AST::Members::MethodDefinition::Overload.new(
+                    method_type: factory.method_type(type: factory.function(message_type(method.input_type))),
+                    annotations: []
+                  )
+                ],
+                annotations: [],
+                location: nil,
+                comment: nil,
+                overloading: false,
+                visibility: nil
+              ),
+              RBS::AST::Members::MethodDefinition.new(
+                name: :respond_with,
+                kind: :instance,
+                overloads: [
+                  RBS::AST::Members::MethodDefinition::Overload.new(
+                    method_type: factory.method_type(
+                      type: factory.function().update(
+                        required_positionals: [
+                          factory.param(message_init_type(message_type(method.output_type)))
+                        ]
+                      )
+                    ),
+                    annotations: []
+                  )
+                ],
+                annotations: [],
+                location: nil,
+                comment: nil,
+                overloading: false,
+                visibility: nil
+              )
+            ],
+            annotations: [],
+            location: nil,
+            comment: nil
+          )
+
+          members << RBS::AST::Members::MethodDefinition.new(
+            name: method_name,
+            kind: :instance,
+            overloads: [
+              RBS::AST::Members::MethodDefinition::Overload.new(
+                method_type: factory.method_type(type: factory.function()),
+                annotations: []
+              )
+            ],
+            annotations: [],
+            location: nil,
+            comment: nil,
+            overloading: false,
+            visibility: nil
+          )
+        end
+
         RBS::AST::Declarations::Class.new(
           name: RBS::TypeName.new(name: service_name.to_sym, namespace: prefix),
           super_class: service_base_class,
           type_params: factory.module_type_params(),
-          members: [],
+          members: members,
           comment: comment_for_path(source_code_info, path, options: nil),
           location: nil,
           annotations: []

data/lib/rbs_protobuf/version.rb

@@ -1,3 +1,3 @@
 module RBSProtobuf
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/rbs_collection.lock.yaml

@@ -2,7 +2,7 @@
 sources:
 - type: git
   name: ruby/gem_rbs_collection
-  revision: 8a678b2ec20e9d594055f53745399814e3a887dc
+  revision: 5666e737d2b27a8425b4e3855c1a38cae54989f7
   remote: https://github.com/ruby/gem_rbs_collection.git
   repo_dir: gems
 path: ".gem_rbs_collection"

data/sig/rbs_protobuf/rbs_factory.rbs

@@ -10,7 +10,7 @@ module RBSProtobuf
 
     def singleton_type: (String | RBS::TypeName name) -> RBS::Types::ClassSingleton
 
-    def union_type: (RBS::Types::t `type`, *RBS::Types::t types) -> RBS::Types::t
+    def union_type: (RBS::Types::t `type`, *RBS::Types::t? types) -> RBS::Types::t
 
     def nil_type: (?location: RBS::Location[untyped, untyped]?) -> RBS::Types::Bases::Nil
 

data/sig/rbs_protobuf/translator/base.rbs

@@ -5,7 +5,15 @@ module RBSProtobuf
 
       attr_reader input: untyped
 
-      def initialize: (untyped input) -> void
+      type filter = ^(String rbs_name, String rbs_content, Array[untyped] proto_files) -> [String, String]?
+
+      attr_reader filters: Array[filter]
+
+      attr_accessor rbs_concat_level: Integer?
+
+      def initialize: (untyped input, ?Array[filter] filters) -> void
+
+      def apply_filter: (String rbs_name, String rbs_content, Array[untyped] proto_file) -> [String, String]?
 
       @factory: RBSFactory
 
@@ -21,7 +29,9 @@ module RBSProtobuf
 
       def rbs_suffix: () -> ::String
 
-      def rbs_content: (String file) -> String
+      def format_rbs: (?dirs: Array[RBS::AST::Directives::t], ?decls: Array[RBS::AST::Declarations::t]) -> String
+
+      def rbs_content: (String file) -> Array[RBS::AST::Declarations::t]
 
       def comment_for_path: (untyped source_code_info, Array[Integer] path, options: untyped) -> RBS::AST::Comment?
 
@@ -30,6 +40,8 @@ module RBSProtobuf
       def base_type: (untyped `type`) -> RBS::Types::t
 
       def message_type: (String) -> RBS::Types::ClassInstance
+
+      def optional_type: (RBS::Types::t) -> RBS::Types::Optional
     end
   end
 end

data/sig/rbs_protobuf/translator/protobuf_gem.rbs

@@ -28,6 +28,7 @@ module RBSProtobuf
 
       def initialize: (
         untyped input,
+        ?Array[Base::filter] filters,
         upcase_enum: bool,
         nested_namespace: bool,
         extension: bool | :print | nil,
@@ -63,7 +64,7 @@ module RBSProtobuf
       # The entry point.
       # Generate RBS declarations from the `file` and returns the string representation of the declarations.
       #
-      def rbs_content: (untyped file) -> String
+      def rbs_content: (untyped file) -> Array[RBS::AST::Declarations::t]
 
       # Returns the class declaration for given message.
       #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbs_protobuf
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-16 00:00:00.000000000 Z
+date: 2023-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs