fluent-tools 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 807b6f8dbd3ccbbb76cbb8420d6093b250e88608a8a90c8fb0eda55f87bbf22c
+  data.tar.gz: 0533e6d8cfd25c021486c0b56931843347adb96fdb6b8ae3ba28021db8596547
+SHA512:
+  metadata.gz: 4a538a4801bfab70efc3635c2f6bc492ff866cac46222291b59fa8893fbfeaef225dc60e64e5503c556d41d12ef1c2e890117704e480b0b69cb971b6df28011a
+  data.tar.gz: bafabd8faabf050e41ce921ea69e9c6a5d3e950c0006ef3c50a1cb1c78112cac68d1ae4f3829c3bf380309ffbf114bdf3e6da10f542780dd1be9bfbbe829db0f

data/exe/fluent-tools

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/fluent_tools'
+
+FluentTools::CLI.start(ARGV)

data/ext/fluent_tools/extconf.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../../installer'
+require_relative '../../lib/fluent_tools/version'
+require 'fileutils'
+
+puts "Installing fluent-tools #{FluentTools::VERSION}..."
+
+# Create installer instance for gem context with version
+installer = FluentToolsInstaller.new(version: FluentTools::VERSION)
+
+# Run installation
+success = installer.install!
+
+# Ensure the bin directory exists and is included in the gem
+bin_dir = File.expand_path('../../bin', __dir__)
+FileUtils.mkdir_p(bin_dir)
+
+# Create dummy Makefile for RubyGems compatibility
+makefile_content = <<~MAKEFILE
+  all:
+  \t@echo 'Binary already installed'
+
+  install:
+  \t@echo 'Binary already installed'
+
+  clean:
+  \t@echo 'Nothing to clean'
+MAKEFILE
+
+File.write('Makefile', makefile_content)
+
+unless success
+  puts '❌ Installation failed - binary could not be installed'
+  puts 'This may still work if the binary becomes available at runtime'
+  puts 'or if you build it manually using: rake build_rust'
+  exit 1
+end
+
+puts '✅ Extension configuration complete'

data/installer.rb

