alexpass 0.1.0

data/lib/alexpass.rb

@@ -0,0 +1,91 @@
+class Alexpass
+
+  VERSION = '0.1.0'
+
+  DEFAULT_LENGTH = 8
+  DEFAULT_OPTIONS = {:length => DEFAULT_LENGTH, :memorizable => true}
+
+  # character sets divided by touch typing hands
+  LN = '12345'.split('')                   # Left-hand Numbers
+  RN = '67890' .split('')                  # Right       ''
+  LL = ('qwert'+'asdfg'+'zxcvb').split('') # Left-hand Lowercase letters
+  RL = ('yuiop'+'hjkl'+'nm').split('')     # Right        ''       ''
+  LU = LL.collect {|c| c.capitalize}       # Left-hand Uppercase letters
+  RU = RL.collect {|c| c.capitalize}       # Right        ''       ''
+
+  AMBIGUOUS = '1lI0O' + # visually ambiguous
+              '6b'      # left/right ambiguous
+
+  # patterns for even and odd length passwords;
+  # alternating hands, with the last always being on the left;
+  # only the first in each subset takes part in the "memorizable" pattern: LUUNLLNL
+  @pattern_even = [[RL], [LU, LN, LL], [RU, RN, RL], [LN, LL, LU], [RL, RU, RN], [LL, LU, LN], [RN, RL, RU], [LL]]
+
+  @pattern_odd  = [[LL], [RU, RN, RL], [LU, LN, LL], [RN, RL, RU], [LL, LU, LN], [RL, RU, RN], [LN, LL, LU], [RL]]
+
+  # return a password
+  def self.generate(options={})
+    options = self._verify_options(options)
+    password = ''
+    iterations = options[:length]/DEFAULT_LENGTH + 1
+    iterations.times { password += self._generate(options) }
+    password.slice(0...options[:length])
+  end
+
+  # return the number of permutations,
+  # and additionally print out details when options[:permutations] contains v's
+  def self.permutations(options={})
+    options = self._verify_options(options)
+    p = 1
+    pattern = options[:length].even? ? @pattern_even : @pattern_odd
+    plen = pattern.length
+    samples = []
+    (0...options[:length]).each { |i|
+      samples[i] = (options[:memorizable] ? pattern[i%plen][0] : pattern[i%plen].flatten).reject{|c| AMBIGUOUS.include?(c)}
+      p *= samples[i].length # take the product of all sample sizes to get the total number of permutations
+    }
+    if options[:permutations] =~ /^v{3,}\Z/
+      puts "sample sets:"
+      samples.each {|s|
+        puts s.inspect
+      }
+    end
+    puts "#{samples.collect {|s| s.length}.join(' * ')} permutations" if options[:permutations] =~ /^v{2,}\Z/
+    p
+  end
+
+private
+
+  # verify and return an options hash, after merging the default options with the incoming ones
+  def self._verify_options(options=nil)
+    raise ArgumentError, "expected a Hash, but got: #{options.inspect}" unless options.kind_of?(Hash)
+    options = DEFAULT_OPTIONS.merge(options)
+    raise ArgumentError, "expected :memorizable to be boolean, but got: #{options[:memorizable].inspect}" unless options[:memorizable].kind_of?(TrueClass) || options[:memorizable].kind_of?(FalseClass)
+    raise ArgumentError, "expected :length to be a Fixnum, but got: #{options[:length].inspect}" unless options[:length].kind_of?(Fixnum)
+    raise ArgumentError, "expected :length > 0, but got: #{options[:length]}" unless options[:length] > 0
+    options
+  end
+
+  # generate and return a string, having a parity-appropriate pattern, where each character is sampled from the appropriate character set (depending on whether :memorizable is true or false)
+  def self._generate(options={})
+    options = self._verify_options(options)
+    pattern = options[:length].even? ? @pattern_even : @pattern_odd
+    return pattern.collect { |i|
+      s =''
+      loop do
+        s = _sample(i[options[:memorizable] ? 0 : rand(i.length)])
+        break unless AMBIGUOUS.include?(s)
+      end
+      s
+    }.join.slice(0..-1)
+  end
+
+  # pick a random element from the given array
+  def self._sample(a=[])
+    raise ArgumentError, "expected an Array, but got: #{a.class}" unless a.kind_of?(Array)
+    raise ArgumentError, "expected a non-empty Array, but got an empty one" unless a.length > 0
+    a[rand(a.length)]
+  end
+
+end
+

