passforge 1.0.0 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19de543a33fde644993268167a9c0dc324742d17a1f0740a209336344a182e27
-  data.tar.gz: 157117e07e81ead27864064fc56b452536c77effbfada6c509015fc7d720750f
+  metadata.gz: 4a1d4c2fc2135b7b729e8e6768463070cbb6fe4e02c3b45b36bd3ee4f8697ae4
+  data.tar.gz: d6acd23b744bcf275093dfec5022451b1c34039e002838e47eb1883310e2201f
 SHA512:
-  metadata.gz: 37a1da349da3288e91759c6a3efb7ac8f28c3d6fd5575c2fa506621df69323a8108b7afa94e44c87afddbdcd976263c25c61910928df1f1e31c7decacffc3b57
-  data.tar.gz: 54ffee689bbf0c4e5f0f94f650835a8515452863cc076efa87a7f0614044f690bb22e31d0b7b079ccb2cb8139aba73966c5436203dd9ebc0f0919e95e39c85c5
+  metadata.gz: f3e7a72036d5607b20306a6067487e606ca47774ee97102a778778f3c08c962dd56c17417bb17b8f188f8689bb468561f5dfa1e6686f19bc8974ad1864db7d08
+  data.tar.gz: ebebbb78520b87792020174054e16d376977832d72c18c3d30c3c0f6e320eb09e5f462fc40c0017086d3d64e04dabe07e3fba86b11e6703b0440f596b17889d7

data/README.md

@@ -13,8 +13,9 @@ PassForge is a feature-rich password generation toolkit that goes beyond simple
 - 📝 **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)*
+- 🗣️ **Pronounceable Passwords** - Easier to type and remember
+- 🎨 **Pattern-Based Generation** - Custom password patterns
+- 📦 **Batch Generation** - Generate multiple passwords at once
 
 ## 📦 Installation
 
@@ -187,13 +188,92 @@ result[:count]     # => 0
 - Your actual password never leaves your system
 - Powered by HaveIBeenPwned API
 
+### Pronounceable Passwords
+
+Generate passwords that are easier to type and remember:
+
+```ruby
+# Basic pronounceable password
+PassForge.pronounceable
+# => "Fabiroxotu86"
+
+# Custom length
+PassForge.pronounceable(length: 16)
+# => "Tuvaxo8qibale9f#"
+
+# Without capitalization
+PassForge.pronounceable(capitalize: false)
+# => "fabiroxotu86"
+
+# Without numbers
+PassForge.pronounceable(numbers: false)
+# => "Fabiroxotu"
+
+# With symbols
+PassForge.pronounceable(symbols: true)
+# => "Fabiroxotu86#"
+```
+
+### Pattern-Based Generation
+
+Create passwords from custom patterns:
+
+```ruby
+# Basic pattern
+PassForge.pattern("Cvccvc99!")
+# => "Piceej98{"
+
+# Pattern characters:
+# C = uppercase letter
+# c = lowercase letter  
+# v = lowercase vowel
+# V = uppercase vowel
+# 9 = digit
+# ! = symbol
+# Any other = literal
+
+# Complex pattern
+PassForge.pattern("CC-vv-99-!!")
+# => "XY-ae-42-@#"
+
+# With literal characters
+PassForge.pattern("Pass-Cvcc-9999")
+# => "Pass-Rabi-5678"
+```
+
+### Batch Generation
+
+Generate multiple passwords at once:
+
+```ruby
+# Generate 10 random passwords
+passwords = PassForge.batch(10, :random, length: 16)
+# => ["aB3dE7gH9jK2mN5p", "xY9zA2bC4dE6fG8h", ...]
+
+# Generate 5 passphrases
+passwords = PassForge.batch(5, :passphrase, words: 4)
+# => ["Correct-Horse-Battery-Staple", ...]
+
+# Generate pronounceable passwords
+passwords = PassForge.batch(10, :pronounceable, length: 12)
+
+# Generate from pattern
+passwords = PassForge.batch(10, :pattern, pattern: "Cvccvc99!")
+
+# Export to CSV
+csv = PassForge::Batch.to_csv(passwords)
+
+# Export to JSON
+json = PassForge::Batch.to_json(passwords)
+```
+
 ## 🔮 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