@@ -0,0 +1,212 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Installer for fluent-rust-tools gem
+# Used by extconf.rb during gem installation
+
+require 'net/http'
+require 'uri'
+require 'fileutils'
+require 'rbconfig'
+require 'json'
+require 'pathname'
+require_relative 'lib/fluent_tools/utils'
+
+# Installer for fluent-rust-tools gem
+# Downloads pre-built binaries or builds from source
+class FluentToolsInstaller
+  include FluentTools::Utils::Logger
+
+  def initialize(version: nil)
+    @version = version
+  end
+
+  # Main installation method
+  def install!
+    log_info "🚀 Installing #{FluentTools::Utils::BINARY_NAME}#{" `#{@version}`" if @version}..."
+
+    platform = FluentTools::Utils.detect_platform
+    if platform
+      log_info "🔍 Detected platform: #{platform}"
+
+      if download_prebuilt_binary(platform)
+        log_success 'Installation complete using pre-built binary!'
+        true
+      else
+        log_warning 'Pre-built binary not available, falling back to compilation...'
+        build_binary_from_source
+      end
+    else
+      log_warning "Platform #{RUBY_PLATFORM} not supported for pre-built binaries"
+      build_binary_from_source
+    end
+  end
+
+  private
+
+  def download_prebuilt_binary(platform)
+    log_info "🔍 Attempting to download pre-built binary for #{platform}..."
+
+    begin
+      release_data = @version ? fetch_release_by_version(@version) : fetch_latest_release
+      download_url = find_download_url(release_data, platform)
+
+      return false unless download_url
+
+      log_info "📦 Downloading from #{download_url}"
+      binary_data = download_file(download_url)
+
+      install_binary(binary_data, platform)
+      log_success 'Pre-built binary downloaded successfully!'
+      true
+    rescue StandardError => e
+      if @version
+        log_error "Failed to download pre-built binary for version #{@version}: #{e.message}"
+      else
+        log_error "Failed to download pre-built binary: #{e.message}"
+      end
+      false
+    end
+  end
+
+  def fetch_latest_release
+    api_url = "https://api.github.com/repos/#{FluentTools::Utils::REPO_OWNER}/#{FluentTools::Utils::REPO_NAME}/releases/latest"
+    uri = URI(api_url)
+    response = Net::HTTP.get_response(uri)
+
+    raise "Could not fetch release information (HTTP #{response.code})" unless response.code == '200'
+
+    JSON.parse(response.body)
+  end
+
+  def fetch_release_by_version(version)
+    api_url = "https://api.github.com/repos/#{FluentTools::Utils::REPO_OWNER}/#{FluentTools::Utils::REPO_NAME}/releases/tags/#{version}"
+    uri = URI(api_url)
+    response = Net::HTTP.get_response(uri)
+
+    case response.code
+    when '200'
+      JSON.parse(response.body)
+    when '404'
+      raise "Release #{version} not found. Available releases can be viewed at: https://github.com/#{FluentTools::Utils::REPO_OWNER}/#{FluentTools::Utils::REPO_NAME}/releases"
+    else
+      raise "Could not fetch release #{version} (HTTP #{response.code})"
+    end
+  end
+
+  def find_download_url(release_data, platform)
+    binary_name = FluentTools::Utils.binary_name_for_platform(platform)
+
+    asset = release_data['assets'].find { |a| a['name'] == binary_name }
+
+    unless asset
+      log_error "No pre-built binary found for #{platform}"
+      return nil
+    end
+
+    asset['browser_download_url']
+  end
+
+  def download_file(url)
+    uri = URI(url)
+
+    Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+      request = Net::HTTP::Get.new(uri)
+      response = http.request(request)
+
+      # Follow redirects (GitHub releases use them)
+      case response
+      when Net::HTTPRedirection
+        download_file(response['location'])
+      when Net::HTTPSuccess
+        response.body
+      else
+        raise "Download failed: HTTP #{response.code} - #{response.message}"
+      end
+    end
+  end
+
+  def install_binary(binary_data, platform)
+    install_dir = determine_install_dir
+    FileUtils.mkdir_p(install_dir)
+
+    binary_extension = FluentTools::Utils.binary_extension(platform)
+    binary_path = File.join(install_dir, "#{FluentTools::Utils::BINARY_NAME}#{binary_extension}")
+
+    log_info "📁 Installing binary to: #{binary_path}"
+    log_info "📏 Binary data size: #{binary_data.length} bytes"
+
+    raise 'Downloaded binary data is empty' if binary_data.empty?
+
+    File.binwrite(binary_path, binary_data)
+
+    # Make executable on Unix-like systems
+    File.chmod(0o755, binary_path) unless FluentTools::Utils.windows_platform?(platform)
+
+    log_info "✅ Binary installed successfully (#{File.size(binary_path)} bytes)"
+    @binary_path = binary_path
+  end
+
+  # rubocop:disable Naming/PredicateMethod
+  def build_binary_from_source
+    log_info '🔨 Building from source...'
+
+    # Find project root (where Cargo.toml and Makefile are)
+    project_root = find_project_root
+    unless project_root
+      log_error 'Could not find project root (Cargo.toml)'
+      return false
+    end
+
+    # Use Makefile to build the binary
+    Dir.chdir(project_root) do
+      unless system('make build_native')
+        log_error 'Failed to build Rust binary using Makefile'
+        return false
+      end
+    end
+
+    # Copy binary to install location
+    copy_built_binary(project_root)
+    log_success 'Binary built and installed successfully!'
+
+    true
+  end
+  # rubocop:enable Naming/PredicateMethod
+
+  def find_project_root
+    Pathname.pwd.ascend do |dir|
+      return dir.to_s if File.exist?(File.join(dir, 'Cargo.toml'))
+    end
+    nil
+  end
+
+  def copy_built_binary(project_root)
+    install_dir = determine_install_dir
+    FileUtils.mkdir_p(install_dir)
+
+    binary_extension = FluentTools::Utils.binary_extension
+    source_binary = File.join(project_root, 'target', 'release', "#{FluentTools::Utils::BINARY_NAME}#{binary_extension}")
+    dest_binary = File.join(install_dir, "#{FluentTools::Utils::BINARY_NAME}#{binary_extension}")
+
+    raise "Built binary not found at #{source_binary}" unless File.exist?(source_binary)
+
+    FileUtils.cp(source_binary, dest_binary)
+    @binary_path = dest_binary
+  end
+
+  def determine_install_dir
+    # First check if we're in the development context (has Cargo.toml in parent dirs)
+    project_root = find_project_root
+    if project_root
+      # Development context - put in ruby/bin relative to project root
+      File.join(project_root, 'ruby', 'bin')
+    else
+      # We're in a gem installation context - create bin directory in current gem location
+      current_dir = File.expand_path('..', __dir__)
+      bin_dir = File.join(current_dir, 'bin')
+      FileUtils.mkdir_p(bin_dir)
+      bin_dir
+    end
+  end
+end

