alexpass 0.1.0 → 0.1.1

data/lib/alexpass.rb

@@ -1,90 +1,16 @@
 class Alexpass
 
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
+  DEPRECATED = 'Sorry, but this gem has been replaced by Altpass: https://github.com/abatko/altpass'
 
-  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])
+    warn DEPRECATED
+    DEPRECATED
   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)]
+    warn DEPRECATED
+    DEPRECATED
   end
 
 end

data/test/test_alexpass.rb

@@ -3,63 +3,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)
+  def test__deprecated
+    assert_equal Alexpass::DEPRECATED, Alexpass.generate
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: alexpass
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,10 +9,10 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-10 00:00:00.000000000Z
+date: 2012-12-14 00:00:00.000000000Z
 dependencies: []
-description: Generate passwords derived from hand-alternating, visually unambiguous,
-  alphanumeric characters.
+description: ! 'Sorry, but this gem has been replaced by Altpass: https://github.com/abatko/altpass
+  (sorry!)'
 email:
 - alexbatko@gmail.com
 executables: []
@@ -46,8 +46,7 @@ rubyforge_project:
 rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: Generate passwords derived from hand-alternating, visually unambiguous, alphanumeric
-  characters
+summary: ! 'Sorry, but this gem has been replaced by Altpass: https://github.com/abatko/altpass'
 test_files:
 - test/test_alexpass.rb
 - test/test_helper.rb