multibases 0.1.0

data/lib/multibases/base64.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Multibases
+  class Base64
+    def inspect
+      '[Multibases::Base64 ' \
+        "alphabet=\"#{@table.alphabet}\"" \
+        "#{@table.padder.nil? ? '' : ' pad="' + @table.padder.chr + '"'}" \
+      ']'
+    end
+
+    # RFC 4648 implementation
+    def self.encode(plain)
+      plain = plain.map(&:chr).join if plain.is_a?(Array)
+
+      # Base64.strict_encode(plain)
+      EncodedByteArray.new(Array(String(plain)).pack('m0').bytes)
+    end
+
+    def self.decode(packed)
+      packed = packed.map(&:chr).join if packed.is_a?(Array)
+      # Base64.strict_decode64("m").first
+      # Don't use m0, as that requires padderding _always_
+      DecodedByteArray.new(packed.unpack1('m').bytes)
+    end
+
+    class Table < OrdTable
+      def self.from(alphabet, **opts)
+        alphabet = alphabet.bytes if alphabet.respond_to?(:bytes)
+        alphabet.map!(&:ord)
+
+        new(alphabet, **opts)
+      end
+
+      def initialize(ords, **opts)
+        ords = ords.uniq
+
+        if ords.length < 64 || ords.length > 65
+          raise ArgumentError,
+                'Expected alphabet to contain 64 characters or 65 + 1 ' \
+                "padding character. Actual: #{ords.length} characters"
+        end
+
+        padder = nil
+        *ords, padder = ords if ords.length == 65
+
+        super(ords, padder: padder, **opts)
+      end
+    end
+
+    def initialize(alphabet, strict: false)
+      @table = Table.from(alphabet, strict: strict)
+    end
+
+    def encode(plain)
+      return EncodedByteArray::EMPTY if plain.empty?
+
+      encoded = Multibases::Base64.encode(plain)
+      encoded.chomp!(Default.table_padder) unless @table.padder
+      return encoded if default?
+
+      encoded.transcode(
+        Default.table_ords(force_strict: @table.strict?),
+        table_ords
+      )
+    end
+
+    def decode(encoded)
+      return DecodedByteArray::EMPTY if encoded.empty?
+
+      unless encoded.is_a?(Array)
+        encoded = encoded.force_encoding(Encoding::ASCII_8BIT).bytes
+      end
+
+      unless decodable?(encoded)
+        raise ArgumentError, "'#{encoded}' contains unknown characters'"
+      end
+
+      unless default?
+        encoded = ByteArray.new(encoded).transcode(
+          table_ords,
+          Default.table_ords(force_strict: @table.strict?)
+        )
+      end
+
+      Multibases::Base64.decode(encoded)
+    end
+
+    def default?
+      eql?(Default)
+    end
+
+    def eql?(other)
+      other.is_a?(Base64) && other.instance_variable_get(:@table) == @table
+    end
+
+    alias == eql?
+
+    def decodable?(encoded)
+      (encoded.uniq - table_ords).length.zero?
+    end
+
+    def table_ords(force_strict: nil)
+      @table.tr_ords(force_strict: force_strict)
+    end
+
+    def table_padder
+      @table.padder
+    end
+
+    # rubocop:disable Metrics/LineLength
+    Default = Base64.new('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=')
+    UrlSafe = Base64.new('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=')
+    # rubocop:enable Metrics/LineLength
+  end
+end

