sifar 0.1.0 → 0.2.0

data/.document

@@ -1,5 +1,5 @@
-README.rdoc
 lib/**/*.rb
 bin/*
+- 
 features/**/*.feature
-LICENSE
+LICENSE.txt

data/{LICENSE → LICENSE.txt}

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Suman Debnath
+Copyright (c) 2011 Suman Debnath
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -2,32 +2,103 @@
 
 Sifar can be used to check for strong passwords. Apart from the standard tests for length and homogeneity, it can check passwords that sound and spell similar to a given word.
 
-Sifar can also generate passwords that satisfy the same criteria.
+Sifar can also generate passwords that satisfy the given criteria.
+
+== Upgrade Notes
+
+Version 0.2.0 is a complete rewrite. Please check usage before upgrading.
 
 == Installation
 
 === Requirements
 
-You need english-0.4.0. This is installed automatically if ActiveMerchantCcavenue is installed as a gem.
+You need the text gem. This is installed automatically if Sifar is installed as a gem. More information on text can be found at https://github.com/threedaymonk/text.
 
-More information on english can be found at http://rubyworks.github.com/english.
+Sifar has been tested only on *nix systems.
 
-=== As a gem (recommended)
+=== As a gem
 
 Install the gem:
 
   > sudo gem install sifar
 
-To use the Sifar gem in a Rails application, add the following line in your environment.rb:
+To use the Sifar gem with bundler, add the following line in your Gemfile:
 
-  config.gem 'sifar'
+  gem 'sifar'
 
 === As a Rails plugin
 
 To add Sifar as a plugin in a Rails application, run the following command from your application root:
 
   > ./script/plugin install git@github.com:meshbrain/sifar.git
+  
+== Usage
+=== Validate
+
+  require 'sifar'
+  checker = Sifar.new ...
+  p checker.errors unless checker.check(word)
+  
+=== Generate
+
+  require 'sifar'
+  checker = Sifar.new ...
+  password = checker.generate
+
+=== Checks
+
+Checks can be used separately or in combination.
+
+==== Minimum length
+
+Password should be at least x characters long.
+
+  checker = Sifar.new :minimum_length => 8
+  checker.check('pword')                        # => false
+  checker.check('password')                     # => true
+  checker.check('longpassword')                 # => true
+
+==== Heterogeneous passwords
+
+Password should contain a mix of digits, uppercase and lowercase characters.
+
+  checker = Sifar.new :heterogeneous => true
+  checker.check('password')                     # => false
+  checker.check('Pa55w0rD')                     # => true
+
+==== Dictionary passwords
+
+Password should not contain any word from a given file.
+
+  checker = Sifar.new :dictionary => '/path/to/dictionary'
+  checker.check('indictionary')                 # => false
+
+==== Reject specific characters
+
+Password should not contain any character from a given set.
+
+  checker = Sifar.new :character_blacklist => %w(& % $)
+  checker.check('pass%word')                    # => false
+
+==== Passwords that spell similar to a given name
+
+Levenshtein distance of two words should be more than a given threshold. :name is mandatory.
+
+  checker = Sifar.new :similarity => 1, :name => 'shoeman'
+  checker.check('showman')                      # => false
+  checker.check('anothershowman')               # => false
+  checker.check('password')                     # => true
+
+==== Words that sound similar to a given name
+
+Phonetic similarity of two words should be more than a given threshold. :name is mandatory.
+
+  checker = Sifar.new :phonetic_similarity => 1, :name => 'suman'
+  checker.check('showman')                      # => false
+  checker.check('password')                     # => true
+
+NOTE: This check uses metaphone; and might not work as expected in all languages.
 
 == Copyright
 
-Copyright (c) 2010 Suman Debnath. See LICENSE for details.
+Copyright (c) 2011 Suman Debnath. See LICENSE for details.

data/Rakefile

@@ -1,37 +1,34 @@
 require 'rubygems'
 require 'rake'
 
