nice_password 1.0.0

data/lib/nice_password/errors.rb

@@ -0,0 +1,9 @@
+module NicePassword #:nodoc:
+  
+  class FormatError < StandardError #:nodoc:
+  end
+  
+  class DictionaryError < StandardError #:nodoc:
+  end
+  
+end

data/lib/nice_password/nice_password.rb

@@ -0,0 +1,134 @@
+require "yaml"
+module NicePassword #:nodoc:
+
+  class << self
+
+    @@languages = ['en', 'fr', 'es']
+    @@default_language = 'en'
+    @@dictionaries = {}
+    
+    def default_language; @@default_language; end
+    def default_language=(value); @@default_language = value; end
+
+    # <tt>new</tt> generates a new NicePassword according to the parameters passed 
+    # in via the options hash, or using the default parameters.
+    #
+    # Options include:
+    #   :length - total number of characters in the password, default is 12
+    #   :words - total number of words in the password, between 1-4, default is 2
+    #   :digits - number of digits between each word (not the total number), default is 2
+    #   :language - abbreviation for language to use for the words, default is 'en' (English)
+    #   :dictionary - specify a custom dictionary to use instead of the default dictionary
+    #
+    def new(options= {})
+      password        = ""
+      total_length    = (options[:length] || 12).to_i
+      word_count      = (options[:words]  ||  2).to_i
+      digit_length    = (options[:digits] ||  2).to_i
+      word_options    = options.slice(:language, :dictionary)
+      length_variance = 3
+      
+      validate_word_count(word_count)
+      
+      total_digits = digit_length * (word_count - 1)
+      avg_word_length = (total_length - total_digits) / word_count
+      
+      validate_avg_word_length(avg_word_length)
+
+      word_count.downto(1) do |n|
+        length_needed = total_length - password.length
+        break if length_needed <= 0
+
+        if n == 1 # this is the last word
+          word_options[:exact] = length_needed
+        else # not the last word
+          word_options[:min] = [1, avg_word_length - length_variance].max
+          # max_length = total remaining length - remaining digits and words
+          word_options[:max] = length_needed - ((n-1) * (digit_length + avg_word_length))
+        end
+        password << pick_dictionary_word(word_options)
+        password << pick_random_number(digit_length).to_s if digit_length > 0 && n > 1
+      end
+
+      return password
+    end
+
+    protected
+    
+      # <tt>load_dictionary</tt> load the YAML dictionary file for the given language
+      # The language should be a two letter abbreviation that corresponds to the file 
+      # name in /lib/nice_password/dictionaries/*.yml such as 'en', 'fr', 'es'.
+      def load_dictionary(lang)
+        return false unless lang
+        dictionary = File.join(File.dirname(__FILE__), 'dictionaries', "#{lang}.yml")
+        YAML::load(File.open(dictionary))
+      end
+    
+      # <tt>pick_dictionary_word</tt> selects a word from the dictionary that matches the 
+      # desired (or default) length parameters.
+      #
+      # Options include:
+      #   :min - minimum length word to retrieve, defaults to 1
+      #   :max - maximum length word to retreive, defaults to 5
+      #   :exact - if included, :exact overrides :min and :max lengths
+      #   :language - abbreviation for language to use for the words, default is 'en' (English)
+      #   :dictionary - specify a custom dictionary to use instead of the default dictionary
+      #
+      def pick_dictionary_word(options={})
+        min_length = (options[:exact] || options[:min] || 1).to_i
+        max_length = (options[:exact] || options[:max] || 5).to_i
+        
+        language   = (options[:language] || @@default_language).to_s
+        validate_language(language)
+        
+        dictionary = options[:dictionary] || @@dictionaries[language] ||= load_dictionary(language)
+        validate_dictionary(dictionary)
+        
+        sized_words = dictionary.select do |word|
+          min_length <= word.length && word.length <= max_length
+        end
+        if !sized_words.empty?
+          return sized_words[rand(sized_words.length)] 
+        else
+          # TODO: How should an empty sized_words be handled?
+          return ""
+        end
+      end
+    
+      # <tt>pick_random_number</tt> chooses a random number with the same number of digits 
+      # as the first argument
+      def pick_random_number(digits=1)
+        min = 10 ** (digits - 1)
+        max = (10 ** digits ) - 1
+        semirandom = min + rand(max-min)
+        semirandom += 1 if semirandom == 666 #would be unpleasant to receive...
+        return semirandom
+      end
+    
+    private
+    
+      def validate_word_count(word_count)
+        raise NicePassword::FormatError.new("Word count must be greater than 0") if word_count < 1
+        raise NicePassword::FormatError.new("Word count must be less than 4") if word_count > 4
+      end
+      
+      def validate_avg_word_length(avg_word_length)
+        raise NicePassword::FormatError.new("Word length is too short, increase :length") if avg_word_length <= 2
+        raise NicePassword::FormatError.new("Word length is too long, decrease :length") if avg_word_length >= 12
+      end
+      
+      def validate_language(language)
+        unless @@languages.include?(language)
+          raise NicePassword::DictionaryError.new("Invalid language")
+        end
+      end
+      
+      def validate_dictionary(dictionary)
+        unless dictionary.is_a?(Array) && !dictionary.compact.empty?
+          raise NicePassword::DictionaryError.new("Invalid dictionary format")
+        end
+      end
+      
+  end
+  
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'nice_password')

data/spec/nice_password/nice_password_spec.rb

