gapic-generator 0.45.1 → 0.45.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c44ace94e73e85dad3b7b20373016a28f46181631709dd52fe19672b7da80a6
-  data.tar.gz: 2f8bdc5d63b8253687711ff7bc6d139e536cc3f5d096be9c8f1546676db60aa4
+  metadata.gz: 271aec2d05b52adb5498c05c65461142789397a22d3b9a99d1d09f1559e8cf4f
+  data.tar.gz: 16e8bbbf90f2c0eb2174939cc7972fa37552cb807cfd24ecc0d74c9ed252a642
 SHA512:
-  metadata.gz: 3f24b95f72f3a26e89190694fff115e8b6e5206b430676fda14ef6d3669b6b2de1eefdada75d2420607f63d31789491acfb11f419cbdce237deaa1fa597fb667
-  data.tar.gz: b88884b59cc8d3d426f793a97696617e2314b81c4c38e61fa3a507270a2d9e20e67c631fdefad2cf2cd793f5c1bae06577dd4381157a33b64092ad7c7f77ee97
+  metadata.gz: e46aeb79a605c9395704b0cc14d4b8b540c34c119c9ee7d33178fc8d1a384d91fecfc42e92311e7197e36f9cec7cf21cb85e3a29850256643d348eae6571e8d2
+  data.tar.gz: 9f953a7d82a33f19a6309b6ca6abdf5da4b0f5bec294f6f1da8b0aadec47466f335a4df091c8021dd87a9596b0a310bdfa006fd617f03af8e167067a76712d47

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Release History for gapic-generator
 
+### 0.45.3 / 2025-06-21
+
+* Fix: correct pagination heuristic for Compute
+* Fix: add libyaml to checks and configure for the prebuilt binary
+* Fix: update Ruby prebuilt binary (version 3.4.3)
+
+### 0.45.2 / 2025-06-04
+
+* Fix: update Ruby prebuilt binary, version 3.4.3
+
 ### 0.45.1 / 2025-05-01
 
 No significant changes

data/lib/gapic/formatting_utils.rb

@@ -102,7 +102,8 @@ module Gapic
 
       def line_indent line
         m = /^( *)\S/.match line
-        m.nil? ? nil : m[1].length
+        return nil unless m
+        m[1].length
       end
 
       def escape_line_braces line

data/lib/gapic/generator/version.rb

@@ -16,6 +16,6 @@
 
 module Gapic
   module Generator
-    VERSION = "0.45.1"
+    VERSION = "0.45.3"
   end
 end

data/lib/gapic/model/api_metadata.rb

@@ -160,7 +160,7 @@ module Gapic
           selector = setting[SELECTOR]
           methods = service_config.apis.filter_map do |api|
             # Removes API prefix and trailing period.
-            selector[api.name.length + 1..].downcase if selector.start_with? api.name
+            selector[(api.name.length + 1)..].downcase if selector.start_with? api.name
           end
           if !methods.nil? && setting.key?(AUTO_POPULATED_FIELDS)
             @auto_populated_fields_by_method_name[methods.first] = setting[AUTO_POPULATED_FIELDS]

data/lib/gapic/presenters/method/compute_pagination_info.rb

@@ -0,0 +1,392 @@
+# frozen_string_literal: true
+
+# Copyright 2021 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 Presenters
+    module Method
+      ##
+      # Compute-specific pagination info determined from the proto method
+      #
+      # This implements the Compute-specific pagination heuristic
+      #
+      # The following steps are followed for this heuristic:
+      # 1. The method should not be server-streamed
+      # 2. The request should have a page token and page size fields
+      # 3. The response should have a next page token and contain a valid results field
+      #
+      # Now determining the valid results field is its own complicated sub-heuristic that should be run last.
+      # This sub-heuristic cannot end in "not paginated". It should either determine the results field or throw an error
+      #
+      # The following steps are followed for this sub-heuristic:
+      # 0. Check the exception dictionary. If the method is there as a key, use the value as the results field.
+      # 1. If there is exactly one map field, that field is the results field.
+      #
+      # NB: at this point the response contains either 0 or 2+ map fields
+      #
+      # 2. If there are no repeated fields there is no results field and we shall throw an error
+      # 3. If there is exactly one repeated field, that field is the results field.
+      # 4. If there are exactly 2 repeated fields, one is of message type, and the other is of type
+      #    "String", the field of message type is the results field.
+      #
+      # At this point there are either 2 repeated fields in wrong configuration, or 3 or more repeated
+      # fields. The method should have been in the exception dictionary (see step 0).
+      # Since the method is NOT in the exception dictionary we should throw an error to prevent
+      # accidentally releasing a Compute library with incorrect pagination.
+      #
+      class ComputePaginationInfo
+        include Gapic::Helpers::NamespaceHelper
+
+        # @private Field name for Pagination Request page token
+        PAGE_TOKEN_NAME = "page_token"
+        private_constant :PAGE_TOKEN_NAME
+        # @private Field type for Pagination Request page token
+        PAGE_TOKEN_TYPE = :TYPE_STRING
+        private_constant :PAGE_TOKEN_TYPE
+
+        # @private Field names for Pagination Request page size
+        PAGE_SIZE_NAMES = ["page_size", "max_results"].freeze
+        private_constant :PAGE_SIZE_NAMES
+        # @private Field types for Pagination Request page size
+        PAGE_SIZE_TYPES = [:TYPE_UINT32, :TYPE_INT32].freeze
+        private_constant :PAGE_SIZE_TYPES
+
+        # @private Field name for Pagination Response next page token
+        NEXT_PAGE_TOKEN_NAME = "next_page_token"
+        private_constant :NEXT_PAGE_TOKEN_NAME
+        # @private Field type for Pagination Response next page token
+        NEXT_PAGE_TOKEN_TYPE = :TYPE_STRING
+        private_constant :NEXT_PAGE_TOKEN_TYPE
+
+        # @private A dictionary of special response messages of paginated methods and their repeated fields
+        # Curently contains only UsableSubnetworksAggregatedList which is a paginated field with 3 repeated fields,
+        #   2 of which are message-typed fields
+        REPEATED_FIELD_SPECIAL_DICTIONARY = {
+          "google.cloud.compute.v1.UsableSubnetworksAggregatedList" => "items",
+          "google.cloud.compute.v1beta.UsableSubnetworksAggregatedList" => "items"
+        }.freeze
+        private_constant :REPEATED_FIELD_SPECIAL_DICTIONARY
+
+        ##
+        # @param proto_method [Gapic::Schema::Method] the method to derive pagination info from
+        # @param api [Gapic::Schema::Api]
+        #
+        def initialize proto_method, api
+          @api = api
+          @method_full_name = proto_method.full_name
+          @request = proto_method.input
+          @response = proto_method.output
+          @server_streaming = proto_method.server_streaming
+        end
+
+        ##
+        # Whether the method should be generated as paged
+        #
+        # @return [Boolean]
+        def paged?
+          paged_candidate = !server_streaming? && paged_request? && paged_response_candidate?
+
+          # `paged_response?` can raise and should be evaluated last
+          paged_candidate && paged_response?
+        end
+
+        ##
+        # Name of the request's field used for page size
+        # For Regapic can be either `page_size` or `max_results`
+        #
+        # @return [String, nil]
+        def request_page_size_name
+          request_page_size_field&.name
+        end
+
+        ##
+        # Name of the repeated field in the response message
+        # For REST gapics can be either a vanilla repeated field or a map
+        #
+        # @return [String, nil]
+        def response_repeated_field_name
+          response_results_field&.name
+        end
+
+        ##
+        # Whether the repeated field in the response message is a map
+        #
+        # @return [Boolean, nil]
+        def repeated_field_is_a_map?
+          response_results_field&.map?
+        end
+
+        ##
+        # Proto type of the repeated field in the response message
+        #
+        # @return [String, nil]
+        def paged_element_doc_type
+          return nil if response_results_field.nil?
+          field_paginated_elem_doc_type response_results_field
+        end
+
+        private
+
+        ##
+        # Whether the underlying proto rpc is a server streaming rpc
+        #
+        # @return [Boolean]
+        attr_accessor :server_streaming
+
+        ##
+        # Whether the underlying proto rpc is a server streaming rpc
+        #
+        # @return [Boolean]
+        def server_streaming?
+          @server_streaming
+        end
+
+        ##
+        # Whether the request message for the REGAPIC rpc satisfies the criteria
+        # for the rpc to be classified and implemented as paged
+        #
+        # @return [Boolean]
+        def paged_request?
+          # Has a String page_token field which specifies the actual (next) page to retrieve.
+          # Has an int32 page_size or int32 max_results field
+          # which defines the maximum number of paginated resources to return in the response.
+          !request_page_token_field.nil? && !request_page_size_field.nil?
+        end
+
+        ##
+        # The field in the request that holds a page_token
+        #
+        # @return [Gapic::Schema::Field, nil]
+        def request_page_token_field
+          # Has a String page_token field which specifies the actual (next) page to retrieve.
+          @request_page_token_field ||= @request.fields.find do |f|
+            f.name == PAGE_TOKEN_NAME && f.type == PAGE_TOKEN_TYPE
+          end
+        end
+
+        ##
+        # The field in the request that holds a page_size
+        # For Regapic can have a name of either `page_size` or `max_results`
+        #
+        # @return [Gapic::Schema::Field, nil]
+        def request_page_size_field
+          @request_page_size_field ||=
+            begin
+              field = @request.fields.find do |f|
+                PAGE_SIZE_NAMES.include?(f.name) && PAGE_SIZE_TYPES.include?(f.type)
+              end
+
+              field
+            end
+        end
+
+        ##
+        # Whether the response message for the REGAPIC rpc satisfies the criteria
+        # for the rpc to be classified and implemented as paged
+        #
+        # @return [Boolean]
+        def paged_response?
+          # Has the string next_page_token field to be used in the next request as
+          # page_token to retrieve the next page.
+          # Passes the heuristic for paginated response
+          # Order is important here, since paginated response heuristic can raise and should be evaluated last
+          paged_response_candidate? && !response_results_field.nil?
+        end
+
+        ##
+        # Whether the response message for the REGAPIC rpc satisfies the criteria
+        # to be a candidate for pagination. This is intentinally split from evaluating
+        # the paged response heuristic since that heuristic can raise.
+        #
+        # @return [Boolean]
+        def paged_response_candidate?
+          # Has the string next_page_token field to be used in the next request as
+          # page_token to retrieve the next page.
+          !response_next_page_token_field.nil?
+        end
+
+        ##
+        # The field in the response that holds a next page_token
+        #
+        # @return [Gapic::Schema::Field, nil]
+        def response_next_page_token_field
+          # Has the string next_page_token field to be used in the next request as
+          # page_token to retrieve the next page.
+          @response_next_page_token_field ||= @response.fields.find do |f|
+            f.name == NEXT_PAGE_TOKEN_NAME && f.type == NEXT_PAGE_TOKEN_TYPE
+          end
+        end
+
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # The heuristic in `response_results_field` would be more confusing if spread across several methods
+
+        ##
+        # The field in the response that holds the results
+        # For Compute Regapic can be either a vanilla repeated field or a map
+        #
+        # @return [Gapic::Schema::Field, nil]
+        def response_results_field
+          # This sub-heuristic cannot end in "not paginated".
+          # It should either determine the results field or throw an error.
+          @response_results_field ||= begin
+            map_fields = @response.fields.find_all(&:map?)
+            repeated_fields = @response.fields.find_all do |f|
+              !f.map? && f.label == :LABEL_REPEATED
+            end
+
+            # The following steps are followed for this sub-heuristic:
+            # 0. Check the exception dictionary. If the method is there as key, use the value as the results field.
+            if REPEATED_FIELD_SPECIAL_DICTIONARY.key? @response.full_name
+              field_name = REPEATED_FIELD_SPECIAL_DICTIONARY[@response.full_name]
+              field = map_fields.find do |f|
+                f.name == field_name
+              end || repeated_fields.find do |f|
+                f.name == field_name
+              end
+
+              unless field
+                error_text = "A field of name \"#{field_name}\" is included in the special dictionary for " \
+                             "the response type \"#{@response.full_name}\". However this field is not a map " \
+                             "or repeated field. Failing, as the generator cannot continue."
+
+                raise ::Gapic::Model::ModelError, error_text
+              end
+
+              field
+            elsif map_fields.count == 1
+              # 1. If there is exactly one map field, that field is the results field.
+              map_fields.first
+            # NB: at this point the response contains either 0 or 2 map fields.
+            elsif repeated_fields.count.zero?
+              # 2. If there are no repeated fields there is no results field and we shall throw an error
+              error_text = "A response message \"#{@response.full_name}\" has a next page token field and " \
+                           "is being evaluated as a candidate for pagination. However it has " \
+                           "#{map_fields.count} (!= 1) map fields and no repeated fields.  " \
+                           "Failing, as the generator should not continue."
+
+              raise ::Gapic::Model::ModelError, error_text
+            elsif repeated_fields.count == 1
+              # 3. If there is exactly one repeated field, that field is the results field.
+              repeated_fields.first
+            elsif repeated_fields.count == 2
+              # 4. If there are exactly 2 repeated fields, one is of message type, and the other is of type
+              #    "String", the field of message type is the results field.
+              pagination_field = repeated_fields.find(&:message?)
+              string_field = repeated_fields.find { |f| f.type == :TYPE_STRING }
+
+              unless pagination_field && string_field
+                # At this point if there are 2 repeated fields of different configuration, or 3 or more repeated
+                # fields the method should have been in the exception dictionary (see step 0).
+                error_text = "A response message \"#{@response.full_name}\" has a next page token " \
+                             "field and is being evaluated as a candidate for pagination. However it should have " \
+                             "a configuration of exactly 2 repeated fields, one is of message type, and the other " \
+                             "of type \"String\". Failing, as the generator cannot continue. \n" \
+                             "As a developer, please evaluate the message that fails this heuristic and either " \
+                             "change the heuristic or add the message to the special dictionary."
+
+                raise ::Gapic::Model::ModelError, error_text
+              end
+
+              pagination_field
+            else
+              # At this point there are 3 or more repeated fields, and the method should have been in the
+              # exception dictionary (see step 0).
+              error_text = "A response message \"#{@response.full_name}\" has a next page token " \
+                           "field and is being evaluated as a candidate for pagination. However it has  " \
+                           "#{repeated_fields.count} (>= 3) repeated fields, and not in the special dictionary " \
+                           "for exceptions. Failing, as the generator cannot continue. \n" \
+                           "As a developer, please evaluate the message that fails this heuristic and either " \
+                           "change the heuristic or add the message to the special dictionary."
+
+              raise ::Gapic::Model::ModelError, error_text
+            end
+          end
+        end
+
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        # @private
+        FIELD_TYPE_MAPPING = {
+          TYPE_DOUBLE: "::Float",
+          TYPE_FLOAT: "::Float",
+          TYPE_INT64: "::Integer",
+          TYPE_UINT64: "::Integer",
+          TYPE_INT32: "::Integer",
+          TYPE_FIXED64: "::Integer",
+          TYPE_FIXED32: "::Integer",
+          TYPE_BOOL: "::Boolean",
+          TYPE_STRING: "::String",
+          TYPE_BYTES: "::String",
+          TYPE_UINT32: "::Integer",
+          TYPE_SFIXED32: "::Integer",
+          TYPE_SFIXED64: "::Integer",
+          TYPE_SINT32: "::Integer",
+          TYPE_SINT64: "::Integer"
+        }.freeze
+        private_constant :FIELD_TYPE_MAPPING
+
+        ##
+        # A helper to get a Ruby doc-type for a paginated element.
+        #
+        # @param field [Gapic::Schema::Field]
+        #
+        # @return [String]
+        def field_paginated_elem_doc_type field
+          return field_paginated_elem_map_type field if field.map?
+          if field.message?
+            message_ruby_type field.message
+          elsif field.enum?
+            # TODO: handle when arg message is nil and enum is the type
+            message_ruby_type field.enum
+          else
+            FIELD_TYPE_MAPPING[field.type] || "::Object"
+          end
+        end
+
+        ##
+        # A helper to get a Ruby doc-type for a proto map's paginated element.
+        #
+        # @param field [Gapic::Schema::Field]
+        #
+        # @return [String]
+        def field_paginated_elem_map_type field
+          key_field = field.map_key_field
+          value_field = field.map_val_field
+
+          if key_field && value_field
+            key_type = field_paginated_elem_doc_type key_field
+            value_type = field_paginated_elem_doc_type value_field
+            "#{key_type}, #{value_type}"
+          else
+            class_name
+          end
+        end
+
+        ##
+        # A helper to get a Ruby type for a proto message.
+        #
+        # @param message [Gapic::Schema::Message]
+        #
+        # @return [String]
+        def message_ruby_type message
+          ruby_namespace @api, message.address.join(".")
+        end
+      end
+    end
+  end
+end

