gapic-generator 0.11.0 → 0.45.1

data/lib/gapic/presenters/service_rest_presenter.rb

@@ -17,6 +17,7 @@
 require "active_support/inflector"
 require "gapic/helpers/filepath_helper"
 require "gapic/helpers/namespace_helper"
+require "forwardable"
 
 module Gapic
   module Presenters
@@ -27,6 +28,18 @@ module Gapic
       include Gapic::Helpers::FilepathHelper
       include Gapic::Helpers::NamespaceHelper
 
+      extend Forwardable
+      def_delegators :@main_service, :name, :helpers_file_name, :is_hosted_mixin?, :is_main_mixin_service?, :mixins?,
+                     :mixin_binding_overrides?, :grpc_service_config, :grpc_service_config_presenter, :lro_service,
+                     :lro_client_var, :nonstandard_lro_provider?, :credentials_class_xref, :client_name, :module_name,
+                     :grpc_full_name, :client_suffix_for_default_transport, :client_endpoint_template
+
+      # The namespace of the service. (not the client)
+      # Intentionally does not include "Rest", since
+      # we do not want Rest service's configuration to
+      # default to GRPC configuration (right now).
+      def_delegators :@main_service, :namespace
+
       ##
       # @param main_service [Gapic::Presenters::ServicePresenter]
       # @param api [Gapic::Schema::Api]
@@ -34,15 +47,7 @@ module Gapic
       def initialize main_service, api
         @main_service = main_service
         @api = api
-      end
-
-      ##
-      # Ruby name of this service
-      #
-      # @return [String]
-      #
-      def name
-        main_service.name
+        @type = "service"
       end
 
       ##
@@ -65,11 +70,12 @@ module Gapic
 
       ##
       # Folder name for this service
+      # This is just "rest" for rest services
       #
       # @return [String]
       #
       def service_directory_name
-        service_require.split("/")[-2]
+        "rest"
       end
 
       ##
@@ -100,13 +106,6 @@ module Gapic
         "#{service_stub_require}.rb"
       end
 
-      ##
-      # @return [String]
-      #
-      def client_name
-        main_service.client_name
-      end
-
       ##
       # @return [String]
       #
@@ -153,14 +152,7 @@ module Gapic
       # @return [String]
       #
       def test_client_file_path
-        main_service.service_file_path.sub ".rb", "_test.rb"
-      end
-
-      ##
-      # @return [String]
-      #
-      def credentials_class_xref
-        main_service.credentials_class_xref
+        main_service.service_file_path.sub ".rb", "_rest_test.rb"
       end
 
       ##
@@ -215,13 +207,141 @@ module Gapic
         ruby_file_path @api, "#{service_name_full}::#{nonstandard_lro_name}"
       end
 
