multibases 0.1.0

data/lib/multibases/bare.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'multibases/version'
+require 'multibases/registry'
+
+module Multibases
+  class Error < StandardError; end
+
+  class NoEngine < Error
+    def initialize(encoding)
+      super(
+        "There is no engine registered to encode or decode #{encoding}.\n" \
+          'Either pass it as an argument, or use Multibases.implement to ' \
+          'register it globally.'
+      )
+    end
+  end
+
+  Encoded = Struct.new(:code, :encoding, :length, :data) do
+    ##
+    # Packs the data and the code into an encoded string
+    #
+    # @return [EncodedByteArray]
+    #
+    def pack
+      data.unshift(code.ord)
+      data
+    end
+
+    ##
+    # Decodes the data and returns a DecodedByteArray
+    #
+    # @return [DecodedByteArray]
+    #
+    def decode(engine = Multibases.engine(encoding))
+      raise NoEngine, encoding unless engine
+
+      engine.decode(data)
+    end
+  end
+
+  class Identity
+    def initialize(*_); end
+
+    def encode(data)
+      EncodedByteArray.new(data.is_a?(Array) ? data : data.bytes)
+    end
+
+    def decode(data)
+      DecodedByteArray.new(data.is_a?(Array) ? data : data.bytes)
+    end
+  end
+
+  implement 'identity', "\x00", Identity
+  implement 'base1', '1'
+  implement 'base2', '0'
+  implement 'base8', '7'
+  implement 'base10', '9'
+  implement 'base16', 'f'
+  implement 'base16upper', 'F'
+  implement 'base32hex', 'v'
+  implement 'base32hexupper', 'V'
+  implement 'base32hexpad', 't'
+  implement 'base32hexpadupper', 'T'
+  implement 'base32', 'b'
+  implement 'base32upper', 'B'
+  implement 'base32pad', 'c'
+  implement 'base32padupper', 'c'
+  implement 'base32z', 'h'
+  implement 'base58flickr', 'Z'
+  implement 'base58btc', 'z'
+  implement 'base64', 'm'
+  implement 'base64pad', 'M'
+  implement 'base64url', 'u'
+  implement 'base64urlpad', 'U'
+
+  module_function
+
+  def encode(encoding, data, engine = Multibases.engine(encoding))
+    raise NoEngine, encoding unless engine
+
+    encoded_data = engine.encode(data)
+
+    Encoded.new(
+      Multibases.code(encoding),
+      encoding,
+      encoded_data.length,
+      encoded_data
+    )
+  end
+
+  def unpack(decorated)
+    decorated = decorated.pack('c*') if decorated.is_a?(Array)
+    code = decorated[0]
+    encoded_data = decorated[1..-1]
+
+    Encoded.new(
+      code,
+      Multibases.encoding(code),
+      encoded_data.length,
+      EncodedByteArray.new(encoded_data.bytes)
+    )
+  end
+
+  def decorate(encoding, encoded = nil)
+    return encoding.pack if encoding.is_a?(Encoded)
+
+    encoded = encoded.bytes unless encoded.is_a?(Array)
+
+    Encoded.new(
+      Multibases.code(encoding),
+      encoding,
+      encoded.length,
+      EncodedByteArray.new(encoded)
+    ).pack
+  end
+
+  def pack(*args)
+    encoded = Multibases.encode(*args)
+    encoded.pack
+  end
+
+  def decode(data, *args)
+    encoded = Multibases.unpack(data)
+    encoded.decode(*args)
+  end
+
+  def encoding(code)
+    fetch_by!(code: code).encoding
+  end
+
+  def code(encoding)
+    fetch_by!(encoding: encoding).code
+  end
+
+  def engine(lookup)
+    registration = find_by(code: lookup, encoding: lookup)
+    raise NoEngine, lookup unless registration
+
+    registration.engine
+  end
+end

