Class: Gapic::Model::Method::Routing::RoutingParameter

Inherits:

Object

• Object
• Gapic::Model::Method::Routing::RoutingParameter

Defined in:

lib/gapic/model/method/routing.rb

Overview

Full routing parameter information, including parsing order and matching/extraction patterns and regexes.

Instance Attribute Summary

• #field ⇒ String readonly

  Field to extract the routing header from.

• #field_full_regex_str ⇒ String readonly

  The regex matching the full unsimplified field pattern (it will contain the named capture corresponding to the resource id segment name).

• #field_pattern ⇒ String readonly

  The pattern of the full field (simplified) The field as a whole should match this pattern This pattern is simplified, stipped of the names of the resource id segments.

• #field_regex_str ⇒ String readonly

  The regex matching the field_pattern (the regex form of the simplified pattern).

• #key ⇒ String readonly

  Name of the key to add to the routing header.

• #order ⇒ Integer readonly

  Order of the parameter in the annotation.

• #path_template ⇒ String readonly

  'Processed' template, handling such cases as empty or nameless template.

• #raw_template ⇒ String^? readonly

  Raw template as given in the annotation.

• #value_pattern ⇒ String readonly

  The pattern of the value to be extracted.

Instance Method Summary

• #initialize(routing_parameter, order) ⇒ RoutingParameter constructor

  A new instance of RoutingParameter.

• #pattern_matching_not_needed? ⇒ Boolean

  Whether pattern matching is not needed since the patterns allow all strings.

• #value_is_full_field? ⇒ Boolean

  Whether the value to be added to the routing header is the value of the whole field.

Constructor Details

#initialize(routing_parameter, order) ⇒ RoutingParameter

# File 'lib/gapic/model/method/routing.rb', line 158

def initialize routing_parameter, order
  @order = order
  @field = routing_parameter.field
  @raw_template = routing_parameter.path_template
  @path_template = infer_template @raw_template, @field
  @path_pattern = Gapic::PathPattern.parse @path_template

  resource_segment = @path_pattern.segments.find(&:resource_id_segment?)

  # Only one segment providing an argument and only one argument in the segment
  # (no `{foo}~{bar}` segments)
  valid = @path_pattern.segments.count(&:resource_id_segment?) == 1 &&
          resource_segment.arguments.count == 1

  unless valid
    error_text = create_invalid_error_text @path_pattern, @raw_template
    raise ModelError, error_text
  end

  @field_pattern = @path_pattern.simplified_pattern
  @field_full_regex_str = @path_pattern.to_field_regex_str
  @field_regex_str = Gapic::PathPattern.parse(@field_pattern).to_field_regex_str

  @key = resource_segment.arguments[0]
  @value_pattern = resource_segment.resource_patterns[0]
end

Instance Attribute Details

#field ⇒ String (readonly)

# File 'lib/gapic/model/method/routing.rb', line 141

