gapic-generator 0.6.0 → 0.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19f79c05f4e657a010e8f9663f1eefeadabd18ef4b456c137a8278bf8bb13a9e
-  data.tar.gz: ebe4c8c756ebd1e18424eccffc986f92bcda6f694a50842ed394c7d62d91f252
+  metadata.gz: 27e2894595efed8561aa48e9059465257267e7f29310a806251bcc6d4d85c63f
+  data.tar.gz: af47f16264074317a8d02e73539208a4b43f565ae346aef480619bc73a6b1203
 SHA512:
-  metadata.gz: 4a6689a12fcd02390d416ab8ada828f79e182e87a3230361fe32e3a8eea42d7555039b61c699903d25a5fb244c9db1857bbad1d816ea04e4de329d67c4359c74
-  data.tar.gz: fac5801f38bb3fd92b871c2c5ab9b2d7ee7138d0947ffb0c9695bd21ea0561762fee5dc462de884b5182cbf4627c5c9148783474584b6cb4c9dc7727313f7f1c
+  metadata.gz: eacd1840fadb1236cb5ed7efe7ba254a977529435ee7ddff1fcee7bb900fa847ccc0a3b861098f1292a63f72e82f6065146f1f0a0260b0624dc9a184de3d3389
+  data.tar.gz: 8a93aaef7317b85fc048604b626af4cef13cf90ea2dd785a12180d94d71dbf0bc4ea24a34c828a04825adcfd4ae2b88e4cc3934d41de7de01b3be27f6302aaba

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Release History for gapic-generator
 
+### 0.6.5 / 2020-07-16
+
+* Examples in auth, rakefile, and readme should pick a non-common service.
+* Emit a warning if common_services config references a nonexistent service.
+
+### 0.6.4 / 2020-07-13
+
+* Fix rubocop warning on a generated multi-path helper if it could take no arguments.
+* Run the rubocop file formatting step without caching.
+* Fix an issue where generating a service with no options would fail.
+
+### 0.6.3 / 2020-06-27
+
+* Fixes for generated tests for some cases involving proto maps.
+* Fix a Ruby 2.7 keyword arguments warning in generated tests.
+* Clean up bundler references in gemspecs and Gemfiles.
+
+### 0.6.2 / 2020-06-18
+
+* Support for the proto3_optional
+* Fixed an issue where tests for the oneof fields were not generating correctly
+* Removed ruby <2.5 pin for the protobuf dependency since new protobuf supports it again
+* Generated libraries now depend on gapic-common 0.3
+
+### 0.6.1 / 2020-06-16
+
+* Add auto-generated disclaimer to generated tests.
+* Support shortname and issue tracker URL configs.
+* Refactors and minor fixes around resource template parsing.
+
 ### 0.6.0 / 2020-06-02
 
 * Support for clients with generic endpoint and credentials.

data/gem_templates/entrypoint.erb

@@ -16,6 +16,7 @@ done
 
 mkdir -p /workspace/out/lib
 exec grpc_tools_ruby_protoc \
+        --experimental_allow_proto3_optional=1 \
         --proto_path=/workspace/common-protos/ --proto_path=/workspace/in/ \
         --ruby_out=/workspace/out/lib \
         --grpc_out=/workspace/out/lib \

data/gem_templates/gemspec.erb

@@ -29,7 +29,6 @@ Gem::Specification.new do |spec|
   spec.add_dependency "protobuf", "~> 3.8"
   spec.add_dependency "rubocop", "~> 0.61"
 
-  spec.add_development_dependency "bundler", "~> 2.1"
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency "minitest-focus", "~> 1.0"
   spec.add_development_dependency "rake", "~> 10.0"

data/lib/gapic/file_formatter.rb

@@ -26,7 +26,6 @@ module Gapic
     ##
     # Create a new file formatter object
     #
-    # @param path_template [String] The URI path template to be parsed.
     def initialize configuration, files
       @configuration = configuration
       @files = format! configuration, files
