encoded_id 1.0.0.rc3 → 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,14 +1,12 @@
 # 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
 # Note hashIds already has a built in profanity limitation algorithm
 module EncodedId
   class ReversibleId
-    def initialize(salt:, length: 8, split_at: 4, split_with: "-", alphabet: Alphabet.modified_crockford, hex_digit_encoding_group_size: 4, max_length: 128)
+    def initialize(salt:, length: 8, split_at: 4, split_with: "-", alphabet: Alphabet.modified_crockford, hex_digit_encoding_group_size: 4, max_length: 128, max_inputs_per_id: 32)
       @alphabet = validate_alphabet(alphabet)
       @salt = validate_salt(salt)
       @length = validate_length(length)
@@ -16,13 +14,14 @@ module EncodedId
       @split_with = validate_split_with(split_with, alphabet)
       @hex_represention_encoder = HexRepresentation.new(hex_digit_encoding_group_size)
       @max_length = validate_max_length(max_length)
+      @max_inputs_per_id = validate_max_input(max_inputs_per_id)
     end
 
     # Encode the input values into a hash
     def encode(values)
       inputs = prepare_input(values)
       encoded_id = encoded_id_generator.encode(inputs)
-      encoded_id = humanize_length(encoded_id) unless split_at.nil?
+      encoded_id = humanize_length(encoded_id) unless split_with.nil? || split_at.nil?
 
       raise EncodedIdLengthError if max_length_exceeded?(encoded_id)
 
@@ -36,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
 
@@ -80,6 +79,11 @@ module EncodedId
       raise InvalidConfigurationError, "Max length must be an integer greater than 0"
     end
 
+    def validate_max_input(max_inputs_per_id)
+      return max_inputs_per_id if valid_integer_option?(max_inputs_per_id)
+      raise InvalidConfigurationError, "Max inputs per ID must be an integer greater than 0"
+    end
+
     # Split the encoded string into groups of this size
     def validate_split_at(split_at)
       return split_at if valid_integer_option?(split_at) || split_at.nil?
@@ -87,8 +91,8 @@ module EncodedId
     end
 
     def validate_split_with(split_with, alphabet)
-      return split_with if split_with.is_a?(String) && !alphabet.characters.include?(split_with)
-      raise InvalidConfigurationError, "Split with must be a string and not part of the alphabet"
+      return split_with if split_with.nil? || (split_with.is_a?(String) && !alphabet.characters.include?(split_with))
+      raise InvalidConfigurationError, "Split with must be a string and not part of the alphabet or nil"
     end
 
     def valid_integer_option?(value)
@@ -99,11 +103,13 @@ module EncodedId
       inputs = value.is_a?(Array) ? value.map(&:to_i) : [value.to_i]
       raise ::EncodedId::InvalidInputError, "Integer IDs to be encoded can only be positive" if inputs.any?(&:negative?)
 
+      raise ::EncodedId::InvalidInputError, "%d integer IDs provided, maximum amount of IDs is %d" % [inputs.length, @max_inputs_per_id] if inputs.length > @max_inputs_per_id
+
       inputs
     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.rc3"
+  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