data/lib/fluent_tools/cli.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module FluentTools
+  # CLI commands for Android XML conversion
+  class AndroidCLI < Thor
+    desc 'from_fluent INPUT OUTPUT', 'Convert Fluent file to Android XML strings'
+    long_desc <<~DESC
+      Convert a Fluent localization file to Android XML string resources.
+
+      INPUT: Path to the input Fluent (.ftl) file
+      OUTPUT: Path to the output Android XML file
+    DESC
+    def from_fluent(input, output)
+      command_executor = CommandExecutor.new
+      command_executor.fluent_to_android(input, output)
+      puts "Successfully converted #{input} to #{output}"
+    rescue Error => e
+      puts "Error: #{e.message}"
+      exit 1
+    end
+
+    desc 'to_fluent INPUT OUTPUT', 'Convert Android XML strings to Fluent file'
+    long_desc <<~DESC
+      Convert Android XML string resources to a Fluent localization file.
+
+      INPUT: Path to the input Android XML file
+      OUTPUT: Path to the output Fluent (.ftl) file
+    DESC
+    option :original_fluent, aliases: '-o', desc: 'Original Fluent file for variable mapping recovery'
+    def to_fluent(input, output)
+      command_executor = CommandExecutor.new
+      command_executor.android_to_fluent(input, output, original_fluent: options[:original_fluent])
+
+      message = "Successfully converted #{input} to #{output}"
+      message += " using original Fluent file #{options[:original_fluent]}" if options[:original_fluent]
+      puts message
+    rescue Error => e
+      puts "Error: #{e.message}"
+      exit 1
+    end
+  end
+
+  # CLI commands for PO (GNU gettext) conversion
+  class PoCLI < Thor
+    desc 'from_fluent INPUT OUTPUT', 'Convert Fluent file to PO format'
+    long_desc <<~DESC
+      Convert a Fluent localization file to GNU gettext PO format.
+
+      INPUT: Path to the input Fluent (.ftl) file
+      OUTPUT: Path to the output PO file
+    DESC
+    option :locale, aliases: '-l', default: 'en-US', desc: 'Source locale (e.g., en-US)'
+    def from_fluent(input, output)
+      command_executor = CommandExecutor.new
+      command_executor.fluent_to_po(input, output, locale: options[:locale])
+      puts "Successfully converted #{input} to #{output}"
+    rescue Error => e
+      puts "Error: #{e.message}"
+      exit 1
+    end
+
+    desc 'to_fluent INPUT OUTPUT', 'Convert PO file to Fluent format'
+    long_desc <<~DESC
+      Convert a GNU gettext PO file to Fluent localization format.
+
+      INPUT: Path to the input PO file
+      OUTPUT: Path to the output Fluent (.ftl) file
+    DESC
+    def to_fluent(input, output)
+      command_executor = CommandExecutor.new
+      command_executor.po_to_fluent(input, output)
+      puts "Successfully converted #{input} to #{output}"
+    rescue Error => e
+      puts "Error: #{e.message}"
+      exit 1
+    end
+  end
+
+  # Main CLI interface with subcommands for different formats
+  class CLI < Thor
+    # Android conversion commands
+    desc 'android SUBCOMMAND', 'Android XML conversion commands'
+    subcommand 'android', AndroidCLI
+
+    # PO conversion commands
+    desc 'po SUBCOMMAND', 'PO (GNU gettext) conversion commands'
+    subcommand 'po', PoCLI
+
+    desc 'version', 'Show version'
+    def version
+      puts "#{FluentTools::Utils::BINARY_NAME} #{VERSION}"
+    end
+  end
+end