data/lib/gapic/presenters/method_rest_presenter.rb

@@ -14,7 +14,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require "gapic/presenters/method/rest_pagination_info"
+require "gapic/presenters/method/compute_pagination_info"
 
 module Gapic
   module Presenters
@@ -22,9 +22,14 @@ module Gapic
     # A presenter for rpc methods (REST submethods)
     #
     class MethodRestPresenter
-      # @return [Gapic::Presenters::Method::RestPaginationInfo]
+      # @return [Gapic::Presenters::Method::ComputePaginationInfo] Special pagination presenter for Compute
       attr_reader :compute_pagination
 
+      ##
+      # Presenters for HTTP bindings, used to check whether this method should be generated in REST client
+      #
+      # @return [Array<Gapic::Presenters::Method::HttpBindingsPresenter>]
+      #
       attr_reader :http_bindings
 
       # @return [String] String representation of this presenter type.
@@ -39,7 +44,7 @@ module Gapic
         @http_bindings = main_method.http_bindings
         @compute_pagination =
           if @main_method.service.special_compute_behavior?
-            Gapic::Presenters::Method::RestPaginationInfo.new main_method.method, api
+            Gapic::Presenters::Method::ComputePaginationInfo.new main_method.method, api
           end
         @type = "method"
       end
@@ -54,7 +59,7 @@ module Gapic
       end
 
       ##