class RoutingParameter
  attr_reader :order
  attr_reader :field
  attr_reader :raw_template
  attr_reader :path_template
  attr_reader :key
  attr_reader :value_pattern
  attr_reader :field_pattern
  attr_reader :field_regex_str
  attr_reader :field_full_regex_str

  ##
  # @param routing_parameter [::Google::Api::RoutingParameter]
  #   Routing parameter annotation
  #
  # @param order [Integer]
  #   Order of this annotation among its peers
  def initialize routing_parameter, order
    @order = order
    @field = routing_parameter.field
    @raw_template = routing_parameter.path_template
    @path_template = infer_template @raw_template, @field
    @path_pattern = Gapic::PathPattern.parse @path_template

    resource_segment = @path_pattern.segments.find(&:resource_id_segment?)

    # Only one segment providing an argument and only one argument in the segment
    # (no `{foo}~{bar}` segments)
    valid = @path_pattern.segments.count(&:resource_id_segment?) == 1 &&
            resource_segment.arguments.count == 1

    unless valid
      error_text = create_invalid_error_text @path_pattern, @raw_template
      raise ModelError, error_text
    end

    @field_pattern = @path_pattern.simplified_pattern
    @field_full_regex_str = @path_pattern.to_field_regex_str
    @field_regex_str = Gapic::PathPattern.parse(@field_pattern).to_field_regex_str

    @key = resource_segment.arguments[0]
    @value_pattern = resource_segment.resource_patterns[0]
  end

  ##
  # Whether pattern matching is not needed
  # since the patterns allow all strings
  # @return [Boolean]
  def pattern_matching_not_needed?
    field_pattern == "**" && value_pattern == "**"
  end

  ##
  # Whether the value to be added to the routing header
  # is the value of the whole field
  # @return [Boolean]
  def value_is_full_field?
    @path_pattern.segments.count == 1
  end

  private

  # Converts path template simplified forms into canonical
  # ResourceId representations by adding a field as a Resource Id
  # @param template [String]
  # @param field [String]
  # @return [String]
  def infer_template template, field
    if template.nil? || template.empty?
      return "{#{field}=**}"
    end

    if template.strip == "**"
      return "{#{field}=**}"
    end

    if template.strip == "*"
      return "{#{field}=*}"
    end

    template
  end

  def create_invalid_error_text path_pattern, raw_template
    reason = if path_pattern.segments.count(&:resource_id_segment?).zero?
               "it contains no ResourceId (e.g. `{foo=*}`) segments"
             elsif path_pattern.segments.count(&:resource_id_segment?) > 1
               "it contains more than one ResourceId (e.g. `{foo=*}`) segments "
             else
               "it contains a multivariate ResourceId segment (e.g. `{foo}~{bar}`)"
             end

    "A routing header parameter with the path_template #{raw_template}\n is invalid: #{reason}"
  end
end

#field_full_regex_str ⇒ String (readonly)

# File 'lib/gapic/model/method/routing.rb', line 141

class RoutingParameter
  attr_reader :order
  attr_reader :field
  attr_reader :raw_template
  attr_reader :path_template
  attr_reader :key
  attr_reader :value_pattern
  attr_reader :field_pattern
  attr_reader :field_regex_str
  attr_reader :field_full_regex_str

  ##
  # @param routing_parameter [::Google::Api::RoutingParameter]
  #   Routing parameter annotation
  #
  # @param order [Integer]
  #   Order of this annotation among its peers
  def initialize routing_parameter, order
    @order = order
    @field = routing_parameter.field
    @raw_template = routing_parameter.path_template
    @path_template = infer_template @raw_template, @field
    @path_pattern = Gapic::PathPattern.parse @path_template

    resource_segment = @path_pattern.segments.find(&:resource_id_segment?)

    # Only one segment providing an argument and only one argument in the segment
    # (no `{foo}~{bar}` segments)
    valid = @path_pattern.segments.count(&:resource_id_segment?) == 1 &&
            resource_segment.arguments.count == 1

    unless valid
      error_text = create_invalid_error_text @path_pattern, @raw_template
      raise ModelError, error_text
    end

    @field_pattern = @path_pattern.simplified_pattern
    @field_full_regex_str = @path_pattern.to_field_regex_str
    @field_regex_str = Gapic::PathPattern.parse(@field_pattern).to_field_regex_str

    @key = resource_segment.arguments[0]
    @value_pattern = resource_segment.resource_patterns[0]
  end

  ##
  # Whether pattern matching is not needed
  # since the patterns allow all strings
  # @return [Boolean]
  def pattern_matching_not_needed?
    field_pattern == "**" && value_pattern == "**"
  end

  ##
  # Whether the value to be added to the routing header
  # is the value of the whole field
  # @return [Boolean]
  def value_is_full_field?
    @path_pattern.segments.count == 1
  end

  private

  # Converts path template simplified forms into canonical
  # ResourceId representations by adding a field as a Resource Id
  # @param template [String]
  # @param field [String]
  # @return [String]
  def infer_template template, field
    if template.nil? || template.empty?
      return "{#{field}=**}"
    end

    if template.strip == "**"
      return "{#{field}=**}"
    end

    if template.strip == "*"
      return "{#{field}=*}"
    end

    template
  end

  def create_invalid_error_text path_pattern, raw_template
    reason = if path_pattern.segments.count(&:resource_id_segment?).zero?
               "it contains no ResourceId (e.g. `{foo=*}`) segments"
             elsif path_pattern.segments.count(&:resource_id_segment?) > 1
               "it contains more than one ResourceId (e.g. `{foo=*}`) segments "
             else
               "it contains a multivariate ResourceId segment (e.g. `{foo}~{bar}`)"
             end

    "A routing header parameter with the path_template #{raw_template}\n is invalid: #{reason}"
  end
