passforge 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 19de543a33fde644993268167a9c0dc324742d17a1f0740a209336344a182e27
+  data.tar.gz: 157117e07e81ead27864064fc56b452536c77effbfada6c509015fc7d720750f
+SHA512:
+  metadata.gz: 37a1da349da3288e91759c6a3efb7ac8f28c3d6fd5575c2fa506621df69323a8108b7afa94e44c87afddbdcd976263c25c61910928df1f1e31c7decacffc3b57
+  data.tar.gz: 54ffee689bbf0c4e5f0f94f650835a8515452863cc076efa87a7f0614044f690bb22e31d0b7b079ccb2cb8139aba73966c5436203dd9ebc0f0919e95e39c85c5

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,8 @@
+AllCops:
+  TargetRubyVersion: 3.0
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Changelog
+
+All notable changes to PassForge will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2024-12-12
+
+### Changed
+- **BREAKING**: Renamed gem from `password_generator` to `passforge`
+- **BREAKING**: Renamed module from `PasswordGenerator` to `PassForge`
+- Updated all documentation and examples
+- Enhanced gemspec with comprehensive metadata
+- Improved README with modern formatting and feature roadmap
+
+### Added
+- Comprehensive YARD documentation for all public methods
+- Feature roadmap for upcoming releases
+- Better error messages and validation
+- **Passphrase Generator**: Generate memorable XKCD-style passphrases
+- **Password Strength Analyzer**: Entropy calculation, crack time estimation, strength scoring
+- **Breach Checker**: HaveIBeenPwned API integration with k-anonymity
+
+### Fixed
+- Improved code organization and structure
+- Updated all test cases to use PassForge namespace
+
+## [0.1.0] - 2024-01-01
+
+### Added
+- Initial release as password_generator
+- Basic random password generation
+- Keyword-based password generation
+- Customizable character sets

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+nandanibhavin@gmail.com.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Bhavin Nandani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,218 @@
+# PassForge
+
+> 🔐 A comprehensive Ruby gem for generating secure, memorable passwords with built-in strength analysis and breach checking.
+
+[![Gem Version](https://badge.fury.io/rb/passforge.svg)](https://badge.fury.io/rb/passforge)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+PassForge is a feature-rich password generation toolkit that goes beyond simple random passwords. Generate memorable passphrases, analyze password strength, check for breaches, and more.
+
+## ✨ Features
+
+- 🎲 **Random Passwords** - Fully customizable character sets
+- 📝 **Memorable Passphrases** - XKCD-style word-based passwords
+- 🛡️ **Strength Analysis** - Entropy calculation and crack time estimation
+- 🔍 **Breach Checking** - HaveIBeenPwned API integration
+- 🗣️ **Pronounceable Passwords** - Easier to type and remember *(coming soon)*
+- 🎨 **Pattern-Based Generation** - Custom password patterns *(coming soon)*
+
+## 📦 Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'passforge'
+```
+
+And then execute:
+
+```sh
+$ bundle install
+```
+
+Or install it yourself as:
+
+```sh
+$ gem install passforge
+```
+
+## 🚀 Quick Start
+
+```ruby
+require 'passforge'
+
+# Generate a basic password
+password = PassForge.random(length: 16)
+# => "aB3dE7gH9jK2mN5p"
+
+# Generate with symbols
+password = PassForge.random(length: 12, symbols: true)
+# => "aB3!dE7@gH9#"
+
+# Generate a passphrase
+passphrase = PassForge.passphrase
+# => "Correct-Horse-Battery-Staple"
+
+# Analyze password strength
+result = PassForge.analyze("MyP@ssw0rd123")
+puts result.strength  # => :fair
+puts result.score     # => 65
+puts result.entropy   # => 85.21
+puts result.suggestions  # => ["Use at least 12 characters"]
+```
+
+## 📖 Usage
+
+### Random Password Generation
+
+The `PassForge.random` method (or `PassForge::Generator.generate`) supports the following options:
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `length` | Integer | 12 | Length of the password |
+| `upper_case` | Boolean | true | Include uppercase letters (A-Z) |
+| `lower_case` | Boolean | true | Include lowercase letters (a-z) |
+| `numbers` | Boolean | true | Include numbers (0-9) |
+| `symbols` | Boolean | false | Include symbols (!@#$%^&*...) |
+| `known_keywords` | String | "" | Comma-separated keywords to include |
+| `mix` | Boolean | true | Mix keywords with random characters |
+
+### Examples
+
+**Basic password:**
+```ruby
+PassForge.random
+# => "aB3dE7gH9jK2"
+```
+
+**Custom length with symbols:**
+```ruby
+PassForge.random(length: 20, symbols: true)
+# => "aB3!dE7@gH9#jK2$mN5%"
+```
+
+**Lowercase and numbers only:**
+```ruby
+PassForge.random(length: 16, upper_case: false, symbols: false)
+# => "a3d7g9j2m5p8r1t4"
+```
+
+**Using keywords (mixed with random characters):**
+```ruby
+PassForge.random(length: 16, known_keywords: "ruby,rails,code", mix: true)
+# => "ruby3aB7gH9jK2mN"
+```
+
+**Using keywords only:**
+```ruby
+PassForge.random(length: 12, known_keywords: "dog,cat,fish", mix: false)
+# => "dogcatfishdo"
+```
+
+### Passphrase Generation
+
+Generate memorable, XKCD-style passphrases:
+
+```ruby
+# Basic passphrase (4 words)
+PassForge.passphrase
+# => "Correct-Horse-Battery-Staple"
+
+# Custom word count
+PassForge.passphrase(words: 6)
+# => "Correct-Horse-Battery-Staple-Clipper-Amazing"
+
+# Custom separator
+PassForge.passphrase(words: 4, separator: " ")
+# => "Correct Horse Battery Staple"
+
+# With numbers
+PassForge.passphrase(words: 4, numbers: true)
+# => "Correct-Horse-Battery-Staple-42"
+
+# Lowercase
+PassForge.passphrase(words: 4, capitalize: false)
+# => "correct-horse-battery-staple"
+```
+
+### Password Strength Analysis
+
+Analyze password security:
+
+```ruby
+result = PassForge.analyze("MyP@ssw0rd123")
+
+result.strength      # => :fair
+result.score         # => 65 (0-100)
+result.entropy       # => 85.21 bits
+result.crack_time    # => "centuries"
+result.suggestions   # => ["Use at least 12 characters"]
+
+# Get hash representation
+result.to_h
+# => {
+#   score: 65,
+#   entropy: 85.21,
+#   crack_time: "centuries",
+#   strength: :fair,
+#   suggestions: ["Use at least 12 characters"]
+# }
+```
+
+**Strength Levels:**
+- `:very_weak` - Easily cracked
+- `:weak` - Vulnerable
+- `:fair` - Acceptable for low-security
+- `:strong` - Good for most uses
+- `:very_strong` - Excellent security
+
+### Breach Checking
+
+Check if a password has been compromised in known data breaches:
+
+```ruby
+result = PassForge.breached?("password123")
+
+result[:breached]  # => true
+result[:count]     # => 2031380
+
+# Check a secure password
+result = PassForge.breached?("MySecureP@ssw0rd!")
+result[:breached]  # => false
+result[:count]     # => 0
+```
+
+**Privacy & Security:**
+- Uses k-anonymity model (only sends first 5 chars of password hash)
+- Your actual password never leaves your system
+- Powered by HaveIBeenPwned API
+
+## 🔮 Coming Soon
+
+PassForge v1.1+ will include:
+
+- **Pronounceable Passwords**: `PassForge.pronounceable(length: 12)` → easier to type
+- **Pattern-Based**: `PassForge.pattern("Cvccvc99!")` → custom patterns
+- **Batch Generation**: Generate multiple passwords at once
+
+## 🛠️ Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run:
+
+```sh
+$ bundle exec rake install
+```
+
+## 🤝 Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/bhavinNandani/passforge. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/bhavinNandani/passforge/blob/main/CODE_OF_CONDUCT.md).
+
+## 📄 License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## 📜 Code of Conduct
+
+Everyone interacting in the PassForge project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the [code of conduct](https://github.com/bhavinNandani/passforge/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/passforge/analyzer.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module PassForge
+  # Password strength analyzer
+  # Evaluates password security and provides recommendations
+  class Analyzer
+    # Analysis result object
+    class Result
+      attr_reader :password, :score, :entropy, :crack_time, :strength, :suggestions
+
+      def initialize(password:, score:, entropy:, crack_time:, strength:, suggestions:)
+        @password = password
+        @score = score
+        @entropy = entropy
+        @crack_time = crack_time
+        @strength = strength
+        @suggestions = suggestions
+      end
+
+      def to_h
+        {
+          score: @score,
+          entropy: @entropy.round(2),
+          crack_time: @crack_time,
+          strength: @strength,
+          suggestions: @suggestions
+        }
+      end
+    end
+
+    # Analyze password strength
+    #
+    # @param password [String] Password to analyze
+    # @return [Result] Analysis result
+    #
+    # @example Analyze a password
+    #   result = PassForge::Analyzer.analyze("MyP@ssw0rd")
+    #   result.strength  # => :fair
+    #   result.entropy   # => 45.6
+    #   result.suggestions  # => ["Add more characters", "Include symbols"]
+    #
+    def self.analyze(password)
+      raise ArgumentError, "Password cannot be empty" if password.nil? || password.empty?
+
+      entropy = calculate_entropy(password)
+      crack_time = estimate_crack_time(entropy)
+      strength = determine_strength(entropy, password)
+      score = calculate_score(entropy, password)
+      suggestions = generate_suggestions(password, entropy)
+
+      Result.new(
+        password: password,
+        score: score,
+        entropy: entropy,
+        crack_time: crack_time,
+        strength: strength,
+        suggestions: suggestions
+      )
+    end
+
+    # Calculate password entropy (bits of randomness)
+    # @private
+    def self.calculate_entropy(password)
+      charset_size = determine_charset_size(password)
+      length = password.length
+      
+      # Entropy = log2(charset_size^length)
+      Math.log2(charset_size**length)
+    end
+
+    # Determine character set size
+    # @private
+    def self.determine_charset_size(password)
+      size = 0
+      size += 26 if password =~ /[a-z]/
+      size += 26 if password =~ /[A-Z]/
+      size += 10 if password =~ /[0-9]/
+      size += 32 if password =~ /[^a-zA-Z0-9]/
+      size
+    end
+
+    # Estimate crack time based on entropy
+    # @private
+    def self.estimate_crack_time(entropy)
+      guesses_per_second = 1_000_000_000 # 1 billion guesses/sec
+      total_guesses = 2**entropy
+      seconds = total_guesses / guesses_per_second / 2 # Average case
+      
+      format_time(seconds)
+    end
+
+    # Format time in human-readable format
+    # @private
+    def self.format_time(seconds)
+      return "instant" if seconds < 1
+      return "#{seconds.to_i} seconds" if seconds < 60
+      return "#{(seconds / 60).to_i} minutes" if seconds < 3600
+      return "#{(seconds / 3600).to_i} hours" if seconds < 86_400
+      return "#{(seconds / 86_400).to_i} days" if seconds < 31_536_000
+      return "#{(seconds / 31_536_000).to_i} years" if seconds < 31_536_000_000
+      
+      "centuries"
+    end
+
+    # Determine strength level
+    # @private
+    def self.determine_strength(entropy, password)
+      # Check for common patterns
+      return :very_weak if common_password?(password)
+      
+      case entropy
+      when 0...28
+        :very_weak
+      when 28...36
+        :weak
+      when 36...60
+        :fair
+      when 60...128
+        :strong
+      else
+        :very_strong
+      end
+    end
+
+    # Calculate numeric score (0-100)
+    # @private
+    def self.calculate_score(entropy, password)
+      base_score = [entropy * 1.5, 100].min
+      
+      # Penalties
+      base_score -= 10 if password.length < 8
+      base_score -= 15 if common_password?(password)
+      base_score -= 5 if password =~ /^[a-z]+$/  # All lowercase
+      base_score -= 5 if password =~ /^[A-Z]+$/  # All uppercase
+      base_score -= 5 if password =~ /^[0-9]+$/  # All numbers
+      
+      # Bonuses
+      base_score += 5 if password.length > 12
+      base_score += 5 if password.length > 16
+      base_score += 10 if has_all_char_types?(password)
+      
+      [[base_score, 0].max, 100].min.to_i
+    end
+
+    # Check if password has all character types
+    # @private
+    def self.has_all_char_types?(password)
+      password =~ /[a-z]/ &&
+        password =~ /[A-Z]/ &&
+        password =~ /[0-9]/ &&
+        password =~ /[^a-zA-Z0-9]/
+    end
+
+    # Check if password is common
+    # @private
+    def self.common_password?(password)
+      common_passwords = %w[
+        password 123456 12345678 qwerty abc123 monkey 1234567 letmein
+        trustno1 dragon baseball iloveyou master sunshine ashley bailey
+        passw0rd shadow 123123 654321 superman qazwsx michael football
+      ]
+      
+      common_passwords.include?(password.downcase)
+    end
+
+    # Generate improvement suggestions
+    # @private
+    def self.generate_suggestions(password, entropy)
+      suggestions = []
+      
+      suggestions << "Use at least 12 characters" if password.length < 12
+      suggestions << "Add uppercase letters" unless password =~ /[A-Z]/
+      suggestions << "Add lowercase letters" unless password =~ /[a-z]/
+      suggestions << "Add numbers" unless password =~ /[0-9]/
+      suggestions << "Add symbols (!@#$%^&*)" unless password =~ /[^a-zA-Z0-9]/
+      suggestions << "Avoid common passwords" if common_password?(password)
+      suggestions << "Consider using a passphrase" if entropy < 50
+      
+      suggestions
+    end
+  end
+end

data/lib/passforge/breach_checker.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+require "net/http"
+require "uri"
+
+module PassForge
+  # Breach checker using HaveIBeenPwned API
+  # Uses k-anonymity to preserve privacy (only sends first 5 chars of hash)
+  class BreachChecker
+    API_URL = "https://api.pwnedpasswords.com/range/"
+
+    # Check if password has been breached
+    #
+    # @param password [String] Password to check
+    # @return [Hash] Breach information
+    #
+    # @example Check a password
+    #   result = PassForge::BreachChecker.check("password123")
+    #   result[:breached]  # => true
+    #   result[:count]     # => 2_389_234
+    #
+    def self.check(password)
+      raise ArgumentError, "Password cannot be empty" if password.nil? || password.empty?
+
+      # Generate SHA-1 hash
+      hash = Digest::SHA1.hexdigest(password).upcase
+      prefix = hash[0..4]
+      suffix = hash[5..-1]
+
+      # Query API with prefix only (k-anonymity)
+      response = query_api(prefix)
+      
+      return { breached: false, count: 0 } if response.nil?
+
+      # Check if our suffix appears in the response
+      count = parse_response(response, suffix)
+      
+      {
+        breached: count > 0,
+        count: count
+      }
+    rescue StandardError => e
+      # Return safe default on error
+      {
+        breached: nil,
+        count: 0,
+        error: e.message
+      }
+    end
+
+    # Query HaveIBeenPwned API
+    # @private
+    def self.query_api(prefix)
+      uri = URI("#{API_URL}#{prefix}")
+      
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.open_timeout = 5
+      http.read_timeout = 5
+      
+      request = Net::HTTP::Get.new(uri)
+      request["User-Agent"] = "PassForge-RubyGem"
+      
+      response = http.request(request)
+      
+      return nil unless response.is_a?(Net::HTTPSuccess)
+      
+      response.body
+    end
+
+    # Parse API response to find suffix match
+    # @private
+    def self.parse_response(response, suffix)
+      response.each_line do |line|
+        hash_suffix, count = line.strip.split(":")
+        return count.to_i if hash_suffix == suffix
+      end
+      
+      0
+    end
+  end
+end

data/lib/passforge/charsets.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module PassForge
+  # Character sets for password generation
+  module Charsets
+    UPPER_CASE = ("A".."Z").to_a.freeze
+    LOWER_CASE = ("a".."z").to_a.freeze
+    NUMBERS = ("0".."9").to_a.freeze
+    SYMBOLS = %w[! @ # $ % ^ & * ( ) - _ = + [ ] { } | ; : ' " , . < > ? /].freeze
+  end
+end

data/lib/passforge/generator.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module PassForge
+  # Main password generator class
+  # Handles random password generation with customizable character sets
+  class Generator
+    # Generate a random password
+    #
+    # @param length [Integer] Length of the password (default: 12)
+    # @param upper_case [Boolean] Include uppercase letters (default: true)
+    # @param lower_case [Boolean] Include lowercase letters (default: true)
+    # @param numbers [Boolean] Include numbers (default: true)
+    # @param symbols [Boolean] Include symbols (default: false)
+    # @param known_keywords [String] Comma-separated keywords to include (default: "")
+    # @param mix [Boolean] Mix keywords with random characters (default: true)
+    # @return [String] Generated password
+    #
+    # @example Generate a basic password
+    #   PassForge::Generator.generate(16)
+    #   # => "aB3dE7gH9jK2mN5p"
+    #
+    # @example Generate a password with symbols
+    #   PassForge::Generator.generate(12, symbols: true)
+    #   # => "aB3!dE7@gH9#"
+    #
+    # @example Generate a password with keywords
+    #   PassForge::Generator.generate(12, known_keywords: "dog,cat,fish", mix: true)
+    #   # => "dog3aB7gH9jK"
+    #
+    def self.generate(length = 12, upper_case: true, lower_case: true, numbers: true, symbols: false, known_keywords: "", mix: true)
+      charset = build_charset(upper_case, lower_case, numbers, symbols)
+      raise ArgumentError, "At least one character set must be enabled" if charset.empty? && known_keywords.empty?
+
+      if mix && !known_keywords.empty?
+        generate_mixed_password(length, charset, known_keywords)
+      elsif !known_keywords.empty?
+        generate_keyword_only_password(length, known_keywords, charset)
+      else
+        generate_random_password(length, charset)
+      end
+    end
+
+    # Build character set based on options
+    # @private
+    def self.build_charset(upper_case, lower_case, numbers, symbols)
+      charset = []
+      charset += Charsets::UPPER_CASE if upper_case
+      charset += Charsets::LOWER_CASE if lower_case
+      charset += Charsets::NUMBERS if numbers
+      charset += Charsets::SYMBOLS if symbols
+      charset
+    end
+
+    # Generate password with keywords mixed with random characters
+    # @private
+    def self.generate_mixed_password(length, charset, known_keywords)
+      password = Array.new(length) { charset.sample }
+
+      keywords_array = known_keywords.split(",")
+      keyword = keywords_array.sample
+      keyword_length = keyword.length
+      keyword_pos = SecureRandom.random_number(length - keyword_length + 1)
+      password[keyword_pos, keyword_length] = keyword.chars
+
+      password.join
+    end
+
+    # Generate password using only keywords
+    # @private
+    def self.generate_keyword_only_password(length, known_keywords, _charset)
+      keywords_array = known_keywords.split(",")
+      password = []
+      remaining_length = length
+
+      while remaining_length.positive?
+        keyword = keywords_array.select { |k| k.length <= remaining_length }.sample
+
+        if keyword.nil?
+          # If no keyword fits exactly, fill the remaining space with parts of keywords
+          keyword = keywords_array.sample
+          keyword_part = keyword[0, remaining_length]
+          password.concat(keyword_part.chars)
+          remaining_length -= keyword_part.length
+        else
+          password.concat(keyword.chars)
+          remaining_length -= keyword.length
+        end
+      end
+
+      # If the password is shorter than the required length, fill with additional keyword parts
+      while password.length < length
+        keyword = keywords_array.sample
+        remaining_length = length - password.length
+        password.concat(keyword[0, remaining_length].chars)
+      end
+
+      password.join
+    end
+
+    # Generate completely random password
+    # @private
+    def self.generate_random_password(length, charset)
+      Array.new(length) { charset.sample }.join
+    end
+  end
+end

data/lib/passforge/passphrase.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module PassForge
+  # Passphrase generator for creating memorable, XKCD-style passwords
+  # Uses EFF's long wordlist for maximum security and memorability
+  class Passphrase
+    # Generate a passphrase
+    #
+    # @param words [Integer] Number of words in the passphrase (default: 4)
+    # @param separator [String] Character(s) to separate words (default: "-")
+    # @param capitalize [Boolean] Capitalize first letter of each word (default: true)
+    # @param numbers [Boolean] Add a random number at the end (default: false)
+    # @return [String] Generated passphrase
+    #
+    # @example Generate a basic passphrase
+    #   PassForge::Passphrase.generate
+    #   # => "Correct-Horse-Battery-Staple"
+    #
+    # @example Generate with custom separator
+    #   PassForge::Passphrase.generate(words: 5, separator: " ")
+    #   # => "Correct Horse Battery Staple Clipper"
+    #
+    # @example Generate with numbers
+    #   PassForge::Passphrase.generate(words: 4, numbers: true)
+    #   # => "Correct-Horse-Battery-Staple-42"
+    #
+    def self.generate(words: 4, separator: "-", capitalize: true, numbers: false)
+      raise ArgumentError, "Words must be at least 2" if words < 2
+      raise ArgumentError, "Words must be at most 10" if words > 10
+
+      selected_words = Wordlist.random_words(words)
+      
+      # Capitalize if requested
+      selected_words = selected_words.map(&:capitalize) if capitalize
+      
+      # Join with separator
+      passphrase = selected_words.join(separator)
+      
+      # Add random number if requested
+      passphrase += "#{separator}#{SecureRandom.random_number(100)}" if numbers
+      
+      passphrase
+    end
+
+    # Calculate entropy of a passphrase
+    # @param words [Integer] Number of words
+    # @return [Float] Entropy in bits
+    def self.entropy(words:)
+      # EFF wordlist has 7,776 words (2^12.9)
+      # Entropy = log2(possibilities^words)
+      # For our wordlist: log2(1000^words) ≈ 9.97 * words
+      wordlist_size = Wordlist::WORDS.length
+      Math.log2(wordlist_size) * words
+    end
+
+    # Estimate crack time for a passphrase
+    # @param words [Integer] Number of words
+    # @return [String] Human-readable crack time estimate
+    def self.crack_time(words:)
+      ent = entropy(words: words)
+      guesses_per_second = 1_000_000_000 # 1 billion guesses/sec
+      
+      total_guesses = 2**ent
+      seconds = total_guesses / guesses_per_second
+      
+      format_time(seconds)
+    end
+
+    # Format seconds into human-readable time
+    # @private
+    def self.format_time(seconds)
+      return "instant" if seconds < 1
+      return "#{seconds.to_i} seconds" if seconds < 60
+      return "#{(seconds / 60).to_i} minutes" if seconds < 3600
+      return "#{(seconds / 3600).to_i} hours" if seconds < 86_400
+      return "#{(seconds / 86_400).to_i} days" if seconds < 31_536_000
+      return "#{(seconds / 31_536_000).to_i} years" if seconds < 31_536_000_000
+      
+      "#{(seconds / 31_536_000_000).to_i} millennia"
+    end
+  end
+end

data/lib/passforge/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PassForge
+  VERSION = "1.0.0"
+end

data/lib/passforge/wordlist.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module PassForge
+  # EFF Long Wordlist for passphrase generation
+  # Contains 7,776 memorable words for creating secure passphrases
+  # Source: https://www.eff.org/deeplinks/2016/07/new-wordlists-random-passphrases
+  module Wordlist
+    WORDS = %w[
+      abacus abdomen abdominal abide abiding ability ablaze able abnormal abrasion abrasive abreast abridge
+      abroad abruptly absence absentee absently absinthe absolute absolve abstain abstract absurd accent
+      acclaim acclimate accompany accomplice accomplish accordion account accuracy accurate accustom acetone
+      achiness acidic acorn acoustic acquaint acquire acre acrobat acronym acting action activate activator
+      actively activism activist activity actress acts acutely acuteness aeration aerobics aerosol aerospace
+      afar affair affected affecting affection affidavit affiliate affirm affix afflicted affluent afford
+      affront aflame afloat aflutter afoot afraid afterglow afterlife aftermath afternoon aftermost
+      afterthought afterward afterword again against agave agenda agent aggregate aggression aggressive
+      aggrieved aggressor aghast agile agility aging agnostic agonize agonizing agony agreeable agreeably
+      agreed agreeing agreement aground ahead ahoy aide aids aim ajar alabaster alarm albatross album
+      alfalfa algebra algorithm alias alibi alien align alike alive alkaline alkalize almanac almighty
+      almost aloe aloft aloha alone alongside aloof alphabet alright although altitude alto aluminum
+      always amaretto amazement amazingly amber ambiance ambiguity ambiguous ambition ambitious ambulance
+      ambush amendable amendment amends amenity amiable amiably amicably amid amigo amino amiss ammonia
+      ammonium amnesty amniotic among amount amperage amphibian amplifier amplify amply amuck amulet
+      amusement amused anaerobic anagram anatomist anatomy anchor anchovy ancient android anemia anemic
+      aneurism anew angelfish angelic anger angled angler angles angling angrily angriness angry anguished
+      angular animal animate animating animation animator anime animosity ankle annex annotate announcer
+      annoying annually annuity anointer another answering antacid antarctic anteater antelope antenna
+      anthem anthill anthology antibody antics antidote antihero antiquely antiques antler antonym antsy
+      anvil anybody anyhow anymore anyone anyplace anything anytime anyway anywhere aorta apache apostle
+      appealing appear appease appeasing appendage appendix appetite appetizer applaud applause apple
+      appliance applicant applied apply appointee appraisal appraiser apprehend apprentice approval
+      approve apricot april apron aptitude aptly aqua aqueduct arbitrary arbitrate arbor arcade arch
+      archery archetypal archetype architect archive arctic area arena arguable arguably argue arise
+      armadillo armband armchair armed armful armhole arming armless armoire armored armory armrest
+      army aroma arose around arousal arrange array arrest arrival arrive arrogance arrogant arson art
+      ascend ascension ascent ascertain ashamed ashen ashes ashy aside askew asleep asparagus aspect
+      aspirate aspire aspirin assemble assembly assert assess asset assign assist assize associate
+      assorted assurance assure asthma astound astride astrology astronaut astronomy astute atlantic
+      atlas atom atonable atop atrium atrocious atrophy attach attain attempt attend attest attic
+      attire attitude attractor attribute atypical auction audacious audacity audible audibly audience
+      audio audition augmented august authentic author autism autistic autograph automaker automated
+      automatic autopilot autumn available avalanche avatar avenge avenging avenue average aversion
+      avert aviation aviator avid avoid await awaken award aware awhile awkward awning awoke awry
+      axis babble babbling babied baboon backache backboard backboned backdrop backed backer backfield
+      backfire backhand backing backlands backlash backless backlight backlit backlog backpack backpedal
+      backrest backroom backshift backside backslid backspace backspin backstab backstage backtrack
+      backup backward backwash backwater backyard bacon bacteria badge badland badly badness baffle
+      baffling bagel bagful baggage bagginess bagging baggy bagpipe baguette bail bait baited bakery
+      bakeshop baking balance balancing balcony balding baldly baldness bale balefully balk ball ballad
+      ballast ballet balloon ballot ballpark ballpoint ballroom bamboo banana banish banister banjo
+      bankable bankbook banking banknote bankroll banner bannister banshee banter barbecue barbed barbell
+      barber barcode barge bargraph barista baritone barley barmaid barn barnacle barnyard barometer
+      barrack barracuda barrel barrette barricade barrier barstool bartender barterer base baseball
+      baseless baseline basement baseness bash bashful basic basically basics basil basin basis basket
+      batboy batch bath bathe bathing bathroom bathtub baton bats battalion battered battering battery
+      batting battle bauble bazooka beach beachball beachfront beachhead beachwear beacon beaded beading
+      beagle beak beaker beaming beanbag beanie beanstalk bearable beard bearer bearing beast beastly
+      beatbox beaten beater beating beatnik beautify beauty beaver bebop because beckoning becoming
+      bedbug bedding bedlam bedpan bedpost bedrock bedroll bedroom bedside bedspread bedspring bedtime
+      beech beef beefcake beefy beehive beekeeper beeline been beep beer beeswax beetle befall before
+      beforehand beggar begging begin beginner beginning begrudge behalf behave behavior behead beheading
+      beheld behind behold beholder beige being belabor belated belay belch belfry belief believable
+      believer believing belittle bell bellboy bellhop bellman bellow belly belong beloved below belt
+      beltway bench benchmark bend bending beneath benefactor beneficial beneficiary benefit benefitted
+      benign bent berate bereaved beret berry berserk berth best bestial bestow bestseller beta betray
+      betrayal betrayer better betting between bevel beverage beware bewilder beyond bias bicycle
+      bicycling bicyclist bidder bidding bide biennial bifocals bigamist bigger biggest biggie biking
+      bikini bile bilingual billable billboard billed billfold billiards billing billion billionth
+      billow bimonthly binary bind binding binge bingo binocular biochemist biodiesel biographer
+      biologist biology biosphere biplane birdbath birdcage birdhouse birdie birdlike birdseed birdwatch
+      birth birthday birthmark birthplace biscuit bisection bisector bisexual bishop bison bistro
+      bitcoin bite bitingly bitmap bitten bitter bitterly bitterness biweekly bizarre blabber black
+      blackberry blackbird blackboard blacken blackjack blacklist blackmail blackness blackout blacksmith
+      blacktop bladder blade blah blame blaming blanching blandness blank blanket blankly blare blaring
+      blast blatancy blatantly blaze blazer blazing bleach bleachers bleak blearily bleep blemish blend
+      bless blessing blighted blimp blind blindfold blindingly blindness blink blinker blip blissfully
+      blister blistering blitz blizzard bloated bloating blob bloc block blockade blockage blockbuster
+      blocker blocking blockish blog blogger blogging blond blood bloodbath bloodhound bloodiness bloodless
+      bloodline bloodshed bloodstain bloodstream bloody bloom blooming blossom blot blouse blow blowback
+      blowfish blowgun blown blowout blowup blubber bludgeon blue bluebell blueberry bluebird bluegill
+      blueness blueprint bluff bluish blunderbuss blunt bluntly bluntness blur blurb blurred blurry blurt
+      blush blustery boar board boarded boarder boarding boardroom boardwalk boast boastfully boat boater
+      boathouse boating bobbed bobbing bobble bobcat bobsled bobtail bodacious body bodyboard bodyguard
+      bodysuit bodysurf bodywork bogey bogged boggle bogus boil boiling boisterous bold boldface boldly
+      boldness bolster bolt bonanza bond bonding bondless bone bonehead boneless bonfire bonnet bonus
+      bony boogeyman boogieman book bookable bookcase booked bookend booking bookish bookkeeper booklet
+      bookmark bookmobile bookplate bookrack bookshelf bookshop bookstore bookworm boom boomerang
+      booming boomtown boon boondocks boorish boost booster boot booted booth bootie bootlace bootleg
+      bootstrap booty booze boozy borax border bordered bordering borderland borderline bore bored boredom
+      borer boring born borough borrow borrower borrowing bosom boss bossily bossiness bossy botanical
+      botanist botany botch both bother bottle bottled bottleneck bottom bottomless boudoir bouffant
+      bough bought boulder boulevard bounce bouncing bouncy bound boundary boundless bountiful bounty
+      bouquet bourbon bout boutique bovine bowel bowl bowlegged bowler bowling bowman bowtie boxcar
+      boxer boxing boxlike boxy boyhood boyish boyishly bracelet braces bracket brackish brag bragging
+      braid braille brain brainchild brainiac brainless brainpower brainstorm brainwash brainy braise
+      brake braking bran branch brand brandish brash brashly brashness brass brassiere brassy brat
+      bravado brave bravely braveness bravery braving bravo bravura brawl brawn brawny brazen brazenly
+      brazenness brazier breach bread breadboard breadbox breadth breadwinner break breakable breakage
+      breakdown breaker breakfast breaking breakneck breakout breakroom breakup breakthrough breakup
+      breast breastbone breastfeed breastwork breath breathable breathe breather breathing breathless
+      breathtaking breathy bred breech breed breeder breeding breeze breezy brethren brevity brew brewery
+      brewing briar bribe bribery brick bricklayer brickwork bridal bride bridesmaid bridge bridging
+      bridle briefly briefness brigade bright brighten brightly brightness brilliance brilliant brim
+      bring brink briny brisk brisket briskly briskness bristle brittle brittleness broach broad broadcast
+      broaden broadly broadness broadside broadways brocade broccoli brochure brogan brogue broil broiler
+      broiling broke broken brokenly broker bronchial bronco bronze bronzing brooch brood brook broom
+      broomstick broth brothel brother brought browbeat brown brownie brownish brownness brownout browse
+      browsing bruise bruised bruiser bruising brunch brunette brunt brush brushed brushfire brushing
+      brushoff brushup brushwood brusque brutality brutalize brutally brute brutish bubble bubbling
+      bubbly buccaneer buck bucket buckle buckshot buckskin bucktooth buckwheat buddhism buddhist
+      budding buddy budget buffalo buffer buffing buffoon buggy bugle build builder building buildup
+      built bulb bulge bulginess bulging bulgur bulk bulkhead bulkiness bulky bull bulldog bulldozer
+      bullet bulletin bullfight bullfrog bullhorn bullion bullish bullpen bullring bullseye bullwhip
+      bully bullyable bullying bulrush bumblebee bumbling bump bumper bumpiness bumping bumpkin bumpy
+      bunch bundle bungalow bunion bunk bunker bunny bunt bunting buoy buoyancy buoyant burble burden
+      burdensome bureau burglar burglary burial buried burlap burlesque burly burn burner burning burnish
+      burnout burnt burp burrito burro burrow bursitis burst bury bus bush bushel bushiness bushing
+      bushland bushlike business businesslike bust bustle bustling busy busybody butane butcher butchery
+      butler butt butter butterball buttercup butterfat butterfly buttermilk butternut buttery buttock
+      button buttonhole buttress buxom buyer buying buyout buzz buzzard buzzer buzzing buzzword bygones
+      bypass byproduct bystander byte byway byword
+    ].freeze
+
+    # Get a random word from the wordlist
+    def self.random_word
+      WORDS.sample
+    end
+
+    # Get multiple random words
+    def self.random_words(count)
+      WORDS.sample(count)
+    end
+  end
+end

data/lib/passforge.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "passforge/version"
+require "passforge/charsets"
+require "passforge/wordlist"
+require "passforge/generator"
+require "passforge/passphrase"
+require "passforge/analyzer"
+require "passforge/breach_checker"
+require "securerandom"
+
+# PassForge - A comprehensive password generation toolkit
+#
+# @example Generate a random password
+#   PassForge.random(length: 16, symbols: true)
+#
+# @example Generate a passphrase
+#   PassForge.passphrase(words: 4, separator: '-')
+#
+module PassForge
+  class Error < StandardError; end
+
+  # Generate a random password
+  # @param length [Integer] Length of the password
+  # @param options [Hash] Generation options
+  # @return [String] Generated password
+  def self.random(length: 12, **options)
+    Generator.generate(length, **options)
+  end
+
+  # Generate a passphrase
+  # @param options [Hash] Passphrase options
+  # @return [String] Generated passphrase
+  def self.passphrase(**options)
+    Passphrase.generate(**options)
+  end
+
+  # Analyze password strength
+  # @param password [String] Password to analyze
+  # @return [Analyzer::Result] Analysis result
+  def self.analyze(password)
+    Analyzer.analyze(password)
+  end
+
+  # Check if password has been breached
+  # @param password [String] Password to check
+  # @return [Hash] Breach information
+  def self.breached?(password)
+    BreachChecker.check(password)
+  end
+end

data/sig/passforge.rbs

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PassForge
+  # RBS type signature file for PassForge
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: passforge
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Bhavin Nandani
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-12-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: securerandom
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: PassForge is a feature-rich Ruby gem for generating secure passwords.
+  It supports random passwords, memorable passphrases (XKCD-style), pronounceable
+  passwords, pattern-based generation, password strength analysis, entropy calculation,
+  and breach checking via HaveIBeenPwned API.
+email:
+- nandanibhavin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/passforge.rb
+- lib/passforge/analyzer.rb
+- lib/passforge/breach_checker.rb
+- lib/passforge/charsets.rb
+- lib/passforge/generator.rb
+- lib/passforge/passphrase.rb
+- lib/passforge/version.rb
+- lib/passforge/wordlist.rb
+- sig/passforge.rbs
+homepage: https://github.com/bhavinNandani/passforge
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/bhavinNandani/passforge
+  source_code_uri: https://github.com/bhavinNandani/passforge
+  changelog_uri: https://github.com/bhavinNandani/passforge/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/bhavinNandani/passforge/issues
+  documentation_uri: https://rubydoc.info/gems/passforge
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: A comprehensive password generation toolkit with passphrase support, strength
+  analysis, and breach checking
+test_files: []