sqids 0.1.2 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c79695a1c507e1785e6c454fed0e0f4bca689598608d5b680b019493dfe9406
-  data.tar.gz: 9c64e11d7b0a8c551caf8b24d73fd01cb0aaf8ade971a4b6d535f120e1be8d9a
+  metadata.gz: 8738a24714961747ba8fb004ffba899f34889de1e65ba3932a59a50b85558aef
+  data.tar.gz: 6b26a781bd07bc2b805af36d29bd0cc838351569a3a44988e171b6083e75a3e4
 SHA512:
-  metadata.gz: 9992329b56a99da95e7ee85e1b928407d7cbb40f5312cbc18a0f17ed95b0ba51b175088dc84db69d894bfa0814d587f5cdbe327c7a6a1d56c89eb004c68a83ae
-  data.tar.gz: 00d797e9d692a9c4ad82f80971649d2e4553d317c78b72e258ae497fa94521246205e56873971685b42d9b4ee7d8507d71bdf4c05fd80eab9735f58176adf230
+  metadata.gz: 4dbacb914b13fc4a8125f3b313359db82afe1251d5f9ef7d5eaa724fb8b474521e102ec00ef938d621259c52541bf9f6b63647ef1d24243e3bd72a1ab07f6926
+  data.tar.gz: 33660c785f18c7a2692e3e184c275c104c73dd72ac5aa6bca940f1da7dda1a5b3f66c30f55c4010d488bec694bafd0329979bcce3f3e0db20bfb87bdf01a6f4b

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # CHANGELOG
 
