Cabriolet: Working with Microsoft Compression Formats in Pure Ruby

require "cabriolet"

# Open and extract
decompressor = Cabriolet::CAB::Decompressor.new
cabinet = decompressor.open("example.cab")

# List files
cabinet.files.each do |file|
  puts "#{file.filename}: #{file.length} bytes"
end

# Extract single file
file = cabinet.files.first
decompressor.extract_file(file, "output.txt")

# Extract all files
decompressor.extract_all(cabinet, "output/")

decompressor = Cabriolet::CAB::Decompressor.new
decompressor.salvage = true  # Enable salvage mode
decompressor.fix_mszip = true  # Enable MSZIP error recovery
decompressor.buffer_size = 8192  # Set buffer size

cabinet = decompressor.open("example.cab")
decompressor.extract_all(cabinet, "output/")

decompressor = Cabriolet::CAB::Decompressor.new

# Open first cabinet
cab1 = decompressor.open("disk1.cab")

# Open and append subsequent parts
cab2 = decompressor.open("disk2.cab")
decompressor.append(cab1, cab2)

cab3 = decompressor.open("disk3.cab")
decompressor.append(cab2, cab3)

# Extract from merged cabinet set
decompressor.extract_all(cab1, "output/")

decompressor = Cabriolet::CAB::Decompressor.new
cabinet = decompressor.search("installer.exe")

while cabinet
  puts "Cabinet at offset #{cabinet.base_offset}"
  puts "  Files: #{cabinet.file_count}"

  # Extract this cabinet
  decompressor.extract_all(cabinet, "output_#{cabinet.base_offset}/")

  # Move to next found cabinet
  cabinet = cabinet.next
end

compressor = Cabriolet::CAB::Compressor.new

# Add files
compressor.add_file("README.txt")
compressor.add_file("data.bin", "custom/path.bin")

# Generate cabinet
bytes = compressor.generate("output.cab",
  compression: :mszip,
  set_id: 12345,
  cabinet_index: 0)

puts "Created output.cab (#{bytes} bytes)"

decompressor = Cabriolet::CHM::Decompressor.new
chm = decompressor.open("help.chm")

# List files
chm.files&.each do |file|
  puts file.filename
end

# Extract single file
file = chm.files.first
decompressor.extract(file, "output.html") if file

# Extract all files
chm.files&.each do |file|
  output_path = File.join("output", file.filename)
  FileUtils.mkdir_p(File.dirname(output_path))
  decompressor.extract(file, output_path)
end

decompressor = Cabriolet::CHM::Decompressor.new

# Quick open (headers only, no file enumeration)
chm = decompressor.fast_open("help.chm")

# Find specific file quickly
file = Models::CHMFile.new
result = decompressor.fast_find(chm, "/index.html", file)

if file.length > 0
  decompressor.extract(file, "index.html")
end

compressor = Cabriolet::CHM::Compressor.new

# Add files
compressor.add_file("index.html", "/index.html", section: :compressed)
compressor.add_file("image.png", "/images/image.png", section: :uncompressed)

# Generate CHM
bytes = compressor.generate("help.chm",
  window_bits: 16,
  language_id: 0x0409)

puts "Created help.chm (#{bytes} bytes)"

decompressor = Cabriolet::SZDD::Decompressor.new

# Open and get header
header = decompressor.open("file.tx_")

puts "Format: #{header.format_name}"
puts "Length: #{header.length} bytes"
puts "Missing char: #{header.missing_char}" if header.missing_char

# Extract
decompressor.extract(header, "file.txt")

# Or one-shot
decompressor.decompress("file.tx_", "file.txt")

compressor = Cabriolet::SZDD::Compressor.new

# Compress file
bytes = compressor.compress("file.txt", "file.tx_",
  missing_char: "t",
  format: :normal)

# Or compress data from memory
bytes = compressor.compress_data("Hello, world!", "output.tx_")

decompressor = Cabriolet::KWAJ::Decompressor.new

# Open and get header
header = decompressor.open("setup.kwj")

puts "Compression: #{header.compression_name}"
puts "Length: #{header.length} bytes" if header.length
puts "Filename: #{header.filename}" if header.filename

# Extract
decompressor.extract(header, "setup.kwj", "output.exe")

# Or one-shot
decompressor.decompress("setup.kwj", "setup.exe")

compressor = Cabriolet::KWAJ::Compressor.new

# Compress file
bytes = compressor.compress("file.exe", "file.kwj",
  compression: :szdd,
  include_length: true,
  filename: "original.exe")

# Compression options: :none, :xor, :szdd, :mszip

# Works with both QuickHelp and Windows Help formats
decompressor = Cabriolet::HLP::Decompressor.new
header = decompressor.open("help.hlp")

# Format is automatically detected
case header
when Cabriolet::Models::HLPHeader
  puts "QuickHelp format (DOS)"
when Cabriolet::Models::WinHelpHeader
  puts "Windows Help format (#{header.version_string})"
end

# Extract files
decompressor.extract_all(header, "output/")

compressor = Cabriolet::HLP::Compressor.new

# Add topics
compressor.add_data("Topic 1 text", "topic1")
compressor.add_data("Topic 2 text", "topic2")

# Generate QuickHelp format (DOS)
bytes = compressor.generate("help.hlp",
  database_name: "MyHelp",
  control_character: 0x3A)  # ':'

# Create WinHelp 3.x format file
compressor = Cabriolet::HLP::WinHelp::Compressor.new

# Add system metadata
compressor.add_system_file(
  title: "My Help File",
  copyright: "Copyright 2025",
  contents: "contents.hlp")

# Add topics (automatically compressed with Zeck LZ77)
compressor.add_topic_file(["Topic 1 text", "Topic 2 text"], compress: true)

# Generate WinHelp 3.x or 4.x
bytes = compressor.generate("help.hlp", version: :winhelp3)
# or version: :winhelp4 for WinHelp 4.x format

decompressor = Cabriolet::HLP::WinHelp::Decompressor.new("help.hlp")
header = decompressor.parse

# List internal files (|SYSTEM, |TOPIC, etc.)
puts decompressor.internal_filenames

# Extract specific internal file
system_data = decompressor.extract_system_file
topic_data = decompressor.extract_topic_file

# Decompress topics
if topic_data
  decompressed = decompressor.decompress_topic(topic_data, expected_size)
end

decompressor = Cabriolet::LIT::Decompressor.new

begin
  lit = decompressor.open("book.lit")

  if lit.encrypted
    raise "LIT file is DRM-encrypted. Decryption not supported."
  end

  # Extract files
  lit.files.each do |file|
    decompressor.extract_file(file, "output/#{file.filename}")
  end
rescue NotImplementedError => e
  puts "Error: #{e.message}"
end

compressor = Cabriolet::LIT::Compressor.new

compressor.add_file("content.html", "/content.html")
bytes = compressor.generate("book.lit")

decompressor = Cabriolet::OAB::Decompressor.new

# Extract full file
decompressor.decompress("contacts.lzx", "contacts.oab")

# Apply incremental patch
decompressor.decompress_incremental("patch.lzx", "base.oab", "new.oab")

compressor = Cabriolet::OAB::Compressor.new

# Compress full file
compressor.compress("contacts.oab", "contacts.lzx")

# Create incremental patch
compressor.compress_incremental("new.oab", "old.oab", "patch.lzx")

compressor = Cabriolet::CAB::Compressor.new
compressor.add_file("file1.txt")
compressor.add_file("file2.txt")
bytes = compressor.generate("output.cab", compression: :mszip)