-begin
-    require 'jeweler'
-    Jeweler::Tasks.new do |gem|
-        gem.name = 'sifar'
-        gem.summary = %Q{A library to generate strong passwords and check password strength.}
-        gem.description = %Q{Sifar can be used to check for strong passwords. Apart from the standard tests for length and homogeneity, it can check passwords that sound and spell similar to a given word. Sifar can also generate passwords that satisfy the same criteria.}
-        gem.email = 'contact@meshbrain.com'
-        gem.homepage = 'http://github.com/meshbrain/sifar'
-        gem.authors = ['Suman Debnath']
-        gem.add_development_dependency 'rspec', '~> 1.2'
-        gem.add_dependency 'english', '= 0.4.0'
-    end
-    Jeweler::GemcutterTasks.new
-rescue LoadError
-    puts 'Jeweler (or a dependency) not available. Install it with: gem install jeweler'
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+    gem.name = 'sifar'
+    gem.homepage = 'http://github.com/meshbrain/sifar'
+    gem.license = 'MIT'
+    gem.summary = %Q{A library to generate strong passwords and check password strength.}
+    gem.description = %Q{Sifar can be used to check for strong passwords. Apart from the standard tests for length and homogeneity, it can check passwords that sound and spell similar to a given word. Sifar can also generate passwords that satisfy the same criteria.}
+    gem.email = 'contact@meshbrain.com'
+    gem.authors = ['Suman Debnath']
+    gem.add_dependency 'text', '~> 0.2.0'
+    gem.add_development_dependency 'rspec', '~> 2.3.0'
+    #gem.add_development_dependency 'bundler', '~> 1.0.0'
+    gem.add_development_dependency 'jeweler', '~> 1.5.2'
+    gem.add_development_dependency 'rcov', '>= 0'
 end
+Jeweler::RubygemsDotOrgTasks.new
 
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-    spec.libs << 'lib' << 'spec'
-    spec.spec_files = FileList['spec/**/*_spec.rb']
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+    spec.pattern = FileList['spec/**/*_spec.rb']
 end
 
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-    spec.libs << 'lib' << 'spec'
+RSpec::Core::RakeTask.new(:rcov) do |spec|
     spec.pattern = 'spec/**/*_spec.rb'
     spec.rcov = true
 end
 
-task :spec => :check_dependencies
-
 task :default => :spec
 
 require 'rake/rdoctask'
@@ -39,7 +36,7 @@ Rake::RDocTask.new do |rdoc|
     version = File.exist?('VERSION') ? File.read('VERSION') : ''
 
     rdoc.rdoc_dir = 'rdoc'
-    rdoc.title = "sifar #{version}"
+    rdoc.title = 'sifar #{version}'
     rdoc.rdoc_files.include('README*')
     rdoc.rdoc_files.include('lib/**/*.rb')
 end

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/sifar.rb

@@ -1,170 +1,132 @@
 require 'rubygems'
-gem 'english', '= 0.4.0'
+require 'text'
+require 'digest'
 
 class Sifar
-    attr_accessor :errors
-
-    def initialize
-        @checks = {
-            'L' => :check_length,
-            'D' => :check_dictionary,
-            'H' => :check_heterogeneity,
-            'W' => :check_word_blacklist,
-            'C' => :check_char_blacklist,
-            'P' => :check_phonetic,
-            'T' => :check_similarity,
-            'S' => :check_string
-        }
+  attr_accessor :errors
+
+  def initialize(options = {}, error_messages = {})
+    set_opt options, error_messages
+  end
+
+  def check(word)
+    @errors = []
+
+    check_length(word) unless @options[:minimum_length].nil?
+    check_dictionary(word) unless @options[:dictionary].nil?
+    check_character_blacklist(word) unless @options[:character_blacklist].nil?
+    check_phonetic(word, @options[:name]) unless @options[:phonetic_similarity].nil?
+    check_similarity(word, @options[:name]) unless @options[:similarity].nil?
+
+    check_heterogeneity(word) if true == @options[:heterogeneous]
+
+    1 > @errors.length
+  end
+
+  def generate
+    n = 0
+    begin
+      n += 1
+      word = create
+    end until true == check(word)
+    word
+  end
+
+  private
+  def create
+    max = @options[:minimum_length] || 8
+    seed = (0..max).map{|i| (32 + rand(126-32)).chr}.join
+    Digest::SHA1.hexdigest(seed)[0..max]
+  end
+
+  def check_length(word)
+    @errors << @error_messages[:length] if word.length < @options[:minimum_length].to_i
+  end
+
+  def check_heterogeneity(word)
+    num_chars = word.length
+    num = {}
+    num[:upper] = word.gsub(/[^[:upper:]]/, '').length
+    num[:lower] = word.gsub(/[^[:lower:]]/, '').length
+    num[:digit] = word.gsub(/[^[:digit:]]/, '').length
+    num[:special] = num_chars - (num[:upper] + num[:lower] + num[:digit])
+
+    max = 4 > num_chars ? 3 : num_chars - 3
+    num.each_value do |value|
+      if value > max
+        @errors << @error_messages[:heter]
+        return false
+      end
     end
 
