gapic-generator 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19f79c05f4e657a010e8f9663f1eefeadabd18ef4b456c137a8278bf8bb13a9e
-  data.tar.gz: ebe4c8c756ebd1e18424eccffc986f92bcda6f694a50842ed394c7d62d91f252
+  metadata.gz: b063888cabf4893087dcefa274cb8ab5a9469a762fc3dbb34af2e143cb1bcce4
+  data.tar.gz: 589dc9fdf67d63dc25fe62537783e6305e4441f51b5caa2c94a5b1a161e71ab7
 SHA512:
-  metadata.gz: 4a6689a12fcd02390d416ab8ada828f79e182e87a3230361fe32e3a8eea42d7555039b61c699903d25a5fb244c9db1857bbad1d816ea04e4de329d67c4359c74
-  data.tar.gz: fac5801f38bb3fd92b871c2c5ab9b2d7ee7138d0947ffb0c9695bd21ea0561762fee5dc462de884b5182cbf4627c5c9148783474584b6cb4c9dc7727313f7f1c
+  metadata.gz: 07a03fd0adcc1640a37fa334883838aee76c124d2e5380a00d540751b3740e1b0f13d82a981ab35297c095df38620a0895bf4bb7bb5dbf1421c659e71cd92e85
+  data.tar.gz: 10269fc5c70542e1ae9ee1471eb6365c1669c741aa1ac03dbaf3b652cec2aee14801717589d1c45febc554b280cd8cd178ac19e02b1224b2692d1e98324142f6

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Release History for gapic-generator
 
+### 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/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

data/lib/gapic/generator/version.rb

@@ -16,6 +16,6 @@
 
 module Gapic
   module Generator
-    VERSION = "0.6.0"
+    VERSION = "0.6.1"
   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

data/lib/gapic/presenters/gem_presenter.rb

@@ -134,7 +134,17 @@ module Gapic
       end
 
       def api_id
-        gem_config :api_id
+        raw_id = gem_config :api_id
+        return nil unless raw_id
+        raw_id.include?(".") ? raw_id : "#{raw_id}.googleapis.com"
+      end
+
+      def api_shortname
+        gem_config :api_shortname
+      end
+
+      def issue_tracker_url
+        gem_config :issue_tracker_url
       end
 
       def free_tier?

data/lib/gapic/presenters/method_presenter.rb

@@ -15,7 +15,7 @@
 # limitations under the License.
 
 require "active_support/inflector"
-require "gapic/path_template"
+require "gapic/uri_template"
 require "gapic/ruby_info"
 require "gapic/helpers/namespace_helper"
 
@@ -194,8 +194,7 @@ module Gapic
       # @return [Array<String>] The segment key names.
       #
       def routing_params
-        segments = Gapic::PathTemplate.parse method_path
-        segments.select { |s| s.is_a? Gapic::PathTemplate::Segment }.map(&:name)
+        Gapic::UriTemplate.parse_arguments method_path
       end
 
       def routing_params?

data/lib/gapic/presenters/resource_presenter.rb

@@ -14,7 +14,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require "gapic/path_template"
+require "gapic/path_pattern"
 require "active_support/inflector"
 
 module Gapic
@@ -27,7 +27,7 @@ module Gapic
       def initialize resource
         @resource = resource
 
-        @patterns = resource.pattern.map { |template| PatternPresenter.new template }
+        @patterns = resource.pattern.map { |pattern| PatternPresenter.new pattern }
 
         # Keep only patterns that can be used to create path helpers
         @patterns.filter!(&:useful_for_helpers?)
@@ -53,59 +53,51 @@ module Gapic
       # A presenter for a particular pattern
       #
       class PatternPresenter
-        def initialize template
-          @template = template
-          @segments = Gapic::PathTemplate.parse template
-          @arguments = arg_segments.map(&:name)
+        def initialize pattern_string
+          @pattern = pattern_string
+          @parsed_pattern = Gapic::PathPattern.parse pattern_string
           @path_string = build_path_string
         end
 
-        attr_reader :template, :segments, :arguments, :path_string
+        attr_reader :pattern, :path_string
 
         def useful_for_helpers?
-          arg_segments.none?(&:nontrivial_pattern?) && arg_segments.none?(&:positional?)
+          !@parsed_pattern.positional_segments? && !@parsed_pattern.nontrivial_pattern_segments?
+        end
+
+        def arguments
+          @parsed_pattern.arguments
         end
 
         def formal_arguments
-          arguments.map { |arg| "#{arg}:" }.join ", "
+          @parsed_pattern.arguments.map { |name| "#{name}:" }.join ", "
         end
 
         def arguments_key
