encoded_id 1.0.0.rc4 → 1.0.0.rc6

data/lib/encoded_id/reversible_id.rb

@@ -1,14 +1,33 @@
 # frozen_string_literal: true
 
-require "hashids"
+# rbs_inline: enabled
 
 # 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
+# Build with support for https://hashids.org and https://sqids.org
 module EncodedId
+  # @rbs!
+  #   type encodeableValue = Array[String | Integer] | String | Integer
+
   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, max_inputs_per_id: 32)
+    # @rbs VALID_ENCODERS: Array[Symbol]
+    VALID_ENCODERS = [:hashids, :sqids].freeze
+    # @rbs DEFAULT_ENCODER: Symbol
+    DEFAULT_ENCODER = :hashids
+
+    # @rbs @alphabet: Alphabet
+    # @rbs @salt: String
+    # @rbs @length: Integer
+    # @rbs @split_at: Integer?
+    # @rbs @split_with: String?
+    # @rbs @hex_represention_encoder: HexRepresentation
+    # @rbs @max_length: Integer?
+    # @rbs @max_inputs_per_id: Integer
+    # @rbs @blocklist: Blocklist
+    # @rbs @encoder: Encoders::Base
+
+    # @rbs (salt: String, ?length: Integer, ?split_at: Integer?, ?split_with: String?, ?alphabet: Alphabet, ?hex_digit_encoding_group_size: Integer, ?max_length: Integer?, ?max_inputs_per_id: Integer, ?encoder: Symbol | Encoders::Base, ?blocklist: Blocklist | Array[String] | Set[String] | nil) -> void
+    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, encoder: DEFAULT_ENCODER, blocklist: Blocklist.empty)
       @alphabet = validate_alphabet(alphabet)
       @salt = validate_salt(salt)
       @length = validate_length(length)
@@ -17,13 +36,27 @@ module EncodedId
       @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)
+      @blocklist = validate_blocklist(blocklist)
+      @encoder = create_encoder(validate_encoder(encoder))
     end
 
+    # Accessors for introspection
+    attr_reader :salt #: String
+    attr_reader :length #: Integer
+    attr_reader :alphabet #: Alphabet
+    attr_reader :split_at #: Integer?
+    attr_reader :split_with #: String?
+    attr_reader :hex_represention_encoder #: HexRepresentation
+    attr_reader :max_length #: Integer?
+    attr_reader :blocklist #: Blocklist
+    attr_reader :encoder #: Encoders::Base
+
     # Encode the input values into a hash
+    # @rbs (encodeableValue values) -> String
     def encode(values)
       inputs = prepare_input(values)
-      encoded_id = encoded_id_generator.encode(inputs)
-      encoded_id = humanize_length(encoded_id) unless split_with.nil? || split_at.nil?
+      encoded_id = encoder.encode(inputs)
+      encoded_id = humanize_length(encoded_id) if split_with && split_at
 
       raise EncodedIdLengthError if max_length_exceeded?(encoded_id)
 
@@ -31,78 +64,83 @@ module EncodedId
     end
 
     # Encode hex strings into a hash
+    # @rbs (encodeableHexValue hexs) -> String
     def encode_hex(hexs)
       encode(hex_represention_encoder.hex_as_integers(hexs))
     end
 
     # Decode the hash to original array
+    # @rbs (String str, ?downcase: bool) -> Array[Integer]
     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
+      encoder.decode(convert_to_hash(str, downcase))
+    rescue InvalidInputError => e
       raise EncodedIdFormatError, e.message
     end
 
     # Decode hex strings from a hash
+    # @rbs (String str, ?downcase: bool) -> Array[String]
     def decode_hex(str, downcase: true)
-      integers = encoded_id_generator.decode(convert_to_hash(str, downcase))
+      integers = encoder.decode(convert_to_hash(str, downcase))
       hex_represention_encoder.integers_as_hex(integers)
     end
 
     private
 
