xkpassword 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a85ce5f07e033d7e20eb30071b644c118ac1e67426c321df01ec2574590eb06f
-  data.tar.gz: f5505a6dddc828b5cb673d32c90b29dd073a0b7143017b2766e54274eba61315
+  metadata.gz: a8679b970d4279654ff7aa2f1212267bd2874466af8adfb197d4005dd94fb62a
+  data.tar.gz: 46877ecf578b62ced17e1ba35c8463387c34676d15cf301e8de5188af7619a79
 SHA512:
-  metadata.gz: 37b272ecbb57d3e652fa01e6ddd1c047241640e957dd733d9323e57c9daa0e92e5fbb8dbbcf3c82eb5eb5f1c72ca51bac2188f60464d6e4c57dfb6453b07ec4a
-  data.tar.gz: 47778296384d3398000a0b4cf3f890d847e11461da40f0f8a269ebe4bc6a718a8194b4ea3e3369f8a81c5fb056bcc85e3ee5c89b8568819b72286ce423ce88c2
+  metadata.gz: 512d12534d4a4d0072dfb2581f98c7b9e1464647739b7b508cea5e3fb4e9ab972158d3b4ffa58fafc12f1a904ddc369b308ec33d57a32355b29028e2424d5476
+  data.tar.gz: '0828510166c54f05316e349a0187aee1d9fd49acf19ee4d8fd970309c938e9a0cb2a06390436f32788a87dc2e71a3cbc23aaf31d82dff868340b45dbd3244a38'

data/.gitignore

@@ -3,7 +3,6 @@
 /Gemfile.lock
 /_yardoc/
 /coverage/
-/doc/
 /pkg/
 /spec/reports/
 /tmp/

data/README.md

@@ -29,7 +29,7 @@ it.
 
 ## Installation
 
-Developed in Linux/Ubuntu, this should work fine in a Linux machine. How ever I can't say
+Developed in Linux/Ubuntu, this should work fine on Linux machines. I cannot say
 the same is true with Mac or Windows systems.
 
 Add this line to your application's Gemfile:
@@ -50,69 +50,108 @@ Or install it yourself as:
 ~# gem install xkpassword
 ```
 
+Installing the gem also installs the `xkpassword` executable.
+
 ## Usage
 
-You can use this app stand-alone in the command line or include it in any of your Ruby
-applications.
+You can use this app as a Ruby gem in your application or as a command line utility.
+For a fuller guide to presets and examples, see [doc/README.md](doc/README.md).
+
+### Command Line
 
-### Comamnd Line
-The commandline application accepts the same collection of configuration options as would
-the `XKPassword` module would. For more information use `xkpassword --help` to obtain a
-full list of options.
+The command line app accepts the same generation options as `XKPassword.generate`.
+If you installed the gem, use the executable directly. If you are working from a
+checkout, run the executable through Bundler.
 
 ```bash
 ~# xkpassword
 ~# xkpassword --help
+~# bundle exec exe/xkpassword
+```
+
+#### Global CLI config
+
+The CLI reads optional defaults from `~/.xkpassword`. The file uses YAML, so it can
+include comments while you experiment with different settings. Use `xkpassword --init`
+to create a commented starter file.
+
+```bash
+~# xkpassword --init
+~# xkpassword
+~# xkpassword --separator .
 ```
 
+```yaml
+# ~/.xkpassword
+# preset: wifi
+words: 5
+min_length: 4
+max_length: 8
+separator: "-"
+# case_transform: capitalize
+```
+
+CLI flags always override values from `~/.xkpassword`, so you can keep preferred defaults
+in the file and still override them per command.
+
 ### Ruby Apps
 
+Use the library API inside your Ruby application:
+
 ```ruby
 require 'xkpassword'
 
 options = {
+  words: 5,
+  min_length: 5,
   max_length: 8,
-  min_length: 4,
+  separator: '.',
   case_transform: :capitalize,
-  separator: '-',
-  words: 4,
 }
 
 XKPassword.generate(options)
 ```
 
-If you are generating multiple passwords at once, I recommend you use
-the following as then it will only load and parse the databse once.
+You can still use presets when they fit your use case:
+
+```ruby
+require 'xkpassword'
+
+XKPassword.generate(preset: :security, separator: '.')
+```
+
+If you are generating multiple passwords at once, use a single generator instance so
+the dictionary only needs to be loaded once:
 
 ```ruby
 require 'xkpassword/generator'
 
 options = {
-  max_length: 8,
+  words: 4,
   min_length: 4,
-  case_transform: :capitalize,
+  max_length: 6,
   separator: '-',
-  words: 4,
+  case_transform: :downcase,
 }
