zxcvbn-ruby 1.2.4 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52ddbaaabcb2929e59d34d91104bce81b86f223428001218872294363d79f2ac
-  data.tar.gz: 5c488ab8d0dfbd6c46b2b5b05f3b878355e09babe09304c3653c9e45dcf64d02
+  metadata.gz: 43a759e1040848c8da4bea8d1e871eb7d811d5cab0ebf962255990963b796f75
+  data.tar.gz: c78d0453bb8c92d1f3b21c37f1493f305a6667f24e6ae85a621841a9396fb584
 SHA512:
-  metadata.gz: 6ac904b4f3e4219981def358d1f7aa69870e9e33605c3696123e95f936d4880b39d2b5e1d5f323fd89ebc7b2ff43eaa93f22c598ac40ea20bdd768072a082162
-  data.tar.gz: f32d688a3ee53867c1f47f0e52527d3da4397e26c93854305ee5cbcf224e9dad104f087ab80174848b3765dd41a086a6fd33a4ab72a1b72d8ea05209aa88b289
+  metadata.gz: 552d40a11c071613eefb14819b4dabbd3abc6a1f2d336e6bf9bfbc873a34640a229b3bedcc0bd77aca6ffe5e43e31fefec74fe94d74f3cdaebd4e7169610ec02
+  data.tar.gz: 84c006df22e0224da4a891f8fa923c81b69229f2b99e5d60ba29104473e566c83a36fbcc404defe980d80cfb176964864f00dbdfa02d655e05eaac7753e64360

data/CHANGELOG.md