-    attr_reader :salt,
-      :length,
-      :alphabet,
-      :split_at,
-      :split_with,
-      :hex_represention_encoder,
-      :max_length
-
+    # @rbs (Alphabet alphabet) -> Alphabet
     def validate_alphabet(alphabet)
       return alphabet if alphabet.is_a?(Alphabet)
       raise InvalidAlphabetError, "alphabet must be an instance of Alphabet"
     end
 
+    # @rbs (String salt) -> String
     def validate_salt(salt)
       return salt if salt.is_a?(String) && salt.size > 3
       raise InvalidConfigurationError, "Salt must be a string and longer than 3 characters"
     end
 
     # Target length of the encoded string (the minimum but not maximum length)
+    # @rbs (Integer length) -> Integer
     def validate_length(length)
       return length if valid_integer_option?(length)
       raise InvalidConfigurationError, "Length must be an integer greater than 0"
     end
 
+    # @rbs (Integer? max_length) -> Integer?
     def validate_max_length(max_length)
       return max_length if valid_integer_option?(max_length) || max_length.nil?
       raise InvalidConfigurationError, "Max length must be an integer greater than 0"
     end
 
+    # @rbs (Integer max_inputs_per_id) -> Integer
     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
+    # @rbs (Integer? split_at) -> Integer?
     def validate_split_at(split_at)
       return split_at if valid_integer_option?(split_at) || split_at.nil?
       raise InvalidConfigurationError, "Split at must be an integer greater than 0 or nil"
     end
 
+    # @rbs (String? split_with, Alphabet alphabet) -> String?
     def validate_split_with(split_with, 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
 
+    # @rbs (Integer? value) -> bool
     def valid_integer_option?(value)
       value.is_a?(Integer) && value > 0
     end
 
+    # @rbs (encodeableValue value) -> Array[Integer]
     def prepare_input(value)
       inputs = value.is_a?(Array) ? value.map(&:to_i) : [value.to_i]
+      raise ::EncodedId::InvalidInputError, "Cannot encode an empty array" if inputs.empty?
       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
@@ -110,24 +148,69 @@ module EncodedId
       inputs
     end
 
-    def encoded_id_generator
-      @encoded_id_generator ||= ::Hashids.new(salt, length, alphabet.characters)
+    # @rbs (Symbol | Encoders::Base encoder) -> Encoders::Base
+    def create_encoder(encoder)
+      # If an encoder instance was provided, return it directly
+      return @encoder if defined?(@encoder) && @encoder.is_a?(Encoders::Base)
+      return encoder if encoder.is_a?(Encoders::Base)
+
+      case encoder
+      when :sqids
+        if defined?(Encoders::Sqids)
+          Encoders::Sqids.new(salt, length, alphabet, @blocklist)
+        else
+          raise InvalidConfigurationError, "Sqids encoder requested but the sqids gem is not available. Please add 'gem \"sqids\"' to your Gemfile."
+        end
+      when :hashids
+        Encoders::HashId.new(salt, length, alphabet, @blocklist)
+      else
+        raise InvalidConfigurationError, "The encoder name is not supported '#{encoder}'"
+      end
     end
 
-    def split_regex
-      @split_regex ||= /.{#{split_at}}(?=.)/
+    # @rbs (Symbol | Encoders::Base encoder) -> (Symbol | Encoders::Base)
+    def validate_encoder(encoder)
+      # Accept either a valid symbol or an Encoders::Base instance
+      return encoder if VALID_ENCODERS.include?(encoder) || encoder.is_a?(Encoders::Base)
+      raise InvalidConfigurationError, "Encoder must be one of: #{VALID_ENCODERS.join(", ")} or an instance of EncodedId::Encoders::Base"
     end
 
+    # @rbs (Blocklist | Array[String] | Set[String] | nil blocklist) -> Blocklist
+    def validate_blocklist(blocklist)
+      return blocklist if blocklist.is_a?(Blocklist)
+      return Blocklist.empty if blocklist.nil?
+
+      return Blocklist.new(blocklist) if blocklist.is_a?(Array) || blocklist.is_a?(Set)
+
+      raise InvalidConfigurationError, "Blocklist must be an instance of Blocklist, a Set, or an Array of strings"
+    end
+
+    # @rbs (String hash) -> String
     def humanize_length(hash)
-      hash.gsub(split_regex, "\\0#{split_with}")
+      len = hash.length
+      at = split_at #: Integer
+      with = split_with #: String
+      return hash if len <= at
+
+      separator_count = (len - 1) / at
+      result = hash.dup
+      insert_offset = 0
+      (1..separator_count).each do |i|
+        insert_pos = i * at + insert_offset
+        result.insert(insert_pos, with)
+        insert_offset += with.length
+      end
+      result
     end
 
+    # @rbs (String str, bool downcase) -> String
     def convert_to_hash(str, downcase)
-      clean = str.gsub(split_with, "")
-      clean = clean.downcase if downcase
-      map_equivalent_characters(clean)
+      str = str.gsub(split_with, "") if split_with
+      str = str.downcase if downcase
+      map_equivalent_characters(str)
     end
 
+    # @rbs (String str) -> String
     def map_equivalent_characters(str)
       return str unless alphabet.equivalences
 
@@ -137,6 +220,7 @@ module EncodedId
       end
     end
 
+    # @rbs (String str) -> bool
     def max_length_exceeded?(str)
       return false if max_length.nil?
 

data/lib/encoded_id/version.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 module EncodedId
-  VERSION = "1.0.0.rc4"
+  # @rbs VERSION: String
+  VERSION = "1.0.0.rc6"
 end

data/lib/encoded_id.rb

@@ -1,18 +1,59 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 require_relative "encoded_id/version"
 require_relative "encoded_id/alphabet"
 require_relative "encoded_id/hex_representation"
+require_relative "encoded_id/blocklist"
+
+# Load the encoder framework
+require_relative "encoded_id/encoders/base"
+require_relative "encoded_id/encoders/hash_id_salt"
+require_relative "encoded_id/encoders/hash_id_consistent_shuffle"
+require_relative "encoded_id/encoders/hash_id_ordinal_alphabet_separator_guards"
+require_relative "encoded_id/encoders/hash_id"
+
+# Only load Sqids encoder if the gem is available
+begin
+  require "sqids"
+  require_relative "encoded_id/encoders/my_sqids"
+  require_relative "encoded_id/encoders/sqids"
+rescue LoadError
+  # Sqids gem not available, encoder will not be loaded
+end
+
 require_relative "encoded_id/reversible_id"
 
+# @rbs!
+#   class Integer
+#     MAX: Integer
+#   end
+#
+#   # Optional Sqids gem support
+#   module Sqids
+#     DEFAULT_BLOCKLIST: Array[String]
+#   end
+
 module EncodedId
+  # @rbs InvalidConfigurationError: singleton(StandardError)
   class InvalidConfigurationError < StandardError; end
 
+  # @rbs InvalidAlphabetError: singleton(ArgumentError)
   class InvalidAlphabetError < ArgumentError; end
 
+  # @rbs EncodedIdFormatError: singleton(ArgumentError)
   class EncodedIdFormatError < ArgumentError; end
 
+  # @rbs EncodedIdLengthError: singleton(ArgumentError)
   class EncodedIdLengthError < ArgumentError; end
 
+  # @rbs InvalidInputError: singleton(ArgumentError)
   class InvalidInputError < ArgumentError; end
+
+  # @rbs BlocklistError: singleton(StandardError)
+  class BlocklistError < StandardError; end
+
+  # @rbs SaltError: singleton(ArgumentError)
+  class SaltError < ArgumentError; end
 end

metadata

@@ -1,34 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: encoded_id
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc4
+  version: 1.0.0.rc6
 platform: ruby
 authors:
 - Stephen Ierodiaconou
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-29 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: hashids
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
+date: 2025-11-17 00:00:00.000000000 Z
+dependencies: []
 description: Encode your numerical IDs (eg record primary keys) into obfuscated strings
   that can be used in URLs. The obfuscated strings are reversible, so you can decode
   them back into the original numerical IDs. Supports encoding multiple IDs at once,
   and generating IDs with custom alphabets and separators to make the IDs easier to
-  read or share.
+  read or share. Dependency free.
 email:
 - stevegeek@gmail.com
 executables: []
@@ -36,27 +21,29 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
-- Gemfile
 - LICENSE.txt
 - README.md
-- Rakefile
-- Steepfile
+- context/encoded_id.md
 - lib/encoded_id.rb
 - lib/encoded_id/alphabet.rb
+- lib/encoded_id/blocklist.rb
+- lib/encoded_id/encoders/base.rb
+- lib/encoded_id/encoders/hash_id.rb
+- lib/encoded_id/encoders/hash_id_consistent_shuffle.rb
+- lib/encoded_id/encoders/hash_id_ordinal_alphabet_separator_guards.rb
+- lib/encoded_id/encoders/hash_id_salt.rb
+- lib/encoded_id/encoders/my_sqids.rb
+- lib/encoded_id/encoders/sqids.rb
 - lib/encoded_id/hex_representation.rb
 - lib/encoded_id/reversible_id.rb
 - lib/encoded_id/version.rb
-- rbs_collection.yaml
-- sig/encoded_id.rbs
-- sig/hash_ids.rbs
 homepage: https://github.com/stevegeek/encoded_id
 licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/stevegeek/encoded_id
   source_code_uri: https://github.com/stevegeek/encoded_id
-  changelog_uri: https://github.com/stevegeek/encoded_id/blob/master/CHANGELOG.md
-post_install_message:
+  changelog_uri: https://github.com/stevegeek/encoded_id/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -64,16 +51,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: EncodedId is a gem for creating reversible obfuscated IDs from numerical
-  IDs. It uses Hash IDs under the hood.
+  IDs. It uses an implementation of Hash IDs under the hood.
 test_files: []

data/Gemfile

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-source "https://rubygems.org"
-
-# Specify your gem's dependencies in encoded_id.gemspec
-gemspec
-
-gem "rake", "~> 13.0"
-
-gem "minitest"
-
-gem "standard", "~> 1.30"
-
-gem "rbs"
-
-gem "steep"
-
-gem "simplecov"
-
-gem "benchmark-ips"
-
-gem "benchmark-memory"
-
-gem "fuzzbert"

data/Rakefile

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-require "rake/testtask"
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/test_*.rb"]
-end
-
-require "standard/rake"
-
-task default: %i[test standard]

data/Steepfile

@@ -1,5 +0,0 @@
-target :lib do
-  signature "sig"
-
-  check "lib"
-end

data/rbs_collection.yaml

@@ -1,24 +0,0 @@
-# Download sources
-sources:
-  - name: ruby/gem_rbs_collection
-    remote: https://github.com/ruby/gem_rbs_collection.git
-    revision: main
-    repo_dir: gems
-
-# A directory to install the downloaded RBSs
-path: .gem_rbs_collection
-
-gems:
-  # Skip loading rbs gem's RBS.
-  # It's unnecessary if you don't use rbs as a library.
-  - name: rbs
-    ignore: true
-  - name: rake
-    ignore: true
-  - name: minitest
-    ignore: true
-  - name: standard
-    ignore: true
-  - name: steep
-    ignore: true
-

data/sig/encoded_id.rbs

@@ -1,117 +0,0 @@
-module EncodedId
-  VERSION: ::String
-
-  InvalidConfigurationError: ::StandardError
-  EncodedIdFormatError: ::ArgumentError
-  EncodedIdLengthError: ::ArgumentError
-  InvalidAlphabetError: ::ArgumentError
-  InvalidInputError: ::ArgumentError
-
-  class Alphabet
-    MIN_UNIQUE_CHARACTERS: ::Integer
-
-    def initialize: (String | ::Array[::String] characters, ::Hash[::String, ::String] ?equivalences) -> void
-
-    attr_reader unique_characters: ::Array[::String]
-    attr_reader characters: String
-    attr_reader equivalences: ::Hash[::String, ::String] | nil
-
-    def include?: (::String character) -> bool
-
-    def self.modified_crockford: () -> Alphabet
-
-    private
-
-    def valid_input_characters?: ((::Array[::String] | ::String) characters) -> bool
-
-    def valid_characters?: -> bool
-
-    def sufficient_characters?: -> bool
-
-    def unique_character_alphabet: ((::Array[::String] | ::String) characters) -> ::Array[::String]
-
-    def valid_equivalences?: (::Hash[::String, ::String] ?equivalences) -> bool
-
-    def raise_character_set_too_small!: -> untyped
-
-    def raise_invalid_alphabet!: -> void
-
-    def raise_invalid_equivalences!: -> void
-  end
-
-  type encodeableValue = ::Array[::String | ::Integer] | ::String | ::Integer
-  type encodeableHexValue = ::Array[::String] | ::String
-
-  class HexRepresentation
-    def initialize: (::Integer) -> void
-    def hex_as_integers: (encodeableHexValue) -> ::Array[::Integer]
-    def integers_as_hex: (::Array[::Integer]) -> ::Array[::String]
-
-    private
-
-    def validate_hex_digit_encoding_group_size: (::Integer) -> ::Integer
-    def integer_representation: (encodeableHexValue) -> ::Array[::Integer]
-    def integers_to_hex_strings: (::Array[::Integer]) -> ::Array[::String]
-    def hex_string_as_integer_representation: (::String) -> ::Array[::Integer]
-    def hex_string_separator: -> ::Integer
-    def remove_non_hex_characters: (::String) -> ::String
-    def convert_to_integer_groups: (::String) -> ::Array[::Integer]
-  end
-
-  class ReversibleId
-    def initialize: (salt: ::String, ?length: ::Integer, ?split_at: ::Integer, ?split_with: ::String, ?alphabet: Alphabet, ?hex_digit_encoding_group_size: ::Integer, ?max_length: ::Integer, ?max_inputs_per_id: ::Integer) -> void
-
-    # Encode the input values into a hash
-    def encode: (encodeableValue values) -> ::String
-
-    # Encode hex strings into a hash
-    def encode_hex: (encodeableHexValue hexs) -> ::String
-
-    # Decode the hash to original array
-    def decode: (::String str) -> ::Array[::Integer]
-
-    # Decode hex strings from a hash
-    def decode_hex: (::String str) -> ::Array[::String]
-
-    private
-
-    @encoded_id_generator: ::Hashids
-    @split_regex: ::Regexp
-    @hex_string_separator: ::Integer
-
-    attr_reader salt: ::String
-
-    attr_reader length: ::Integer
-    attr_reader max_length: ::Integer | nil
-
-    attr_reader alphabet: Alphabet
-
-    attr_reader split_at: ::Integer | nil
-    attr_reader split_with: ::String
-
-    attr_reader hex_represention_encoder: HexRepresentation
-
-    def validate_alphabet: (Alphabet) -> Alphabet
-    def validate_salt: (::String) -> ::String
-    def validate_length: (::Integer) -> ::Integer
-    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_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 split_regex: () -> ::Regexp
-
-    def humanize_length: (::String hash) -> ::String
-
-    def convert_to_hash: (::String str, bool) -> ::String
-
-    def map_equivalent_characters: (::String str) -> ::String
-    def max_length_exceeded?: (::String str) -> bool
-  end
-end

data/sig/hash_ids.rbs

@@ -1,70 +0,0 @@
-class Hashids
-  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
-
-  attr_reader alphabet: ::String
-
-  attr_reader seps: ::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: (untyped alphabet, untyped salt) -> 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
-