data/lib/fluent_tools/command_executor.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'pathname'
+require 'fileutils'
+
+module FluentTools
+  # Core command executor class that interfaces with the fluent-tools Rust binary
+  # Handles file validation, output directory creation, and command execution
+  class CommandExecutor
+    def initialize
+      @binary_path = find_binary_path
+    end
+
+    # Convert Fluent file to Android XML
+    def fluent_to_android(input_path, output_path)
+      validate_input_file!(input_path)
+      ensure_output_directory(output_path)
+
+      cmd = [@binary_path, 'android', 'from-fluent', '-i', input_path, '-o', output_path]
+      execute_command(cmd)
+    end
+
+    # Convert Android XML to Fluent file
+    def android_to_fluent(input_path, output_path, original_fluent: nil)
+      validate_input_file!(input_path)
+      ensure_output_directory(output_path)
+
+      cmd = [@binary_path, 'android', 'to-fluent', '-i', input_path, '-o', output_path]
+      cmd += ['--original-fluent', original_fluent] if original_fluent
+
+      execute_command(cmd)
+    end
+
+    # Convert Fluent file to PO
+    def fluent_to_po(input_path, output_path, locale: 'en-US')
+      validate_input_file!(input_path)
+      ensure_output_directory(output_path)
+
+      cmd = [@binary_path, 'po', 'from-fluent', '-i', input_path, '-o', output_path, '-l', locale]
+      execute_command(cmd)
+    end
+
+    # Convert PO file to Fluent
+    def po_to_fluent(input_path, output_path)
+      validate_input_file!(input_path)
+      ensure_output_directory(output_path)
+
+      cmd = [@binary_path, 'po', 'to-fluent', '-i', input_path, '-o', output_path]
+      execute_command(cmd)
+    end
+
+    private
+
+    def find_binary_path
+      binary_name = FluentTools::Utils::BINARY_NAME
+
+      # 1. Standard gem installation (works for all gem contexts)
+      gem_binary = File.join(__dir__, '..', '..', 'bin', binary_name)
+      return gem_binary if File.executable?(gem_binary)
+
+      # 2. Development context
+      if development_context?
+        dev_binary = File.join(project_root, 'target', 'release', binary_name)
+        return dev_binary if File.executable?(dev_binary)
+
+        ruby_binary = File.join(project_root, 'ruby', 'bin', binary_name)
+        return ruby_binary if File.executable?(ruby_binary)
+      end
+
+      # 3. System PATH
+      system_binary = `which #{binary_name} 2>/dev/null`.strip
+      return system_binary unless system_binary.empty?
+
+      # If nothing found, return the expected gem path for better error messages
+      gem_binary
+    end
+
+    def development_context?
+      !project_root.nil?
+    end
+
+    def project_root
+      @project_root ||= find_project_root
+    end
+
+    def find_project_root
+      Pathname.new(__dir__).ascend do |dir|
+        return dir.to_s if File.exist?(File.join(dir, 'Cargo.toml'))
+      end
+      nil
+    end
+
+    def validate_input_file!(path)
+      return if File.exist?(path)
+
+      raise Error, "Input file does not exist: #{path}"
+    end
+
+    def ensure_output_directory(path)
+      output_dir = File.dirname(path)
+      return if Dir.exist?(output_dir)
+
+      begin
+        FileUtils.mkdir_p(output_dir)
+      rescue StandardError => e
+        raise Error, "Failed to create output directory #{output_dir}: #{e.message}"
+      end
+    end
+
+    def execute_command(cmd)
+      unless File.executable?(@binary_path)
+        raise Error, "Binary not found or not executable: #{@binary_path}. " \
+                     'Make sure the gem was installed correctly and Rust is available.'
+      end
+
+      stdout, stderr, status = Open3.capture3(*cmd)
+
+      unless status.success?
+        error_message = stderr.empty? ? stdout : stderr
+        raise Error, "Command failed: #{error_message}"
+      end
+
+      stdout
+    end
+  end
+end