@@ -0,0 +1,135 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Nice Password" do
+
+  describe "defaults" do
+
+    it "should have the length of 12" do
+      NicePassword.new.length.should == 12
+    end
+
+    it "should contain a two digit number" do
+      digits = NicePassword.new.scan(/\d+/)
+      digits.join.size.should == 2
+    end
+
+    it "should contain two words" do
+      words = NicePassword.new.scan(/\D+/)
+      words.size.should == 2
+    end
+
+  end
+
+  describe "options" do
+
+    it "should be able to specify length" do
+      (8..24).each do |n|
+        password = NicePassword.new(:length => n)
+        password.length.should == n
+      end
+    end
+
+    it "should be able to specify number of digits" do
+      (1..5).each do |n|
+        password = NicePassword.new(:digits => n)
+        password.scan(/\d+/).join.size.should == n
+      end
+    end
+
+    it "should be able to specify number of words" do
+      (2..4).each do |n|
+        # :length increases :words to avoid validation errors
+        password = NicePassword.new(:words => n, :length => n * 5)
+        password.scan(/\D+/).size.should == n
+      end
+    end
+    
+    it "should be able to specify the language as a string" do
+      ['en', 'fr', 'es'].each do |lang|
+        yaml_file = File.join(File.dirname(__FILE__), '..', '..', 'lib', 'nice_password', 'dictionaries', "#{lang}.yml")
+        dictionary = YAML::load(File.open(yaml_file))
+        
+        password = NicePassword.new(:language => lang)
+        password.scan(/\D+/).each do |word|
+          dictionary.include?(word).should be_true
+        end
+      end
+      
+    end
+    
+    it "should be able to specify the language as a symbol" do
+      [:en, :fr, :es].each do |lang|
+        yaml_file = File.join(File.dirname(__FILE__), '..', '..', 'lib', 'nice_password', 'dictionaries', "#{lang}.yml")
+        dictionary = YAML::load(File.open(yaml_file))
+        
+        password = NicePassword.new(:language => lang)
+        password.scan(/\D+/).each do |word|
+          dictionary.include?(word).should be_true
+        end
+      end
+      
+    end
+    
+    it "should be able to send an alternate dictionary" do
+      dictionary = ['a', 'b', 'c', 'd', 'e', 'ax', 'be', 'co', 'do', 'em', 
+        'art', 'bye', 'cat', 'doe', 'ear', 'aces', 'baby', 'cart', 'dove', 'even',
+        'apple', 'boast', 'child', 'devil', 'eager',
+        'aprons', 'bounce', 'chance', 'denied', 'easter',
+        'approve', 'beneath', 'chiller', 'defined', 'evolves',
+        'annotate', 'believes', 'children', 'destruct', 'eloquent',
+        'appreciate', 'backbench', 'construct', 'deflected', 'everybody']
+      password = NicePassword.new(:dictionary => dictionary)
+      password.scan(/\D+/).each do |word|
+        dictionary.include?(word).should be_true
+      end
+    end
+
+  end
+
+  describe "validations" do
+    
+    it "should raise FormatError if avg word count is too small" do
+      lambda do
+        NicePassword.new(:length => 6, :words => 0, :digits => 2)
+      end.should raise_error(NicePassword::FormatError)
+    end
+
+    it "should raise FormatError if avg word count is too large" do
+      lambda do
+        NicePassword.new(:length => 6, :words => 5, :digits => 2)
+      end.should raise_error(NicePassword::FormatError)
+    end
+
+    it "should raise FormatError if avg word length is too small" do
+      lambda do
+        NicePassword.new(:length => 6, :words => 2, :digits => 2)
+      end.should raise_error(NicePassword::FormatError)
+    end
+
+    it "should raise FormatError if avg word length is too large" do
+      lambda do
+        NicePassword.new(:length => 26, :words => 2, :digits => 2)
+      end.should raise_error(NicePassword::FormatError)
+    end
+
+    it 'should raise DictionaryError if language is an invalid choice' do
+      lambda do
+        NicePassword.new(:language => 'martian')
+      end.should raise_error(NicePassword::DictionaryError)
+    end
+    
+    it 'should raise DictionaryError if dictionary is invalid'   do
+      lambda do
+        NicePassword.new(:dictionary => {})
+      end.should raise_error(NicePassword::DictionaryError)
+      lambda do
+        NicePassword.new(:dictionary => [])
+      end.should raise_error(NicePassword::DictionaryError)
+      lambda do
+        NicePassword.new(:dictionary => [nil, nil, nil])
+      end.should raise_error(NicePassword::DictionaryError)
+    end
+    
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+$LOAD_PATH << "." unless $LOAD_PATH.include?(".")
+
+begin
+  require "rubygems"
+  require "bundler"
+
+  if Gem::Version.new(Bundler::VERSION) <= Gem::Version.new("0.9.5")
+    raise RuntimeError, "Your bundler version is too old." +
+      "Run `gem install bundler` to upgrade."
+  end
+
+  # Set up load paths for all bundled gems
+  Bundler.setup
+rescue Bundler::GemNotFound
+  raise RuntimeError, "Bundler couldn't find some gems." +
+    "Did you run `bundle install`?"
+end
+
+Bundler.require(:default, :test)
+
+
+require File.expand_path('../../lib/nice_password', __FILE__)
+

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: nice_password
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Kevin Skoglund
+- Matthew Bergman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-06 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: NicePassword creates easy-to-remember, reasonably-secure passwords by mixing dictionary words and random numbers.
+email: kevin@novafabrica.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- Gemfile
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/nice_password.rb
+- lib/nice_password/core_ext.rb
+- lib/nice_password/dictionaries/en.yml
+- lib/nice_password/dictionaries/es.yml
+- lib/nice_password/dictionaries/fr.yml
+- lib/nice_password/errors.rb
+- lib/nice_password/nice_password.rb
+- rails/init.rb
+- spec/nice_password/nice_password_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/novafabrica/nice_password
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Generate easy to read/remember passwords
+test_files: 
+- spec/nice_password/nice_password_spec.rb
+- spec/spec_helper.rb