encoded_id 1.0.0.rc4 → 1.0.0.rc5

data/ext/encoded_id/hashids.h

@@ -0,0 +1,139 @@
+// https://github.com/tzvetkoff/hashids.c
+/*
+Copyright (C) 2014 Latchezar Tzvetkoff
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 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.
+*/
+
+
+#ifndef HASHIDS_H
+#define HASHIDS_H 1
+
+#include <stdlib.h>
+
+/* version constants */
+#define HASHIDS_VERSION "1.2.1"
+#define HASHIDS_VERSION_MAJOR 1
+#define HASHIDS_VERSION_MINOR 2
+#define HASHIDS_VERSION_PATCH 1
+
+/* minimal alphabet length */
+#define HASHIDS_MIN_ALPHABET_LENGTH 16u
+
+/* separator divisor */
+#define HASHIDS_SEPARATOR_DIVISOR 3.5f
+
+/* guard divisor */
+#define HASHIDS_GUARD_DIVISOR 12u
+
+/* default salt */
+#define HASHIDS_DEFAULT_SALT ""
+
+/* default minimal hash length */
+#define HASHIDS_DEFAULT_MIN_HASH_LENGTH 0u
+
+/* default alphabet */
+#define HASHIDS_DEFAULT_ALPHABET "abcdefghijklmnopqrstuvwxyz" \
+                                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
+                                 "1234567890"
+
+/* default separators */
+#define HASHIDS_DEFAULT_SEPARATORS "cfhistuCFHISTU"
+
+/* error codes */
+#define HASHIDS_ERROR_OK                0
+#define HASHIDS_ERROR_ALLOC             -1
+#define HASHIDS_ERROR_ALPHABET_LENGTH   -2
+#define HASHIDS_ERROR_ALPHABET_SPACE    -3
+#define HASHIDS_ERROR_INVALID_HASH      -4
+#define HASHIDS_ERROR_INVALID_NUMBER    -5
+
+/* thread-safe hashids_errno indirection */
+extern int *__hashids_errno_addr(void);
+#define hashids_errno (*__hashids_errno_addr())
+
+/* alloc & free */
+extern void *(*_hashids_alloc)(size_t size);
+extern void (*_hashids_free)(void *ptr);
+
+/* the hashids "object" */
+struct hashids_s {
+    char *alphabet;
+    char *alphabet_copy_1;
+    char *alphabet_copy_2;
+    size_t alphabet_length;
+
+    char *salt;
+    size_t salt_length;
+
+    char *separators;
+    size_t separators_count;
+
+    char *guards;
+    size_t guards_count;
+
+    size_t min_hash_length;
+};
+typedef struct hashids_s hashids_t;
+
+/* exported function definitions */
+void
+hashids_shuffle(char *str, size_t str_length, char *salt, size_t salt_length);
+
+void
+hashids_free(hashids_t *hashids);
+
+hashids_t *
+hashids_init3(const char *salt, size_t min_hash_length,
+    const char *alphabet);
+
+hashids_t *
+hashids_init2(const char *salt, size_t min_hash_length);
+
+hashids_t *
+hashids_init(const char *salt);
+
+size_t
+hashids_estimate_encoded_size(hashids_t *hashids, size_t numbers_count,
+    unsigned long long *numbers);
+
+size_t
+hashids_estimate_encoded_size_v(hashids_t *hashids, size_t numbers_count, ...);
+
+size_t
+hashids_encode(hashids_t *hashids, char *buffer, size_t numbers_count,
+    unsigned long long *numbers);
+
+size_t
+hashids_encode_v(hashids_t *hashids, char *buffer, size_t numbers_count, ...);
+
+size_t
+hashids_encode_one(hashids_t *hashids, char *buffer,
+    unsigned long long number);
+
+size_t
+hashids_numbers_count(hashids_t *hashids, const char *str);
+
+size_t
+hashids_decode(hashids_t *hashids, const char *str,
+    unsigned long long *numbers, size_t numbers_max);
+
+size_t
+hashids_decode_unsafe(hashids_t *hashids, const char *str,
+    unsigned long long *numbers);
+
+size_t
+hashids_decode_safe(hashids_t *hashids, const char *str,
+    unsigned long long *numbers, size_t numbers_max);
+
+size_t
+hashids_encode_hex(hashids_t *hashids, char *buffer, const char *hex_str);
+
+size_t
+hashids_decode_hex(hashids_t *hashids, char *str, char *output);
+
+#endif

