gapic-generator 0.6.7 → 0.6.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5aa9d03bd1f1b684465822ee5d675fd68d59bc540fff223872296f654c070003
-  data.tar.gz: 776dc70b99781fb0bb302fd17dd4cf346635a0a6893c486e345806d89356e4a6
+  metadata.gz: afaa0b6b4a0d16eaae66efab5a4e45e7cda3ffd7be99ca7bf2c6367c520dacc0
+  data.tar.gz: 6894ec83f3ad88187f11e1fd3c9a55d3044c262338e5a4b6deab4c84bae5d675
 SHA512:
-  metadata.gz: deb619583674bdbf4b93ec0c01d2372032cc009d94e264a208590357bba2952c69d6bb15ab82bddd40a90c6e64b19d312515d1b221731771c9656b61954fd00d
-  data.tar.gz: 67e2be16533a5ed217c81a9b0d20f85d438792edcc0ff8bccbc9626b21e794e8b130957a4fd1bea4823efb8d4de9c4a10ccab4fae40fdd2122402f6b3989988b
+  metadata.gz: 9368519ee9f66aeed7df95a11dbabf826ace7f22d8a36698e6625663ffdc49f7566f2f6977eca02d412410bbdc1012f10e4676bfb9bea6fd253cd470a1a8b31c
+  data.tar.gz: fd1a76c09ad489a9ed8a99616b9a9e4b1ecc17a47faf5044d3fd4abf111d5a01a0efede4bc3232d896837a441251fad974e4a9afcb1bc75e827b0a58ef5bf983

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Release History for gapic-generator
 
+### 0.6.12 / 2021-02-01
+
+* No changes.
+
+### 0.6.11 / 2021-02-01
+
+* Generated clients determine whether to use self-signed JWT credentials.
+
+### 0.6.10 / 2021-01-13
+
+* A set of human-readable command-line parameters can now be specified for the gapic-generator, e.g. `gem-name`. These parameters strictly duplicate the existing behaviour of old command-line parameters, e.g. `:gem.:name`.
+* Documentation for the `timeout` parameter in some templates has been fixed to correctly specify 'seconds' where previously it incorrectly sais 'milliseconds'. This is a purely documentation update, no functionality changes.
+
+### 0.6.9 / 2020-12-07
+
+* Load package-level handwritten helpers.
+* Disable Names/PredicateName rubocop rule.
+* Fix generated client tests when a request field name collides with a Ruby superclass method.
+
+### 0.6.8 / 2020-09-16
+
+* Add samples tasks to generated gapic rakefiles.
+* Disable Style/AsciiComments rule.
+
 ### 0.6.7 / 2020-08-07
 
 * Generated credentials config allows symbols.

data/lib/gapic/generator/version.rb

@@ -16,6 +16,6 @@
 
 module Gapic
   module Generator
-    VERSION = "0.6.7"
+    VERSION = "0.6.12"
   end
 end

data/lib/gapic/generators/default_generator.rb

@@ -15,6 +15,7 @@
 # limitations under the License.
 
 require "gapic/generators/base_generator"
+require "gapic/generators/default_generator_parameters"
 require "gapic/presenters"
 
 module Gapic
@@ -89,6 +90,12 @@ module Gapic
 
       # rubocop:enable all
 
+      # Schema of the parameters that the generator accepts
+      # @return [Gapic::Schema::ParameterSchema]
+      def self.parameter_schema
+        DefaultGeneratorParameters.default_schema
+      end
+
       private
 
       ##

data/lib/gapic/generators/default_generator_parameters.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+# Copyright 2020 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 "gapic/schema/parameter_schema"
+
+module Gapic
+  module Generators
+    # Contains the default generator's parameters
+    module DefaultGeneratorParameters
+      BOOL_PARAMETERS = [
+        ":gem.:free_tier",
+        ":gem.:yard_strict",
+        ":gem.:generic_endpoint"
+      ].freeze
+
+      STRING_PARAMETERS = [
+        ":gem.:name",
+        ":gem.:namespace",
+        ":gem.:title",
+        ":gem.:description",
+        ":gem.:summary",
+        ":gem.:homepage",
+        ":gem.:env_prefix",
+        ":gem.:version_dependencies",
+        ":gem.:migration_version",
+        ":gem.:product_documentation_url",
+        ":gem.:issue_tracker_url",
+        ":gem.:api_id",
+        ":gem.:api_shortname",
+        ":gem.:factory_method_suffix",
+        ":defaults.:service.:default_host",
+        "grpc_service_config"
+      ].freeze
+
+      ARRAY_PARAMETERS = [
+        ":defaults.:service.:oauth_scopes"
+      ].freeze
+
+      MAP_PARAMETERS = [
+        ":common_services",
+        ":overrides.:file_path",
+        ":overrides.:namespace",
+        ":overrides.:service",
+        ":gem.:extra_dependencies"
+      ].freeze
+
+      BOOL_PARAMETERS_ALIASES = {
+        "gem-free-tier"        => ":gem.:free_tier",
+        "gem-yard-strict"      => ":gem.:yard_strict",
+        "gem-generic-endpoint" => ":gem.:generic_endpoint"
+      }.freeze
+
+      STRING_PARAMETERS_ALIASES = {
+        "gem-name"                  => ":gem.:name",
+        "gem-namespace"             => ":gem.:namespace",
+        "gem-title"                 => ":gem.:title",
+        "gem-description"           => ":gem.:description",
+        "gem-summary"               => ":gem.:summary",
+        "gem-homepage"              => ":gem.:homepage",
+        "gem-env-prefix"            => ":gem.:env_prefix",
+        "gem-wrapper-of"            => ":gem.:version_dependencies",
+        "gem-migration-version"     => ":gem.:migration_version",
+        "gem-product-url"           => ":gem.:product_documentation_url",
+        "gem-issues-url"            => ":gem.:issue_tracker_url",
+        "gem-api-id"                => ":gem.:api_id",
+        "gem-api-shortname"         => ":gem.:api_shortname",
+        "gem-factory-method-suffix" => ":gem.:factory_method_suffix",
+        "default-service-host"      => ":defaults.:service.:default_host",
+        "grpc-service-config"       => "grpc_service_config"
+      }.freeze
+
+      ARRAY_PARAMETERS_ALIASES = {
+        "default-oauth-scopes" => ":defaults.:service.:oauth_scopes"
+      }.freeze
+
+      MAP_PARAMETERS_ALIASES = {
+        "common-services"        => ":common_services",
+        "file-path-override"     => ":overrides.:file_path",
+        "namespace-override"     => ":overrides.:namespace",
+        "service-override"       => ":overrides.:service",
+        "gem-extra-dependencies" => ":gem.:extra_dependencies"
+      }.freeze
+
+      def self.default_schema
+        base_schema = Gapic::Schema::ParameterSchema.create(
+          bool_params_list:   BOOL_PARAMETERS,
+          string_params_list: STRING_PARAMETERS,
+          array_params_list:  ARRAY_PARAMETERS,
+          map_params_list:    MAP_PARAMETERS
+        )
+
+        base_schema.extend_with_aliases(
+          bool_aliases:   BOOL_PARAMETERS_ALIASES,
+          string_aliases: STRING_PARAMETERS_ALIASES,
+          array_aliases:  ARRAY_PARAMETERS_ALIASES,
+          map_aliases:    MAP_PARAMETERS_ALIASES
+        )
+      end
+    end
+  end
+end

data/lib/gapic/presenters/package_presenter.rb

@@ -80,9 +80,25 @@ module Gapic
         package_require + ".rb"
       end
 
+      def package_directory_name
+        package_require.split("/").last
+      end
+
       def empty?
         services.empty?
       end
+
+      def helpers_file_path
+        helpers_require + ".rb"
+      end
+
+      def helpers_file_name
+        "_helpers.rb"
+      end
+
+      def helpers_require
+        package_require + "/_helpers"
+      end
     end
   end
 end

data/lib/gapic/runner.rb

@@ -16,6 +16,7 @@
 
 require "gapic/generator"
 require "gapic/schema"
+require "gapic/schema/request_param_parser"
 require "google/protobuf/compiler/plugin.pb"
 
 module Gapic
@@ -27,6 +28,20 @@ module Gapic
     # Initializes the runner.
     # @param [Google::Protobuf::Compiler::CodeGeneratorRequest] request
     def initialize request
+      # parse the parameters that apply to runner and not to the api and exclude them from the request
+      runner_param_names = ["binary_output", "generator"]
+      runner_schema = Gapic::Schema::ParameterSchema.create(
+        string_params_list: runner_param_names
+      )
+
+      params = Gapic::Schema::RequestParamParser.parse_parameters_string request.parameter, param_schema: runner_schema
+      @binary_output_path = params.filter { |p| p.config_name == "binary_output" }.first&.config_value
+      @generator_type = params.filter { |p| p.config_name == "generator" }.first&.config_value
+
+      gapic_params = params.filter { |p| !runner_param_names.include? p.config_name }
+      # reconstruct the request parameter string without the runner parameters
+      request.parameter = Gapic::Schema::RequestParamParser.reconstruct_parameters_string gapic_params
+
       @request = request
     end
 
@@ -34,22 +49,22 @@ module Gapic
     # @param [String] generator_type
     # @return [Google::Protobuf::Compiler::CodeGeneratorResponse]
     def run generator_type: nil
-      # Create an API Schema from the FileDescriptorProtos
-      api = Gapic::Schema::Api.new request
-
-      write_binary_file! api
+      # save the binary file if needed
+      write_binary_file
 
       # Retrieve generator type from protoc_options if not already provided.
-      generator_type ||= api.protoc_options["generator"]
+      generator_type ||= @generator_type
       # Find the generator for the generator type.
       generator = Gapic::Generator.find generator_type
 
+      # Create an API Schema from the FileDescriptorProtos
+      api = Gapic::Schema::Api.new request, parameter_schema: generator.parameter_schema
+
       # Create and run the generator from the API.
       output_files = generator.new(api).generate
 
       # Create and write the response
-      response = Google::Protobuf::Compiler::CodeGeneratorResponse.new \
-        file: output_files
+      response = Google::Protobuf::Compiler::CodeGeneratorResponse.new file: output_files
       response.supported_features = Google::Protobuf::Compiler::CodeGeneratorResponse::FEATURE_PROTO3_OPTIONAL
       response
     end
@@ -64,15 +79,13 @@ module Gapic
 
     private
 
-    def write_binary_file! api
-      return unless api.protoc_options["binary_output"]
-
-      # First, strip the binary_output parameter out so it doesn't get saved
-      binary_file = api.protoc_options.delete "binary_output"
-      request.parameter = api.protoc_parameter
+    # Save binary file with the request
+    # if the binary_output_path parameter is set
+    def write_binary_file
+      return unless @binary_output_path
 
       # Write binary file if the binary_output option is set
-      File.binwrite binary_file, request.to_proto
+      File.binwrite @binary_output_path, request.to_proto
     end
   end
 end

data/lib/gapic/schema/api.rb

@@ -16,7 +16,9 @@
 
 require "yaml"
 require "json"
+require "gapic/generators/default_generator_parameters"
 require "gapic/schema/loader"
+require "gapic/schema/request_param_parser"
 require "gapic/grpc_service_config/parser"
 
 module Gapic
@@ -44,9 +46,11 @@ module Gapic
       #
       # @param request [Google::Protobuf::Compiler::CodeGeneratorRequest]
       #   The request object.
+      # @param parameter_schema [Gapic::Schema::ParameterSchema]
+      #   The request parameters schema to use
       # @param error_output [IO] An IO to write any errors/warnings to.
       # @param configuration [Hash] Optional override of configuration.
-      def initialize request, error_output: STDERR, configuration: nil
+      def initialize request, parameter_schema: nil, error_output: STDERR, configuration: nil
         @request = request
         loader = Loader.new
         @files = request.proto_file.map do |fd|
@@ -55,6 +59,9 @@ module Gapic
         @files.each { |f| f.parent = self }
         @configuration = configuration
         @resource_types = analyze_resources
