pwfoo 0.1.0

data/Manifest

@@ -0,0 +1,17 @@
+Manifest
+README.rdoc
+Rakefile
+features/pwfoo_calculate_password_strength.feature
+features/pwfoo_generate_random_password.feature
+features/step_definitions/password_steps.rb
+features/support/env.rb
+lib/pwfoo.rb
+lib/pwfoo/generate_password.rb
+lib/pwfoo/password_score_calculator.rb
+lib/pwfoo/password_strength.rb
+lib/pwfoo/srand_seed_generator.rb
+pwfoo.gemspec
+spec/pwfoo/generates_password_spec.rb
+spec/pwfoo/password_score_calculator_spec.rb
+spec/pwfoo/random_seed_generator_spec.rb
+spec/spec_helper.rb

data/README.rdoc

@@ -0,0 +1,3 @@
+= pwfoo
+
+== INSTALL

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new("pwfoo", "0.1.0") do |p|
+  p.author = "Perry Hertler"
+  p.summary = "A gem that generates strong random passwords, scores the strength of passwords, and generates random seeds."
+  p.url = "http://github.com/perry3819/pwfoo"
+  p.email = "perry@hertler.org"
+  p.ignore_pattern = ["tmp/*", "script/*, .idea/*"]
+  p.development_dependencies = []
+end
+
+Dir["#File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }

data/features/pwfoo_calculate_password_strength.feature

@@ -0,0 +1,21 @@
+Feature: password manager submit password
+  The password manager submits a password to receive
+  a password strength score.
+
+  Scenario Outline: submit password
+    Given the password is <password>
+    When I submit
+    Then the score should be <score>
+
+  Scenarios: valid passwords
+    | password       | score |
+    | ate*92.        | 56    |
+    | a              | 3     |
+    |                | 0     |
+    | ate*92.U1^     | 100   |
+    | 123456789      | 4     |
+    | 0*f#8G(3i      | 100   |
+    | 0*432tuvUi     | 86    |
+    | 0432tuvi       | 44    |
+    | 0432*$         | 51    |
+    

data/features/pwfoo_generate_random_password.feature

@@ -0,0 +1,13 @@
+Feature: password manager requests a random password
+  The password manager clicks generate_password to receive
+  a randomly generated strong password.
+
+  Scenario Outline: request password
+    Given the requested length is <length>
+    When I request
+    Then the generated length will be <gen_length>
+
+  Scenarios: valid lengths
+    | length | gen_length |
+    | 1      | 1          |
+    | 100    | 100        |

data/features/step_definitions/password_steps.rb

@@ -0,0 +1,29 @@
+def password_strength
+  @password_strength ||= PwFoo::PasswordStrength.new
+end
+
+Given /^the password is (.*)/ do |pw|
+   @score = password_strength.calculate_score pw
+end
+
+When /^I submit$/ do
+
+end
+
+Then /^the score should be (.*)/ do |expected_score|
+  @score.should == expected_score.to_i
+end
+
+Given /^the requested length is (.*)/ do |length|
+  @gen_password = PwFoo::GeneratePassword.new(length.to_i).generate
+end
+
+When /^I request$/ do
+
+end
+
+Then /^the generated length will be (.*)/ do | expected_length |
+  expected_length.to_i.should == @gen_password.length
+end
+
+

data/features/support/env.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__),"..","..","lib")
+require 'pwfoo'
+require 'spec/expectations'
+require 'spec/stubs/cucumber'

data/lib/pwfoo.rb

@@ -0,0 +1,4 @@
+require 'pwfoo/password_strength'
+require 'pwfoo/password_score_calculator'
+require 'pwfoo/generate_password'
+require 'pwfoo/srand_seed_generator'

data/lib/pwfoo/generate_password.rb