data/lib/multibases/base_x.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative './byte_array'
+require_relative './ord_table'
+
+module Multibases
+  class BaseX
+    def inspect
+      "[Multibases::Base#{@table.base} " \
+        "alphabet=\"#{@table.alphabet}\"" \
+        "#{@table.strict? ? ' strict' : ''}" \
+      ']'
+    end
+
+    class Table < IndexedOrdTable
+      def self.from(alphabet, **opts)
+        raise ArgumentError, 'Alphabet too long' if alphabet.length >= 255
+
+        alphabet = alphabet.bytes if alphabet.respond_to?(:bytes)
+        alphabet.map!(&:ord)
+
+        new(alphabet, **opts)
+      end
+    end
+
+    def initialize(alphabet, strict: false)
+      @table = Table.from(alphabet, strict: strict)
+    end
+
+    ##
+    # Encode +plain+ to an encoded string
+    #
+    # @param plain [String, Array] plain string or byte array
+    # @return [EncodedByteArray] encoded byte array
+    #
+    def encode(plain)
+      return EncodedByteArray::EMPTY if plain.empty?
+
+      plain = plain.bytes unless plain.is_a?(Array)
+      expected_length = @table.encoded_length(plain)
+
+      # Find leading zeroes
+      zeroes_count = [
+        0,
+        plain.find_index { |b| b.ord != 0 } || plain.length
+      ].max
+      plain = plain.drop(zeroes_count)
+      expected_length = @table.encoded_length(plain) unless @table.pad_to_power?
+
+      # Encode number into destination base as byte array
+      output = []
+      plain_big_number = plain.inject { |a, b| (a << 8) + b.ord }
+
+      while plain_big_number >= @table.base
+        mod = plain_big_number % @table.base
+        output.unshift(@table.ord_at(mod))
+        plain_big_number = (plain_big_number - mod) / @table.base
+      end
+
+      output.unshift(@table.ord_at(plain_big_number))
+
+      # Prepend the leading zeroes
+      @table.encoded_zeroes_length(zeroes_count).times do
+        output.unshift(@table.zero)
+      end
+
+      # Padding at the front (to match expected length). Because of the
+      if @table.pad_to_power?
+        (expected_length - output.length).times do
+          output.unshift(@table.zero)
+        end
+      end
+
+      EncodedByteArray.new(output)
+    end
+
+    ##
+    # Decode +encoded+ to a byte array
+    #
+    # @param encoded [String, Array, ByteArray] encoded string or byte array
+    # @return [DecodedByteArray] decoded byte array
+    #
+    def decode(encoded)
+      return DecodedByteArray::EMPTY if encoded.empty?
+
+      unless encoded.is_a?(Array)
+        encoded = encoded.force_encoding(Encoding::ASCII_8BIT).bytes
+      end
+
+      unless decodable?(encoded)
+        raise ArgumentError, "'#{encoded}' contains unknown characters'"
+      end
+
+      # Find leading zeroes
+      zeroes_count = [
+        0,
+        encoded.find_index { |b| b.ord != @table.zero } || encoded.length
+      ].max
+      encoded = encoded.drop(zeroes_count)
+
+      # Decode number from encoding base to base 10
+      encoded_big_number = 0
+
+      encoded.reverse.each_with_index do |char, i|
+        table_i = @table.index(char)
+        encoded_big_number += @table.base**i * table_i
+      end
+
+      # Build the output by reversing the bytes. Because the encoding is "lost"
+      # the result might not be correct just yet. This is up to the caller to
+      # fix. The algorithm **can not know** what the encoding was.
+      output = 1.upto((Math.log2(encoded_big_number) / 8).ceil).collect do
+        encoded_big_number, character_byte = encoded_big_number.divmod 256
+        character_byte
+      end.reverse
+
+      # Prepend the leading zeroes
+      @table.decoded_zeroes_length(zeroes_count).times do
+        output.unshift(0x00)
+      end
+
+      DecodedByteArray.new(output)
+    end
+
+    def decodable?(encoded)
+      (encoded.uniq - @table.tr_ords).length.zero?
+    end
+  end
+end

data/lib/multibases/byte_array.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Multibases
+  class ByteArray < DelegateClass(Array)
+    def hash
+      __getobj__.hash
+    end
+
+    def eql?(other)
+      other.to_s.eql?(to_s)
+    end
+
+    def to_arr
+      __getobj__.dup
+    end
+
+    def is_a?(klazz)
+      super || __getobj__.is_a?(klazz)
+    end
+
+    def transcode(from, to)
+      from = from.each_with_index.to_h
+      to = Hash[to.each_with_index.to_a.collect(&:reverse)]
+
+      self.class.new(map { |byte| to[from[byte]] })
+    end
+
+    alias to_a to_arr
+    alias kind_of? is_a?
+  end
+
+  class EncodedByteArray < ByteArray
+    def inspect
+      "[Multibases::EncodedByteArray \"#{to_str}\"]"
+    end
+
+    def to_str
+      map(&:chr).join.encode(Encoding::ASCII_8BIT)
+    end
+
+    def chomp!(ord)
+      return self unless ord
+
+      __getobj__.reverse!
+      index = __getobj__.find_index { |el| el != ord }
+      __getobj__.slice!(0, index) unless index.nil?
+      __getobj__.reverse!
+
+      self
+    end
+
+    alias to_s to_str
+  end
+
+  class DecodedByteArray < ByteArray
+    def inspect
+      "[Multibases::DecodedByteArray \"#{to_str}\"]"
+    end
+
+    def to_str(encoding = Encoding::UTF_8)
+      map(&:chr).join.force_encoding(encoding)
+    end
+
+    def force_encoding(*args)
+      to_str(*args)
+    end
+
+    alias to_s to_str
+  end
+
+  EncodedByteArray.const_set(:EMPTY, EncodedByteArray.new([]))
+  DecodedByteArray.const_set(:EMPTY, DecodedByteArray.new([]))
+end