data/lib/encoded_id/alphabet.rb

@@ -15,6 +15,10 @@ module EncodedId
           }
         )
       end
+
+      def alphanum
+        new("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890")
+      end
     end
 
     def initialize(characters, equivalences = nil)

data/lib/encoded_id/hash_id.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+# This implementation based on https://github.com/peterhellberg/hashids.rb
+#
+# Original Hashids implementation is MIT licensed:
+#
+# Copyright (c) 2013-2017 Peter Hellberg
+#
+# MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# 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.
+#
+# This version also MIT licensed (Stephen Ierodiaconou): see LICENSE.txt file
+module EncodedId
+  class HashId
+    def initialize(salt, min_hash_length = 0, alphabet = Alphabet.alphanum)
+      unless min_hash_length.is_a?(Integer) && min_hash_length >= 0
+        raise ArgumentError, "The min length must be a Integer and greater than or equal to 0"
+      end
+      @min_hash_length = min_hash_length
+
+      # TODO: move this class creation out of the constructor?
+      @separators_and_guards = OrdinalAlphabetSeparatorGuards.new(alphabet, salt)
+      @alphabet_ordinals = @separators_and_guards.alphabet
+      @separator_ordinals = @separators_and_guards.seps
+      @guard_ordinals = @separators_and_guards.guards
+      @salt_ordinals = @separators_and_guards.salt
+
+      @escaped_separator_selector = @separators_and_guards.seps_tr_selector
+      @escaped_guards_selector = @separators_and_guards.guards_tr_selector
+    end
+
+    attr_reader :alphabet_ordinals, :separator_ordinals, :guard_ordinals, :salt_ordinals
+
+    # We could get rid of calling with multiple arguments and just use an array as the argument always
+    def encode(numbers)
+      numbers.all? { |n| Integer(n) } # raises if conversion fails
+
+      return "" if numbers.empty? || numbers.any? { |n| n < 0 }
+
+      internal_encode(numbers)
+    end
+
+    def encode_hex(str)
+      return "" unless hex_string?(str)
+
+      numbers = str.scan(/[\w\W]{1,12}/).map do |num|
+        "1#{num}".to_i(16)
+      end
+
+      encode(numbers)
+    end
+
+    def decode(hash)
+      return [] if hash.nil? || hash.empty?
+
+      internal_decode(hash)
+    end
+
+    def decode_hex(hash)
+      numbers = decode(hash)
+
+      ret = numbers.map do |n|
+        n.to_s(16)[1..]
+      end
+
+      ret.join.upcase
+    end
+
+    protected
+
+    def internal_encode(numbers)
+      current_alphabet = @alphabet_ordinals.dup
+      separator_ordinals = @separator_ordinals
+      guard_ordinals = @guard_ordinals
+
+      alphabet_length = current_alphabet.length
+      length = numbers.length
+
+      hash_int = 0
+      # We dont use the iterator#sum to avoid the extra array allocation
+      i = 0
+      while i < length
+        hash_int += numbers[i] % (i + 100)
+        i += 1
+      end
+
+      lottery = current_alphabet[hash_int % alphabet_length]
+
+      # This is the final string form of the hash, as an array of ordinals
+      hashid_code = []
+      hashid_code << lottery
+      seasoning = [lottery].concat(@salt_ordinals)
+
+      i = 0
+      while i < length
+        num = numbers[i]
+        consistent_shuffle!(current_alphabet, seasoning, current_alphabet.dup, alphabet_length)
+        last_char_ord = hash_one_number(hashid_code, num, current_alphabet, alphabet_length)
+
+        if (i + 1) < length
+          num %= (last_char_ord + i)
+          hashid_code << separator_ordinals[num % separator_ordinals.length]
+        end
+
+        i += 1
+      end
+
+      if hashid_code.length < @min_hash_length
+        hashid_code.prepend(guard_ordinals[(hash_int + hashid_code[0]) % guard_ordinals.length])
+
+        if hashid_code.length < @min_hash_length
+          hashid_code << guard_ordinals[(hash_int + hashid_code[2]) % guard_ordinals.length]
+        end
+      end
+
+      half_length = current_alphabet.length.div(2)
+
+      while hashid_code.length < @min_hash_length
+        consistent_shuffle!(current_alphabet, current_alphabet.dup, nil, current_alphabet.length)
+        hashid_code.prepend(*current_alphabet[half_length..])
+        hashid_code.concat(current_alphabet[0, half_length])
+
+        excess = hashid_code.length - @min_hash_length
+        hashid_code = hashid_code[excess / 2, @min_hash_length] if excess > 0
+      end
+
+      # Convert the array of ordinals to a string
+      hashid_code.pack("U*")
+    end
+
+    def internal_decode(hash)
+      ret = []
+      current_alphabet = @alphabet_ordinals.dup
+      salt_ordinals = @salt_ordinals
+
+      breakdown = hash.tr(@escaped_guards_selector, " ")
+      array = breakdown.split(" ")
+
+      i = [3, 2].include?(array.length) ? 1 : 0
+
+      if (breakdown = array[i])
+        lottery, breakdown = breakdown[0], breakdown[1..]
+        breakdown.tr!(@escaped_separator_selector, " ")
+        sub_hashes = breakdown.split(" ")
+
+        seasoning = [lottery.ord].concat(salt_ordinals)
+
+        len = sub_hashes.length
+        time = 0
+        while time < len
+          sub_hash = sub_hashes[time]
+          consistent_shuffle!(current_alphabet, seasoning, current_alphabet.dup, current_alphabet.length)
+
+          ret.push unhash(sub_hash, current_alphabet)
+          time += 1
+        end
+
+        # Check if the result is consistent with the hash, this is important for safety since otherwise
+        # a random string could feasibly decode to a set of numbers
+        if encode(ret) != hash
+          ret = []
+        end
+      end
+
+      ret
+    end
+
+    def hash_one_number(hash_code, num, alphabet, alphabet_length)
+      char = nil
+      insert_at = 0
+      while true # standard:disable Style/InfiniteLoop
+        char = alphabet[num % alphabet_length]
+        insert_at -= 1
+        hash_code.insert(insert_at, char)
+        num /= alphabet_length
+        break unless num > 0
+      end
+
+      char
+    end
+
+    def unhash(input, alphabet)
+      num = 0
+      input_length = input.length
+      alphabet_length = alphabet.length
+      i = 0
+      while i < input_length
+        pos = alphabet.index(input[i].ord)
+
+        raise InvalidInputError, "unable to unhash" unless pos
+
+        num += pos * alphabet_length**(input_length - i - 1)
+        i += 1
+      end
+
+      num
+    end
+
+    private
+
+    def hex_string?(string)
+      string.to_s.match(/\A[0-9a-fA-F]+\Z/)
+    end
+
+    def consistent_shuffle!(collection_to_shuffle, salt_part_1, salt_part_2, max_salt_length)
+      HashIdConsistentShuffle.shuffle!(collection_to_shuffle, salt_part_1, salt_part_2, max_salt_length)
+    end
+  end
+end

data/lib/encoded_id/hash_id_consistent_shuffle.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module EncodedId
+  class HashIdConsistentShuffle
+    def self.shuffle!(collection_to_shuffle, salt_part_1, salt_part_2, max_salt_length)
+      salt_part_1_length = salt_part_1.length
+      raise SaltError, "Salt is too short in shuffle" if salt_part_1_length < max_salt_length && salt_part_2.nil?
+
+      return collection_to_shuffle if collection_to_shuffle.empty? || max_salt_length == 0 || salt_part_1.nil? || salt_part_1_length == 0
+
+      idx = ord_total = 0
+      i = collection_to_shuffle.length - 1
+      while i >= 1
+        n = (idx >= salt_part_1_length) ? salt_part_2[idx - salt_part_1_length] : salt_part_1[idx]
+        ord_total += n
+        j = (n + idx + ord_total) % i
+
+        collection_to_shuffle[i], collection_to_shuffle[j] = collection_to_shuffle[j], collection_to_shuffle[i]
+
+        idx = (idx + 1) % max_salt_length
+        i -= 1
+      end
+
+      collection_to_shuffle
+    end
+  end
+end

data/lib/encoded_id/hash_id_salt.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module EncodedId
+  class HashIdSalt
+    def initialize(salt)
+      unless salt.is_a?(String)
+        raise SaltError, "The salt must be a String"
+      end
+      @salt = salt.freeze
+      @chars = salt.chars.freeze
+    end
+
+    attr_reader :salt, :chars
+  end
+end