-      # Method name
+      # Method's name
       #
       # @return [String]
       #
@@ -62,8 +67,11 @@ module Gapic
         @main_method.name
       end
 
+      ##
       # Fully qualified proto name of the method (namespace.PascalCase)
+      #
       # @return [String]
+      #
       def grpc_full_name
         @main_method.grpc.full_name
       end
@@ -103,7 +111,10 @@ module Gapic
       end
 
       ##
-      # @return [String] The name of the repeated field in paginated responses
+      # Name of the repeated field in paginated responses
+      # For Compute the pagination is different from GRPC and cannot be looked up in GRPC method presenter
+      #
+      # @return [String]
       #
       def paged_response_repeated_field_name
         if compute_pagination
@@ -168,7 +179,9 @@ module Gapic
       end
 
       ##
-      # @return [Boolean] Whether the method is marked as deprecated.
+      # Whether the method is marked as deprecated.
+      #
+      # @return [Boolean]
       #
       def is_deprecated?
         @main_method.is_deprecated?

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

@@ -95,7 +95,7 @@ module Gapic
 
         def render_complex proto, json
           lines = ["{"]
-          proto.each do |key, value_expr|
+          proto.sort_by { |key, _| key.to_s }.each do |key, value_expr|
             value_presenter = ExpressionPresenter.new value_expr, json[key]
             value_lines = value_presenter.render_lines
             next unless value_lines