-          arguments.sort.join ":"
+          @parsed_pattern.arguments.sort.join ":"
         end
 
         def arguments_with_dummy_values
-          arguments.each_with_index.map { |arg, index| "#{arg}: \"value#{index}\"" }.join ", "
+          @parsed_pattern.arguments.each_with_index.map { |name, index| "#{name}: \"value#{index}\"" }.join ", "
         end
 
         def expected_path_for_dummy_values
-          index = -1
-          segments.map do |segment|
-            if segment.is_a? Gapic::PathTemplate::Segment
-              index += 1
-              "value#{index}"
+          index = 0
+          @parsed_pattern.segments.map do |segment|
+            if segment.provides_arguments?
+              segment_dummy_path = segment.expected_path_for_dummy_values index
+              index += segment.arguments.length
+              segment_dummy_path
             else
-              # Should be a String
-              segment
+              segment.pattern
             end
-          end.join
+          end.join "/"
         end
 
         private
 
-        def arg_segments
-          segments.select { |segment| segment.is_a? Gapic::PathTemplate::Segment }
-        end
-
         def build_path_string
-          segments.map do |segment|
-            if segment.is_a? Gapic::PathTemplate::Segment
-              "\#{#{segment.name}}"
-            else
-              # Should be a String
-              segment
-            end
-          end.join
+          @parsed_pattern.segments.map(&:path_string).join "/"
         end
       end
     end

data/lib/gapic/schema/wrappers.rb

@@ -15,6 +15,7 @@
 # limitations under the License.
 
 require "gapic/formatting_utils"
+require "gapic/path_pattern"
 
 module Gapic
   module Schema
@@ -761,30 +762,32 @@ module Gapic
     #   @return [Array<Gapic::Schema::ResourceDescriptor>] The resource
     #     descriptor.
     # @!attribute [r] parsed_patterns
-    #   @return [Array<Array<String>>] The normalized, segmented forms of the
-    #     patterns. Normalized means all ID segments are replaced by asterisks
+    #   @return [Array<String>] The template form of the
+    #     patterns. Template means all ID segments are replaced by asterisks
     #     to remove non-structural differences due to different names being
-    #     used. Segmented means simply split on slashes.
+    #     used.
     #     For example, if a pattern is `"projects/{project}""`, the
-    #     corresponding parsed pattern would be `["projects", "*"]`.
+    #     corresponding parsed pattern would be `"projects/*"]`.
+    # @!attribure [r] parsed_parent_patterns
+    #   return [Array<String>] Parsed patterns for the expected parents.
     # @!attribute [r] parent_resources
     #   @return [Array<Gapic::Schema::Resource>] Parent resources
     class Resource
       extend Forwardable
-      attr_reader :descriptor, :parsed_patterns, :parent_resources
+      attr_reader :descriptor, :parsed_patterns, :parsed_parent_patterns, :parent_resources
       attr_accessor :parent
 
       # Initializes a resource object.
-      # @param descriptor [Google::Protobuf::ResourceDescriptor] the protobuf
+      # @param descriptor [Google::Api::ResourceDescriptor] the protobuf
       #   representation of this resource.
       def initialize descriptor
         @parent = nil
         @descriptor = descriptor
-        @parsed_patterns = descriptor.pattern.map do |pattern|
-          pattern.split("/").map do |segment|
-            segment =~ %r{\{[^/\}]+(=[^\}]+)?\}} ? "*" : segment
-          end.freeze
+        patterns = descriptor.pattern.map do |pattern|
+          Gapic::PathPattern.parse pattern
         end.freeze
+        @parsed_patterns = patterns.map(&:template).compact.uniq.freeze
+        @parsed_parent_patterns = patterns.map(&:parent_template).compact.uniq.freeze
         @parent_resources = []
       end
 
@@ -800,15 +803,6 @@ module Gapic
         parent&.containing_file
       end
 
-      # Returns parsed patterns for the expected parents.
-      # @return [Array<Array<String>>]
-      def parsed_parent_patterns
-        @parsed_patterns.map do |pat|
-          parent = pat.last =~ /^\*\*?$/ ? pat[0...-2] : pat[0...-1]
-          parent.empty? ? nil : parent
-        end.compact.uniq
-      end
-
       # @!method type
       #   @return [String] the resource type string.
       # @!method pattern

data/lib/gapic/uri_template.rb

