Class: Zxcvbn::Match

Inherits:

Data

Object
Data
Zxcvbn::Match

show all

Defined in:: lib/zxcvbn/match.rb,
sig/zxcvbn/match.rbs

Overview

A substring match found by one of the pattern matchers.

All attributes are optional and default to nil. Use #with to derive a new match with changed attributes.

Constant Summary

Constants inherited from Data

Data::RESERVED_NAMES

Instance Attribute Summary collapse

#ascending ⇒ Boolean^? readonly
True if the sequence is ascending.
#base_guesses ⇒ Numeric^? readonly
Guesses for the base token (repeat matches) or rank before variation multipliers (dictionary matches).
#base_token ⇒ String^? readonly
The minimal repeating unit (repeat matches).
#day ⇒ Integer^? readonly
Matched day (date matches).
#dictionary_name ⇒ String^? readonly
Source dictionary name (dictionary matches).
#graph ⇒ String^? readonly
Keyboard graph name (spatial matches).
#guesses ⇒ Numeric^? readonly
Estimated guess count.
#guesses_log10 ⇒ Float^? readonly
Log10 of #guesses.
#i ⇒ Integer^? readonly
Start index in the password (inclusive).
#j ⇒ Integer^? readonly
End index in the password (inclusive).
#l33t ⇒ Boolean^? readonly
True when the match required l33t substitution.
#l33t_variations ⇒ Numeric^? readonly
L33t substitution variant count (dictionary matches).
#matched_word ⇒ String^? readonly
Lowercased dictionary word (dictionary matches).
#month ⇒ Integer^? readonly
Matched month (date matches).
#pattern ⇒ String^? readonly
The matcher that produced this match.
#rank ⇒ Integer^? readonly
Frequency rank of the matched word (dictionary matches).
#repeat_count ⇒ Integer^? readonly
Number of repetitions (repeat matches).
#reversed ⇒ Boolean^? readonly
True when matched in the reversed password.
#separator ⇒ String^? readonly
Date separator character (date matches).
#sequence_name ⇒ String^? readonly
Sequence type: "lower", "upper", "digits", or "unicode".
#sequence_space ⇒ Integer^? readonly
Size of the character set for the sequence.
#shifted_count ⇒ Integer^? readonly
Number of shifted characters (spatial matches).
#sub ⇒ Hash^? readonly
Map of l33t characters to their substituted letters.
#sub_display ⇒ String^? readonly
Human-readable substitution summary.
#token ⇒ String^? readonly
The matched substring.
#turns ⇒ Integer^? readonly
Number of direction changes (spatial matches).
#uppercase_variations ⇒ Numeric^? readonly
Capitalisation variant count (dictionary matches).
#year ⇒ Integer^? readonly
Matched year (date/year matches).

Attributes inherited from Data

#adjacency_graphs, #dictionaries, #graph_stats

Instance Method Summary collapse

#initialize(pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil, dictionary_name: nil, reversed: nil, l33t: nil, sub: nil, sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil, uppercase_variations: nil, l33t_variations: nil, base_token: nil, repeat_count: nil, sequence_name: nil, sequence_space: nil, ascending: nil, graph: nil, turns: nil, shifted_count: nil, year: nil, month: nil, day: nil, separator: nil) ⇒ Match constructor
A new instance of Match.
#inspect ⇒ String
A human-readable representation omitting nil fields and token.
#pretty_print(pp) ⇒ void
#with ⇒ Match

Methods inherited from Data

#add_word_list, #build_tries, #compute_graph_stats, #dictionary_tries, #ranked_dictionaries, #read_word_list

Constructor Details

#initialize(pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil, dictionary_name: nil, reversed: nil, l33t: nil, sub: nil, sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil, uppercase_variations: nil, l33t_variations: nil, base_token: nil, repeat_count: nil, sequence_name: nil, sequence_space: nil, ascending: nil, graph: nil, turns: nil, shifted_count: nil, year: nil, month: nil, day: nil, separator: nil) ⇒ `Match`

Returns a new instance of Match.

Parameters:

