gapic-generator 0.11.0 → 0.45.1

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

@@ -0,0 +1,329 @@
+# 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
+      ##
+      # Some common private methods for response handling presenters
+      #
+      module ResponseHandlingPresenterCommon
+        private
+
+        def compute_response_name proto, phase1
+          return "result" if phase1
+          return nil if proto&.response_name.to_s.empty?
+          proto.response_name
+        end
+      end
+
+      ##
+      # Presentation information about simple response handling
+      #
+      class SimpleResponseHandlingPresenter
+        include ResponseHandlingPresenterCommon
+
+        ##
+        # Create a simple response handling presenter
+        #
+        # @param proto [Google::Cloud::Tools::SnippetGen::ConfigLanguage::V1::Snippet::SimpleResponseHandling]
+        #     The protobuf representation
+        # @param json [String]
+        #     The JSON representation
+        # @param response_type [String] The fully qualified response message class
+        # @param phase1 [Boolean] True if this is a phase 1 snippet without config
+        #
+        def initialize proto, _json, response_type:, phase1:
+          @response_name = compute_response_name proto, phase1
+          @render_lines =
+            if @response_name && phase1
+              [
+                "# The returned object is of type #{response_type}.",
+                "p #{@response_name}"
+              ]
+            else
+              []
+            end
+          @render = @render_lines.join "\n"
+        end
+
+        ##
+        # The lines of rendered code
+        # @return [Array<String>]
+        #
+        attr_reader :render_lines
+
+        ##
+        # The rendered code as a single string, possibly with line breaks
+        # @return [String]
+        #
+        attr_reader :render
+
+        ##
+        # The name of the response variable, or nil for no response handling
+        # @return [String,nil]
+        #
+        attr_reader :response_name
+      end
+
+      ##
+      # Presentation information about LRO response handling
+      #
+      class LroResponseHandlingPresenter
+        include ResponseHandlingPresenterCommon
+
+        ##
+        # Create an LRO response handling presenter
+        #
+        # @param proto [Google::Cloud::Tools::SnippetGen::ConfigLanguage::V1::Snippet::LroResponseHandling]
+        #     The protobuf representation
+        # @param json [String]
+        #     The JSON representation
+        # @param phase1 [Boolean] True if this is a phase 1 snippet without config
+        #
+        def initialize proto, _json, phase1:
+          @response_name = compute_response_name proto, phase1
+          @render_lines = []
+          if @response_name
+            if phase1
+              @render_lines << "# The returned object is of type Gapic::Operation. You can use it to"
+              @render_lines << "# check the status of an operation, cancel it, or wait for results."
+            end
+            case proto&.polling_type
+            when :NONE
+              # Do nothing
+            when :ONCE
+              @render_lines += check_once_lines phase1
+            else
+              @render_lines += wait_response_lines phase1
+            end
+          end
+          @render = @render_lines.join "\n"
+        end
+
+        ##
+        # The lines of rendered code
+        # @return [Array<String>]
+        #
+        attr_reader :render_lines
+
+        ##
+        # The rendered code as a single string, possibly with line breaks
+        # @return [String]
+        #
+        attr_reader :render
+
+        ##
+        # The name of the response variable, or nil for no response handling
+        # @return [String,nil]
+        #
+        attr_reader :response_name
+
+        private
+
+        def check_once_lines phase1
+          lines = []
+          lines << "# Here is how to check once for a response." if phase1
+          lines + [
+            "if #{@response_name}.response?",
+            "  p #{@response_name}.response",
+            "else",
+            '  puts "Response not yet arrived."',
+            "end"
+          ]
+        end
+
+        def wait_response_lines phase1
+          lines = []
+          lines << "# Here is how to wait for a response." if phase1
+          lines + [
+            "#{@response_name}.wait_until_done! timeout: 60",
+            "if #{@response_name}.response?",
+            "  p #{@response_name}.response",
+            "else",
+            '  puts "No response received."',
+            "end"
+          ]
+        end
+      end
+
+      ##
+      # Presentation information about server-streaming response handling
+      #
+      class StreamingResponseHandlingPresenter
+        ##
+        # Create a server-streaming response handling presenter
+        #
+        # @param proto [Google::Cloud::Tools::SnippetGen::ConfigLanguage::V1::Snippet::StreamingResponseHandling]
+        #     The protobuf representation
+        # @param json [String]
+        #     The JSON representation
+        # @param response_name [String] The name of the stream variable
+        # @param base_response_type [String] The fully qualified message class
+        #     for individual responses
+        # @param phase1 [Boolean] True if this is a phase 1 snippet without config
+        #
+        def initialize proto, json, response_name:, base_response_type:, phase1:
+          @response_name = response_name
+          @render_lines = []
+          if response_name
+            if phase1 && base_response_type
+              @render_lines << "# The returned object is a streamed enumerable yielding elements of type"
+              @render_lines << "# #{base_response_type}"
+            end
+            @render_lines += per_stream_response_lines proto, json, response_name, phase1
+          end
+          @render = @render_lines.join "\n"
+        end
+
+        ##
+        # The lines of rendered code
+        # @return [Array<String>]
+        #
+        attr_reader :render_lines
+
+        ##
+        # The rendered code as a single string, possibly with line breaks
+        # @return [String]
+        #
+        attr_reader :render
+
+        ##
+        # The name of the response variable, or nil for no response handling
+        # @return [String,nil]
+        #
+        attr_reader :response_name
+
+        private
+
+        def per_stream_response_lines proto, json, response_name, phase1
+          lines = []
+          item_name = phase1 ? "current_response" : proto.current_response_name
+          lines << "#{response_name}.each do |#{item_name}|"
+          if json&.key? "perStreamResponseStatements"
+            proto.per_stream_response_statements&.each_with_index do |statement_proto, index|
+              statement = StatementPresenter.new statement_proto, json["perStreamResponseStatements"][index]
+              lines += statement.render_lines.map { |line| "  #{line}" }
+            end
+          else
+            lines << "  p #{item_name}"
+          end
+          lines << "end"
+          lines
+        end
+      end
+
+      ##
+      # Presentation information about paginated response handling
+      #
+      class PaginatedResponseHandlingPresenter
+        include ResponseHandlingPresenterCommon
+
+        ##
+        # Create a paginated response handling presenter
+        #
+        # @param proto [Google::Cloud::Tools::SnippetGen::ConfigLanguage::V1::Snippet::PaginatedResponseHandling]
+        #     The protobuf representation
+        # @param json [String]
+        #     The JSON representation
+        # @param paged_response_type [String] The fully qualified message class
+        #     for individual responses
+        # @param phase1 [Boolean] True if this is a phase 1 snippet without config
+        #
+        def initialize proto, json, paged_response_type:, phase1:
+          @response_name = compute_response_name proto, phase1
+          @render_lines = []
+          if @response_name
+            if phase1
+              @render_lines << "# The returned object is of type Gapic::PagedEnumerable. You can iterate"
+              @render_lines << "# over elements, and API calls will be issued to fetch pages as needed."
+            end
+            @render_lines +=
+              if proto&.by_page
+                by_page_lines proto, json, @response_name, paged_response_type, phase1
+              elsif proto&.next_page_token
+                next_page_token_lines proto, json
+              else
+                by_item_lines proto, json, @response_name, paged_response_type, phase1
+              end
+          end
+          @render = @render_lines.join "\n"
+        end
+
+        ##
+        # The lines of rendered code
+        # @return [Array<String>]
+        #
+        attr_reader :render_lines
+
+        ##
+        # The rendered code as a single string, possibly with line breaks
+        # @return [String]
+        #
+        attr_reader :render
+
+        ##
+        # The name of the response variable, or nil for no response handling
+        # @return [String,nil]
+        #
+        attr_reader :response_name
+
+        private
+
+        def by_item_lines proto, json, collection_name, paged_response_type, phase1
+          lines = []
+          proto = proto&.by_item
+          json = json&.fetch "byItem", nil
+          item_name = phase1 ? "item" : proto.item_name
+          lines << "#{collection_name}.each do |#{item_name}|"
+          if json&.key? "perItemStatements"
+            proto.per_item_statements&.each_with_index do |item_proto, index|
+              statement = StatementPresenter.new item_proto, json["perItemStatements"][index]
+              lines += statement.render_lines.map { |line| "  #{line}" }
+            end
+          else
+            lines << "  # Each element is of type #{paged_response_type}." if phase1
+            lines << "  p #{item_name}"
+          end
+          lines << "end"
+          lines
+        end
+
+        def by_page_lines proto, json, response_name, paged_response_type, phase1
+          lines = []
+          proto = proto.by_page
+          json = json["byPage"]
+          page_name = phase1 ? "page" : proto.page_name
+          lines << "#{response_name}.each_page do |#{page_name}|"
+          if json&.key? "perPageStatements"
+            proto.per_page_statements&.each_with_index do |page_proto, index|
+              statement = StatementPresenter.new page_proto, json["perPageStatements"][index]
+              lines += statement.render_lines.map { |line| "  #{line}" }
+            end
+          end
+          iteration_lines = by_item_lines proto, json, page_name, paged_response_type, phase1
+          lines + iteration_lines.map { |line| "  #{line}" } + ["end"]
+        end
+
+        def next_page_token_lines _proto, _json
+          # TODO
+          []
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# 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 statement
+      #
+      class StatementPresenter
+        ##
+        # Create a statement presenter.
+        #
+        # @param proto [Google::Cloud::Tools::SnippetGen::ConfigLanguage::V1::Statement]
+        #     The protobuf representation of the statement
+        # @param json [String]
+        #     The JSON representation of the statement
+        #
+        def initialize proto, json
+          @render_lines =
+            if json&.key? "declaration"
+              declaration_lines proto.declaration, json["declaration"]
+            elsif json&.key? "standardOutput"
+              output_lines proto.standard_output, json["standardOutput"]
+            elsif json&.key? "return"
+              return_lines proto.return, json["return"]
+            elsif json&.key? "conditional"
+              conditional_lines proto.conditional, json["conditional"]
+            elsif json&.key? "iteration"
+              iteration_lines proto.iteration, json["iteration"]
+            else
+              ["# Unknown statement omitted here."]
+            end
+          @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 declaration_lines proto, json
+          declaration = DeclarationPresenter.new proto, json
+          if declaration.exist?
+            declaration.render_lines
+          else
+            ["# Unknown declaration statement omitted here."]
+          end
+        end
+
+        def output_lines proto, json
+          expr = ExpressionPresenter.new proto.value, json["value"]
+          return ["# Unknown output statement omitted here."] unless expr.exist?
+          lines = expr.render_lines
+          if lines.size == 1
+            ["puts(#{lines.first})"]
+          else
+            ["puts("] + lines.map { |line| "  #{line}" } + [")"]
+          end
+        end
+
+        def return_lines proto, json
+          expr = ExpressionPresenter.new proto.result, json["result"]
+          return ["# Unknown return statement omitted here."] unless expr.exist?
+          lines = expr.render_lines
+          lines[0] = "return #{lines.first}"
+          lines
+        end
+
+        def conditional_lines proto, json
+          expr = ExpressionPresenter.new proto.condition, json["condition"]
+          return ["# Unknown conditional statement omitted here."] unless expr.exist?
+
+          if json.key? "onTrue"
+            conditional_lines_inner "if", expr, proto.on_true, json["onTrue"], proto.on_false, json["onFalse"]
+          elsif json.key? "onFalse"
+            conditional_lines_inner "unless", expr, proto.on_false, json["onFalse"], nil, nil
+          else
+            ["# Do nothing"]
+          end
+        end
+
+        def conditional_lines_inner keyword, expr, if_protos, if_json, else_protos, else_json
+          lines = ["#{keyword} #{expr.render}"]
+          if_protos.each_with_index do |statement_proto, index|
+            statement = StatementPresenter.new statement_proto, if_json[index]
+            lines += statement.render_lines.map { |line| "  #{line}" }
+          end
+          if else_json
+            lines << "else"
+            else_protos.each_with_index do |statement_proto, index|
+              statement = StatementPresenter.new statement_proto, else_json[index]
+              lines += statement.render_lines.map { |line| "  #{line}" }
+            end
+          end
+          lines << "end"
+          lines
+        end
+
+        def iteration_lines proto, json
+          iteration = IterationPresenter.new proto, json
+          if iteration.exist?
+            iteration.render_lines
+          else
+            ["# Unknown iteration statement omitted here."]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# 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.
+
+require "active_support/inflector"
+
+module Gapic
+  module Presenters
+    class SnippetPresenter
+      ##
+      # Presentation information about a type
+      #
+      class TypePresenter
+        ##
+        # Create a type presenter.
+        #
+        # @param proto [Google::Cloud::Tools::SnippetGen::ConfigLanguage::V1::Type]
+        #     The protobuf representation of the type
+        # @param json [String]
+        #     The JSON representation of the type
+        #
+        def initialize proto, json
+          @render =
+            if json&.key? "scalarType"
+              SCALAR_TYPE_MAPPING[proto.scalar_type] || "Object"
+            elsif json&.key? "bytesType"
+              "String"
+            elsif json&.key? "messageType"
+              proto_to_ruby proto.message_type.message_full_name
+            elsif json&.key? "enumType"
+              proto_to_ruby proto.enum_type.enum_full_name
+            elsif json&.key? "repeatedType"
+              repeated_render proto, json
+            elsif json&.key? "mapType"
+              map_render proto, json
+            else
+              "Object"
+            end
+        end
+
+        ##
+        # The rendered type string.
+        # @return [String]
+        #
+        attr_reader :render
+
+        private
+
+        def proto_to_ruby name
+          name.split(".").map { |str| ActiveSupport::Inflector.upcase_first str }.join "::"
+        end
+
+        def repeated_render proto, json
+          inner_type = TypePresenter.new proto.repeated_type.element_type, json["repeatedType"]["elementType"]
+          "Array<#{inner_type.render}>"
+        end
+
+        def map_render proto, json
+          proto = proto.map_type
+          json = json["mapType"]
+          key_type = TypePresenter.new proto.key_type, json["keyType"]
+          value_type = TypePresenter.new proto.value_type, json["valueType"]
+          "Hash{#{key_type.render}=>#{value_type.render}}"
+        end
+
+        SCALAR_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_UINT32: "Integer",
+          TYPE_SFIXED32: "Integer",
+          TYPE_SFIXED64: "Integer",
+          TYPE_SINT32: "Integer",
+          TYPE_SINT64: "Integer"
+        }.freeze
+        private_constant :SCALAR_TYPE_MAPPING
+      end
+    end
+  end
+end