@@ -0,0 +1,36 @@
+# 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/uri_template/parser"
+
+module Gapic
+  # TODO: Enter docs
+  # Dooooooooocs!!!
+  module UriTemplate
+    # Parse arguments from a URI template.
+    # @see https://tools.ietf.org/html/rfc6570 URI Template
+    #
+    # used to satisfy AIP-4222 Routing headers
+    # @see https://google.aip.dev/client-libraries/4222
+    #
+    # @param uri_template [String] The URI template to be parsed.
+    #
+    # @return [Array<String>] The arguments of the URI template.
+    def self.parse_arguments uri_template
+      Parser.parse_arguments uri_template
+    end
+  end
+end

data/lib/gapic/uri_template/parser.rb

@@ -0,0 +1,50 @@
+# 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 UriTemplate
+    # A URI template parser.
+    # see https://tools.ietf.org/html/rfc6570 URI Template
+    #
+    # @!attribute [r] path_pattern
+    #   @return [String] The path pattern to be parsed.
+    # @!attribute [r] segments
+    #   @return [Array<Segment|String>] The segments of the parsed path pattern.
+    module Parser
+      # @private
+      # /((?<positional>\*\*?)|{(?<name>[^\/]+?)(?:=(?<template>.+?))?})/
+      URI_TEMPLATE = %r{
+        (
+          (?<positional>\*\*?)
+          |
+          {(?<name>[^\/]+?)(?:=(?<template>.+?))?}
+        )
+      }x.freeze
+
+      def self.parse_arguments uri_template
+        arguments = []
+
+        while (match = URI_TEMPLATE.match uri_template)
+          # The String before the match needs to be added to the segments
+          arguments << match[:name] if match[:name]
+          uri_template = match.post_match
+        end
+
+        arguments
+      end
+    end
+  end
+end

data/templates/default/service/client/resource/_doc.erb

@@ -1,7 +1,7 @@
 <%- assert_locals pattern -%>
 The resource will be in the following format:
 
-`<%= pattern.template %>`
+`<%= pattern.pattern %>`
 
 <%- pattern.arguments.each do |arg| -%>
 @param <%= arg %> [String]

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

@@ -1,7 +1,5 @@
 <%- assert_locals service -%>
-# frozen_string_literal: true
-
-<%= render partial: "shared/license" %>
+<%= render partial: "shared/header" %>
 require "helper"
 
 require "gapic/grpc/service_stub"

data/templates/default/service/test/client_operations.erb

@@ -1,7 +1,5 @@
 <%- assert_locals service -%>
-# frozen_string_literal: true
-
-<%= render partial: "shared/license" %>
+<%= render partial: "shared/header" %>
 require "helper"
 
 require "gapic/grpc/service_stub"

data/templates/default/service/test/client_paths.erb

@@ -1,7 +1,5 @@
 <%- assert_locals service -%>
-# frozen_string_literal: true
-
-<%= render partial: "shared/license" %>
+<%= render partial: "shared/header" %>
 require "helper"
 
 require "gapic/grpc/service_stub"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gapic-generator
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Ernest Landrito
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-02 00:00:00.000000000 Z
+date: 2020-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -217,9 +217,10 @@ files:
 - lib/gapic/grpc_service_config/service_config.rb
 - lib/gapic/helpers/filepath_helper.rb
 - lib/gapic/helpers/namespace_helper.rb
-- lib/gapic/path_template.rb
-- lib/gapic/path_template/parser.rb
-- lib/gapic/path_template/segment.rb
+- lib/gapic/path_pattern.rb
+- lib/gapic/path_pattern/parser.rb
+- lib/gapic/path_pattern/pattern.rb
+- lib/gapic/path_pattern/segment.rb
 - lib/gapic/presenters.rb
 - lib/gapic/presenters/enum_presenter.rb
 - lib/gapic/presenters/enum_value_presenter.rb
@@ -239,6 +240,8 @@ files:
 - lib/gapic/schema/api.rb
 - lib/gapic/schema/loader.rb
 - lib/gapic/schema/wrappers.rb
+- lib/gapic/uri_template.rb
+- lib/gapic/uri_template/parser.rb
 - lib/google/api/annotations.pb.rb
 - lib/google/api/client.pb.rb
 - lib/google/api/field_behavior.pb.rb

data/lib/gapic/path_template/parser.rb

@@ -1,83 +0,0 @@
-# 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

@@ -1,74 +0,0 @@
-# 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
-
-      # Determines if the segment has a nontrivial pattern (i.e. not `*` or `**`).
-      #
-      # @return [Boolean]
-      def nontrivial_pattern?
-        @pattern && @pattern != "*" && @pattern != "**"
-      end
-
-      # @private
-      def == other
-        return false unless other.is_a? self.class
-
-        (name == other.name) && (pattern == other.pattern)
-      end
-    end
-  end
-end