+      ##
+      # A presenter for the LRO subclient if needed
+      #
+      # @return [Gapic::Presenters::Service::LroClientPresenter, nil]
+      def lro_client_presenter
+        return nil unless lro?
+        Gapic::Presenters::Service::LroClientPresenter.new service: "google.longrunning.operations",
+                                                           client_class_name: "Operations",
+                                                           client_class_docname: operations_name_full,
+                                                           client_var_name: lro_client_var,
+                                                           require_str: operations_file_path,
+                                                           service_description: "long-running operations"
+      end
+
+      ##
+      # Whether an AIP-151 LRO subclient needs to be generated for this service
+      #
+      # @return [Boolean]
+      def lro?
+        methods.find(&:lro?)
+      end
+
+      def operations_name
+        "Operations"
+      end
+
+      def operations_name_full
+        fix_namespace @api, "#{service_name_full}::#{operations_name}"
+      end
+
+      def operations_file_path
+        "#{operations_require}.rb"
+      end
+
+      def operations_file_name
+        operations_file_path.split("/").last
+      end
+
+      def operations_require
+        ruby_file_path @api, "#{service_name_full}::#{operations_name}"
+      end
+
+      def operations_stub_name
+        "OperationsServiceStub"
+      end
+
+      ##
+      # The client presenters of the nonstandard LROs that are used by the methods of this service
+      #
+      # @return [Enumerable<Gapic::Presenters::Service::LroClientPresenter>]
+      def nonstandard_lros
+        return [] unless main_service.nonstandard_lro_consumer?
+        main_service.nonstandard_lros_models.map do |lro|
+          lro_wrapper = @api.lookup lro.service_full_name
+          lro_service = ServicePresenter.new(main_service.gem, @api, lro_wrapper).rest
+
+          service_description = "long-running operations via #{lro_service.name}"
+          client_var_name = ruby_file_path_for_namespace lro_service.name
+          Gapic::Presenters::Service::LroClientPresenter.new service: lro.service_full_name,
+                                                             client_class_name: lro_service.client_name_full,
+                                                             client_class_docname: lro_service.client_name_full,
+                                                             client_var_name: client_var_name,
+                                                             require_str: lro_service.service_require,
+                                                             service_description: service_description,
+                                                             helper_type: lro_service.nonstandard_lro_name_full
+        end
+      end
+
+      ##
+      # Whether config for this service should include the `bindings_override` field.
+      # This field is needed:
+      #   * if a service is a mixin in it's own package, e.g. `google.Cloud.Location`
+      #   * if a service hosts a mixin and has bindings overrides for it
+      # but the generated Operations clients should not have it since override for
+      # their bindings are generated instead of set during runtime.
+      #
+      def mixin_should_generate_override_config?
+        (is_main_mixin_service? || main_service.mixin_binding_overrides?) &&
+          main_service.grpc_full_name != "google.longrunning.Operations"
+      end
+
+      ##
+      # The client presenters of the mixin services that are used by the methods of this service
+      #
+      # @return [Enumerable<Gapic::Presenters::Service::MixinClientPresenter>]
+      def mixin_presenters
+        return [] unless main_service.mixins?
+        main_service.mixin_presenters.map do |grpc_presenter|
+          model = main_service.mixin_models.find { |mdl| mdl.service == grpc_presenter.service }
+          raise "Mismatch between model and presenters in service #{service_name_full}" unless model
+
+          Gapic::Presenters::Service::MixinClientPresenter.new service: model.service,
+                                                               client_class_name: model.client_class_name_rest,
+                                                               client_class_docname: model.client_class_docname_rest,
+                                                               client_var_name: model.client_var_name,
+                                                               require_str: model.require_str_rest,
+                                                               service_description: model.service_description,
+                                                               bindings_override: grpc_presenter.bindings_override
+        end
+      end
+
+      ##
+      # Whether there are any subclients to generate with this service.
+      # Subclients are the clients to other services (e.g. an LRO provider service).
+      #
+      # @return [Boolean]
+      def subclients?
+        subclients.any?
+      end
+
+      ##
+      # Subclients for this service
+      # Subclients are the clients to other services (e.g. an LRO provider service).
+      #
+      # The following is typically generated for a subclient:
+      # - a require statement for the subclient's class
+      # - a class-level variable in the host service's client
+      # - a code to initialize this variable with a subclient's class instance in the host service's constructor
+      #
+      # @return [Enumerable<Gapic::Presenters::Service::LroClientPresenter, Gapic::Model::Mixins::Mixin>]
+      def subclients
+        [lro_client_presenter, mixin_presenters, nonstandard_lros].flatten.compact
+      end
+
+      def lro_subclients
+        [lro_client_presenter, nonstandard_lros].flatten.compact
+      end
+
       ##
       # The method to use for quick start samples. Normally this is simply the
       # first non-client-streaming method defined, but it can be overridden via
       # a gem config.
       #
       # @return [Gapic::Presenters::MethodRestPresenter] if there is a method
-      #     appropriatke for quick start
+      #     appropriate for quick start
       # @return [nil] if there is no method appropriate for quick start
       #
       def quick_start_method
@@ -229,10 +349,41 @@ module Gapic
       end
 
       ##
+      # Presenters for methods that can be generated in REST clients.
+      #
       # @return [Enumerable<Gapic::Presenters::MethodPresenter>]
       #
       def methods
-        main_service.methods
+        main_service.methods.select(&:can_generate_rest?)
+      end
+
+      ##
+      # Require string for the helpers file
+      #
+      # @return [String]
+      #
+      def helpers_require
+        ruby_file_path @api, "#{service_name_full}::Helpers"
+      end
+
+      ##
+      # Whether this rest service should send the numeric enums signal
+      # @return [Boolean]
+      #
+      def numeric_enums?
+        main_service.gem.rest_numeric_enums?
+      end
+
+      ##
+      # @return [Boolean] Whether the service is marked as deprecated.
+      #
+      def is_deprecated?
+        @main_service.is_deprecated?
+      end
+
+      # @return [String] The api_version for this service, or empty if not defined.
+      def api_version
+        @main_service.api_version.to_s
       end
 
       private