@@ -40,7 +39,7 @@ module Gapic
           write_file dir, file
         end
 
-        system "rubocop -x #{dir} -o #{dir}/rubocop.out -c #{configuration}"
+        system "rubocop --cache false -x #{dir} -o #{dir}/rubocop.out -c #{configuration}"
 
         files.each do |file|
           read_file dir, file

data/lib/gapic/generator/version.rb

@@ -16,6 +16,6 @@
 
 module Gapic
   module Generator
-    VERSION = "0.6.0"
+    VERSION = "0.6.5"
   end
 end

data/lib/gapic/{path_template.rb → path_pattern.rb}

@@ -14,22 +14,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require "gapic/path_template/parser"
+require "gapic/path_pattern/parser"
 
 module Gapic
   # TODO: Enter docs
   # Dooooooooocs!!!
-  module PathTemplate
-    # Parse a URI path template.
+  module PathPattern
+    # Parse a URI path pattern.
     #
-    # @see https://tools.ietf.org/html/rfc6570 URI Template
+    # @see https://google.aip.dev/122 AIP-122 Resource names
+    # @see https://google.aip.dev/123 AIP-123 Resource types
     #
-    # @param path_template [String] The URI path template to be parsed.
+    # @param path_pattern [String] The URI path template to be parsed.
     #
-    # @return [Array<PathTemplate::Segment|String>] The segments of the URI
+    # @return [PathPattern::Pattern] The parsed pattern
     #   path template.
-    def self.parse path_template
-      Parser.new(path_template).segments
+    def self.parse path_pattern
+      Parser.parse path_pattern
     end
   end
 end

data/lib/gapic/path_pattern/parser.rb

