memorable_password 0.0.3 → 0.1.1

data/.gitignore

@@ -2,3 +2,7 @@
 .bundle
 Gemfile.lock
 pkg/*
+coverage/*
+doc/*
+.yardoc
+.DS_Store

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.rvmrc

@@ -0,0 +1 @@
+rvm ree@memorable_password --create

data/Gemfile

@@ -1,4 +1,4 @@
 source "http://rubygems.org"
 
 # Specify your gem's dependencies in memorable_password.gemspec
-gemspec
+gemspec

data/README.markdown

@@ -1,7 +1,7 @@
 # Memorable Password
 
-[Kevin McPhillips](mailto:github@kevinmcphillips.ca)
-
+[Kevin McPhillips](mailto:github@kevinmcphillips.ca),
+[Oleksandr Ulianytskyi](mailto:a.ulyanitsky@gmail.com)
 
 ## About
 
@@ -14,29 +14,33 @@ It is, of course, by definition less secure than a truly random password. The in
 
 Generates a password with the default length of 8 characters.
 
-    MemorablePassword.generate
+    MemorablePassword.new.generate
     => "pad8dune"
 
 Generates a password with a specified length.
 
-    MemorablePassword.generate :length => 10
+    MemorablePassword.new.generate :length => 10
     => "june3eaten"
 
 Generates a password that is at least a certain length.
 
-    MemorablePassword.generate :min_length => 8
+    MemorablePassword.new.generate :min_length => 8
     => "gale3covalt"
 
 Generates a password that includes special characters.
 
-    MemorablePassword.generate :special_characters => true
+    MemorablePassword.new.generate :special_characters => true
     => "grace!pi"
 
 Generates a password that mixes upper case in.
 
-    MemorablePassword.generate :mixed_case => true
+    MemorablePassword.new.generate :mixed_case => true
     => "was7Room"
 
+Generates a password that is two 4-char words joined by non-ambiguous digit (not 2 and 4).
+
+    MemorablePassword.new.generate_simple
+    => "sons3pied"
 
 ## Feedback
 

data/Rakefile

@@ -1,2 +1,11 @@
 require 'bundler'
+require 'rspec/core/rake_task'
+
 Bundler::GemHelper.install_tasks
+RSpec::Core::RakeTask.new
+
+desc "Run all specs with rcov"
+RSpec::Core::RakeTask.new(:rcov) do |t|
+  t.rcov      = true
+  t.rcov_opts = %w{--rails --exclude osx\/objc,gems\/,spec\/,features\/}
+end

data/lib/memorable_password/sample.rb

@@ -4,4 +4,4 @@ if RUBY_VERSION.to_f < 1.9
       self[rand(length)]
     end
   end
-end
+end

data/lib/memorable_password/version.rb

@@ -1,3 +1,3 @@
-module MemorablePassword
-  VERSION = "0.0.3"
+class MemorablePassword
+  VERSION = "0.1.1"
 end

data/lib/memorable_password.rb

@@ -1,27 +1,87 @@
 require 'memorable_password/sample'
 
-module MemorablePassword
-  
+# This class is used for generating memorable passwords.  It generates the password
+# from a list of words, proper names, digits and characters.
+#
+# If no options are passed in, the dictionary is built from '/usr/share/dict/words'.
+#
+# Options are:
+# * <tt>ban_list</tt> -  an array of words that should added to the blacklist
+# * <tt>dictionary_paths</tt> - an array of paths to files that contain dictionary words
+# * <tt>blacklist_paths</tt> - an array of paths to files that contain blacklisted words
+#
+# Option examples:
+#   MemorablePassword.new(:ban_list => ['bad word'])
+#   MemorablePassword.new(:dictionary_paths => ['path_to_dictionary/dict.txt'])
+#   MemorablePassword.new(:blacklist_paths => ['path_to_blacklist/blacklist.txt'])
+#
+# == Generate password
+# Generate a random password by calling #generate.
+# See #generate for configuration details.
+#
+#   MemorablePassword.new.generate
+#   # => "fig7joeann"
+#
+# == Generate simple password
+# Generate a simple 9-character password by calling #generate_simple.
+#
+#   MemorablePassword.new.generate_simple
+#   # => "sons3pied"
+#
+class MemorablePassword
   MAX_WORD_LENGTH = 7
-  DIGITS = (0..9).to_a.map{|d| d.to_s}
-  CHARACTERS = %w[! @ $ ? -]
-  
-  DEFAULT_OPTIONS = {
+  DIGITS = %w[0 1 2 3 4 5 6 7 8 9].freeze
+  NON_WORD_DIGITS = (DIGITS - %w(2 4 8)).freeze
+  CHARACTERS = %w[! @ $ ? -].freeze
+
+  # The default paths to the various dictionary flat files
+  DEFAULT_PATH = "#{File.dirname(__FILE__)}/memorable_password"
+  DEFAULT_DICTIONARY_PATHS = ['/usr/share/dict/words', "#{DEFAULT_PATH}/names.txt"]
+  DEFAULT_BLACKLIST_PATHS  = ["#{DEFAULT_PATH}/blacklist.txt"]
+
+  DEFAULT_GENERATE_OPTIONS = {
     :mixed_case => false,
     :special_characters => false,
     :length => nil,
     :min_length => nil
   }
-  
-  class << self; attr_accessor :dictionary, :blacklist end
-  @dictionary = nil
-  @blacklist = nil
-  
-  def self.generate(opts={})
-    opts = DEFAULT_OPTIONS.merge(opts)
-    
-    raise "You cannot specify :length and :min_length at the same time" if opts[:length] && opts[:min_length]  # Nonsense!
-    
+
+  attr_reader :dictionary, :blacklist, :ban_list,
+              :dictionary_paths, :blacklist_paths
+
+  def initialize(options={})
+    # TODO implement these lists as Sets to get Hash lookup and uniqueness for free -- matt.dressel 20120328
+    # The dictionary is currently a hash of length to words: {1 => ['w','a'], 2 => ['at']}
+    @ban_list = options.fetch(:ban_list, [])
+
+    # TODO support passing data in as an array -- matt.dressel 20120328
+    @dictionary_paths = options.fetch(:dictionary_paths, DEFAULT_DICTIONARY_PATHS)
+    @blacklist_paths = options.fetch(:blacklist_paths, DEFAULT_BLACKLIST_PATHS)
+
+    @dictionary = {}
+    @blacklist = []
+
+    build_dictionary
+  end
+
+  # Generates memorable password as a combination of two 4-letter dictionary
+  # words joined by a numeric character excluding 2, 4 and 8.
+  def generate_simple
+    "#{word(4)}#{non_word_digit}#{word(4)}"
+  end
+
+  # Generates memorable password.
+  # +opts+:: hash with options
+  # [:mixed_case] +true+ or +false+ - use mixedCase (default: +false+)
+  # [:special_characters] +true+ or +false+ - use special characters like ! @ $? - (default: +false+)
+  # [:length] Fixnum - generate passoword with specific length
+  # [:min_length] Fixnum - generate passoword with length grather or equal of specified
+  # Options +:length+ and +:min_length+ are incompatible.
+  def generate(opts={})
+    opts = DEFAULT_GENERATE_OPTIONS.merge(opts)
+
+    raise "You cannot specify :length and :min_length at the same time" if opts[:length] && opts[:min_length]
+
     if opts[:length]
       password = [(opts[:length] >= 8 ? long_word : word), (opts[:special_characters] ? character : digit)]
       password << word(opts[:length] - password.compact.join.length)
@@ -33,95 +93,141 @@ module MemorablePassword
           password << word(count)
         end
       end
-      
+
+    elsif opts[:special_characters]
+      password = [word, character, word, digit]
     else
-      if opts[:special_characters]
-        password = [word, character, word, digit]
-      else
-        password = [word, digit, long_word]
-      end
+      password = [word, non_word_digit, long_word]
     end
-    
+
     if opts[:mixed_case]
       password.compact.reject{|x| x.length == 1}.sample.capitalize!
     end
-    
+
     # If a minimum length is required and this password is too short
-    if opts[:min_length] && password.compact.join.length < opts[:min_length]
-      if (count = opts[:min_length] - password.compact.join.length) == 1
+    compact_password_length = password.compact.join.length
+    if opts[:min_length] && compact_password_length < opts[:min_length]
+      if (count = opts[:min_length] - compact_password_length) == 1
         password << digit
       else
         password << word(count)
       end
     end
-    
+
+
     # If it is too long, just cut it down to size. This should not happen often unless the :length option is present and is very small.
-    if opts[:length] && password.compact.join.length > opts[:length]
-      result = password.compact.join.slice(0, opts[:length])
-      
+    compact_password_string = password.compact.join
+    if opts[:length] && compact_password_string.length > opts[:length]
+      result = compact_password_string.slice(0, opts[:length])
+
       # If there is no digit then it is probably a short password that by chance is just a dictionary word. Override that because that is bad.
       if result =~ /^[a-z]+$/
         password = [(opts[:mixed_case] ? word(opts[:length] - 1).capitalize : word(opts[:length] - 1)), (opts[:special_characters] ? character : digit)]
         result = password.compact.join
       end
-      
+
       result
     else
-      password.compact.join
+      compact_password_string
     end
   end
-  
+
+  # Adds the +word+ to the dictionary unless it is invalid or blacklisted
+  def add_word(word)
+    return unless validate_word(word)
+    word = normalize_word(word)
+
+    unless @blacklist.include?(word)
+      length = word.length
+      @dictionary[length] = [] unless @dictionary[length]
+      @dictionary[length] << word
+    end
+  end
+
+  # Adds the +word+ to the blacklist unless it is invalid
+  def blacklist_word(word)
+    return unless validate_word(word)
+    word = normalize_word(word)
+
+    @blacklist << word
+    # Remove the blacklisted word from the dictionary if it exists
+    dictionary_array = @dictionary[word.length]
+    dictionary_array.delete(word) if dictionary_array && dictionary_array.include?(word)
+  end
+
   private
-  
-  def self.character
+
+  # Returns a random character
+  def character
     CHARACTERS.sample
   end
-  
-  def self.digit
+
+  # Returns a random digit
+  def digit
     DIGITS.sample
   end
-  
-  def self.word(length=nil)
-    length = self.dictionary.keys.sample if !length || length > self.dictionary.keys.max
-    self.dictionary[length].sample if self.dictionary.has_key?(length)
+
+  # Returns a random, non-ambiguous digit (0..9 without 2, 4 and 8)
+  def non_word_digit
+    NON_WORD_DIGITS.sample
   end
-  
-  def self.long_word
-    keys = self.dictionary.keys.sort
-    self.dictionary[keys.partition{|v| v >= keys[keys.size/2] }.first.sample].sample  # Magic! It actually just randomly picks from the larger words..
+
+  # Ensures that the word is valid:
+  #   is not null
+  #   is at least 2 letters
+  #   and does not exceed the MAX_WORD_LENGTH
+  #
+  # Returns +true+ if the word if it is valid
+  # Returns +false+ if the word is invalid
+  def validate_word(word)
+    return false if word.nil?
+
+    word = normalize_word(word)
+    word.length <= MAX_WORD_LENGTH && word =~ /^[a-z]{2,}$/
   end
-  
-  def self.initialize_dictionary
-    unless self.dictionary
-      self.dictionary = {}
-      self.blacklist = []
-      
-      # Load blacklist from text file
-      File.foreach(File.join(File.dirname(__FILE__), 'memorable_password', 'blacklist.txt'))do |word|
-        word = word.strip.downcase
-        self.blacklist << word if word =~ /^[a-z]+$/
-      end
-      
-      # Load system dictionary words
-      File.foreach("/usr/share/dict/words"){|word| add_word word}
-      
-      # Load list of proper names
-      File.foreach(File.join(File.dirname(__FILE__), 'memorable_password', 'names.txt')){|word| add_word word}
-    end
-    
-    self.dictionary
+
+  # Strips the word of carriage return characters
+  # and converts all characters to lowercase
+  def normalize_word(word)
+    word.strip.downcase
+  end
+
+  # Returns a random word. If +length+ is given, find a word with this length.
+  def word(length=nil)
+    length = @dictionary.keys.sample if !length || length > @dictionary.keys.max
+    @dictionary[length].sample if @dictionary.has_key?(length)
+  end
+
+  # Returns a random word from most long ones
+  def long_word
+    keys = @dictionary.keys.sort
+    @dictionary[keys.partition{|v| v >= keys[keys.size/2] }.first.sample].sample  # Magic! It actually just randomly picks from the larger words..
   end
-  
-  def self.add_word(word)
-    word = word.strip.downcase
-    length = word.length
-    
-    if length <= MAX_WORD_LENGTH && length > 1 && word =~ /^[a-z]+$/ && !self.blacklist.include?(word)
-      self.dictionary[length] = [] unless self.dictionary[length]
-      self.dictionary[length] << word
+
+  # Builds the blacklist from the blacklist text file
+  # Adds user-supplied banned words to the blacklist
+  def build_blacklist
+    # Load blacklisted words from blacklist files
+    blacklist_paths.each do |blacklist_path|
+      File.foreach(blacklist_path){ |word| blacklist_word(word) }
     end
+
+    # Append custom banned words to the blacklist
+    ban_list.each{ |word| blacklist_word(word) }
   end
 
-  initialize_dictionary
-  
+  # Builds the dictionary from flat files located in the dictionary_paths
+  #
+  # If the dictionary_paths option is not set, the default paths will be used
+  # including the system dictionary and a list of proper names
+  def build_dictionary
+    # Make sure the blacklist is built before building the dictionary
+    # add_word will make sure the word is not in the blacklist before adding it
+    build_blacklist
+
+    # Load dictionary words from the dictionary files
+    dictionary_paths.each do |dictionary_path|
+      File.foreach(dictionary_path){ |word| add_word(word) }
+    end
+  end
 end

data/memorable_password.gemspec

@@ -6,8 +6,8 @@ Gem::Specification.new do |s|
   s.name        = "memorable_password"
   s.version     = MemorablePassword::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Kevin McPhillips"]
-  s.email       = ["github@kevinmcphillips.ca"]
+  s.authors     = ["Kevin McPhillips", "Oleksandr Ulianytskyi"]
+  s.email       = ["github@kevinmcphillips.ca", "a.ulyanitsky@gmail.com"]
   s.homepage    = "http://github.com/kimos/memorable_password"
   s.summary     = %q{Generate human readable and easy to remember passwords}
   s.description = %q{This simple gem generates a random password that is easy to read and remember. It uses dictionary words as well as a list of proper names mixed in with numbers and special characters.}
@@ -18,4 +18,8 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
+
+  s.add_development_dependency("rspec", ">= 2.6.0")
+  s.add_development_dependency("rcov", ">= 0")
+  s.add_development_dependency("yard", ">= 0")
 end

data/spec/lib/config/custom_blacklist.txt

@@ -0,0 +1,3 @@
+list
+black
+blcklst

data/spec/lib/config/custom_dictionary.txt

@@ -0,0 +1,14 @@
+i
+to
+who
+word
+bird
+words
+worlds
+u
+tu
+two
+thou
+tour
+their
+though

data/spec/lib/config/short_dictionary.txt

@@ -0,0 +1 @@
+foo

data/spec/lib/memorable_password_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+require 'open-uri'
+
+describe MemorablePassword do
+  let(:memorable_password) do
+    default_path = "#{File.dirname(__FILE__)}/config"
+    @memorable_password ||= MemorablePassword.new(
+                              :dictionary_paths => ["#{default_path}/custom_dictionary.txt"],
+                              :blacklist_paths => ["#{default_path}/custom_blacklist.txt"])
+  end
+
+  subject {memorable_password}
+
+  describe "constructor" do
+    it "should initialize ban_list" do
+      subject.ban_list.should_not be_nil
+      subject.ban_list.should be_empty
+    end
+
+    it "should support a ban_list option" do
+      expected_ban_list = ['a','b']
+      MemorablePassword.new(:ban_list => expected_ban_list).ban_list.should == expected_ban_list
+    end
+
+    it "should support configurable dictionary paths" do
+      subject.dictionary.values.flatten.should include 'word'
+    end
+
+    it "should support configurable blacklist paths" do
+      subject.blacklist.should include 'blcklst'
+    end
+  end
+
+  describe "#add_word" do
+    it "should not add words that are less than 2 characters" do
+      subject.add_word('i')
+      subject.dictionary.values.flatten.should_not include('i')
+    end
+
+    it "should not add words that are greater than MemorablePassword::MAX_WORD_LENGTH" do
+      long_word = (0..MemorablePassword::MAX_WORD_LENGTH+1).map{|a| 'a'}.join
+      subject.add_word(long_word)
+      subject.dictionary.values.flatten.should_not include(long_word)
+    end
+
+    it "should not add words that have non-letters" do
+      subject.add_word('iask3')
+      subject.dictionary.values.flatten.should_not include('iask3')
+    end
+
+    it "should not add words that are blacklisted" do
+      blacklisted_word = subject.blacklist.first
+      subject.add_word(blacklisted_word)
+      subject.dictionary.values.flatten.should_not include(blacklisted_word)
+    end
+
+    it "should add valid words to the dictionary" do
+      valid_word = 'uhappy'
+      subject.add_word(valid_word)
+      subject.dictionary.values.flatten.should include(valid_word)
+    end
+  end
+
+  describe "#blacklist_word" do
+    it "should not add words that are less than 2 characters" do
+      subject.blacklist_word('i')
+      subject.blacklist.should_not include('i')
+    end
+
+    it "should not add words that are greater than MemorablePassword::MAX_WORD_LENGTH" do
+      long_word = (0..MemorablePassword::MAX_WORD_LENGTH+1).map{|a| 'a'}.join
+      subject.blacklist_word(long_word)
+      subject.blacklist.should_not include(long_word)
+    end
+
+    it "should not add words that have non-letters" do
+      subject.blacklist_word('iask3')
+      subject.blacklist.should_not include('iask3')
+    end
+
+    it "should add valid words to the blacklist" do
+      valid_word = 'uhappy'
+      subject.blacklist_word(valid_word)
+      subject.blacklist.should include(valid_word)
+    end
+
+    it "should remove blacklisted word from the dictionary" do
+      blacklisted_dictionary_word = subject.dictionary.values.flatten.sample
+      subject.blacklist_word(blacklisted_dictionary_word)
+      subject.dictionary.values.flatten.should_not include(blacklisted_dictionary_word)
+    end
+
+  end
+
+  describe "#generate_simple" do
+    let(:generated_password) { @generated_password ||= subject.generate_simple }
+
+    it "should return a 9-letter string" do
+      generated_password.should be_a(String)
+      generated_password.length.should eq(9)
+    end
+
+    it "should be a combination of two 4-letter dictionary words joined by a numeric character" do
+      generated_password.should =~ /^[a-z]{4}[0-1,3-7,9][a-z]{4}$/i
+    end
+
+    it "should exclude the numbers 2, 4 and 8" do
+      examples = Array.new(10) { memorable_password.generate_simple }
+      examples.should_not match_any([/[248]/])
+    end
+
+    it "should not mutate the dictionary" do
+      default_path = "#{File.dirname(__FILE__)}/config"
+      memorable_password = MemorablePassword.new(:dictionary_paths => ["#{default_path}/short_dictionary.txt"])
+
+      generated_password = memorable_password.generate_simple
+      generated_password.should =~ /foo[0-9]foo$/
+
+      generated_password = memorable_password.generate_simple
+      generated_password.should =~ /foo[0-9]foo$/
+    end
+
+  end
+
+  describe "#generate" do
+    it "should generate a random password" do
+      generated_password = memorable_password.generate
+      generated_password.should =~ /[a-z]*[0-9][a-z]*$/
+    end
+
+    it "should support the mixed_case option" do
+      generated_password = memorable_password.generate(:mixed_case => true)
+      generated_password.should =~ /[A-Z]?[a-z]*[0-9][A-Z]?[a-z]*$/
+    end
+
+    it "should support the special_characters option" do
+      generated_password = memorable_password.generate(:special_characters => true)
+      generated_password.should =~ /[a-z]*[!@$?-][a-z]*[0-9]$/
+    end
+
+    it "should support the length option" do
+      generated_password = memorable_password.generate(:length => 5)
+      generated_password.length.should == 5
+    end
+
+    it "should support the min_length option" do
+      generated_password = memorable_password.generate(:min_length => 12)
+      generated_password.length.should >= 12
+    end
+
+    it "should raise an exception if both the length and min_length options are supplied" do
+      expect {
+        memorable_password.generate(:length => 5, :min_length => 2)
+      }.should raise_exception('You cannot specify :length and :min_length at the same time')
+    end
+  end
+
+  describe "#dictionary" do
+    # TODO  determine if we should have a mechanistm to test or update the default blacklist
+    #       with words from http://www.bannedwordlist.com/lists/swearWords.txt
+    let(:default_memorable_password) do
+      @default_memorable_password ||= MemorablePassword.new
+    end
+
+    it "should not include any blacklisted words" do
+      uniq_dictionary_words = default_memorable_password.dictionary.values.flatten.uniq
+      uniq_blacklist_words = default_memorable_password.blacklist.uniq
+      (uniq_dictionary_words - uniq_blacklist_words).should == uniq_dictionary_words
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+$: << File.expand_path('../../lib', __FILE__)
+require 'rubygems'
+require 'rspec'
+require 'memorable_password'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end

data/spec/support/match_any_matcher.rb

@@ -0,0 +1,23 @@
+# Mather check that enumerable with strings match any regexp in array
+#   ["abc", "def", "abb"].should match_any([/ab/, /ss/]) # => passes
+#   ["abc", "def", "abb"].should match_any([/yz/, /ss/]) # => fails
+RSpec::Matchers.define :match_any do |patterns|
+  match do |actual|
+    actual.any? { |str| patterns.any? { |regexp| str =~ regexp } }
+  end
+
+  # TODO: make failure messages more informative
+  failure_message_for_should do |actual|
+    "expected that
+      #{actual.inspect}
+    matches any of
+      #{patterns.inspect}"
+  end
+
+  failure_message_for_should_not do |actual|
+    "expected that
+      #{actual.inspect}
+    not matches any of
+      #{patterns.inspect}"
+  end
+end

metadata

@@ -2,26 +2,70 @@
 name: memorable_password
 version: !ruby/object:Gem::Version 
   hash: 25
-  prerelease: false
+  prerelease: 
   segments: 
   - 0
-  - 0
-  - 3
-  version: 0.0.3
+  - 1
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Kevin McPhillips
+- Oleksandr Ulianytskyi
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-06-05 00:00:00 -05:00
-default_executable: 
-dependencies: []
-
+date: 2012-05-03 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 2
+        - 6
+        - 0
+        version: 2.6.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
 description: This simple gem generates a random password that is easy to read and remember. It uses dictionary words as well as a list of proper names mixed in with numbers and special characters.
 email: 
 - github@kevinmcphillips.ca
+- a.ulyanitsky@gmail.com
 executables: []
 
 extensions: []
@@ -30,6 +74,8 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
+- .rspec
+- .rvmrc
 - Gemfile
 - README.markdown
 - Rakefile
@@ -39,7 +85,12 @@ files:
 - lib/memorable_password/sample.rb
 - lib/memorable_password/version.rb
 - memorable_password.gemspec
-has_rdoc: true
+- spec/lib/config/custom_blacklist.txt
+- spec/lib/config/custom_dictionary.txt
+- spec/lib/config/short_dictionary.txt
+- spec/lib/memorable_password_spec.rb
+- spec/spec_helper.rb
+- spec/support/match_any_matcher.rb
 homepage: http://github.com/kimos/memorable_password
 licenses: []
 
@@ -69,9 +120,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: memorable_password
-rubygems_version: 1.3.7
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: Generate human readable and easy to remember passwords
 test_files: []
 
+has_rdoc: