PureRubyZip

gem 'pure_ruby_zip'

require "pure_ruby_zip"

# Open a ZIP file
zip = PureRubyZip::ZipFile.new("archive.zip")

# List all files
puts zip.entries
# => ["file1.txt", "dir/file2.txt", "image.png"]

# Check if a file exists
zip.include?("file1.txt")
# => true

# Get number of entries
zip.size
# => 3

# Extract a single file to memory
data = zip.extract("file1.txt")
puts data
# => "contents of file1.txt"

# Extract all files to memory
files = zip.extract_all
files.each do |file|
  puts "#{file[:path]}: #{file[:data].length} bytes"
end

# Extract all files to disk (default: creates directory named after ZIP file)
zip.extract_to_disk

# Extract to a specific directory
zip.extract_to_disk("/path/to/output")

# Extract files matching a pattern (returns array)
txt_files = zip.extract_matching(/\.txt$/)
txt_files.each do |file|
  puts "#{file[:path]}: #{file[:data]}"
end

# Extract files matching a pattern (with block)
zip.extract_matching(/\.jpg$/i) do |path, data|
  File.write("output/#{File.basename(path)}", data)
end

# Iterate over all entries
zip.each do |path, item|
  puts "#{path} (#{item.compressed_size} bytes compressed)"
  puts "  Compression: #{item.compression_method}"
  puts "  Directory: #{item.directory?}"
end

# Or use the enumerator
zip.each.with_index do |(path, item), index|
  puts "#{index + 1}. #{path}"
end

# Get item by path
item = zip["dir/file.txt"]

# Check item properties
puts item.filename
puts item.compressed_size
puts item.uncompressed_size
puts item.compression_method  # 0 = stored, 8 = deflate
puts item.directory?

begin
  zip = PureRubyZip::ZipFile.new("archive.zip")
  data = zip.extract("file.txt")
rescue PureRubyZip::FileNotFoundError => e
  puts "File not found in archive: #{e.message}"
rescue PureRubyZip::InvalidZipError => e
  puts "Invalid or corrupted ZIP file: #{e.message}"
rescue PureRubyZip::PathTraversalError => e
  puts "Security error: #{e.message}"
rescue PureRubyZip::ZipBombError => e
  puts "Potential zip bomb detected: #{e.message}"
rescue PureRubyZip::UnsupportedCompressionError => e
  puts "Unsupported compression method: #{e.message}"
rescue PureRubyZip::Error => e
  puts "Error: #{e.message}"
end

zip.decompress_file("file.txt")           # alias for extract
zip.decompress_all_files                  # alias for extract_all
zip.decompress_all_files_to_disk          # alias for extract_to_disk

require "pure_ruby_zip"

# Create a new ZIP file
PureRubyZip::ZipWriter.create("archive.zip") do |zip|
  # Add a file from memory
  zip.add_buffer("Hello, World!", "hello.txt")

  # Add a file from disk (uses basename)
  zip.add_file("data.csv")

  # Add a file with custom path in ZIP
  zip.add_file("report.pdf", "documents/2024/report.pdf")
end

PureRubyZip::ZipWriter.create("data.zip") do |zip|
  # Add string content
  zip.add_buffer("Some text content", "file.txt")

  # Add binary data
  binary_data = File.binread("image.png")
  zip.add_buffer(binary_data, "images/logo.png")

  # Add generated content
  csv_data = "name,age\nJohn,30\nJane,25"
  zip.add_buffer(csv_data, "exports/data.csv")
end

PureRubyZip::ZipWriter.create("backup.zip") do |zip|
  # Add file with its original basename
  zip.add_file("config.json")
  # Creates: config.json in the ZIP

  # Add file with custom path in ZIP
  zip.add_file("config.json", "configs/production.json")
  # Creates: configs/production.json in the ZIP

  # Add multiple files
  Dir["logs/*.log"].each do |log_file|
    zip.add_file(log_file, "logs/#{File.basename(log_file)}")
  end
end

PureRubyZip::ZipWriter.create("mixed.zip") do |zip|
  # Use DEFLATE compression (default)
  zip.add_buffer("Text content", "compressed.txt", compression: :deflate)

  # Use stored (no compression) for already-compressed files
  zip.add_file("image.jpg", compression: :stored)
  zip.add_file("video.mp4", compression: :stored)

  # DEFLATE is good for text files
  zip.add_file("data.csv", compression: :deflate)
end

require "pure_ruby_zip"

# Create a project archive
PureRubyZip::ZipWriter.create("project-backup.zip") do |zip|
  # Add project files
  zip.add_file("README.md")
  zip.add_file("LICENSE")

  # Add source files with directory structure
  Dir["lib/**/*.rb"].each do |file|
    zip.add_file(file)
  end

  # Add generated metadata
  metadata = {
    created_at: Time.now,
    version: "1.0.0",
    files_count: Dir["lib/**/*.rb"].length
  }.to_json
  zip.add_buffer(metadata, "metadata.json")

  # Add a manifest
  files_list = Dir["lib/**/*.rb"].join("\n")
  zip.add_buffer(files_list, "MANIFEST.txt")
end

# Verify the archive
zip = PureRubyZip::ZipFile.new("project-backup.zip")
puts "Created archive with #{zip.size} files"
puts zip.entries

# Create a ZIP file
PureRubyZip::ZipWriter.create("test.zip") do |zip|
  zip.add_buffer("Original content", "file.txt")
  zip.add_buffer("More data", "data.txt")
end

# Read it back
zip = PureRubyZip::ZipFile.new("test.zip")
puts zip.extract("file.txt")  # => "Original content"
puts zip.extract("data.txt")  # => "More data"