@@ -0,0 +1,146 @@
+# 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_pattern/segment"
+require "gapic/path_pattern/pattern"
+
+module Gapic
+  module PathPattern
+    ##
+    # A path pattern parser.
+    # takes a pattern and transforms it into a collection of parsed segments
+    # @see https://google.aip.dev/122
+    # @see https://google.aip.dev/123
+    #
+    module Parser
+      ##
+      # @param path_pattern [String] The path pattern to be parsed
+      # @return [Gapic::PathPattern::Pattern]
+      def self.parse path_pattern
+        remainder = path_pattern.sub(%r{^/}, "").sub(%r{/$}, "")
+
+        segments = []
+        position = 0
+        until remainder.empty?
+          segment, position, remainder = parse_first_segment_with_position remainder, position
+          segments << segment
+        end
+
+        Pattern.new path_pattern, segments
+      end
+
+      # @private
+      def self.parse_first_segment_with_position url_pattern, position
+        # check for the wildcard segment -- either * or **
+        # wildcard segments are positional, so the position counter is used and updated
+        segment, remainder = try_capture_wildcard_segment url_pattern, position
+        return [segment, position + 1, remainder] if segment
+
+        # check for the complex resource id segment, e.g. {foo}-{bar}_{baz}
+        segment, remainder = try_capture_complex_resource_id_segment url_pattern
+        return [segment, position, remainder] if segment
+
+        # check for the simple resource id segment, e.g. {foo} or {foo=some/pattern/*}
+        segment, remainder = try_capture_simple_resource_id_segment url_pattern
+        return [segment, position, remainder] if segment
+
+        # if nothing else fits, it's the collection id segment
+        segment, remainder = capture_collection_id_segment url_pattern
+        [segment, position, remainder]
+      end
+
+      ##
+      # Tries to capture the first segment of the pattern as a wildcard segment
+      # The wildcard segment can be either * or **
+      # @private
+      def self.try_capture_wildcard_segment url_pattern, position
+        wildcard_capture_regex = %r{^(?<pattern>\*\*|\*)(?:/|$)}
+        return nil, url_pattern unless wildcard_capture_regex.match? url_pattern
+
+        match = wildcard_capture_regex.match url_pattern
+
+        wildcard_pattern = match[:pattern]
+
+        segment = PositionalSegment.new position, wildcard_pattern
+        remainder = match.post_match
+        [segment, remainder]
+      end
+
+      ##
+      # Tries to capture the first segment of the pattern as a complex resource id segment
+      # The pattern for the complex resource id segments is:
+      # {<name_first>}<separator>{<name_second>} etc, e.g. {foo}-{bar}_{baz}
+      # see AIP-4231 Parsing resource names, Complex resource ID path segments
+      # @private
+      def self.try_capture_complex_resource_id_segment url_pattern
+        complex_resource_id_regex =
+          %r/^(?<segment_pattern>{(?<name_first>[^\/}]+?)}(?:(?<separator>[_\-~\.]){(?<name_seq>[^\/}]+?)})+)(?:\/|$)/
+
+        return nil, url_pattern unless complex_resource_id_regex.match? url_pattern
+
+        match = complex_resource_id_regex.match url_pattern
+        segment_pattern = match[:segment_pattern]
+
+        resource_name_regex = %r/{(?<name>[^\/}]+?)}/
+        resource_names = segment_pattern.scan(resource_name_regex).flatten
+
+        segment = ResourceIdSegment.new :complex_resource_id, segment_pattern, resource_names
+        remainder = match.post_match
+        [segment, remainder]
+      end
+
+      ##
+      # Tries to capture the first segment of the pattern as a simple resource id segment
+      # The pattern for the simple resource id segments is:
+      # {<name>} or with an optional resource name pattern {<name>=<pattern>}
+      # e.g. {foo} or with an optional pattern, e.g. {foo=**} or {foo=bar}
+      # notably here the pattern between the = and } *can* contain the path separator /
+      # @private
+      def self.try_capture_simple_resource_id_segment url_pattern
+        simple_resource_id_regex =
+          %r/^(?<segment_pattern>{(?<resource_name>[^\/}]+?)(?:=(?<resource_pattern>.+?))?})(?:\/|$)/
+        return nil, url_pattern unless simple_resource_id_regex.match? url_pattern
+
+        match = simple_resource_id_regex.match url_pattern
+        segment_pattern = match[:segment_pattern]
+
+        resource_name = match[:resource_name]
+        resource_pattern = match[:resource_pattern] if match.names.include? "resource_pattern"
+        resource_patterns = resource_pattern.nil? ? [] : [resource_pattern]
+
+        segment = ResourceIdSegment.new :simple_resource_id, segment_pattern, [resource_name], resource_patterns
+        remainder = match.post_match
+        [segment, remainder]
+      end
+
+      ##
+      # Captures the first segment of the pattern as a collection id segment
+      # This is used as a catch-all, so the collection id segment can contain anything
+      # except the path separator /
+      # @private
+      def self.capture_collection_id_segment url_pattern
+        collection_id_regex = %r{^(?<collection_name>[^/]+?)(?:/|$)}
+        match = collection_id_regex.match url_pattern
+
+        collection_name = match[:collection_name]
+
+        segment = CollectionIdSegment.new collection_name
+        remainder = match.post_match
+        [segment, remainder]
+      end
+    end
+  end
+end

data/lib/gapic/path_pattern/pattern.rb