pattern: (String, nil) (defaults to: nil)
i: (Integer, nil) (defaults to: nil)
j: (Integer, nil) (defaults to: nil)
token: (String, nil) (defaults to: nil)
matched_word: (String, nil) (defaults to: nil)
rank: (Integer, nil) (defaults to: nil)
dictionary_name: (String, nil) (defaults to: nil)
reversed: (Boolean, nil) (defaults to: nil)
l33t: (Boolean, nil) (defaults to: nil)
sub: (Hash[String, String], nil) (defaults to: nil)
sub_display: (String, nil) (defaults to: nil)
guesses: (Numeric, nil) (defaults to: nil)
guesses_log10: (Float, nil) (defaults to: nil)
base_guesses: (Numeric, nil) (defaults to: nil)
uppercase_variations: (Numeric, nil) (defaults to: nil)
l33t_variations: (Numeric, nil) (defaults to: nil)
base_token: (String, nil) (defaults to: nil)
repeat_count: (Integer, nil) (defaults to: nil)
sequence_name: (String, nil) (defaults to: nil)
sequence_space: (Integer, nil) (defaults to: nil)
ascending: (Boolean, nil) (defaults to: nil)
graph: (String, nil) (defaults to: nil)
turns: (Integer, nil) (defaults to: nil)
shifted_count: (Integer, nil) (defaults to: nil)
year: (Integer, nil) (defaults to: nil)
month: (Integer, nil) (defaults to: nil)
day: (Integer, nil) (defaults to: nil)
separator: (String, nil) (defaults to: nil)

# File 'lib/zxcvbn/match.rb', line 73

def initialize(
  pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
  dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
  sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
  uppercase_variations: nil, l33t_variations: nil, base_token: nil,
  repeat_count: nil, sequence_name: nil, sequence_space: nil,
  ascending: nil, graph: nil, turns: nil, shifted_count: nil,
  year: nil, month: nil, day: nil, separator: nil
)
  super
end

Instance Attribute Details

#ascending ⇒ `Boolean`^? (readonly)

Returns true if the sequence is ascending.

Returns:

(Boolean, nil) —
true if the sequence is ascending

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#base_guesses ⇒ `Numeric`^? (readonly)

Returns guesses for the base token (repeat matches) or rank before variation multipliers (dictionary matches).

Returns:

(Numeric, nil) —
guesses for the base token (repeat matches) or rank before variation multipliers (dictionary matches)

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#base_token ⇒ `String`^? (readonly)

Returns the minimal repeating unit (repeat matches).

Returns:

(String, nil) —
the minimal repeating unit (repeat matches)

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#day ⇒ `Integer`^? (readonly)

Returns matched day (date matches).

Returns:

(Integer, nil) —
matched day (date matches)

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#dictionary_name ⇒ `String`^? (readonly)

Returns source dictionary name (dictionary matches).

Returns:

(String, nil) —
source dictionary name (dictionary matches)

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#graph ⇒ `String`^? (readonly)

Returns keyboard graph name (spatial matches).

Returns:

(String, nil) —
keyboard graph name (spatial matches)

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#guesses ⇒ `Numeric`^? (readonly)

Returns estimated guess count.

Returns:

(Numeric, nil) —
estimated guess count

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#guesses_log10 ⇒ `Float`^? (readonly)

Returns log10 of #guesses.

Returns:

(Float, nil) —
log10 of #guesses

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#i ⇒ `Integer`^? (readonly)

Returns start index in the password (inclusive).

Returns:

(Integer, nil) —
start index in the password (inclusive)

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#j ⇒ `Integer`^? (readonly)

Returns end index in the password (inclusive).

Returns:

(Integer, nil) —
end index in the password (inclusive)

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#l33t ⇒ `Boolean`^? (readonly)

Returns true when the match required l33t substitution.

Returns:

(Boolean, nil) —
true when the match required l33t substitution

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#l33t_variations ⇒ `Numeric`^? (readonly)

Returns l33t substitution variant count (dictionary matches).

Returns:

(Numeric, nil) —
l33t substitution variant count (dictionary matches)

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#matched_word ⇒ `String`^? (readonly)

Returns lowercased dictionary word (dictionary matches).

Returns:

(String, nil) —
lowercased dictionary word (dictionary matches)

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#month ⇒ `Integer`^? (readonly)

Returns matched month (date matches).

Returns:

