hashids 0.0.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4aca5b2a67715e91ddbfc9b5c68cfd794a6c986a
-  data.tar.gz: 23974c9688a19b0da1215bbdc9065071234cd903
+  metadata.gz: 55450f1c6ad19dcf1420aaa46d62003216197f21
+  data.tar.gz: ea41a9497fe51dc028af387210e716627a03890c
 SHA512:
-  metadata.gz: 8e7f1e742554373ce8fbb3128c59ccb5e4992a95624b5115649ccd7cd9e1cd90078bdd04d611f2e0f71e8d6d0be2cd659bba453140483fa54b263250e7137243
-  data.tar.gz: 62132383ecd62f42c0d9ecd8a2684a746bf1fd6e8dd99f2c5e5ad06c72941359a1aec729f00f443dab42b7a5b62d5a29c23ab7e3151c3299ecdcd956fb86dbf3
+  metadata.gz: 34d65939ac98b5a38e9f518cf8dd0da07a3c760e49cad4df4d05cec4952f0177c58b982b871c7dc5d75eef9cb1ba766c7ed197c169eb1b9ddb570f1682831e49
+  data.tar.gz: 7c5c66153a745d579810d14815db3a60a2fc3d02c15bf868dc60077d898ee3ab7c614189a7772b3040847b3a226feca975a9067d51246673da6717d31b1688d9

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Peter Hellberg
+Copyright (c) 2013 Peter Hellberg
 
 MIT License
 
@@ -19,4 +19,4 @@ 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.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -24,7 +24,7 @@ This algorithm tries to satisfy the following requirements:
 3. You should be able to specify minimum hash length.
 4. Hashes should not contain basic English curse words (since they are meant to appear in public places - like the URL).
 
-Instead of showing items as `1`, `2`, or `3`, you could show them as `U6dc`, `u87U`, and `HMou`.
+Instead of showing items as `1`, `2`, or `3`, you could show them as `jR`, `k5`, and `l5`.
 You don't have to store these hashes in the database, but can encrypt + decrypt on the fly.
 
 All integers need to be greater than or equal to zero.
@@ -47,7 +47,8 @@ Or install it yourself as:
 
 ### Encrypting one number
 
-You can pass a unique salt value so your hashes differ from everyone else's. I use "**this is my salt**" as an example.
+You can pass a unique salt value so your hashes differ from everyone else's. 
+I use **this is my salt** as an example.
 
 ```ruby
 hashids = Hashids.new("this is my salt")
@@ -56,7 +57,7 @@ hash = hashids.encrypt(12345)
 
 `hash` is now going to be:
 
-    ryBo
+    NkK9
 
 ### Decrypting
 
@@ -64,7 +65,7 @@ Notice during decryption, same salt value is used:
 
 ```ruby
 hashids = Hashids.new("this is my salt")
-numbers = hashids.decrypt("ryBo")
+numbers = hashids.decrypt("NkK9")
 ```
 
 `numbers` is now going to be:
@@ -77,7 +78,7 @@ Decryption will not work if salt is changed:
 
 ```ruby
 hashids = Hashids.new("this is my pepper")
-numbers = hashids.decrypt("ryBo")
+numbers = hashids.decrypt("NkK9")
 ```
 
 `numbers` is now going to be:
@@ -93,13 +94,13 @@ hash = hashids.encrypt(683, 94108, 123, 5)
 
 `hash` is now going to be:
 
-    zBphL54nuMyu5
+    aBMswoO2UB3Sj
   
 ### Decrypting is done the same way
 
 ```ruby
 hashids = Hashids.new("this is my salt")
-numbers = hashids.decrypt("zBphL54nuMyu5")
+numbers = hashids.decrypt("aBMswoO2UB3Sj")
 ```
 
 `numbers` is now going to be:
@@ -108,7 +109,8 @@ numbers = hashids.decrypt("zBphL54nuMyu5")
 
 ### Encrypting and specifying minimum hash length
 
-Here we encrypt integer 1, and set the minimum hash length to **8** (by default it's **0** -- meaning hashes will be the shortest possible length).
+Here we encrypt integer 1, and set the minimum hash length to **8**
+(by default it's **0** -- meaning hashes will be the shortest possible length).
 
 ```ruby
 hashids = Hashids.new("this is my salt", 8)
@@ -117,13 +119,13 @@ hash = hashids.encrypt(1)
 
 `hash` is now going to be:
 
-    b9iLXiAa
+    gB0NV05e
 
-### Decrypting
+### Decrypting with minimum hash length
 
 ```ruby
 hashids = Hashids.new("this is my salt", 8)
-numbers = hashids.decrypt("b9iLXiAa")
+numbers = hashids.decrypt("gB0NV05e")
 ```
 
 `numbers` is now going to be:
