gapic-generator 0.1.4

data/lib/gapic/path_template.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Copyright 2019 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/path_template/parser"
+
+module Gapic
+  # TODO: Enter docs
+  # Dooooooooocs!!!
+  module PathTemplate
+    # Parse a URI path template.
+    #
+    # @see https://tools.ietf.org/html/rfc6570 URI Template
+    #
+    # @param path_template [String] The URI path template to be parsed.
+    #
+    # @return [Array<PathTemplate::Segment|String>] The segments of the URI
+    #   path template.
+    def self.parse path_template
+      Parser.new(path_template).segments
+    end
+  end
+end

data/lib/gapic/path_template/parser.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# Copyright 2019 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/path_template/segment"
+
+module Gapic
+  module PathTemplate
+    # A URI path template parser.
+    #
+    # @see https://tools.ietf.org/html/rfc6570 URI Template
+    #
+    # @!attribute [r] path_template
+    #   @return [String] The URI path template to be parsed.
+    # @!attribute [r] segments
+    #   @return [Array<Segment|String>] The segments of the parsed URI path
+    #     template.
+    class Parser
+      # @private
+      # /((?<positional>\*\*?)|{(?<name>[^\/]+?)(?:=(?<template>.+?))?})/
+      PATH_TEMPLATE = %r{
+        (
+          (?<positional>\*\*?)
+          |
+          {(?<name>[^\/]+?)(?:=(?<template>.+?))?}
+        )
+      }x.freeze
+
+      attr_reader :path_template, :segments
+
+      # Create a new URI path template parser.
+      #
+      # @param path_template [String] The URI path template to be parsed.
+      def initialize path_template
+        @path_template = path_template
+        @segments = parse! path_template
+      end
+
+      protected
+
+      def parse! path_template
+        # segments contain either Strings or segment objects
+        segments = []
+        segment_pos = 0
+
+        while (match = PATH_TEMPLATE.match path_template)
+          # The String before the match needs to be added to the segments
+          segments << match.pre_match unless match.pre_match.empty?
+
+          segment, segment_pos = segment_and_pos_from_match match, segment_pos
+          segments << segment
+
+          path_template = match.post_match
+        end
+
+        # Whatever String is unmatched needs to be added to the segments
+        segments << path_template unless path_template.empty?
+
+        segments
+      end
+
+      def segment_and_pos_from_match match, pos
+        if match[:positional]
+          [Segment.new(pos, match[:positional]), pos + 1]
+        else
+          [Segment.new(match[:name], match[:template]), pos]
+        end
+      end
+    end
+  end
+end

data/lib/gapic/path_template/segment.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# Copyright 2019 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 PathTemplate
+    # A segment in a URI path template.
+    #
+    # @see https://tools.ietf.org/html/rfc6570 URI Template
+    #
+    # @!attribute [r] name
+    #   @return [String, Integer] The name of a named segment, or the position
+    #     of a positional segment.
+    # @!attribute [r] pattern
+    #   @return [String, nil] The pattern of the segment, nil if not set.
+    class Segment
+      attr_reader :name, :pattern
+
+      def initialize name, pattern
+        @name    = name
+        @pattern = pattern
+      end
+
+      # Determines if the segment is positional (has a number for a name).
+      #
+      # @return [Boolean]
+      def positional?
+        name.is_a? Integer
+      end
+
+      # Determines if the segment is named (has a string for a name).
+      #
+      # @return [Boolean]
+      def named?
+        !positional?
+      end
+
+      # Determines if the segment has a pattern. Positional segments always
+      # have a pattern. Named segments may have a pattern if provided in the
+      # URI path template.
+      #
+      # @return [Boolean]
+      def pattern?
+        !@pattern.nil?
+      end
+
+      # @private
+      def == other
+        return false unless other.is_a? self.class
+
+        (name == other.name) && (pattern == other.pattern)
+      end
+    end
+  end
+end

data/lib/gapic/resource_lookup.rb

