Pull in some changes from thetron#47

Author: williamatodd

README.md

@@ -152,6 +152,8 @@ generated character, and are as follows:
 
 * `%s` - any uppercase, lowercase, or numeric character
 * `%w` - any uppercase, or lowercase character
+* `%a` - any lowercase, or numeric character
+* `%A` - any uppercase, or numeric character
 * `%c` - any lowercase character
 * `%C` - any uppercase character
 * `%d` - any digit

lib/mongoid/token/generator.rb

@@ -1,4 +1,6 @@
 # proposed pattern options
+# %a - lowercase alphanumeric character
+# %A - uppercase alphanumeric character
 # %c - lowercase character
 # %C - uppercase character
 # %d - digit
@@ -12,7 +14,7 @@
 module Mongoid
   module Token
     module Generator
-      REPLACE_PATTERN = /%((?<character>[cCdDhHpsw]{1})(?<length>\d+(,\d+)?)?)/
+      REPLACE_PATTERN = /%((?<character>[aAcCdDhHpsw]{1})(?<length>\d+(,\d+)?)?)/
 
       def self.generate(pattern)
         pattern.gsub REPLACE_PATTERN do |match|
@@ -21,6 +23,10 @@ def self.generate(pattern)
           length = [match_data[:length].to_i, 1].max
 
           case type
+          when 'a'
+            alphanumeric(length).downcase
+          when 'A'
+            alphanumeric(length).upcase
           when 'c'
             down_character(length)
           when 'C'
@@ -38,42 +44,45 @@ def self.generate(pattern)
           when 'w'
             alpha(length)
           when 'p'
-            "-"
+            '-'
           end
         end
       end
 
-      private
-      def self.rand_string_from_chars(chars, length = 1)
-        Array.new(length).map{ chars.sample }.join
-      end
+      class << self
+        private
 
-      def self.down_character(length = 1)
-        self.rand_string_from_chars ('a'..'z').to_a, length
-      end
+        def rand_string_from_chars(chars, length = 1)
+          Array.new(length).map { chars.sample }.join
+        end
 
-      def self.up_character(length = 1)
-        self.rand_string_from_chars ('A'..'Z').to_a, length
-      end
+        def down_character(length = 1)
+          rand_string_from_chars ('a'..'z').to_a, length
+        end
 
-      def self.integer(length = 1, base = 10)
-        (rand(base**length - base**(length-1)) + base**(length-1)).to_s(base)
-      end
+        def up_character(length = 1)
+          rand_string_from_chars ('A'..'Z').to_a, length
+        end
 
-      def self.digits(length = 1, base = 10)
-        rand(base**length).to_s(base).rjust(length, "0")
-      end
+        def integer(length = 1, base = 10)
+          (rand(base**length - base**(length - 1)) + base**(length - 1)).to_s(base)
+        end
 
-      def self.alpha(length = 1)
-        self.rand_string_from_chars (('A'..'Z').to_a + ('a'..'z').to_a), length
-      end
+        def digits(length = 1, base = 10)
+          rand(base**length).to_s(base).rjust(length, '0')
+        end
 
-      def self.alphanumeric(length = 1)
-        (1..length).collect { (i = Kernel.rand(62); i += ((i < 10) ? 48 : ((i < 36) ? 55 : 61 ))).chr }.join
-      end
+        def alpha(length = 1)
+          rand_string_from_chars (('A'..'Z').to_a + ('a'..'z').to_a), length
+        end
+
+        def alphanumeric(length = 1)
+          (1..length).collect { (i = Kernel.rand(62); i += ((i < 10) ? 48 : ((i < 36) ? 55 : 61))).chr }.join
+        end
 
-      def self.punctuation(length = 1)
-        self.rand_string_from_chars ['.','-','_','=','+','$'], length
+        def punctuation(length = 1)
+          rand_string_from_chars ['.', '-', '_', '=', '+', '$'], length
+        end
       end
     end
   end

spec/mongoid/token/generator_spec.rb

@@ -1,57 +1,65 @@
-require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+require File.join(File.dirname(__FILE__), %w(.. .. spec_helper))
 
 describe Mongoid::Token::Generator do
-  describe "#generate" do
-    it "generates lowercase characters" do
-      100.times{ Mongoid::Token::Generator.generate("%c").should =~ /[a-z]/ }
+  describe '#generate' do
+    it 'generates lowercase alphanumeric characters' do
+      100.times { Mongoid::Token::Generator.generate('%a').should =~ /[a-z0-9]/ }
     end
 