+- **CLI Tool**: Command-line interface for quick password generation
+- **Browser Extension**: Chrome/Firefox extension
+- **Password History**: Save generated passwords locally (encrypted)
 
 ## 🛠️ Development
 

data/lib/passforge/batch.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module PassForge
+  # Batch password generator
+  # Generate multiple passwords at once
+  class Batch
+    # Generate multiple passwords
+    #
+    # @param count [Integer] Number of passwords to generate
+    # @param type [Symbol] Type of password (:random, :passphrase, :pronounceable, :pattern)
+    # @param options [Hash] Options for the generator
+    # @return [Array<String>] Array of generated passwords
+    #
+    # @example Generate 10 random passwords
+    #   PassForge::Batch.generate(10, :random, length: 16)
+    #   # => ["aB3dE7gH9jK2mN5p", "xY9zA2bC4dE6fG8h", ...]
+    #
+    def self.generate(count, type = :random, **options)
+      raise ArgumentError, "Count must be at least 1" if count < 1
+      raise ArgumentError, "Count must be at most 1000" if count > 1000
+      
+      passwords = []
+      
+      count.times do
+        password = case type
+                   when :random
+                     length = options.delete(:length) || 12
+                     Generator.generate(length, **options)
+                   when :passphrase
+                     Passphrase.generate(**options)
+                   when :pronounceable
+                     Pronounceable.generate(**options)
+                   when :pattern
+                     Pattern.generate(options[:pattern] || "Cvccvc99!")
+                   else
+                     raise ArgumentError, "Unknown type: #{type}"
+                   end
+        
+        passwords << password
+      end
+      
+      passwords
+    end
+    
+    # Export passwords to CSV format
+    # @param passwords [Array<String>] Passwords to export
+    # @return [String] CSV string
+    def self.to_csv(passwords)
+      "Password\n" + passwords.join("\n")
+    end
+    
+    # Export passwords to JSON format
+    # @param passwords [Array<String>] Passwords to export
+    # @return [String] JSON string
+    def self.to_json(passwords)
+      require "json"
+      { passwords: passwords, count: passwords.length, generated_at: Time.now.iso8601 }.to_json
+    end
+  end
+end

data/lib/passforge/pattern.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module PassForge
+  # Pattern-based password generator
+  # Generate passwords based on custom patterns
+  class Pattern
+    # Generate password from pattern
+    #
+    # @param pattern [String] Pattern string
+    # @return [String] Generated password
+    #
+    # Pattern characters:
+    # - C = uppercase letter
+    # - c = lowercase letter
+    # - v = lowercase vowel
+    # - V = uppercase vowel
+    # - 9 = digit
+    # - ! = symbol
+    # - Any other character = literal
+    #
+    # @example Generate from pattern
+    #   PassForge::Pattern.generate("Cvccvc99!")
+    #   # => "Rabmit42!"
+    #
+    def self.generate(pattern)
+      raise ArgumentError, "Pattern cannot be empty" if pattern.nil? || pattern.empty?
+      
+      result = []
+      
+      pattern.each_char do |char|
+        result << case char
+                  when 'C'
+                    Charsets::UPPER_CASE.sample
+                  when 'c'
+                    Charsets::LOWER_CASE.sample
+                  when 'v'
+                    Pronounceable::VOWELS.sample
+                  when 'V'
+                    Pronounceable::VOWELS.sample.upcase
+                  when '9'
+                    Charsets::NUMBERS.sample
+                  when '!'
+                    Charsets::SYMBOLS.sample
+                  else
+                    char # Literal character
+                  end
+      end
+      
+      result.join
+    end
+  end
+end

