gapic-generator 0.1.4

data/lib/gapic/generators/default_generator.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+# Copyright 2018 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/generators/base_generator"
+
+module Gapic
+  module Generators
+    # The generator orchestrates the rendering of templates.
+    class DefaultGenerator < BaseGenerator
+      # Initializes the generator.
+      #
+      # @param api [Gapic::Schema::Api] The API model/context to
+      #   generate.
+      def initialize api
+        super
+
+        # Configure to use a custom templates directory
+        use_templates! File.join __dir__, "../../../templates/default"
+
+        # Configure these helper method to be used by the generator
+        use_helpers! :gem_presenter
+      end
+
+      # Disable Rubocop because we expect generate to grow and violate more
+      # and more style rules.
+      # rubocop:disable all
+
+      # Generates all the files for the API.
+      #
+      # @return [Array<
+      #   Google::Protobuf::Compiler::CodeGeneratorResponse::File>]
+      #   The files that were generated for the API.
+      def generate
+        files = []
+
+        gem = gem_presenter @api
+
+        gem.packages.each do |package|
+          # Package level files
+          files << g("package.erb", "lib/#{package.package_file_path}", package: package)
+
+          package.services.each do |service|
+            # Service level files
+            files << g("service.erb",                        "lib/#{service.service_file_path}",                 service: service)
+            files << g("service/client.erb",                 "lib/#{service.client_file_path}",                  service: service)
+            files << g("service/credentials.erb",            "lib/#{service.credentials_file_path}",             service: service)
+            files << g("service/paths.erb",                  "lib/#{service.paths_file_path}",                   service: service) if service.paths?
+            files << g("service/operations.erb",             "lib/#{service.operations_file_path}",              service: service) if service.lro?
+            files << g("service/test/client.erb",            "test/#{service.test_client_file_path}",            service: service)
+            files << g("service/test/client_operations.erb", "test/#{service.test_client_operations_file_path}", service: service) if service.lro?
+          end
+        end
+
+        # Gem level files
+        files << g("gem/gitignore.erb", ".gitignore",                   gem: gem)
+        files << g("gem/version.erb",   "lib/#{gem.version_file_path}", gem: gem)
+        files << g("gem/gemspec.erb",   "#{gem.name}.gemspec",          gem: gem)
+        files << g("gem/gemfile.erb",   "Gemfile",                      gem: gem)
+        files << g("gem/rakefile.erb",  "Rakefile",                     gem: gem)
+        files << g("gem/readme.erb",    "README.md",                    gem: gem)
+        files << g("gem/changelog.erb", "CHANGELOG.md",                 gem: gem)
+        files << g("gem/rubocop.erb",   ".rubocop.yml",                 gem: gem)
+        files << g("gem/yardopts.erb",  ".yardopts",                    gem: gem)
+        files << g("gem/license.erb",   "LICENSE.md",                   gem: gem)
+
+        gem.proto_files.each do |proto_file|
+          files << g("proto_docs/proto_file.erb", "proto_docs/#{proto_file.docs_file_path}", file: proto_file)
+        end
+        files << g("proto_docs/readme.erb", "proto_docs/README.md", gem: gem)
+
+        format_files files
+
+        files
+      end
+
+      # rubocop:enable all
+
+      private
+
+      ##
+      # Override the default rubocop config file to be used.
+      def format_config
+        @api.configuration[:format_config] ||
+          super
+      end
+    end
+  end
+end

data/lib/gapic/grpc_service_config/method_config.rb

@@ -0,0 +1,49 @@
+# 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 GrpcServiceConfig
+    ##
+    # Method config represents a combination of a timeout and
+    # a retry policy, both of which can be optional
+    # It is applied during a GRPC method call and governs the
+    # client-side timeout/retry policy
+    #
+    class MethodConfig
+      attr_reader :timeout_seconds, :retry_policy
+
+      ##
+      # Create new MethodConfig
+      #
+      # @param timeout_seconds [Float, nil] the value of timeout in seconds if provided
+      # @param retry_policy [Gapic::GrpcServiceConfig::RetryPolicy] the retry policy
+      #
+      def initialize timeout_seconds, retry_policy
+        @timeout_seconds = timeout_seconds
+        @retry_policy    = retry_policy
+      end
+
+      ##
+      # Returns whether MethodConfig is empty (does not contain any values)
+      #
+      # @return [Boolean] whether MethodConfig is empty
+      #
+      def empty?
+        @timeout_seconds.nil? && @retry_policy.empty?
+      end
+    end
+  end
+end

data/lib/gapic/grpc_service_config/parser.rb

