gapic-generator 0.51.1 → 0.53.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eacc61ce38027f685621213ffaca3db69125b98c6a1d4d377984ee87d3b5d300
-  data.tar.gz: 72ff91b581965488f97e8e521bb38847234d32c3ffb1a3b229e056f33129fa1c
+  metadata.gz: 3264cfe286069bf2e3bed64ae2246c0b8e48d97851809c99c5520e072fa38889
+  data.tar.gz: d9503be57f76aedd856a46159e138673fc83f2912fa51018d16e5cd1e8c71f90
 SHA512:
-  metadata.gz: b8509223c3abf3617ef9bd7c6ea6aef239b57f8e60e774a33df471d131106ecb2a1942e6be9a374c2540753fa0d50ad91e2519ed5fa096ef391c946b35129c4f
-  data.tar.gz: ff480bcbf75f4181647600ed686822911628f6cc98c3f048d91ba46af89cb31fb2db6faf7dfc3332dd2e30ce671574e8347d1149cd6cb25c874feb05788bc8af
+  metadata.gz: d8109c1036d6b95c2bf2fe201de7e2cf26516e4d315c6d4ca3331b52f0d312d27884416bd6ce7db8209ae78c13ffab4120b444e229fc914d3d329ca801dd6837
+  data.tar.gz: 1ef6ae68e1fc76dfc19bbe947d7f4340918403494d57bd3d1ba40540b953921470a5090b7ed7f6d2fe80519066c28d92e8a0a3115acbf4d498fc43c8580debd9

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Release History for gapic-generator
 
+### 0.53.0 / 2026-09-30
+
+* Feature: update gapic-common for generated libraries to 1.4
+* Feature: resumable upload support in gapic-generator
+
+### 0.52.0 / 2026-09-04
+
+* Fix: escape multi-line braces and backtick unknown doc tags in yard formatting
+* Fix: rejoin split doc URLs (b/153077040) and strip non-existent message links (b/158466893)
+* Feature: add ruby-cloud-renamed-from for renamed wrapper gems
+
 ### 0.51.1 / 2026-08-05
 
 No significant changes

data/lib/gapic/formatting_utils.rb

@@ -21,16 +21,30 @@ module Gapic
   # Various string formatting utils
   #
   module FormattingUtils
-    @brace_detector = /\A(?<pre>[^`]*(?:`[^`]*`[^`]*)*[^`\\])?\{(?<inside>[^\s][^}]*)\}(?<post>.*)\z/m
     @xref_detector = /\A(?<pre>[^`]*(?:`[^`]*`[^`]*)*)?\[(?<text>[\w. `-]+)\]\[(?<addr>[\w.]+)\](?<post>.*)\z/m
     @list_element_detector = /\A\s*(?:\*|\+|-|[0-9a-zA-Z]+\.)\s/
     @omit_lines = ["@InputOnly\n", "@OutputOnly\n"]
+    # Built-in YARD meta-data tags as documented in:
+    # https://rubydoc.info/gems/yard/file/docs/Tags.md#Tag_List
+    @known_yard_tags = [
+      "abstract", "api", "attr", "attr_reader", "attr_writer", "author", "deprecated", "example",
+      "note", "option", "overload", "param", "private", "raise", "return", "see", "since", "todo",
+      "version", "yield", "yieldparam", "yieldreturn"
+    ].freeze
+
+    # Non-existent messages referenced in proto documentation comments (b/158466893).
+    # Cross-references to these messages (or their fields) cannot be resolved, so the links
+    # are stripped to avoid broken documentation references.
+    @non_existent_messages = [
+      "google.cloud.automl.v1.ColumnSpec"
+    ].freeze
 
     class << self
       ##
       # Given an enumerable of lines, performs yardoc formatting, including:
       # * Interpreting cross-references identified as described in AIP 192
       # * Escaping literal braces that look like yardoc type links
+      # * Backticking unknown doc tags so they are not parsed as YARD tags
       #
       # Tries to be smart about exempting preformatted text blocks.
       #
@@ -45,23 +59,26 @@ module Gapic
       #
       def format_doc_lines api, lines, disable_xrefs: false, transport: nil
         transport ||= api&.default_transport || :grpc
-        # To detect preformatted blocks, this tracks the "expected" base indent
-        # according to Markdown. Specifically, this is the effective indent of
-        # previous block, which is normally 0 except if we're in a list item.
-        # Then, if a block is indented at least 4 spaces past that expected
-        # indent (and as long as it remains so), those lines are considered
-        # preformatted.
+        lines = rejoin_split_urls lines
+        in_fence = in_code_span = false
         in_block = nil
         base_indent = 0
         (lines - @omit_lines).map do |line|
-          indent = line_indent line
-          if indent.nil?
+          if line =~ /^\s*(?:```|~~~)/
+            in_fence = !in_fence
+            in_code_span = false
             in_block = nil
-          else
-            in_block, base_indent = update_indent_state in_block, base_indent, line, indent
-            if in_block == false
-              line = escape_line_braces line
-              line = format_line_xrefs api, line, disable_xrefs, transport
+          elsif !in_fence
+            indent = line_indent line
+            if indent.nil?
+              in_block = nil
+              in_code_span = false
+            else
+              in_block, base_indent = update_indent_state in_block, base_indent, line, indent
+              if in_block == false
+                line, in_code_span = format_line_content line, in_code_span
+                line = format_line_xrefs api, line, disable_xrefs, transport
+              end
             end
           end
           line
@@ -88,6 +105,21 @@ module Gapic
 
       private
 
+      def rejoin_split_urls lines
+        return lines if lines.empty?
+
+        # Fix for misformatted markdown links across line breaks (b/153077040).
+        # Callers may pass lines with trailing newlines (e.g., from String#each_line in schema wrappers)
+        # or without trailing newlines (e.g., from String#split("\n") in GemPresenter#readme_description).
+        # We must preserve the presence or absence of trailing newlines on each element.
+        has_newlines = lines.any? { |l| l.end_with? "\n" }
+        if has_newlines
+          lines.join.gsub(%r{https:\n\s*//}, "https://").each_line.to_a
+        else
+          lines.join("\n").gsub(%r{https:\n\s*//}, "https://").split("\n", -1)
+        end
+      end
+
       def update_indent_state in_block, base_indent, line, indent
         if in_block != true && @list_element_detector =~ line
           in_block = false
@@ -106,15 +138,50 @@ module Gapic
         m[1].length
       end
 
-      def escape_line_braces line
-        while (m = @brace_detector.match line)
-          line = "#{m[:pre]}\\\\{#{m[:inside]}}#{m[:post]}"
+      def format_line_content line, in_code_span
+        parts = line.split("`", -1)
+        formatted_parts = parts.each_with_index.map do |part, idx|
+          if in_code_span
+            in_code_span = false if idx < parts.length - 1
+            part
+          else
+            is_followed_by_backtick = idx < parts.length - 1
+            in_code_span = true if is_followed_by_backtick
+            formatted = escape_prose_braces part, is_followed_by_backtick: is_followed_by_backtick
+            sanitize_prose_tags formatted
+          end
+        end
+        [formatted_parts.join("`"), in_code_span]
+      end
+
+      def escape_prose_braces text, is_followed_by_backtick: false
+        # Matches unescaped `{` outside backtick spans followed by non-whitespace.
+        # If `{` is at the end of a non-code chunk (is_followed_by_backtick: true), it is followed
+        # immediately by a backticked code span (starting with a non-whitespace backtick),
+        # so \z (end of string) is also matched.
+        pattern = is_followed_by_backtick ? /(?<!\\)\{(?=[^\s]|\z)/ : /(?<!\\)\{(?=[^\s])/
+        text.gsub(pattern) { "\\\\{" }
+      end
+
+      def sanitize_prose_tags text
+        # Matches doc tags starting with `@` at the start of a line or preceded by whitespace.
+        # Avoids matching `@` within email addresses (e.g. user@example.com) or quotes.
+        # Any tag not in the YARD recognized list (or starting with `!`) is wrapped in backticks
+        # so YARD renders it as literal text rather than an unrecognized tag directive.
+        text.gsub(/(?<=\A|\s)@([a-zA-Z_]\w*)/) do |match|
+          tag = Regexp.last_match 1
+          @known_yard_tags.include?(tag) || tag.start_with?("!") ? match : "`#{match}`"
         end
-        line
       end
 
       def format_line_xrefs api, line, disable_xrefs, transport
         while (m = @xref_detector.match line)
+          # Remove links to known non-existent messages (b/158466893)
+          if @non_existent_messages.any? { |msg| m[:addr] == msg || m[:addr].start_with?("#{msg}.") }
+            line = "#{m[:pre]}#{m[:text]}#{m[:post]}"
+            next
+          end
+
           entity = api.lookup m[:addr]
           is_mixin_field_addr = Gapic::Model::Mixins.mixin_message_field_address?(
             m[:addr],

data/lib/gapic/generator/version.rb

@@ -16,6 +16,6 @@
 
 module Gapic
   module Generator
-    VERSION = "0.51.1"
+    VERSION = "0.53.0"
   end
 end

data/lib/gapic/generators/default_generator.rb

@@ -92,10 +92,16 @@ module Gapic
             # Rest-only `service.stub` file
             files << g("service/rest/service_stub",      "lib/#{service.rest.service_stub_file_path}",       service: service) if should_generate_rest
 
+            # Resumable upload stub, shared by both transports because uploads always travel over REST
+            files << g("service/resumable_upload_stub",  "lib/#{service.resumable_upload_stub_file_path}",   service: service) if service.resumable_upload?
+
             # Unit tests for `client.rb`
             files << g("service/test/client",            "test/#{service.test_client_file_path}",            service: service) if should_generate_grpc
             files << g("service/rest/test/client",       "test/#{service.rest.test_client_file_path}",       service: service) if should_generate_rest
 
+            # Unit tests for resumable upload RPCs, which the client tests above skip
+            files << g("service/test/resumable_upload",  "test/#{service.test_resumable_upload_file_path}",  service: service) if service.resumable_upload?
+
             # Unit tests for `paths.rb`
             files << g("service/test/client_paths",      "test/#{service.test_paths_file_path}",             service: service) if service.paths? && should_generate_grpc
 

data/lib/gapic/generators/default_generator_parameters.rb

@@ -40,6 +40,7 @@ module Gapic
         ":gem.:homepage",
         ":gem.:env_prefix",
         ":gem.:version_dependencies",
+        ":gem.:renamed_from",
         ":gem.:migration_version",
         ":gem.:product_documentation_url",
         ":gem.:issue_tracker_url",
@@ -83,6 +84,7 @@ module Gapic
         "gem-homepage"              => ":gem.:homepage",
         "gem-env-prefix"            => ":gem.:env_prefix",
         "gem-wrapper-of"            => ":gem.:version_dependencies",
+        "gem-renamed-from"          => ":gem.:renamed_from",
         "gem-migration-version"     => ":gem.:migration_version",
         "gem-product-url"           => ":gem.:product_documentation_url",
         "gem-issues-url"            => ":gem.:issue_tracker_url",

data/lib/gapic/model/method/resumable_upload.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "gapic/model/model_error"
+
+module Gapic
+  module Model
+    module Method
+      ##
+      # Resumable upload method-level model.
+      #
+      # A resumable upload RPC does not send its payload in the initiation request. The request it
+      # describes only creates an upload session; the bytes travel afterwards, over REST, in chunks
+      # addressed to a URL the server hands back. Generated clients therefore return an upload handle
+      # from such a method rather than a response message.
+      #
+      # Until the upload annotation is published, the set of such RPCs is carried here as a table, and
+      # so is the URL prefix each one's initiation request is sent under. When the annotation lands,
+      # {.url_prefix_for} keeps the table and detection moves to `http.media_upload.enabled`.
+      #
+      # @!attribute [r] url_prefix
+      #   @return [String] The path prefix prepended to the transcoded initiation URL, without
+      #     surrounding slashes, e.g. `resumable/upload`.
+      #
+      class ResumableUpload
+        # @return [String]
+        attr_reader :url_prefix
+
+        ##
+        # @param url_prefix [String] The upload URL prefix for the matched RPC.
+        #
+        def initialize url_prefix
+          @url_prefix = url_prefix
+        end
+
+        ##
+        # Exact matches, keyed by the full gRPC name of the RPC.
+        #
+        EXACT_PREFIXES = {
+          "google.showcase.v1beta1.ResumableUploadService.UploadMedia" => "resumable/upload"
+        }.freeze
+
+        ##
+        # Version-family matches, for protos that are republished under a new version regularly.
+        # Anchored on the left at the package and on the right at the service and method, with the
+        # intervening segments (e.g. `.services.`) unconstrained.
+        #
+        VERSIONED_PREFIXES = [
+          {
+            left:   /\Agoogle\.ads\.googleads\.v[0-9_]+\./,
+            right:  ".YouTubeVideoUploadService.CreateYouTubeVideoUpload",
+            prefix: "resumable/upload"
+          }
+        ].freeze
+
+        class << self
+          ##
+          # Inspects a method and returns its resumable upload model, or `nil` if it does not perform
+          # resumable uploads.
+          #
+          # @param method [Gapic::Presenters::MethodPresenter]
+          #
+          # @raise [Gapic::Model::ModelError] if the method is a resumable upload RPC that the
+          #   generator cannot generate an upload surface for.
+          #
+          # @return [Gapic::Model::Method::ResumableUpload, nil]
+          #
+          def create method
+            prefix = url_prefix_for method.grpc_full_name
+            return nil if prefix.nil?
+            validate! method
+            new prefix
+          end
+
+          ##
+          # The upload URL prefix for an RPC, or `nil` if the RPC does not perform resumable uploads.
+          #
+          # @param full_name [String] The full gRPC name of the RPC,
+          #   e.g. `google.showcase.v1beta1.ResumableUploadService.UploadMedia`.
+          #
+          # @return [String, nil]
+          #
+          def url_prefix_for full_name
+            EXACT_PREFIXES[full_name] ||
+              VERSIONED_PREFIXES.find do |match|
+                match[:left].match?(full_name) && full_name.end_with?(match[:right])
+              end&.fetch(:prefix)
+          end
+
+          ##
+          # Verifies that an upload surface can be generated for the given method. A resumable upload
+          # is a single unary POST that carries a body, and anything else in the table is a
+          # misconfiguration that must fail the build rather than generate code that cannot work.
+          #
+          # @param method [Gapic::Presenters::MethodPresenter]
+          #
+          # @raise [Gapic::Model::ModelError]
+          #
+          # @return [void]
+          #
+          def validate! method
+            reason = unsupported_reason method
+            return if reason.nil?
+            raise ModelError, "The method #{method.grpc_full_name} performs resumable uploads, " \
+                              "which the generator supports only for #{reason}."
+          end
+
+          private
+
+          ##
+          # @param method [Gapic::Presenters::MethodPresenter]
+          # @return [String, nil] What the method would have had to be, or `nil` if it is supported.
+          #
+          def unsupported_reason method
+            return "non-streaming methods" if method.client_streaming? || method.server_streaming?
+            return "non-paginated methods" if method.paged?
+            return "methods that are not long-running operations" if method.lro? || method.nonstandard_lro?
+
+            binding = method.http_bindings.first
+            return "methods with an HTTP binding" if binding.nil?
+            return "methods bound to POST" unless binding.verb == :post
+            return "methods whose HTTP binding has a body" unless binding.body?
+
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gapic/presenters/gem_presenter.rb

@@ -260,7 +260,7 @@ module Gapic
 
       def dependencies
         @dependencies ||= begin
-          deps = { "gapic-common" => "~> 1.3" }
+          deps = { "gapic-common" => "~> 1.5" }
           deps["grpc-google-iam-v1"] = "~> 1.11" if iam_dependency?
           extra_deps = gem_config_dependencies
           deps.merge! mixins_model.dependencies if mixins_model.mixins?

data/lib/gapic/presenters/method_presenter.rb

@@ -17,6 +17,7 @@
 require "active_support/inflector"
 require "gapic/ruby_info"
 require "gapic/helpers/namespace_helper"
+require "gapic/model/method/resumable_upload"
 
 module Gapic
   module Presenters
@@ -71,6 +72,10 @@ module Gapic
         @lro = Gapic::Model::Method.parse_lro @method, @api
 
         @rest = MethodRestPresenter.new self, @api
+
+        # Built last: detection is cheap but its validation reads the LRO model, the HTTP bindings
+        # and the pagination check, all of which have to exist first.
+        @resumable_upload = Gapic::Model::Method::ResumableUpload.create self
       end
 
       ##
@@ -279,6 +284,36 @@ module Gapic
         service.nonstandard_lros.find { |model| model.service == @lro.service_full_name }
       end
 
+      ##
+      # Whether this method performs a resumable upload. Such a method returns an upload handle
+      # rather than a response, and its payload travels over REST in chunks after the request this
+      # method describes has created the upload session.
+      #
+      # @return [Boolean]
+      #
+      def resumable_upload?
+        !@resumable_upload.nil?
+      end
+
+      ##
+      # The path prefix prepended to this method's transcoded initiation URL, without surrounding
+      # slashes, e.g. `resumable/upload`. `nil` unless this method performs a resumable upload.
+      #
+      # @return [String, nil]
+      #
+      def upload_url_prefix
+        @resumable_upload&.url_prefix
+      end
+
+      ##
+      # The name of the constant the generated upload stub holds this method's URL prefix in.
+      #
+      # @return [String]
+      #
+      def upload_url_prefix_const_name
+        "#{name.upcase}_URL_PREFIX"
+      end
+
       def client_streaming?
         @method.client_streaming
       end

data/lib/gapic/presenters/service_presenter.rb

@@ -422,6 +422,15 @@ module Gapic
         service_file_path.sub ".rb", "_operations_test.rb"
       end
 
+      ##
+      # Path of the generated tests covering this service's resumable upload RPCs. Those RPCs are
+      # excluded from the ordinary client tests, which assume a call returns a response.
+      #
+      # @return [String]
+      def test_resumable_upload_file_path
+        service_file_path.sub ".rb", "_resumable_upload_test.rb"
+      end
+
       def stub_name
         "#{ActiveSupport::Inflector.underscore name}_stub"
       end
@@ -489,6 +498,62 @@ module Gapic
         ServicePresenter.new @gem_presenter, @api, lro.services.first, parent_service: self unless lro.nil?
       end
 
+      ##
+      # Whether any of this service's RPCs perform resumable uploads, and therefore whether an upload
+      # stub has to be generated for it and built by its clients.
+      #
+      # @return [Boolean]
+      def resumable_upload?
+        methods.any?(&:resumable_upload?)
+      end
+
+      ##
+      # Presenters for the RPCs of this service that perform resumable uploads.
+      #
+      # @return [Enumerable<Gapic::Presenters::MethodPresenter>]
+      def resumable_upload_methods
+        methods.select(&:resumable_upload?)
+      end
+
+      ##
+      # The class name of the generated upload stub. One per service, shared by both transports, and
+      # deliberately not nested under `Rest::`: the gRPC client builds it too, because the upload
+      # itself always travels over REST.
+      #
+      # @return [String]
+      def resumable_upload_stub_name
+        "ResumableUploadStub"
+      end
+
+      # @return [String]
+      def resumable_upload_stub_name_full
+        fix_namespace @api, "#{service_name_full}::#{resumable_upload_stub_name}"
+      end
+
+      # @return [String]
+      def resumable_upload_stub_require
+        ruby_file_path @api, resumable_upload_stub_name_full
+      end
+
+      # @return [String]
+      def resumable_upload_stub_file_path
+        "#{resumable_upload_stub_require}.rb"
+      end
+
+      # @return [String]
+      def resumable_upload_stub_file_name
+        resumable_upload_stub_file_path.split("/").last
+      end
+
+      ##
+      # An instance variable name used for the generated upload stub. The clients keep the stub here
+      # and expose no reader for it.
+      #
+      # @return [String]
+      def resumable_upload_stub_ivar
+        "@resumable_upload_stub"
+      end
+
       def config_channel_args
         { "grpc.service_config_disable_resolution" => 1 }
       end

data/lib/gapic/presenters/service_rest_presenter.rb

@@ -357,6 +357,18 @@ module Gapic
         main_service.methods.select(&:can_generate_rest?)
       end
 
+      ##
+      # Presenters for methods that the REST service stub carries an implementation for. An upload
+      # RPC has no ordinary REST path: the REST client delegates to the upload handle exactly as the
+      # gRPC client does, so a plain call method and transcoder here would be dead code that also
+      # happens to be wrong — a non-resumable POST of the whole payload.
+      #
+      # @return [Enumerable<Gapic::Presenters::MethodPresenter>]
+      #
+      def service_stub_methods
+        methods.reject(&:resumable_upload?)
+      end
+
       ##
       # Require string for the helpers file
       #

data/lib/gapic/presenters/snippet/response_handling_presenters.rb

@@ -80,6 +80,66 @@ module Gapic
         attr_reader :response_name
       end
 
+      ##
+      # Presentation information about resumable upload response handling.
+      #
+      # A resumable upload RPC returns a {::Gapic::ResumableUpload} handle rather than a
+      # response message, so the snippet names the call result `upload` and goes on to
+      # start the upload, which is what actually produces the response message.
+      #
+      class ResumableUploadResponseHandlingPresenter
+        include ResponseHandlingPresenterCommon
+
+        ##
+        # Create a resumable upload response handling presenter
+        #
+        # @param proto [Google::Cloud::Tools::SnippetGen::ConfigLanguage::V1::Snippet::SimpleResponseHandling]
+        #     The protobuf representation
+        # @param json [String]
+        #     The JSON representation
+        # @param response_type [String] The fully qualified response message class
+        # @param phase1 [Boolean] True if this is a phase 1 snippet without config
+        #
+        def initialize proto, _json, response_type:, phase1:
+          @response_name = phase1 ? "upload" : compute_response_name(proto, phase1)
+          @render_lines = phase1 ? upload_lines(response_type) : []
+          @render = @render_lines.join "\n"
+        end
+
+        ##
+        # The lines of rendered code
+        # @return [Array<String>]
+        #
+        attr_reader :render_lines
+
+        ##
+        # The rendered code as a single string, possibly with line breaks
+        # @return [String]
+        #
+        attr_reader :render
+
+        ##
+        # The name of the response variable, or nil for no response handling
+        # @return [String,nil]
+        #
+        attr_reader :response_name
+
+        private
+
+        def upload_lines response_type
+          [
+            "# The returned object is a handle for a resumable upload. Nothing has been",
+            "# uploaded yet, and the timeout and retry policy of the call above cover only",
+            "# the request that creates the upload session, not the upload as a whole.",
+            "stream = File.open \"input.bin\", \"rb\"",
+            "result = #{@response_name}.start stream: stream, content_type: \"application/octet-stream\"",
+            "",
+            "# The returned object is of type #{response_type}.",
+            "p result"
+          ]
+        end
+      end
+
       ##
       # Presentation information about LRO response handling
       #

data/lib/gapic/presenters/snippet_presenter.rb

@@ -63,6 +63,8 @@ module Gapic
           :paged
         elsif @method_presenter.lro?
           :lro
+        elsif @method_presenter.resumable_upload?
+          :resumable_upload
         else
           :simple
         end
@@ -244,13 +246,12 @@ module Gapic
           LroResponseHandlingPresenter.new call_proto&.lro_handling,
                                            call_json&.fetch("lroHandling", nil),
                                            phase1: phase1
+        when :resumable_upload
+          ResumableUploadResponseHandlingPresenter.new call_proto&.response_handling,
+                                                       call_json&.fetch("responseHandling", nil),
+                                                       response_type: return_type, phase1: phase1
         when :streaming
-          response_name = phase1 ? "output" : call_proto&.server_stream_name
-          response_name = nil if response_name == ""
-          StreamingResponseHandlingPresenter.new call_proto&.response_handling,
-                                                 call_json&.fetch("responseHandling", nil),
-                                                 response_name: response_name, base_response_type: base_response_type,
-                                                 phase1: phase1
+          build_streaming_response_handling_presenter call_proto, call_json, phase1
         else
           SimpleResponseHandlingPresenter.new call_proto&.response_handling,
                                               call_json&.fetch("responseHandling", nil),
@@ -258,6 +259,15 @@ module Gapic
         end
       end
 
+      def build_streaming_response_handling_presenter call_proto, call_json, phase1
+        response_name = phase1 ? "output" : call_proto&.server_stream_name
+        response_name = nil if response_name == ""
+        StreamingResponseHandlingPresenter.new call_proto&.response_handling,
+                                               call_json&.fetch("responseHandling", nil),
+                                               response_name: response_name, base_response_type: base_response_type,
+                                               phase1: phase1
+      end
+
       def build_client_call_presenter call_proto, call_json, request_name, response_name
         phase1 = !config?
         if response_kind == :paged

data/templates/default/lib/_service.text.erb

@@ -15,6 +15,9 @@ require "<%= service.credentials_require %>"
 <%- if service.paths? -%>
 require "<%= service.paths_require %>"
 <%- end -%>
+<%- if service.resumable_upload? -%>
+require "<%= service.resumable_upload_stub_require %>"
+<%- end -%>
 <%- if service.generate_grpc_clients? -%>
 <%- if service.lro? -%>
 require "<%= service.operations_require %>"

data/templates/default/lib/rest/_rest.text.erb

@@ -15,6 +15,9 @@ require "<%= service.credentials_require %>"
 <%- if service.paths? -%>
 require "<%= service.paths_require %>"
 <%- end -%>
+<%- if service.resumable_upload? -%>
+require "<%= service.resumable_upload_stub_require %>"
+<%- end -%>
 <%- if service.rest.lro? -%>
 require "<%= service.rest.operations_require %>"
 <%- end -%>