@@ -132,16 +134,16 @@ numbers = hashids.decrypt("b9iLXiAa")
 
 ### Specifying custom hash alphabet
 
-Here we set the alphabet to consist of only four letters: "abcd"
+Here we set the alphabet to consist of: "abcdefghijkABCDEFGHIJK12345"
 
 ```ruby
-hashids = Hashids.new("this is my salt", 0, "abcd")
+hashids = Hashids.new("this is my salt", 0, "abcdefghijkABCDEFGHIJK12345")
 hash = hashids.encrypt(1, 2, 3, 4, 5)
 ```
 
 `hash` is now going to be:
 
-    adcdacddcdaacdad
+    dEc4iEHeF3
 
 ## Randomness
 
@@ -157,7 +159,7 @@ hash = hashids.encrypt(5, 5, 5, 5)
 
 You don't see any repeating patterns that might show there's 4 identical numbers in the hash:
 
-    GLh5SMs9
+    1Wc8cwcE
 
 Same with incremented numbers:
 
@@ -166,24 +168,51 @@ hashids = Hashids.new("this is my salt")
 hash = hashids.encrypt(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 ```
 
-`hash` will be :
+`hash` is now going to be:
 
-    zEUzfySGIpuyhpF6HaC7
+    kRHnurhptKcjIDTWC3sx
 
 ### Incrementing number hashes:
 
 ```ruby
 hashids = Hashids.new("this is my salt")
 
-hashids.encrypt 1 #=> LX
-hashids.encrypt 2 #=> ed
-hashids.encrypt 3 #=> o9
-hashids.encrypt 4 #=> 4n
-hashids.encrypt 5 #=> a5
+hashids.encrypt 1 #=> NV
+hashids.encrypt 2 #=> 6m
+hashids.encrypt 3 #=> yD
+hashids.encrypt 4 #=> 2l
+hashids.encrypt 5 #=> rD
+```
+
+### Encrypting using a HEX string
+
+```ruby
+hashids = Hashids.new("this is my salt")
+hash = hashids.encrypt_hex('DEADBEEF')
 ```
 
+`hash` is now going to be:
+
+    kRNrpKlJ
+
+### Decrypting to a HEX string
+
+```ruby
+hashids = Hashids.new("this is my salt")
+hex_str = hashids.decrypt_hex("kRNrpKlJ")
+```
+
+`hex_str` is now going to be:
+
+    DEADBEEF
+
 ## Changelog
 
+**0.3.0**
+
+ - Bumped the version number since hashids.rb now support the new algorithm
+ - Support for `encrypt_hex` and `decrypt_hex`
+
 **0.0.3**
 
  - Default salt (Allows for `Hashids.new.encrypt(91) #=> "kBy"`)

data/lib/hashids.rb

@@ -1,255 +1,283 @@
 # encoding: utf-8
 
 class Hashids
-  VERSION          = "0.0.5"
-  DEFAULT_ALPHABET = "xcS4F6h89aUbideAI7tkynuopqrXCgTE5GBKHLMjfRsz"
-  PRIMES           = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43]
+  VERSION  = "0.3.0"
 
-  SaltError        = Class.new(ArgumentError)
-  MinLengthError   = Class.new(ArgumentError)
-  AlphabetError    = Class.new(ArgumentError)
+  MIN_ALPHABET_LENGTH = 16
+  SEP_DIV             = 3.5
+  GUARD_DIV           = 12.0
 
-  def initialize(salt = "", min_length = 0, alphabet = DEFAULT_ALPHABET)
-    @salt        = salt
-    @min_length  = min_length
-    @alphabet    = alphabet
+  DEFAULT_ALPHABET    = "abcdefghijklmnopqrstuvwxyz" +
+                        "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +
+                        "1234567890"
 
-    @chars_regex = /./
+  attr_reader :salt, :min_hash_length, :alphabet, :seps, :guards
+
+  def initialize(salt = "", min_hash_length = 0, alphabet = DEFAULT_ALPHABET)
+    @salt             = salt
+    @min_hash_length  = min_hash_length
+    @alphabet         = alphabet
 
-    validate_attributes
     setup_alphabet
   end
 
   def encrypt(*numbers)
     numbers.flatten! if numbers.length == 1
 
-    if numbers.empty? || numbers.reject { |n| Integer(n) && n > 0 }.any?
+    if numbers.empty? || numbers.reject { |n| Integer(n) && n >= 0 }.any?
       ""
     else
-      encode(numbers, @alphabet, @salt, @min_length)
+      encode(numbers)
     end
   end
 
