gapic-generator 0.11.0 → 0.45.1

data/lib/gapic/schema/proto_tools.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+# Copyright 2023 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 "stringio"
+
+module Gapic
+  module Schema
+    ##
+    # @private
+    #
+    # A set of logic dealing with parsing raw proto data. This is unfortunately
+    # necessary for getting options extension information from proto
+    # descriptors, because the google-protobuf library implementation is
+    # incomplete. (Specifically, it does not expose Ruby interfaces for Service
+    # and Method descriptors, the objects that normally surface extended
+    # options; see https://github.com/protocolbuffers/protobuf/issues/14891.)
+    #
+    # We hope this code will be temporary until the above protobuf features are
+    # available. In the meantime, we make it private.
+    #
+    module ProtoTools
+      class << self
+        ##
+        # Parse through an options object looking for specific fields.
+        #
+        # The fields should be provided as a hash mapping the option name to
+        # an array of the form `[id, type, flags...]` where the ID is the field
+        # number, the type is the protobuf message class or one of the symbols
+        # `:string`, `:bool`, `:enum`, and currently the only flag supported is
+        # `:repeated`.
+        #
+        # Returns a hash mapping option names found to their values. Repeated
+        # values are represented as arrays (not as protobuf repeated values).
+        #
+        def parse_options_extensions options, extension_config
+          return {} unless options
+          return options.dup.delete_if { |k, _v| !extension_config.key? k } if options.is_a? Hash
+          bytes = options.class.encode options
+          return {} if bytes.empty?
+          option_data_by_id = build_option_data_by_id extension_config
+          results = build_default_results extension_config
+          walk_bytes bytes do |id, _wire_type, data|
+            option_data = option_data_by_id[id]
+            next unless option_data
+            name = option_data[0]
+            type = option_data[1]
+            results[name] =
+              if option_data[2].include? :repeated
+                decode_repeated data, type, results[name]
+              else
+                decode_data data, type
+              end
+          end
+          results
+        end
+
+        ##
+        # Given a byte string of data, parse through it and yield each record
+        # as the field number, wire type number, and data. The data is either
+        # an integer (for VARINT) or byte array (for LEN). I64 and I32 records
+        # are skipped.
+        #
+        def walk_bytes bytes
+          io = StringIO.new bytes
+          until io.eof?
+            tag = read_varint io
+            id = tag >> 3
+            wire_type = tag & 7
+            case wire_type
+            when 0 # VARINT
+              data = read_varint io
+              yield id, wire_type, data
+            when 1 # I64
+              # Skip
+              io.read 8
+            when 2 # LEN
+              len = read_varint io
+              data = io.read len
+              yield id, wire_type, data
+            when 5 # I32
+              # Skip
+              io.read 4
+            else
+              raise "Wire type #{wire_type} not supported (id = #{id})"
+            end
+          end
+        end
+
+        ##
+        # Read and return a single VARINT from the byte stream
+        #
+        def read_varint io
+          acc = 0
+          shift = 0
+          loop do
+            byte = io.getbyte
+            acc += ((byte & 0x7f) << shift)
+            shift += 7
+            break if byte < 0x80
+          end
+          acc
+        end
+
+        ##
+        # Given a data and type, return a decoded form of the data.
+        # If the type is `:string`, the data must be a bytestring and is
+        # returned as is. If the type is `:enum`, the data must be an integer
+        # and is returned as is. If the type is `:bool`, the data must be an
+        # integer and is converted to a boolean. If the type is a protobuf
+        # message class, the data must be a bytestring and is decoded. Any
+        # other type is not supported and results in an exception.
+        #
+        def decode_data data, type
+          case type
+          when :string, :enum
+            data
+          when :bool
+            !data.zero?
+          when ::Class
+            type.decode data
+          else
+            raise "Type #{type} not supported"
+          end
+        end
+
+        ##
+        # Given a data and a repeated type, return a decoded form of the data
+        # as an array.  Supports repeated `:string`, `:enum`, and protobuf
+        # message class types. Any other type results in an exception.
+        #
+        def decode_repeated data, type, acc = nil
+          acc ||= []
+          case type
+          when :string
+            acc << data
+          when :enum
+            if data.is_a? ::String
+              io = StringIO.new data
+              acc << read_varint(io) until io.eof?
+            else
+              acc << data
+            end
+          when ::Class
+            acc << type.decode(data)
+          else
+            raise "Type #{type} not supported"
+          end
+          acc
+        end
+
+        private
+
+        # @private
+        # Internal method to build a hash of default results
+        def build_default_results extension_config
+          extension_config.to_h do |name, config|
+            default =
+              if config[2..].include? :repeated
+                []
+              else
+                case config[1]
+                when :enum
+                  0
+                when :string
+                  ""
+                end
+              end
+            [name, default]
+          end
+        end
+
+        # @private
+        # Internal method to build a hash keyed by id
+        def build_option_data_by_id extension_config
+          extension_config.to_h { |name, config| [config[0], [name, config[1], config[2..]]] }
+        end
+      end
+    end
+  end
+end

data/lib/gapic/schema/request_param_parser.rb

@@ -100,9 +100,8 @@ module Gapic
         # @return [String,Array<String>,Hash{String => String}]
         def parse_validate_param_value param_type, param_name_input, param_config_name, value_str, error_output
           if param_type == :bool && !["true", "false"].include?(unescape(value_str))
-            error_str = "WARNING: parameter #{param_name_input} (recognised as bool " \
-                                          "#{param_config_name}) will be discarded because of " \
-                                          "invalid value. Value should be either 'true' or 'false'."
+            error_str = "WARNING: parameter #{param_name_input} (recognised as bool #{param_config_name}) will be " \
+                        "discarded because of invalid value. Value should be either 'true' or 'false'."
             error_output&.puts error_str
           end
 
@@ -113,10 +112,9 @@ module Gapic
             noncompliant_values = param_value.reject { |pv| allowed_transports.include? pv }
             if noncompliant_values.any?
               noncompliant_values_list = noncompliant_values.join ", "
-              error_str = "WARNING: parameter #{param_name_input} (recognised as string array " \
-                                          "#{param_config_name}) will be discarded because "\
-                                          "it contains invalid values: #{noncompliant_values_list}. "\
-                                          "#{param_config_name} can only contain 'grpc' and/or 'rest' or be empty."
+              error_str = "WARNING: parameter #{param_name_input} (recognised as string array #{param_config_name}) " \
+                          "will be discarded because it contains invalid values: #{noncompliant_values_list}. " \
+                          "#{param_config_name} can only contain 'grpc' and/or 'rest' or be empty."
               error_output&.puts error_str
               param_value = nil
             end

data/lib/gapic/schema/service_config_parser.rb

@@ -15,7 +15,7 @@
 # limitations under the License.
 
 require "yaml"
-require "google/api/service.pb"
+require "google/api/service_pb"
 
 module Gapic
   module Schema
@@ -35,6 +35,15 @@ module Gapic
         HTTP_RULES_VERBS_ALLOWED = ["get", "post", "put", "patch", "delete"].freeze
         HTTP_RULES_BODY_KEY = "body"
         HTTP_RULES_ADDITIONAL_BINDINGS_KEY = "additional_bindings"
+        PUBS_KEY = "publishing"
+        PUBS_SHORTNAME_KEY = "api_short_name"
+        PUBS_ORGANIZATION_KEY = "organization"
+        PUBS_DOCURL_KEY = "documentation_uri"
+        PUBS_DOCTAG_KEY = "doc_tag_prefix"
+        PUBS_METHOD_SETTINGS = "method_settings"
+        DOCS_KEY = "documentation"
+        DOCS_SUMMARY_KEY = "summary"
+        DOCS_OVERVIEW_KEY = "overview"
 
         ##
         # Returns the parsed Google::Api::Service object.
@@ -57,11 +66,36 @@ module Gapic
           service.id = service_yaml[ID_KEY] if service_yaml.key? ID_KEY
           service.title = service_yaml[TITLE_KEY] if service_yaml.key? TITLE_KEY
 
-          service.apis = parse_apis service_yaml[APIS_KEY] if service_yaml.key? APIS_KEY
+          service.apis += parse_apis service_yaml[APIS_KEY] if service_yaml.key? APIS_KEY
           service.http = parse_http service_yaml[HTTP_KEY] if service_yaml.key? HTTP_KEY
           service
         end
 
+        ##
+        # Populates Gapic::Model::ApiMetadata from a service yaml file.
+        #
+        # @param service_yaml_text [String] YAML content
+        # @param api_metadata [Gapic::Model::ApiMetadata] model to populate
+        #
+        def parse_api_metadata service_yaml_text, api_metadata = nil
+          api_metadata ||= Gapic::Model::ApiMetadata.new
+          if service_yaml_text && !service_yaml_text.empty?
+            service_yaml = YAML.safe_load service_yaml_text
+            pubs_yaml = service_yaml[PUBS_KEY] || {}
+            docs_yaml = service_yaml[DOCS_KEY] || {}
+            api_metadata.update! name: service_yaml[NAME_KEY],
+                                 short_name: pubs_yaml[PUBS_SHORTNAME_KEY],
+                                 title: service_yaml[TITLE_KEY],
+                                 summary: docs_yaml[DOCS_SUMMARY_KEY],
+                                 description: docs_yaml[DOCS_OVERVIEW_KEY],
+                                 organization: pubs_yaml[PUBS_ORGANIZATION_KEY],
+                                 documentation_url: pubs_yaml[PUBS_DOCURL_KEY],
+                                 doc_tag_prefix: pubs_yaml[PUBS_DOCTAG_KEY],
+                                 method_settings: pubs_yaml[PUBS_METHOD_SETTINGS] || {}
+          end
+          api_metadata
+        end
+
         private
 
         # Parses the Apis section of the service yaml
@@ -87,7 +121,7 @@ module Gapic
           http = Google::Api::Http.new
 
           if http_yaml.key? HTTP_RULES_KEY
-            http.rules = http_yaml[HTTP_RULES_KEY].map { |rule_yaml| parse_http_rule rule_yaml }
+            http.rules += http_yaml[HTTP_RULES_KEY].map { |rule_yaml| parse_http_rule rule_yaml }
           end
 
           http
@@ -105,7 +139,7 @@ module Gapic
           rule.body = rule_yaml[HTTP_RULES_BODY_KEY] if rule_yaml.key? HTTP_RULES_BODY_KEY
 
           if rule_yaml.key? HTTP_RULES_ADDITIONAL_BINDINGS_KEY
-            rule.additional_bindings = rule_yaml[HTTP_RULES_ADDITIONAL_BINDINGS_KEY].map do |binding_yaml|
+            rule.additional_bindings += rule_yaml[HTTP_RULES_ADDITIONAL_BINDINGS_KEY].map do |binding_yaml|
               parse_http_rule binding_yaml
             end
           end