@@ -0,0 +1,218 @@
+# 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/grpc_service_config/service_config"
+require "gapic/grpc_service_config/method_config"
+require "gapic/grpc_service_config/retry_policy"
+require "gapic/grpc_service_config/parsing_error"
+
+module Gapic
+  module GrpcServiceConfig
+    ##
+    # Takes a json of a GRPC service Config and parses it into the form
+    # usable by the microgenerator templates
+    #
+    module Parser
+      METHOD_CONFIG_JSON_KEY = "methodConfig"
+      RETRY_POLICY_JSON_KEY = "retryPolicy"
+
+      NAMES_JSON_KEY = "name"
+      SERVICE_NAME_JSON_KEY = "service"
+      METHOD_NAME_JSON_KEY = "method"
+
+      TIMEOUT_JSON_KEY = "timeout"
+
+      INITIAL_DELAY_JSON_KEY = "initialBackoff"
+      MAX_DELAY_JSON_KEY = "maxBackoff"
+      MULTIPLIER_JSON_KEY = "backoffMultiplier"
+      STATUS_CODES_JSON_KEY = "retryableStatusCodes"
+
+
+      ##
+      # Parses ServiceConfig from a json of a GRPC service config
+      #
+      # @param service_config_json [Hash] a hash that results from JSON.parse
+      #
+      # @return [Gapic::GrpcServiceConfig::ServiceConfig] parsed ServiceConfig
+      #
+      def self.parse service_config_json
+        service_level_result = {}
+        service_method_level_result = {}
+
+        if !service_config_json.nil? && key?(service_config_json, METHOD_CONFIG_JSON_KEY)
+          method_configs_json = get service_config_json, METHOD_CONFIG_JSON_KEY
+
+          method_configs_json.each do |method_config_json|
+            method_config = parse_config method_config_json
+            service_names = parse_service_names get(method_config_json, NAMES_JSON_KEY)
+            service_method_names = filter_service_method_names get(method_config_json, NAMES_JSON_KEY)
+
+            service_names.each do |service_name|
+              service_level_result[service_name] = method_config
+            end
+
+            service_method_names.each do |service_method_name|
+              service_name = get service_method_name, SERVICE_NAME_JSON_KEY
+              method_name = get service_method_name, METHOD_NAME_JSON_KEY
+
+              service_method_level_result[service_name] ||= {}
+              service_method_level_result[service_name][method_name] = method_config
+            end
+          end
+        end
+
+        ServiceConfig.new service_level_result, service_method_level_result
+      end
+
+      ##
+      # Parses the names of the services for which the service-level
+      # config is defined from the GRPC service config json.
+      # Within the json the names are arranged in hashes. Each hash contains a
+      # required "service" key and an optional "method" key. Here we select only
+      # the hashes WITHOUT the optional key -- meaning that the config will be
+      # applied on a service-level -- and return just the service names.
+      #
+      # @param method_config_json_names [Array<Hash<String, String>>] "name" hashes from
+      #   the GRPC service config
+      #
+      # @return [Array<String>] parsed names of services
+      #
+      def self.parse_service_names method_config_json_names
+        service_names_jsons = method_config_json_names.select do |names_json|
+          names_json.size == 1 && key?(names_json, SERVICE_NAME_JSON_KEY)
+        end
+
+        service_names_jsons.map { |names_json| get names_json, SERVICE_NAME_JSON_KEY }
+      end
+
+      ##
+      # Filters the "name" hashes from the GRPC service config json
+      # to exclude service-level names
+      # Within the json the names are arranged in hashes. Each hash contains a
+      # required "service" key and an optional "method" key. Here we select only
+      # the hashes WITH the optional key -- meaning that the config will be
+      # applied on a method-level -- and return the hashes in full.
+      #
+      # @param method_config_json_names [Array<Hash<String, String>>] "name" hashes
+      #   from the GRPC service config
+      #
+      # @return [Array<Hash<String, String>>] filtered hashes for methods
+      #
+      def self.filter_service_method_names method_config_json_names
+        method_config_json_names.select do |names_json|
+          names_json.size == 2 && key?(names_json, SERVICE_NAME_JSON_KEY) && key?(names_json, METHOD_NAME_JSON_KEY)
+        end
+      end
+
+      ##
+      # Parses MethodConfig from the GRPC service config json
+      #
+      # @param method_config_json [Hash] a hash of a single "method_config"
+      #   from the GRPC service config
+      #
+      # @return [Gapic::GrpcServiceConfig::MethodConfig] parsed MethodConfig
+      #
+      def self.parse_config method_config_json
+        timeout_seconds = parse_interval_seconds get(method_config_json, TIMEOUT_JSON_KEY)
+        retry_policy = parse_retry_policy get(method_config_json, RETRY_POLICY_JSON_KEY)
+
+        MethodConfig.new timeout_seconds, retry_policy
+      end
+
+      ##
+      # Parses RetryPolicy from the GRPC service config json
+      #
+      # @param retry_policy_json [Hash<String, String>] a hash of a single "retry_policy"
+      #   from the GRPC service config
+      #
+      # @return [Gapic::GrpcServiceConfig::RetryPolicy] parsed RetryPolicy
+      #
+      def self.parse_retry_policy retry_policy_json
+        return nil if retry_policy_json.nil? || retry_policy_json.empty?
+
+        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
+
+        RetryPolicy.new initial_delay_seconds, max_delay_seconds, multiplier, status_codes
+      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
+      # If given a nil or an empty string returns nil for 'not set' semantic
+      # If a string sans the 's' cannot be converted throws a ParsingError
+      #
+      # @param timestring [String, nil] a string of a time inerval from the GRPC service config
+      #
+      # @raise [ParsingError] if the time interval string could not be converted
+      #
+      # @return [Float, nil] converted time interval or nil for 'not set'
+      #
+      def self.parse_interval_seconds timestring
+        return nil if timestring.empty?
+
+        timestring_nos = timestring.delete_suffix "s"
+        unless valid_float? timestring_nos
+          error_text = "Was not able to convert the string `#{timestring}` " \
+                        "to a time interval when parsing a grpc service config"
+          raise ParsingError, error_text
+        end
+        Float(timestring_nos)
+      end
+
+      ##
+      # Determines if the key or its underscore form exists
+      #
+      # @param hash [Hash] hash structure
+      # @param key [String] lowerCamelCase string
+      # @return [Boolean]
+      #
+      def self.key? hash, key
+        hash.key?(key) || hash.key?(ActiveSupport::Inflector.underscore(key))
+      end
+
+      ##
+      # Look up a key including checking its underscore form
+      #
+      # @param hash [Hash] hash structure
+      # @param key [String] lowerCamelCase string
+      # @return [Object] the result, or `nil` if not found
+      #
+      def self.get hash, key
+        hash[key] || hash[ActiveSupport::Inflector.underscore(key)]
+      end
+
+      ##
+      # Determines if a given string can be converted to a float
+      #
+      # @param str [String, nil] a given string, can be nil
+      #
+      # @return [Boolean] true, if converstion to float is possible
+      #
+      def self.valid_float? str
+        Float(str)
+        true
+      rescue ::ArgumentError, ::TypeError
+        false
+      end
+
+      private_class_method :parse_service_names, :filter_service_method_names, :parse_config,
+                           :parse_retry_policy, :parse_interval_seconds, :valid_float?
+    end
+  end
+end