data/lib/encoded_id/ordinal_alphabet_separator_guards.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module EncodedId
+  class OrdinalAlphabetSeparatorGuards
+    SEP_DIV = 3.5
+    DEFAULT_SEPS = "cfhistuCFHISTU".chars.map(&:ord).freeze
+    GUARD_DIV = 12.0
+    SPACE_CHAR = " ".ord
+
+    def initialize(alphabet, salt)
+      @alphabet = alphabet.characters.chars.map(&:ord)
+      @salt = salt.chars.map(&:ord)
+
+      setup_seps
+      setup_guards
+
+      @seps_tr_selector = escape_characters_string_for_tr(@seps.map(&:chr))
+      @guards_tr_selector = escape_characters_string_for_tr(@guards.map(&:chr))
+
+      @alphabet.freeze
+      @seps.freeze
+      @guards.freeze
+    end
+
+    attr_reader :salt, :alphabet, :seps, :guards, :seps_tr_selector, :guards_tr_selector
+
+    private
+
+    def escape_characters_string_for_tr(chars)
+      chars.join.gsub(/([-\\^])/) { "\\#{$1}" }
+    end
+
+    def setup_seps
+      @seps = DEFAULT_SEPS.dup
+
+      @seps.length.times do |i|
+        # Seps should only contain characters present in alphabet,
+        # and alphabet should not contains seps
+        if (j = @alphabet.index(@seps[i]))
+          @alphabet = pick_characters(@alphabet, j)
+        else
+          @seps = pick_characters(@seps, i)
+        end
+      end
+
+      @alphabet.delete(SPACE_CHAR)
+      @seps.delete(SPACE_CHAR)
+
+      consistent_shuffle!(@seps, @salt, nil, @salt.length)
+
+      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
+
+        if seps_length > @seps.length
+          diff = seps_length - @seps.length
+
+          @seps += @alphabet[0, diff]
+          @alphabet = @alphabet[diff..]
+        else
+          @seps = @seps[0, seps_length]
+        end
+      end
+
+      consistent_shuffle!(@alphabet, @salt, nil, @salt.length)
+    end
+
+    def setup_guards
+      gc = (@alphabet.length / GUARD_DIV).ceil
+
+      if @alphabet.length < 3
+        @guards = @seps[0, gc]
+        @seps = @seps[gc..]
+      else
+        @guards = @alphabet[0, gc]
+        @alphabet = @alphabet[gc..]
+      end
+    end
+
+    def pick_characters(array, index)
+      tail = array[index + 1..]
+      head = array[0, index] + [SPACE_CHAR] # This space seems pointless but the original code does it, and its needed to maintain the same result in shuffling
+      tail ? head + tail : head
+    end
+
+    def consistent_shuffle!(collection_to_shuffle, salt_part_1, salt_part_2, max_salt_length)
+      HashIdConsistentShuffle.shuffle!(collection_to_shuffle, salt_part_1, salt_part_2, max_salt_length)
+    end
+  end
+end

data/lib/encoded_id/reversible_id.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "hashids"
-
 # Hashid with a reduced character set Crockford alphabet and split groups
 # See: https://www.crockford.com/wrmg/base32.html
 # Build with https://hashids.org
@@ -37,10 +35,10 @@ module EncodedId
 
     # Decode the hash to original array
     def decode(str, downcase: true)
-      raise InvalidInputError if max_length_exceeded?(str)
+      raise EncodedIdFormatError, "Max length of input exceeded" if max_length_exceeded?(str)
 
       encoded_id_generator.decode(convert_to_hash(str, downcase))
-    rescue ::Hashids::InputError => e
+    rescue InvalidInputError => e
       raise EncodedIdFormatError, e.message
     end
 
@@ -111,7 +109,7 @@ module EncodedId
     end
 
     def encoded_id_generator
-      @encoded_id_generator ||= ::Hashids.new(salt, length, alphabet.characters)
+      @encoded_id_generator ||= HashId.new(salt, length, alphabet)
     end
 
     def split_regex