end

#field_pattern ⇒ String (readonly)

# File 'lib/gapic/model/method/routing.rb', line 141

class RoutingParameter
  attr_reader :order
  attr_reader :field
  attr_reader :raw_template
  attr_reader :path_template
  attr_reader :key
  attr_reader :value_pattern
  attr_reader :field_pattern
  attr_reader :field_regex_str
  attr_reader :field_full_regex_str

  ##
  # @param routing_parameter [::Google::Api::RoutingParameter]
  #   Routing parameter annotation
  #
  # @param order [Integer]
  #   Order of this annotation among its peers
  def initialize routing_parameter, order
    @order = order
    @field = routing_parameter.field
    @raw_template = routing_parameter.path_template
    @path_template = infer_template @raw_template, @field
    @path_pattern = Gapic::PathPattern.parse @path_template

    resource_segment = @path_pattern.segments.find(&:resource_id_segment?)

    # Only one segment providing an argument and only one argument in the segment
    # (no `{foo}~{bar}` segments)
    valid = @path_pattern.segments.count(&:resource_id_segment?) == 1 &&
            resource_segment.arguments.count == 1

    unless valid
      error_text = create_invalid_error_text @path_pattern, @raw_template
      raise ModelError, error_text
    end

    @field_pattern = @path_pattern.simplified_pattern
    @field_full_regex_str = @path_pattern.to_field_regex_str
    @field_regex_str = Gapic::PathPattern.parse(@field_pattern).to_field_regex_str

    @key = resource_segment.arguments[0]
    @value_pattern = resource_segment.resource_patterns[0]
  end

  ##
  # Whether pattern matching is not needed
  # since the patterns allow all strings
  # @return [Boolean]
  def pattern_matching_not_needed?
    field_pattern == "**" && value_pattern == "**"
  end

  ##
  # Whether the value to be added to the routing header
  # is the value of the whole field
  # @return [Boolean]
  def value_is_full_field?
    @path_pattern.segments.count == 1
  end

  private

  # Converts path template simplified forms into canonical
  # ResourceId representations by adding a field as a Resource Id
  # @param template [String]
  # @param field [String]
  # @return [String]
  def infer_template template, field
    if template.nil? || template.empty?
      return "{#{field}=**}"
    end

    if template.strip == "**"
      return "{#{field}=**}"
    end

    if template.strip == "*"
      return "{#{field}=*}"
    end

    template
  end

  def create_invalid_error_text path_pattern, raw_template
    reason = if path_pattern.segments.count(&:resource_id_segment?).zero?
               "it contains no ResourceId (e.g. `{foo=*}`) segments"
             elsif path_pattern.segments.count(&:resource_id_segment?) > 1
               "it contains more than one ResourceId (e.g. `{foo=*}`) segments "
             else
               "it contains a multivariate ResourceId segment (e.g. `{foo}~{bar}`)"
             end

    "A routing header parameter with the path_template #{raw_template}\n is invalid: #{reason}"
  end
end

#field_regex_str ⇒ String (readonly)

# File 'lib/gapic/model/method/routing.rb', line 141

class RoutingParameter
  attr_reader :order
  attr_reader :field
  attr_reader :raw_template
  attr_reader :path_template
  attr_reader :key
  attr_reader :value_pattern
  attr_reader :field_pattern
  attr_reader :field_regex_str
  attr_reader :field_full_regex_str

  ##
  # @param routing_parameter [::Google::Api::RoutingParameter]
  #   Routing parameter annotation
  #
  # @param order [Integer]
  #   Order of this annotation among its peers
  def initialize routing_parameter, order
    @order = order
    @field = routing_parameter.field
    @raw_template = routing_parameter.path_template
    @path_template = infer_template @raw_template, @field
    @path_pattern = Gapic::PathPattern.parse @path_template

    resource_segment = @path_pattern.segments.find(&:resource_id_segment?)

    # Only one segment providing an argument and only one argument in the segment
    # (no `{foo}~{bar}` segments)
    valid = @path_pattern.segments.count(&:resource_id_segment?) == 1 &&
            resource_segment.arguments.count == 1

    unless valid
      error_text = create_invalid_error_text @path_pattern, @raw_template
      raise ModelError, error_text
    end

    @field_pattern = @path_pattern.simplified_pattern
    @field_full_regex_str = @path_pattern.to_field_regex_str
    @field_regex_str = Gapic::PathPattern.parse(@field_pattern).to_field_regex_str

    @key = resource_segment.arguments[0]
    @value_pattern = resource_segment.resource_patterns[0]
  end

  ##
  # Whether pattern matching is not needed
  # since the patterns allow all strings
  # @return [Boolean]
  def pattern_matching_not_needed?
    field_pattern == "**" && value_pattern == "**"
  end

  ##
  # Whether the value to be added to the routing header
  # is the value of the whole field
  # @return [Boolean]
  def value_is_full_field?
    @path_pattern.segments.count == 1
  end

  private

  # Converts path template simplified forms into canonical
  # ResourceId representations by adding a field as a Resource Id
  # @param template [String]
  # @param field [String]
  # @return [String]
  def infer_template template, field
    if template.nil? || template.empty?
      return "{#{field}=**}"
    end

    if template.strip == "**"
      return "{#{field}=**}"
    end

    if template.strip == "*"
      return "{#{field}=*}"
    end

    template
  end

  def create_invalid_error_text path_pattern, raw_template
    reason = if path_pattern.segments.count(&:resource_id_segment?).zero?
               "it contains no ResourceId (e.g. `{foo=*}`) segments"
             elsif path_pattern.segments.count(&:resource_id_segment?) > 1
               "it contains more than one ResourceId (e.g. `{foo=*}`) segments "
             else
               "it contains a multivariate ResourceId segment (e.g. `{foo}~{bar}`)"
             end

    "A routing header parameter with the path_template #{raw_template}\n is invalid: #{reason}"
  end
end

#key ⇒ String (readonly)

# File 'lib/gapic/model/method/routing.rb', line 141

class RoutingParameter
  attr_reader :order
  attr_reader :field
  attr_reader :raw_template
  attr_reader :path_template
  attr_reader :key
  attr_reader :value_pattern
  attr_reader :field_pattern
  attr_reader :field_regex_str
  attr_reader :field_full_regex_str

  ##
  # @param routing_parameter [::Google::Api::RoutingParameter]
  #   Routing parameter annotation
  #
  # @param order [Integer]
  #   Order of this annotation among its peers
  def initialize routing_parameter, order
    @order = order
    @field = routing_parameter.field
    @raw_template = routing_parameter.path_template
    @path_template = infer_template @raw_template, @field
    @path_pattern = Gapic::PathPattern.parse @path_template

    resource_segment = @path_pattern.segments.find(&:resource_id_segment?)

    # Only one segment providing an argument and only one argument in the segment
    # (no `{foo}~{bar}` segments)
    valid = @path_pattern.segments.count(&:resource_id_segment?) == 1 &&
            resource_segment.arguments.count == 1

    unless valid
      error_text = create_invalid_error_text @path_pattern, @raw_template
      raise ModelError, error_text
    end

    @field_pattern = @path_pattern.simplified_pattern
    @field_full_regex_str = @path_pattern.to_field_regex_str
    @field_regex_str = Gapic::PathPattern.parse(@field_pattern).to_field_regex_str

    @key = resource_segment.arguments[0]
    @value_pattern = resource_segment.resource_patterns[0]
  end

  ##
  # Whether pattern matching is not needed
  # since the patterns allow all strings
  # @return [Boolean]
  def pattern_matching_not_needed?
    field_pattern == "**" && value_pattern == "**"
  end

  ##
  # Whether the value to be added to the routing header
  # is the value of the whole field
  # @return [Boolean]
  def value_is_full_field?
    @path_pattern.segments.count == 1
  end

  private

  # Converts path template simplified forms into canonical
  # ResourceId representations by adding a field as a Resource Id
  # @param template [String]
  # @param field [String]
  # @return [String]
  def infer_template template, field
    if template.nil? || template.empty?
      return "{#{field}=**}"
    end

    if template.strip == "**"
      return "{#{field}=**}"
    end

    if template.strip == "*"
      return "{#{field}=*}"
    end

    template
  end

  def create_invalid_error_text path_pattern, raw_template
    reason = if path_pattern.segments.count(&:resource_id_segment?).zero?
               "it contains no ResourceId (e.g. `{foo=*}`) segments"
             elsif path_pattern.segments.count(&:resource_id_segment?) > 1
               "it contains more than one ResourceId (e.g. `{foo=*}`) segments "
             else
               "it contains a multivariate ResourceId segment (e.g. `{foo}~{bar}`)"
             end

    "A routing header parameter with the path_template #{raw_template}\n is invalid: #{reason}"
  end