data/lib/passforge/pronounceable.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module PassForge
+  # Pronounceable password generator
+  # Creates passwords that are easier to type and remember
+  class Pronounceable
+    CONSONANTS = %w[b c d f g h j k l m n p r s t v w x z].freeze
+    VOWELS = %w[a e i o u].freeze
+    
+    # Generate a pronounceable password
+    #
+    # @param length [Integer] Length of the password (default: 12)
+    # @param capitalize [Boolean] Capitalize first letter (default: true)
+    # @param numbers [Boolean] Include numbers (default: true)
+    # @param symbols [Boolean] Include symbols (default: false)
+    # @return [String] Generated pronounceable password
+    #
+    # @example Generate a pronounceable password
+    #   PassForge::Pronounceable.generate(12)
+    #   # => "Tuvaxo8qiba#"
+    #
+    def self.generate(length: 12, capitalize: true, numbers: true, symbols: false)
+      raise ArgumentError, "Length must be at least 4" if length < 4
+      
+      # Reserve space for numbers and symbols
+      letter_count = length
+      letter_count -= 2 if numbers
+      letter_count -= 1 if symbols
+      
+      # Generate pronounceable base
+      password = generate_pronounceable_string(letter_count)
+      
+      # Capitalize first letter
+      password[0] = password[0].upcase if capitalize
+      
+      # Add numbers
+      if numbers
+        2.times { password += SecureRandom.random_number(10).to_s }
+      end
+      
+      # Add symbol
+      if symbols
+        symbol = Charsets::SYMBOLS.sample
+        password += symbol
+      end
+      
+      password
+    end
+    
+    # Generate pronounceable string by alternating consonants and vowels
+    # @private
+    def self.generate_pronounceable_string(length)
+      result = []
+      use_consonant = [true, false].sample
+      
+      length.times do
+        if use_consonant
+          result << CONSONANTS.sample
+        else
+          result << VOWELS.sample
+        end
+        use_consonant = !use_consonant
+      end
+      
+      result.join
+    end
+  end
+end

data/lib/passforge/version.rb

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

data/lib/passforge.rb

@@ -7,6 +7,10 @@ require "passforge/generator"
 require "passforge/passphrase"
 require "passforge/analyzer"
 require "passforge/breach_checker"
+require "passforge/pronounceable"
+require "passforge/pattern"
+require "passforge/batch"
+require "passforge/personal"
 require "securerandom"
 
 # PassForge - A comprehensive password generation toolkit
@@ -48,4 +52,35 @@ module PassForge
   def self.breached?(password)
     BreachChecker.check(password)
   end
+
+  # Generate a pronounceable password
+  # @param options [Hash] Generation options
+  # @return [String] Generated password
+  def self.pronounceable(**options)
+    Pronounceable.generate(**options)
+  end
+
+  # Generate password from pattern
+  # @param pattern [String] Pattern string
+  # @return [String] Generated password
+  def self.pattern(pattern)
+    Pattern.generate(pattern)
+  end
+
+  # Generate multiple passwords
+  # @param count [Integer] Number of passwords
+  # @param type [Symbol] Type of password
+  # @param options [Hash] Generation options
+  # @return [Array<String>] Generated passwords
+  def self.batch(count, type = :random, **options)
+    Batch.generate(count, type, **options)
+  end
+
+  # Generate a personalized password
+  # @param keywords [Array<String>] Personal keywords
+  # @param options [Hash] Generation options
+  # @return [String] Generated password
+  def self.personal(keywords, **options)
+    Personal.generate(keywords, **options)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: passforge
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.2
 platform: ruby
 authors:
 - Bhavin Nandani
@@ -127,10 +127,13 @@ files:
 - Rakefile
 - lib/passforge.rb
 - lib/passforge/analyzer.rb
+- lib/passforge/batch.rb
 - lib/passforge/breach_checker.rb
 - lib/passforge/charsets.rb
 - lib/passforge/generator.rb
 - lib/passforge/passphrase.rb
+- lib/passforge/pattern.rb
+- lib/passforge/pronounceable.rb
 - lib/passforge/version.rb
 - lib/passforge/wordlist.rb
 - sig/passforge.rbs