password_policy 0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in password_policy.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Craig Russell
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,111 @@
+# Password Policy #
+
+A password policy class for Ruby    
+
+**Author** Craig Russell [craig@craig-russell.co.uk](mailto:craig@craig-russell.co.uk)      
+**Version** 0.1     
+
+Password Policy is a library that makes it easy to implement a password format policy on your application. It includes functions to return password validation errors.
+## Download ##
+
+
+## Usage ##
+
+### Getting Started ###
+
+Using Password Policy on your site is simple.
+
+1.  Install the Gem
+
+        $ gem install password_policy
+
+2.  Include the library
+
+        > require 'password_policy'
+        
+2.  Create the Password Policy object
+
+        > @policy = PasswordPolicy.new
+        
+3.  Define the policy rules
+
+        > @policy.min_length = 8;
+        > @policy.max_length = 64;
+        
+4.  Validate a password
+
+        puts "Password OK!" if @policy.validate 'passw0rd'
+
+
+## Advanced ##
+
+### Separate Policy Rules ###
+
+You can define your policy rules separately as a Hash and pass this to the constructor, rather than defining rules on the object. Hash keys should be rule identifiers, values should be the correct type. This is useful if you want to define your policy rules is a separate configuration file.
+
+    @rules = {
+      :min_length => 8,
+      :max_length => 64
+    }
+    @policy = PasswordPolicy.new @rules
+
+### Password Validation Errors ###
+
+After validating the password, any errors can be retrieved as an array of strings.
+
+    @policy.errors.each do |error|
+      puts error
+    end
+
+## Policy Rules ##
+
+A Password Policy has several rules which can be configured, these are detailed below.
+
+Policy rules have different types, a rule will ignore any attempt to set its value to an incorrect type. Please refer to the documentation below.
+
+**IMPORTANT** It is possible to define conflicting rules in a policy, which would make it impossible to set a password.
+
+    @rules = {
+      :min_length => 20,
+      :max_length => 10
+    }
+
+### Minimum Length ###
+
+The minimum length of a password
+
+**Identifier** `min_length`     
+
+    @policy.min_length = 10;
+
+### Maximum Length ###
+
+The maximum length of a password
+
+**Identifier** `max_length`     
+
+    @policy.max_length = 64;
+
+### Minimum Lower-case Characters ###
+
+The minimum number of lower-case characters allowed in a password
+
+**Identifier** `min_lowercase_chars`     
+
+    @policy.min_lowercase_chars = 1;
+
+### Minimum Uppercase Characters ###
+
+The minimum number of uppercase characters allowed in a password
+
+**Identifier** `min_uppercase_chars`     
+
+    @policy.min_uppercase_chars = 1;
+
+### Minimun Numeric Characters ###
+
+The minimum number of numeric characters allowed in a password
+
+**Identifier** `min_numeric_chars`     
+
+    @policy.min_numeric_chars = 1;

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/lib/password_policy.rb

@@ -0,0 +1,82 @@
+require_relative "password_policy/version"
+require_relative "password_policy/rules"
+
+class PasswordPolicy
+
+  # Constructor
+  #
+  # == Parameters:
+  # rules::
+  #   A Hash of rule values defining the policy
+  #
+  # == Returns:
+  #   A PasswordPolicy object
+  def initialize(rules = {})
+    
+    # Initialize error message and rule data structures
+    @errors = []
+    @rules  = {}
+
+    # Define rules
+    rule_definitions
+
+    # Define accessors for rule values
+    @rules.each do |id, rule|
+      define_singleton_method(id)       {       rule[:value] }
+      define_singleton_method("#{id}=") { |val| rule[:value] = val }
+    end
+
+    # Merge provided rules values with defaults
+    rules.each do |rule, val|
+      @rules[rule.to_sym][:value] = val
+    end
+  end
+
+  # Validate a password against the password policy
+  #
+  # == Parameters:
+  # password:
+  #   A password String to be validated
+  #
+  # == Returns:
+  #   True if the password is validated
+  #   false otherwise
+  #
+  def validate(password)
+    # Reset errors
+    @errors = []
+    # Test password against rules
+    @rules.each_value do |rule|
+      @errors << vsub(rule[:error_msg], rule[:value]) unless rule[:test].call(password)
+    end
+    # Password validated if no errors
+    @errors.length == 0
+  end
+
+  # Get a list of failed validation errors
+  #
+  # == Returns:
+  #  An Array of password error Strings
+  #
+  def errors
+    @errors
+  end
+
+  private
+
+  # Globally substitute #VAL# for val in string
+  #
+  # == Parameters:
+  # string:
+  #   The host String
+  # val:
+  #   The value to be substituted in
+  #
+  # == Returns:
+  #   The host Sting with all instances of #VAL# 
+  #   replaced with val:
+  #
+  def vsub(string, val)
+    string.gsub('#VAL#', val.to_s)
+  end
+end

