gapic-generator 0.10.1 → 0.45.1

data/lib/gapic/presenters/method_presenter.rb

@@ -32,15 +32,45 @@ module Gapic
       # @return [Gapic::Presenters::MethodRestPresenter]
       attr_accessor :rest
 
+      # @return [Gapic::Model::Method::Routing]
+      attr_accessor :routing
+
+      # @return [Gapic::Model::Method::HttpAnnotation]
+      attr_accessor :http
+
+      # @return [Array<Gapic::Presenters::Method::HttpBindingsPresenter>]
+      attr_accessor :http_bindings
+
+      # @return [Gapic::Model::Method::AipLro, Gapic::Model::Method::NonStandardLro, Gapic::Model::Method::NoLro]
+      attr_accessor :lro
+
+      # @return [String] String representation of this presenter type.
+      attr_reader :type
+
       ##
       # @param service_presenter [Gapic::Presenters::ServicePresenter]
       # @param api [Gapic::Schema::Api]
       # @param method [Gapic::Schema::Method]
+      #
       def initialize service_presenter, api, method
         @service_presenter = service_presenter
         @api = api
         @method = method
-        @rest = MethodRestPresenter.new self, api
+        @type = "method"
+
+        # Service config override should only happen for Operations.
+        # For the main services we expect service config overrides to be rolled into the protos by the publisher.
+        # For all other mixins, since we do not generate them for the service,
+        # the overrides should get configured separately.
+        is_lro = @service_presenter.address.join(".") == Gapic::Model::Mixins::LRO_SERVICE
+        service_config_override_http = is_lro ? @api.service_config : nil
+        @http = Gapic::Model::Method::HttpAnnotation.create_with_override @method, service_config_override_http
+
+        @http_bindings = @http.bindings.map { |binding| Gapic::Presenters::Method::HttpBindingPresenter.new binding }
+        @routing = Gapic::Model::Method::Routing.new @method.routing, @http
+        @lro = Gapic::Model::Method.parse_lro @method, @api
+
+        @rest = MethodRestPresenter.new self, @api
       end
 
       ##
@@ -50,8 +80,22 @@ module Gapic
         @service_presenter
       end
 
-      def snippet
-        SnippetPresenter.new self, @api
+      ##
+      # Return the "primary" snippet for this method. This should be used for
+      # inline snippets.
+      # @return [Gapic::Presenters::SnippetPresenter]
+      #
+      def snippet transport: nil
+        configs = @api.snippet_configs_for @method.full_name
+        SnippetPresenter.new self, @api, config: configs.first, transport: transport
+      end
+
+      ##
+      # @return [Array<Gapic::Presenters::SnippetPresenter>]
+      #
+      def all_snippets transport: nil
+        configs = @api.snippet_configs_for(@method.full_name) + [nil]
+        configs.map { |config| SnippetPresenter.new self, @api, config: config, transport: transport }
       end
 
       def generate_yardoc_snippets?
@@ -66,6 +110,18 @@ module Gapic
         end
       end
 
+      # Proto name of the method (PascalCase)
+      # @return [String]
+      def grpc_name
+        @method.name
+      end
+
+      # Fully qualified proto name of the method (namespace.PascalCase)
+      # @return [String]
+      def grpc_full_name
+        @method.full_name
+      end
+
       def kind
         if client_streaming?
           if server_streaming?
@@ -80,8 +136,15 @@ module Gapic
         end
       end
 
-      def doc_description
-        @method.docs_leading_comments
+      ##
+      # The description as it should appear in YARD docs.
+      #
+      # @param transport [:grpc,:rest] Whether xref links should go to REST or
+      #   gRPC client classes. Uses the default transport if not provided.
+      # @return [String]
+      #
+      def doc_description transport: nil
+        @method.docs_leading_comments transport: transport
       end
 
       def doc_response_type
@@ -98,7 +161,7 @@ module Gapic
       end
 
       ##
-      # @return [Boolean]
+      # @return [Boolean] Whether the method is marked as deprecated.
       #
       def is_deprecated?
         @method.is_deprecated?
@@ -109,6 +172,14 @@ module Gapic
         arguments.map { |arg| FieldPresenter.new @api, @method.input, arg }
       end
 