@@ -0,0 +1,91 @@
+# 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
+  # TODO: Enter docs
+  # Dooooooooocs!!!
+  class ResourceLookup
+    # @private
+    def initialize service
+      @service = service
+      @api = service.parent.parent
+    end
+
+    # @private
+    def lookup!
+      resources = @api.files.flat_map { |file| lookup_file_resource_descriptors file }
+      resources.compact.uniq
+    end
+
+    # @private
+    def lookup_file_resource_descriptors file
+      resources = []
+      resources += file.resources.select { |resource| service_resource_types.include? resource.type }
+      resources += file.messages.flat_map { |message| lookup_message_resources_descriptors message }
+      resources
+    end
+
+    # @private
+    def service_resource_types
+      @service_resource_types ||= begin
+        @service.methods.flat_map do |method|
+          message_resource_types method.input
+        end.uniq
+      end
+    end
+
+    # @private
+    def message_resource_types message, seen_messages = []
+      return [] if seen_messages.include? message
+      seen_messages << message
+      resource_types = []
+      resource_types << message.resource.type if message.resource
+      resource_types += message.nested_messages.map do |nested_message|
+        message_resource_types nested_message, seen_messages
+      end
+      message.fields.each do |field|
+        resource_types << field.resource_reference.type if field.resource_reference
+        resource_types += message_resource_types field.message, seen_messages if field.message?
+      end
+      resource_types.flatten
+    end
+
+    # @private
+    def lookup_message_resources_descriptors message
+      resources = []
+
+      # We don't expect service_resource_types to iclude nil, so we can use message.resource&.type
+      resources << message.resource if service_resource_types.include? message.resource&.type
+
+      if message.nested_messages
+        resources += message.nested_messages.flat_map do |nested_message|
+          lookup_message_resources_descriptors nested_message
+        end
+      end
+
+      resources
+    end
+
+    # Lookup all resources for a given service.
+    #
+    # @param service [Gapic::Service] The service to lookup on.
+    #
+    # @return [Array<Google::Api::ResourceDescriptor>]
+    def self.for_service service
+      ResourceLookup.new(service).lookup!
+    end
+  end
+end

data/lib/gapic/runner.rb

@@ -0,0 +1,76 @@
+# 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/generator"
+require "gapic/schema"
+require "google/protobuf/compiler/plugin.pb"
+
+module Gapic
+  # TODO: Enter docs
+  # Dooooooooocs!!!
+  class Runner
+    attr_reader :request
+
+    # Initializes the runner.
+    # @param [Google::Protobuf::Compiler::CodeGeneratorRequest] request
+    def initialize request
+      @request = request
+    end
+
+    # Run protoc generation.
+    # @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
+
+      # Retrieve generator type from protoc_options if not already provided.
+      generator_type ||= api.protoc_options["generator"]
+      # Find the generator for the generator type.
+      generator = Gapic::Generator.find generator_type
+
+      # Create and run the generator from the API.
+      output_files = generator.new(api).generate
+
+      # Create and write the response
+      Google::Protobuf::Compiler::CodeGeneratorResponse.new \
+        file: output_files
+    end
+
+    # Run protoc generation.
+    # @param [Google::Protobuf::Compiler::CodeGeneratorRequest] request
+    # @param [String] generator
+    # @return [Google::Protobuf::Compiler::CodeGeneratorResponse]
+    def self.run request, generator: nil
+      new(request).run generator_type: generator
+    end
+
+    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
+
+      # Write binary file if the binary_output option is set
+      File.binwrite binary_file, request.to_proto
+    end
+  end
+end

data/lib/gapic/schema.rb

@@ -0,0 +1,17 @@
+# 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/schema/api"

data/lib/gapic/schema/api.rb

@@ -0,0 +1,264 @@
+# 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 "yaml"
+require "json"
+require "gapic/schema/loader"
+require "gapic/grpc_service_config/parser"
+
+module Gapic
+  module Schema
+    # rubocop:disable Metrics/ClassLength
+
+    # A representation of a full API.
+    #
+    # @!attribute [r] files
+    #   @return [Array<File>] The files represented by this API.
+    # @!attribute [r] services
+    #   @return [<Array<Service>] The services seen across all files in this
+    #     API.
+    # @!attribute [r] messages
+    #   @return [Array<Message>] The top level messages seen across all files
+    #     in this API.
+    # @!attribute [r] enums
+    #   @return [Array<Enum>] The top level enums seen across all files in
+    #     this API.
+    class Api
+      attr_accessor :request, :files
+
+      # Initializes an API object with the file descriptors that represent the
+      # API.
+      #
+      # @param request [Google::Protobuf::Compiler::CodeGeneratorRequest]
+      #   The request object.
+      def initialize request
+        @request = request
+        loader = Loader.new
+        @files = request.proto_file.map do |fd|
+          loader.load_file fd, request.file_to_generate.include?(fd.name)
+        end
+        @files.each { |f| f.parent = self }
+      end
+
+      def lookup address
+        address = address.join "." if address.is_a? Array
+        @files.each do |f|
+          lookup = f.lookup address
+          return lookup if lookup
+        end
+        nil
+      end
+
+      def file_for address
+        address = address.join "." if address.is_a? Array
+        matching_files = @files.select { |f| f.lookup address }
+        matching_files.first
+      end
+
+      def fix_file_path str
+        str = String str
+        return str if configuration[:overrides].nil?
+        return str if configuration[:overrides][:file_path].nil?
+        configuration[:overrides][:file_path].fetch str, str
+      end
+
+      def fix_namespace str
+        str = String str
+        return str if configuration[:overrides].nil?
+        return str if configuration[:overrides][:namespace].nil?
+        configuration[:overrides][:namespace].fetch str, str
+      end
+
+      def generate_files
+        @files.select(&:generate?)
+      end
+
+      def services
+        @files.map(&:services).flatten
+      end
+
+      def messages
+        @files.map(&:messages).flatten
+      end
+
+      # 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
+          end
+          result
+        end
+      end
+
+      # Reconstructed string representation of the protoc options
+      # @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 ","
+      end
+
+      # Structured representation of the samples configuration files.
+      # @return [Array<Hash>]
+      #   An array of the sample file hashes.
+      def samples
+        @samples ||= begin
+          protoc_options["samples"].to_s.split(";").flat_map do |sample_path|
+            YAML.load_file sample_path
+          end.compact
+        end
+      end
+
+      # Structured representation of the standalone samples configuration files.
+      # @return [Array<Hash>]
+      #   An array of the standalone sample configuration hashes.
+      def standalone_samples
+        @standalone_samples ||= begin
+          supported_types = [
+            "com.google.api.codegen.SampleConfigProto",
+            "com.google.api.codegen.samplegen.v1p2.SampleConfigProto"
+          ]
+          supported_sample_types = [nil, "standalone"]
+          samples.select { |sample_file| supported_types.include? sample_file["type"] }
+                 .select { |sample_file| sample_file["schema_version"] == "1.2.0" }
+                 .map { |sample_file| sample_file["samples"] }
+                 .flatten.compact
+                 .select { |sample_config| supported_sample_types.include? sample_config["sample_type"] }
+        end
+      end
+
+      # Structured representation of the standalone test samples configuration files.
+      # @return [Array<Hash>]
+      #   An array of the standalone sample configuration hashes.
+      def standalone_test_samples
+        @standalone_test_samples ||= begin
+          samples.select { |sample| sample["type"] == "test/samples" }
+                 .select { |sample| sample["schema_version"] == "1" || sample["schema_version"] == 1 }
+                 .map { |sample| sample["samples"] }
+                 .flatten.compact
+        end
+      end
+
+      # Structured representation of the inline samples configuration files.
+      # @return [Array<Hash>]
+      #   An array of the incode sample configuration hashes, sorted by sample_type.
+      def incode_samples
+        @incode_samples ||= begin
+          supported_types = [
+            "com.google.api.codegen.SampleConfigProto",
+            "com.google.api.codegen.samplegen.v1p2.SampleConfigProto"
+          ]
+          samples.select { |sample_file| supported_types.include? sample_file["type"] }
+                 .select { |sample_file| sample_file["schema_version"] == "1.2.0" }
+                 .map { |sample_file| sample_file["samples"] }
+                 .flatten.compact
+                 .select { |sample_config| sample_config["sample_type"]&.start_with? "incode/" }
+                 .sort_by { |sample_config| sample_config["sample_type"] }
+        end
+      end
+
+      # Structured Hash representation of the configuration file.
+      # @return [Hash]
+      #   A Hash of the configuration values.
+      def configuration
+        @configuration ||= begin
+          config_file = protoc_options["configuration"]
+          config = config_file ? YAML.load_file(config_file) : {}
+          protoc_options.each do |k, v|
+            next if k == "configuration"
+            branch = key_to_str(k).split(".").reverse.inject(v) { |m, s| { str_to_key(s) => m } }
+            config = deep_merge config, branch
+          end
+          config
+        end
+      end
+
+      # Raw parsed json of the combined grpc service config files if provided
+      # or an empty hash if no config was provided
+      def grpc_service_config_raw
+        @grpc_service_config_raw ||= begin
+          filenames = protoc_options["grpc_service_config"].to_s.split ";"
+          filenames.inject({}) do |running_hash, filename|
+            file_hash = JSON.parse ::File.read filename
+            deep_merge running_hash, file_hash
+          end
+        end
+      end
+
+      # Parsed grpc service config
+      def grpc_service_config
+        @grpc_service_config ||= begin
+          Gapic::GrpcServiceConfig::Parser.parse grpc_service_config_raw
+        end
+      end
+
+      private
+
+      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
+      end
+
+      def str_to_key str
+        str = str.to_s
+        str.start_with?(":") ? str[1..-1].to_sym : str
+      end
+
+      def key_to_str key
+        key.is_a?(::Symbol) ? ":#{key}" : key.to_s
+      end
+
+      def deep_merge left, right
+        left.merge right do |_k, lt, rt|
+          if lt.is_a?(Hash) && rt.is_a?(Hash)
+            deep_merge lt, rt
+          elsif lt.is_a?(Array) && rt.is_a?(Array)
+            lt + rt
+          else
+            rt
+          end
+        end
+      end
+    end
+
+    # rubocop:enable Metrics/ClassLength
+  end
+end