data/lib/multibases/ord_table.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Multibases
+  class OrdTable
+    def initialize(ords, strict:, padder: nil)
+      ords = ords.uniq
+
+      @ords = ords
+      @base = ords.length
+      @padder = padder
+
+      chars = ords.map(&:chr)
+      chars_downcased = chars.map(&:downcase).uniq
+      chars_upcased = chars.map(&:upcase).uniq
+      chars_cased = chars_upcased - chars_downcased
+
+      # Strict means that the algorithm may _not_ treat incorrectly cased
+      # input the same as correctly cased input. In other words, the table is
+      # strict if a character exists that is both upcased and downcased and
+      # therefore has a canonical casing.
+      @strict = strict ||
+                chars_cased.empty? ||
+                chars.length != chars_downcased.length
+
+      @loose_ords = (chars + chars_downcased + chars_upcased).uniq.map(&:ord)
+    end
+
+    def eql?(other)
+      other.is_a?(OrdTable) &&
+        other.alphabet == alphabet &&
+        other.strict? == strict?
+    end
+
+    alias == eql?
+
+    def hash
+      @ords.hash
+    end
+
+    def strict?
+      @strict
+    end
+
+    def tr_ords(force_strict: false)
+      return @ords + [@padder].compact if strict? || force_strict
+
+      @loose_ords + [@padder].compact
+    end
+
+    def alphabet
+      @ords.map(&:chr).join
+    end
+
+    attr_reader :base, :factor, :padder
+  end
+
+  class IndexedOrdTable < OrdTable
+    def initialize(ords, **opts)
+      super(ords, **opts)
+
+      @forward = ords.each_with_index.to_h
+      @backward = Hash[@forward.to_a.collect(&:reverse)]
+      @factor = Math.log(256) / Math.log(base)
+    end
+
+    def zero
+      @backward[0]
+    end
+
+    def index(byte)
+      @forward[byte] || !strict? && (
+        @forward[byte.chr.upcase.ord] ||
+        @forward[byte.chr.downcase.ord]
+      )
+    end
+
+    def ord_at(index)
+      @backward[index]
+    end
+
+    def encoded_length(plain_bytes)
+      (plain_bytes.length.to_f * factor).ceil
+    end
+
+    def decoded_length(encoded_bytes)
+      (encoded_bytes.length / factor).round
+    end
+
+    def encoded_zeroes_length(count)
+      # For power of 2 bases, add "canonical-width"
+      return (factor * count).floor if pad_to_power?
+
+      # For other bases, add a equivalent count to front
+      count
+    end
+
+    def decoded_zeroes_length(count)
+      # For power of 2 bases, add "canonical-width"
+      return (count / factor).round if pad_to_power?
+
+      # For other bases, add a equivalent count to front
+      count
+    end
+
+    def pad_to_power?
+      (Math.log2(base) % 1).zero?
+    end
+  end
+end

data/lib/multibases/registry.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Multibases
+  # rubocop:disable Style/MutableConstant
+  IMPLEMENTATIONS = {}
+  # rubocop:enable Style/MutableConstant
+
+  Registration = Struct.new(:code, :encoding, :engine) do
+    def hash
+      encoding.hash
+    end
+
+    def ==(other)
+      return [encoding, code].include?(other) if other.is_a?(String)
+
+      eql?(other)
+    end
+
+    def eql?(other)
+      other.is_a?(Registration) && other.encoding == encoding
+    end
+  end
+
+  module_function
+
+  def implement(encoding, code, implementation = nil, alphabet = nil)
+    Multibases::IMPLEMENTATIONS[encoding] = Registration.new(
+      code,
+      encoding,
+      implementation&.new(alphabet)
+    )
+  end
+
+  def fetch_by!(code: nil, encoding: nil)
+    return Multibases::IMPLEMENTATIONS.fetch(encoding) if encoding
+
+    Multibases.find_by(code: code).tap do |found|
+      raise KeyError, "No implementation has code #{code}" unless found
+    end
+  end
+
+  def find_by(code: nil, encoding: nil)
+    Multibases::IMPLEMENTATIONS.values.find do |v|
+      v == code || v == encoding
+    end
+  end
+
+  def multibase_version(multibase_semver = nil)
+    return @multibase_version if multibase_semver.nil?
+
+    @multibase_version = multibase_semver
+  end
+end