gapic-generator 0.11.0 → 0.45.1

data/lib/gapic/presenters/method_presenter.rb

@@ -38,22 +38,39 @@ module Gapic
       # @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
-        @http = Gapic::Model::Method::HttpAnnotation.new @method
-        @routing = Gapic::Model::Method::Routing.new @method.routing, http
-        @lro = Gapic::Model::Method.parse_lro @method, 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
+        @rest = MethodRestPresenter.new self, @api
       end
 
       ##
@@ -64,10 +81,21 @@ module Gapic
       end
 
       ##
+      # Return the "primary" snippet for this method. This should be used for
+      # inline snippets.
       # @return [Gapic::Presenters::SnippetPresenter]
       #
-      def snippet
-        SnippetPresenter.new self, @api
+      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?
@@ -82,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?
@@ -96,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
@@ -114,7 +161,7 @@ module Gapic
       end
 
       ##
-      # @return [Boolean]
+      # @return [Boolean] Whether the method is marked as deprecated.
       #
       def is_deprecated?
         @method.is_deprecated?
@@ -125,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
@@ -168,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
@@ -256,17 +306,28 @@ 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
 
       ##
@@ -304,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"
@@ -328,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?
           "{}"
@@ -355,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
@@ -373,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

@@ -23,147 +23,32 @@ 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
-        @http = main_method.http
-
-        @pagination = Gapic::Presenters::Method::RestPaginationInfo.new @proto_method, api
-      end
-
-      ##
-      # @return [Boolean] Whether a http verb is present for this method
-      #
-      def verb?
-        @http.verb?
-      end
-
-      ##
-      # @return [Symbol] a http verb for this method
-      #
-      def verb
-        @http.verb
-      end
-
-      ##
-      # @return [Boolean] Whether a method path is present and non-empty
-      #
-      def path?
-        @http.path?
-      end
-
-      ##
-      # @return [Boolean] Whether any routing params are present
-      #
-      def routing_params?
-        @http.routing_params?
-      end
-
-      ##
-      # @return [Array<String>] The segment key names.
-      #
-      def routing_params
-        @http.routing_params
-      end
-
-      ##
-      # @return [Boolean] Whether method has body specified in proto
-      #
-      def body?
-        @http.body?
-      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
-      #
-      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
-      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 [Boolean] True if body contains full request object (`*` in the annotation), false otherwise
-      #
-      def body_is_request_object?
-        body == "*"
-      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"
-      #
-      # @return [String] A string to interpolate values from the request object into body
-      #
-      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"
-      end
-
-      ##
-      # @return [Boolean] whether any query string parameters are present
-      #
-      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"
+        @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
 
       ##
       # Name for the GRPC transcoding helper method
       #
       # @return [String]
+      #
       def transcoding_helper_name
         "transcode_#{name}_request"
       end
@@ -177,6 +62,12 @@ 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
+
       ##
       # Full class name of the request type
       #
@@ -202,18 +93,37 @@ module Gapic
       # @return [String]
       #
       def doc_response_type
-        return "::Gapic::Rest::PagedEnumerable<#{pagination.paged_element_doc_type}>" if paged?
+        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 [String] The name of the repeated field in paginated responses
+      #
+      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
+
       ##
       # Whether the REGAPIC method should be rendered as paged
       #
       # @return [Boolean]
       #
       def paged?
-        @pagination.paged?
+        compute_pagination ? compute_pagination.paged? : @main_method.paged?
+      end
+
+      def lro?
+        @main_method.lro?
       end
 
       ##
@@ -225,20 +135,43 @@ module Gapic
         @main_method.nonstandard_lro?
       end
 