-  def decrypt(hash)
-    hash.empty? ? [] : decode(hash)
+  def encrypt_hex(str)
+    return "" unless str.to_s.match(/\A[0-9a-fA-F]+\Z/)
+
+    numbers = str.scan(/[\w\W]{1,12}/).map do |num|
+      "1#{num}".to_i(16)
+    end
+
+    encrypt(numbers)
   end
 
-  private
+  def decrypt(hash)
+    return [] if hash.nil? || hash.empty?
 
-  def validate_attributes
-    unless @salt.kind_of?(String)
-      raise Hashids::SaltError, "The salt must be a String"
-    end
+    decode(hash, @alphabet)
+  end
 
-    unless @min_length.kind_of?(Fixnum)
-      raise Hashids::MinLengthError, "The min length must be a Fixnum"
-    end
+  def decrypt_hex(hash)
 
-    unless @min_length >= 0
-      raise Hashids::MinLengthError, "The min length must be 0 or more"
-    end
+    ret = ""
+    numbers = decrypt(hash)
 
-    unless @alphabet.kind_of?(String)
-      raise Hashids::AlphabetError, "The alphabet must be a String"
+    numbers.length.times do |i|
+      ret += numbers[i].to_s(16)[1 .. -1]
     end
+
+    ret.upcase
   end
 
-  def setup_alphabet
-    @seps   = []
-    @guards = []
+  protected
+
+  def encode(numbers)
+    ret = ""
 
-    @alphabet = @alphabet.scan(@chars_regex).uniq.join('')
+    alphabet = @alphabet
+    length   = numbers.length
+    hash_int = 0
 
-    if @alphabet.length < 4
-      raise AlphabetError, "Alphabet must contain at least 4 unique characters."
+    length.times do |i|
+      hash_int += (numbers[i] % (i + 100))
     end
 
-    PRIMES.each do |prime|
-      char = @alphabet[prime - 1]
+    lottery = ret = alphabet[hash_int % alphabet.length]
+
+    length.times do |i|
+      num = numbers[i]
+      buf = lottery + salt + alphabet
+
+      alphabet = consistent_shuffle(alphabet, buf[0, alphabet.length])
+      last     = hash(num, alphabet)
 
-      break if char.nil?
+      ret += last
 
-      @seps << char
-      @alphabet.tr!(char, ' ')
+      if (i + 1) < length
+        num %= (last.ord + i)
+        ret += seps[num % seps.length]
+      end
     end
 
-    [0, 4, 8, 12].each do |index|
-      separator = @seps[index]
+    if ret.length < min_hash_length
+      ret = guards[(hash_int + ret[0].ord) % guards.length] + ret
 
-      unless separator.nil?
-        @guards << separator
-        @seps.delete_at(index)
+      if ret.length < min_hash_length
+        ret += guards[(hash_int + ret[2].ord) % guards.length]
       end
     end
 
-    @alphabet.delete!(' ')
-    @alphabet = consistent_shuffle(@alphabet, @salt)
-  end
+    half_length = alphabet.length.div(2)
 
-  def encode(numbers, alphabet, salt, min_length = 0)
-    ret = ""
+    while(ret.length < min_hash_length)
+      alphabet = consistent_shuffle(alphabet, alphabet)
+      ret = alphabet[half_length .. -1] + ret + alphabet[0, half_length]
 
-    seps = consistent_shuffle(@seps, numbers).scan(@chars_regex)
-    lottery_char = ""
+      excess = ret.length - min_hash_length
+      ret = ret[excess / 2, min_hash_length] if excess > 0
+    end
 
-    numbers.each_with_index do |number, i|
-      if i == 0
-        lottery_salt = numbers.join('-')
-        numbers.each { |n| lottery_salt += "-#{(n + 1) * 2}" }
+    ret
+  end
 
-        lottery = consistent_shuffle(alphabet, lottery_salt)
+  def decode(hash, alphabet)
+    ret = []
 
