gapic-generator 0.4.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6eb09d3958e2bf3212a940df300ab29228dabdb7dabc31b1d9755eddee129c5b
-  data.tar.gz: e9431a7bc6f8680553e0bd682d68cdf6ec5fc61a6c564fec5c074f4884d362c9
+  metadata.gz: b063888cabf4893087dcefa274cb8ab5a9469a762fc3dbb34af2e143cb1bcce4
+  data.tar.gz: 589dc9fdf67d63dc25fe62537783e6305e4441f51b5caa2c94a5b1a161e71ab7
 SHA512:
-  metadata.gz: 554bdbb8d1b6ca6dbfb646656cb91dc5f1080d60e8e7103771ca8e3352f09e33a0b9ef3edd86547c173cfc98e18d45da1be8b9648aef40525b1bfb13c5579d62
-  data.tar.gz: c998693373a980357d17d540fdbaa891959666bfb2b2dd12b2843eb9b8df0bca1808259305c25614a3951f695b004fa28b862888e1e9e4fa706ce6cfcd2b4f5f
+  metadata.gz: 07a03fd0adcc1640a37fa334883838aee76c124d2e5380a00d540751b3740e1b0f13d82a981ab35297c095df38620a0895bf4bb7bb5dbf1421c659e71cd92e85
+  data.tar.gz: 10269fc5c70542e1ae9ee1471eb6365c1669c741aa1ac03dbaf3b652cec2aee14801717589d1c45febc554b280cd8cd178ac19e02b1224b2692d1e98324142f6

data/CHANGELOG.md

@@ -1,5 +1,36 @@
 # 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.
+* Support for adding extra dependencies.
+* Fixed a Ruby warning when looking up RPC-scoped configs with no parent.
+* Internal: Presenters reference their parent rather than creating new objects.
+
+### 0.5.1 / 2020-05-21
+
+* Support a configuration for overriding service module names.
+* Operations client honors the quota_project setting.
+
+### 0.5.0 / 2020-05-19
+
+* Add quota_project to the generated configs.
+* Allow resource patterns with a star as a segment template.
+* Generate tests for resource path helpers.
+* Pin protobuf dependency for Ruby < 2.5.
+* Create a test helper in for generated tests.
+
+### 0.4.2 / 2020-04-28
+
+* Prepend double-colon to absolute/global namespaces to prevent conflicts.
+* Fix documentation/examples of timeouts to clarify they are in seconds.
+
 ### 0.4.0 / 2020-04-20
 
 * Support generating clients of "common" interfaces by delegating to another service config.

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/formatting_utils.rb

@@ -137,15 +137,15 @@ module Gapic
 
         case entity
         when Gapic::Schema::Service
-          "{#{convert_address_to_ruby entity}::Client #{text}}"
+          "{::#{convert_address_to_ruby entity}::Client #{text}}"
         when Gapic::Schema::Method
-          "{#{convert_address_to_ruby entity.parent}::Client##{entity.name.underscore} #{text}}"
+          "{::#{convert_address_to_ruby entity.parent}::Client##{entity.name.underscore} #{text}}"
         when Gapic::Schema::Message, Gapic::Schema::Enum
-          "{#{convert_address_to_ruby entity} #{text}}"
+          "{::#{convert_address_to_ruby entity} #{text}}"
         when Gapic::Schema::EnumValue
-          "{#{convert_address_to_ruby entity.parent}::#{entity.name} #{text}}"
+          "{::#{convert_address_to_ruby entity.parent}::#{entity.name} #{text}}"
         when Gapic::Schema::Field
-          "{#{convert_address_to_ruby entity.parent}##{entity.name} #{text}}"
+          "{::#{convert_address_to_ruby entity.parent}##{entity.name} #{text}}"
         end
       end
 
@@ -155,7 +155,7 @@ module Gapic
         address = entity.address
         address = address.join "." if address.is_a? Array
         address = address.sub file.package, file.ruby_package if file.ruby_package&.present?
-        address.split(".").reject(&:empty?).map(&:camelize).map { |node| api.fix_namespace node }.join("::")
+        address.split(/\.|::/).reject(&:empty?).map(&:camelize).map { |node| api.fix_namespace node }.join("::")
       end
     end
   end

data/lib/gapic/generator/version.rb

@@ -16,6 +16,6 @@
 
 module Gapic
   module Generator
-    VERSION = "0.4.0"
+    VERSION = "0.6.1"
   end
 end

data/lib/gapic/generators/default_generator.rb

@@ -41,10 +41,10 @@ module Gapic
       # @return [Array<
       #   Google::Protobuf::Compiler::CodeGeneratorResponse::File>]
       #   The files that were generated for the API.
-      def generate
+      def generate gem_presenter: nil
         files = []
 
-        gem = Gapic::Presenters.gem_presenter @api
+        gem = gem_presenter || Gapic::Presenters.gem_presenter(@api)
 
         gem.packages.each do |package|
           # Package level files
@@ -54,26 +54,28 @@ module Gapic
             # 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/credentials.erb",            "lib/#{service.credentials_file_path}",             service: service) unless gem.generic_endpoint?
             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_paths.erb",      "test/#{service.test_paths_file_path}",             service: service) if service.paths?
             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)
-        files << g("gem/entrypoint.erb", "lib/#{gem.name}.rb",           gem: gem)
+        files << g("gem/gitignore.erb",   ".gitignore",                   gem: gem)
+        files << g("gem/version.erb",     "lib/#{gem.version_file_path}", gem: gem)
+        files << g("gem/test_helper.erb", "test/helper.rb",               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)
+        files << g("gem/entrypoint.erb",  "lib/#{gem.name}.rb",           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)

data/lib/gapic/helpers/filepath_helper.rb

@@ -25,6 +25,7 @@ module Gapic
       ##
       # Converts a ruby namespace string to a file path string.
       def ruby_file_path api, namespace
+        namespace = namespace.sub(/^::/, "")
         file_path = ruby_file_path_for_namespace namespace
         fix_file_path api, file_path
       end

data/lib/gapic/helpers/namespace_helper.rb

@@ -38,7 +38,14 @@ module Gapic
       # Ruby double-semicolon separators.
       def ruby_namespace_for_address address
         address = address.split "." if address.is_a? String
-        address.reject(&:empty?).map(&:camelize).join "::"
+        ensure_absolute_namespace address.reject(&:empty?).map(&:camelize).join("::")
+      end
+
+      ##
+      # Returns the given namespace, ensuring double colons are prepended
+      #
+      def ensure_absolute_namespace namespace
+        namespace.start_with?("::") ? namespace : "::#{namespace}"
       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