-  
+
 generator = XKPassword::Generator.new
 generator.generate(options)
 
 # 10.times { generator.generate(options) }
 ```
 
+`preset` supports `:xkcd` (default), `:web32`, `:wifi`, `:security`, and `:apple_id`.
+You can still override any individual option in the selected preset.
+
+The default `:xkcd` preset keeps the gem's original behavior of generating 4 words.
+
 `case_transform` supports `:upcase`, `:downcase`, and `:capitalize`, and applies the
 selected transform to every generated word in the password.
 
 ## The GEM
 
-I run a policy of tagging any improvement done for the code base. For example, I just
-bumped a minor (resulting 0.2.3 ~> 0.3.0) for adding Travis CI which doesn't change any
-functional aspect of the app.
-
-I am thinking of releasing gems only on functional updates (real code changes) that
-happen with new features and bug fixes. So for now, there will be no 0.3.0v available
-in Ruby GEMs and the latest would be 0.2.3.
+Releases are intended for functional updates such as new features and bug fixes.
+Check the Git tags or RubyGems release history for the latest published version.
 
 ## Development
 
@@ -124,16 +163,6 @@ a new version, update the version number in `version.rb`, and then run `bundle e
 release`, which will create a git tag for the version, push git commits and tags, and push
 the `.gem` file to [rubygems.org](https://rubygems.org).
 
-## TODO
-
-Some of the things I am interested in doing in the near future.
-
-- More tests, didn't have the time to write it all
-- Local configuration file -> ex: `~/.xkpassword`
-- Check for a better dictionary
-- Ability to provide a dictionary (this should help languages other than English)
-- A black-list - words that will not show up in the generation
-
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/xkpassword.

data/doc/README.md

@@ -0,0 +1,9 @@
+# XKPassword Docs
+
+Additional documentation for this gem lives in this folder.
+
+- [Preset guide](presets.md)
+- [Project README](../README.md) for installation, Ruby gem usage, CLI usage, and `~/.xkpassword` defaults
+- [GitHub repository](https://github.com/jdeen/xkpassword)
+
+Use these docs for feature-specific details, then jump back to the main README or repository as needed.

data/doc/presets.md

@@ -0,0 +1,37 @@
+# Presets
+
+Back to the [docs index](README.md) or the [project README](../README.md).
+
+`XKPassword.generate` and `XKPassword::Generator#generate` accept a `:preset` option.
+If omitted, `:preset` defaults to `:xkcd`.
+
+## Supported presets
+
+| Preset | Defaults |
+| --- | --- |
+| `:xkcd` | 4 words, 4-8 letters, `-` separator, random per-word uppercasing |
+| `:web32` | 4 words, 4-5 letters, `-` separator, random per-word uppercasing |
+| `:wifi` | 6 words, 4-8 letters, `-` separator, random per-word uppercasing |
+| `:security` | 6 words, 4-8 letters, space separator, lowercase words |
+| `:apple_id` | 3 words, 4-7 letters, `-` separator, random per-word uppercasing |
+
+## Examples
+
+```ruby
+require 'xkpassword'
+
+XKPassword.generate
+XKPassword.generate(preset: :wifi)
+XKPassword.generate(preset: :security, separator: '.')
+```
+
+You can pass a preset as a symbol or string. String values like `"apple_id"` and `"apple-id"`
+are normalized to the matching preset.
+
+Explicit options always win over the preset defaults, so this is valid:
+
+```ruby
+XKPassword.generate(preset: :xkcd, words: 6, case_transform: :capitalize)
+```
+
+For the full source and latest updates, see the [GitHub repository](https://github.com/jdeen/xkpassword).

data/exe/xkpassword

@@ -1,48 +1,6 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require 'optparse'
-require 'artii'
-
-require 'bundler/setup'
-require 'xkpassword'
-
-artii = Artii::Base.new font: 'standard'
-message = """
-#{ artii.asciify('XKPassword') }
-by Ziyan Junaideen
-
-How many times have you changed your password just because you forgot it?
-Well, you are not alone. In todays security requirements, passwords need
-to be secure and difficult to break. Passwords need to be secure, sure,
-but they can also be easy to remember. Follow up this XKCD article for more
-information - http://xkcd.com/936/
-
-This does exactly what the picture predicts. You can use this in your Ruby 
-applications (Ex: Rails, Sinatra) or standalone if you install the gem (as 
-you have done here).
-
-Wish you all the best keeping things secure.
-
-Ziyan Junaideen
-ziyan@jdeen.com
-
-"""
-
-options = {}
-OptionParser.new do |opts|
-  opts.banner = "Usage: ./exe/xkpassword [options]"
-
-  opts.on('-v', '--version', 'Gem version') { options[:version] = true }
-  opts.on('-i', '--info', 'Gem info') { options[:info] = true }
-
-  opts.on('--words [INTEGER]', 'Number of wrods to be used in the generated password') { |words| options[:words] = words.to_i }
-  opts.on('--min-length [INTEGER]', 'Minimum length of a word') { |min| options[:min_length] = min.to_i }
-  opts.on('--max-length [INTEGER]', 'Maximum length of a word') { |max| options[:max_length] = max.to_i }
-  opts.on('--separator [STRING]', 'The separator to separate password') { |separator| options[:separator] = separator }
-  opts.on('--case-transform [STRING]', 'Transform each word using upcase, downcase, or capitalize') { |case_transform| options[:case_transform] = case_transform }
-end.parse!
-
-puts message if options[:info]
-puts XKPassword::VERSION if options[:version]
-puts XKPassword.generate(options) if !options[:info] && !options[:version]
+require 'xkpassword/cli'
 
+exit XKPassword::CLI.new.run

data/lib/xkpassword/cli.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'artii'
+
+require 'xkpassword'
+require 'xkpassword/config_file'
+
+module XKPassword
+  # Command-line entrypoint for the xkpassword executable.
+  class CLI
+    INFO_MESSAGE = <<~TEXT.freeze
+      #{Artii::Base.new(font: 'standard').asciify('XKPassword')}
+      by Ziyan Junaideen
+
+      How many times have you changed your password just because you forgot it?
+      Well, you are not alone. In todays security requirements, passwords need
+      to be secure and difficult to break. Passwords need to be secure, sure,
+      but they can also be easy to remember. Follow up this XKCD article for more
+      information - http://xkcd.com/936/
+
+      This does exactly what the picture predicts. You can use this in your Ruby
+      applications (Ex: Rails, Sinatra) or standalone if you install the gem (as
+      you have done here).
+
+      Wish you all the best keeping things secure.
+
+      Ziyan Junaideen
+      ziyan@jdeen.com
+    TEXT
+
+    def initialize(argv = ARGV, stdout: $stdout, stderr: $stderr, env: ENV)
+      @argv = argv.dup
+      @stdout = stdout
+      @stderr = stderr
+      @config_file = XKPassword::ConfigFile.new(XKPassword::ConfigFile.default_path(env))
+      @options = {}
+    end
+
+    def run
+      option_parser.parse!(@argv)
+
+      return initialize_config if @options[:init]
+      return write_special_output if special_output?
+
+      options = @config_file.load.merge(@options)
+      write_line(XKPassword.generate(options))
+    rescue OptionParser::ParseError, XKPassword::ConfigFile::Error, ArgumentError => e
+      @stderr.puts(e.message)
+      1
+    end
+
+    private
+
+    def option_parser
+      @option_parser ||= OptionParser.new do |opts|
+        opts.banner = 'Usage: xkpassword [options]'
+
+        add_command_options(opts)
+        add_generation_options(opts)
+      end
+    end
+
+    def add_command_options(opts)
+      opts.on('-v', '--version', 'Gem version') { @options[:version] = true }
+      opts.on('-i', '--info', 'Gem info') { @options[:info] = true }
+      opts.on('--init', "Create #{@config_file.path} with commented defaults") { @options[:init] = true }
+      opts.on('-h', '--help', 'Show help') { @options[:help] = true }
+    end
+
+    def add_generation_options(opts)
+      add_numeric_generation_options(opts)
+      add_text_generation_options(opts)
+    end
+
+    def add_numeric_generation_options(opts)
+      opts.on(
+        '--words [INTEGER]',
+        'Number of words to use in the generated password'
+      ) { |words| @options[:words] = words.to_i }
+      opts.on('--min-length [INTEGER]', 'Minimum length of a word') { |min| @options[:min_length] = min.to_i }
+      opts.on('--max-length [INTEGER]', 'Maximum length of a word') { |max| @options[:max_length] = max.to_i }
+    end
+
+    def add_text_generation_options(opts)
+      opts.on(
+        '--separator [STRING]',
+        'The separator between generated words'
+      ) { |separator| @options[:separator] = separator }
+      opts.on(
+        '--case-transform [STRING]',
+        'Transform each word using upcase, downcase, or capitalize'
+      ) { |case_transform| @options[:case_transform] = case_transform }
+      add_preset_option(opts)
+    end
+
+    def add_preset_option(opts)
+      opts.on(
+        '--preset [STRING]',
+        'Preset to use: xkcd, web32, wifi, security, or apple_id'
+      ) { |preset| @options[:preset] = preset }
+    end
+
+    def special_output?
+      @options[:help] || @options[:info] || @options[:version]
+    end
+
+    def write_special_output
+      write_line(option_parser) if @options[:help]
+      write_line(INFO_MESSAGE) if @options[:info]
+      write_line(XKPassword::VERSION) if @options[:version]
+      0
+    end
+
+    def initialize_config
+      path = @config_file.init!
+      write_line("Created #{path}")
+    end
+
+    def write_line(message)
+      @stdout.puts(message)
+      0
+    end
+  end
+end

data/lib/xkpassword/config_file.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'psych'
+
+module XKPassword
+  # Loads and initializes the CLI config file stored at ~/.xkpassword.
+  class ConfigFile
+    Error = Class.new(StandardError)
+
+    ALLOWED_OPTIONS = %i[
+      preset
+      words
+      min_length
+      max_length
+      separator
+      case_transform
+    ].freeze
+    INTEGER_OPTIONS = %i[words min_length max_length].freeze
+    TEMPLATE = <<~YAML
+      # Global defaults for the xkpassword CLI.
+      # Remove the leading "#" from any setting you want to enable.
+      #
+      # Supported keys:
+      #   preset: xkcd, web32, wifi, security, apple_id
+      #   words: integer
+      #   min_length: integer
+      #   max_length: integer
+      #   separator: string
+      #   case_transform: upcase, downcase, capitalize
+      #
+      # Example:
+      # preset: wifi
+      # words: 6
+      # min_length: 4
+      # max_length: 8
+      # separator: "-"
+      # case_transform: capitalize
+    YAML
+
+    attr_reader :path
+
+    def initialize(path = self.class.default_path)
+      @path = path
+    end
+
+    def self.default_path(env = ENV)
+      home = env['HOME'] || Dir.home
+      File.expand_path('.xkpassword', home)
+    end
+
+    def load
+      return {} unless File.exist?(path)
+
+      data = Psych.safe_load(File.read(path), aliases: false)
+      return {} if data.nil?
+      raise Error, "#{path} must contain a YAML mapping of options" unless data.is_a?(Hash)
+
+      normalize_options(data)
+    rescue Psych::SyntaxError => e
+      raise Error, "Could not parse #{path}: #{e.message}"
+    end
+
+    def init!
+      raise Error, "#{path} already exists" if File.exist?(path)
+
+      File.write(path, TEMPLATE)
+      path
+    end
+
+    private
+
+    def normalize_options(data)
+      data.each_with_object({}) do |(key, value), normalized|
+        normalized_key = normalize_key(key)
+
+        unless ALLOWED_OPTIONS.include?(normalized_key)
+          raise Error, "Unsupported config option #{key.inspect} in #{path}"
+        end
+
+        normalized[normalized_key] = normalize_value(normalized_key, value)
+      end
+    end
+
+    def normalize_key(key)
+      key.to_s.strip.downcase.tr(' -', '_').to_sym
+    end
+
+    def normalize_value(key, value)
+      return normalize_integer(key, value) if INTEGER_OPTIONS.include?(key)
+
+      return value if value.nil? || value.is_a?(String) || value.is_a?(Symbol)
+
+      raise Error, "#{key} in #{path} should be a string or left unset"
+    end
+
+    def normalize_integer(key, value)
+      integer_value = value.is_a?(String) ? Integer(value, 10) : value
+      return integer_value if integer_value.is_a?(Integer)
+
+      raise Error, "#{key} in #{path} should be an integer"
+    rescue ArgumentError, TypeError
+      raise Error, "#{key} in #{path} should be an integer"
+    end
+  end
+end

data/lib/xkpassword/generator.rb

@@ -2,16 +2,60 @@ require 'xkpassword/words'
 
 # The Generator class which finds words based on the requirement and using the provided options to build a
 # new random passowrd.
+# Presets provide convenient defaults for common password styles, and callers can override any
+# preset-derived value by passing explicit generation options.
 # 
 # @attr_reader [XKPassword::Words] words  A word database that gen provide you words for the length required
 class XKPassword::Generator
-  DEFAULTS = {
-    case_transform: nil,
-    max_length: 8,
-    min_length: 4,
-    separator: '-',
-    words: 4,
+  # The preset used when `:preset` is omitted.
+  DEFAULT_PRESET = :xkcd
+
+  # Built-in password presets.
+  #
+  # - `:xkcd` generates 4 words between 4 and 8 letters separated by `-`, preserving the gem's
+  #   original default behavior.
+  # - `:web32` generates 4 shorter words between 4 and 5 letters separated by `-`.
+  # - `:wifi` generates 6 words between 4 and 8 letters separated by `-`.
+  # - `:security` generates 6 lowercase words between 4 and 8 letters separated by spaces.
+  # - `:apple_id` generates 3 words between 4 and 7 letters separated by `-`.
+  PRESETS = {
+    xkcd: {
+      case_transform: nil,
+      max_length: 8,
+      min_length: 4,
+      separator: '-',
+      words: 4,
+    },
+    web32: {
+      case_transform: nil,
+      max_length: 5,
+      min_length: 4,
+      separator: '-',
+      words: 4,
+    },
+    wifi: {
+      case_transform: nil,
+      max_length: 8,
+      min_length: 4,
+      separator: '-',
+      words: 6,
+    },
+    security: {
+      case_transform: :downcase,
+      max_length: 8,
+      min_length: 4,
+      separator: ' ',
+      words: 6,
+    },
+    apple_id: {
+      case_transform: nil,
+      max_length: 7,
+      min_length: 4,
+      separator: '-',
+      words: 3,
+    },
   }
+  VALID_CASE_TRANSFORMS = [:upcase, :downcase, :capitalize]
 
   attr_reader :words
 
@@ -20,8 +64,14 @@ class XKPassword::Generator
   end
 
   # Generates a password absed on the configuration provided.
+  # A preset supplies a base configuration and any explicit options passed in `options` override
+  # those preset defaults.
   #
   # @param [Hash] options The options to populate a generator
+  # @option options [String, Symbol] :preset The preset to use. Supports `:xkcd`, `:web32`,
+  #                                          `:wifi`, `:security`, and `:apple_id`.
+  #                                          String values like `"apple_id"` and `"apple-id"`
+  #                                          are normalized to `:apple_id`. Defaults to `:xkcd`.
   # @option options [Integer] :words      The number of words to include in the generated password
   # @option options [String]  :separator  The separator symbol to use joining words used in password
   # @option options [Integer] :min_length The minimum length of a word to be used in the process
@@ -30,20 +80,37 @@ class XKPassword::Generator
   #
   # @return [String]                      The generated password
   #
-  # @example Populating the method with all options (current default)
+  # @example Using the default xkcd preset
+  #   generator = XKPassword::Generator.new
+  #   generator.generate
+  #
+  # @example Using the security preset
+  #   generator = XKPassword::Generator.new
+  #   generator.generate(preset: :security)
+  #
+  # @example Populating the method with a preset and explicit overrides
   #   options = {
+  #     preset: :security,
   #     separator: ' ',
-  #     words: 4,
+  #     words: 6,
   #     min_length: 4,
   #     max_length: 8,
-  #     case_transform: :capitalize
+  #     case_transform: :downcase
   #   }
   #
   #   generator = XKPassword::Generator.new
   #   generator.generate(options)
+  #
+  # @example Built-in preset defaults
+  #   :xkcd     # 4 words, 4..8 letters, "-" separator, random per-word uppercasing
+  #   :web32    # 4 words, 4..5 letters, "-" separator, random per-word uppercasing
+  #   :wifi     # 6 words, 4..8 letters, "-" separator, random per-word uppercasing
+  #   :security # 6 words, 4..8 letters, " " separator, lowercase
+  #   :apple_id # 3 words, 4..7 letters, "-" separator, random per-word uppercasing
   def generate(options = nil)
-    options ||= {}
-    options = DEFAULTS.merge(options)
+    options = (options || {}).dup
+    preset = normalize_preset(options.delete(:preset))
+    options = PRESETS.fetch(preset).merge(options)
     case_transform = normalize_case_transform(options[:case_transform])
     length_vals = (options[:min_length]..options[:max_length]).to_a
 
@@ -73,11 +140,20 @@ class XKPassword::Generator
     return nil if case_transform.nil?
 
     case_transform = case_transform.to_sym if case_transform.is_a?(String)
-    valid_case_transforms = [:upcase, :downcase, :capitalize]
 
-    return case_transform if valid_case_transforms.include?(case_transform)
+    return case_transform if VALID_CASE_TRANSFORMS.include?(case_transform)
+
+    fail ArgumentError, "case_transform should be one of: #{ VALID_CASE_TRANSFORMS.join(', ') }"
+  end
+
+  def normalize_preset(preset)
+    return DEFAULT_PRESET if preset.nil?
+
+    preset = preset.strip.downcase.tr(' -', '_').to_sym if preset.is_a?(String)
+
+    return preset if PRESETS.key?(preset)
 
-    fail ArgumentError, "case_transform should be one of: #{ valid_case_transforms.join(', ') }"
+    fail ArgumentError, "preset should be one of: #{ PRESETS.keys.join(', ') }"
   end
 
 end

data/lib/xkpassword/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module XKPassword
-  VERSION = '0.4.0'
+  VERSION = '0.6.0'
 end

data/lib/xkpassword.rb

@@ -7,12 +7,29 @@ module XKPassword
   # use the `XKPassword::Generator` class as it will be faster since it will only need to load
   # the dictionary once.
   #
+  # Presets provide named defaults for common password styles, and any explicit options passed to
+  # this method override the selected preset.
+  #
   # @param [Hash] options The options to populate a generator
+  # @option options [String, Symbol] :preset The preset to use. Supports `:xkcd`, `:web32`,
+  #                                          `:wifi`, `:security`, and `:apple_id`.
+  #                                          Defaults to `:xkcd`.
+  #                                          - `:xkcd` uses 4 words of 4..8 letters joined by `-`
+  #                                          - `:web32` uses 4 words of 4..5 letters joined by `-`
+  #                                          - `:wifi` uses 6 words of 4..8 letters joined by `-`
+  #                                          - `:security` uses 6 lowercase words of 4..8 letters joined by spaces
+  #                                          - `:apple_id` uses 3 words of 4..7 letters joined by `-`
   # @option options [Integer] :words      The number of words to include in the generated password
   # @option options [String]  :separator  The separator symbol to use joining words used in password
   # @option options [Integer] :min_length The minimum length of a word to be used in the process
   # @option options [Integer] :max_length The maximum length of a word to be used in the process
   # @option options [String, Symbol] :case_transform The transform to apply to every generated word
+  #
+  # @example Generate with the default preset
+  #   XKPassword.generate
+  #
+  # @example Generate with a preset and override one of its defaults
+  #   XKPassword.generate(preset: :apple_id, separator: '.')
   def self.generate(options = nil)
     generator = XKPassword::Generator.new
     generator.generate(options)
@@ -22,4 +39,3 @@ end
 
 require 'xkpassword/version'
 require 'xkpassword/generator'
-

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xkpassword
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Ziyan Junaideen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-10 00:00:00.000000000 Z
+date: 2026-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: artii
@@ -90,8 +90,12 @@ files:
 - bin/console
 - bin/setup
 - bin/xkpassword
+- doc/README.md
+- doc/presets.md
 - exe/xkpassword
 - lib/xkpassword.rb
+- lib/xkpassword/cli.rb
+- lib/xkpassword/config_file.rb
 - lib/xkpassword/data/google-10000-english-no-swears.txt
 - lib/xkpassword/generator.rb
 - lib/xkpassword/store.rb