@@ -107,9 +107,12 @@ module Gapic
         end
 
         def render_list proto, json
+          exprs = proto.map.with_index do |item, index|
+            ExpressionPresenter.new item, json[index]
+          end
+
           lines = ["["]
-          proto.each_with_index do |item, index|
-            expr = ExpressionPresenter.new item, json[index]
+          exprs.sort_by(&:render).each do |expr|
             value_lines = expr.render_lines
             lines[lines.size - 1] = "#{lines.last}," if lines.size > 1
             lines += value_lines.map { |line| "  #{line}" }
@@ -118,17 +121,33 @@ module Gapic
         end
 
         def render_map proto, json
+          key_to_kvlines = get_key_to_kvlines proto, json
+
           lines = ["{"]
-          proto.keys.zip(proto.values).each_with_index do |(key, value), index|
-            key_lines = ExpressionPresenter.new(key, json["keys"][index]).render_lines
-            value_lines = ExpressionPresenter.new(value, json["values"][index]).render_lines
-            next unless key_lines && value_lines
+          key_to_kvlines.sort_by { |key, _| key }.each do |_, key_val_lines|
+            key_lines = key_val_lines[0]
+            value_lines = key_val_lines[1]
             elem_lines = key_lines[0..-2] + ["#{key_lines.last} => #{value_lines.first}"] + value_lines[1..]
             lines[lines.size - 1] = "#{lines.last}," if lines.size > 1
             lines += elem_lines.map { |line| "  #{line}" }
           end
           lines + ["}"]
         end