-      private
+      ##
+      # 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?
+        @main_method.service.rest.nonstandard_lros.find { |model| model.service == @main_method.lro.service_full_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?
+        [:normal, :server].include?(@main_method.kind) &&
+          http_bindings.first&.verb? &&
+          http_bindings.first&.path?
+      end
 
       ##
-      # @return [String] A method path or an empty string if not present
+      # Whether this method is a server-streaming method
+      #
+      # @return [Boolean]
       #
-      def path
-        @http.path
+      def server_streaming?
+        @main_method.server_streaming?
       end
 
       ##
-      # @return [String] A body specified for the given method in proto or an empty string if not specified
+      # @return [Boolean] Whether the method is marked as deprecated.
       #
-      def body
-        @http.body
+      def is_deprecated?
+        @main_method.is_deprecated?
       end
     end
   end

data/lib/gapic/presenters/package_presenter.rb

@@ -61,16 +61,68 @@ module Gapic
       def services
         @services ||= begin
           files = @api.generate_files.select { |f| f.package == @package }
-          services = files.map(&:services).flatten
+          service_list = files.map(&:services).flatten
+          mixin_service_names = gem.mixins_model.mixin_services
+          service_list.delete_if { |s| mixin_service_names.include? s.full_name }
           # Omit common services in this package. Common service clients do not
           # go into their own package.
-          normal_services = services.select { |s| @api.delegate_service_for(s).nil? }
+          normal_services = service_list.select { |s| @api.delegate_service_for(s).nil? }
           # But include common services that delegate to normal services in this package.
           common_services = normal_services.flat_map { |s| @api.common_services_for s }
           (normal_services + common_services).map { |s| ServicePresenter.new @gem_presenter, @api, s }
         end
       end
 
+      ##
+      # @return [Boolean] Whether the generation of REST clients is requested
+      #    and can be done because at least one method has rest bindings.
+      #
+      def generate_rest_clients?
+        @api.generate_rest_clients? && !first_service_with_rest.nil?
+      end
+
+      ##
+      # @return [Boolean] Whether the generation of gRPC clients is requested
+      #
+      def generate_grpc_clients?
+        @api.generate_grpc_clients?
+      end
+
+      ##
+      # First service with REST bindings.
+      # @return [Gapic::Presenters::ServicePresenter, nil]
+      #
+      def first_service_with_rest
+        services.find(&:methods_rest_bindings?)
+      end
+
+      ##
+      # Whether there are mixin services that this package has http binding overrides for.
+      #
+      # @return [Boolean]
+      #
+      def mixin_binding_overrides?
+        first_service_with_rest&.rest&.mixin_binding_overrides? || false
+      end
+
+      ##
+      # Requires path for the mixin binding overrides file
+      #
+      # @return [String]
+      #
+      def mixin_binding_overrides_require
+        "#{ruby_file_path @api, namespace}/bindings_override"
+      end
+
+      ##
+      # File path for the mixin binding overrides file
+      #
+      # @return [String]
+      #
+      def mixin_binding_overrides_file_path
+        "#{mixin_binding_overrides_require}.rb"
+      end
+
       def address
         @package.split "."
       end
@@ -79,10 +131,18 @@ module Gapic
         ruby_file_path @api, namespace
       end
 
+      def package_rest_require
+        "#{ruby_file_path @api, namespace}/rest"
+      end
+
       def package_file_path
         "#{package_require}.rb"
       end
 
+      def package_rest_file_path
+        "#{package_rest_require}.rb"
+      end
+
       def package_directory_name
         package_require.split("/").last
       end
@@ -117,24 +177,9 @@ module Gapic
           language:       "ruby",
           protoPackage:   name,
           libraryPackage: namespace,
-          services:       services.map { |s| [s.grpc_service_name, s.drift_manifest] }.to_h
+          services:       services.to_h { |s| [s.grpc_service_name, s.drift_manifest] }
         }
       end
-
-      ##
-      # How comments in the generated libraries refer to the GRPC client
-      # if no REST code is generated, this should just be "client",
-      # if REST code is generated, this should be disambiguated into the "GRPC client"
-      #
-      # Since we are using first service for an indication of whether package generates
-      # REST code, it's OK to defer this to the first service as well.
-      # For packages with no services the value of this does not really matter as
-      # no client generation docs will be generated.
-      #
-      # @return [String]
-      def grpc_client_designation
-        services.first&.grpc_client_designation || ""
-      end
     end
   end
 end

data/lib/gapic/presenters/resource_presenter.rb

@@ -15,7 +15,6 @@
 # limitations under the License.
 
 require "gapic/path_pattern"
-require "active_support/inflector"
 
 module Gapic
   module Presenters
@@ -58,12 +57,10 @@ module Gapic
       #
       class PatternPresenter
         def initialize pattern_string
-          @pattern = pattern_string
           @parsed_pattern = Gapic::PathPattern.parse pattern_string
           @path_string = build_path_string
         end
 
-        attr_reader :pattern
         attr_reader :path_string
 
         def pattern_template
@@ -78,6 +75,11 @@ module Gapic
           @parsed_pattern.arguments
         end
 
+        # @return [String] The conflicting argument name escaped with local binding.
+        def escape_argument arg
+          Gapic::RubyInfo.keywords.include?(arg) ? "binding.local_variable_get(:#{arg})" : arg
+        end
+
         def formal_arguments
           @parsed_pattern.arguments.map { |name| "#{name}:" }.join ", "
         end
@@ -103,6 +105,10 @@ module Gapic
           end.join "/"
         end
 
+        def pattern
+          @parsed_pattern.path_pattern
+        end
+
         private
 
         def build_path_string