+**v0.2.1:**
+- Improvement: speeding up Sqids.new: [[PR #7](https://github.com/sqids/sqids-ruby/pull/7)] (thanks to [@lawrencegripper](https://github.com/lawrencegripper))
+
+**v0.2.0:** **⚠️ BREAKING CHANGE**
+- **Breaking change**: IDs change. Algorithm has been fine-tuned for better performance [[Issue #11](https://github.com/sqids/sqids-spec/issues/11)]
+- `alphabet` cannot contain multibyte characters
+- `min_length` upper limit has increased from alphabet length to `255`
+- Max blocklist re-encoding attempts has been capped at the length of the alphabet - 1
+- Minimum alphabet length has changed from 5 to 3
+- `min_value()` and `max_value()` functions have been removed
+
 **v0.1.2:**
 - Bug fix: spec update (PR #7): blocklist filtering in uppercase-only alphabet [[PR #7](https://github.com/sqids/sqids-spec/pull/7)]
 - Lower uniques test from 1_000_000 to 10_000

data/README.md

@@ -55,37 +55,42 @@ Simple encode & decode:
 
 ```ruby
 sqids = Sqids.new
-id = sqids.encode([1, 2, 3]) # '8QRLaD'
+id = sqids.encode([1, 2, 3]) # '86Rf07'
 numbers = sqids.decode(id) # [1, 2, 3]
 ```
 
 > **Note**
 > 🚧 Because of the algorithm's design, **multiple IDs can decode back into the same sequence of numbers**. If it's important to your design that IDs are canonical, you have to manually re-encode decoded numbers and check that the generated ID matches.
 
-Randomize IDs by providing a custom alphabet:
+Enforce a *minimum* length for IDs:
 
 ```ruby
-sqids = Sqids.new(alphabet: 'FxnXM1kBN6cuhsAvjW3Co7l2RePyY8DwaU04Tzt9fHQrqSVKdpimLGIJOgb5ZE')
-id = sqids.encode([1, 2, 3]) # 'B5aMa3'
+sqids = Sqids.new(min_length: 10)
+id = sqids.encode([1, 2, 3]) # '86Rf07xd4z'
 numbers = sqids.decode(id) # [1, 2, 3]
 ```
 
-Enforce a *minimum* length for IDs:
+Randomize IDs by providing a custom alphabet:
 
 ```ruby
-sqids = Sqids.new(min_length: 10)
-id = sqids.encode([1, 2, 3]) # '75JT1cd0dL'
+sqids = Sqids.new(alphabet: 'FxnXM1kBN6cuhsAvjW3Co7l2RePyY8DwaU04Tzt9fHQrqSVKdpimLGIJOgb5ZE')
+id = sqids.encode([1, 2, 3]) # 'B4aajs'
 numbers = sqids.decode(id) # [1, 2, 3]
 ```
 
 Prevent specific words from appearing anywhere in the auto-generated IDs:
 
 ```ruby
-sqids = Sqids.new(blocklist: Set.new(%w[word1 word2]))
-id = sqids.encode([1, 2, 3]) # '8QRLaD'
+sqids = Sqids.new(blocklist: Set.new(%w[86Rf07]))
+id = sqids.encode([1, 2, 3]) # 'se8ojk'
 numbers = sqids.decode(id) # [1, 2, 3]
 ```
 
+> [!WARNING]  
+> If you provide a large custom blocklist and/or custom alphabet, calls to `Sqid.new` can take 
+> ~1ms. You should create a singleton instance of `Sqid` at service start and reusing that rather than
+> repeatedly calling `Squid.new`
+
 ## 📝 License
 
 [MIT](LICENSE)

data/lib/sqids.rb

@@ -15,21 +15,33 @@ class Sqids
     min_length = options[:min_length] || DEFAULT_MIN_LENGTH
     blocklist = options[:blocklist] || DEFAULT_BLOCKLIST
 
-    raise ArgumentError, 'Alphabet length must be at least 5' if alphabet.length < 5
+    raise ArgumentError, 'Alphabet cannot contain multibyte characters' if contains_multibyte_chars(alphabet)
+    raise ArgumentError, 'Alphabet length must be at least 3' if alphabet.length < 3
 
     if alphabet.chars.uniq.size != alphabet.length
       raise ArgumentError,
             'Alphabet must contain unique characters'
     end
 
-    unless min_length.is_a?(Integer) && min_length >= Sqids.min_value && min_length <= alphabet.length
+    min_length_limit = 255
+    unless min_length.is_a?(Integer) && min_length >= 0 && min_length <= min_length_limit
       raise TypeError,
-            "Minimum length has to be between #{Sqids.min_value} and #{alphabet.length}"
+            "Minimum length has to be between 0 and #{min_length_limit}"
     end
 
-    filtered_blocklist = blocklist.select do |word|
-      word.length >= 3 && (word.downcase.chars - alphabet.downcase.chars).empty?
-    end.to_set(&:downcase)
+    filtered_blocklist = if blocklist == DEFAULT_BLOCKLIST && alphabet == DEFAULT_ALPHABET
+                           # If the blocklist is the default one, we don't need to filter it
+                           # we already know it's valid (lowercase and words longer than 3 chars)
+                           blocklist
+                         else
+                           # Downcase the alphabet once, rather than in the loop, to save significant time
+                           # with large blocklists
+                           downcased_alphabet = alphabet.downcase.chars
+                           # Filter the blocklist
+                           blocklist.select do |word|
+                             word.length >= 3 && (word.downcase.chars - downcased_alphabet).empty?
+                           end.to_set(&:downcase)
+                         end
 
     @alphabet = shuffle(alphabet)
     @min_length = min_length
@@ -39,13 +51,13 @@ class Sqids
   def encode(numbers)
     return '' if numbers.empty?
 
-    in_range_numbers = numbers.select { |n| n >= Sqids.min_value && n <= Sqids.max_value }
+    in_range_numbers = numbers.select { |n| n >= 0 && n <= Sqids.max_value }
     unless in_range_numbers.length == numbers.length
       raise ArgumentError,
-            "Encoding supports numbers between #{Sqids.min_value} and #{Sqids.max_value}"
+            "Encoding supports numbers between 0 and #{Sqids.max_value}"
     end
 
-    encode_numbers(in_range_numbers, partitioned: false)
+    encode_numbers(in_range_numbers)
   end
 
   def decode(id)
@@ -61,26 +73,18 @@ class Sqids
     prefix = id[0]
     offset = @alphabet.index(prefix)
     alphabet = @alphabet.slice(offset, @alphabet.length) + @alphabet.slice(0, offset)
-    partition = alphabet[1]
-    alphabet = alphabet.slice(2, alphabet.length)
+    alphabet = alphabet.reverse
 
     id = id[1, id.length]
 
-    partition_index = id.index(partition)
-    if !partition_index.nil? && partition_index.positive? && partition_index < id.length - 1
-      id = id[partition_index + 1, id.length]
-      alphabet = shuffle(alphabet)
-    end
-
     while id.length.positive?
-      separator = alphabet[-1]
-      chunks = id.split(separator, 2)
+      separator = alphabet[0]
 
+      chunks = id.split(separator, 2)
       if chunks.any?
-        alphabet_without_separator = alphabet.slice(0, alphabet.length - 1)
-        return [] unless chunks[0].chars.all? { |c| alphabet_without_separator.include?(c) }
+        return ret if chunks[0] == ''
 
-        ret.push(to_number(chunks[0], alphabet_without_separator))
+        ret.push(to_number(chunks[0], alphabet.slice(1, alphabet.length - 1)))
         alphabet = shuffle(alphabet) if chunks.length > 1
       end
 
@@ -90,14 +94,6 @@ class Sqids
     ret
   end
 
-  def self.min_value
-    0
-  end
-
-  def self.max_value
-    defined?(Integer::MAX) ? Integer::MAX : ((2**((0.size * 8) - 2)) - 1)
-  end
-
   private
 
   def shuffle(alphabet)
@@ -115,59 +111,42 @@ class Sqids
     chars.join
   end
 
-  def encode_numbers(numbers, partitioned: false)
+  def encode_numbers(numbers, increment: 0)
+    raise ArgumentError, 'Reached max attempts to re-generate the ID' if increment > @alphabet.length
+
     offset = numbers.length
     numbers.each_with_index do |v, i|
       offset += @alphabet[v % @alphabet.length].ord + i
     end
     offset = offset % @alphabet.length
+    offset = (offset + increment) % @alphabet.length
 
     alphabet = @alphabet.slice(offset, @alphabet.length) + @alphabet.slice(0, offset)
     prefix = alphabet[0]
-    partition = alphabet[1]
-    alphabet = alphabet.slice(2, alphabet.length)
+    alphabet = alphabet.reverse
     ret = [prefix]
 
     numbers.each_with_index do |num, i|
-      alphabet_without_separator = alphabet.slice(0, alphabet.length - 1)
-      ret.push(to_id(num, alphabet_without_separator))
+      ret.push(to_id(num, alphabet.slice(1, alphabet.length - 1)))
 
       next unless i < numbers.length - 1
 
-      separator = alphabet[-1]
-      if partitioned && i.zero?
-        ret.push(partition)
-      else
-        ret.push(separator)
-      end
-
+      ret.push(alphabet[0])
       alphabet = shuffle(alphabet)
     end
 
     id = ret.join
 
     if @min_length > id.length
-      unless partitioned
-        numbers = [0] + numbers
-        id = encode_numbers(numbers, partitioned: true)
-      end
+      id += alphabet[0]
 
-      if @min_length > id.length
-        id = id[0] + alphabet[0,
-                              @min_length - id.length] + id[1,
-                                                            id.length - 1]
+      while (@min_length - id.length).positive?
+        alphabet = shuffle(alphabet)
+        id += alphabet.slice(0, [@min_length - id.length, alphabet.length].min)
       end
     end
 
-    if blocked_id?(id)
-      if partitioned
-        numbers[0] += 1
-      else
-        numbers = [0] + numbers
-      end
-
-      id = encode_numbers(numbers, partitioned: true)
-    end
+    id = encode_numbers(numbers, increment: increment + 1) if blocked_id?(id)
 
     id
   end
@@ -206,4 +185,16 @@ class Sqids
       end
     end
   end
+
+  def contains_multibyte_chars(input_str)
+    input_str.each_char do |char|
+      return true if char.bytesize > 1
+    end
+
+    false
+  end
+
+  def self.max_value
+    defined?(Integer::MAX) ? Integer::MAX : ((2**((0.size * 8) - 2)) - 1)
+  end
 end

data/spec/alphabet_spec.rb

@@ -8,14 +8,14 @@ describe Sqids do
     sqids = Sqids.new(alphabet: '0123456789abcdef')
 
     numbers = [1, 2, 3]
-    id = '4d9fd2'
+    id = '489158'
 
     expect(sqids.encode(numbers)).to eq(id)
     expect(sqids.decode(id)).to eq(numbers)
   end
 
   it 'decodes after encoding with a short alphabet' do
-    sqids = Sqids.new(alphabet: 'abcde')
+    sqids = Sqids.new(alphabet: 'abc')
 
     numbers = [1, 2, 3]
     encoded = sqids.encode(numbers)
@@ -33,6 +33,12 @@ describe Sqids do
     expect(sqids.decode(encoded)).to eq(numbers)
   end
 
+  it 'fails when alphabet has multibyte characters' do
+    expect do
+      Sqids.new(alphabet: 'ë1092')
+    end.to raise_error(ArgumentError)
+  end
+
   it 'fails when alphabet characters are repeated' do
     expect do
       Sqids.new(alphabet: 'aabcdefg')
@@ -41,7 +47,7 @@ describe Sqids do
 
   it 'fails when alphabet is too short' do
     expect do
-      Sqids.new(alphabet: 'abcd')
+      Sqids.new(alphabet: 'ab')
     end.to raise_error(ArgumentError)
   end
 end

data/spec/blocklist_spec.rb

@@ -8,59 +8,74 @@ describe Sqids do
   it 'uses default blocklist if no custom blocklist is provided' do
     sqids = Sqids.new
 
-    expect(sqids.decode('sexy')).to eq([200_044])
-    expect(sqids.encode([200_044])).to eq('d171vI')
+    expect(sqids.decode('aho1e')).to eq([4_572_721])
+    expect(sqids.encode([4_572_721])).to eq('JExTR')
   end
 
   it 'does not use any blocklist if an empty blocklist is provided' do
     sqids = Sqids.new(blocklist: Set.new([]))
 
-    expect(sqids.decode('sexy')).to eq([200_044])
-    expect(sqids.encode([200_044])).to eq('sexy')
+    expect(sqids.decode('aho1e')).to eq([4_572_721])
+    expect(sqids.encode([4_572_721])).to eq('aho1e')
   end
 
   it 'uses provided blocklist if non-empty blocklist is provided' do
-    sqids = Sqids.new(blocklist: Set.new(['AvTg']))
+    sqids = Sqids.new(blocklist: Set.new(['ArUO']))
 
-    expect(sqids.decode('sexy')).to eq([200_044])
-    expect(sqids.encode([200_044])).to eq('sexy')
+    expect(sqids.decode('aho1e')).to eq([4_572_721])
+    expect(sqids.encode([4_572_721])).to eq('aho1e')
 
-    expect(sqids.decode('AvTg')).to eq([100_000])
-    expect(sqids.encode([100_000])).to eq('7T1X8k')
-    expect(sqids.decode('7T1X8k')).to eq([100_000])
+    expect(sqids.decode('ArUO')).to eq([100_000])
+    expect(sqids.encode([100_000])).to eq('QyG4')
+    expect(sqids.decode('QyG4')).to eq([100_000])
   end
 
   it 'uses blocklist to prevent certain encodings' do
-    sqids = Sqids.new(blocklist: Set.new(%w[8QRLaD 7T1cd0dL UeIe imhw LfUQ]))
+    sqids = Sqids.new(blocklist: Set.new(%w[JSwXFaosAN OCjV9JK64o rBHf 79SM 7tE6]))
 
-    expect(sqids.encode([1, 2, 3])).to eq('TM0x1Mxz')
-    expect(sqids.decode('TM0x1Mxz')).to eq([1, 2, 3])
+    expect(sqids.encode([1_000_000, 2_000_000])).to eq('1aYeB7bRUt')
+    expect(sqids.decode('1aYeB7bRUt')).to eq([1_000_000, 2_000_000])
   end
 
   it 'can decode blocklist words' do
-    sqids = Sqids.new(blocklist: Set.new(%w[8QRLaD 7T1cd0dL RA8UeIe7 WM3Limhw LfUQh4HN]))
+    sqids = Sqids.new(blocklist: Set.new(%w[86Rf07 se8ojk ARsz1p Q8AI49 5sQRZO]))
 
-    expect(sqids.decode('8QRLaD')).to eq([1, 2, 3])
-    expect(sqids.decode('7T1cd0dL')).to eq([1, 2, 3])
-    expect(sqids.decode('RA8UeIe7')).to eq([1, 2, 3])
-    expect(sqids.decode('WM3Limhw')).to eq([1, 2, 3])
-    expect(sqids.decode('LfUQh4HN')).to eq([1, 2, 3])
+    expect(sqids.decode('86Rf07')).to eq([1, 2, 3])
+    expect(sqids.decode('se8ojk')).to eq([1, 2, 3])
+    expect(sqids.decode('ARsz1p')).to eq([1, 2, 3])
+    expect(sqids.decode('Q8AI49')).to eq([1, 2, 3])
+    expect(sqids.decode('5sQRZO')).to eq([1, 2, 3])
   end
 
   it 'matches against a short blocklist word' do
-    sqids = Sqids.new(blocklist: Set.new(['pPQ']))
+    sqids = Sqids.new(blocklist: Set.new(['pnd']))
 
     expect(sqids.decode(sqids.encode([1_000]))).to eq([1_000])
   end
 
   it 'blocklist filtering in constructor' do
     # lowercase blocklist in only-uppercase alphabet
-    sqids = Sqids.new(alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', blocklist: Set.new(['sqnmpn']))
+    sqids = Sqids.new(alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', blocklist: Set.new(['sxnzkl']))
 
     id = sqids.encode([1, 2, 3])
     numbers = sqids.decode(id)
 
-    expect(id).to eq('ULPBZGBM') # without blocklist, would've been "SQNMPN"
+    expect(id).to eq('IBSHOZ') # without blocklist, would've been "SXNZKL"
     expect(numbers).to eq([1, 2, 3])
   end
+
+  it 'max encoding attempts' do
+    alphabet = 'abc'
+    min_length = 3
+    blocklist = Set.new(%w[cab abc bca])
+
+    sqids = Sqids.new(alphabet: alphabet, min_length: min_length, blocklist: blocklist)
+
+    expect(min_length).to eq(alphabet.length)
+    expect(min_length).to eq(blocklist.size)
+
+    expect do
+      sqids.encode([0])
+    end.to raise_error(ArgumentError)
+  end
 end

data/spec/encoding_spec.rb

@@ -8,7 +8,7 @@ describe 'Sqids' do
     sqids = Sqids.new
 
     numbers = [1, 2, 3]
-    id = '8QRLaD'
+    id = '86Rf07'
 
     expect(sqids.encode(numbers)).to eq(id)
     expect(sqids.decode(id)).to eq(numbers)
@@ -25,16 +25,16 @@ describe 'Sqids' do
     sqids = Sqids.new
 
     ids = {
-      'bV' => [0],
-      'U9' => [1],
-      'g8' => [2],
-      'Ez' => [3],
-      'V8' => [4],
-      'ul' => [5],
-      'O3' => [6],
-      'AF' => [7],
-      'ph' => [8],
-      'n8' => [9]
+      'bM' => [0],
+      'Uk' => [1],
+      'gb' => [2],
+      'Ef' => [3],
+      'Vq' => [4],
+      'uw' => [5],
+      'OI' => [6],
+      'AX' => [7],
+      'p6' => [8],
+      'nJ' => [9]
     }
 
     ids.each do |id, numbers|
@@ -47,16 +47,16 @@ describe 'Sqids' do
     sqids = Sqids.new
 
     ids = {
-      'SrIu' => [0, 0],
-      'nZqE' => [0, 1],
-      'tJyf' => [0, 2],
-      'e86S' => [0, 3],
-      'rtC7' => [0, 4],
-      'sQ8R' => [0, 5],
-      'uz2n' => [0, 6],
-      '7Td9' => [0, 7],
-      '3nWE' => [0, 8],
-      'mIxM' => [0, 9]
+      'SvIz' => [0, 0],
+      'n3qa' => [0, 1],
+      'tryF' => [0, 2],
+      'eg6q' => [0, 3],
+      'rSCF' => [0, 4],
+      'sR8x' => [0, 5],
+      'uY2M' => [0, 6],
+      '74dI' => [0, 7],
+      '30WX' => [0, 8],
+      'moxr' => [0, 9]
     }
 
     ids.each do |id, numbers|
@@ -69,16 +69,16 @@ describe 'Sqids' do
     sqids = Sqids.new
 
     ids = {
-      'SrIu' => [0, 0],
-      'nbqh' => [1, 0],
-      't4yj' => [2, 0],
-      'eQ6L' => [3, 0],
-      'r4Cc' => [4, 0],
-      'sL82' => [5, 0],
-      'uo2f' => [6, 0],
-      '7Zdq' => [7, 0],
-      '36Wf' => [8, 0],
-      'm4xT' => [9, 0]
+      'SvIz' => [0, 0],
+      'nWqP' => [1, 0],
+      'tSyw' => [2, 0],
+      'eX68' => [3, 0],
+      'rxCY' => [4, 0],
+      'sV8a' => [5, 0],
+      'uf2K' => [6, 0],
+      '7Cdk' => [7, 0],
+      '3aWP' => [8, 0],
+      'm2xn' => [9, 0]
     }
 
     ids.each do |id, numbers|
@@ -110,14 +110,9 @@ describe 'Sqids' do
     expect(sqids.decode('*')).to eq([])
   end
 
-  it 'decoding an invalid ID with a repeating reserved character' do
-    sqids = Sqids.new
-    expect(sqids.decode('fff')).to eq([])
-  end
-
   it 'encode out-of-range numbers' do
     sqids = Sqids.new
-    expect { sqids.encode([Sqids.min_value - 1]) }.to raise_error(ArgumentError)
+    expect { sqids.encode([-1]) }.to raise_error(ArgumentError)
     expect { sqids.encode([Sqids.max_value + 1]) }.to raise_error(ArgumentError)
   end
 end

data/spec/minlength_spec.rb

@@ -10,26 +10,52 @@ describe Sqids do
     sqids = Sqids.new(min_length: default_alphabet.length)
 
     numbers = [1, 2, 3]
-    id = '75JILToVsGerOADWmHlY38xvbaNZKQ9wdFS0B6kcMEtnRpgizhjU42qT1cd0dL'
+    id = '86Rf07xd4zBmiJXQG6otHEbew02c3PWsUOLZxADhCpKj7aVFv9I8RquYrNlSTM'
 
     expect(sqids.encode(numbers)).to eq(id)
     expect(sqids.decode(id)).to eq(numbers)
   end
 
+  it 'encodes and decodes incremental' do
+    numbers = [1, 2, 3]
+    map = {
+      6 => '86Rf07',
+      7 => '86Rf07x',
+      8 => '86Rf07xd',
+      9 => '86Rf07xd4',
+      10 => '86Rf07xd4z',
+      11 => '86Rf07xd4zB',
+      12 => '86Rf07xd4zBm',
+      13 => '86Rf07xd4zBmi'
+    }
+    map[default_alphabet.length + 0] = '86Rf07xd4zBmiJXQG6otHEbew02c3PWsUOLZxADhCpKj7aVFv9I8RquYrNlSTM'
+    map[default_alphabet.length + 1] = '86Rf07xd4zBmiJXQG6otHEbew02c3PWsUOLZxADhCpKj7aVFv9I8RquYrNlSTMy'
+    map[default_alphabet.length + 2] = '86Rf07xd4zBmiJXQG6otHEbew02c3PWsUOLZxADhCpKj7aVFv9I8RquYrNlSTMyf'
+    map[default_alphabet.length + 3] = '86Rf07xd4zBmiJXQG6otHEbew02c3PWsUOLZxADhCpKj7aVFv9I8RquYrNlSTMyf1'
+
+    map.each do |min_length, id|
+      sqids = Sqids.new(min_length: min_length)
+
+      expect(sqids.encode(numbers)).to eq(id)
+      expect(sqids.encode(numbers).length).to eq(min_length)
+      expect(sqids.decode(id)).to eq(numbers)
+    end
+  end
+
   it 'encodes and decodes incremental numbers' do
     sqids = Sqids.new(min_length: default_alphabet.length)
 
     ids = {
-      'jf26PLNeO5WbJDUV7FmMtlGXps3CoqkHnZ8cYd19yIiTAQuvKSExzhrRghBlwf' => [0, 0],
-      'vQLUq7zWXC6k9cNOtgJ2ZK8rbxuipBFAS10yTdYeRa3ojHwGnmMV4PDhESI2jL' => [0, 1],
-      'YhcpVK3COXbifmnZoLuxWgBQwtjsSaDGAdr0ReTHM16yI9vU8JNzlFq5Eu2oPp' => [0, 2],
-      'OTkn9daFgDZX6LbmfxI83RSKetJu0APihlsrYoz5pvQw7GyWHEUcN2jBqd4kJ9' => [0, 3],
-      'h2cV5eLNYj1x4ToZpfM90UlgHBOKikQFvnW36AC8zrmuJ7XdRytIGPawqYEbBe' => [0, 4],
-      '7Mf0HeUNkpsZOTvmcj836P9EWKaACBubInFJtwXR2DSzgYGhQV5i4lLxoT1qdU' => [0, 5],
-      'APVSD1ZIY4WGBK75xktMfTev8qsCJw6oyH2j3OnLcXRlhziUmpbuNEar05QCsI' => [0, 6],
-      'P0LUhnlT76rsWSofOeyRGQZv1cC5qu3dtaJYNEXwk8Vpx92bKiHIz4MgmiDOF7' => [0, 7],
-      'xAhypZMXYIGCL4uW0te6lsFHaPc3SiD1TBgw5O7bvodzjqUn89JQRfk2Nvm4JI' => [0, 8],
-      '94dRPIZ6irlXWvTbKywFuAhBoECQOVMjDJp53s2xeqaSzHY8nc17tmkLGwfGNl' => [0, 9]
+      'SvIzsqYMyQwI3GWgJAe17URxX8V924Co0DaTZLtFjHriEn5bPhcSkfmvOslpBu' => [0, 0],
+      'n3qafPOLKdfHpuNw3M61r95svbeJGk7aAEgYn4WlSjXURmF8IDqZBy0CT2VxQc' => [0, 1],
+      'tryFJbWcFMiYPg8sASm51uIV93GXTnvRzyfLleh06CpodJD42B7OraKtkQNxUZ' => [0, 2],
+      'eg6ql0A3XmvPoCzMlB6DraNGcWSIy5VR8iYup2Qk4tjZFKe1hbwfgHdUTsnLqE' => [0, 3],
+      'rSCFlp0rB2inEljaRdxKt7FkIbODSf8wYgTsZM1HL9JzN35cyoqueUvVWCm4hX' => [0, 4],
+      'sR8xjC8WQkOwo74PnglH1YFdTI0eaf56RGVSitzbjuZ3shNUXBrqLxEJyAmKv2' => [0, 5],
+      'uY2MYFqCLpgx5XQcjdtZK286AwWV7IBGEfuS9yTmbJvkzoUPeYRHr4iDs3naN0' => [0, 6],
+      '74dID7X28VLQhBlnGmjZrec5wTA1fqpWtK4YkaoEIM9SRNiC3gUJH0OFvsPDdy' => [0, 7],
+      '30WXpesPhgKiEI5RHTY7xbB1GnytJvXOl2p0AcUjdF6waZDo9Qk8VLzMuWrqCS' => [0, 8],
+      'moxr3HqLAK0GsTND6jowfZz3SUx7cQ8aC54Pl1RbIvFXmEJuBMYVeW9yrdOtin' => [0, 9]
     }
 
     ids.each do |id, numbers|
@@ -41,7 +67,7 @@ describe Sqids do
   it 'encodes with different min lengths' do
     [0, 1, 5, 10, default_alphabet.length].each do |min_length|
       [
-        [Sqids.min_value],
+        [0],
         [0, 0, 0, 0, 0],
         [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
         [100, 200, 300],
@@ -60,6 +86,6 @@ describe Sqids do
 
   it 'raises error for out-of-range invalid min lengths' do
     expect { Sqids.new(min_length: -1) }.to raise_error(TypeError)
-    expect { Sqids.new(min_length: default_alphabet.length + 1) }.to raise_error(TypeError)
+    expect { Sqids.new(min_length: 256) }.to raise_error(TypeError)
   end
 end

data/sqids.gemspec

@@ -7,7 +7,7 @@ require 'sqids'
 
 Gem::Specification.new do |gem|
   gem.name          = 'sqids'
-  gem.version       = '0.1.2'
+  gem.version       = '0.2.1'
   gem.authors       = ['Sqids Maintainers']
   gem.summary       = 'Generate YouTube-like ids from numbers.'
   gem.homepage      = 'https://sqids.org/ruby'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sqids
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.1
 platform: ruby
 authors:
 - Sqids Maintainers
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-31 00:00:00.000000000 Z
+date: 2024-07-25 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -27,7 +27,6 @@ files:
 - spec/blocklist_spec.rb
 - spec/encoding_spec.rb
 - spec/minlength_spec.rb
-- spec/uniques_spec.rb
 - sqids.gemspec
 homepage: https://sqids.org/ruby
 licenses:

data/spec/uniques_spec.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require 'rspec'
-require_relative '../lib/sqids'
-
-upper = 10_000
-
-describe Sqids do
-  let(:sqids) { Sqids.new(min_length: Sqids::DEFAULT_ALPHABET.length) }
-
-  it 'uniques, with padding' do
-    set = Set.new
-
-    (0...upper).each do |i|
-      numbers = [i]
-      id = sqids.encode(numbers)
-      set.add(id)
-      expect(sqids.decode(id)).to eq(numbers)
-    end
-
-    expect(set.size).to eq(upper)
-  end
-
-  it 'uniques, low ranges' do
-    set = Set.new
-
-    (0...upper).each do |i|
-      numbers = [i]
-      id = sqids.encode(numbers)
-      set.add(id)
-      expect(sqids.decode(id)).to eq(numbers)
-    end
-
-    expect(set.size).to eq(upper)
-  end
-
-  it 'uniques, high ranges' do
-    set = Set.new
-
-    (100_000_000...(100_000_000 + upper)).each do |i|
-      numbers = [i]
-      id = sqids.encode(numbers)
-      set.add(id)
-      expect(sqids.decode(id)).to eq(numbers)
-    end
-
-    expect(set.size).to eq(upper)
-  end
-
-  it 'uniques, multi' do
-    set = Set.new
-
-    (0...upper).each do |i|
-      numbers = [i, i, i, i, i]
-      id = sqids.encode(numbers)
-      set.add(id)
-      expect(sqids.decode(id)).to eq(numbers)
-    end
-
-    expect(set.size).to eq(upper)
-  end
-end