@@ -0,0 +1,48 @@
+module PwFoo
+  class GeneratePassword
+    LOWER_CASE = 'lower_case'
+    UPPER_CASE = 'upper_case'
+    NUMBERS = 'numbers'
+    SPECIALS = 'specials'
+
+    @@character_pool = {
+            LOWER_CASE => ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'],
+            UPPER_CASE => ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'],
+            NUMBERS => ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+            SPECIALS => ['!', '@', '#', '$', '%', '^', '*', '_', '-', '*', '(', ')']
+    }
+
+    def initialize(length = 10, *allowed_types)
+      @length = length
+      @allowed_types = allowed_types == nil || 0 == allowed_types.length ? [LOWER_CASE, UPPER_CASE, NUMBERS] : allowed_types
+      @pw_strength_finder = PasswordStrength.new
+      srand(SrandSeedGenerator.new().get_next_seed)
+    end
+
+    def generate_with_min_strength(min_strength)
+      gen = nil
+      while gen == nil || min_strength > @pw_strength_finder.calculate_score(gen) do
+        gen = generate
+      end
+      gen
+    end
+
+    def generate
+      gen_pw = ''
+      @length.times { |i|
+        gen_pw.concat next_char
+      }
+      gen_pw
+    end
+
+    def next_char
+      ta = next_type_array
+      ta[rand(ta.length)]
+    end
+
+    def next_type_array
+      @@character_pool[@allowed_types[rand(@allowed_types.length)]]
+    end
+
+  end
+end

data/lib/pwfoo/password_score_calculator.rb