data/lib/multibases/base16.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative './byte_array'
+require_relative './ord_table'
+
+module Multibases
+  class Base16
+    def inspect
+      '[Multibases::Base16 ' \
+        "alphabet=\"#{@table.alphabet}\"" \
+        "#{@table.strict? ? ' strict' : ''}" \
+      ']'
+    end
+
+    # RFC 4648 implementation
+    def self.encode(plain)
+      plain = plain.map(&:chr).join if plain.is_a?(Array)
+
+      # plain.each_byte.map do |byte| byte.to_s(16) end.join
+      EncodedByteArray.new(plain.unpack1('H*').bytes)
+    end
+
+    def self.decode(packed)
+      packed = packed.map(&:chr).join if packed.is_a?(Array)
+
+      # packed.scan(/../).map { |x| x.hex.chr }.join
+      DecodedByteArray.new(Array(String(packed)).pack('H*').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 < 16 || ords.length > 17
+          # Allow 17 for stale padding that does nothing
+          raise ArgumentError,
+                'Expected alphabet to contain 16 exactly. Actual: ' \
+                "#{ords.length} characters."
+        end
+
+        super ords, **opts
+      end
+    end
+
+    def initialize(alphabet, strict: false)
+      @table = Table.from(alphabet, strict: strict)
+    end
+
+    def encode(plain)
+      encoded = Multibases::Base16.encode(plain)
+      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::Base16.decode(encoded)
+    end
+
+    def default?
+      eql?(Default)
+    end
+
+    def eql?(other)
+      other.is_a?(Base16) && other.instance_variable_get(:@table) == @table
+    end
+
+    alias == eql?
+
+    def decodable?(encoded)
+      (encoded.uniq - @table.tr_ords).length.zero?
+    end
+
+    def table_ords(force_strict: nil)
+      @table.tr_ords(force_strict: force_strict)
+    end
+
+    Default = Base16.new('0123456789abcdef')
+  end
+end

data/lib/multibases/base2.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative './byte_array'
+require_relative './ord_table'
+
+module Multibases
+  class Base2
+    def inspect
+      "[Multibases::Base2 alphabet=\"#{@table.alphabet}\"]"
+    end
+
+    def self.encode(plain)
+      plain = plain.map(&:chr).join if plain.is_a?(Array)
+      EncodedByteArray.new(plain.unpack1('B*').bytes)
+    end
+
+    def self.decode(packed)
+      packed = packed.map(&:chr).join if packed.is_a?(Array)
+      # Pack only works on an array with a single bit string
+      DecodedByteArray.new(Array(String(packed)).pack('B*').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 != 2
+          raise ArgumentError,
+                'Expected chars to contain 2 exactly. Actual: ' \
+                "#{ords.length} characters."
+        end
+
+        super ords, **opts
+      end
+    end
+
+    def initialize(alphabet, strict: false)
+      @table = Table.from(alphabet, strict: strict)
+    end
+
+    def encode(plain)
+      encoded = Multibases::Base2.encode(plain)
+      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::Base2.decode(encoded)
+    end
+
+    def default?
+      eql?(Default)
+    end
+
+    def eql?(other)
+      other.is_a?(Base2) && other.instance_variable_get(:@table) == @table
+    end
+
+    alias == eql?
+
+    def decodable?(encoded)
+      (encoded.uniq - @table.tr_ords).length.zero?
+    end
+
+    def table_ords(force_strict: false)
+      @table.tr_ords(force_strict: force_strict)
+    end
+
+    Default = Base2.new('01')
+  end
+end

data/lib/multibases/base32.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative './byte_array'
+require_relative './ord_table'
+
+module Multibases
+  # RFC 3548
+  class Base32
+    def inspect
+      '[Multibases::Base32 ' \
+        "alphabet=\"#{@table.chars.join}\"" \
+        "#{@table.strict? ? ' strict' : ''}" \
+      ']'
+    end
+
+    def self.encode(plain)
+      Default.encode(plain)
+    end
+
+    def self.decode(plain)
+      Default.decode(plain)
+    end
+
+    class Table < IndexedOrdTable
+      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 < 32 || ords.length > 33
+          raise ArgumentError,
+                'Expected alphabet to contain 32 characters or 32 + 1 ' \
+                "padding character. Actual: #{ords.length} characters"
+        end
+
+        padder = nil
+        *ords, padder = ords if ords.length == 33
+
+        super(ords, padder: padder, **opts)
+      end
+    end
+
+    class Chunk
+      def initialize(bytes, table)
+        @bytes = bytes
+        @table = table
+      end
+
+      def decode
+        bytes = @bytes.take_while { |c| c != @table.padder }
+
+        n = (bytes.length * 5.0 / 8.0).floor
+        p = bytes.length < 8 ? 5 - (n * 8) % 5 : 0
+
+        c = bytes.inject(0) do |m, o|
+          i = @table.index(o)
+          raise ArgumentError, "Invalid character '#{o.chr}'" if i.nil?
+
+          (m << 5) + i
+        end >> p
+
+        (0..(n - 1)).to_a.reverse.collect { |i| ((c >> i * 8) & 0xff) }
+      end
+
+      def encode
+        n = (@bytes.length * 8.0 / 5.0).ceil
+        p = n < 8 ? 5 - (@bytes.length * 8) % 5 : 0
+        c = @bytes.inject(0) { |m, o| (m << 8) + o } << p
+
+        output = (0..(n - 1)).to_a.reverse.collect do |i|
+          @table.ord_at((c >> i * 5) & 0x1f)
+        end
+        @table.padder ? output + Array.new((8 - n), @table.padder) : output
+      end
+    end
+
+    def initialize(alphabet, strict: false)
+      @table = Table.from(alphabet, strict: strict)
+    end
+
+    def encode(plain)
+      return EncodedByteArray::EMPTY if plain.empty?
+
+      EncodedByteArray.new(chunks(plain, 5).collect(&:encode).flatten)
+    end
+
+    def decode(encoded)
+      return DecodedByteArray::EMPTY if encoded.empty?
+
+      DecodedByteArray.new(chunks(encoded, 8).collect(&:decode).flatten)
+    end
+
+    private
+
+    def chunks(whole, size)
+      whole = whole.bytes unless whole.is_a?(Array)
+
+      whole.each_slice(size).map do |slice|
+        ::Multibases::Base32::Chunk.new(slice, @table)
+      end
+    end
+
+    Default = Base32.new('abcdefghijklmnopqrstuvwxyz234567=')
+  end
+end