gapic-generator 0.6.5 → 0.6.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27e2894595efed8561aa48e9059465257267e7f29310a806251bcc6d4d85c63f
-  data.tar.gz: af47f16264074317a8d02e73539208a4b43f565ae346aef480619bc73a6b1203
+  metadata.gz: 4fd38043485e7ffbb2e8edf375019429972c5ac01b8be85803c5f6f9518b06c5
+  data.tar.gz: 23312fda7203a549f3e2f714df2ef73a0d71aea1aae369104de8ba079d4746c1
 SHA512:
-  metadata.gz: eacd1840fadb1236cb5ed7efe7ba254a977529435ee7ddff1fcee7bb900fa847ccc0a3b861098f1292a63f72e82f6065146f1f0a0260b0624dc9a184de3d3389
-  data.tar.gz: 8a93aaef7317b85fc048604b626af4cef13cf90ea2dd785a12180d94d71dbf0bc4ea24a34c828a04825adcfd4ae2b88e4cc3934d41de7de01b3be27f6302aaba
+  metadata.gz: cef8f93df7ca8b3207815a9c8239eeea6fb783265943d6ec22b246945582df439ddad1419a1783df8c0c1a3e432194a8ddb204c08856ac67dce5abb030ede394
+  data.tar.gz: 82df4fc573990154f629711aa9829d0c8aa6aacb2df34bcff9cff140dd5049de1f135325c5df089ca9b6b9188fae415e1bad351df8e6904bc1e071c0ae3ee63b

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Release History for gapic-generator
 
+### 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.
+
+### 0.6.6 / 2020-08-05
+
+* Use numeric error codes rather than strings in generated retry configs.
+
 ### 0.6.5 / 2020-07-16
 
 * Examples in auth, rakefile, and readme should pick a non-common service.

data/lib/gapic/generator/version.rb

@@ -16,6 +16,6 @@
 
 module Gapic
   module Generator
-    VERSION = "0.6.5"
+    VERSION = "0.6.10"
   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/grpc_service_config/parser.rb

@@ -40,6 +40,31 @@ module Gapic
       MULTIPLIER_JSON_KEY = "backoffMultiplier"
       STATUS_CODES_JSON_KEY = "retryableStatusCodes"
 
+      # See https://grpc.github.io/grpc/core/md_doc_statuscodes.html for a
+      # list of error codes.
+      ERROR_CODE_MAPPING = [
+        "OK",
+        "CANCELLED",
+        "UNKNOWN",
+        "INVALID_ARGUMENT",
+        "DEADLINE_EXCEEDED",
+        "NOT_FOUND",
+        "ALREADY_EXISTS",
+        "PERMISSION_DENIED",
+        "RESOURCE_EXHAUSTED",
+        "FAILED_PRECONDITION",
+        "ABORTED",
+        "OUT_OF_RANGE",
+        "UNIMPLEMENTED",
+        "INTERNAL",
+        "UNAVAILABLE",
+        "DATA_LOSS",
+        "UNAUTHENTICATED"
+      ].freeze
+
+      ERROR_STRING_MAPPING = ERROR_CODE_MAPPING.each_with_index.each_with_object({}) do |(str, num), hash|
+        hash[str] = num
+      end.freeze
 
       ##
       # Parses ServiceConfig from a json of a GRPC service config
@@ -146,11 +171,26 @@ module Gapic
         initial_delay_seconds = parse_interval_seconds get(retry_policy_json, INITIAL_DELAY_JSON_KEY)
         max_delay_seconds = parse_interval_seconds get(retry_policy_json, MAX_DELAY_JSON_KEY)
         multiplier = get retry_policy_json, MULTIPLIER_JSON_KEY
-        status_codes = get retry_policy_json, STATUS_CODES_JSON_KEY
+        status_codes = convert_codes get retry_policy_json, STATUS_CODES_JSON_KEY
 
         RetryPolicy.new initial_delay_seconds, max_delay_seconds, multiplier, status_codes
       end
 
+      ##
+      # Interpret input status codes. Convert strings to their associated integer codes.
+      #
+      def self.convert_codes input_codes
+        return nil if input_codes.nil?
+        Array(input_codes).map do |obj|
+          case obj
+          when String
+            ERROR_STRING_MAPPING[obj]
+          when Integer
+            obj
+          end
+        end.compact
+      end
+
       ##
       # Parses time expressed in secondds from the GRPC service config json
       # The time is encoded is a string as float or integer with a letter 's' afterwards
@@ -212,7 +252,7 @@ module Gapic
       end
 
       private_class_method :parse_service_names, :filter_service_method_names, :parse_config,
-                           :parse_retry_policy, :parse_interval_seconds, :valid_float?
+                           :parse_retry_policy, :parse_interval_seconds, :valid_float?, :convert_codes
     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/_config.erb

@@ -87,7 +87,7 @@ class Configuration
 
   config_attr :endpoint,      <%= service.client_endpoint.inspect %>, ::String
   config_attr :credentials,   nil do |value|
-    allowed = [::String, ::Hash, ::Proc, ::Google::Auth::Credentials, ::Signet::OAuth2::Client, nil]
+    allowed = [::String, ::Hash, ::Proc, ::Symbol, ::Google::Auth::Credentials, ::Signet::OAuth2::Client, nil]
     allowed += [::GRPC::Core::Channel, ::GRPC::Core::ChannelCredentials] if defined? ::GRPC
     allowed.any? { |klass| klass === value }
   end
@@ -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.5
+  version: 0.6.10
 platform: ruby
 authors:
 - Ernest Landrito
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-20 00:00:00.000000000 Z
+date: 2021-01-14 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.2
 signing_key: 
 specification_version: 4
 summary: An API Client Generator for Ruby in Ruby!