data/lib/encoded_id/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EncodedId
-  VERSION = "1.0.0.rc4"
+  VERSION = "1.0.0.rc5"
 end

data/lib/encoded_id.rb

@@ -3,6 +3,12 @@
 require_relative "encoded_id/version"
 require_relative "encoded_id/alphabet"
 require_relative "encoded_id/hex_representation"
+
+require_relative "encoded_id/hash_id_salt"
+require_relative "encoded_id/hash_id_consistent_shuffle"
+require_relative "encoded_id/ordinal_alphabet_separator_guards"
+require_relative "encoded_id/hash_id"
+
 require_relative "encoded_id/reversible_id"
 
 module EncodedId
@@ -15,4 +21,6 @@ module EncodedId
   class EncodedIdLengthError < ArgumentError; end
 
   class InvalidInputError < ArgumentError; end
+
+  class SaltError < ArgumentError; end
 end

data/sig/encoded_id.rbs

@@ -7,6 +7,78 @@ module EncodedId
   InvalidAlphabetError: ::ArgumentError
   InvalidInputError: ::ArgumentError
 
+  class HashId
+    MIN_ALPHABET_LENGTH: ::Integer
+
+    SEP_DIV: ::Float
+
+    GUARD_DIV: ::Float
+
+    DEFAULT_SEPS: ::String
+
+    DEFAULT_ALPHABET: ::String
+
+    attr_reader salt: ::String
+
+    attr_reader min_hash_length: ::Integer
+
+    @alphabet: ::String
+
+    attr_reader alphabet: ::String
+
+    attr_reader seps: ::String | ::Array[::String]
+
+    attr_reader guards: untyped
+
+    def initialize: (?::String salt, ?::Integer min_hash_length, ?untyped alphabet) -> void
+
+    def encode: (*(Array[::Integer] | ::Integer) numbers) -> ::String
+
+    def encode_hex: (::String str) -> ::String
+
+    def decode: (::String hash) -> ::Array[::Integer]
+
+    def decode_hex: (::String hash) -> ::Array[::Integer]
+
+    # protected
+
+    def internal_encode: (untyped numbers) -> untyped
+
+    def internal_decode: (untyped hash, untyped alphabet) -> untyped
+
+    def consistent_shuffle: (::Array[::String] chars, ::String salt1, ::String ?salt2, ::Integer salt1_length) -> untyped
+
+    def hash: (untyped input, untyped alphabet) -> untyped
+
+    def unhash: (untyped input, untyped alphabet) -> untyped
+
+    private
+
+    def setup_alphabet: () -> untyped
+
+    def setup_seps: () -> untyped
+
+    def setup_guards: () -> untyped
+
+    SaltError: ArgumentError
+
+    MinLengthError: ArgumentError
+
+    AlphabetError: ArgumentError
+
+    InputError: ArgumentError
+
+    def validate_attributes: () -> untyped
+
+    def validate_alphabet: () -> (untyped | nil)
+
+    def hex_string?: (untyped string) -> untyped
+
+    def pick_characters: (untyped array, untyped index) -> untyped
+
+    def uniq_characters: (untyped string) -> untyped
+  end
+
   class Alphabet
     MIN_UNIQUE_CHARACTERS: ::Integer
 
@@ -75,7 +147,7 @@ module EncodedId
 
     private
 
-    @encoded_id_generator: ::Hashids
+    @encoded_id_generator: HashId
     @split_regex: ::Regexp
     @hex_string_separator: ::Integer
 
@@ -97,13 +169,13 @@ module EncodedId
     def validate_max_length: (::Integer | nil) -> (::Integer | nil)
     def validate_max_input: (::Integer) -> ::Integer
     def validate_split_at: (::Integer | nil) -> (::Integer | nil)
-    def validate_split_with: (::String, Alphabet) -> ::String
+    def validate_split_with: (::String, Alphabet) -> (::String | nil)
     def validate_hex_digit_encoding_group_size: (::Integer) -> ::Integer
     def valid_integer_option?: (::Integer | nil) -> bool
 
     def prepare_input: (untyped value) -> ::Array[::Integer]
 
-    def encoded_id_generator: () -> ::Hashids
+    def encoded_id_generator: () -> HashId
 
     def split_regex: () -> ::Regexp