data/lib/password_policy/rules.rb

@@ -0,0 +1,52 @@
+class PasswordPolicy
+
+  def rule_definitions
+    # Rule definitions are stored in the Hash @rules
+    # Hash key describes rule and is used as the accessor
+    # :value      Default value for rule (can be overridden in constructor)
+    # :error_msg  Message returned if validation fails
+    # :test       Proc returning true if password validates against rule
+
+
+    @rules[:min_length] = {
+      :value      => 8,
+      :error_msg  => 'Password must be more than #VAL# characters',
+      :test       => proc do |password| 
+        password.length >= @rules[:min_length][:value]
+      end
+    }
+
+    @rules[:max_length] = {
+      :value      => 64,
+      :error_msg  => 'Password must be less than #VAL# characters',
+      :test       => proc do |password|
+        password.length <= @rules[:max_length][:value]
+      end
+    }
+
+    @rules[:min_lowercase_chars] = {
+      :value      => 0,
+      :error_msg  => 'Password must contain at least #VAL# lowercase characters',
+      :test       => proc do |password|
+        password.scan(/[a-z]/).size >= @rules[:min_lowercase_chars][:value]
+      end
+    }
+
+    @rules[:min_uppercase_chars] = {
+      :value      => 0,
+      :error_msg  => 'Password must contain at least #VAL# uppercase characters',
+      :test       => proc do |password|
+        password.scan(/[A-Z]/).size >= @rules[:min_uppercase_chars][:value]
+      end
+    }
+
+    @rules[:min_numeric_chars] = {
+      :value      => 0,
+      :error_msg  => 'Password must contain at least #VAL# numeric characters',
+      :test       => proc do |password|
+        password.scan(/[0-9]/).size >= @rules[:min_numeric_chars][:value]
+      end
+    }
+
+  end
+end

data/lib/password_policy/version.rb

@@ -0,0 +1,3 @@
+class PasswordPolicy
+  VERSION = "0.1"
+end

data/password_policy.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/password_policy/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Craig Russell"]
+  gem.email         = ["craig@craig-russell.co.uk"]
+  gem.description   = %q{A simple password policy enforcer}
+  gem.summary       = %q{Password Policy}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "password_policy"
+  gem.require_paths = ["lib"]
+  gem.version       = PasswordPolicy::VERSION
+end

data/test/test_password_policy.rb

@@ -0,0 +1,25 @@
+require 'test/unit'
+require File.expand_path('../../lib/password_policy', __FILE__)
+
+class PasswordPolicyTests < Test::Unit::TestCase
+
+  def setup
+    @pp = PasswordPolicy.new
+  end
+
+  def test_password_policy_object
+    assert_not_nil PasswordPolicy
+    assert_equal PasswordPolicy, @pp.class
+  end
+
+  def test_error_message_method
+    assert @pp.respond_to? :errors
+    assert_equal Array, @pp.errors.class
+    assert_equal [], @pp.errors
+  end
+
+  def test_validation_method
+    assert @pp.respond_to? :validate
+    assert @pp.validate('').is_a?(TrueClass) || @pp.validate('').is_a?(FalseClass)
+  end
+end

data/test/test_rule_definitions.rb

