memorable_strings 0.1.0

data/CHANGELOG.rdoc

@@ -0,0 +1,25 @@
+== master
+
+== 0.1.0 / 2009-04-18
+
+* Add :print_friendly option to skip ambiguous characters [Nate Kontny]
+* Add better tests
+* Add more documentation
+* Redesign phoneme / consonant / vowel / digit logic to be in separate classes
+* Move Password.generate to String.memorable
+* Rename to memorable_strings
+
+== 0.0.3 / 2009-01-11
+
+* Add compatibility with Ruby 1.9+
+
+== 0.0.2 / 2008-05-05
+
+* Update documentation
+
+== 0.0.1 / 2007-09-26
+
+* Add documentation
+* Fix licensing
+* Add unit tests
+* Rename to password_generator

data/LICENSE

@@ -0,0 +1,15 @@
+Copyright (C) 2002-2006 Ian Macdonald, 2006-2009 Aaron Pfeifer
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software Foundation,
+Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

data/README.rdoc

@@ -0,0 +1,49 @@
+= memorable_strings
+
++memorable_strings+ generates strings that can be easily remembered.
+
+== Resources
+
+API
+
+* http://api.pluginaweek.org/memorable_strings
+
+Bugs
+
+* http://pluginaweek.lighthouseapp.com/projects/13282-memorable_strings
+
+Development
+
+* http://github.com/pluginaweek/memorable_strings
+
+Source
+
+* git://github.com/pluginaweek/memorable_strings.git
+
+== Description
+
+Certain strings like passwords are often difficult to remember, especially if
+they are simply a random combination of letters and numbers.  With
++memorable_strings+, strings are generated based on a set of rules that
+combine phonemes in a manner that makes the sequence of characters more
+memorable.  When used in combination with features like generating passwords,
+this can help improve the user experience.
+
+== Usage
+
+  String.memorable                                    # => "maikipeo"
+  String.memorable(:length => 5)                      # => "quoge"
+  String.memorable(:capital => true)                  # => "Bukievai"
+  String.memorable(:digit => true)                    # => "ood4yosa"
+  String.memorable(:capital => true, :digit => true)  # => "Goodah5e"
+  String.memorable(:print_friendly => true)           # => "ahkeehav"
+
+See MemorableStrings::Extensions::String for more information.
+
+== Dependencies
+
+None.
+
+== References
+
+* Ian Macdonald - {ruby-password}[http://raa.ruby-lang.org/project/ruby-password]

data/Rakefile

@@ -0,0 +1,88 @@
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
+
+spec = Gem::Specification.new do |s|
+  s.name              = 'memorable_strings'
+  s.version           = '0.1.0'
+  s.platform          = Gem::Platform::RUBY
+  s.summary           = 'Generates strings that can be easily remembered'
+  
+  s.files             = FileList['{lib,test}/**/*'] + %w(CHANGELOG.rdoc init.rb LICENSE Rakefile README.rdoc)
+  s.require_path      = 'lib'
+  s.has_rdoc          = true
+  s.test_files        = Dir['test/**/*_test.rb']
+  
+  s.author            = 'Aaron Pfeifer'
+  s.email             = 'aaron@pluginaweek.org'
+  s.homepage          = 'http://www.pluginaweek.org'
+  s.rubyforge_project = 'pluginaweek'
+end
+  
+desc 'Default: run all tests.'
+task :default => :test
+
+desc "Test the #{spec.name} plugin."
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.test_files = spec.test_files
+  t.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  namespace :test do
+    desc "Test the #{spec.name} plugin with Rcov."
+    Rcov::RcovTask.new(:rcov) do |t|
+      t.libs << 'lib'
+      t.test_files = spec.test_files
+      t.rcov_opts << '--exclude="^(?!lib/)"'
+      t.verbose = true
+    end
+  end
+rescue LoadError
+end
+
+desc "Generate documentation for the #{spec.name} plugin."
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = spec.name
+  rdoc.template = '../rdoc_template.rb'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc', 'CHANGELOG.rdoc', 'LICENSE', 'lib/**/*.rb')
+end
+  
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+desc 'Publish the beta gem.'
+task :pgem => [:package] do
+  Rake::SshFilePublisher.new('aaron@pluginaweek.org', '/home/aaron/gems.pluginaweek.org/public/gems', 'pkg', "#{spec.name}-#{spec.version}.gem").upload
+end
+
+desc 'Publish the API documentation.'
+task :pdoc => [:rdoc] do
+  Rake::SshDirPublisher.new('aaron@pluginaweek.org', "/home/aaron/api.pluginaweek.org/public/#{spec.name}", 'rdoc').upload
+end
+
+desc 'Publish the API docs and gem'
+task :publish => [:pgem, :pdoc, :release]
+
+desc 'Publish the release files to RubyForge.'
+task :release => [:gem, :package] do
+  require 'rubyforge'
+  
+  ruby_forge = RubyForge.new.configure
+  ruby_forge.login
+  
+  %w(gem tgz zip).each do |ext|
+    file = "pkg/#{spec.name}-#{spec.version}.#{ext}"
+    puts "Releasing #{File.basename(file)}..."
+    
+    ruby_forge.add_release(spec.rubyforge_project, spec.name, spec.version, file)
+  end
+end

data/init.rb

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

data/lib/memorable_strings/consonant.rb

@@ -0,0 +1,21 @@
+require 'memorable_strings/phoneme'
+
+module MemorableStrings
+  # Represents a phoneme that begins with a consonant letter
+  class Consonant < Phoneme
+    # Generates a phoneme of at most the given length that should follow this
+    # consononant.
+    # 
+    # This will always generate a vowel.
+    def next(stack, maxlength, &block)
+      Vowel.random(maxlength, &block)
+    end
+    
+    # Bootstrap
+    add %w(c f h j k m n p r t v w x y ch ph th)
+    add %w(b d g q s z qu sh), :print_friendly => :downcase
+    add :l, :print_friendly => false
+    add :ng, :first => false
+    add :gh, :first => false, :print_friendly => :downcase
+  end
+end

data/lib/memorable_strings/digit.rb

@@ -0,0 +1,18 @@
+require 'memorable_strings/phoneme'
+
+module MemorableStrings
+  # Represents a single-digit character
+  class Digit < Phoneme
+    # Generates a phoneme of at most the given length that should follow this
+    # digit.
+    # 
+    # This will always randomly generate either a vowel or a consonant.
+    def next(stack, maxlength, &block)
+      Phoneme.first(maxlength, &block)
+    end
+    
+    # Bootstrap
+    add %w(3 4 7 9)
+    add %w(0 1 2 5 6 8), :print_friendly => false
+  end
+end

data/lib/memorable_strings/extensions/string.rb

@@ -0,0 +1,91 @@
+require 'memorable_strings/phoneme'
+require 'memorable_strings/digit'
+require 'memorable_strings/vowel'
+require 'memorable_strings/consonant'
+
+module MemorableStrings
+  module Extensions #:nodoc:
+    # Adds support for easily generating memorable strings
+    module String
+      # Generates a string based on a set of rules defining which characters
+      # should be grouped together to form a memorable sequence.
+      # 
+      # Configuration options:
+      # * <tt>:length</tt> - The length of the string to generate.  Default is 8.
+      # * <tt>:capital</tt> - Whether to include a capital letter.  Default is false.
+      # * <tt>:digit</tt> - Whether to include a digit.  Default is false.
+      # * <tt>:print_friendly</tt> - Whether to only include characters that
+      #   are unambiguous when printed out.  This includes: B8G6I1l0OQDS5Z2
+      # 
+      # == Examples
+      # 
+      #   String.memorable                                    # => "maikipeo"
+      #   String.memorable(:length => 5)                      # => "quoge"
+      #   String.memorable(:capital => true)                  # => "Bukievai"
+      #   String.memorable(:digit => true)                    # => "ood4yosa"
+      #   String.memorable(:capital => true, :digit => true)  # => "Goodah5e"
+      # 
+      # == Algorithm
+      # 
+      # See MemorableStrings::Consonant, MemorableStrings::Vowel, and
+      # MemorableStrings::Digit for more information about how it's determined
+      # which characters are allowed to follow which other characters.
+      def memorable(options = {})
+        invalid_keys = options.keys - [:length, :capital, :digit, :print_friendly]
+        raise ArgumentError, "Invalid key(s): #{invalid_keys.join(', ')}" unless invalid_keys.empty?
+        
+        length = options[:length] || 8
+        raise ArgumentError, 'Length must be at least 1' if length < 1
+        raise ArgumentError, 'Length must be at least 3 if using digits' if length < 3 && options[:digit]
+        
+        value = nil
+        conditions = lambda {|phoneme| options[:print_friendly] ? phoneme.print_friendly?(:downcase) : true}
+        
+        begin
+          value = ''
+          stack = []
+          left = length
+          flags = options.dup
+          phoneme = nil
+          
+          begin
+            if !phoneme
+              # Special-case first
+              phoneme = Phoneme.first(left, &conditions)
+            elsif flags[:digit] && stack.length >= 2 && rand(10) < 3
+              # Add digit in >= 3rd spot (30% chance)
+              flags.delete(:digit) 
+              phoneme = Digit.random(1, &conditions)
+            else
+              # Choose next based on current phoneme
+              phoneme = phoneme.next(stack, left, &conditions)
+            end
+            
+            # Track the phoneme
+            stack << phoneme
+            value << phoneme.value
+            left -= phoneme.length
+            
+            # Capitalize the first letter, phoneme after or a digit, or a consonant (30% chance)
+            if flags[:capital]
+              previous = stack[-2]
+              upcase_allowed = !options[:print_friendly] || phoneme.print_friendly?(:upcase)
+              context_allowed = !previous || previous.is_a?(Digit) || phoneme.is_a?(Consonant)
+              
+              if upcase_allowed && context_allowed && rand(10) < 3
+                flags.delete(:capital)
+                value[-phoneme.length, 1] = value[-phoneme.length, 1].upcase!
+              end
+            end
+          end while left > 0
+        end while [:capital, :digit].any? {|key| flags.include?(key)}
+        
+        value
+      end
+    end
+  end
+end
+
+String.class_eval do
+  extend MemorableStrings::Extensions::String
+end

data/lib/memorable_strings/phoneme.rb

@@ -0,0 +1,116 @@
+module MemorableStrings
+  # A unit of sound that can be used to build a larger string.  Phonemes have
+  # no semantic meaning themselves, but have sound types and characteristics
+  # associated with them that are helpful in building a discernable word.
+  class Phoneme
+    class << self
+      # The collection of phonemes
+      attr_reader :all
+      
+      # Adds a new phoneme of the current class's type.
+      # 
+      # See Phoneme#new for more information.
+      def add(*values)
+        options = values.last.is_a?(Hash) ? values.pop : {}
+        
+        values.flatten!
+        values.map! do |value|
+          (@all ||= []) << value = new(value, options)
+          value
+        end
+        values.length == 1 ? values.first : values
+      end
+      
+      # Generates a random phoneme for the current class of at most the given
+      # length.  In addition, an optional block can be used to determine
+      # whether the chosen phoneme is acceptable.
+      # 
+      # == Examples
+      # 
+      #   # Choose any vowel
+      #   MemorableStrings::Vowel.random
+      #   # => #<MemorableStrings::Vowel:0xb7c3efe4 @first=true, @value="e", @length=1>
+      #   
+      #   # Choose a vowel with at most 1 character
+      #   MemorableStrings::Vowel.random(2)
+      #   # => <MemorableStrings::Vowel:0xb7c3eb34 @first=true, @value="u", @length=1>
+      #   
+      #   # Choose a vowel that can be the first letter
+      #   MemorableStrings::Vowel.random {|vowel| vowel.first?}
+      #   # => #<MemorableStrings::Vowel:0xb7c3e080 @first=true, @value="a", @length=1>
+      def random(maxlength = nil, &block)
+        phonemes = all
+        phonemes = phonemes.select {|phoneme| phoneme.length <= maxlength} if maxlength
+        
+        begin
+          phoneme = phonemes[rand(phonemes.size)]
+        end while !phoneme.matches?(&block)
+        
+        phoneme
+      end
+      
+      # Generates a random phoneme of at most the given length.  This will
+      # only randomly choose from the following sounds that are allowed to be
+      # the first character:
+      # * Vowel
+      # * Consonant
+      # 
+      # == Examples
+      # 
+      #   MemorableStrings::Phoneme.first(1)
+      #   #<MemorableStrings::Consonant:0xb7c38248 @first=true, @value="x", @length=1>
+      #   
+      #   MemorableStrings::Phoneme.first(2)
+      #   #<MemorableStrings::Vowel:0xb7c3e2b0 @first=true, @value="ae", @length=2>
+      def first(maxlength, &block)
+        (rand(2) == 1 ? Vowel : Consonant).random(maxlength) do |phoneme|
+          phoneme.first? && phoneme.matches?(&block)
+        end
+      end
+    end
+    
+    # The character(s) representing this phoneme
+    attr_reader :value
+    
+    # The number of characters
+    attr_reader :length
+    
+    # Creates a new phoneme with the given value and configuration options.
+    # 
+    # Configuration options:
+    # * <tt>:first</strong> - Whether it can be used as the first value in a
+    #   string.  Default is true.
+    # * <tt>:print_friendly</strong> - Whether the characters are unambiguous
+    #   when printed.  This can be set to one of the following values:
+    #   * <tt>true</tt> - Always print-friendly (default)
+    #   * <tt>:downcase</tt> - Only print-friendly when in lower case
+    #   * <tt>:upcase</tt> - Only print-friendly when in upper case
+    #   * <tt>false</tt> - Never print-friendly
+    def initialize(value, options = {})
+      invalid_keys = options.keys - [:first, :print_friendly]
+      raise ArgumentError, "Invalid key(s): #{invalid_keys.join(', ')}" unless invalid_keys.empty?
+      
+      options = {:first => true, :print_friendly => true}.merge(options)
+      
+      @value = value.to_s
+      @length = @value.length
+      @first = options[:first]
+      @print_friendly = options[:print_friendly]
+    end
+    
+    # Is this allowed to be the first in a sequence of phonemes?
+    def first?
+      @first
+    end
+    
+    # Is this character unambiguous with other characters?
+    def print_friendly?(context)
+      @print_friendly == true || @print_friendly == context
+    end
+    
+    # Does this phoneme match the conditions specified by the block?
+    def matches?
+      !block_given? || yield(self)
+    end
+  end
+end

data/lib/memorable_strings/vowel.rb

@@ -0,0 +1,29 @@
+require 'memorable_strings/phoneme'
+
+module MemorableStrings
+  # Represents a phoneme that begins with a vowel letter
+  class Vowel < Phoneme
+    # Generates a phoneme of at most the given length that should follow this
+    # vowel.
+    # 
+    # If the last two characters in the stack (including this one) were
+    # vowels, then this will always generate a consonant.  Otherwise, 40% of
+    # the time it will generate a single-character vowel and 60% of the time
+    # it will generate a consonant.
+    # 
+    # It is never possible for two consecutive vowel phonemes to result in
+    # more than 2 vowel characters in the stack.
+    def next(stack, maxlength, &block)
+      previous = stack[-2]
+      if previous && previous.is_a?(Vowel) || length > 1 || rand(10) > 3
+        Consonant.random(1, &block)
+      else
+        Vowel.random(1, &block)
+      end
+    end
+    
+    # Bootstrap
+    add %w(a e u ae ah ee)
+    add %w(i o ai ei ie oh oo), :print_friendly => false
+  end
+end

data/lib/memorable_strings.rb

@@ -0,0 +1,5 @@
+require 'memorable_strings/extensions/string'
+
+# Provides the ability to generate strings that can be easily remembered
+module MemorableStrings
+end

data/test/consonant_test.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ConsonantNextTest < Test::Unit::TestCase
+  def setup
+    setup_phonemes
+    
+    MemorableStrings::Vowel.all << @a = MemorableStrings::Vowel.new(:a)
+    @b = MemorableStrings::Consonant.new(:b)
+    @stack = [@b]
+  end
+  
+  def test_should_generate_a_vowel
+    assert_equal @a, @b.next(@stack, 2)
+  end
+  
+  def test_should_allow_block_conditional
+    MemorableStrings::Vowel.all << @c = MemorableStrings::Vowel.new(:c)
+    MemorableStrings::Vowel.expects(:rand).with(2).times(2).returns(1, 0)
+    
+    assert_equal @a, @b.next(@stack, 2) {|phoneme| phoneme.value == 'a'}
+  end
+  
+  def teardown
+    teardown_phonemes
+  end
+end

data/test/digit_test.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class DigitNextTest < Test::Unit::TestCase
+  def setup
+    setup_phonemes
+    
+    @digit = MemorableStrings::Digit.new(1)
+    @stack = [@digit]
+  end
+  
+  def test_should_generate_vowel_half_the_time
+    MemorableStrings::Vowel.all << @a = MemorableStrings::Vowel.new(:a)
+    
+    MemorableStrings::Vowel.expects(:rand).at_least_once.returns(0)
+    MemorableStrings::Phoneme.expects(:rand).with(2).returns(1)
+    
+    assert_equal @a, @digit.next(@stack, 2)
+  end
+  
+  def test_should_generate_consonant_half_the_time
+    MemorableStrings::Consonant.all << @b = MemorableStrings::Vowel.new(:b)
+    
+    MemorableStrings::Consonant.expects(:rand).at_least_once.returns(0)
+    MemorableStrings::Phoneme.expects(:rand).with(2).returns(0)
+    
+    assert_equal @b, @digit.next(@stack, 2)
+  end
+  
+  def test_should_allow_block_conditional
+    MemorableStrings::Consonant.all << @b = MemorableStrings::Vowel.new(:b)
+    MemorableStrings::Consonant.all << @c = MemorableStrings::Vowel.new(:c)
+    MemorableStrings::Consonant.expects(:rand).with(2).times(2).returns(1, 0)
+    MemorableStrings::Phoneme.expects(:rand).with(2).returns(0)
+    
+    assert_equal @b, @digit.next(@stack, 2) {|phoneme| phoneme.value == 'b'}
+  end
+  
+  def teardown
+    teardown_phonemes
+  end
+end

data/test/phoneme_test.rb

@@ -0,0 +1,220 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class PhonemeByDefaultTest < Test::Unit::TestCase
+  def setup
+    @phoneme = MemorableStrings::Phoneme.new(:a)
+  end
+  
+  def test_should_have_a_value
+    assert_equal 'a', @phoneme.value
+  end
+  
+  def test_should_have_a_length
+    assert_equal 1, @phoneme.length
+  end
+  
+  def test_should_be_allowed_to_be_first
+    assert @phoneme.first?
+  end
+  
+  def test_should_be_print_friendly_with_downcase_context
+    assert @phoneme.print_friendly?(:downcase)
+  end
+  
+  def test_should_be_print_friendly_with_upcase_context
+    assert @phoneme.print_friendly?(:upcase)
+  end
+end
+
+class PhonemeTest < Test::Unit::TestCase
+  def test_should_raise_exception_if_invalid_option_specified
+    assert_raise(ArgumentError) { MemorableStrings::Phoneme.new(:a, :invalid => true) }
+  end
+end
+
+class PhonemeWithMultipleCharactersTest < Test::Unit::TestCase
+  def setup
+    @phoneme = MemorableStrings::Phoneme.new(:ab)
+  end
+  
+  def test_should_have_a_value
+    assert_equal 'ab', @phoneme.value
+  end
+  
+  def test_should_have_a_length
+    assert_equal 2, @phoneme.length
+  end
+  
+  def test_should_be_allowed_to_be_first
+    assert @phoneme.first?
+  end
+end
+
+class PhonemeNotFirstTest < Test::Unit::TestCase
+  def setup
+    @phoneme = MemorableStrings::Phoneme.new(:a, :first => false)
+  end
+  
+  def test_should_not_be_allowed_to_be_first
+    assert !@phoneme.first?
+  end
+end
+
+class PhonemeNotPrintFriendlyTest < Test::Unit::TestCase
+  def setup
+    @phoneme = MemorableStrings::Phoneme.new(:i, :print_friendly => false)
+  end
+  
+  def test_should_not_be_print_friendly_with_downcase_context
+    assert !@phoneme.print_friendly?(:downcase)
+  end
+  
+  def test_should_not_be_print_friendly_with_upcase_context
+    assert !@phoneme.print_friendly?(:upcase)
+  end
+end
+
+class PhonemeContextPrintFriendlyTest < Test::Unit::TestCase
+  def setup
+    @phoneme = MemorableStrings::Phoneme.new(:b, :print_friendly => :downcase)
+  end
+  
+  def test_should_be_print_friendly_with_downcase_context
+    assert @phoneme.print_friendly?(:downcase)
+  end
+  
+  def test_should_not_be_print_friendly_with_upcase_context
+    assert !@phoneme.print_friendly?(:upcase)
+  end
+end
+
+class PhonemeMatchingTest < Test::Unit::TestCase
+  def setup
+    @phoneme = MemorableStrings::Phoneme.new(:a)
+  end
+  
+  def test_should_match_if_no_block_given
+    assert @phoneme.matches?
+  end
+  
+  def test_should_pass_self_into_block
+    context = nil
+    @phoneme.matches? {|*args| context = args}
+    
+    assert_equal [@phoneme], context
+  end
+  
+  def test_should_match_if_block_is_not_false
+    assert @phoneme.matches? {true}
+  end
+  
+  def test_should_not_match_if_block_is_false
+    assert !@phoneme.matches? {false}
+  end
+end
+
+class PhonemeCreationTest < Test::Unit::TestCase
+  def test_should_add_phoneme_to_collection
+    phoneme = MemorableStrings::Phoneme.add(:a)
+    
+    assert_equal [phoneme], MemorableStrings::Phoneme.all
+    assert_equal 'a', phoneme.value
+  end
+  
+  def test_should_allow_multiple_phonemes
+    phonemes = MemorableStrings::Phoneme.add(:a, :b, :c, :first => false)
+    
+    assert_equal 3, phonemes.length
+    assert_equal phonemes, MemorableStrings::Phoneme.all
+    assert phonemes.all? {|phoneme| !phoneme.first?}
+  end
+  
+  def test_should_allow_phoneme_arraye
+    phonemes = MemorableStrings::Phoneme.add([:a, :b, :c], :first => false)
+    
+    assert_equal 3, phonemes.length
+    assert_equal phonemes, MemorableStrings::Phoneme.all
+    assert phonemes.all? {|phoneme| !phoneme.first?}
+  end
+  
+  def teardown
+    MemorableStrings::Phoneme.all.clear
+  end
+end
+
+class PhonemeRandomTest < Test::Unit::TestCase
+  def setup
+    @a, @b, @ab = MemorableStrings::Phoneme.add(:a, :b, :ab)
+  end
+  
+  def test_should_select_any_phoneme
+    MemorableStrings::Phoneme.expects(:rand).with(3).returns(0)
+    assert_equal @a, MemorableStrings::Phoneme.random
+    
+    MemorableStrings::Phoneme.expects(:rand).with(3).returns(1)
+    assert_equal @b, MemorableStrings::Phoneme.random
+  end
+  
+  def test_should_restrict_selection_based_on_maxlength
+    MemorableStrings::Phoneme.expects(:rand).with(2).returns(0)
+    assert_equal @a, MemorableStrings::Phoneme.random(1)
+  end
+  
+  def teardown
+    MemorableStrings::Phoneme.all.clear
+  end
+end
+
+class PhonemeRandomWithBlockTest < Test::Unit::TestCase
+  def setup
+    @a, @b = MemorableStrings::Phoneme.add(:a, :b)
+  end
+  
+  def test_should_select_phoneme_that_returns_true
+    MemorableStrings::Phoneme.expects(:rand).with(2).returns(0)
+    assert_equal @a, MemorableStrings::Phoneme.random {|phoneme| phoneme.value == 'a'}
+    
+    MemorableStrings::Phoneme.expects(:rand).with(2).times(2).returns(1, 0)
+    assert_equal @a, MemorableStrings::Phoneme.random {|phoneme| phoneme.value == 'a'}
+  end
+  
+  def teardown
+    MemorableStrings::Phoneme.all.clear
+  end
+end
+
+class PhonemeFirstTest < Test::Unit::TestCase
+  def setup
+    setup_phonemes
+    
+    MemorableStrings::Vowel.all << @a = MemorableStrings::Vowel.new(:a)
+    MemorableStrings::Consonant.all << @b = MemorableStrings::Consonant.new(:b)
+  end
+  
+  def test_should_select_vowel_half_the_time
+    MemorableStrings::Vowel.expects(:rand).with(1).returns(0)
+    MemorableStrings::Phoneme.expects(:rand).with(2).returns(1)
+    
+    assert_equal @a, MemorableStrings::Phoneme.first(1)
+  end
+  
+  def test_should_select_consonant_half_the_time
+    MemorableStrings::Consonant.expects(:rand).with(1).returns(0)
+    MemorableStrings::Phoneme.expects(:rand).with(2).returns(0)
+    
+    assert_equal @b, MemorableStrings::Phoneme.first(1)
+  end
+  
+  def test_should_not_select_phonemes_marked_as_not_first
+    c = MemorableStrings::Consonant.add(:c, :first => false)
+    
+    MemorableStrings::Consonant.expects(:rand).with(2).times(2).returns(1, 0)
+    MemorableStrings::Phoneme.expects(:rand).with(2).returns(0)
+    
+    assert_equal @b, MemorableStrings::Phoneme.first(1)
+  end
+  
+  def teardown
+    teardown_phonemes
+  end
+end

data/test/string_test.rb

@@ -0,0 +1,234 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class StringByDefaultTest < Test::Unit::TestCase
+  def setup
+    @value = String.memorable
+  end
+  
+  def test_should_have_8_characters
+    assert_equal 8, @value.length
+  end
+  
+  def test_should_not_include_capital_letter
+    assert_no_match /[A-Z]/, @value
+  end
+  
+  def test_should_not_include_digit
+    assert_no_match /[0-9]/, @value
+  end
+  
+  def test_should_be_consistent
+    consistent = (1..1000).each do
+      value = String.memorable
+      value =~ /^[a-z]+$/
+    end
+    
+    assert consistent
+  end
+end
+
+class StringTest < Test::Unit::TestCase
+  def test_should_raise_exception_if_invalid_option_specified
+    assert_raise(ArgumentError) { String.memorable(:invalid => true) }
+  end
+  
+  def test_should_raise_exception_if_invalid_length
+    assert_raise(ArgumentError) { String.memorable(:length => -1) }
+    assert_raise(ArgumentError) { String.memorable(:length => 0) }
+    assert_nothing_raised { String.memorable(:length => 1) }
+  end
+  
+  def test_should_raise_exception_if_length_too_short_with_digits
+    assert_raise(ArgumentError) { String.memorable(:length => 1, :digit => true) }
+    assert_raise(ArgumentError) { String.memorable(:length => 2, :digit => true) }
+    assert_nothing_raised { String.memorable(:length => 3, :digit => true) }
+  end
+end
+
+class StringWithCustomLengthTest < Test::Unit::TestCase
+  def setup
+    @value = String.memorable(:length => 2)
+  end
+  
+  def test_should_use_custom_length
+    assert_equal 2, @value.length
+  end
+end
+
+class StringWithCapitalTest < Test::Unit::TestCase
+  def setup
+    @value = String.memorable(:capital => true)
+  end
+  
+  def test_should_have_8_characters
+    assert_equal 8, @value.length
+  end
+  
+  def test_include_capital
+    assert_match /[A-Z]/, @value
+  end
+  
+  def test_should_not_include_digit
+    assert_no_match /[0-9]/, @value
+  end
+  
+  def test_should_capitalize_with_length_of_1
+    @value = String.memorable(:capital => true, :length => 1)
+    assert_equal 1, @value.length
+    assert_equal @value.upcase, @value
+  end
+  
+  def test_should_be_consistent
+    consistent = (1..1000).all? do
+      value = String.memorable(:capital => true)
+      value =~ /^[a-z]*[A-Z][a-z]*$/
+    end
+    
+    assert consistent
+  end
+end
+
+class StringWithDigitTest < Test::Unit::TestCase
+  def setup
+    @value = String.memorable(:digit => true)
+  end
+  
+  def test_should_have_8_characters
+    assert_equal 8, @value.length
+  end
+  
+  def test_not_include_capital
+    assert_no_match /[A-Z]/, @value
+  end
+  
+  def test_should_include_digit
+    assert_match /[0-9]/, @value
+  end
+  
+  def test_should_always_use_last_character_with_length_of_3
+    @value = String.memorable(:digit => true, :length => 3)
+    assert_equal 3, @value.length
+    assert_match /[0-9]/, @value[-1, 1]
+  end
+  
+  def test_should_be_consistent
+    consistent = (1..1000).all? do
+      value = String.memorable(:digit => true)
+      value =~ /^[a-z]+[0-9]{1}[a-z]*$/
+    end
+    
+    assert consistent
+  end
+end
+
+class StringWithCapitalAndDigitTest < Test::Unit::TestCase
+  def setup
+    @value = String.memorable(:capital => true, :digit => true)
+  end
+  
+  def test_should_have_8_characters
+    assert_equal 8, @value.length
+  end
+  
+  def test_include_capital
+    assert_match /[A-Z]/, @value
+  end
+  
+  def test_should_include_digit
+    assert_match /[0-9]/, @value
+  end
+  
+  def test_should_be_consistent
+    consistent = (1..1000).all? do
+      value = String.memorable(:capital => true, :digit => true)
+      value =~ /^[a-z]*([A-Z][a-z]*[0-9]|[0-9][a-z]*[A-Z])[a-z]*$/
+    end
+    
+    assert consistent
+  end
+end
+
+class StringWithPrintFriendlyTest < Test::Unit::TestCase
+  def setup
+    @value = String.memorable(:print_friendly => true)
+  end
+  
+  def test_should_have_8_characters
+    assert_equal 8, @value.length
+  end
+  
+  def test_not_include_capital
+    assert_no_match /[A-Z]/, @value
+  end
+  
+  def test_should_not_include_digit
+    assert_no_match /[0-9]/, @value
+  end
+  
+  def test_should_not_include_ambiguous_letters
+    assert_no_match /lio/, @value
+  end
+  
+  def test_should_be_consistent
+    consistent = (1..1000).all? do
+      value = String.memorable(:print_friendly => true)
+      value =~ /^[^lio]*$/
+    end
+    
+    assert consistent
+  end
+end
+
+class StringWithPrintFriendlyAndCapitalTest < Test::Unit::TestCase
+  def setup
+    @value = String.memorable(:print_friendly => true, :capital => true)
+  end
+  
+  def test_should_include_capital
+    assert_match /[A-Z]/, @value
+  end
+  
+  def test_should_not_include_digit
+    assert_no_match /[0-9]/, @value
+  end
+  
+  def test_should_not_include_ambiguous_letters
+    assert_no_match /lioBDGQSZIO/, @value
+  end
+  
+  def test_should_be_consistent
+    consistent = (1..1000).all? do
+      value = String.memorable(:print_friendly => true, :capital => true)
+      value =~ /^[^lioBDGQSZIO]*$/
+    end
+    
+    assert consistent
+  end
+end
+
+class StringWithPrintFriendlyAndDigitTest < Test::Unit::TestCase
+  def setup
+    @value = String.memorable(:print_friendly => true, :digit => true)
+  end
+  
+  def test_should_not_include_capital
+    assert_no_match /[A-Z]/, @value
+  end
+  
+  def test_should_include_digit
+    assert_match /[0-9]/, @value
+  end
+  
+  def test_should_not_include_ambiguous_letters
+    assert_no_match /lio012568/, @value
+  end
+  
+  def test_should_be_consistent
+    consistent = (1..1000).all? do
+      value = String.memorable(:print_friendly => true, :digit => true)
+      value =~ /^[^lio012568]*$/
+    end
+    
+    assert consistent
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,31 @@
+require 'test/unit'
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require File.dirname(__FILE__) + '/../init'
+
+# Force mocha to be installed
+begin
+  require 'rubygems'
+  require 'mocha'
+rescue LoadError
+  $stderr.puts "Mocha is not installed. `gem install mocha` and try again."
+  exit
+end
+
+Test::Unit::TestCase.class_eval do
+  def setup_phonemes
+    @vowels = MemorableStrings::Vowel.all.dup
+    @consonants = MemorableStrings::Consonant.all.dup
+    @digits = MemorableStrings::Digit.all.dup
+    
+    MemorableStrings::Vowel.all.clear
+    MemorableStrings::Consonant.all.clear
+    MemorableStrings::Digit.all.clear
+  end
+  
+  def teardown_phonemes
+    MemorableStrings::Vowel.all.replace(@vowels)
+    MemorableStrings::Consonant.all.replace(@consonants)
+    MemorableStrings::Digit.all.replace(@digits)
+  end
+end

data/test/vowel_test.rb

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class VowelWithPreviousVowelTest < Test::Unit::TestCase
+  def setup
+    setup_phonemes
+    
+    MemorableStrings::Consonant.all << @b = MemorableStrings::Vowel.new(:b)
+    MemorableStrings::Consonant.all << @br = MemorableStrings::Vowel.new(:br)
+    
+    @previous = MemorableStrings::Vowel.new(:a)
+    @vowel = MemorableStrings::Vowel.new(:e)
+    @stack = [@previous, @vowel]
+  end
+  
+  def test_should_generate_consonant_with_one_character
+    MemorableStrings::Consonant.expects(:rand).with(1).returns(0)
+    assert_equal @b, @vowel.next(@stack, 2)
+  end
+  
+  def teardown
+    teardown_phonemes
+  end
+end
+
+class VowelWithMultipleCharactersTest < Test::Unit::TestCase
+  def setup
+    setup_phonemes
+    
+    MemorableStrings::Consonant.all << @b = MemorableStrings::Vowel.new(:b)
+    MemorableStrings::Consonant.all << @br = MemorableStrings::Vowel.new(:br)
+    
+    @previous = MemorableStrings::Consonant.new(:c)
+    @vowel = MemorableStrings::Vowel.new(:ai)
+    @stack = [@previous, @vowel]
+  end
+  
+  def test_should_generate_consonant_with_one_character
+    MemorableStrings::Consonant.expects(:rand).with(1).returns(0)
+    assert_equal @b, @vowel.next(@stack, 2)
+  end
+  
+  def teardown
+    teardown_phonemes
+  end
+end
+
+class VowelNextTest < Test::Unit::TestCase
+  def setup
+    setup_phonemes
+    
+    @previous = MemorableStrings::Consonant.new(:c)
+    @vowel = MemorableStrings::Vowel.new(:a)
+    @stack = [@previous, @vowel]
+  end
+  
+  def test_should_generate_vowel_forty_percent_the_time
+    MemorableStrings::Vowel.all << @e = MemorableStrings::Vowel.new(:e)
+    MemorableStrings::Vowel.all << @ee = MemorableStrings::Vowel.new(:ee)
+    
+    (0..3).each do |value|
+      @vowel.expects(:rand).with(10).returns(value)
+      MemorableStrings::Vowel.expects(:rand).with(1).returns(0)
+      
+      assert_equal @e, @vowel.next(@stack, 2)
+    end
+  end
+  
+  def test_should_generate_consonant_sixty_percent_the_time
+    MemorableStrings::Consonant.all << @b = MemorableStrings::Vowel.new(:b)
+    MemorableStrings::Consonant.all << @br = MemorableStrings::Vowel.new(:br)
+    
+    (4..9).each do |value|
+      @vowel.expects(:rand).with(10).returns(value)
+      MemorableStrings::Consonant.expects(:rand).with(1).returns(0)
+      
+      assert_equal @b, @vowel.next(@stack, 2)
+    end
+  end
+  
+  def test_should_allow_block_conditional
+    MemorableStrings::Consonant.all << @b = MemorableStrings::Vowel.new(:b)
+    MemorableStrings::Consonant.all << @c = MemorableStrings::Vowel.new(:c)
+    MemorableStrings::Consonant.expects(:rand).with(2).times(2).returns(1, 0)
+    @vowel.expects(:rand).returns(4)
+    
+    assert_equal @b, @vowel.next(@stack, 2) {|phoneme| phoneme.value == 'b'}
+  end
+  
+  def teardown
+    teardown_phonemes
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: memorable_strings
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Aaron Pfeifer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-18 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: 
+email: aaron@pluginaweek.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/memorable_strings.rb
+- lib/memorable_strings
+- lib/memorable_strings/vowel.rb
+- lib/memorable_strings/consonant.rb
+- lib/memorable_strings/extensions
+- lib/memorable_strings/extensions/string.rb
+- lib/memorable_strings/digit.rb
+- lib/memorable_strings/phoneme.rb
+- test/test_helper.rb
+- test/consonant_test.rb
+- test/string_test.rb
+- test/phoneme_test.rb
+- test/digit_test.rb
+- test/vowel_test.rb
+- CHANGELOG.rdoc
+- init.rb
+- LICENSE
+- Rakefile
+- README.rdoc
+has_rdoc: true
+homepage: http://www.pluginaweek.org
+post_install_message: 
+rdoc_options: []
+
+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: "0"
+  version: 
+requirements: []
+
+rubyforge_project: pluginaweek
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Generates strings that can be easily remembered
+test_files: 
+- test/consonant_test.rb
+- test/string_test.rb
+- test/phoneme_test.rb
+- test/digit_test.rb
+- test/vowel_test.rb