@@ -0,0 +1,180 @@
+module PwFoo
+  class PasswordScoreCalculator
+    SYMBOLS_REGEX = /[^a-zA-Z0-9_]/
+    LETTERS_REGEX = /[A-Za-z]/
+    UPPER_CASE_REGEX = /[A-Z]/
+    LOWER_CASE_REGEX = /[a-z]/
+    NUMBERS_REGEX = /\d/
+
+    def initialize(word)
+      if word == nil then
+        @word = ''
+      else
+        @word = word
+      end
+    end
+
+    def number_of_characters_score
+      4 * @word.length
+    end
+
+    def upper_case_letters_score
+      case_letters_score(UPPER_CASE_REGEX)
+    end
+
+    def symbols_score
+      zero_if_empty{6 * count(SYMBOLS_REGEX)}
+    end
+
+    def numbers_score
+      return zero_if_empty{
+        count = count(NUMBERS_REGEX)
+        count < @word.length ? 4 * count : 0
+      }
+    end
+
+    def repeat_characters_deduction
+      repeats = _consecutive_count {|last, current| current == last}
+      - (repeats * (repeats - 1))
+    end
+
+    def consecutive_numbers_deduction
+      regex = NUMBERS_REGEX
+      repeats = _consecutive_count {|last, current| nil != current && nil != last && current.chr =~ regex && last.chr =~ regex}
+      return - (repeats * 2)
+    end
+
+    def consecutive_upper_case_letters_deduction
+      _consecutive_case_letters_deduction(UPPER_CASE_REGEX)
+    end
+
+    def consecutive_lower_case_letters_deduction
+      _consecutive_case_letters_deduction(LOWER_CASE_REGEX)
+    end
+
+    def _consecutive_case_letters_deduction(regex)
+      repeats = _consecutive_count {|last, current| nil != current && nil != last && current.chr =~ regex && last.chr =~ regex}
+      - (repeats * 2)
+    end
+
+    def sequential_letters_deduction
+      repeats = _three_consecutive_count(lambda {|first, second, third|
+        consec = false
+        if nil != first && first.chr =~ LETTERS_REGEX && nil != second && second.chr =~ LETTERS_REGEX && nil != third && third.chr =~ LETTERS_REGEX then
+          consec = _are_consecutive first.chr.downcase[0], second.chr.downcase[0], third.chr.downcase[0]
+        end
+        return consec
+      })
+      - (repeats * 3)
+    end
+
+    def sequential_numbers_deduction
+      repeats = _three_consecutive_count(lambda {|first, second, third|
+        consec = false
+        if nil != first && first.chr =~ NUMBERS_REGEX && nil != second && second.chr =~ NUMBERS_REGEX && nil != third && first.chr =~ NUMBERS_REGEX then
+          consec = _are_consecutive first, second, third
+        end
+        consec
+      })
+      - (repeats * 3)
+    end
+
+    def _are_consecutive(first, second, third)
+      (second == (first + 1) && third == (second + 1)) || (second == (first -1) && third == (second -1))
+    end
+
+    def _three_consecutive_count(is_consecutive)
+      repeats = 0
+      first = nil, second = nil, third = nil
+
+      0.upto(@word.length - 1) { |i|
+        first = second
+        second = third
+        third = @word[i]
+        if is_consecutive.call(first, second, third) then
+          repeats = repeats + 1
+        end
+      }
+
+      repeats
+    end
+
+    def _consecutive_count(&is_consecutive)
+      repeats = 0
+
+      cur_char = nil
+      0.upto(@word.length - 1) { |i|
+        if is_consecutive.call(cur_char, @word[i]) then
+          repeats = repeats + 1
+        end
+        cur_char = @word[i]
+      }
+
+      repeats
+    end
+
+    def letters_only_deduction
+      only_deduction(LETTERS_REGEX)
+    end
+
+    def numbers_only_deduction
+      only_deduction(NUMBERS_REGEX)
+    end
+
+    def only_deduction(regex)
+      zero_if_empty{
+        @word.length == count(regex) ? (- @word.length) : 0
+      }
+    end
+
+    def lower_case_letters_score
+      case_letters_score(/[a-z]/)
+    end
+
+    def case_letters_score(regex)
+      zero_if_empty {
+        count = count(regex)
+        count > 0 ? ((@word.length - count(regex)) * 2) : 0
+      }
+    end
+
+    def zero_if_empty(&calculator)
+      0 == number_of_characters_score ? 0 : calculator.call
+    end
+
+    def middle_numbers_or_symbols_score
+      middle = @word[1, @word.length-2]
+      @word.length < 3 ? 0 : (2 * (count(SYMBOLS_REGEX, middle) + count(NUMBERS_REGEX, middle)))
+    end
+
+    def count(regex, count_word=@word)
+      count_word.scan(regex).length
+    end
+
+    def requirements_score
+      0
+    end
+
+    def print_all
+      puts '=============================================================='
+      puts 'Score for word: ' << @word
+      puts 'Number of Characters: ' << number_of_characters_score.to_s
+      puts 'Uppercase Letters: ' << upper_case_letters_score.to_s
+      puts 'Lowercase Letters: ' << lower_case_letters_score.to_s
+      puts 'Numbers: ' << numbers_score.to_s
+      puts 'Symbols: ' << symbols_score.to_s
+      puts 'Middle Numbers or Symbols: ' << middle_numbers_or_symbols_score.to_s
+      puts 'Requirements: ' << requirements_score.to_s
+      puts 'Letters Only: ' << letters_only_deduction.to_s
+      puts 'Numbers Only: ' << numbers_only_deduction.to_s
+      puts 'Repeat Characters: ' << repeat_characters_deduction.to_s
+      puts 'Consecutive Uppercase Letters: ' << consecutive_upper_case_letters_deduction.to_s
+      puts 'Consecutive Lowercase Letters: ' << consecutive_lower_case_letters_deduction.to_s
+      puts 'Consecutive Numbers: ' << consecutive_numbers_deduction.to_s
+      puts 'Sequential Letters: ' << sequential_letters_deduction.to_s
+      puts 'Sequential Numbers: ' << sequential_numbers_deduction.to_s
+      puts '=============================================================='
+    end
+
+  end
+end

data/lib/pwfoo/password_strength.rb

@@ -0,0 +1,16 @@
+module PwFoo
+  class PasswordStrength
+    def initialize
+    end
+
+    def calculate_score(pw)
+      sc = PasswordScoreCalculator.new(pw)
+      total = sc.number_of_characters_score + sc.upper_case_letters_score + sc.lower_case_letters_score + sc.numbers_score + sc.symbols_score + sc.middle_numbers_or_symbols_score + sc.requirements_score + sc.letters_only_deduction + sc.numbers_only_deduction + sc.repeat_characters_deduction + sc.consecutive_upper_case_letters_deduction + sc.consecutive_lower_case_letters_deduction + sc.consecutive_numbers_deduction + sc.sequential_letters_deduction + sc.sequential_numbers_deduction
+      total > 100 ? 100 : total
+    end
+
+    def print_score(pw)
+      PasswordScoreCalculator.new(pw).print_all
+    end
+  end
+end