end

#order ⇒ Integer (readonly)

# File 'lib/gapic/model/method/routing.rb', line 141

class RoutingParameter
  attr_reader :order
  attr_reader :field
  attr_reader :raw_template
  attr_reader :path_template
  attr_reader :key
  attr_reader :value_pattern
  attr_reader :field_pattern
  attr_reader :field_regex_str
  attr_reader :field_full_regex_str

  ##
  # @param routing_parameter [::Google::Api::RoutingParameter]
  #   Routing parameter annotation
  #
  # @param order [Integer]
  #   Order of this annotation among its peers
  def initialize routing_parameter, order
    @order = order
    @field = routing_parameter.field
    @raw_template = routing_parameter.path_template
    @path_template = infer_template @raw_template, @field
    @path_pattern = Gapic::PathPattern.parse @path_template

    resource_segment = @path_pattern.segments.find(&:resource_id_segment?)

    # Only one segment providing an argument and only one argument in the segment
    # (no `{foo}~{bar}` segments)
    valid = @path_pattern.segments.count(&:resource_id_segment?) == 1 &&
            resource_segment.arguments.count == 1

    unless valid
      error_text = create_invalid_error_text @path_pattern, @raw_template
      raise ModelError, error_text
    end

    @field_pattern = @path_pattern.simplified_pattern
    @field_full_regex_str = @path_pattern.to_field_regex_str
    @field_regex_str = Gapic::PathPattern.parse(@field_pattern).to_field_regex_str

    @key = resource_segment.arguments[0]
    @value_pattern = resource_segment.resource_patterns[0]
  end

  ##
  # Whether pattern matching is not needed
  # since the patterns allow all strings
  # @return [Boolean]
  def pattern_matching_not_needed?
    field_pattern == "**" && value_pattern == "**"
  end

  ##
  # Whether the value to be added to the routing header
  # is the value of the whole field
  # @return [Boolean]
  def value_is_full_field?
    @path_pattern.segments.count == 1
  end

  private

  # Converts path template simplified forms into canonical
  # ResourceId representations by adding a field as a Resource Id
  # @param template [String]
  # @param field [String]
  # @return [String]
  def infer_template template, field
    if template.nil? || template.empty?
      return "{#{field}=**}"
    end

    if template.strip == "**"
      return "{#{field}=**}"
    end

    if template.strip == "*"
      return "{#{field}=*}"
    end

    template
  end

  def create_invalid_error_text path_pattern, raw_template
    reason = if path_pattern.segments.count(&:resource_id_segment?).zero?
               "it contains no ResourceId (e.g. `{foo=*}`) segments"
             elsif path_pattern.segments.count(&:resource_id_segment?) > 1
               "it contains more than one ResourceId (e.g. `{foo=*}`) segments "
             else
               "it contains a multivariate ResourceId segment (e.g. `{foo}~{bar}`)"
             end

    "A routing header parameter with the path_template #{raw_template}\n is invalid: #{reason}"
  end
end

#path_template ⇒ String (readonly)

# File 'lib/gapic/model/method/routing.rb', line 141

class RoutingParameter
  attr_reader :order
  attr_reader :field
  attr_reader :raw_template
  attr_reader :path_template
  attr_reader :key
  attr_reader :value_pattern
  attr_reader :field_pattern
  attr_reader :field_regex_str
  attr_reader :field_full_regex_str

  ##
  # @param routing_parameter [::Google::Api::RoutingParameter]
  #   Routing parameter annotation
  #
  # @param order [Integer]
  #   Order of this annotation among its peers
  def initialize routing_parameter, order
    @order = order
    @field = routing_parameter.field
    @raw_template = routing_parameter.path_template
    @path_template = infer_template @raw_template, @field
    @path_pattern = Gapic::PathPattern.parse @path_template

    resource_segment = @path_pattern.segments.find(&:resource_id_segment?)

    # Only one segment providing an argument and only one argument in the segment
    # (no `{foo}~{bar}` segments)
    valid = @path_pattern.segments.count(&:resource_id_segment?) == 1 &&
            resource_segment.arguments.count == 1

    unless valid
      error_text = create_invalid_error_text @path_pattern, @raw_template
      raise ModelError, error_text
    end

    @field_pattern = @path_pattern.simplified_pattern
    @field_full_regex_str = @path_pattern.to_field_regex_str
    @field_regex_str = Gapic::PathPattern.parse(@field_pattern).to_field_regex_str

    @key = resource_segment.arguments[0]
    @value_pattern = resource_segment.resource_patterns[0]
  end

  ##
  # Whether pattern matching is not needed
  # since the patterns allow all strings
  # @return [Boolean]
  def pattern_matching_not_needed?
    field_pattern == "**" && value_pattern == "**"
  end

  ##
  # Whether the value to be added to the routing header
  # is the value of the whole field
  # @return [Boolean]
  def value_is_full_field?
    @path_pattern.segments.count == 1
  end

  private

  # Converts path template simplified forms into canonical
  # ResourceId representations by adding a field as a Resource Id
  # @param template [String]
  # @param field [String]
  # @return [String]
  def infer_template template, field
    if template.nil? || template.empty?
      return "{#{field}=**}"
    end

    if template.strip == "**"
      return "{#{field}=**}"
    end

    if template.strip == "*"
      return "{#{field}=*}"
    end

    template
  end

  def create_invalid_error_text path_pattern, raw_template
    reason = if path_pattern.segments.count(&:resource_id_segment?).zero?
               "it contains no ResourceId (e.g. `{foo=*}`) segments"
             elsif path_pattern.segments.count(&:resource_id_segment?) > 1
               "it contains more than one ResourceId (e.g. `{foo=*}`) segments "
             else
               "it contains a multivariate ResourceId segment (e.g. `{foo}~{bar}`)"
             end

    "A routing header parameter with the path_template #{raw_template}\n is invalid: #{reason}"
  end
end

#raw_template ⇒ String^? (readonly)

# File 'lib/gapic/model/method/routing.rb', line 141

class RoutingParameter
  attr_reader :order
  attr_reader :field
  attr_reader :raw_template
  attr_reader :path_template
  attr_reader :key
  attr_reader :value_pattern
  attr_reader :field_pattern
  attr_reader :field_regex_str
  attr_reader :field_full_regex_str

  ##
  # @param routing_parameter [::Google::Api::RoutingParameter]
  #   Routing parameter annotation
  #
  # @param order [Integer]
  #   Order of this annotation among its peers
  def initialize routing_parameter, order
    @order = order
    @field = routing_parameter.field
    @raw_template = routing_parameter.path_template
    @path_template = infer_template @raw_template, @field
    @path_pattern = Gapic::PathPattern.parse @path_template

    resource_segment = @path_pattern.segments.find(&:resource_id_segment?)

    # Only one segment providing an argument and only one argument in the segment
    # (no `{foo}~{bar}` segments)
    valid = @path_pattern.segments.count(&:resource_id_segment?) == 1 &&
            resource_segment.arguments.count == 1

    unless valid
      error_text = create_invalid_error_text @path_pattern, @raw_template
      raise ModelError, error_text
    end

    @field_pattern = @path_pattern.simplified_pattern
    @field_full_regex_str = @path_pattern.to_field_regex_str
    @field_regex_str = Gapic::PathPattern.parse(@field_pattern).to_field_regex_str

    @key = resource_segment.arguments[0]
    @value_pattern = resource_segment.resource_patterns[0]
  end

  ##
  # Whether pattern matching is not needed
  # since the patterns allow all strings
  # @return [Boolean]
  def pattern_matching_not_needed?
    field_pattern == "**" && value_pattern == "**"
  end

  ##
  # Whether the value to be added to the routing header
  # is the value of the whole field
  # @return [Boolean]
  def value_is_full_field?
    @path_pattern.segments.count == 1
  end

  private

  # Converts path template simplified forms into canonical
  # ResourceId representations by adding a field as a Resource Id
  # @param template [String]
  # @param field [String]
  # @return [String]
  def infer_template template, field
    if template.nil? || template.empty?
      return "{#{field}=**}"
    end

    if template.strip == "**"
      return "{#{field}=**}"
    end

    if template.strip == "*"
      return "{#{field}=*}"
    end

    template
  end

  def create_invalid_error_text path_pattern, raw_template
    reason = if path_pattern.segments.count(&:resource_id_segment?).zero?
               "it contains no ResourceId (e.g. `{foo=*}`) segments"
             elsif path_pattern.segments.count(&:resource_id_segment?) > 1
               "it contains more than one ResourceId (e.g. `{foo=*}`) segments "
             else
               "it contains a multivariate ResourceId segment (e.g. `{foo}~{bar}`)"
             end

    "A routing header parameter with the path_template #{raw_template}\n is invalid: #{reason}"
  end
end

#value_pattern ⇒ String (readonly)

# File 'lib/gapic/model/method/routing.rb', line 141

class RoutingParameter
  attr_reader :order
  attr_reader :field
  attr_reader :raw_template
  attr_reader :path_template
  attr_reader :key
  attr_reader :value_pattern
  attr_reader :field_pattern
  attr_reader :field_regex_str
  attr_reader :field_full_regex_str

  ##
  # @param routing_parameter [::Google::Api::RoutingParameter]
  #   Routing parameter annotation
  #
  # @param order [Integer]
  #   Order of this annotation among its peers
  def initialize routing_parameter, order
    @order = order
    @field = routing_parameter.field
    @raw_template = routing_parameter.path_template
    @path_template = infer_template @raw_template, @field
    @path_pattern = Gapic::PathPattern.parse @path_template

    resource_segment = @path_pattern.segments.find(&:resource_id_segment?)

    # Only one segment providing an argument and only one argument in the segment
    # (no `{foo}~{bar}` segments)
    valid = @path_pattern.segments.count(&:resource_id_segment?) == 1 &&
            resource_segment.arguments.count == 1

    unless valid
      error_text = create_invalid_error_text @path_pattern, @raw_template
      raise ModelError, error_text
    end

    @field_pattern = @path_pattern.simplified_pattern
    @field_full_regex_str = @path_pattern.to_field_regex_str
    @field_regex_str = Gapic::PathPattern.parse(@field_pattern).to_field_regex_str

    @key = resource_segment.arguments[0]
    @value_pattern = resource_segment.resource_patterns[0]
  end

  ##
  # Whether pattern matching is not needed
  # since the patterns allow all strings
  # @return [Boolean]
  def pattern_matching_not_needed?
    field_pattern == "**" && value_pattern == "**"
  end

  ##
  # Whether the value to be added to the routing header
  # is the value of the whole field
  # @return [Boolean]
  def value_is_full_field?
    @path_pattern.segments.count == 1
  end

  private

  # Converts path template simplified forms into canonical
  # ResourceId representations by adding a field as a Resource Id
  # @param template [String]
  # @param field [String]
  # @return [String]
  def infer_template template, field
    if template.nil? || template.empty?
      return "{#{field}=**}"
    end

    if template.strip == "**"
      return "{#{field}=**}"
    end

    if template.strip == "*"
      return "{#{field}=*}"
    end

    template
  end

  def create_invalid_error_text path_pattern, raw_template
    reason = if path_pattern.segments.count(&:resource_id_segment?).zero?
               "it contains no ResourceId (e.g. `{foo=*}`) segments"
             elsif path_pattern.segments.count(&:resource_id_segment?) > 1
               "it contains more than one ResourceId (e.g. `{foo=*}`) segments "
             else
               "it contains a multivariate ResourceId segment (e.g. `{foo}~{bar}`)"
             end

    "A routing header parameter with the path_template #{raw_template}\n is invalid: #{reason}"
  end
end

Instance Method Details

#pattern_matching_not_needed? ⇒ Boolean

Whether pattern matching is not needed since the patterns allow all strings

# File 'lib/gapic/model/method/routing.rb', line 189

def pattern_matching_not_needed?
  field_pattern == "**" && value_pattern == "**"
end

#value_is_full_field? ⇒ Boolean

Whether the value to be added to the routing header is the value of the whole field

# File 'lib/gapic/model/method/routing.rb', line 197

def value_is_full_field?
  @path_pattern.segments.count == 1
end