data/lib/gapic/grpc_service_config/parsing_error.rb

@@ -0,0 +1,25 @@
+# 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 GrpcServiceConfig
+    ##
+    # Represents an error occuring during the GRPC config parsing
+    #
+    class ParsingError < StandardError
+    end
+  end
+end

data/lib/gapic/grpc_service_config/retry_policy.rb

@@ -0,0 +1,51 @@
+# 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 GrpcServiceConfig
+    ##
+    # RetryPolicy encapsulates the parameters governing the client-side retry
+    # for the GRPC method invocation. It is embedded into the MethodConfig
+    #
+    class RetryPolicy
+      attr_reader :initial_delay_seconds, :max_delay_seconds, :multiplier, :status_codes
+
+      ##
+      # Create new ParsedRetryPolicy.
+      #
+      # @param initial_delay_seconds [Float, nil] the value of initial retry delay in seconds if provided
+      # @param max_delay_seconds [Float, nil] the value of max retry delay in seconds if provided
+      # @param multiplier [Float, nil] the value of retry multiplier if provided
+      # @param status_codes [Array<String>, nil] the retry status codes if provided
+      #
+      def initialize initial_delay_seconds, max_delay_seconds, multiplier, status_codes
+        @initial_delay_seconds = initial_delay_seconds
+        @max_delay_seconds     = max_delay_seconds
+        @multiplier            = multiplier
+        @status_codes          = status_codes
+      end
+
+      ##
+      # Returns whether RetryPolicy is empty (does not contain any values)
+      #
+      # @return [Boolean] whether RetryPolicy is empty
+      #
+      def empty?
+        @initial_delay_seconds.nil? && @max_delay_seconds.nil? && @multiplier.nil? && status_codes.to_a.empty?
+      end
+    end
+  end
+end

data/lib/gapic/grpc_service_config/service_config.rb

@@ -0,0 +1,42 @@
+# 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 GrpcServiceConfig
+    ##
+    # Representation of a GRPC service config split into the configurations
+    # applied on the service level (to all the methods) and the configurations
+    # applied to the specific methods
+    #
+    class ServiceConfig
+      attr_reader :service_level_configs, :service_method_level_configs
+
+      ##
+      # Create new ServiceConfig.
+      #
+      # @param service_level_configs [Hash<String, Gapic::GrpcServiceConfig::MethodConfig>] service-level configs
+      #   in a lookup hash by the service full grpc name
+      #
+      # @param service_method_level_configs [Hash<String, Hash<String, Gapic::GrpcServiceConfig::MethodConfig>>]
+      #   method-level configs in a double lookup hash, first by the service full grpc name then by the method name
+      #
+      def initialize service_level_configs, service_method_level_configs
+        @service_level_configs = service_level_configs
+        @service_method_level_configs = service_method_level_configs
+      end
+    end
+  end
+end