@@ -0,0 +1,80 @@
+# 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/path_pattern/segment"
+
+module Gapic
+  module PathPattern
+    ##
+    # A parsed pattern.
+    # @see https://google.aip.dev/122 AIP-122 Resource names
+    # @see https://google.aip.dev/123 AIP-123 Resource types
+    #
+    # @!attribute [r] path_pattern
+    #   @return [String] The path pattern
+    # @!attribute [r] segments
+    #   @return [Array<PositionalSegment|ResourceIdSegment|CollectionIdSegment>]
+    #     The parsed segments of the path pattern
+    class Pattern
+      attr_reader :path_pattern, :segments
+
+      def initialize path_pattern, segments
+        @path_pattern = path_pattern
+        @segments = segments
+      end
+
+      ##
+      # All argument names from this pattern
+      # @return [Array<String>]
+      def arguments
+        @segments.select(&:provides_arguments?).map(&:arguments).flatten
+      end
+
+      ##
+      # Whether pattern contains a positional segment
+      # @return [Boolean]
+      def positional_segments?
+        @segments.any?(&:positional?)
+      end
+
+      ##
+      # Whether pattern contains a segment with a nontrivial resource pattern
+      # @return [Boolean]
+      def nontrivial_pattern_segments?
+        @segments.any?(&:nontrivial_resource_pattern?)
+      end
+
+      ##
+      # A template of this pattern - all resource id segments are
+      # stripped and replaced by '*'
+      # @return [String]
+      def template
+        @segments.map(&:pattern_template).join("/")
+      end
+
+      ##
+      # A parent template to this pattern or an empty string if a pattern
+      # can not have a parent (too short)
+      # @return [String]
+      def parent_template
+        return nil if segments.length <= 2
+        last_segment = segments.last
+        parent_pattern_segments = last_segment.provides_arguments? ? segments[0...-2] : segments[0...-1]
+        parent_pattern_segments.map(&:pattern_template).join("/")
+      end
+    end
+  end
+end

data/lib/gapic/path_pattern/segment.rb