+
+        # Helper method to render_map.
+        # Returns a map from a key rendered as a string
+        # to the array of key and value rendered as lines.
+        def get_key_to_kvlines proto, json
+          key_to_kvlines = {}
+          proto.keys.zip(proto.values).each_with_index do |(key, value), index|
+            key_expr = ExpressionPresenter.new key, json["keys"][index]
+            value_expr = ExpressionPresenter.new value, json["values"][index]
+            next unless key_expr.render_lines && value_expr.render_lines
+
+            key_to_kvlines[key_expr.render] = [key_expr.render_lines, value_expr.render_lines]
+          end
+          key_to_kvlines
+        end
       end
     end
   end

data/templates/default/gem/gemfile.text.erb

@@ -3,7 +3,7 @@ source "https://rubygems.org"
 
 gemspec
 
-gem "google-style", "~> 1.31.0"
+gem "google-style", "~> 1.31.1"
 gem "minitest", "~> 5.22"
 gem "minitest-focus", "~> 1.4"
 gem "minitest-rg", "~> 5.3"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gapic-generator
 version: !ruby/object:Gem::Version
-  version: 0.45.1
+  version: 0.45.3
 platform: ruby
 authors:
 - Ernest Landrito
@@ -87,14 +87,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.31.0
+        version: 1.31.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.31.0
+        version: 1.31.1
 email:
 - landrito@google.com
 - quartzmo@gmail.com
@@ -167,8 +167,8 @@ files:
 - lib/gapic/presenters/gem_presenter.rb
 - lib/gapic/presenters/grpc_service_config_presenter.rb
 - lib/gapic/presenters/message_presenter.rb
+- lib/gapic/presenters/method/compute_pagination_info.rb
 - lib/gapic/presenters/method/http_binding_presenter.rb
-- lib/gapic/presenters/method/rest_pagination_info.rb
 - lib/gapic/presenters/method_presenter.rb
 - lib/gapic/presenters/method_rest_presenter.rb
 - lib/gapic/presenters/package_presenter.rb