data/lib/pwfoo/srand_seed_generator.rb

@@ -0,0 +1,20 @@
+module PwFoo
+  require 'digest/md5'
+  
+  class SrandSeedGenerator
+    def initialize
+    end
+
+    def get_next_seed
+      time_in_micro = Time.new().to_f * 100000
+      checksum = _get_checksum
+
+      time_in_micro * time_in_micro + checksum.to_i
+    end
+
+    def _get_checksum
+      Digest::MD5.hexdigest(`ps axww | gzip`)
+    end
+
+  end
+end

data/pwfoo.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{pwfoo}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Perry Hertler"]
+  s.date = %q{2009-11-10}
+  s.description = %q{A gem that generates strong random passwords, scores the strength of passwords, and generates random seeds.}
+  s.email = %q{perry@hertler.org}
+  s.extra_rdoc_files = ["README.rdoc", "lib/pwfoo.rb", "lib/pwfoo/generate_password.rb", "lib/pwfoo/password_score_calculator.rb", "lib/pwfoo/password_strength.rb", "lib/pwfoo/srand_seed_generator.rb"]
+  s.files = ["Manifest", "README.rdoc", "Rakefile", "features/pwfoo_calculate_password_strength.feature", "features/pwfoo_generate_random_password.feature", "features/step_definitions/password_steps.rb", "features/support/env.rb", "lib/pwfoo.rb", "lib/pwfoo/generate_password.rb", "lib/pwfoo/password_score_calculator.rb", "lib/pwfoo/password_strength.rb", "lib/pwfoo/srand_seed_generator.rb", "pwfoo.gemspec", "spec/pwfoo/generates_password_spec.rb", "spec/pwfoo/password_score_calculator_spec.rb", "spec/pwfoo/random_seed_generator_spec.rb", "spec/spec_helper.rb"]
+  s.homepage = %q{http://github.com/perry3819/pwfoo}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Pwfoo", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{pwfoo}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{A gem that generates strong random passwords, scores the strength of passwords, and generates random seeds.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/spec/pwfoo/generates_password_spec.rb

@@ -0,0 +1,88 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+module PwFoo
+  describe GeneratePassword do
+    include GeneratePasswordHelper
+
+    before(:all) do
+      Spec::Matchers.define :be_greater_than_or_equal do |min_score|
+        match do |score|
+          score >= min_score
+        end
+      end
+    end
+
+    before(:each) do
+
+    end
+
+    context "with defaults" do
+      it "should have length of 7" do
+        PwFoo::GeneratePassword.new(7).generate.length.should == 7
+      end
+      it "should have length of 0" do
+        PwFoo::GeneratePassword.new(0).generate.length.should == 0
+      end
+      it "should have length of 1" do
+        PwFoo::GeneratePassword.new(1).generate.length.should == 1
+      end
+      it "should have length of 100" do
+        PwFoo::GeneratePassword.new(100).generate.length.should == 100
+      end
+      context "with just letters" do
+        def length_of_nonletters (word)
+          word.scan(/[^A-Za-z]/).length
+        end
+
+        it "should contain no numbers or specials" do
+          gw = PwFoo::GeneratePassword.new(12, PwFoo::GeneratePassword::LOWER_CASE, PwFoo::GeneratePassword::UPPER_CASE)
+          length_of_nonletters(gw.generate).should == 0
+          length_of_nonletters(gw.generate).should == 0
+          length_of_nonletters(gw.generate).should == 0
+          length_of_nonletters(gw.generate).should == 0
+        end
+      end
+      context "with just numbers" do
+        def length_of_nonnumbers(word)
+          word.scan(/[^0-9]/).length
+        end
+
+        it "should contain no letters or specials" do
+          gw = PwFoo::GeneratePassword.new(12, PwFoo::GeneratePassword::NUMBERS)
+          length_of_nonnumbers(gw.generate).should == 0
+          length_of_nonnumbers(gw.generate).should == 0
+          length_of_nonnumbers(gw.generate).should == 0
+          length_of_nonnumbers(gw.generate).should == 0
+        end
+      end
+      context "with just specials" do
+        def length_of_nonspecials(word)
+          word.scan(/[A-Za-z0-9]/).length
+        end
+
+        it "should contain no letters or specials" do
+          gw = PwFoo::GeneratePassword.new(12, PwFoo::GeneratePassword::SPECIALS)
+          length_of_nonspecials(gw.generate).should == 0
+          length_of_nonspecials(gw.generate).should == 0
+          length_of_nonspecials(gw.generate).should == 0
+          length_of_nonspecials(gw.generate).should == 0
+        end
+      end
+      context "with minimum strength" do
+        def generate_with_min_strength(min_s)
+          gp = PwFoo::GeneratePassword.new(12, PwFoo::GeneratePassword::SPECIALS, PwFoo::GeneratePassword::LOWER_CASE, PwFoo::GeneratePassword::UPPER_CASE, PwFoo::GeneratePassword::NUMBERS)
+          gp.generate_with_min_strength min_s
+        end
+
+        def calc_strength(word)
+          PasswordStrength.new.calculate_score(word)
+        end
+
+        it "should have a strength greater than 70" do
+          pw = generate_with_min_strength(70)
+          calc_strength(pw).should be_greater_than_or_equal( 70 )
+        end
+      end
+    end
+  end
+end

data/spec/pwfoo/password_score_calculator_spec.rb

@@ -0,0 +1,221 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+module PwFoo
+  describe PasswordScoreCalculator do
+    before(:each) do
+      @score_calculator = PwFoo::PasswordScoreCalculator.new('a4bV%(z')
+      @nil_score_calculator = PwFoo::PasswordScoreCalculator.new(nil)
+    end
+    context "with upper case letters" do
+      it "should return 12" do
+        @score_calculator.upper_case_letters_score.should == 12
+      end
+    end
+    context "with nil password" do
+      it "should return 0" do
+        @nil_score_calculator.upper_case_letters_score.should == 0
+        @nil_score_calculator.lower_case_letters_score.should == 0
+        @nil_score_calculator.symbols_score.should == 0
+        @nil_score_calculator.middle_numbers_or_symbols_score.should == 0
+        @nil_score_calculator.repeat_characters_deduction.should == 0
+        @nil_score_calculator.consecutive_upper_case_letters_deduction.should == 0
+        @nil_score_calculator.consecutive_lower_case_letters_deduction.should == 0
+        @nil_score_calculator.consecutive_numbers_deduction.should == 0
+        @nil_score_calculator.sequential_letters_deduction.should == 0
+        @nil_score_calculator.sequential_numbers_deduction.should == 0
+        @nil_score_calculator.numbers_only_deduction.should == 0
+        @nil_score_calculator.letters_only_deduction.should == 0
+        @nil_score_calculator.numbers_score.should == 0
+        @nil_score_calculator.number_of_characters_score.should == 0
+      end
+    end
+    context "with no upper case letters" do
+      it "should return 0" do
+        PwFoo::PasswordScoreCalculator.new('ate*92.').upper_case_letters_score.should == 0
+      end
+    end
+    context "with lower case letters" do
+      it "should return 8" do
+        @score_calculator.lower_case_letters_score.should == 8
+      end
+    end
+    context "with no lower case letters" do
+      it "should return 0" do
+        PwFoo::PasswordScoreCalculator.new('AA').lower_case_letters_score.should == 0
+      end
+    end
+    context "with symbols" do
+      it "should return 12" do
+        @score_calculator.symbols_score.should == 12
+      end
+    end
+    context "with no symbols" do
+      it "should return 0" do
+        PwFoo::PasswordScoreCalculator.new('AAa').symbols_score.should == 0
+      end
+    end
+    context "with middle numbers or symbols" do
+      it "should return 6" do
+        @score_calculator.middle_numbers_or_symbols_score.should == 6
+      end
+    end
+    context "with no middle numbers or symbols" do
+      it "should return 0" do
+        PwFoo::PasswordScoreCalculator.new('AAa').middle_numbers_or_symbols_score.should == 0
+      end
+    end
+    context "with no requirements score" do
+      it "should return 0" do
+        @score_calculator.requirements_score.should == 0
+      end
+    end
+    context "with repeat characters" do
+      it "should return -2" do
+        PwFoo::PasswordScoreCalculator.new('8a77bbw').repeat_characters_deduction.should == -2
+      end
+      it "should return -6" do
+        PwFoo::PasswordScoreCalculator.new('8a777bbw').repeat_characters_deduction.should == -6
+      end
+    end
+    context "with no repeat characters" do
+      it "should return 0" do
+        @score_calculator.repeat_characters_deduction.should == 0
+      end
+    end
+    context "with consecutive upper case" do
+      it "should return -2" do
+        PwFoo::PasswordScoreCalculator.new('8a77BBw').consecutive_upper_case_letters_deduction.should == -2
+      end
+      it "should return -8" do
+        PwFoo::PasswordScoreCalculator.new('8aBB777CCCCbbw').consecutive_upper_case_letters_deduction.should == -8
+      end
+    end
+    context "with no consecutive upper case" do
+      it "should return 0" do
+        @score_calculator.consecutive_upper_case_letters_deduction.should == 0
+      end
+    end
+    context "with consecutive lower case" do
+      it "should return -2" do
+        PwFoo::PasswordScoreCalculator.new('8a77zzW').consecutive_lower_case_letters_deduction.should == -2
+      end
+      it "should return -14" do
+        PwFoo::PasswordScoreCalculator.new('8abe777dddbbw').consecutive_lower_case_letters_deduction.should == -14
+      end
+    end
+    context "with no consecutive lower case" do
+      it "should return 0" do
+        @score_calculator.consecutive_lower_case_letters_deduction.should == 0
+      end
+    end
+    context "with consecutive numbers" do
+      it "should return -2" do
+        PwFoo::PasswordScoreCalculator.new('8a77zzW').consecutive_numbers_deduction.should == -2
+      end
+      it "should return -10" do
+        PwFoo::PasswordScoreCalculator.new('8abe777dddbbw8361').consecutive_numbers_deduction.should == -10
+      end
+      it "should return -16" do
+        PwFoo::PasswordScoreCalculator.new('123456789').consecutive_numbers_deduction.should == -16
+      end
+    end
+    context "with no consecutive numbers" do
+      it "should return 0" do
+        @score_calculator.consecutive_numbers_deduction.should == 0
+      end
+      it "should return 0" do
+        PwFoo::PasswordScoreCalculator.new('0*f#8G(3i').consecutive_numbers_deduction.should == 0
+      end
+    end
+    context "with sequential letters" do
+      it "should return -3" do
+        PwFoo::PasswordScoreCalculator.new('aBc872ai').sequential_letters_deduction.should == -3
+      end
+      it "should return -6" do
+        PwFoo::PasswordScoreCalculator.new('8abe777tSrQdddbbw').sequential_letters_deduction.should == -6
+      end
+    end
+    context "with no sequential letters" do
+      it "should return 0" do
+        @score_calculator.sequential_letters_deduction.should == 0
+      end
+    end
+    context "with sequential numbers" do
+      it "should return -3" do
+        PwFoo::PasswordScoreCalculator.new('aBc854372ai').sequential_numbers_deduction.should == -3
+      end
+      it "should return -3" do
+        PwFoo::PasswordScoreCalculator.new('8abe77789tSrQdddbbw').sequential_numbers_deduction.should == -3
+      end
+      it "should return -12" do
+        PwFoo::PasswordScoreCalculator.new('8abe77789tSr56789Qdddbbw').sequential_numbers_deduction.should == -12
+      end
+      it "should return -21" do
+        PwFoo::PasswordScoreCalculator.new('123456789').sequential_numbers_deduction.should == -21
+      end
+    end
+    context "with no sequential numbers" do
+      it "should return 0" do
+        @score_calculator.sequential_numbers_deduction.should == 0
+      end
+      it "should return 0" do
+        PwFoo::PasswordScoreCalculator.new('0*f#8G(3i').sequential_numbers_deduction.should == 0
+      end
+    end
+    context "with numbers only" do
+      it "should return -6" do
+        PwFoo::PasswordScoreCalculator.new('123456').numbers_only_deduction.should == -6
+      end
+      it "should return -9" do
+        PwFoo::PasswordScoreCalculator.new('123456789').numbers_only_deduction.should == -9
+      end
+    end
+    context "with no sequential numbers" do
+      it "should return 0" do
+        @score_calculator.numbers_only_deduction.should == 0
+      end
+      it "should return 0" do
+        PwFoo::PasswordScoreCalculator.new('0*f#8G(3i').numbers_only_deduction.should == 0
+      end
+    end
+    context "with letters only" do
+      it "should return -5" do
+        PwFoo::PasswordScoreCalculator.new('abcde').letters_only_deduction.should == -5
+      end
+    end
+    context "with no letters" do
+      it "should return 0" do
+        @score_calculator.letters_only_deduction.should == 0
+      end
+    end
+    context "with numbers score" do
+      it "should return 4" do
+        @score_calculator.numbers_score.should == 4
+      end
+    end
+    context "with no numbers score" do
+      it "should return 0" do
+        PwFoo::PasswordScoreCalculator.new('123456789').numbers_score.should == 0
+      end
+    end
+    context "with characters score" do
+      it "should return 28" do
+        @score_calculator.number_of_characters_score.should == 28
+      end
+    end
+    context "with count" do
+      it "should return 4" do
+        @score_calculator.count(/[A-Za-z]/).should == 4
+      end
+      it "should return 1" do
+        @score_calculator.count(/\d/).should == 1
+      end
+      it "should return 2" do
+        @score_calculator.count(/\W/).should == 2
+      end
+      it "should return 2" do
+        @score_calculator.count(/[^a-zA-Z0-9_]/).should == 2
+      end
+    end
+  end
+end

data/spec/pwfoo/random_seed_generator_spec.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+module PwFoo
+  describe SrandSeedGenerator do
+    before(:each) do
+      @seed_gen = SrandSeedGenerator.new
+    end
+    context "with different seeds" do
+      it "should not be equal" do
+        @seed_gen.get_next_seed.should_not == @seed_gen.get_next_seed
+      end
+    end
+    context "with checksum" do
+      it "should not be nil" do
+          @seed_gen._get_checksum.should_not be_nil
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__),"..","lib")
+require 'spec'
+require 'pwfoo'

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: pwfoo
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Perry Hertler
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-10 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: A gem that generates strong random passwords, scores the strength of passwords, and generates random seeds.
+email: perry@hertler.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- lib/pwfoo.rb
+- lib/pwfoo/generate_password.rb
+- lib/pwfoo/password_score_calculator.rb
+- lib/pwfoo/password_strength.rb
+- lib/pwfoo/srand_seed_generator.rb
+files: 
+- Manifest
+- README.rdoc
+- Rakefile
+- features/pwfoo_calculate_password_strength.feature
+- features/pwfoo_generate_random_password.feature
+- features/step_definitions/password_steps.rb
+- features/support/env.rb
+- lib/pwfoo.rb
+- lib/pwfoo/generate_password.rb
+- lib/pwfoo/password_score_calculator.rb
+- lib/pwfoo/password_strength.rb
+- lib/pwfoo/srand_seed_generator.rb
+- pwfoo.gemspec
+- spec/pwfoo/generates_password_spec.rb
+- spec/pwfoo/password_score_calculator_spec.rb
+- spec/pwfoo/random_seed_generator_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/perry3819/pwfoo
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Pwfoo
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: pwfoo
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A gem that generates strong random passwords, scores the strength of passwords, and generates random seeds.
+test_files: []
+