Class: Mustermann::Pattern Abstract

Inherits:
Object
  • Object
show all
Defined in:
lib/mustermann/pattern.rb

Overview

This class is abstract.

Superclass for all pattern implementations.

Direct Known Subclasses

Identity, RegexpBased, Shell

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(string, **options) ⇒ Pattern

Returns a new instance of Pattern

Raises:

  • (Mustermann::Error)

    if the pattern can't be generated from the string

See Also:


57
58
59
60
# File 'lib/mustermann/pattern.rb', line 57

def initialize(string, uri_decode: true, **options)
  @uri_decode = uri_decode
  @string     = string.dup
end

Class Method Details

.new(string, **options) ⇒ Mustermann::Pattern

Returns a new instance of Mustermann::Pattern

Raises:

  • (ArgumentError)

    if some option is not supported

  • (Mustermann::Error)

    if the pattern can't be generated from the string

See Also:


39
40
41
42
43
44
45
46
47
# File 'lib/mustermann/pattern.rb', line 39

def self.new(string, ignore_unknown_options: false, **options)
  unless ignore_unknown_options
    unsupported = options.keys.detect { |key| not supported?(key) }
    raise ArgumentError, "unsupported option %p for %p" % [unsupported, self] if unsupported
  end

  @map ||= EqualityMap.new
  @map.fetch(string, options) { super(string, options) }
end

.supported?(option) ⇒ Boolean


29
30
31
# File 'lib/mustermann/pattern.rb', line 29

def self.supported?(option)
  supported_options.include? option
end

.supported_optionsArray<Symbol> .supported_options(*list) ⇒ Array<Symbol>

List of supported options.

Overloads:

  • .supported_options(*list) ⇒ Array<Symbol>

    This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

    Adds options to the list.


20
21
22
23
24
25
# File 'lib/mustermann/pattern.rb', line 20

def self.supported_options(*list)
  @supported_options ||= []
  options = @supported_options.concat(list)
  options += superclass.supported_options if self < Pattern
  options
end

Instance Method Details

#===(string) ⇒ Boolean

Note:

Needs to be overridden by subclass.

Returns Whether or not the pattern matches the given string

Raises:

  • (NotImplementedError)

See Also:


87
88
89
# File 'lib/mustermann/pattern.rb', line 87

def ===(string)
  raise NotImplementedError, 'subclass responsibility'
end

#=~(string) ⇒ Integer?

Returns nil if pattern does not match the string, zero if it does.

See Also:


79
80
81
# File 'lib/mustermann/pattern.rb', line 79

def =~(string)
  0 if self === string
end

#expand(**values) ⇒ String

Note:

This method is only implemented by certain subclasses.

Returns expanded string

Examples:

Expanding a pattern

pattern = Mustermann.new('/:name(.:ext)?')
pattern.expand(name: 'hello')             # => "/hello"
pattern.expand(name: 'hello', ext: 'png') # => "/hello.png"

Checking if a pattern supports expanding

if pattern.respond_to? :expand
  pattern.expand(name: "foo")
else
  warn "does not support expanding"
end

Raises:

  • (NotImplementedError)

    raised if expand is not supported.

  • (Mustermann::ExpandError)

    raised if a value is missing or unknown

See Also:


135
136
137
# File 'lib/mustermann/pattern.rb', line 135

def expand(**values)
  raise NotImplementedError, "expanding not supported by #{self.class}"
end

#match(string) ⇒ MatchData, ...

Returns MatchData or similar object if the pattern matches.


72
73
74
# File 'lib/mustermann/pattern.rb', line 72

def match(string)
  SimpleMatch.new(string) if self === string
end

#named_capturesArray<String>

Returns capture names.


93
94
95
# File 'lib/mustermann/pattern.rb', line 93

def named_captures
  {}
end

#namesHash{String: Array<Integer>}

Returns capture names mapped to capture index.

See Also:


99
100
101
# File 'lib/mustermann/pattern.rb', line 99

def names
  []
end

#params(string = nil, captures: nil, offset: 0) ⇒ Hash{String: String, Array<String>}?


105
106
107
108
109
110
111
112
113
114
# File 'lib/mustermann/pattern.rb', line 105

def params(string = nil, captures: nil, offset: 0)
  return unless captures ||= match(string)
  params   = named_captures.map do |name, positions|
    values = positions.map { |pos| map_param(name, captures[pos + offset]) }.flatten
    values = values.first if values.size < 2 and not always_array? name
    [name, values]
  end

  Hash[params]
end

#to_sString


63
64
65
# File 'lib/mustermann/pattern.rb', line 63

def to_s
  @string.dup
end