@@ -0,0 +1,276 @@
+# 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 PathPattern
+    ##
+    # A positional segment in a path pattern.
+    #  positional segments have a pattern of wildcards and do not carry a name
+    #
+    # @!attribure [r] type
+    #   @return [String] The type of this segment
+    # @!attribute [r] position
+    #   @return [Integer] The argument position of this segment i.e.
+    #     it's position if we remove all non-positional segments from the pattern
+    # @!attribute [r] pattern
+    #   @return [String] The pattern of the segment, for the positional segment it is also
+    #     a pattern of its resource
+    class PositionalSegment
+      attr_reader :type, :position, :pattern
+      def initialize position, pattern
+        @type       = :positional
+        @position   = position
+        @pattern    = pattern
+      end
+
+      ##
+      # Whether the segment is positional
+      # @return [Boolean]
+      def positional?
+        true
+      end
+
+      ##
+      # Whether the segment provides a resource pattern
+      # @return [Boolean]
+      def resource_pattern?
+        true
+      end
+
+      ##
+      # Whether the segment provides a nontrivial resource pattern
+      # @return [Boolean]
+      def nontrivial_resource_pattern?
+        false
+      end
+
+      ##
+      # Whether the segment provides arguments
+      # @return [Boolean]
+      def provides_arguments?
+        true
+      end
+
+      ##
+      # Names of the segment's arguments
+      # @return [Array<String>]
+      def arguments
+        [position.to_s]
+      end
+
+      ##
+      # Returns a segment's pattern filled with dummy values
+      #   names of the values are generated starting from the index provided
+      # @param start_index [Integer] a starting index for dummy value generation
+      # @return [String] a pattern filled with dummy values
+      def expected_path_for_dummy_values start_index
+        "value#{start_index}"
+      end
+
+      ##
+      # Path string for this segment
+      # @return [String]
+      def path_string
+        "\#{#{position}}"
+      end
+
+      ##
+      # A pattern template for this segment
+      # @return [String]
+      def pattern_template
+        pattern
+      end
+
+      # @private
+      def == other
+        return false unless other.is_a? self.class
+
+        (pattern == other.pattern && position == other.position)
+      end
+    end
+
+    # A ResourceId segment in a path pattern.
+    #  ResourceId segments can be simple, with one resource name
+    #  or complex, with multiple resource names divided by separators
+    #
+    # @!attribure [r] type
+    #   @return [String] The type of this segment
+    # @!attribute [r] pattern
+    #   @return [String] The pattern of the segment, for the positional segment it is also
+    #     a pattern of its resource
+    # @!attribute [r] resource_names
+    #   @return [Array<String>] The resource names in this segment
+    # @!attribute [r] resource_patterns
+    #   @return [Array<String>] The resource patterns associated with
+    #     the resource_names of this segment
+    class ResourceIdSegment
+      attr_reader :type, :pattern, :resource_names, :resource_patterns
+
+      def initialize type, pattern, resource_names, resource_patterns = []
+        @type              = type
+        @pattern           = pattern
+        @resource_names    = resource_names
+        @resource_patterns = resource_patterns
+      end
+
+      ##
+      # Whether the segment is positional
+      # @return [Boolean]
+      def positional?
+        false
+      end
+
+      ##
+      # Whether the segment provides a resource pattern
+      # @return [Boolean]
+      def resource_pattern?
+        resource_patterns.any?
+      end
+
+      ##
+      # Whether the segment provides a nontrivial resource pattern
+      # @return [Boolean]
+      def nontrivial_resource_pattern?
+        resource_patterns.any? { |res_pattern| !res_pattern.match?(/^\*+$/) }
+      end
+
+      ##
+      # Whether the segment provides arguments
+      # @return [Boolean]
+      def provides_arguments?
+        true
+      end
+
+      ##
+      # Names of the segment's arguments
+      # @return [Array<String>]
+      def arguments
+        resource_names
+      end
+
+      ##
+      # Returns a segment's pattern filled with dummy values
+      #   names of the values are generated starting from the index provided
+      # @param start_index [Integer] a starting index for dummy value generation
+      # @return [String] a pattern filled with dummy values
+      def expected_path_for_dummy_values start_index
+        return "value#{start_index}" if type == :simple_resource_id
+
+        resource_names.each_with_index.reduce pattern do |exp_path, (res_name, index)|
+          exp_path.sub "{#{res_name}}", "value#{start_index + index}"
+        end
+      end
+
+      ##
+      # Path string for this segment
+      # @return [String]
+      def path_string
+        type == :simple_resource_id ? "\#{#{resource_names[0]}}" : pattern.gsub("{", "\#{")
+      end
+
+      ##
+      # A pattern template for this segment
+      # @return [String]
+      def pattern_template
+        "*"
+      end
+
+      ##
+      # Initialization helper to create a simple resource without a pattern
+      # @param name [String] resource name
+      # @return [ResourceIdSegment]
+      def self.create_simple name
+        ResourceIdSegment.new :simple_resource_id, "{#{name}}", [name]
+      end
+
+      # @private
+      def == other
+        return false unless other.is_a? self.class
+
+        (type == other.type && pattern == other.pattern &&
+          resource_names == other.resource_names &&
+          resource_patterns == other.resource_patterns)
+      end
+    end
+
+    ##
+    # A CollectionId segment in a path template.
+    #  CollectionId segments are basically string literals
+    #
+    # @!attribure [r] type
+    #   @return [String] The type of this segment
+    # @!attribute [r] pattern
+    #   @return [String] The pattern of the segment, for the positional segment it is also
+    #     a pattern of its resource
+    class CollectionIdSegment
+      attr_reader :type, :pattern
+
+      def initialize pattern
+        @type     = :collection_id
+        @pattern  = pattern
+      end
+
+      ##
+      # Whether the segment is positional
+      # @return [Boolean]
+      def positional?
+        false
+      end
+
+      ##
+      # Whether the segment provides a resource pattern
+      # @return [Boolean]
+      def resource_pattern?
+        false
+      end
+
+      ##
+      # Whether the segment provides a nontrivial resource pattern
+      # @return [Boolean]
+      def nontrivial_resource_pattern?
+        false
+      end
+
+      ##
+      # Whether the segment provides arguments
+      # @return [Boolean]
+      def provides_arguments?
+        false
+      end
+
+      ##
+      # Path string for this segment
+      # @return [String]
+      def path_string
+        pattern
+      end
+
+      ##
+      # A pattern template for this segment
+      # @return [String]
+      def pattern_template
+        pattern
+      end
+
+      # @private
+      def == other
+        return false unless other.is_a? self.class
+
+        (pattern == other.pattern)
+      end
+    end
+  end
+end