gapic-generator 0.10.1 → 0.45.1

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

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

@@ -0,0 +1,118 @@
+# 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 iteration
+      #
+      class IterationPresenter
+        ##
+        # Create an iteration presenter.
+        #
+        # @param proto [Google::Cloud::Tools::SnippetGen::ConfigLanguage::V1::Statement::Iteration]
+        #     The protobuf representation of the iteration
+        # @param json [String]
+        #     The JSON representation of the iteration
+        #
+        def initialize proto, json
+          @prelude_render_lines, @postlude_render_lines =
+            if json&.key? "repeatedIteration"
+              parse_repeated_iteration proto.repeated_iteration, json["repeatedIteration"]
+            elsif json&.key? "mapIteration"
+              parse_map_iteration proto.map_iteration, json["mapIteration"]
+            else
+              # TODO: numeric sequence and bytes iteration
+              [[], []]
+            end
+          if @prelude_render_lines.empty? && @postlude_render_lines.empty?
+            @inner_render_lines = @render_lines = @render = nil
+          else
+            @inner_render_lines = parse_inner_lines proto&.statements, json&.fetch("statements", nil)
+            @render_lines = @prelude_render_lines +
+                            @inner_render_lines.map { |line| "  #{line}" } +
+                            @postlude_render_lines
+            @render = @render_lines.join "\n"
+          end
+        end
+
+        ##
+        # The iteration prelude lines
+        # @return [Array<String>]
+        #
+        attr_reader :prelude_render_lines
+
+        ##
+        # The iteration postlude lines
+        # @return [Array<String>]
+        #
+        attr_reader :postlude_render_lines
+
+        ##
+        # The inner statement lines
+        # @return [Array<String>]
+        #
+        attr_reader :inner_render_lines
+
+        ##
+        # 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 iteration could be interpreted.
+        # @return [Boolean]
+        #
+        def exist?
+          !render_lines.nil?
+        end
+
+        private
+
+        def parse_repeated_iteration proto, json
+          decl = DeclarationPresenter.new proto.repeated_elements, json["repeatedElements"]
+          prelude = decl.render_lines + ["#{decl.name}.each do |#{proto.current_name}|"]
+          [prelude, ["end"]]
+        end
+
+        def parse_map_iteration proto, json
+          decl = DeclarationPresenter.new proto.map, json["map"]
+          prelude = decl.render_lines +
+                    ["#{decl.name}.each do |#{proto.current_key_name}, #{proto.current_value_name}|"]
+          [prelude, ["end"]]
+        end
+
+        def parse_inner_lines protos, jsons
+          lines = []
+          protos.each_with_index do |statement, index|
+            inner_statement = StatementPresenter.new statement, jsons[index]
+            lines += inner_statement.render_lines
+          end
+          lines
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# 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 snippet method parameter
+      #
+      class ParameterPresenter
+        ##
+        # Create an expression presenter.
+        #
+        # @param proto [Google::Cloud::Tools::SnippetGen::ConfigLanguage::V1::Statement::Declaration]
+        #     The protobuf representation of the parameter
+        # @param json [String]
+        #     The JSON representation of the parameter
+        #
+        def initialize proto, json
+          @name = proto.name
+          @description = proto.description
+          @description = nil if @description&.empty?
+          @type = TypePresenter.new proto&.type, json&.fetch("type", nil)
+          @example = ExpressionPresenter.new proto&.value, json&.fetch("value", nil)
+        end
+
+        ##
+        # The name of this parameter
+        # @return [String]
+        #
+        attr_reader :name
+
+        ##
+        # A description of this parameter, or nil if none.
+        # @return [String,nil]
+        #
+        attr_reader :description
+
+        ##
+        # The type of this parameter, as a presenter.
+        # @return [Gapic::Presenters::SnippetPresenter::TypePresenter]
+        #
+        attr_reader :type
+
+        ##
+        # The default/example value for this parameter, as a presenter.
+        # @return [Gapic::Presenters::SnippetPresenter::ExpressionPresenter]
+        #
+        attr_reader :example
+      end
+    end
+  end
+end

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

@@ -0,0 +1,202 @@
+# 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 simple request initialization
+      #
+      class SimpleRequestInitializationPresenter
+        ##
+        # Create a simple request init presenter.
+        #
+        # @param proto [Google::Cloud::Tools::SnippetGen::ConfigLanguage::V1::Snippet::SimpleRequestInitialization]
+        #     The protobuf representation
+        # @param json [String]
+        #     The JSON representation
+        # @param request_type [String] The fully qualified request message class
+        # @param phase1 [Boolean] True if this is a phase 1 snippet without config
+        # @param default_request_name [String] Default name of request variable
+        #
+        def initialize proto, json, request_type:, phase1:, default_request_name: "request"
+          @request_name = phase1 ? default_request_name : proto.request_name
+          @render_precall_lines =
+            if proto
+              configured_lines proto, json, request_type
+            else
+              fallback_lines request_type
+            end
+          @render_precall = @render_precall_lines.join "\n"
+          @render_postcall_lines = []
+          @render_postcall = ""
+        end
+
+        ##
+        # The lines of rendered code for before the rpc call
+        # @return [Array<String>]
+        #
+        attr_reader :render_precall_lines
+
+        ##
+        # The pre-call rendered code as a single string, possibly with line breaks
+        # @return [String]
+        #
+        attr_reader :render_precall
+
+        ##
+        # The lines of rendered code for after the rpc call
+        # @return [Array<String>]
+        #
+        attr_reader :render_postcall_lines
+
+        ##
+        # The post-call rendered code as a single string, possibly with line breaks
+        # @return [String]
+        #
+        attr_reader :render_postcall
+
+        ##
+        # The name of the request variable set
+        # @return [String]
+        #
+        attr_reader :request_name
+
+        private
+
+        def fallback_lines request_type
+          [
+            "# Create a request. To set request fields, pass in keyword arguments.",
+            "#{@request_name} = #{request_type}.new"
+          ]
+        end
+
+        def configured_lines proto, json, request_type
+          pre_lines = []
+          if json.key? "preRequestInitialization"
+            proto.pre_request_initialization&.each_with_index do |statement_proto, index|
+              statement = StatementPresenter.new statement_proto, json["preRequestInitialization"][index]
+              pre_lines += statement.render_lines
+            end
+          end
+          expr = ExpressionPresenter.new proto.request_value, json["requestValue"]
+          if expr.exist?
+            request_lines = expr.render_lines
+            request_lines[0] = "#{@request_name} = #{request_lines.first}"
+          else
+            request_lines = fallback_lines request_type
+          end
+          pre_lines + request_lines
+        end
+      end
+
+      ##
+      # Presentation information about client-streaming request initialization
+      #
+      class StreamingRequestInitializationPresenter
+        ##
+        # Create a streaming request init presenter.
+        #
+        # @param proto [Google::Cloud::Tools::SnippetGen::ConfigLanguage::V1::Snippet::StreamingRequestInitialization]
+        #     The protobuf representation
+        # @param json [String]
+        #     The JSON representation
+        # @param request_name [String] The request variable name
+        # @param request_type [String] The fully qualified request message class
+        # @param phase1 [Boolean] True if this is a phase 1 snippet without config
+        #
+        def initialize proto, json, request_name:, request_type:, phase1:
+          @request_name = request_name
+          @render_precall_lines = []
+          @render_precall_lines << "# Create an input stream." if phase1
+          @render_precall_lines << "#{request_name} = Gapic::StreamInput.new"
+          @render_precall = @render_precall_lines.join "\n"
+
+          @render_postcall_lines =
+            if proto && json
+              configured_lines proto, json, request_name, request_type
+            else
+              fallback_lines request_name, request_type
+            end
+          @render_postcall = @render_postcall_lines.join "\n"
+        end
+
+        ##
+        # The lines of rendered code for before the rpc call
+        # @return [Array<String>]
+        #
+        attr_reader :render_precall_lines
+
+        ##
+        # The pre-call rendered code as a single string, possibly with line breaks
+        # @return [String]
+        #
+        attr_reader :render_precall
+
+        ##
+        # The lines of rendered code for after the rpc call
+        # @return [Array<String>]
+        #
+        attr_reader :render_postcall_lines
+
+        ##
+        # The post-call rendered code as a single string, possibly with line breaks
+        # @return [String]
+        #
+        attr_reader :render_postcall
+
+        ##
+        # The name of the request variable set
+        # @return [String]
+        #
+        attr_reader :request_name
+
+        private
+
+        def configured_lines proto, json, request_name, request_type
+          lines = []
+          if json.key? "firstStreamingRequest"
+            first_request = SimpleRequestInitializationPresenter.new \
+              proto.first_streaming_request, json["firstStreamingRequest"],
+              default_request_name: "stream_item", request_type: request_type, phase1: false
+            lines += first_request.render_precall_lines
+            lines << "#{request_name} << #{first_request.request_name}"
+          end
+          next_request = SimpleRequestInitializationPresenter.new \
+            proto.streaming_request, json["streamingRequest"],
+            default_request_name: "stream_item", request_type: request_type, phase1: false
+          iteration = IterationPresenter.new proto.iteration, json["iteration"]
+          lines += iteration.prelude_render_lines
+          lines += next_request.render_precall_lines.map { |line| "  #{line}" }
+          lines << "  #{request_name} << #{next_request.request_name}"
+          lines += iteration.postlude_render_lines
+          lines + ["#{request_name}.close"]
+        end
+
+        def fallback_lines request_name, request_type
+          [
+            "# Send requests on the stream. For each request object, set fields by",
+            "# passing keyword arguments. Be sure to close the stream when done.",
+            "#{request_name} << #{request_type}.new",
+            "#{request_name} << #{request_type}.new",
+            "#{request_name}.close"
+          ]
+        end
+      end
+    end
+  end
+end