@@ -365,7 +365,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 3.6.9
 specification_version: 4
 summary: An API Client Generator for Ruby in Ruby!
 test_files: []

data/lib/gapic/presenters/method/rest_pagination_info.rb

@@ -1,255 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright 2021 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.
-
-module Gapic
-  module Presenters
-    module Method
-      ##
-      # Pagination info determined from the proto method
-      #
-      class RestPaginationInfo
-        include Gapic::Helpers::NamespaceHelper
-        ##
-        # @param proto_method [Gapic::Schema::Method] the method to derive pagination info from
-        # @param api [Gapic::Schema::Api]
-        #
-        def initialize proto_method, api
-          @api = api
-          @request = proto_method.input
-          @response = proto_method.output
-          @server_streaming = proto_method.server_streaming
-        end
-
-        ##
-        # Whether the method should be generated as paged
-        #
-        # @return [Boolean]
-        def paged?
-          !server_streaming? && paged_request? && paged_response?
-        end
-
-        ##
-        # Name of the request's field used for page size
-        # For Regapic can be either `page_size` or `max_results`
-        #
-        # @return [String, nil]
-        def request_page_size_name
-          request_page_size_field&.name
-        end
-
-        ##
-        # Name of the repeated field in the response message
-        # For REST gapics can be either a vanilla repeated field or a map
-        #
-        # @return [String, nil]
-        def response_repeated_field_name
-          response_results_field&.name
-        end
-
-        ##
-        # Whether the repeated field in the response message is a map
-        #
-        # @return [Boolean, nil]
-        def repeated_field_is_a_map?
-          response_results_field&.map?
-        end
-
-        ##
-        # Proto type of the repeated field in the response message
-        #
-        # @return [String, nil]
-        def paged_element_doc_type
-          return nil if response_results_field.nil?
-          field_paginated_elem_doc_type response_results_field
-        end
-
-        private
-
-        # Whether the underlying proto rpc is a server streaming rpc
-        # @return [Boolean]
-        attr_accessor :server_streaming
-
-        ##
-        # Whether the underlying proto rpc is a server streaming rpc
-        #
-        # @return [Boolean]
-        def server_streaming?
-          @server_streaming
-        end
-
-        ##
-        # Whether the request message for the REGAPIC rpc satisfies the criteria
-        # for the rpc to be classified and implemented as paged
-        #
-        # @return [Boolean]
-        def paged_request?
-          # Has a String page_token field which specifies the actual (next) page to retrieve.
-          # Has an int32 page_size or int32 max_results field
-          # which defines the maximum number of paginated resources to return in the response.
-          !request_page_token_field.nil? && !request_page_size_field.nil?
-        end
-
-        ##
-        # The field in the request that holds a page_token
-        #
-        # @return[Gapic::Schema::Field, nil]
-        def request_page_token_field
-          # Has a String page_token field which specifies the actual (next) page to retrieve.
-          @request_page_token_field ||= @request.fields.find do |f|
-            f.name == "page_token" && f.type == :TYPE_STRING
-          end
-        end
-
-        ##
-        # The field in the request that holds a page_size
-        # For Regapic can have a name of either `page_size` or `max_results`
-        #
-        # @return[Gapic::Schema::Field, nil]
-        def request_page_size_field
-          @request_page_size_field ||=
-            begin
-              page_size_names = ["page_size", "max_results"]
-
-              # Has the int32 page_size or int32 max_results field
-              # which defines the maximum number of paginated resources to return in the response.
-              page_size_types = [:TYPE_UINT32, :TYPE_INT32]
-
-              field = @request.fields.find do |f|
-                page_size_names.include?(f.name) && page_size_types.include?(f.type)
-              end
-
-              field
-            end
-        end
-
-        ##
-        # Whether the response message for the REGAPIC rpc satisfies the criteria
-        # for the rpc to be classified and implemented as paged
-        #
-        # @return [Boolean]
-        def paged_response?
-          # Has the string next_page_token field to be used in the next request as page_token to retrieve the next page.
-          # Has only one repeated or map<string, ?> field containing a list of paginated resources.
-          !response_next_page_token_field.nil? && !response_results_field.nil?
-        end
-
-        ##
-        # The field in the response that holds a next page_token
-        #
-        # @return[Gapic::Schema::Field, nil]
-        def response_next_page_token_field
-          # Has the string next_page_token field to be used in the next request as page_token to retrieve the next page.
-          @response_next_page_token_field ||= @response.fields.find do |f|
-            f.name == "next_page_token" && f.type == :TYPE_STRING
-          end
-        end
-
-        ##
-        # The field in the response that holds the results
-        # For Regapic can be either a vanilla repeated field or a map
-        #
-        # @return [Gapic::Schema::Field, nil]
-        def response_results_field
-          @response_results_field ||= begin
-            map_fields = @response.fields.find_all(&:map?)
-            repeated_fields = @response.fields.find_all do |f|
-              !f.map? && f.label == :LABEL_REPEATED
-            end
-
-            if map_fields.count == 1
-              # If the response message has only one map<string, ?> field
-              # treat it as the one with paginated resources (i.e. ignore the repeated fields if any).
-              map_fields.first
-            elsif repeated_fields.count == 1 && map_fields.empty?
-              # If the response message contains only one repeated field,
-              # treat that field as the one containing the paginated resources.
-              repeated_fields.first
-            end
-            # If the response message contains more than one repeated field or does not have repeated fields at all
-            # but has more than one map<string, ?> field, do not generate any paginated methods for such rpc.
-          end
-        end
-
-        # @private
-        FIELD_TYPE_MAPPING = {
-          TYPE_DOUBLE: "::Float",
-          TYPE_FLOAT: "::Float",
-          TYPE_INT64: "::Integer",
-          TYPE_UINT64: "::Integer",
-          TYPE_INT32: "::Integer",
-          TYPE_FIXED64: "::Integer",
-          TYPE_FIXED32: "::Integer",
-          TYPE_BOOL: "::Boolean",
-          TYPE_STRING: "::String",
-          TYPE_BYTES: "::String",
-          TYPE_UINT32: "::Integer",
-          TYPE_SFIXED32: "::Integer",
-          TYPE_SFIXED64: "::Integer",
-          TYPE_SINT32: "::Integer",
-          TYPE_SINT64: "::Integer"
-        }.freeze
-        private_constant :FIELD_TYPE_MAPPING
-
-        ##
-        # A helper to get a Ruby doc-type for a paginated element.
-        #
-        # @param field [Gapic::Schema::Field]
-        #
-        # @return [String]
-        def field_paginated_elem_doc_type field
-          return field_paginated_elem_map_type field if field.map?
-          if field.message?
-            message_ruby_type field.message
-          elsif field.enum?
-            # TODO: handle when arg message is nil and enum is the type
-            message_ruby_type field.enum
-          else
-            FIELD_TYPE_MAPPING[field.type] || "::Object"
-          end
-        end
-
-        ##
-        # A helper to get a Ruby doc-type for a proto map's paginated element.
-        #
-        # @param field [Gapic::Schema::Field]
-        #
-        # @return [String]
-        def field_paginated_elem_map_type field
-          key_field = field.map_key_field
-          value_field = field.map_val_field
-
-          if key_field && value_field
-            key_type = field_paginated_elem_doc_type key_field
-            value_type = field_paginated_elem_doc_type value_field
-            "#{key_type}, #{value_type}"
-          else
-            class_name
-          end
-        end
-
-        ##
-        # A helper to get a Ruby type for a proto message.
-        #
-        # @param message [Gapic::Schema::Message]
-        #
-        # @return [String]
-        def message_ruby_type message
-          ruby_namespace @api, message.address.join(".")
-        end
-      end
-    end
-  end
-end