Binaries for ffi-libarchive

Purpose

Contains pre-compiled and install-time-compiled binaries for ffi-libarchive.

Installation

Add this line to your application’s Gemfile:

gem "ffi-libarchive-binary"

And then execute:

$ bundle install

Or install it yourself as:

$ gem install ffi-libarchive-binary

Usage

Require the gem and use calls from ffi-libarchive.

require "ffi-libarchive-binary"

path = File.expand_path('file.pkg', __dir__)
flags = Archive::EXTRACT_PERM
reader = Archive::Reader.open_filename(path)

reader.each_entry do |entry|
  reader.extract(entry, flags.to_i)
end

reader.close

Development

We are following Sandi Metz’s Rules for this gem, you can read the description of the rules here. All new code should follow these rules. If you make changes in a pre-existing file that violates these rules you should fix the violations as part of your contribution.

Releasing

The gem uses an automated release workflow that handles version bumping and publishing to RubyGems using the gem-release gem.

Release workflow

The release process is managed through GitHub Actions workflow dispatch:

1. Navigate to the Actions tab in the GitHub repository

2. Select the "release" workflow

3. Click "Run workflow"

4. Choose the version bump type:

   • x.y.z - Set a specific version (e.g., 1.2.3)

   • major - Bump major version (e.g., 0.4.2 → 1.0.0)

   • minor - Bump minor version (e.g., 0.4.2 → 0.5.0)

   • patch - Bump patch version (e.g., 0.4.2 → 0.4.3)

   • skip - Publish current version without bumping (useful for republishing)

The workflow will:

1. Install the gem-release gem

2. Bump the version in [lib/ffi-libarchive-binary/version.rb](lib/ffi-libarchive-binary/version.rb:4) (if not skip)

3. Create a git commit with the version change

4. Create a git tag (vX.Y.Z)

5. Push changes to the repository

6. Build platform-specific gems for all supported platforms

7. Publish all gems to RubyGems

Note	The workflow uses the gem-release gem which provides a reliable and well-tested version bumping mechanism used across many Ruby projects.

Manual release

For manual releases, you can use the gem-release gem directly:

# Install gem-release if not already installed
gem install gem-release

# Bump patch version (0.4.2 -> 0.4.3) and create tag
gem bump --version patch --tag --push

# Bump minor version (0.4.2 -> 0.5.0) and create tag
gem bump --version minor --tag --push

# Bump major version (0.4.2 -> 1.0.0) and create tag
gem bump --version major --tag --push

# Set specific version and create tag
gem bump --version 1.2.3 --tag --push

Once the tag is pushed, the release workflow will automatically trigger and build the gems for all platforms.

Platform configuration

The gem uses centralized platform configuration in [.github/platforms.json](.github/platforms.json:1) as the single source of truth for all platform-specific settings.

Platform metadata

Each platform entry includes:

• platform - Platform identifier for gem naming (e.g., x86_64-linux)

• os - GitHub Actions runner to use for building

• ruby - Ruby version to use

• description - Human-readable description

• build - Whether to build a gem for this platform

• test - Whether to test this platform

• test_os - Array of OS runners to test on (if applicable)

• cross_compile - Whether this requires cross-compilation

• notes - Additional information

Listing platforms

Use the provided script to list all configured platforms:

# List all platforms
bin/list-platforms

# List only build platforms
bin/list-platforms --build

# List only test platforms
bin/list-platforms --test

Adding or removing platforms

To add or modify platform support:

1. Edit [.github/platforms.json](.github/platforms.json:1)

2. Update the platform entry with appropriate settings

3. Set "build": true to enable building for that platform

4. Set "test": true to enable testing for that platform

5. Update the platform arrays (build_platforms and test_platforms) at the bottom of the file

Note	When adding a new platform, ensure the GitHub Actions runner is available and the build toolchain is properly configured.

Windows ARM64 support

Windows ARM64 (arm64-mingw-ucrt) builds pre-compiled gems for Windows on ARM64 devices (e.g., Surface Pro X, Windows 11 ARM). This platform uses the GitHub Actions windows-11-arm runner.

Contributing

First, thank you for contributing! We love pull requests from everyone. By participating in this project, you hereby grant Ribose Inc. the right to grant or transfer an unlimited number of non exclusive licenses or sub-licenses to third parties, under the copyright covering the contribution to use the contribution by all means.

Here are a few technical guidelines to follow:

1. Open an issue to discuss a new feature.

2. Write tests to support your new feature.

3. Make sure the entire test suite passes locally and on CI.

4. Open a Pull Request.

5. Squash your commits after receiving feedback.

6. Party!

License

This gem is distributed with a BSD 3-Clause license.

This gem is developed, maintained and funded by Ribose Inc.

Supported platforms

The following platforms are officially tested and supported:

Platform	Architecture	Ruby Versions	Status
Windows 2022	x86_64	3.1+	✅ Supported
Windows 2025	x86_64	3.1+	✅ Supported
Windows 11 ARM	ARM64	3.4+	✅ Supported
macOS 15	ARM64 (Apple Silicon)	3.1+	✅ Supported
macOS 15 Large	x86_64 (Intel)	3.1+	✅ Supported
macOS 26	ARM64 (Apple Silicon)	3.1+	✅ Supported
Ubuntu 24.04	x86_64 (glibc)	3.1+	✅ Supported
Ubuntu 22.04	x86_64 (glibc)	3.1+	✅ Supported
Alpine Linux	x86_64 (musl)	3.1+	✅ Supported
Ubuntu 24.04	ARM64 (glibc)	3.1+	✅ Supported
Ubuntu 22.04	ARM64 (glibc)	3.1+	✅ Supported
Alpine Linux	ARM64 (musl)	3.1+	✅ Supported

Note	The gem provides pre-compiled binaries for 11 platforms. Separate binaries are provided for glibc-based (gnu) and musl-based Linux distributions to ensure compatibility.

OpenSSL compiler target strategy

The gem explicitly sets OpenSSL compiler targets to ensure correct assembly code generation:

Platform	Compiler Target	Reason
Windows x64	mingw64	Explicit x86_64 assembly selection
Linux x86_64 (gnu/musl)	Auto-detect	Native toolchain works correctly
Linux ARM64 (gnu/musl)	Auto-detect	Native toolchain works correctly
macOS ARM64	Auto-detect	Native toolchain works correctly
macOS x64	Auto-detect	Native toolchain works correctly

Note	Windows platforms require explicit compiler targets because OpenSSL’s auto-detection does not reliably select the correct target on Windows. Linux musl and glibc variants use the same OpenSSL configuration with auto-detection, as the toolchain correctly identifies the target.

Build requirements

Windows

Windows x64

For building from source on Windows x64, you need:

• Ruby 2.7 or higher with DevKit

• MinGW-w64 x86_64 toolchain

• MSYS2 (recommended) or equivalent Unix-like environment