(Integer, nil) —
matched month (date matches)

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#pattern ⇒ `String`^? (readonly)

Returns the matcher that produced this match.

Returns:

(String, nil) —
the matcher that produced this match

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#rank ⇒ `Integer`^? (readonly)

Returns frequency rank of the matched word (dictionary matches).

Returns:

(Integer, nil) —
frequency rank of the matched word (dictionary matches)

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#repeat_count ⇒ `Integer`^? (readonly)

Returns number of repetitions (repeat matches).

Returns:

(Integer, nil) —
number of repetitions (repeat matches)

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#reversed ⇒ `Boolean`^? (readonly)

Returns true when matched in the reversed password.

Returns:

(Boolean, nil) —
true when matched in the reversed password

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#separator ⇒ `String`^? (readonly)

Returns date separator character (date matches).

Returns:

(String, nil) —
date separator character (date matches)

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#sequence_name ⇒ `String`^? (readonly)

Returns sequence type: "lower", "upper", "digits", or "unicode".

Returns:

(String, nil) —
sequence type: "lower", "upper", "digits", or "unicode"

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#sequence_space ⇒ `Integer`^? (readonly)

Returns size of the character set for the sequence.

Returns:

(Integer, nil) —
size of the character set for the sequence

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#shifted_count ⇒ `Integer`^? (readonly)

Returns number of shifted characters (spatial matches).

Returns:

(Integer, nil) —
number of shifted characters (spatial matches)

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#sub ⇒ `Hash`^? (readonly)

Returns map of l33t characters to their substituted letters.

Returns:

(Hash, nil) —
map of l33t characters to their substituted letters

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#sub_display ⇒ `String`^? (readonly)

Returns human-readable substitution summary.

Returns:

(String, nil) —
human-readable substitution summary

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#token ⇒ `String`^? (readonly)

Returns the matched substring.

Returns:

(String, nil) —
the matched substring

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#turns ⇒ `Integer`^? (readonly)

Returns number of direction changes (spatial matches).

Returns:

(Integer, nil) —
number of direction changes (spatial matches)

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#uppercase_variations ⇒ `Numeric`^? (readonly)

Returns capitalisation variant count (dictionary matches).

Returns:

(Numeric, nil) —
capitalisation variant count (dictionary matches)

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

#year ⇒ `Integer`^? (readonly)

Returns matched year (date/year matches).

Returns:

(Integer, nil) —
matched year (date/year matches)

# File 'lib/zxcvbn/match.rb', line 66

Match = ::Data.define(
  :pattern, :i, :j, :token, :matched_word, :rank, :dictionary_name, :reversed,
  :l33t, :sub, :sub_display, :guesses, :guesses_log10, :base_guesses,
  :uppercase_variations, :l33t_variations, :base_token, :repeat_count,
  :sequence_name, :sequence_space, :ascending, :graph, :turns, :shifted_count,
  :year, :month, :day, :separator
) do
  def initialize(
    pattern: nil, i: nil, j: nil, token: nil, matched_word: nil, rank: nil,
    dictionary_name: nil, reversed: nil, l33t: nil, sub: nil,
    sub_display: nil, guesses: nil, guesses_log10: nil, base_guesses: nil,
    uppercase_variations: nil, l33t_variations: nil, base_token: nil,
    repeat_count: nil, sequence_name: nil, sequence_space: nil,
    ascending: nil, graph: nil, turns: nil, shifted_count: nil,
    year: nil, month: nil, day: nil, separator: nil
  )
    super
  end

  # @return [String] a human-readable representation omitting nil fields and token
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @param pp [PP] the pretty-printer instance
  # @return [void]
  def pretty_print(pp)
    fields = to_h.reject { |_, v| v.nil? }
    pp.group(1, "#<data #{self.class}", '>') do
      fields.each_with_index do |(k, v), i|
        pp.text(',') if i.positive?
        pp.breakable ' '
        pp.text("#{k}=")
        v.pretty_print(pp)
      end
    end
  end
end

Instance Method Details

#inspect ⇒ `String`

Returns a human-readable representation omitting nil fields and token.

Returns:

(String) —
a human-readable representation omitting nil fields and token

# File 'lib/zxcvbn/match.rb', line 86