data/test/test_alexpass.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+require 'test_helper'
+
+class AlexpassTest < Test::Unit::TestCase
+
+  def test__generate__default_length
+    assert_equal Alexpass::DEFAULT_LENGTH, Alexpass.generate.length
+  end
+
+  def test__generate__random_length
+    random_length = rand(20)+1
+    assert_equal random_length, Alexpass.generate(:length=>random_length).length
+  end
+
+  def test__generate__raise_exception_for_non_hash_argument
+    non_hash_argument = 10 
+    exception = assert_raise(ArgumentError) { Alexpass.generate(non_hash_argument) }
+    assert_equal "expected a Hash, but got: #{non_hash_argument}", exception.message
+  end
+
+  def test__generate__raise_exception_for_bad_memorizable_hash_value_type
+    non_boolean = {:memorizable => 10}
+    exception = assert_raise(ArgumentError) { Alexpass.generate(non_boolean) }
+    assert_equal "expected :memorizable to be boolean, but got: #{non_boolean[:memorizable].inspect}", exception.message
+  end
+
+  def test__generate__raise_exception_for_bad_length_hash_value_type
+    non_fixnum = {:length => 'A'}
+    exception = assert_raise(ArgumentError) { Alexpass.generate(non_fixnum) }
+    assert_equal "expected :length to be a Fixnum, but got: #{non_fixnum[:length].inspect}", exception.message
+  end
+
+  def test_raise_exception_for_fixnum_argument_less_than_one_to_generate_to_length
+    fixnum_argument = {:length => 0}
+    exception = assert_raise(ArgumentError) { Alexpass.generate(fixnum_argument) }
+    assert_equal "expected :length > 0, but got: #{fixnum_argument[:length].inspect}", exception.message
+  end
+
+  def test__sample
+    assert_equal 'a', Alexpass._sample(['a'])
+    assert_equal 'a', Alexpass._sample(['a', 'a', 'a'])
+    random_element = Alexpass._sample(['a', 'b', 'c'])
+    assert_equal String, random_element.class
+    assert_equal 1, random_element.length
+  end
+
+  def test__sample_raise_exception_for_non_array_argument
+    exception = assert_raise(ArgumentError) { Alexpass._sample({}) }
+    assert_equal "expected an Array, but got: Hash", exception.message
+  end
+
+  def test__sample_raise_exception_for_empty_array_argument
+    exception = assert_raise(ArgumentError) { Alexpass._sample([]) }
+    assert_equal "expected a non-empty Array, but got an empty one", exception.message
+  end
+
+  def test__permutations
+    # these hardcoded values will need to be updated if/when the character set lengths change
+    assert_equal 31752000, Alexpass.permutations
+    assert_equal 53572004640, Alexpass.permutations(:memorizable => false)
+    assert_equal 60011280000, Alexpass.permutations(:memorizable => true, :length => 11)
+    assert_equal 544505855160960, Alexpass.permutations(:memorizable => false, :length => 11)
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require 'test/unit'
+#require 'alexpass'
+require './lib/alexpass.rb'
+

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: alexpass
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Alex Batko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-10 00:00:00.000000000Z
+dependencies: []
+description: Generate passwords derived from hand-alternating, visually unambiguous,
+  alphanumeric characters.
+email:
+- alexbatko@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/alexpass.rb
+- test/test_alexpass.rb
+- test/test_helper.rb
+homepage: https://github.com/abatko/alexpass
+licenses:
+- MIT
+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.10
+signing_key: 
+specification_version: 3
+summary: Generate passwords derived from hand-alternating, visually unambiguous, alphanumeric
+  characters
+test_files:
+- test/test_alexpass.rb
+- test/test_helper.rb