+
+        parameter_schema ||= Gapic::Generators::DefaultGeneratorParameters.default_schema
+        @protoc_parameters = parse_parameter request.parameter, parameter_schema, error_output
         sanity_checks error_output
       end
 
@@ -116,33 +123,20 @@ module Gapic
 
       # Structured Hash representation of the parameter values.
       # @return [Hash]
-      #   A Hash of the request parameters.
       def protoc_options
         @protoc_options ||= begin
           result = {}
-          parameters = parse_parameter request.parameter
-          parameters.each do |param_array|
-            key = param_array.first
-            next if key.empty?
-            value = param_array[1..-1]
-            value = value.first if value.size == 1
-            value = nil if value.empty?
-            result[str_to_key(key)] = value
+          @protoc_parameters.each do |parameter|
+            result[str_to_key(parameter.config_name)] = parameter.config_value
           end
           result
         end
       end
 
-      # Reconstructed string representation of the protoc options
+      # Reconstructed string representation of the protoc parameters
       # @return [String]
       def protoc_parameter
-        protoc_options.map do |k, v|
-          v = Array(v).map do |s|
-            s.gsub("\\", "\\\\\\\\").gsub(",", "\\\\,").gsub("=", "\\\\=")
-          end.join("=")
-          k = key_to_str k
-          "#{k}=#{v}"
-        end.join ","
+        Gapic::Schema::RequestParamParser.reconstruct_parameters_string @protoc_parameters
       end
 
       # Structured representation of the samples configuration files.
@@ -353,20 +347,13 @@ module Gapic
 
       # Parse a comma-delimited list of equals-delimited lists of strings, while
       # mapping backslash-escaped commas and equal signs to literal characters.
-      def parse_parameter str
-        str.scan(/\\.|,|=|[^\\,=]+/)
-           .each_with_object([[String.new]]) do |tok, arr|
-             if tok == ","
-               arr.append [String.new]
-             elsif tok == "="
-               arr.last.append String.new
-             elsif tok.start_with? "\\"
-               arr.last.last << tok[1]
-             else
-               arr.last.last << tok
-             end
-             arr
-           end
+      # @param str [String]
+      # @param error_output [IO] Stream to write outputs to.
+      # @return [Array<Gapic::Schema::RequestParameter>]
+      def parse_parameter str, parameter_schema, error_output
+        Gapic::Schema::RequestParamParser.parse_parameters_string str,
+                                                                  param_schema: parameter_schema,
+                                                                  error_output: error_output
       end
 
       # split the string on periods, but map backslash-escaped periods to

data/lib/gapic/schema/parameter_schema.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+# Copyright 2020 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 Schema
+    # Contains information about known parameter names
+    # and the types expected to be parsed from the request options string
+    class ParameterSchema
+      attr_accessor :bool_params, :string_params, :array_params, :map_params
+
+      # Creates a schema with given alias-parameter maps
+      # @param bool_params [Hash{String => String}]
+      # @param string_params [Hash{String => String}]
+      # @param array_params [Hash{String => String}]
+      # @param map_params [Hash{String => String}]
+      def initialize bool_params = {}, string_params = {}, array_params = {}, map_params = {}
+        @bool_params = bool_params
+        @string_params = string_params
+        @array_params = array_params
+        @map_params = map_params
+      end
+
+      # Creates a schema from given parameter lists
+      # @param bool_params_list [Array<String>]
+      # @param string_params_list [Array<String>]
+      # @param array_params_list [Array<String>]
+      # @param map_params_list [Array<String>]
+      # @return Gapic::Schema::ParameterSchema
+      def self.create bool_params_list: [], string_params_list: [], array_params_list: [], map_params_list: []
+        bool_params = bool_params_list.map { |val| [val, val] }.to_h
+        string_params = string_params_list.map { |val| [val, val] }.to_h
+        array_params = array_params_list.map { |val| [val, val] }.to_h
+        map_params = map_params_list.map { |val| [val, val] }.to_h
+
+        ParameterSchema.new bool_params, string_params, array_params, map_params
+      end
+
+      # Creates a new schema from this by adding aliases to existing parameters
+      # @param bool_aliases [Hash{String => String}]
+      # @param string_aliases [Hash{String => String}]
+      # @param array_aliases [Hash{String => String}]
+      # @param map_aliases [Hash{String => String}]
+      # @return Gapic::Schema::ParameterSchema
+      def extend_with_aliases bool_aliases: {}, string_aliases: {}, array_aliases: {}, map_aliases: {}
+        bool_params = @bool_params
+        bool_aliases.each { |param_alias, param| bool_params[param_alias] = param if bool_params.key? param }
+
+        string_params = @string_params
+        string_aliases.each { |param_alias, param| string_params[param_alias] = param if string_params.key? param }
+
+        array_params = @array_params
+        array_aliases.each { |param_alias, param| array_params[param_alias] = param if array_params.key? param }
+
+        map_params = @map_params
+        map_aliases.each { |param_alias, param| map_params[param_alias] = param if map_params.key? param }
+
+        ParameterSchema.new bool_params, string_params, array_params, map_params
+      end
+
+      # Looks up a parameter by name (including aliases)
+      # and return a type label (or :unknown) and a configuration name
+      # @param param_name [String] Input parameter name
+      # @return [Array<Symbol, String>] An array of [:detected_type, config_parameter_name]
+      def schema_name_type_for param_name
+        if @bool_params.key? param_name
+          [:bool, @bool_params[param_name]]
+        elsif @string_params.key? param_name
+          [:string, @string_params[param_name]]
+        elsif @array_params.key? param_name
+          [:array, @array_params[param_name]]
+        elsif @map_params.key? param_name
+          [:map, @map_params[param_name]]
+        else
+          [:unknown, param_name]
+        end
+      end
+    end
+  end
+end

data/lib/gapic/schema/request_param_parser.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+# Copyright 2020 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 "gapic/schema/request_parameter"
+require "gapic/schema/parameter_schema"
+
+module Gapic
+  module Schema
+    # Contains logic for parsing protoc request parameters
+    # from the plugin_opt command line
+    module RequestParamParser
+      class << self
+        # Unescapes a symbol from the string
+        # e.g. `'a\.b', '.' => 'a.b'`
+        # @param string [String] String to unescape
+        # @return [String] Unescaped string
+        def unescape string
+          string.gsub(/\\./) { |escaped| escaped[1] }
+        end
+
+        # Splits a string by an unescaped symbol
+        # e.g. `'a\.b.c.d\.e', '.'  => ['a\.b', 'c', 'd\.e']`
+        # @param string [String] String to split
+        # @param symbol [String] Symbol to split by
+        # @param max_splits [Integer] Maximum amount of splits to perform; -1 for no limit
+        # @return [Array<String>] List of split string parts
+        def split_by_unescaped string, symbol, max_splits = -1
+          splits = 0
+          escaped_symbol = Regexp.escape symbol
+          string.scan(/\\.|#{escaped_symbol}|[^#{escaped_symbol}\\]+/).each_with_object([String.new]) do |tok, arr|
+            if tok == symbol && (max_splits.negative? || splits < max_splits)
+              arr.append String.new
+              splits += 1
+            else
+              arr.last << tok
+            end
+            arr
+          end
+        end
+
+        # Parse a comma-delimited list of equals-delimited lists of strings, while
+        # mapping backslash-escaped commas and equal signs to literal characters.
+        # @param str [String] String to parse
+        # @param param_schema [ParameterSchema] Parameter schema to use
+        # @param error_output [IO] Stream to write outputs to.
+        # @return [Array<RequestParameter>] List of parameters parsed
+        def parse_parameters_string str, param_schema: nil, error_output: nil
+          return [] if str.empty?
+          param_schema ||= Gapic::Generators::DefaultGeneratorParameters.default_schema
+
+          param_val_input_strings = split_by_unescaped str, ","
+          param_val_input_strings.map do |param_val_input_str|
+            param_name_input_esc, value_str = split_by_unescaped param_val_input_str, "=", 1
+            param_name_input = unescape param_name_input_esc
+            param_type, param_config_name = param_schema.schema_name_type_for param_name_input
+
+            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_output&.puts error_str
+            end
+
+            param_value = parse_param_value param_type, value_str
+
+            if param_value
+              RequestParameter.new param_val_input_str, param_name_input_esc, value_str, param_config_name, param_value
+            end
+          end.compact # known bool parameters with invalid values will not be added so we have to compact
+        end
+
+        # Take a list of parameters and re-create an input string
+        # that can be parsed into these parameters
+        # @param parameters [Array<RequestParameter>] List of gapic-generator parameters
+        # @return [String] an input string with parameters
+        def reconstruct_parameters_string parameters
+          parameters.map(&:input_str).join ","
+        end
+
+        private
+
+        # Parses param value depending on type
+        # @param param_type [Symbol]
+        # @param value_str [String]
+        # @return [String,Array<String>,Hash{String => String}]
+        def parse_param_value param_type, value_str
+          case param_type
+          when :array
+            # elements in the arrays are concatenated by `;`
+            # e.g. foo;bar;baz
+            array_value_strings = split_by_unescaped value_str, ";"
+            array_value_strings.map { |s| unescape s }
+          when :map
+            # elements in the maps are `=` - separated key-value pairs, concatenated by ';'
+            # e.g. foo=hoge;bar=piyo
+            keyvaluepair_strings = split_by_unescaped value_str, ";"
+            new_hash = keyvaluepair_strings.map do |kvp_str|
+              split_by_unescaped(kvp_str, "=", 1).map { |s| unescape s }
+            end
+            new_hash.to_h
+          when :bool
+            # bools should be either `true` or `false`
+            unesc_val = unescape value_str
+            unesc_val if ["true", "false"].include? unesc_val
+          else
+            # if it's an unknown type, just escape it without attempting to parse anything
+            unescape value_str
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gapic/schema/request_parameter.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# Copyright 2020 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 Schema
+    # Encapsulates information that is parsed from a single command line parameter
+    # from the plugin_opt command line
+    class RequestParameter
+      attr_reader :input_str, :input_name, :input_value, :config_name, :config_value
+
+      # @param input_str [String] the input string containing parameter and value
+      #   that the parameter and value were parsed from
+      # @param input_name [String] the name of the parameter as found in the input
+      #   can be an alias to a known config parameter name
+      # @param input_value [String] the unescaped input value of the parameter as found in the input
+      # @param config_name [String] the known config parameter name as matched during parsing
+      # @param config_value [String,Array,Hash] the parsed and deserialized config value
+      def initialize input_str, input_name, input_value, config_name, config_value
+        @input_str = input_str
+        @input_name = input_name
+        @input_value = input_value
+        @config_name = config_name
+        @config_value = config_value
+      end
+
+      # The hash of input name-value
+      # @return [Hash {String => String}]
+      def to_input_h
+        { input_name => input_value }
+      end
+
+      # The hash of config name-value
+      # @return [Hash {String => String, Array, Hash}]
+      def to_config_h
+        { config_name => config_value }
+      end
+    end
+  end
+end

data/templates/default/gem/rubocop.erb

@@ -25,6 +25,10 @@ Metrics/PerceivedComplexity:
 Naming/FileName:
   Exclude:
     - "lib/<%= gem.name %>.rb"
+Naming/PredicateName:
+  Enabled: false
+Style/AsciiComments:
+  Enabled: false
 Style/CaseEquality:
   Enabled: false
 Style/IfUnlessModifier:

data/templates/default/lib/_package.erb

@@ -15,3 +15,7 @@ require "<%= package.gem.version_require %>"
 <%- end -%>
 module <%= package.module_name %>
 end
+<% @footer = capture do %>
+helper_path = ::File.join __dir__, "<%= package.package_directory_name %>", "<%= package.helpers_file_name %>"
+require "<%= package.helpers_require %>" if ::File.file? helper_path
+<% end %>

data/templates/default/service/_helpers.erb

@@ -1,3 +1,3 @@
 <%- assert_locals service -%>
-helper_path = ::File.join __dir__, "<%= service.service_directory_name%>", "helpers.rb"
+helper_path = ::File.join __dir__, "<%= service.service_directory_name %>", "<%= service.helpers_file_name %>"
 require "<%= service.helpers_require %>" if ::File.file? helper_path

data/templates/default/service/client/_client.erb

@@ -97,7 +97,13 @@ class <%= service.client_name %>
     # Create credentials
     credentials = @config.credentials
     <%- unless service.generic_endpoint? -%>
-    credentials ||= Credentials.default scope: @config.scope
+    # Use self-signed JWT if the scope and endpoint are unchanged from default,
+    # but only if the default endpoint does not have a region prefix.
+    enable_self_signed_jwt = @config.scope == <%= service.client_name %>.configure.scope &&
+                             @config.endpoint == <%= service.client_name %>.configure.endpoint &&
+                             !@config.endpoint.split(".").first.include?("-")
+    credentials ||= Credentials.default scope: @config.scope,
+                                        enable_self_signed_jwt: enable_self_signed_jwt
     if credentials.is_a?(String) || credentials.is_a?(Hash)
       credentials = Credentials.new credentials, scope: @config.scope
     end

data/templates/default/service/client/_config.erb

@@ -127,7 +127,7 @@ class Configuration
   # Each configuration object is of type `Gapic::Config::Method` and includes
   # the following configuration fields:
   #
-  #  *  `timeout` (*type:* `Numeric`) - The call timeout in milliseconds
+  #  *  `timeout` (*type:* `Numeric`) - The call timeout in seconds
   #  *  `metadata` (*type:* `Hash{Symbol=>String}`) - Additional gRPC headers
   #  *  `retry_policy (*type:* `Hash`) - The retry policy. The policy fields
   #     include the following keys:

data/templates/default/service/test/method/_bidi.erb

@@ -87,13 +87,13 @@ def test_<%= method.name %>
         assert_kind_of <%= method.request_type %>, r
         <%- fields.each do |field| -%>
         <%- if field.message? && field.repeated? && !field.map? -%>
-        assert_kind_of <%= field.type_name_full %>, r.<%= field.name %>.first
+        assert_kind_of <%= field.type_name_full %>, r["<%= field.name %>"].first
         <%- elsif field.map? -%>
-        assert_equal(<%= field.default_value %>, r.<%= field.name %>.to_h)
+        assert_equal(<%= field.default_value %>, r["<%= field.name %>"].to_h)
         <%- elsif field.message? -%>
-        assert_equal Gapic::Protobuf.coerce(<%= field.default_value %>, to: <%= field.type_name_full %>), r.<%= field.name %>
+        assert_equal Gapic::Protobuf.coerce(<%= field.default_value %>, to: <%= field.type_name_full %>), r["<%= field.name %>"]
         <%- else -%>
-        assert_equal <%= field.default_value %>, r.<%= field.name %>
+        assert_equal <%= field.default_value %>, r["<%= field.name %>"]
         <%- end -%>
         <%- if field.oneof? && !field.proto3_optional? -%>
         assert_equal :<%= field.name %>, r.<%= field.oneof_name %>

data/templates/default/service/test/method/_client.erb

@@ -71,13 +71,13 @@ def test_<%= method.name %>
         assert_kind_of <%= method.request_type %>, r
         <%- fields.each do |field| -%>
         <%- if field.message? && field.repeated? && !field.map? -%>
-        assert_kind_of <%= field.type_name_full %>, r.<%= field.name %>.first
+        assert_kind_of <%= field.type_name_full %>, r["<%= field.name %>"].first
         <%- elsif field.map? -%>
-        assert_equal(<%= field.default_value %>, r.<%= field.name %>.to_h)
+        assert_equal(<%= field.default_value %>, r["<%= field.name %>"].to_h)
         <%- elsif field.message? -%>
-        assert_equal Gapic::Protobuf.coerce(<%= field.default_value %>, to: <%= field.type_name_full %>), r.<%= field.name %>
+        assert_equal Gapic::Protobuf.coerce(<%= field.default_value %>, to: <%= field.type_name_full %>), r["<%= field.name %>"]
         <%- else -%>
-        assert_equal <%= field.default_value %>, r.<%= field.name %>
+        assert_equal <%= field.default_value %>, r["<%= field.name %>"]
         <%- end -%>
         <%- if field.oneof? && !field.proto3_optional? -%>
         assert_equal :<%= field.name %>, r.<%= field.oneof_name %>

data/templates/default/service/test/method/_normal.erb

@@ -18,13 +18,13 @@ def test_<%= method.name %>
     assert_kind_of <%= method.request_type %>, request
     <%- fields.each do |field| -%>
     <%- if field.message? && field.repeated? && !field.map? -%>
-    assert_kind_of <%= field.type_name_full %>, request.<%= field.name %>.first
+    assert_kind_of <%= field.type_name_full %>, request["<%= field.name %>"].first
     <%- elsif field.map? -%>
-    assert_equal(<%= field.default_value %>, request.<%= field.name %>.to_h)
+    assert_equal(<%= field.default_value %>, request["<%= field.name %>"].to_h)
     <%- elsif field.message? -%>
-    assert_equal Gapic::Protobuf.coerce(<%= field.default_value %>, to: <%= field.type_name_full %>), request.<%= field.name %>
+    assert_equal Gapic::Protobuf.coerce(<%= field.default_value %>, to: <%= field.type_name_full %>), request["<%= field.name %>"]
     <%- else -%>
-    assert_equal <%= field.default_value %>, request.<%= field.name %>
+    assert_equal <%= field.default_value %>, request["<%= field.name %>"]
     <%- end -%>
     <%- if field.oneof? && !field.proto3_optional? -%>
     assert_equal :<%= field.name %>, request.<%= field.oneof_name %>

data/templates/default/service/test/method/_server.erb

@@ -18,13 +18,13 @@ def test_<%= method.name %>
     assert_kind_of <%= method.request_type %>, request
     <%- fields.each do |field| -%>
     <%- if field.message? && field.repeated? && !field.map? -%>
-    assert_kind_of <%= field.type_name_full %>, request.<%= field.name %>.first
+    assert_kind_of <%= field.type_name_full %>, request["<%= field.name %>"].first
     <%- elsif field.map? -%>
-    assert_equal(<%= field.default_value %>, request.<%= field.name %>.to_h)
+    assert_equal(<%= field.default_value %>, request["<%= field.name %>"].to_h)
     <%- elsif field.message? -%>
-    assert_equal Gapic::Protobuf.coerce(<%= field.default_value %>, to: <%= field.type_name_full %>), request.<%= field.name %>
+    assert_equal Gapic::Protobuf.coerce(<%= field.default_value %>, to: <%= field.type_name_full %>), request["<%= field.name %>"]
     <%- else -%>
-    assert_equal <%= field.default_value %>, request.<%= field.name %>
+    assert_equal <%= field.default_value %>, request["<%= field.name %>"]
     <%- end -%>
     <%- if field.oneof? && !field.proto3_optional? -%>
     assert_equal :<%= field.name %>, request.<%= field.oneof_name %>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gapic-generator
 version: !ruby/object:Gem::Version
-  version: 0.6.7
+  version: 0.6.12
 platform: ruby
 authors:
 - Ernest Landrito
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-07 00:00:00.000000000 Z
+date: 2021-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -196,6 +196,7 @@ files:
 - lib/gapic/generator/version.rb
 - lib/gapic/generators/base_generator.rb
 - lib/gapic/generators/default_generator.rb
+- lib/gapic/generators/default_generator_parameters.rb
 - lib/gapic/grpc_service_config/method_config.rb
 - lib/gapic/grpc_service_config/parser.rb
 - lib/gapic/grpc_service_config/parsing_error.rb
@@ -225,6 +226,9 @@ files:
 - lib/gapic/schema.rb
 - lib/gapic/schema/api.rb
 - lib/gapic/schema/loader.rb
+- lib/gapic/schema/parameter_schema.rb
+- lib/gapic/schema/request_param_parser.rb
+- lib/gapic/schema/request_parameter.rb
 - lib/gapic/schema/wrappers.rb
 - lib/gapic/uri_template.rb
 - lib/gapic/uri_template/parser.rb
@@ -343,7 +347,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: An API Client Generator for Ruby in Ruby!