-    def check_password(password, name = '', options = {}, error_messages = {})
-        self.set_opt options, error_messages
-        @errors = []
+    true
+  end
 
-        self.check_strength(password)
-        self.check_against_name(password, name) unless name.empty?
-
-        1 > @errors.length
-    end
-
-    def generate_password(name = '', options = {}, error_messages = {})
-        self.set_opt options, error_messages
-    end
-
-    def check_strength(password)
-        @options[:password_check_type].each(''){|option| self.send(@checks[option], password)}
-    end
-
-    def check_against_name(password, name)
-        @options[:name_check_type].each(''){|option| self.send(@checks[option], password, name)}
-    end
-
-    def check_length(word)
-        @errors << @error_messages[:length] if word.length < @options[:minimum_length]
+  def check_dictionary(word)
+    if File.readable? @options[:dictionary]
+      @errors << @error_messages[:dict] if find_word_in_file(word, @options[:dictionary])
+    else
+      @errors << @error_messages[:config_blackword]
     end
+  end
 
-    def check_heterogeneity(word)
-        num_chars = word.length
-        num = {}
-        num[:upper] = word.gsub(/[^[:upper:]]/, '').length
-        num[:lower] = word.gsub(/[^[:lower:]]/, '').length
-        num[:digit] = word.gsub(/[^[:digit:]]/, '').length
-        num[:special] = num_chars - (num[:upper] + num[:lower] + num[:digit])
-
-        max = 4 > num_chars ? 3 : num_chars - 3
-        num.each do |type, value|
-            if value > max
-                @errors << @error_messages[:heter]
-                return false
-            end
-        end
-
-        true
-    end
-
-    def check_dictionary(word)
-        if File.readable? @options[:dictionary]
-            @errors << @error_messages[:dict] if find_word_in_file(word, @options[:dictionary])
-        else
-            @errors << @error_messages[:config_blackword]
-        end
-    end
+  def check_character_blacklist(word)
+    pattern = /#{@options[:character_blacklist].map{|c| Regexp.escape c}.join('|')}/i
+    @errors << @error_messages[:config_blackword] unless pattern.match(word).nil?
+  end
 
-    def check_word_blacklist(word)
-        if File.readable? @options[:word_blacklist]
-            @errors << @error_messages[:blackword] if find_word_in_file(word, @options[:word_blacklist])
-        else
-            @errors << @error_messages[:config_dict]
-        end
+  def check_phonetic(word, name)
+    unless @options[:phonetic_similarity] < Text::Levenshtein.distance(Text::Metaphone.metaphone(word), Text::Metaphone.metaphone(name))
+      @errors << @error_messages[:phonetic]
+      return false
     end
-
-    def check_char_blacklist(word)
-        if File.readable? @options[:char_blacklist]
-            File.open(@options[:char_blacklist]) do |f|
-                f.readlines.each do |char|
-                    char = char.strip
-                    if not(char.empty?) and word.include?(char)
-                        @errors << @error_messages[:blackchar]
-                        return false
-                    end
-                end
-            end
-        else
-            @errors << @error_messages[:config_blackchar]
-            return false
-        end
-        true
-    end
-
-    def check_phonetic(password, name)
-        require 'english/levenshtein'
-        require 'english/soundex'
-        unless 2 < English::Levenshtein.distance(password.soundex, name.soundex)
-            @errors << @error_messages[:phonetic]
-            return false
-        end
-        true
-    end
-
-    def check_similarity(password, name)
-        require 'english/similarity'
-        if 0.8 < password.similarity(name)
-            @errors << @error_messages[:similar]
-            return false
-        end
-        true
-    end
-
-    def check_string(password, name)
-        longer, shorter = password.size > name.size ? [password, name] : [name, password]
-        if longer.include?(shorter)
-            @errors << @error_messages[:similar]
-            return false
-        end
-        true
-    end
-
-    def find_word_in_file(word, file)
-        t = []
-        IO.popen("#{@options[:grep_path]} -ixs '#{word}' #{file}") {|io|
-            r = io.readlines
-            t << r unless r.empty?
-        }
-        not t.empty?
-    end
-
-    def set_opt(options = {}, error_messages = {})
-        @options = {
-            :minimum_length => 8,
-            :password_check_type => 'LD',
-            :name_check_type => 'S',
-            :dictionary => '',
-            :word_blacklist => '',
-            :char_blacklist => '',
-            :error_msg_hash => {},
-            :umlaut_hash => {},
-            :grep_path => '/bin/grep'
-        }.merge options
-        @options[:minimum_length] = 1 > @options[:minimum_length] ? 8 : @options[:minimum_length]
-        @options[:password_check_type] = @options[:password_check_type].gsub(/[^DLHWC]/, '').split('').sort.join
-        @options[:name_check_type] = @options[:name_check_type].gsub(/[^PTS]/, '').split('').sort.join
-
-        raise ArgumentError, 'grep not found' unless (File.stat(@options[:grep_path]).executable? rescue false)
-
-        @error_messages = {
-            :length => 'The password is too short!',
-            :similar => 'The password is too similar to the given name!',
-            :phonetic => 'The password sounds too similar to the given name!',
-            :dict => 'The password is based upon a dictionary word!',
-            :heter => 'The password is too homogeneous!',
-            :blackword => 'The password is based upon a blacklsited word!',
-            :blackchar => 'The password contains a blacklisted character!',
-            :similar_looking_chars => 'The password contains  similar looking  characters!',
-            :config_blackchar => 'Could not load a valid blacklisted character file!',
-            :config_blackword => 'Could not load a valid blacklisted word file!',
-            :config_dict => 'Could not load a valid dictionary file!',
-            :config_heter => 'Conflict in heterogeneity check and password generation configuration!',
-            :config_length => 'Generated password length cannot be less then specified minimum length!'
-        }.merge error_messages
+    true
+  end
+
+  def check_similarity(word, name)
+    longer, shorter = [word, name].sort{|x,y| y.size <=> x.size}
+    unless !longer.include?(shorter) and @options[:similarity] < Text::Levenshtein.distance(longer, shorter)
+      @errors << @error_messages[:similar]
+      return false
     end
+    true
+  end
+
+  def find_word_in_file(word, file)
+    t = []
+    IO.popen("#{@options[:grep_path]} -ixs '#{word}' #{file}") {|io|
+      r = io.readlines
+      t << r unless r.empty?
+    }
+    not t.empty?
+  end
+
+  def set_opt(options = {}, error_messages = {})
+    @options = {
+      :password_check_type => 'LD',
+      :name_check_type => 'S',
+      :error_msg_hash => {},
+      :umlaut_hash => {},
+      :grep_path => `which grep`.chomp
+    }.merge options
+
+    raise ArgumentError, 'grep not found' unless (File.stat(@options[:grep_path]).executable? rescue false)
+
+    @error_messages = {
+      :length => 'The password is too short!',
+      :similar => 'The password is too similar to the given name!',
+      :phonetic => 'The password sounds too similar to the given name!',
+      :dict => 'The password is based upon a dictionary word!',
+      :heter => 'The password is too homogeneous!',
+      :blackword => 'The password is based upon a blacklsited word!',
+      :blackchar => 'The password contains a blacklisted character!',
+      :similar_looking_chars => 'The password contains  similar looking  characters!',
+      :config_blackchar => 'Could not load a valid blacklisted character file!',
+      :config_blackword => 'Could not load a valid blacklisted word file!',
+      :config_dict => 'Could not load a valid dictionary file!',
+      :config_heter => 'Conflict in heterogeneity check and password generation configuration!',
+      :config_length => 'Generated password length cannot be less then specified minimum length!'
+    }.merge error_messages
+    @errors ||= []
+  end
 end

data/sifar.gemspec

@@ -1,43 +1,41 @@
 # Generated by jeweler
 # DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{sifar}
-  s.version = "0.1.0"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Suman Debnath"]
-  s.date = %q{2010-10-01}
+  s.date = %q{2011-01-28}
   s.description = %q{Sifar can be used to check for strong passwords. Apart from the standard tests for length and homogeneity, it can check passwords that sound and spell similar to a given word. Sifar can also generate passwords that satisfy the same criteria.}
   s.email = %q{contact@meshbrain.com}
   s.extra_rdoc_files = [
-    "LICENSE",
-     "README.rdoc"
+    "LICENSE.txt",
+    "README.rdoc"
   ]
   s.files = [
     ".document",
-     ".gitignore",
-     "LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "init.rb",
-     "lib/sifar.rb",
-     "sifar.gemspec",
-     "spec/sifar_spec.rb",
-     "spec/spec.opts",
-     "spec/spec_helper.rb"
+    ".rspec",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/sifar.rb",
+    "sifar.gemspec",
+    "spec/sifar_spec.rb",
+    "spec/spec_helper.rb"
   ]
   s.homepage = %q{http://github.com/meshbrain/sifar}
-  s.rdoc_options = ["--charset=UTF-8"]
+  s.licenses = ["MIT"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.7}
   s.summary = %q{A library to generate strong passwords and check password strength.}
   s.test_files = [
-    "spec/spec_helper.rb",
-     "spec/sifar_spec.rb"
+    "spec/sifar_spec.rb",
+    "spec/spec_helper.rb"
   ]
 
   if s.respond_to? :specification_version then
@@ -45,15 +43,21 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, ["~> 1.2"])
-      s.add_runtime_dependency(%q<english>, ["= 0.4.0"])
+      s.add_runtime_dependency(%q<text>, ["~> 0.2.0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
     else
-      s.add_dependency(%q<rspec>, ["~> 1.2"])
-      s.add_dependency(%q<english>, ["= 0.4.0"])
+      s.add_dependency(%q<text>, ["~> 0.2.0"])
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
     end
   else
-    s.add_dependency(%q<rspec>, ["~> 1.2"])
-    s.add_dependency(%q<english>, ["= 0.4.0"])
+    s.add_dependency(%q<text>, ["~> 0.2.0"])
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
   end
 end
 

data/spec/sifar_spec.rb

@@ -1,7 +1,108 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe "Sifar" do
-  it "fails" do
-    fail "hey buddy, you should probably rename this file and start specing for real"
+describe Sifar, 'when testing for minimum length' do
+  it 'accepts words equal or bigger than given length' do
+    checker = Sifar.new :minimum_length => 8
+
+    checker.check(password(8)).should == true
+    checker.check(password(10)).should == true
+  end
+
+  it 'rejects words smaller than given length' do
+    checker = Sifar.new :minimum_length => 8
+
+    checker.check(password(7)).should == false
+  end
+end
+
+describe Sifar, 'when testing for heterogeneity' do
+  it 'accepts heterogeneous words' do
+    checker = Sifar.new :heterogeneous => true
+
+    checker.check('aA34zX9j').should == true
+  end
+
+  it 'rejects homogeneous words' do
+    checker = Sifar.new :heterogeneous => true
+
+    checker.check(password(10)).should == false
   end
 end
+
+describe Sifar, 'when testing for dictionary words' do
+  it 'rejects words in dictionary' do
+    word = password(10)
+
+    temporary_file(word) do |dictionary|
+      checker = Sifar.new :dictionary => dictionary
+      checker.check(word).should == false
+    end
+  end
+
+  it 'accepts words not in dictionary' do
+    temporary_file('indictionary') do |dictionary|
+      checker = Sifar.new :dictionary => dictionary
+      checker.check('notindictionary').should == true
+    end
+  end
+end
+
+describe Sifar, 'when testing for blacklisted characters' do
+  it 'rejects words with blacklisted characters' do
+    checker = Sifar.new :character_blacklist => %w(& % $)
+    checker.check('blacklisted&character').should == false
+  end
+
+  it 'accepts words without blacklisted characters' do
+    checker = Sifar.new :character_blacklist => %w(& % $)
+    checker.check('blacklistedcharacter').should == true
+  end
+end
+
+describe Sifar, 'when testing for similar spelling' do
+  it 'rejects words with similarity equal or more than the given threshold' do
+    checker = Sifar.new :similarity => 1, :name => 'shoeman'
+    checker.check('showman').should == false
+    checker.check('anothershoeman').should == false
+  end
+
+  it 'accepts words with similarity less than the given threshold' do
+    checker = Sifar.new :similarity => 1, :name => 'password'
+    checker.check('pa55word').should == true
+  end
+end
+
+describe Sifar, 'when testing for similar pronounciation' do
+  it 'rejects words with phonetic similarity equal or more than the given threshold' do
+    checker = Sifar.new :phonetic_similarity => 1, :name => 'suman'
+    checker.check('showman').should == false
+  end
+
+  it 'accepts words with phonetic similarity less than the given threshold' do
+    checker = Sifar.new :phonetic_similarity => 1, :name => 'password'
+    checker.check('firstpassword').should == true
+  end
+end
+
+describe Sifar, 'when generating passwords' do
+  it 'passes all checks' do
+    temporary_file('indictionary') do |dictionary|
+      checks = {
+        :minimum_length => 8,
+        :dictionary => dictionary,
+        :character_blacklist => %w(& % $),
+        :phonetic_similarity => 2,
+        :similarity => 2
+      }
+
+      c = checks.keys
+      (1..c.size).each do |n|
+        c.combination(n).each do |options|
+          checker = Sifar.new checks.reject{|key, value| !options.include?(key)}.merge({:name => 'suman'})
+          password = checker.generate
+          checker.check(password).should == true
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,9 +1,23 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
 require 'sifar'
-require 'spec'
-require 'spec/autorun'
+require 'tmpdir'
 
-Spec::Runner.configure do |config|
-  
+module SifarHelperMethods
+    def password(num)
+        (0...num).map{ ('a'..'z').to_a[rand(26)] }.join
+    end
+
+    def temporary_file(text, &block)
+        temp_file = File.join(Dir.tmpdir, 'sifar_temporary_file')
+        open(temp_file, 'w'){ |f| f.write text }
+        block.call temp_file
+        File.delete temp_file
+    end
 end
+
+RSpec.configure do |config|
+    config.before(:each) {}
+    include SifarHelperMethods
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sifar
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Suman Debnath
@@ -15,40 +15,71 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-01 00:00:00 +05:30
+date: 2011-01-28 00:00:00 +05:30
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: text
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 11
+        hash: 23
         segments: 
-        - 1
+        - 0
         - 2
-        version: "1.2"
-  type: :development
+        - 0
+        version: 0.2.0
+  type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: english
+  name: rspec
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - "="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 15
+        hash: 3
         segments: 
+        - 2
+        - 3
         - 0
-        - 4
-        - 0
-        version: 0.4.0
-  type: :runtime
+        version: 2.3.0
+  type: :development
   version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
 description: Sifar can be used to check for strong passwords. Apart from the standard tests for length and homogeneity, it can check passwords that sound and spell similar to a given word. Sifar can also generate passwords that satisfy the same criteria.
 email: contact@meshbrain.com
 executables: []
@@ -56,28 +87,26 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- LICENSE
+- LICENSE.txt
 - README.rdoc
 files: 
 - .document
-- .gitignore
-- LICENSE
+- .rspec
+- LICENSE.txt
 - README.rdoc
 - Rakefile
 - VERSION
-- init.rb
 - lib/sifar.rb
 - sifar.gemspec
 - spec/sifar_spec.rb
-- spec/spec.opts
 - spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/meshbrain/sifar
-licenses: []
-
+licenses: 
+- MIT
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -106,5 +135,5 @@ signing_key:
 specification_version: 3
 summary: A library to generate strong passwords and check password strength.
 test_files: 
-- spec/spec_helper.rb
 - spec/sifar_spec.rb
+- spec/spec_helper.rb

data/.gitignore

@@ -1,24 +0,0 @@
-## MAC OS
-.DS_Store
-
-## TEXTMATE
-*.tmproj
-tmtags
-
-## EMACS
-*~
-\#*
-.\#*
-
-## VIM
-*.swp
-
-## Netbeans
-nbproject
-
-## PROJECT::GENERAL
-coverage
-rdoc
-pkg
-
-## PROJECT::SPECIFIC

data/init.rb

@@ -1 +0,0 @@
-require 'sifar'