def inspect
  fields = to_h.reject { |k, v| v.nil? || k == :token }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
  "#<data #{self.class} #{fields}>"
end

#pretty_print(pp) ⇒ `void`

This method returns an undefined value.

Parameters:

pp (PP) —
the pretty-printer instance

# File 'lib/zxcvbn/match.rb', line 93

def pretty_print(pp)
  fields = to_h.reject { |_, v| v.nil? }
  pp.group(1, "#<data #{self.class}", '>') do
    fields.each_with_index do |(k, v), i|
      pp.text(',') if i.positive?
      pp.breakable ' '
      pp.text("#{k}=")
      v.pretty_print(pp)
    end
  end
end

#with ⇒ `Match`

Parameters:

(Object)

Returns:

(Match)

34	# File 'sig/zxcvbn/match.rbs', line 34 def with: (**untyped) -> Match

Class: Zxcvbn::Match

Overview

Constant Summary

Constants inherited from Data

Instance Attribute Summary collapse

Attributes inherited from Data

Instance Method Summary collapse

Methods inherited from Data

Constructor Details

Instance Attribute Details

#ascending ⇒ Boolean? (readonly)

#base_guesses ⇒ Numeric? (readonly)

#base_token ⇒ String? (readonly)

#day ⇒ Integer? (readonly)

#dictionary_name ⇒ String? (readonly)

#graph ⇒ String? (readonly)

#guesses ⇒ Numeric? (readonly)

#guesses_log10 ⇒ Float? (readonly)

#i ⇒ Integer? (readonly)

#j ⇒ Integer? (readonly)

#l33t ⇒ Boolean? (readonly)

#l33t_variations ⇒ Numeric? (readonly)

#matched_word ⇒ String? (readonly)

#month ⇒ Integer? (readonly)

#pattern ⇒ String? (readonly)

#rank ⇒ Integer? (readonly)

#repeat_count ⇒ Integer? (readonly)

#reversed ⇒ Boolean? (readonly)

#separator ⇒ String? (readonly)

#sequence_name ⇒ String? (readonly)

#sequence_space ⇒ Integer? (readonly)

#shifted_count ⇒ Integer? (readonly)

#sub ⇒ Hash? (readonly)

#sub_display ⇒ String? (readonly)

#token ⇒ String? (readonly)

#turns ⇒ Integer? (readonly)

#uppercase_variations ⇒ Numeric? (readonly)

#year ⇒ Integer? (readonly)

Instance Method Details

#inspect ⇒ String

#pretty_print(pp) ⇒ void

#with ⇒ Match

#ascending ⇒ `Boolean`^? (readonly)

#base_guesses ⇒ `Numeric`^? (readonly)

#base_token ⇒ `String`^? (readonly)

#day ⇒ `Integer`^? (readonly)

#dictionary_name ⇒ `String`^? (readonly)

#graph ⇒ `String`^? (readonly)

#guesses ⇒ `Numeric`^? (readonly)

#guesses_log10 ⇒ `Float`^? (readonly)

#i ⇒ `Integer`^? (readonly)

#j ⇒ `Integer`^? (readonly)

#l33t ⇒ `Boolean`^? (readonly)

#l33t_variations ⇒ `Numeric`^? (readonly)

#matched_word ⇒ `String`^? (readonly)

#month ⇒ `Integer`^? (readonly)

#pattern ⇒ `String`^? (readonly)

#rank ⇒ `Integer`^? (readonly)

#repeat_count ⇒ `Integer`^? (readonly)

#reversed ⇒ `Boolean`^? (readonly)

#separator ⇒ `String`^? (readonly)

#sequence_name ⇒ `String`^? (readonly)

#sequence_space ⇒ `Integer`^? (readonly)

#shifted_count ⇒ `Integer`^? (readonly)

#sub ⇒ `Hash`^? (readonly)

#sub_display ⇒ `String`^? (readonly)

#token ⇒ `String`^? (readonly)

#turns ⇒ `Integer`^? (readonly)

#uppercase_variations ⇒ `Numeric`^? (readonly)

#year ⇒ `Integer`^? (readonly)

#inspect ⇒ `String`

#pretty_print(pp) ⇒ `void`

#with ⇒ `Match`