@@ -0,0 +1,105 @@
+require 'test/unit'
+require File.expand_path('../../lib/password_policy', __FILE__)
+
+class PasswordPolicyRulesTests < Test::Unit::TestCase
+
+  def test_min_length_rule
+    assert pp1 = PasswordPolicy.new
+    assert pp2 = PasswordPolicy.new(:min_length => 6)
+
+    assert_respond_to pp1, :min_length
+    assert_respond_to pp1, :min_length=
+
+    assert_equal 8, pp1.min_length
+    assert_equal 6, pp2.min_length
+
+    assert_equal false, pp1.validate('x' * 7)
+    assert_equal true,  pp1.validate('x' * 8)
+
+    assert pp1.min_length = 10
+    assert_equal 10, pp1.min_length
+
+    assert_equal false, pp1.validate('x' * 9)
+    assert_equal true,  pp1.validate('x' * 10)
+  end
+
+  def test_max_length_rule
+    assert pp1 = PasswordPolicy.new
+    assert pp2 = PasswordPolicy.new(:max_length => 10)
+
+    assert_respond_to pp1, :max_length
+    assert_respond_to pp1, :max_length=
+
+    assert_equal 64, pp1.max_length
+    assert_equal 10, pp2.max_length
+
+    assert_equal false, pp1.validate('x' * 65)
+    assert_equal true,  pp1.validate('x' * 64)
+
+    assert pp1.max_length = 32
+    assert_equal 32, pp1.max_length
+
+    assert_equal false, pp1.validate('x' * 33)
+    assert_equal true,  pp1.validate('x' * 32)
+  end
+
+  def test_min_lowercase_chars_rule
+    assert pp1 = PasswordPolicy.new
+    assert pp2 = PasswordPolicy.new(:min_lowercase_chars => 1)
+
+    assert_respond_to pp1, :min_lowercase_chars
+    assert_respond_to pp1, :min_lowercase_chars=
+
+    assert_equal 0, pp1.min_lowercase_chars
+    assert_equal 1, pp2.min_lowercase_chars
+
+    assert_equal false, pp2.validate('ABCDEFGHI')
+    assert_equal true,  pp2.validate('AaBCDEFGHI')
+
+    assert pp1.min_lowercase_chars = 3
+    assert_equal 3, pp1.min_lowercase_chars
+
+    assert_equal false, pp1.validate('AaBbCDEFGHI')
+    assert_equal true,  pp1.validate('AaBbCcDEFGHI')
+  end
+
+  def test_min_uppercase_chars_rule
+    assert pp1 = PasswordPolicy.new
+    assert pp2 = PasswordPolicy.new(:min_uppercase_chars => 1)
+
+    assert_respond_to pp1, :min_uppercase_chars
+    assert_respond_to pp1, :min_uppercase_chars=
+
+    assert_equal 0, pp1.min_uppercase_chars
+    assert_equal 1, pp2.min_uppercase_chars
+
+    assert_equal false, pp2.validate('abcdefghi')
+    assert_equal true,  pp2.validate('aAbcdefghi')
+
+    assert pp1.min_uppercase_chars = 3
+    assert_equal 3, pp1.min_uppercase_chars
+
+    assert_equal false, pp1.validate('aAbBcdefghi')
+    assert_equal true,  pp1.validate('aAbBcCdefghi')
+  end
+
+  def test_min_numeric_chars_rule
+    assert pp1 = PasswordPolicy.new
+    assert pp2 = PasswordPolicy.new(:min_numeric_chars => 1)
+
+    assert_respond_to pp1, :min_numeric_chars
+    assert_respond_to pp1, :min_numeric_chars=
+
+    assert_equal 0, pp1.min_numeric_chars
+    assert_equal 1, pp2.min_numeric_chars
+
+    assert_equal false, pp2.validate('abcdefghi')
+    assert_equal true,  pp2.validate('abcdefghi1')
+
+    assert pp1.min_numeric_chars = 3
+    assert_equal 3, pp1.min_numeric_chars
+
+    assert_equal false, pp1.validate('abcdefghi1')
+    assert_equal true,  pp1.validate('abcdefghi123')
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: password_policy
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Craig Russell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-13 00:00:00.000000000 Z
+dependencies: []
+description: A simple password policy enforcer
+email:
+- craig@craig-russell.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/password_policy.rb
+- lib/password_policy/rules.rb
+- lib/password_policy/version.rb
+- password_policy.gemspec
+- test/test_password_policy.rb
+- test/test_rule_definitions.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: Password Policy
+test_files:
+- test/test_password_policy.rb
+- test/test_rule_definitions.rb