-    it "generates uppercase characters" do
-      100.times{ Mongoid::Token::Generator.generate("%C").should =~ /[A-Z]/ }
+    it 'generates uppercase alphanumeric characters' do
+      100.times { Mongoid::Token::Generator.generate('%A').should =~ /[A-Z0-9]/ }
     end
 
-    it "generates digits" do
-      100.times{ Mongoid::Token::Generator.generate("%d").should =~ /[0-9]/ }
+    it 'generates lowercase characters' do
+      100.times { Mongoid::Token::Generator.generate('%c').should =~ /[a-z]/ }
     end
 
-    it "generates non-zero digits" do
-      100.times{ Mongoid::Token::Generator.generate("%D").should =~ /[1-9]/ }
+    it 'generates uppercase characters' do
+      100.times { Mongoid::Token::Generator.generate('%C').should =~ /[A-Z]/ }
     end
 
-    it "generates hexdigits" do
-      100.times{ Mongoid::Token::Generator.generate("%h").should =~ /[0-9a-f]/ }
+    it 'generates digits' do
+      100.times { Mongoid::Token::Generator.generate('%d').should =~ /[0-9]/ }
     end
 
-    it "generates non-zero hexdigits" do
-      100.times{ Mongoid::Token::Generator.generate("%H").should =~ /[1-9a-f]/ }
+    it 'generates non-zero digits' do
+      100.times { Mongoid::Token::Generator.generate('%D').should =~ /[1-9]/ }
     end
 
-    it "generates alphanumeric characters" do
-      100.times{ Mongoid::Token::Generator.generate("%s").should =~ /[A-Za-z0-9]/ }
+    it 'generates hexdigits' do
+      100.times { Mongoid::Token::Generator.generate('%h').should =~ /[0-9a-f]/ }
     end
 
-    it "generates upper and lowercase characters" do
-      100.times{ Mongoid::Token::Generator.generate("%w").should =~ /[A-Za-z]/ }
+    it 'generates non-zero hexdigits' do
+      100.times { Mongoid::Token::Generator.generate('%H').should =~ /[1-9a-f]/ }
     end
 
-    it "generates URL-safe punctuation" do
-      100.times{ Mongoid::Token::Generator.generate("%p").should =~ /[\.\-\_\=\+\$]/ }
+    it 'generates alphanumeric characters' do
+      100.times { Mongoid::Token::Generator.generate('%s').should =~ /[A-Za-z0-9]/ }
     end
 
-    it "generates patterns of a fixed length" do
-      100.times{ Mongoid::Token::Generator.generate("%s8").should =~ /[A-Za-z0-9]{8}/ }
+    it 'generates upper and lowercase characters' do
+      100.times { Mongoid::Token::Generator.generate('%w').should =~ /[A-Za-z]/ }
     end
 
-    it "generates patterns of a variable length" do
-      100.times{ Mongoid::Token::Generator.generate("%s1,5").should =~ /[A-Za-z0-9]{1,5}/ }
+    it 'generates URL-safe punctuation' do
+      100.times { Mongoid::Token::Generator.generate('%p').should =~ /[\.\-\_\=\+\$]/ }
     end
 
-    it "generates patterns with static prefixes/suffixes" do
-      100.times { Mongoid::Token::Generator.generate("prefix-%s4-suffix").should =~ /prefix\-[A-Za-z0-9]{4}\-suffix/ }
+    it 'generates patterns of a fixed length' do
+      100.times { Mongoid::Token::Generator.generate('%s8').should =~ /[A-Za-z0-9]{8}/ }
     end
 
-    it "generates more complex patterns" do
-      100.times { Mongoid::Token::Generator.generate("pre-%d4-%C3-%d4").should =~ /pre\-[0-9]{4}\-[A-Z]{3}\-[0-9]{4}/ }
+    it 'generates patterns of a variable length' do
+      100.times { Mongoid::Token::Generator.generate('%s1,5').should =~ /[A-Za-z0-9]{1,5}/ }
+    end
+
+    it 'generates patterns with static prefixes/suffixes' do
+      100.times { Mongoid::Token::Generator.generate('prefix-%s4-suffix').should =~ /prefix\-[A-Za-z0-9]{4}\-suffix/ }
+    end
+
+    it 'generates more complex patterns' do
+      100.times { Mongoid::Token::Generator.generate('pre-%d4-%C3-%d4').should =~ /pre\-[0-9]{4}\-[A-Z]{3}\-[0-9]{4}/ }
     end
   end
 end