@@ -241,6 +392,8 @@ module Gapic
       attr_reader :main_service
       # @return [Gapic::Schema::Api]
       attr_reader :api
+      # @return [String] String representation of this presenter type.
+      attr_reader :type
     end
   end
 end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# Copyright 2022 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
+    class SnippetPresenter
+      ##
+      # Presentation information about client call invocation
+      #
+      class ClientCallPresenter
+        ##
+        # Create a client call presenter
+        #
+        # @param proto [Google::Cloud::Tools::SnippetGen::ConfigLanguage::V1::Snippet::ClientCall]
+        #     The protobuf representation
+        # @param json [String]
+        #     The JSON representation
+        # @param method_name [String] The method name
+        # @param request_name [String] The request variable name
+        # @param response_name [String,nil] The response variable name, or nil for no response handling
+        # @param client_streaming [Boolean] True if the call is client streaming
+        # @param server_streaming [Boolean] True if the call is server streaming
+        # @param phase1 [Boolean] True if this is a phase 1 snippet without config
+        #
+        def initialize proto, json,
+                       method_name:, request_name:, response_name:, client_streaming:, server_streaming:, phase1:
+          @render_lines = pre_call_lines proto, json, method_name, client_streaming, server_streaming, phase1
+          main_line = "client.#{method_name} #{request_name}"
+          main_line = "#{response_name} = #{main_line}" if response_name
+          @render_lines << main_line
+          @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
+
+        private
+
+        def pre_call_lines proto, json, method_name, client_streaming, server_streaming, phase1
+          lines = []
+          if json&.key? "preCall"
+            proto.pre_call.each_with_index do |statement_proto, index|
+              statement = StatementPresenter.new statement_proto, json["preCall"][index]
+              lines += statement.render_lines
+            end
+          elsif phase1
+            lines <<
+              if client_streaming || server_streaming
+                "# Call the #{method_name} method to start streaming."
+              else
+                "# Call the #{method_name} method."
+              end
+          end
+          lines
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+# Copyright 2022 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
+    class SnippetPresenter
+      ##
+      # Presentation information about client object initialization
+      #
+      class ClientInitializationPresenter
+        ##
+        # Create an client init presenter.
+        #
+        # @param proto [Google::Cloud::Tools::SnippetGen::ConfigLanguage::V1::Snippet::ClientInitialization]
+        #     The protobuf representation
+        # @param json [String]
+        #     The JSON representation
+        # @param phase1 [Boolean] Whether to inject phase 1 content
+        # @param client_type [String] The fully qualified class name of the client
+        #
+        def initialize proto, json, phase1:, client_type:
+          @render_lines = []
+          if json&.key? "preClientInitialization"
+            proto.pre_client_initialization.each_with_index do |stmt_proto, index|
+              statement = StatementPresenter.new stmt_proto, json["preClientInitialization"][index]
+              @render_lines += statement.render_lines
+            end
+          elsif phase1
+            @render_lines << "# Create a client object. The client can be reused for multiple calls."
+          end
+          @render_lines += build_create_code proto, client_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
+
+        private
+
+        def build_create_code proto, client_type
+          create_code = "client = #{client_type}.new"
+          if proto&.custom_service_endpoint
+            endpoint = build_endpoint proto.custom_service_endpoint
+            [
+              "#{create_code} do |config|",
+              "  config.endpoint = #{endpoint.inspect}",
+              "end"
+            ]
+          else
+            [create_code]
+          end
+        end
+
+        def build_endpoint proto
+          init_module = Google::Cloud::Tools::SnippetGen::ConfigLanguage::V1::Snippet::ClientInitialization
+          schema = proto.schema == init_module::ServiceEndpoint::ServiceEndpointSchema::HTTP ? "http://" : "https://"
+          region = proto.region.to_s.empty? ? "" : "#{proto.region}-"
+          port = proto.port.zero? ? "" : ":#{proto.port}"
+          [schema, region, proto.host, port].join
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# Copyright 2022 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
+    class SnippetPresenter
+      ##
+      # Presentation information about a declaration
+      #
+      class DeclarationPresenter
+        ##
+        # Create a declaration presenter.
+        #
+        # @param proto [Google::Cloud::Tools::SnippetGen::ConfigLanguage::V1::Statement::Declaration]
+        #     The protobuf representation of the declaration
+        # @param json [String]
+        #     The JSON representation of the declaration
+        #
+        def initialize proto, json
+          @render = @render_lines = @name = @description = @has_value = nil
+          return unless proto && json
+          @name = proto.name
+          @description = proto.description unless proto.description.empty?
+          @render_lines = @description ? ["# #{@description}"] : []
+          expr = ExpressionPresenter.new proto.value, json["value"]
+          @has_value = expr.exist?
+          if @has_value
+            expr_lines = expr.render_lines
+            expr_lines[0] = "#{proto.name} = #{expr_lines.first}"
+            @render_lines += expr_lines
+          end
+          @render = @render_lines.join "\n"
+        end
+
+        ##
+        # The name of the variable being declared
+        # @return [String]
+        #
+        attr_reader :name
+
+        ##
+        # The description, or nil if none
+        # @return [String,nil]
+        #
+        attr_reader :description
+
+        ##
+        # 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
+
+        ##
+        # Whether the declaration could be interpreted.
+        # @return [Boolean]
+        #
+        def exist?
+          !render_lines.nil?
+        end
+
+        ##
+        # Whether the declaration includes a value.
+        # @return [Boolean]
+        #
+        def value?
+          @has_value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+# Copyright 2022 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
+    class SnippetPresenter
+      ##
+      # Presentation information about an expression
+      #
+      class ExpressionPresenter
+        ##
+        # Create an expression presenter.
+        #
+        # @param proto [Google::Cloud::Tools::SnippetGen::ConfigLanguage::V1::Expression]
+        #     The protobuf representation of the expression
+        # @param json [String]
+        #     The JSON representation of the expression
+        #
+        def initialize proto, json
+          @render_lines =
+            if json&.key? "stringValue"
+              render_string proto
+            elsif json&.key? "numberValue"
+              render_number proto
+            elsif json&.key? "booleanValue"
+              render_boolean proto
+            elsif json&.key? "nullValue"
+              ["nil"]
+            elsif json&.key? "nameValue"
+              render_name proto.name_value
+            elsif json&.key? "complexValue"
+              render_complex proto.complex_value.properties, json["complexValue"]["properties"]
+            elsif json&.key? "listValue"
+              render_list proto.list_value.values, json["listValue"]["values"]
+            elsif json&.key? "mapValue"
+              render_map proto.map_value, json["mapValue"]
+            end
+          @render = @render_lines&.join " "
+        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
+
+        ##
+        # Whether the expression could be interpreted.
+        # @return [Boolean]
+        #
+        def exist?
+          !render_lines.nil?
+        end
+
+        private
+
+        def render_string proto
+          [proto.string_value.inspect]
+        end
+
+        def render_number proto
+          value = proto.number_value
+          value = value.to_i if value == value.to_i
+          [value.inspect]
+        end
+
+        def render_boolean proto
+          [proto.boolean_value.inspect]
+        end
+
+        def render_name proto
+          line = ([proto.name] + Array(proto.path&.to_a)).join "."
+          [line]
+        end
+
+        def render_complex proto, json
+          lines = ["{"]
+          proto.each do |key, value_expr|
+            value_presenter = ExpressionPresenter.new value_expr, json[key]
+            value_lines = value_presenter.render_lines
+            next unless value_lines
+            lines[lines.size - 1] = "#{lines.last}," if lines.size > 1
+            value_lines[0] = "#{key}: #{value_lines.first}"
+            lines += value_lines.map { |line| "  #{line}" }
+          end
+          lines + ["}"]
+        end
+
+        def render_list proto, json
+          lines = ["["]
+          proto.each_with_index do |item, index|
+            expr = ExpressionPresenter.new item, json[index]
+            value_lines = expr.render_lines
+            lines[lines.size - 1] = "#{lines.last}," if lines.size > 1
+            lines += value_lines.map { |line| "  #{line}" }
+          end
+          lines + ["]"]
+        end
+
+        def render_map 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
+            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
+      end
+    end
+  end
+end