@@ -6,7 +6,39 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-[Unreleased]: https://github.com/envato/zxcvbn-ruby/compare/v1.2.4...HEAD
+[Unreleased]: https://github.com/envato/zxcvbn-ruby/compare/v1.4.0...HEAD
+
+## [1.4.0] - 2026-01-15
+
+### Added
+ - RBS type signatures for improved type checking and IDE support ([#68])
+
+### Changed
+ - Minor fixups in gem metadata ([#67]).
+
+[1.4.0]: https://github.com/envato/zxcvbn-ruby/compare/v1.3.0...v1.4.0
+[#67]: https://github.com/envato/zxcvbn-ruby/pull/67
+[#68]: https://github.com/envato/zxcvbn-ruby/pull/68
+
+## [1.3.0] - 2026-01-02
+
+### Changed
+ - Replace OpenStruct with regular class in `Zxcvbn::Match` for 2x performance improvement ([#61])
+ - Implement Trie data structure for dictionary matching with 1.4x additional performance improvement ([#62])
+ - Replace range operators with `String#slice` for string slicing operations ([#63])
+ - Optimise L33t matcher with early bailout and improved deduplication ([#64])
+ - Pre-compute spatial graph statistics during data initialisation ([#65])
+ - Optimise nCk calculation using symmetry property ([#66])
+
+Overall performance improvement: 4.1x faster than v1.2.4 (0.722ms → 0.176ms per password)
+
+[1.3.0]: https://github.com/envato/zxcvbn-ruby/compare/v1.2.4...v1.3.0
+[#61]: https://github.com/envato/zxcvbn-ruby/pull/61
+[#62]: https://github.com/envato/zxcvbn-ruby/pull/62
+[#63]: https://github.com/envato/zxcvbn-ruby/pull/63
+[#64]: https://github.com/envato/zxcvbn-ruby/pull/64
+[#65]: https://github.com/envato/zxcvbn-ruby/pull/65
+[#66]: https://github.com/envato/zxcvbn-ruby/pull/66
 
 ## [1.2.4] - 2025-12-07
 

data/lib/zxcvbn/data.rb

@@ -2,6 +2,7 @@
 
 require 'json'
 require 'zxcvbn/dictionary_ranker'
+require 'zxcvbn/trie'
 
 module Zxcvbn
   class Data
@@ -14,12 +15,16 @@ module Zxcvbn
         'surnames' => read_word_list('surnames.txt')
       )
       @adjacency_graphs = JSON.parse(DATA_PATH.join('adjacency_graphs.json').read)
+      @dictionary_tries = build_tries
+      @graph_stats = compute_graph_stats
     end
 
-    attr_reader :ranked_dictionaries, :adjacency_graphs
+    attr_reader :ranked_dictionaries, :adjacency_graphs, :dictionary_tries, :graph_stats
 
     def add_word_list(name, list)
-      @ranked_dictionaries[name] = DictionaryRanker.rank_dictionary(list)
+      ranked_dict = DictionaryRanker.rank_dictionary(list)
+      @ranked_dictionaries[name] = ranked_dict
+      @dictionary_tries[name] = build_trie(ranked_dict)
     end
 
     private
@@ -27,5 +32,31 @@ module Zxcvbn
     def read_word_list(file)
       DATA_PATH.join('frequency_lists', file).read.split
     end
+
+    def build_tries
+      @ranked_dictionaries.transform_values { |dict| build_trie(dict) }
+    end
+
+    def build_trie(ranked_dictionary)
+      trie = Trie.new
+      ranked_dictionary.each { |word, rank| trie.insert(word, rank) }
+      trie
+    end
+
+    def compute_graph_stats
+      stats = {}
+      @adjacency_graphs.each do |graph_name, graph|
+        degrees = graph.map { |_, neighbors| neighbors.compact.size }
+        sum = degrees.inject(0, :+)
+        average_degree = sum.to_f / graph.size
+        starting_positions = graph.length
+
+        stats[graph_name] = {
+          average_degree: average_degree,
+          starting_positions: starting_positions
+        }
+      end
+      stats
+    end
   end
 end

data/lib/zxcvbn/dictionary_ranker.rb

@@ -9,10 +9,9 @@ module Zxcvbn
     end
 
     def self.rank_dictionary(words)
-      words.each_with_index
-           .with_object({}) do |(word, i), dictionary|
-        dictionary[word.downcase] = i + 1
-      end
+      words
+        .each_with_index
+        .with_object({}) { |(word, i), dictionary| dictionary[word.downcase] = i + 1 }
     end
   end
 end

data/lib/zxcvbn/match.rb

@@ -1,12 +1,24 @@
 # frozen_string_literal: true
 
-require 'ostruct'
-
 module Zxcvbn
-  class Match < OpenStruct
+  class Match
+    attr_accessor :pattern, :i, :j, :token, :matched_word, :rank,
+                  :dictionary_name, :reversed, :l33t, :sub, :sub_display,
+                  :l, :entropy, :base_entropy, :uppercase_entropy, :l33t_entropy,
+                  :repeated_char, :sequence_name, :sequence_space, :ascending,
+                  :graph, :turns, :shifted_count, :shiffted_count,
+                  :year, :month, :day, :separator, :cardinality, :offset
+
+    def initialize(**attributes)
+      attributes.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+    end
+
     def to_hash
-      @table.keys.sort.each_with_object({}) do |key, hash|
-        hash[key.to_s] = @table[key]
+      instance_variables.sort.each_with_object({}) do |var, hash|
+        key = var.to_s.delete_prefix('@')
+        hash[key] = instance_variable_get(var)
       end
     end
   end

data/lib/zxcvbn/matchers/dictionary.rb

@@ -8,33 +8,64 @@ module Zxcvbn
     # the lowercased password in the dictionary
 
     class Dictionary
-      def initialize(name, ranked_dictionary)
+      def initialize(name, ranked_dictionary, trie = nil)
         @name = name
         @ranked_dictionary = ranked_dictionary
+        @trie = trie
       end
 
       def matches(password)
+        lowercased_password = password.downcase
+
+        if @trie
+          trie_matches(password, lowercased_password)
+        else
+          hash_matches(password, lowercased_password)
+        end
+      end
+
+      private
+
+      def trie_matches(password, lowercased_password)
+        results = []
+
+        (0...password.length).each do |i|
+          @trie.search_prefixes(lowercased_password, i).each do |word, rank, start, ending|
+            results << build_match(word, password.slice(start, ending - start + 1), start, ending, rank)
+          end
+        end
+
+        results
+      end
+
+      def hash_matches(password, lowercased_password)
         results = []
         password_length = password.length
-        lowercased_password = password.downcase
+
         (0..password_length).each do |i|
           (i...password_length).each do |j|
-            word = lowercased_password[i..j]
+            length = j - i + 1
+            word = lowercased_password.slice(i, length)
             next unless @ranked_dictionary.key?(word)
 
-            results << Match.new(
-              matched_word: word,
-              token: password[i..j],
-              i: i,
-              j: j,
-              rank: @ranked_dictionary[word],
-              pattern: 'dictionary',
-              dictionary_name: @name
-            )
+            results << build_match(word, password.slice(i, length), i, j, @ranked_dictionary[word])
           end
         end
+
         results
       end
+
+      def build_match(matched_word, token, start_pos, end_pos, rank)
+        Match.new(
+          matched_word: matched_word,
+          token: token,
+          i: start_pos,
+          j: end_pos,
+          rank: rank,
+          pattern: 'dictionary',
+          dictionary_name: @name
+        )
+      end
     end
   end
 end

data/lib/zxcvbn/matchers/l33t.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'set'
+
 module Zxcvbn
   module Matchers
     class L33t
@@ -25,25 +27,17 @@ module Zxcvbn
       def matches(password)
         matches = []
         lowercased_password = password.downcase
-        combinations_to_try = l33t_subs(relevent_l33t_subtable(lowercased_password))
+        relevent_subtable = relevent_l33t_subtable(lowercased_password)
+
+        # Early bailout: if no l33t characters present, return empty matches
+        return matches if relevent_subtable.empty?
+
+        combinations_to_try = l33t_subs(relevent_subtable)
         combinations_to_try.each do |substitution|
           @dictionary_matchers.each do |matcher|
             subbed_password = translate(lowercased_password, substitution)
             matcher.matches(subbed_password).each do |match|
-              token = password[match.i..match.j]
-              next if token.downcase == match.matched_word.downcase
-
-              match_substitutions = {}
-              substitution.each do |s, letter|
-                match_substitutions[s] = letter if token.include?(s)
-              end
-              match.l33t = true
-              match.token = password[match.i..match.j]
-              match.sub = match_substitutions
-              match.sub_display = match_substitutions.map do |k, v|
-                "#{k} -> #{v}"
-              end.join(', ')
-              matches << match
+              process_match(match, password, substitution, matches)
             end
           end
         end
@@ -51,9 +45,11 @@ module Zxcvbn
       end
 
       def translate(password, sub)
-        password.split('').map do |chr|
-          sub[chr] || chr
-        end.join
+        result = String.new
+        password.each_char do |chr|
+          result << (sub[chr] || chr)
+        end
+        result
       end
 
       def relevent_l33t_subtable(password)
@@ -80,6 +76,26 @@ module Zxcvbn
         new_subs
       end
 
+      private
+
+      def process_match(match, password, substitution, matches)
+        length = match.j - match.i + 1
+        token = password.slice(match.i, length)
+        return if token.downcase == match.matched_word.downcase
+
+        match_substitutions = {}
+        substitution.each do |s, letter|
+          match_substitutions[s] = letter if token.include?(s)
+        end
+        match.l33t = true
+        match.token = token
+        match.sub = match_substitutions
+        match.sub_display = match_substitutions.map do |k, v|
+          "#{k} -> #{v}"
+        end.join(', ')
+        matches << match
+      end
+
       def find_substitutions(subs, table, keys)
         return subs if keys.empty?
 
@@ -113,14 +129,12 @@ module Zxcvbn
 
       def dedup(subs)
         deduped = []
-        members = []
+        seen = Set.new
         subs.each do |sub|
-          assoc = sub.dup
-
-          assoc.sort!
-          label = assoc.map { |k, v| "#{k},#{v}" }.join('-')
-          unless members.include?(label)
-            members << label
+          # Sort and convert to hash for consistent comparison
+          sorted_sub = sub.sort.to_h
+          unless seen.include?(sorted_sub)
+            seen.add(sorted_sub)
             deduped << sub
           end
         end

data/lib/zxcvbn/matchers/new_l33t.rb

@@ -30,7 +30,8 @@ module Zxcvbn
           @dictionary_matchers.each do |matcher|
             subbed_password = substitute(lowercased_password, substitutions)
             matcher.matches(subbed_password).each do |match|
-              token = lowercased_password[match.i..match.j]
+              length = match.j - match.i + 1
+              token = lowercased_password.slice(match.i, length)
               next if token == match.matched_word.downcase
 
               match_substitutions = {}
@@ -38,7 +39,7 @@ module Zxcvbn
                 match_substitutions[substitution] = letter if token.include?(substitution)
               end
               match.l33t = true
-              match.token = password[match.i..match.j]
+              match.token = password.slice(match.i, length)
               match.sub = match_substitutions
               match.sub_display = match_substitutions.map do |k, v|
                 "#{k} -> #{v}"

data/lib/zxcvbn/matchers/regex_helpers.rb

@@ -15,7 +15,7 @@ module Zxcvbn
           match = Match.new(
             i: i,
             j: j,
-            token: password[i..j]
+            token: password.slice(i, j - i + 1)
           )
           yield match, re_match
         end

data/lib/zxcvbn/matchers/repeat.rb

@@ -18,7 +18,7 @@ module Zxcvbn
               pattern: 'repeat',
               i: i,
               j: j - 1,
-              token: password[i...j],
+              token: password.slice(i, j - i),
               repeated_char: cur_char
             )
           end

data/lib/zxcvbn/matchers/spatial.rb

@@ -64,7 +64,7 @@ module Zxcvbn
                   pattern: 'spatial',
                   i: i,
                   j: j - 1,
-                  token: password[i...j],
+                  token: password.slice(i, j - i),
                   graph: graph_name,
                   turns: turns,
                   shifted_count: shifted_count

data/lib/zxcvbn/math.rb

@@ -34,6 +34,10 @@ module Zxcvbn
       return 0 if k > n
       return 1 if k.zero?
 
+      # Use symmetry property: C(n,k) = C(n, n-k)
+      # Choose smaller k to minimize iterations
+      k = n - k if k > n - k
+
       r = 1
       (1..k).each do |d|
         r *= n
@@ -44,14 +48,11 @@ module Zxcvbn
     end
 
     def average_degree_for_graph(graph_name)
-      graph = data.adjacency_graphs[graph_name]
-      degrees = graph.map { |_, neighbors| neighbors.compact.size }
-      sum = degrees.inject(0, :+)
-      sum.to_f / graph.size
+      data.graph_stats[graph_name][:average_degree]
     end
 
     def starting_positions_for_graph(graph_name)
-      data.adjacency_graphs[graph_name].length
+      data.graph_stats[graph_name][:starting_positions]
     end
   end
 end

data/lib/zxcvbn/omnimatch.rb

@@ -38,7 +38,8 @@ module Zxcvbn
     def build_matchers
       matchers = []
       dictionary_matchers = @data.ranked_dictionaries.map do |name, dictionary|
-        Matchers::Dictionary.new(name, dictionary)
+        trie = @data.dictionary_tries[name]
+        Matchers::Dictionary.new(name, dictionary, trie)
       end
       l33t_matcher = Matchers::L33t.new(dictionary_matchers)
       matchers += dictionary_matchers

data/lib/zxcvbn/scorer.rb

@@ -96,7 +96,7 @@ module Zxcvbn
         pattern: 'bruteforce',
         i: i,
         j: j,
-        token: password[i..j],
+        token: password.slice(i, j - i + 1),
         entropy: lg(bruteforce_cardinality**(j - i + 1)),
         cardinality: bruteforce_cardinality
       )

data/lib/zxcvbn/trie.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Zxcvbn
+  # A trie (prefix tree) data structure for efficient dictionary matching.
+  # Provides fast prefix-based lookups to eliminate unnecessary substring checks.
+  #
+  # @see https://en.wikipedia.org/wiki/Trie
+  class Trie
+    def initialize
+      @root = {}
+    end
+
+    # Insert a word and its rank into the trie
+    # @param word [String] the word to insert
+    # @param rank [Integer] the rank/frequency of the word
+    def insert(word, rank)
+      node = @root
+      word.each_char do |char|
+        node[char] ||= {}
+        node = node[char]
+      end
+      node[:rank] = rank
+    end
+
+    # Search for all words in the text starting from a given position
+    # @param text [String] the text to search in
+    # @param start_pos [Integer] the starting position
+    # @return [Array<Array>] array of [word, rank, start, end] tuples
+    def search_prefixes(text, start_pos)
+      results = []
+      node = @root
+
+      (start_pos...text.length).each do |i|
+        char = text[i]
+        break unless node[char]
+
+        node = node[char]
+        results << [text[start_pos..i], node[:rank], start_pos, i] if node[:rank]
+      end
+
+      results
+    end
+  end
+end

data/lib/zxcvbn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Zxcvbn
-  VERSION = '1.2.4'
+  VERSION = '1.4.0'
 end

data/sig/README.md

@@ -0,0 +1,65 @@
+# RBS Type Signatures
+
+This directory contains [RBS](https://github.com/ruby/rbs) type signatures for the zxcvbn-ruby gem.
+
+## What is RBS?
+
+RBS is Ruby's type signature language. It provides a way to describe the structure of Ruby programs with:
+- Class and module definitions
+- Method signatures with parameter and return types
+- Instance variables and constants
+- Duck typing and union types
+
+## Usage
+
+### Validating Type Signatures
+
+To validate that the RBS files are syntactically correct:
+
+```bash
+bundle exec rake rbs:validate
+```
+
+### Runtime Type Checking
+
+To run runtime type checking against the actual Ruby code during tests:
+
+```bash
+bundle exec rake rbs:test
+```
+
+This runs the RSpec test suite with RBS type checking enabled, verifying that method calls match their type signatures at runtime. Note: This takes about 2 minutes to run.
+
+### Other Useful Commands
+
+List all Zxcvbn types:
+```bash
+bundle exec rake rbs:list
+```
+
+Check syntax of RBS files:
+```bash
+bundle exec rake rbs:parse
+```
+
+## File Structure
+
+The signatures mirror the structure of the `lib/` directory:
+
+- `sig/zxcvbn.rbs` - Main Zxcvbn module
+- `sig/zxcvbn/*.rbs` - Core classes (Tester, Score, Match, etc.)
+- `sig/zxcvbn/matchers/*.rbs` - Pattern matcher classes
+
+## Adding New Signatures
+
+When adding new classes or methods to the codebase, remember to:
+
+1. Create or update the corresponding `.rbs` file in the `sig/` directory
+2. Run `bundle exec rake rbs_validate` to ensure the syntax is correct
+3. Keep type signatures in sync with the actual implementation
+
+## Resources
+
+- [RBS Documentation](https://github.com/ruby/rbs)
+- [RBS Syntax Guide](https://github.com/ruby/rbs/blob/master/docs/syntax.md)
+- [Ruby Signature Collection](https://github.com/ruby/gem_rbs_collection)

data/sig/zxcvbn/crack_time.rbs

@@ -0,0 +1,13 @@
+module Zxcvbn
+  module CrackTime
+    SINGLE_GUESS: Float
+    NUM_ATTACKERS: Integer
+    SECONDS_PER_GUESS: Float
+
+    def entropy_to_crack_time: (Numeric entropy) -> Float
+
+    def crack_time_to_score: (Numeric seconds) -> Integer
+
+    def display_time: (Numeric seconds) -> String
+  end
+end

data/sig/zxcvbn/data.rbs

@@ -0,0 +1,31 @@
+module Zxcvbn
+  class Data
+    type ranked_dictionary = Hash[String, Integer]
+    type adjacency_graph = Hash[String, Array[String?]]
+    type graph_stats = Hash[String, { average_degree: Float, starting_positions: Integer }]
+
+    @ranked_dictionaries: Hash[String, ranked_dictionary]
+    @adjacency_graphs: Hash[String, adjacency_graph]
+    @dictionary_tries: Hash[String, Trie]
+    @graph_stats: graph_stats
+
+    attr_reader ranked_dictionaries: Hash[String, ranked_dictionary]
+    attr_reader adjacency_graphs: Hash[String, adjacency_graph]
+    attr_reader dictionary_tries: Hash[String, Trie]
+    attr_reader graph_stats: graph_stats
+
+    def initialize: () -> void
+
+    def add_word_list: (String name, Array[String] list) -> void
+
+    private
+
+    def read_word_list: (String file) -> Array[String]
+
+    def build_tries: () -> Hash[String, Trie]
+
+    def build_trie: (ranked_dictionary ranked_dictionary) -> Trie
+
+    def compute_graph_stats: () -> graph_stats
+  end
+end

data/sig/zxcvbn/dictionary_ranker.rbs

@@ -0,0 +1,7 @@
+module Zxcvbn
+  class DictionaryRanker
+    def self.rank_dictionaries: (Hash[String | Symbol, Array[String]] lists) -> Hash[String | Symbol, Hash[String, Integer]]
+
+    def self.rank_dictionary: (Array[String] words) -> Hash[String, Integer]
+  end
+end

data/sig/zxcvbn/entropy.rbs

@@ -0,0 +1,33 @@
+module Zxcvbn
+  module Entropy
+    include Zxcvbn::Math
+
+    def calc_entropy: (Match match) -> Float
+
+    def repeat_entropy: (Match match) -> Float
+
+    def sequence_entropy: (Match match) -> Float
+
+    def digits_entropy: (Match match) -> Float
+
+    def year_entropy: (Match? match) -> Float
+
+    def date_entropy: (Match match) -> Float
+
+    def dictionary_entropy: (Match match) -> Float
+
+    def extra_uppercase_entropy: (Match match) -> Numeric
+
+    def extra_l33t_entropy: (Match match) -> Numeric
+
+    def spatial_entropy: (Match match) -> Float
+
+    NUM_YEARS: Integer
+    NUM_MONTHS: Integer
+    NUM_DAYS: Integer
+    START_UPPER: Regexp
+    END_UPPER: Regexp
+    ALL_UPPER: Regexp
+    ALL_LOWER: Regexp
+  end
+end

data/sig/zxcvbn/feedback.rbs

@@ -0,0 +1,8 @@
+module Zxcvbn
+  class Feedback
+    attr_accessor warning: String?
+    attr_accessor suggestions: Array[String]
+
+    def initialize: (?warning: String?, ?suggestions: Array[String]) -> void
+  end
+end

data/sig/zxcvbn/feedback_giver.rbs

@@ -0,0 +1,13 @@
+module Zxcvbn
+  class FeedbackGiver
+    NAME_DICTIONARIES: Array[String]
+    DEFAULT_FEEDBACK: Feedback
+    EMPTY_FEEDBACK: Feedback
+
+    def self.get_feedback: (Integer? score, Array[Match] sequence) -> Feedback
+
+    def self.get_match_feedback: (Match match, bool is_sole_match) -> Feedback?
+
+    def self.get_dictionary_match_feedback: (Match match, bool is_sole_match) -> Feedback
+  end
+end

data/sig/zxcvbn/match.rbs

@@ -0,0 +1,38 @@
+module Zxcvbn
+  class Match
+    attr_accessor pattern: String?
+    attr_accessor i: Integer?
+    attr_accessor j: Integer?
+    attr_accessor token: String?
+    attr_accessor matched_word: String?
+    attr_accessor rank: Integer?
+    attr_accessor dictionary_name: String?
+    attr_accessor reversed: bool?
+    attr_accessor l33t: bool?
+    attr_accessor sub: Hash[String, String]?
+    attr_accessor sub_display: String?
+    attr_accessor l: Integer?
+    attr_accessor entropy: Numeric?
+    attr_accessor base_entropy: Numeric?
+    attr_accessor uppercase_entropy: Numeric?
+    attr_accessor l33t_entropy: Numeric?
+    attr_accessor repeated_char: String?
+    attr_accessor sequence_name: String?
+    attr_accessor sequence_space: Integer?
+    attr_accessor ascending: bool?
+    attr_accessor graph: String?
+    attr_accessor turns: Integer?
+    attr_accessor shifted_count: Integer?
+    attr_accessor shiffted_count: Integer?
+    attr_accessor year: Integer?
+    attr_accessor month: Integer?
+    attr_accessor day: Integer?
+    attr_accessor separator: String?
+    attr_accessor cardinality: Integer?
+    attr_accessor offset: Integer?
+
+    def initialize: (**untyped attributes) -> void
+
+    def to_hash: () -> Hash[String, untyped]
+  end
+end

data/sig/zxcvbn/math.rbs

@@ -0,0 +1,13 @@
+module Zxcvbn
+  module Math
+    def bruteforce_cardinality: (String password) -> Integer
+
+    def lg: (Numeric n) -> Float
+
+    def nCk: (Integer n, Integer k) -> Integer
+
+    def average_degree_for_graph: (String graph_name) -> Float
+
+    def starting_positions_for_graph: (String graph_name) -> Integer
+  end
+end

data/sig/zxcvbn/omnimatch.rbs

@@ -0,0 +1,16 @@
+module Zxcvbn
+  class Omnimatch
+    @data: Data
+    @matchers: Array[untyped]
+
+    def initialize: (Data data) -> void
+
+    def matches: (String password, ?Array[String] user_inputs) -> Array[Match]
+
+    private
+
+    def user_input_matchers: (Array[String] user_inputs) -> Array[untyped]
+
+    def build_matchers: () -> Array[untyped]
+  end
+end

data/sig/zxcvbn/password_strength.rbs

@@ -0,0 +1,10 @@
+module Zxcvbn
+  class PasswordStrength
+    @omnimatch: Omnimatch
+    @scorer: Scorer
+
+    def initialize: (Data data) -> void
+
+    def test: (String? password, ?Array[untyped] user_inputs) -> Score
+  end
+end

data/sig/zxcvbn/score.rbs

@@ -0,0 +1,15 @@
+module Zxcvbn
+  class Score
+    attr_accessor entropy: Numeric?
+    attr_accessor crack_time: Numeric?
+    attr_accessor crack_time_display: String?
+    attr_accessor score: Integer?
+    attr_accessor pattern: String?
+    attr_accessor match_sequence: Array[Match]?
+    attr_accessor password: String?
+    attr_accessor calc_time: Float?
+    attr_accessor feedback: Feedback?
+
+    def initialize: (?entropy: Numeric?, ?crack_time: Numeric?, ?crack_time_display: String?, ?score: Integer?, ?match_sequence: Array[Match]?, ?password: String?) -> void
+  end
+end

data/sig/zxcvbn/scorer.rbs

@@ -0,0 +1,20 @@
+module Zxcvbn
+  class Scorer
+    include Entropy
+    include CrackTime
+
+    @data: Data
+
+    attr_reader data: Data
+
+    def initialize: (Data data) -> void
+
+    def minimum_entropy_match_sequence: (String password, Array[Match] matches) -> Score
+
+    def score_for: (String password, Array[Match] match_sequence, Array[Float] up_to_k) -> Score
+
+    def pad_with_bruteforce_matches: (Array[Match] match_sequence, String password, Integer bruteforce_cardinality) -> Array[Match]
+
+    def make_bruteforce_match: (String password, Integer i, Integer j, Integer bruteforce_cardinality) -> Match
+  end
+end

data/sig/zxcvbn/tester.rbs

@@ -0,0 +1,17 @@
+module Zxcvbn
+  class Tester
+    @data: Data
+
+    def initialize: () -> void
+
+    def test: (String? password, ?Array[untyped] user_inputs) -> Score
+
+    def add_word_lists: (Hash[String, Array[untyped]] lists) -> void
+
+    def inspect: () -> String
+
+    private
+
+    def sanitize: (Array[untyped] user_inputs) -> Array[String]
+  end
+end

data/sig/zxcvbn/trie.rbs

@@ -0,0 +1,13 @@
+module Zxcvbn
+  class Trie
+    type node = Hash[untyped, untyped]
+
+    @root: node
+
+    def initialize: () -> void
+
+    def insert: (String word, Integer rank) -> void
+
+    def search_prefixes: (String text, Integer start_pos) -> Array[[String, Integer?, Integer, Integer]]
+  end
+end

data/sig/zxcvbn.rbs

@@ -0,0 +1,10 @@
+module Zxcvbn
+  VERSION: String
+
+  DATA_PATH: Pathname
+
+  type word_list = Hash[String, Array[String]]
+  type user_inputs = Array[String]
+
+  def self.test: (String? password, ?user_inputs user_inputs, ?word_list word_lists) -> Score
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zxcvbn-ruby
 version: !ruby/object:Gem::Version
-  version: 1.2.4
+  version: 1.4.0
 platform: ruby
 authors:
 - Steve Hodgkiss
@@ -52,16 +52,34 @@ files:
 - lib/zxcvbn/score.rb
 - lib/zxcvbn/scorer.rb
 - lib/zxcvbn/tester.rb
+- lib/zxcvbn/trie.rb
 - lib/zxcvbn/version.rb
-homepage: http://github.com/envato/zxcvbn-ruby
+- sig/README.md
+- sig/zxcvbn.rbs
+- sig/zxcvbn/crack_time.rbs
+- sig/zxcvbn/data.rbs
+- sig/zxcvbn/dictionary_ranker.rbs
+- sig/zxcvbn/entropy.rbs
+- sig/zxcvbn/feedback.rbs
+- sig/zxcvbn/feedback_giver.rbs
+- sig/zxcvbn/match.rbs
+- sig/zxcvbn/math.rbs
+- sig/zxcvbn/omnimatch.rbs
+- sig/zxcvbn/password_strength.rbs
+- sig/zxcvbn/score.rbs
+- sig/zxcvbn/scorer.rbs
+- sig/zxcvbn/tester.rbs
+- sig/zxcvbn/trie.rbs
+homepage: https://github.com/envato/zxcvbn-ruby
 licenses:
 - MIT
 metadata:
+  allowed_push_host: https://rubygems.org
   bug_tracker_uri: https://github.com/envato/zxcvbn-ruby/issues
   changelog_uri: https://github.com/envato/zxcvbn-ruby/blob/HEAD/CHANGELOG.md
-  documentation_uri: https://github.com/envato/zxcvbn-ruby/blob/HEAD/README.md
+  documentation_uri: https://www.rubydoc.info/gems/zxcvbn-ruby/1.4.0
   homepage_uri: https://github.com/envato/zxcvbn-ruby
-  source_code_uri: https://github.com/envato/zxcvbn-ruby
+  source_code_uri: https://github.com/envato/zxcvbn-ruby/tree/v1.4.0
 rdoc_options: []
 require_paths:
 - lib
@@ -76,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.0
+rubygems_version: 4.0.4
 specification_version: 4
 summary: ''
 test_files: []