data/lib/fluent_tools/utils.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'rbconfig'
+
+module FluentTools
+  # Shared utilities for fluent-tools
+  module Utils
+    # Project constants
+    REPO_OWNER = 'Automattic'
+    BINARY_NAME = 'fluent-tools'
+    REPO_NAME = 'fluent-rust-tools'
+
+    # Platform to Rust target mapping
+    PLATFORM_RUST_TARGETS = {
+      'x86_64-linux' => 'x86_64-unknown-linux-gnu',
+      'arm64-linux' => 'aarch64-unknown-linux-gnu',
+      'x86_64-darwin' => 'x86_64-apple-darwin',
+      'arm64-darwin' => 'aarch64-apple-darwin',
+      'x86_64-windows' => 'x86_64-pc-windows-gnu',
+      'arm64-windows' => 'aarch64-pc-windows-gnullvm'
+    }.freeze
+
+    # Platform detection using RbConfig to identify the current system
+    # Returns a string in the format "{architecture}-{os}" (e.g., "arm64-darwin")
+    # Returns nil if the platform is not supported
+    def self.detect_platform
+      host_os = RbConfig::CONFIG['host_os']
+      host_cpu = RbConfig::CONFIG['host_cpu']
+
+      platform = case host_os
+                 when /linux/
+                   'linux'
+                 when /darwin/
+                   'darwin'
+                 when /mingw|mswin/
+                   'windows'
+                 else
+                   return nil
+                 end
+
+      architecture = case host_cpu
+                     when /x86_64|amd64/
+                       'x86_64'
+                     when /arm64|aarch64/
+                       'arm64'
+                     else
+                       return nil
+                     end
+
+      "#{architecture}-#{platform}"
+    end
+
+    # Generate the expected binary name for a given platform
+    # Adds .exe extension for Windows platforms
+    def self.binary_name_for_platform(platform)
+      extension = binary_extension(platform)
+      "#{BINARY_NAME}-#{platform}#{extension}"
+    end
+
+    # Check if the current platform is Windows
+    def self.windows_platform?(platform = nil)
+      platform ||= detect_platform
+      platform&.include?('windows') || false
+    end
+
+    # Get binary extension for current platform
+    def self.binary_extension(platform = nil)
+      windows_platform?(platform) ? '.exe' : ''
+    end
+
+    # Validate that a platform is supported
+    def self.validate_platform!(platform)
+      return if PLATFORM_RUST_TARGETS.key?(platform)
+
+      raise "Invalid platform: #{platform}. Valid platforms: #{PLATFORM_RUST_TARGETS.keys.join(', ')}"
+    end
+
+    # Convert platform name to Rust target triple
+    def self.platform_to_rust_target(platform)
+      validate_platform!(platform)
+      PLATFORM_RUST_TARGETS[platform]
+    end
+
+    # Logger mixin to provide consistent logging across tools
+    module Logger
+      def log_info(message, verbose: true)
+        puts message if verbose
+      end
+
+      def log_success(message, verbose: true)
+        puts "✅ #{message}" if verbose
+      end
+
+      def log_warning(message, verbose: true)
+        puts "⚠️ #{message}" if verbose
+      end
+
+      def log_error(message, verbose: true)
+        warn "❌ #{message}" if verbose
+      end
+    end
+  end
+end

data/lib/fluent_tools/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FluentTools
+  VERSION = '0.2.0'
+end

data/lib/fluent_tools.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'fluent_tools/version'
+require_relative 'fluent_tools/utils'
+require_relative 'fluent_tools/command_executor'
+require_relative 'fluent_tools/cli'
+
+# Ruby bindings and CLI for fluent-rust-tools
+# Provides conversion between Fluent, Android XML, and PO formats
+module FluentTools
+  # Custom error class for fluent-tools operations
+  class Error < StandardError; end
+
+  # Convenience method for converting Fluent to Android XML
+  def self.fluent_to_android(input_path, output_path)
+    CommandExecutor.new.fluent_to_android(input_path, output_path)
+  end
+
+  # Convenience method for converting Android XML to Fluent
+  def self.android_to_fluent(input_path, output_path, original_fluent: nil)
+    CommandExecutor.new.android_to_fluent(input_path, output_path, original_fluent: original_fluent)
+  end
+
+  # Convenience method for converting Fluent to PO
+  def self.fluent_to_po(input_path, output_path, locale: 'en-US')
+    CommandExecutor.new.fluent_to_po(input_path, output_path, locale: locale)
+  end
+
+  # Convenience method for converting PO to Fluent
+  def self.po_to_fluent(input_path, output_path)
+    CommandExecutor.new.po_to_fluent(input_path, output_path)
+  end
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: fluent-tools
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Automattic
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-07-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  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'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Ruby gem that wraps a Rust CLI tool for converting between Mozilla's
+  Fluent localization format and other formats like Android XML string resources and
+  GNU gettext PO files
+email:
+- mobile@automattic.com
+executables:
+- fluent-tools
+extensions:
+- ext/fluent_tools/extconf.rb
+extra_rdoc_files: []
+files:
+- exe/fluent-tools
+- ext/fluent_tools/extconf.rb
+- installer.rb
+- lib/fluent_tools.rb
+- lib/fluent_tools/cli.rb
+- lib/fluent_tools/command_executor.rb
+- lib/fluent_tools/utils.rb
+- lib/fluent_tools/version.rb
+homepage: https://github.com/Automattic/fluent-rust-tools
+licenses:
+- MPL-2.0
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/Automattic/fluent-rust-tools
+  source_code_uri: https://github.com/Automattic/fluent-rust-tools
+  changelog_uri: https://github.com/Automattic/fluent-rust-tools/blob/main/CHANGELOG.md
+post_install_message: |
+  This fluent-tools gem will try to use a pre-built binary for your platform.
+  If unavailable, it will compile the Rust binary during installation.
+
+  If compilation is needed, make sure you have Rust installed: https://rustup.rs/
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Convert between Fluent and other formats (Android XML, GNU gettext PO)
+test_files: []