Base32 String Encoding & Decoding in Ruby Programming Language

Discover the tricks of Base32 encoding in Ruby. Learn whether or not Ruby supports Base32 encoding natively, discover the best Base32 libraries, and dive into creating your own Base32 implementation. A must read for all Ruby programmers.

What is Ruby?

Ruby is a dynamic, open-source programming language that focuses on simplicity and productivity. It was developed in the mid-1990s by Yukihiro “Matz” Matsumoto in Japan. Ruby has an elegant syntax that is natural to read and easy to write. It is used in a wide range of fields, but is particularly popular for web development.

Ruby is known for its flexibility, as it allows its users to freely alter its parts. Essential parts of Ruby can be removed or redefined, at will. Existing parts can be added upon. Ruby tries not to restrict the coder.

Here are some keypoints about the Ruby programming language:

Focus on Developer Productivity: Designed to be easy to read and enjoyable for programmers.
Object-Oriented: Structures code around objects for better organization and reusability.
Dynamically Typed: Allows you more flexibility during development, but requires additional testing.
Large & Active Community: Benefits from a vast community for support and libraries (RubyGems).
Popular for Web Development: Frequently combined with the Rails framework for quick web application development.
General Purpose: Can also be used for scripting, data analysis, and other tasks.

Does Ruby Natively Support Base32?

Now, let’s talk about Base32 and its support in Ruby. Base32 is a notation for encoding arbitrary byte data using a restricted set of symbols that can be conveniently used by humans and processed by computers.

While Ruby is a powerful language, it does not natively support Base32 encoding or decoding. This means that the standard Ruby library does not include functions for encoding data in Base32 or decoding Base32 data.

However, this does not mean that you cannot work with Base32 in Ruby. There are several third-party libraries available that provide Base32 functionality. These libraries offer methods for encoding and decoding Base32 data, and can be easily integrated into your Ruby projects.

Base32 Libraries for Ruby

So, while Ruby does not natively support Base32, the functionality can be easily added using external libraries. This is one of the strengths of Ruby – if the language itself doesn’t provide what you need, you can almost certainly find a library that does.

When it comes to working with Base32 in Ruby, there are several libraries that stand out due to their functionality and ease of use. Here are some of the best ones:

stesla/base32: This library provides Base32 encoding and decoding. It is a Ruby extension for encoding and decoding in Base32 per RFC 3548. You can install it with the following command: gem install --remote base32. It also includes a simple example of how to use the library for encoding and decoding.
base32-alphabets: This library allows you to encode and decode numbers in 5-bit groups (2^5=32) with Kai, Crockford or Electrologica notation/alphabet.
ydakuka/digest-base32: It is currently not available on GitHub, but the search will throw it up.

These libraries make it easy to work with Base32 in Ruby, even though the language does not natively support it. They are all available on GitHub, so you can review their source code and documentation to decide which one is the best fit for your project.

Own Base32 Implementation

For scenarios where using external libraries is not feasible or when you want to have complete control over the encoding process, creating your own Base32 encoder is a viable option.

In this section, we will first introduce you to the basics of Base32, and then show you how to get started implementing your own Base32 encoder and decoder.

Base32 Characters

In order to understand exactly how Base32 works, we first need to familiarise ourselves with its character set, which is essential for its implementation. The Base32 character set consists of 32 characters, which typically include:

Uppercase letters A to Z (26 characters)
Digits 2 to 7 (6 characters)

Unlike Base64, Base32 does not include special characters that might cause issues in certain contexts, making it suitable for use in URLs and filenames without the need for URL encoding.

How Base32 works?

Here are the steps to follow when encoding Base32:

Divide the binary data into 40-bit (8-character) chunks. If the data’s length is not a multiple of 40 bits, you will need to handle padding.
Convert each 40-bit chunk into its equivalent Base32 representation by mapping each 5-bit segment to its corresponding character from the character set.
Append padding characters as necessary to ensure that the output is a multiple of 8 characters.
The result is a Base32-encoded string, ready for transmission, storage, or further use.

During decoding, we have to follow the same sequence of operations, but in the opposite order.

Language Independent Base32 Implementation (Pseudo Code)

Now we will demonstrate the Base32 encoding implementation using pseudo code.

function base32_encode(data):
    // Define the Base32 alphabet
    alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'
 
    // Convert the input data to binary
    binary_data = ''.join(format(ord(char), '08b') for char in data)
 
    // Pad the binary data with zeros if necessary
    while len(binary_data) % 5 != 0:
        binary_data += '0'
 
    // Split the binary data into 5-bit chunks
    chunks = [binary_data[i:i+5] for i in range(0, len(binary_data), 5)]
 
    // Convert each 5-bit chunk to its corresponding Base32 character
    encoded_data = ''.join([alphabet[int(chunk, 2)] for chunk in chunks])
 
    return encoded_data

This implementation accepts a string of data as input and returns the Base32-encoded string. It works by converting the incoming data to binary and then dividing it into 5-bit pieces. Each 5-bit chunk is then transformed to a Base32 character using the Base32 alphabet. Finally, a Base32-encoded string is returned.

This implementation assumes that the incoming data is a string of characters. If the input data is in a different format, such as a byte array, the implementation must be adjusted accordingly.

Finally, let’s look at the decoding process:

function base32_decode(encoded_data):
    // Define the Base32 alphabet
    alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'
 
    // Convert the encoded data to binary
    binary_data = ''.join([format(alphabet.index(char), '05b') for char in encoded_data])
 
    // Pad the binary data with zeros if necessary
    while len(binary_data) % 8 != 0:
        binary_data += '0'
 
    // Split the binary data into 8-bit chunks
    chunks = [binary_data[i:i+8] for i in range(0, len(binary_data), 8)]
 
    // Convert each 8-bit chunk to its corresponding ASCII character
    decoded_data = ''.join([chr(int(chunk, 2)) for chunk in chunks])
 
    return decoded_data