+      # @return [Array<Gapic::Presenters::FieldPresenter>] List of auto populated fields.
+      def auto_populated_fields
+        field_names_to_filter = @api.api_metadata.auto_populated_fields_by_method_name[name] || []
+        @method.input.fields.filter_map do |field|
+          FieldPresenter.new @api, @method.input, field if field_names_to_filter.include? field.name
+        end
+      end
+
       def fields
         @method.input.fields.map { |field| FieldPresenter.new @api, @method.input, field }
       end
@@ -152,25 +223,20 @@ module Gapic
         "Access the result along with the RPC operation"
       end
 
+      # Type for MethodPresenter#yield_params
+      YieldParams = Struct.new :name, :doc_types
+
       def yield_params
         if lro?
-          return [
-            OpenStruct.new(
-              name:      "operation",
-              doc_types: "::Gapic::Operation"
-            )
+          [
+            YieldParams.new("operation", "::Gapic::Operation")
+          ]
+        else
+          [
+            YieldParams.new("result", return_type),
+            YieldParams.new("operation", "::GRPC::ActiveCall::Operation")
           ]
         end
-        [
-          OpenStruct.new(
-            name:      "result",
-            doc_types: return_type
-          ),
-          OpenStruct.new(
-            name:      "operation",
-            doc_types: "::GRPC::ActiveCall::Operation"
-          )
-        ]
       end
 
       # @api.incode samples and sample_configs are yaml configuration files such as
@@ -183,12 +249,36 @@ module Gapic
         sample_configs.map { |sample_config| SamplePresenter.new @api, sample_config }
       end
 
+      ##
+      # Whether this method uses standard (AIP-151) LROs
+      #
+      # @return [Boolean]
+      #
       def lro?
         return paged_response_type == "::Google::Longrunning::Operation" if paged?
 
         return_type == "::Google::Longrunning::Operation"
       end
 
+      ##
+      # Whether this method uses nonstandard LROs
+      #
+      # @return [Boolean]
+      #
+      def nonstandard_lro?
+        @lro.nonstandard_lro?
+      end
+
+      ##
+      # The presenter for the nonstandard LRO client of the kind this method uses
+      #
+      # @return [Gapic::Presenters::Service::LroClientPresenter, nil]
+      #
+      def nonstandard_lro_client
+        return unless nonstandard_lro?
+        service.nonstandard_lros.find { |model| model.service == @lro.service_full_name }
+      end
+
       def client_streaming?
         @method.client_streaming
       end
@@ -216,24 +306,35 @@ module Gapic
         return nil unless paged_response? @method.output
 
         repeated_field = @method.output.fields.find do |f|
-          f.label == Google::Protobuf::FieldDescriptorProto::Label::LABEL_REPEATED &&
-            f.type == Google::Protobuf::FieldDescriptorProto::Type::TYPE_MESSAGE
+          f.label == :LABEL_REPEATED && f.type == :TYPE_MESSAGE
         end
         message_ruby_type repeated_field.message
       end
 
+      ##
+      # @return [String] The name of the repeated field in paginated responses
+      #
+      def paged_response_repeated_field_name
+        return nil unless paged_response? @method.output
+
+        repeated_field = @method.output.fields.find do |f|
+          f.label == :LABEL_REPEATED && f.type == :TYPE_MESSAGE
+        end
+        repeated_field.name
+      end
+
       ##
       # @return [Array<String>] The segment key names.
       #
       def routing_params
-        rest.routing_params
+        @http.routing_params
       end
 
       ##
       # @return [Boolean] Whether any routing params are present
       #
       def routing_params?
-        rest.routing_params?
+        @routing.routing_params?
       end
 
       def grpc_service_config
@@ -243,8 +344,8 @@ module Gapic
         end
       end
 
-      def service_config_presenter
-        ServiceConfigPresenter.new grpc_service_config
+      def grpc_service_config_presenter
+        GrpcServiceConfigPresenter.new grpc_service_config
       end
 
       def grpc_method_name
@@ -264,12 +365,25 @@ module Gapic
         { methods: [name] }
       end
 
+      ##
+      # Whether this method can be generated in REST clients
+      # Only methods with http bindings can be generated, and
+      # additionally only unary methods are currently supported.
+      #
+      # @return [Boolean]
+      #
+      def can_generate_rest?
+        rest.can_generate_rest?
+      end
+
       protected
 
       def message_ruby_type message
         ruby_namespace @api, message.address.join(".")
       end
 
+      # @private
+      # BUG: This code seems to be dead
       def doc_types_for arg
         if arg.message?
           "#{message_ruby_type arg.message}, Hash"
@@ -288,12 +402,16 @@ module Gapic
         end
       end
 
+      # @private
+      # BUG: This code seems to be dead
       def doc_desc_for arg
         return nil if arg.docs.leading_comments.empty?
 
         arg.docs.leading_comments
       end
 
+      # @private
+      # BUG: This code seems to be dead
       def default_value_for arg
         if arg.message?
           "{}"
@@ -315,14 +433,11 @@ module Gapic
 
       def paged_request? request
         page_token = request.fields.find do |f|
-          f.name == "page_token" && f.type == Google::Protobuf::FieldDescriptorProto::Type::TYPE_STRING
+          f.name == "page_token" && f.type == :TYPE_STRING
         end
         return false if page_token.nil?
 
-        page_size_types = [
-          Google::Protobuf::FieldDescriptorProto::Type::TYPE_INT32,
-          Google::Protobuf::FieldDescriptorProto::Type::TYPE_INT64
-        ]
+        page_size_types = [:TYPE_INT32, :TYPE_INT64]
         page_size = request.fields.find do |f|
           f.name == "page_size" && page_size_types.include?(f.type)
         end
@@ -333,13 +448,12 @@ module Gapic
 
       def paged_response? response
         next_page_token = response.fields.find do |f|
-          f.name == "next_page_token" && f.type == Google::Protobuf::FieldDescriptorProto::Type::TYPE_STRING
+          f.name == "next_page_token" && f.type == :TYPE_STRING
         end
         return false if next_page_token.nil?
 
         repeated_field = response.fields.find do |f|
-          f.label == Google::Protobuf::FieldDescriptorProto::Label::LABEL_REPEATED &&
-            f.type == Google::Protobuf::FieldDescriptorProto::Type::TYPE_MESSAGE
+          f.label == :LABEL_REPEATED && f.type == :TYPE_MESSAGE
         end
         return false if repeated_field.nil?
 

data/lib/gapic/presenters/method_rest_presenter.rb

@@ -15,7 +15,6 @@
 # limitations under the License.
 
 require "gapic/presenters/method/rest_pagination_info"
-require "gapic/uri_template"
 
 module Gapic
   module Presenters
@@ -24,243 +23,155 @@ module Gapic
     #
     class MethodRestPresenter
       # @return [Gapic::Presenters::Method::RestPaginationInfo]
-      attr_reader :pagination
+      attr_reader :compute_pagination
+
+      attr_reader :http_bindings
+
+      # @return [String] String representation of this presenter type.
+      attr_reader :type
 
       ##
       # @param main_method [Gapic::Presenters::MethodPresenter] the main presenter for this method.
       # @param api [Gapic::Schema::Api]
       #
       def initialize main_method, api
-        @api = api
         @main_method = main_method
-        @proto_method = main_method.method
-
-        @pagination = Gapic::Presenters::Method::RestPaginationInfo.new @proto_method, api
+        @http_bindings = main_method.http_bindings
+        @compute_pagination =
+          if @main_method.service.special_compute_behavior?
+            Gapic::Presenters::Method::RestPaginationInfo.new main_method.method, api
+          end
+        @type = "method"
       end
 
       ##
-      # @return [Boolean] Whether a http verb is present for this method
+      # Name for the GRPC transcoding helper method
       #
-      def verb?
-        !verb.nil?
-      end
-
-      ##
-      # @return [Symbol] a http verb for this method
+      # @return [String]
       #
-      def verb
-        return nil if @proto_method.http.nil?
-
-        method = {
-          get:    @proto_method.http.get,
-          post:   @proto_method.http.post,
-          put:    @proto_method.http.put,
-          patch:  @proto_method.http.patch,
-          delete: @proto_method.http.delete
-        }.find { |_, value| !value.empty? }
-
-        method[0] unless method.nil?
+      def transcoding_helper_name
+        "transcode_#{name}_request"
       end
 
       ##
-      # @return [Boolean] Whether a method path is present and non-empty
+      # Method name
       #
-      def path?
-        !path.empty?
-      end
-
-      ##
-      # @return [String] A method path or an empty string if not present
+      # @return [String]
       #
-      def path
-        return "" if @proto_method.http.nil?
-
-        verb_path = [
-          @proto_method.http.get, @proto_method.http.post, @proto_method.http.put,
-          @proto_method.http.patch, @proto_method.http.delete
-        ].find { |x| !x.empty? }
-
-        verb_path || @proto_method.http.custom&.path || ""
+      def name
+        @main_method.name
       end
 
-      ##
-      # @return [Boolean] Whether any routing params are present
-      #
-      def routing_params?
-        routing_params.any?
+      # Fully qualified proto name of the method (namespace.PascalCase)
+      # @return [String]
+      def grpc_full_name
+        @main_method.grpc.full_name
       end
 
       ##
-      # @return [Array<String>] The segment key names.
+      # Full class name of the request type
       #
-      def routing_params
-        Gapic::UriTemplate.parse_arguments path
-      end
-
-      ##
-      # Performs a limited version of grpc transcoding to create a string that will interpolate
-      # the values from the request object to create a request URI at runtime.
-      # Currently only supports "value" into "request_object.value"
-      # @param [String] request_obj_name the name of the request object for the interpolation
-      #   defaults to "request_pb"
-      # @return [String] A string to interpolate values from the request object into URI
+      # @return [String]
       #
-      def uri_interpolated request_obj_name = "request_pb"
-        return path unless routing_params?
-
-        routing_params.reduce path do |uri, param|
-          param_esc = Regexp.escape param
-          uri.gsub(/{#{param_esc}[^}]*}/, "\#{#{request_obj_name}.#{param}}")
-        end
+      def request_type
+        @main_method.request_type
       end
 
       ##
-      # @return [Boolean] Whether method has body specified in proto
+      # Full class name of the raw return type of the RPC
       #
-      def body?
-        return false if @proto_method.http.nil?
-
-        !@proto_method.http.body.empty?
-      end
-
-      ##
-      # Name of the variable to use for storing the body result of the transcoding call
-      # Normally "body" but use "_body" for discarding the result for
-      # the calls that do not send body
       # @return [String]
-      def body_var_name
-        body? ? "body" : "_body"
-      end
-
-      ##
-      # @return [String] A body specified for the given method in proto or an empty string if not specified
-      #
-      def body
-        @proto_method.http&.body || ""
-      end
-
-      ##
-      # @return [Boolean] True if body contains full request object (`*` in the annotation), false otherwise
       #
-      def body_is_request_object?
-        body == "*"
+      def return_type
+        @main_method.return_type
       end
 
       ##
-      # Performs a limited version of grpc transcoding to create a string that will interpolate
-      # the values from the request object to create a request body at runtime.
-      # Currently only supports either "*" for "the whole request object" or
-      # "value" for "request_object.value"
-      #
-      # @param [String] request_obj_name the name of the request object for the interpolation
-      #   defaults to "request_pb"
+      # Full class name of the return type of the method
+      # (including LRO and Paged cases)
       #
-      # @return [String] A string to interpolate values from the request object into body
+      # @return [String]
       #
-      def body_interpolated request_obj_name = "request_pb"
-        return "\"\"" unless body?
-
-        return "#{request_obj_name}.to_json" if body_is_request_object?
-
-        "#{request_obj_name}.#{body}.to_json"
+      def doc_response_type
+        return "::Gapic::Operation" if lro?
+        if paged?
+          elem_type = compute_pagination&.paged_element_doc_type || @main_method.paged_response_type
+          return "::Gapic::Rest::PagedEnumerable<#{elem_type}>"
+        end
+        return "::Gapic::GenericLRO::Operation" if nonstandard_lro?
+        return_type
       end
 
       ##
-      # @return [Boolean] whether any query string parameters are present
+      # @return [String] The name of the repeated field in paginated responses
       #
-      def query_string_params?
-        query_string_params.any?
-      end
-
-      # @return [Array<String>]
-      def query_string_params
-        return [] if body_is_request_object?
-
-        routing_params_set = routing_params.to_set
-        @main_method.arguments
-                    .reject { |arg| routing_params_set.include? arg.name }
-                    .reject { |arg| body == arg.name }
-                    .reject(&:message?)
-                    .reject { |arg| arg.default_value_for_type.nil? }
-      end
-
-      ##
-      # Name of the variable to use for storing the query_string_params result of the transcoding call
-      # Normally "query_string_params" but use "_query_string_params" for discarding the result for
-      # the calls that do not sent query_string_params
-      # @return [String]
-      def query_string_params_var_name
-        query_string_params? ? "query_string_params" : "_query_string_params"
+      def paged_response_repeated_field_name
+        if compute_pagination
+          compute_pagination.response_repeated_field_name
+        else
+          @main_method.paged_response_repeated_field_name
+        end
       end
 
       ##
-      # Name for the GRPC transcoding helper method
+      # Whether the REGAPIC method should be rendered as paged
       #
-      # @return [String]
-      def transcoding_helper_name
-        "transcode_#{name}_request"
+      # @return [Boolean]
+      #
+      def paged?
+        compute_pagination ? compute_pagination.paged? : @main_method.paged?
       end
 
-      ##
-      # Method name
-      #
-      # @return [String]
-      #
-      def name
-        @main_method.name
+      def lro?
+        @main_method.lro?
       end
 
       ##
-      # Full class name of the request type
+      # Whether this method uses nonstandard LROs
       #
-      # @return [String]
+      # @return [Boolean]
       #
-      def request_type
-        @main_method.request_type
+      def nonstandard_lro?
+        @main_method.nonstandard_lro?
       end
 
       ##
-      # Full class name of the raw return type of the RPC
+      # The presenter for the nonstandard LRO client of the kind this method uses
       #
-      # @return [String]
+      # @return [Gapic::Presenters::Service::LroClientPresenter, nil]
       #
-      def return_type
-        @main_method.return_type
+      def nonstandard_lro_client
+        return unless nonstandard_lro?
+        @main_method.service.rest.nonstandard_lros.find { |model| model.service == @main_method.lro.service_full_name }
       end
 
       ##
-      # Full class name of the return type of the method
-      # (including LRO and Paged cases)
+      # Whether this method can be generated in REST clients
+      # Only methods with http bindings can be generated, and
+      # additionally only unary methods are currently supported.
       #
-      # @return [String]
+      # @return [Boolean]
       #
-      def doc_response_type
-        return "::Gapic::Rest::PagedEnumerable<#{pagination.paged_element_doc_type}>" if paged?
-        return "::Gapic::Rest::BaseOperation" if lro?
-        return_type
+      def can_generate_rest?
+        [:normal, :server].include?(@main_method.kind) &&
+          http_bindings.first&.verb? &&
+          http_bindings.first&.path?
       end
 
       ##
-      # Whether the REGAPIC method should be rendered as paged
+      # Whether this method is a server-streaming method
       #
       # @return [Boolean]
       #
-      def paged?
-        @pagination.paged?
+      def server_streaming?
+        @main_method.server_streaming?
       end
 
       ##
-      # Whether the REGAPIC method should be rendered as LRO
-      # [TODO (virost, 2021-08) Update this when DiReGapic LRO annotations are added to the Compute protos]
+      # @return [Boolean] Whether the method is marked as deprecated.
       #
-      # @return [Boolean]
-      #
-      def lro?
-        return_type == "::Google::Cloud::Compute::V1::Operation" &&
-          @main_method.service.name != "ZoneOperations" &&
-          @main_method.service.name != "RegionOperations" &&
-          @main_method.service.name != "GlobalOperations" &&
-          @main_method.service.name != "GlobalOrganizationOperations"
+      def is_deprecated?
+        @main_method.is_deprecated?
       end
     end
   end