-        ret += lottery_char = lottery[0]
+    breakdown = hash.gsub(/[#{@guards}]/, " ")
+    array     = breakdown.split(" ")
 
-        alphabet = "#{lottery_char}#{alphabet.delete(lottery_char)}"
-      end
+    i = [3,2].include?(array.length) ? 1 : 0
 
-      alphabet = consistent_shuffle(alphabet, "#{lottery_char.ord & 12345}#{salt}")
-      ret += hash(number, alphabet)
+    if breakdown = array[i]
+      lottery   = breakdown[0]
+      breakdown = breakdown[1 .. -1].gsub(/[#{@seps}]/, " ")
+      array     = breakdown.split(" ")
 
-      if (i + 1) < numbers.length
-        seps_index = (number + i) % seps.length
-        ret += seps[seps_index]
+      array.length.times do |i|
+        sub_hash = array[i]
+        buffer   = lottery + salt + alphabet
+        alphabet = consistent_shuffle(alphabet, buffer[0, alphabet.length])
+
+        ret.push unhash(sub_hash, alphabet)
       end
-    end
 
-    if ret.length < min_length
-      first_index = 0
-      numbers.each_with_index do |number, i|
-        first_index += (i + 1) * number
+      if encode(ret) != hash
+        ret = []
       end
+    end
 
-      guard_index = first_index % @guards.length
-      guard = @guards[guard_index]
+    ret
+  end
 
-      ret = guard + ret
+  def consistent_shuffle(alphabet, salt)
+    return alphabet if salt.nil? || salt.empty?
 
-      if ret.length < min_length
-        guard_index = (guard_index + ret.length) % @guards.length
-        guard       = @guards[guard_index]
+    v = 0
+    p = 0
 
-        ret += guard
-      end
-    end
+    (alphabet.length-1).downto(1) do |i|
+      v  = v % salt.length
+      p += n = salt[v].ord
+      j  = (n + v + p) % i
 
-    while ret.length < min_length
-      pad_array = [alphabet[1].ord, alphabet[0].ord]
-      pad_left  = encode(pad_array, alphabet, salt)
-      pad_right = encode(pad_array, alphabet, pad_array.join(''))
+      tmp_char = alphabet[j]
 
-      ret = "#{pad_left}#{ret}#{pad_right}"
-      excess = ret.length - min_length
+      alphabet = alphabet[0, j] + alphabet[i] + alphabet[j + 1..-1]
+      alphabet = alphabet[0, i] + tmp_char    + alphabet[i + 1..-1]
 
-      ret = ret[(excess.div(2)), min_length] if excess > 0
-      alphabet = consistent_shuffle(alphabet, salt + ret)
+      v += 1
     end
 
-    ret
+    alphabet
   end
 
-  def decode(hash)
-    ret = []
+  def hash(input, alphabet)
+    num = input.to_i
+    len = alphabet.length
+    res   = ""
 
-    if hash.length > 0
-      original_hash = hash
-      alphabet      = ""
-      lottery_char  = ""
+    begin
+      res = "#{alphabet[num % len]}#{res}"
+      num = num.div(alphabet.length)
+    end while num > 0
 
-      hash_split = hash.tr(@guards.join(''), ' ').split(' ')
-      hash = hash_split[[3,2].include?(hash_split.length) ? 1 : 0]
+    res
+  end
 
-      hash.tr!(@seps.join(''), ' ')
+  def unhash(input, alphabet)
+    num = 0
 
-      hash_array = hash.split(' ')
+    input.length.times do |i|
+      pos = alphabet.index(input[i])
+      num += pos * alphabet.length ** (input.length - i - 1)
+    end
 
-      hash_array.each_with_index do |sub_hash, i|
-        if sub_hash.length > 0
-          if i == 0
-            lottery_char = hash[0]
-            sub_hash     = sub_hash[1..-1]
-            alphabet     = lottery_char + @alphabet.delete(lottery_char)
-          end
+    num
+  end
 
-          if alphabet.length > 0 && lottery_char.length > 0
-            alphabet = consistent_shuffle(alphabet, (lottery_char.ord & 12345).to_s + @salt)
-            ret << unhash(sub_hash, alphabet)
-          end
-        end
-      end
+  private
 
-      ret = [] if encrypt(*ret) != original_hash
-    end
+  def setup_alphabet
+    validate_attributes
 
-    ret
+    @alphabet = alphabet.split('').uniq.join('')
+
+    setup_seps
+    setup_guards
+
+    validate_alphabet
   end
 
-  def consistent_shuffle(alphabet, salt)
-    ret = ""
+  def setup_seps
+    @seps = "cfhistuCFHISTU"
 
-    alphabet = alphabet.join("") if alphabet.respond_to? :join
-    salt = salt.join("") if salt.respond_to? :join
+    # seps should contain only characters present in alphabet
+    # alphabet should not contains seps
 
-    alphabet_array = alphabet.scan(@chars_regex)
-    salt_array     = salt.scan(@chars_regex)
-    sorting_array  = []
+    seps.length.times do |i|
+      j = @alphabet.index(seps[i])
 
-    salt_array << 0 if salt_array.empty?
-    salt_array.each { |char| sorting_array << char.ord }
+      if j.nil?
+        @seps = seps[0, i] + " " + seps[i + 1 .. -1]
+      else
+        @alphabet = alphabet[0, j] + " " + alphabet[j + 1 .. -1]
+      end
+    end
 
-    sorting_array.each_with_index do |int,i|
-      add = true
-      k   = i
+    alphabet.delete!(' ')
+    seps.delete!(' ')
 
-      while k != sorting_array.length + i - 1
-        next_index = (k + 1) % sorting_array.length
+    @seps = consistent_shuffle(seps, salt)
 
-        if add
-          sorting_array[i] += sorting_array[next_index] + (k * i)
-        else
-          sorting_array[i] -= sorting_array[next_index]
-        end
+    if seps.length == 0 || (alphabet.length / seps.length.to_f) > SEP_DIV
+      seps_length = (alphabet.length / SEP_DIV).ceil
+      seps_length = 2 if seps_length == 1
 
-        add = !add
-        k += 1
-      end
+      if seps_length > seps.length
+        diff = seps_length - seps.length;
 
-      sorting_array[i] = sorting_array[i].abs
+        @seps    += alphabet[0, diff]
+        @alphabet = alphabet[diff .. -1]
+      else
+        @seps = seps[0, seps_length]
+      end
     end
 
-    i = 0
+    @alphabet = consistent_shuffle(alphabet, salt)
+  end
 
-    while alphabet_array.length > 0
-      pos = sorting_array[i]
-      pos %= alphabet_array.length if pos >= alphabet_array.length
-      ret += alphabet_array[pos]
+  def setup_guards
+    gc = (alphabet.length / GUARD_DIV).ceil
 
-      alphabet_array.delete_at(pos)
-      i = (i+1) % sorting_array.length
+    if alphabet.length < 3
+      @guards = seps[0, gc]
+      @seps   = seps[gc .. -1]
+    else
+      @guards   = alphabet[0, gc]
+      @alphabet = alphabet[gc .. -1]
     end
-
-    ret
   end
 
-  def hash(number, alphabet)
-    hash = ""
+  SaltError       = Class.new(ArgumentError)
+  MinLengthError  = Class.new(ArgumentError)
+  AlphabetError   = Class.new(ArgumentError)
 
-    while number > 0
-      hash   = "#{alphabet[number % alphabet.length]}#{hash}"
-      number = number.div(alphabet.length)
+  def validate_attributes
+    unless salt.kind_of?(String)
+      raise SaltError, "The salt must be a String"
     end
 
-    hash
-  end
+    unless min_hash_length.kind_of?(Fixnum)
+      raise MinLengthError, "The min length must be a Fixnum"
+    end
 
-  def unhash(hash, alphabet)
-    number = 0
+    unless min_hash_length >= 0
+      raise MinLengthError, "The min length must be 0 or more"
+    end
 
-    hash.scan(@chars_regex).each_with_index do |char, i|
-      if pos = alphabet.index(char)
-        number += pos * alphabet.length ** (hash.length - i - 1)
-      end
+    unless alphabet.kind_of?(String)
+      raise AlphabetError, "The alphabet must be a String"
     end
 
-    number
+    if alphabet.include?(' ')
+      raise AlphabetError, "The alphabet can’t include spaces"
+    end
+  end
+
+  def validate_alphabet
+    unless alphabet.length >= MIN_ALPHABET_LENGTH
+      raise AlphabetError, "Alphabet must contain at least " +
+                           "#{MIN_ALPHABET_LENGTH} unique characters."
+    end
   end
 end

data/spec/hashids_spec.rb

@@ -8,74 +8,98 @@ require_relative "../lib/hashids"
 
 describe Hashids do
   let(:salt)              { 'this is my salt' }
+  let(:seps)              { 'UHuhtcITCsFifS'  }
+  let(:guards)            { 'AdG0'            }
   let(:hashids)           { Hashids.new(salt) }
-  let(:alphabet)          { "xgzXjp48RaoeLdB6yrAMK9b5n7qEkG" }
-  let(:shuffled_alphabet) { "xMGAE6gXkpBR785zLraqnj49doyKeb" }
-  let(:default_alphabet)  { "xcS4F6h89aUbideAI7tkynuopqrXCgTE5GBKHLMjfRsz" }
-  let(:seps) { ["S", "F", "h", "U", "I", "t", "u", "C", "H", "f", "s"] }
-  let(:examples) {
-    {
-      'aa' => 155, 'ba' => 185, 'j9' => 814,
-      'ky' => 342, 'Xg' => 559, 'GB' => 683,
-      'B4' => 691, '9Xg' => 4159, 'jAz' => 24599
-    }
+
+  let(:default_alphabet)  {
+    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890"
   }
 
-  describe "setup" do
-    it "has a default salt" do
-      Hashids.new.encrypt(1,2,3).must_equal "katKSA"
-    end
+  let(:alphabet)          {
+    "5N6y2rljDQak4xgzn8ZR1oKYLmJpEbVq3OBv9WwXPMe7"
+  }
 
+  describe "setup" do
     it "has a default alphabet" do
       Hashids::DEFAULT_ALPHABET.must_equal default_alphabet
     end
 
+    it "has a default salt" do
+      Hashids.new.encrypt(1,2,3).must_equal "o2fXhV"
+    end
+
     it "has the correct salt" do
       hashids.instance_variable_get(:@salt).must_equal salt
     end
 
     it "defaults to a min_length of 0" do
-      hashids.instance_variable_get(:@min_length).must_equal 0
+      hashids.instance_variable_get(:@min_hash_length).must_equal 0
     end
 
-    it "generates the correct @seps" do
+    it "generates the correct seps" do
       hashids.instance_variable_get(:@seps).must_equal seps
     end
 
     it "generates the correct @guards" do
-      hashids.instance_variable_get(:@guards).must_equal ["c", "i", "T"]
+      hashids.instance_variable_get(:@guards).must_equal guards
     end
 
     it "generates the correct alphabet" do
       hashids.instance_variable_get(:@alphabet).must_equal alphabet
     end
+
+    it "has a minimum alphabet length" do
+      -> {
+        Hashids.new("", 0, 'shortalphabet')
+      }.must_raise Hashids::AlphabetError
+    end
+
+    it "checks the alphabet for spaces" do
+      -> {
+        Hashids.new("", 0, 'abc odefghijklmnopqrstuv')
+      }.must_raise Hashids::AlphabetError
+    end
   end
 
   describe "encrypt" do
     it "encrypts a single number" do
-      hashids.encrypt(12345).must_equal 'ryBo'
-
-      hashids.tap { |h|
-        h.encrypt(-1).must_equal   ''
-        h.encrypt(1).must_equal    'LX'
-        h.encrypt(22).must_equal   '5B'
-        h.encrypt(333).must_equal  'o49'
-        h.encrypt(9999).must_equal 'GKnB'
-      }
+      hashids.encrypt(12345).must_equal 'NkK9'
+
+      hashids.tap do |h|
+        h.encrypt(-1).must_equal          ''
+        h.encrypt(1).must_equal           'NV'
+        h.encrypt(22).must_equal          'K4'
+        h.encrypt(333).must_equal         'OqM'
+        h.encrypt(9999).must_equal        'kQVg'
+        h.encrypt(123_000).must_equal     '58LzD'
+        h.encrypt(456_000_000).must_equal '5gn6mQP'
+        h.encrypt(987_654_321).must_equal 'oyjYvry'
+      end
     end
 
     it "can encrypt a list of numbers" do
-      hashids.encrypt(683, 94108, 123, 5).must_equal 'zBphL54nuMyu5'
+      hashids.tap do |h|
+        h.encrypt(1,2,3).must_equal "laHquq"
+        h.encrypt(2,4,6).must_equal "44uotN"
+        h.encrypt(99,25).must_equal "97Jun"
 
-      hashids.tap { |h|
-        h.encrypt(1,2,3).must_equal 'eGtrS8'
-        h.encrypt(2,4,6).must_equal '9Kh7fz'
-        h.encrypt(99,25).must_equal 'dAECX'
-      }
+        h.encrypt(1337,42,314).
+          must_equal "7xKhrUxm"
+
+        h.encrypt(683, 94108, 123, 5).
+          must_equal "aBMswoO2UB3Sj"
+
+        h.encrypt(547, 31, 241271, 311, 31397, 1129, 71129).
+          must_equal "3RoSDhelEyhxRsyWpCx5t1ZK"
+
+        h.encrypt(21979508, 35563591, 57543099, 93106690, 150649789).
+          must_equal "p2xkL3CK33JjcrrZ8vsw4YRZueZX9k"
+      end
     end
 
     it "can encrypt a list of numbers passed in as an array" do
-      hashids.encrypt([1,2,3]).must_equal 'eGtrS8'
+      hashids.encrypt([1,2,3]).must_equal "laHquq"
     end
 
     it "returns an empty string if no numbers" do
@@ -88,66 +112,107 @@ describe Hashids do
     end
 
     it "can encrypt to a minumum length" do
-      h = Hashids.new(salt, 8)
-      h.encrypt(1).must_equal "b9iLXiAa"
+      h = Hashids.new(salt, 18)
+      h.encrypt(1).must_equal "aJEDngB0NV05ev1WwP"
+
+      h.encrypt(4140, 21147, 115975, 678570, 4213597, 27644437).
+        must_equal "pLMlCWnJSXr1BSpKgqUwbJ7oimr7l6"
     end
 
     it "can encrypt with a custom alphabet" do
-      h = Hashids.new(salt, 0, "abcd")
-      h.encrypt(1,2,3,4,5).must_equal 'adcdacddcdaacdad'
+      h = Hashids.new(salt, 0, "ABCDEFGhijklmn34567890-:")
+      h.encrypt(1,2,3,4,5).must_equal "6nhmFDikA0"
     end
 
     it "does not produce repeating patterns for identical numbers" do
-      hashids.encrypt(5,5,5,5).must_equal 'GLh5SMs9'
+      hashids.encrypt(5,5,5,5).must_equal "1Wc8cwcE"
     end
 
     it "does not produce repeating patterns for incremented numbers" do
-      hashids.encrypt(*(1..10).to_a).must_equal 'zEUzfySGIpuyhpF6HaC7'
+      hashids.encrypt(*(1..10).to_a).must_equal "kRHnurhptKcjIDTWC3sx"
     end
 
     it "does not produce similarities between incrementing number hashes" do
-      hashids.encrypt(1).must_equal 'LX'
-      hashids.encrypt(2).must_equal 'ed'
-      hashids.encrypt(3).must_equal 'o9'
-      hashids.encrypt(4).must_equal '4n'
-      hashids.encrypt(5).must_equal 'a5'
+      hashids.encrypt(1).must_equal 'NV'
+      hashids.encrypt(2).must_equal '6m'
+      hashids.encrypt(3).must_equal 'yD'
+      hashids.encrypt(4).must_equal '2l'
+      hashids.encrypt(5).must_equal 'rD'
+    end
+  end
+
+  describe "encrypt_hex" do
+    it "encrypts hex string" do
+      hashids.tap { |h|
+        h.encrypt_hex("FA").must_equal    "lzY"
+        h.encrypt_hex("26dd").must_equal  "MemE"
+        h.encrypt_hex("FF1A").must_equal  "eBMrb"
+        h.encrypt_hex("12abC").must_equal "D9NPE"
+        h.encrypt_hex("185b0").must_equal "9OyNW"
+        h.encrypt_hex("17b8d").must_equal "MRWNE"
+
+        h.encrypt_hex("1d7f21dd38").must_equal "4o6Z7KqxE"
+        h.encrypt_hex("20015111d").must_equal "ooweQVNB"
+      }
+    end
+
+    it "returns an empty string if passed non-hex string" do
+      hashids.encrypt_hex("XYZ123").must_equal ""
     end
   end
 
   describe "decrypt" do
     it "decrypts an encrypted number" do
-      hashids.decrypt("ryBo").must_equal [12345]
+      hashids.decrypt("NkK9").must_equal [12345]
+      hashids.decrypt("5O8yp5P").must_equal [666555444]
+      hashids.decrypt("KVO9yy1oO5j").must_equal [666555444333222]
 
       hashids.tap { |h|
-        h.decrypt('qkpA').must_equal [1337]
-        h.decrypt('6aX').must_equal [808]
-        h.decrypt('gz9').must_equal [303]
+        h.decrypt("Wzo").must_equal [1337]
+        h.decrypt("DbE").must_equal [808]
+        h.decrypt("yj8").must_equal [303]
       }
     end
 
     it "decrypts a list of encrypted numbers" do
-      hashids.decrypt('zBphL54nuMyu5').must_equal [683, 94108, 123, 5]
+      hashids.decrypt("1gRYUwKxBgiVuX").must_equal [66655,5444333,2,22]
+      hashids.decrypt('aBMswoO2UB3Sj').must_equal [683, 94108, 123, 5]
 
       hashids.tap { |h|
-        h.decrypt('kEFy').must_equal [1, 2]
-        h.decrypt('Aztn').must_equal [6, 5]
+        h.decrypt('jYhp').must_equal [3, 4]
+        h.decrypt('k9Ib').must_equal [6, 5]
+
+        h.decrypt('EMhN').must_equal [31, 41]
+        h.decrypt('glSgV').must_equal [13, 89]
       }
     end
 
     it "does not decrypt with a different salt" do
       peppers = Hashids.new('this is my pepper')
-      hashids.decrypt('ryBo').must_equal [12345]
-      peppers.decrypt('ryBo').must_equal []
+
+      hashids.decrypt('NkK9').must_equal [12345]
+      peppers.decrypt('NkK9').must_equal []
     end
 
     it "can decrypt from a hash with a minimum length" do
       h = Hashids.new(salt, 8)
-      h.decrypt("b9iLXiAa").must_equal [1]
+      h.decrypt("gB0NV05e").must_equal [1]
+
+      h.decrypt("mxi8XH87").must_equal [25, 100, 950]
+      h.decrypt("KQcmkIW8hX").must_equal [5,200,195, 1]
+    end
+  end
+
+  describe "decrypt_hex" do
+    it "decrypts hex string" do
+      hashids.decrypt_hex("lzY").must_equal "FA"
+      hashids.decrypt_hex("eBMrb").must_equal "FF1A"
+      hashids.decrypt_hex("D9NPE").must_equal "12ABC"
     end
   end
 
   describe "setup" do
-    it "raises an exception if the alphabet has less than 4 unique chars" do
+    it "raises an exception if the alphabet has less than 16 unique chars" do
       -> { Hashids.new('salt', 0, 'abc') }.
         must_raise Hashids::AlphabetError
     end
@@ -169,4 +234,69 @@ describe Hashids do
         must_raise Hashids::AlphabetError
     end
   end
+
+  describe "protected methods" do
+
+    describe "unhash" do
+      it "unhashes" do
+        hashids.send(:unhash, 'bb',     'abc').must_equal 4
+        hashids.send(:unhash, 'aaa',    'abc').must_equal 0
+        hashids.send(:unhash, 'cba',    'abc').must_equal 21
+        hashids.send(:unhash, 'cbaabc', 'abc').must_equal 572
+        hashids.send(:unhash, 'aX11b',  'abcXYZ123').must_equal 2728
+      end
+    end
+
+    describe "decode" do
+      it "decodes" do
+        hashids.send(:decode, 'NV', alphabet).must_equal [1]
+      end
+    end
+
+    describe "consistent_shuffle" do
+      it "returns the alphabet if empty salt" do
+        hashids.send(:consistent_shuffle, default_alphabet, '').
+          must_equal default_alphabet
+      end
+
+      it "shuffles consistently" do
+        hashids.send(:consistent_shuffle,    'ab', salt).must_equal 'ba'
+        hashids.send(:consistent_shuffle,   'abc', salt).must_equal 'bca'
+        hashids.send(:consistent_shuffle,  'abcd', salt).must_equal 'cadb'
+        hashids.send(:consistent_shuffle, 'abcde', salt).must_equal 'dceba'
+
+        hashids.send(:consistent_shuffle, default_alphabet, 'salt').
+          must_equal "f17a8zvCwo0iuqYDXlJ4RmAS2end5gh" +
+                     "TcpjbOWLK9GFyE6xUI3ZBMQtPsNHrkV"
+
+        hashids.send(:consistent_shuffle, 'abcdefghijklmnopqrstuvwxyz', salt).
+          must_equal 'fcaodykrgqvblxjwmtupzeisnh'
+      end
+    end
+
+    describe "hash" do
+      it "hashes" do
+        hashids.send(:hash,      12, 'abcdefg').must_equal "bf"
+        hashids.send(:hash,      42, 'abcdefg').must_equal "ga"
+        hashids.send(:hash,     123, 'abcdefg').must_equal "cde"
+        hashids.send(:hash,    1024, 'abcdefg').must_equal "cggc"
+        hashids.send(:hash,  950000, 'abcdefg').must_equal "bbadeefc"
+        hashids.send(:hash,  950000, 'åäö-ÅÄÖ').must_equal "ääå-ÅÅÄö"
+        hashids.send(:hash, 3500000, 'abcdefg').must_equal "ebfbfaea"
+        hashids.send(:hash, 3500000, 'Xyz01-å').must_equal "1y-y-X1X"
+      end
+    end
+
+    describe "unhash" do
+      it "unhashes" do
+        hashids.send(:unhash, 'abbd', 'abcdefg').must_equal 59
+        hashids.send(:unhash, 'abcd', 'abcdefg').must_equal 66
+        hashids.send(:unhash, 'acac', 'abcdefg').must_equal 100
+        hashids.send(:unhash, 'acfg', 'abcdefg').must_equal 139
+        hashids.send(:unhash, 'x21y', 'xyz1234').must_equal 218
+        hashids.send(:unhash, 'yy44', 'xyz1234').must_equal 440
+        hashids.send(:unhash, '1xzz', 'xyz1234').must_equal 1045
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hashids
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.3.0
 platform: ruby
 authors:
 - Peter Hellberg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-13 00:00:00.000000000 Z
+date: 2013-09-10 00:00:00.000000000 Z
 dependencies: []
 description: Use hashids when you do not want to expose your database ids to the user.
 email:
@@ -46,11 +46,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.5
 signing_key: 
 specification_version: 4
 summary: Generate YouTube-like hashes from one or many numbers.
 test_files:
 - spec/hashids_profile.rb
 - spec/hashids_spec.rb
-has_rdoc: