omnizip 0.4.7-arm-linux

data/lib/omnizip/archive_handlers/cpio_handler.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Omnizip
+  module ArchiveHandlers
+    # Read-only adapter for the CPIO format (initramfs images, RPM
+    # payloads). Extraction and listing are supported; CPIO writing
+    # exists at the format level but is not exposed through the
+    # convenience archive API.
+    class CpioHandler
+      def create(_path, **_options)
+        raise Omnizip::UnsupportedFormatError,
+              "cpio archives cannot be created through the convenience " \
+              "API; use Omnizip::Formats::Cpio.create directly"
+      end
+
+      def extract_to(path, output_dir, **_)
+        Omnizip::Formats::Cpio.extract(path, output_dir)
+      end
+
+      def list(path, details: false, **_)
+        entries = Omnizip::Formats::Cpio.list(path)
+        if details
+          entries.map do |e|
+            { name: e.name, size: e.data.bytesize,
+              directory: e.name.end_with?("/"), mtime: nil }
+          end
+        else
+          entries.map(&:name)
+        end
+      end
+
+      def read_entry(path, entry_name, **_)
+        entry = Omnizip::Formats::Cpio.list(path)
+          .find { |e| e.name == entry_name }
+        unless entry
+          raise Errno::ENOENT, "Entry not found: #{entry_name}"
+        end
+
+        entry.data
+      end
+    end
+  end
+end
+
+Omnizip::ArchiveHandler.register(:cpio, Omnizip::ArchiveHandlers::CpioHandler.new)

data/lib/omnizip/archive_handlers/iso_handler.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Omnizip
+  module ArchiveHandlers
+    # Read-only adapter for the ISO 9660 format (disk images).
+    # Extraction and listing are supported; ISO writing exists at the
+    # format level but is not exposed through the convenience archive
+    # API.
+    class IsoHandler
+      def create(_path, **_options)
+        raise Omnizip::UnsupportedFormatError,
+              "iso images cannot be created through the convenience " \
+              "API; use Omnizip::Formats::Iso.create directly"
+      end
+
+      def extract_to(path, output_dir, **_)
+        Omnizip::Formats::Iso.extract(path, output_dir)
+      end
+
+      def list(path, details: false, **_)
+        entries = Omnizip::Formats::Iso.list(path)
+        if details
+          entries.map do |e|
+            { name: e.full_path, size: e.size, directory: e.directory?,
+              mtime: e.recording_date }
+          end
+        else
+          entries.map(&:full_path)
+        end
+      end
+
+      def read_entry(path, entry_name, **_)
+        entry = Omnizip::Formats::Iso.list(path)
+          .find { |e| e.full_path == entry_name }
+        unless entry
+          raise Errno::ENOENT, "Entry not found: #{entry_name}"
+        end
+        raise Errno::EISDIR, "Entry is a directory: #{entry_name}" if entry.directory?
+
+        Dir.mktmpdir("omnizip-iso-entry") do |dir|
+          dest = File.join(dir, "entry")
+          Omnizip::Formats::Iso.open(path) do |iso|
+            iso.extract_entry(entry_name, dest)
+          end
+          File.binread(dest)
+        end
+      end
+    end
+  end
+end
+
+Omnizip::ArchiveHandler.register(:iso, Omnizip::ArchiveHandlers::IsoHandler.new)

data/lib/omnizip/archive_handlers/ole_handler.rb

@@ -0,0 +1,37 @@
+# frozen_string: true
+
+module Omnizip
+  module ArchiveHandlers
+    # Read-only adapter for OLE compound documents ( MSI installers,
+    # legacy Office binaries): stream listing, reading, and
+    # extraction. Stream names are listed exactly as stored — MSI
+    # installers mangle their table-stream names in a
+    # MSI-domain encoding this handler does not decode.
+    class OleHandler
+      def create(_path, **_options)
+        raise Omnizip::UnsupportedFormatError,
+              "compound documents cannot be created through the " \
+              "convenience API; use Omnizip::Formats::Ole directly"
+      end
+
+      def extract_to(path, output_dir, **_)
+        Omnizip::Formats::Ole.extract(path, output_dir)
+        Dir.glob(File.join(output_dir, "**", "*"))
+          .select { |f| File.file?(f) }
+      end
+
+      def list(path, details: false, **_)
+        entries = Omnizip::Formats::Ole.list(path)
+        return entries unless details
+
+        entries.map { |name| { name: name, size: nil, directory: false } }
+      end
+
+      def read_entry(path, entry_name, **_)
+        Omnizip::Formats::Ole.read(path, entry_name)
+      end
+    end
+  end
+end
+
+Omnizip::ArchiveHandler.register(:ole, Omnizip::ArchiveHandlers::OleHandler.new)

data/lib/omnizip/archive_handlers/rar_handler.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+require "tempfile"
+
+module Omnizip
+  module ArchiveHandlers
+    # Adapter for the RAR format: extraction/listing/reading, plus
+    # creation through Formats::Rar (RAR5 STORE is unrar-verified;
+    # compressed methods fall back to STORE with a warning — see the
+    # README interop table).
+    class RarHandler
+      def create(path, **options, &block)
+        proxy = nil
+        result = Omnizip::Formats::Rar.create(path, options) do |writer|
+          proxy = WriterProxy.new(writer)
+          block&.call(proxy)
+        end
+        proxy&.cleanup
+        result
+      end
+
+      def extract_to(path, output_dir, password: nil, **_)
+        Omnizip::Formats::Rar::Decompressor.extract(path, output_dir,
+                                                    password: password)
+        reader = Omnizip::Formats::Rar::Reader.new(path).open
+        reader.list_files.reject(&:is_dir)
+          .map { |e| ::File.join(output_dir, e.name) }
+      end
+
+      def list(path, details: false, **_)
+        reader = Omnizip::Formats::Rar::Reader.new(path).open
+        entries = reader.list_files
+        if details
+          entries.map do |e|
+            { name: e.name, size: e.size, directory: e.is_dir,
+              compressed_size: (e.compressed_size if e.compressed_size.positive?),
+              mtime: e.mtime }
+          end
+        else
+          entries.map(&:name)
+        end
+      end
+
+      def read_entry(path, entry_name, password: nil, **_)
+        Dir.mktmpdir("omnizip-rar-entry") do |dir|
+          dest = File.join(dir, "entry")
+          Omnizip::Formats::Rar::Decompressor.extract_entry(
+            path, entry_name, dest, password: password
+          )
+          File.binread(dest)
+        end
+      end
+
+      # Translates the generic +add(name, source_path)+ /
+      # +add_data(name, data)+ / +add_directory(name)+ interface onto
+      # the RAR writers. The writers take file paths, so in-memory
+      # content spills to a temporary file.
+      class WriterProxy
+        def initialize(writer)
+          @writer = writer
+          @spill = []
+        end
+
+        def add(name, source_path = nil)
+          if source_path
+            @writer.add_file(source_path, name)
+          else
+            @writer.add_directory_entry(name)
+          end
+        end
+
+        def add_data(name, data)
+          file = Tempfile.new(["omnizip_rar_entry", File.extname(name)])
+          file.binmode
+          file.write(data)
+          file.close
+          @spill << file
+          @writer.add_file(file.path, name)
+        end
+
+        def add_directory(name)
+          @writer.add_directory_entry(name)
+        end
+
+        # Remove the temporary files add_data spilled
+        def cleanup
+          @spill.each(&:unlink)
+          @spill.clear
+        end
+      end
+    end
+  end
+end
+
+Omnizip::ArchiveHandler.register(:rar, Omnizip::ArchiveHandlers::RarHandler.new)

data/lib/omnizip/archive_handlers/rpm_handler.rb

@@ -0,0 +1,45 @@
+# frozen_string: true
+
+require "tmpdir"
+
+module Omnizip
+  module ArchiveHandlers
+    # Read-only adapter for the RPM package format: extraction and
+    # listing over the CPIO payload; package metadata lives in
+    # Formats::Rpm.info. RPM writing exists at the format level but
+    # is not exposed through the convenience archive API.
+    class RpmHandler
+      def create(_path, **_options)
+        raise Omnizip::UnsupportedFormatError,
+              "rpm archives cannot be created through the convenience " \
+              "API; use Omnizip::Formats::Rpm::Writer directly"
+      end
+
+      def extract_to(path, output_dir, **_)
+        Omnizip::Formats::Rpm.extract(path, output_dir)
+        Dir.glob(File.join(output_dir, "**", "*"))
+          .select { |f| File.file?(f) }
+      end
+
+      def list(path, details: false, **_)
+        entries = Omnizip::Formats::Rpm.list(path)
+        return entries unless details
+
+        entries.map { |name| { name: name, size: nil, directory: false } }
+      end
+
+      def read_entry(path, entry_name, **_)
+        Dir.mktmpdir("omnizip-rpm-entry") do |dir|
+          Omnizip::Formats::Rpm.extract(path, dir)
+          dest = File.join(dir, entry_name)
+          raise Errno::ENOENT, "Entry not found: #{entry_name}" unless
+            File.exist?(dest)
+
+          File.binread(dest)
+        end
+      end
+    end
+  end
+end
+
+Omnizip::ArchiveHandler.register(:rpm, Omnizip::ArchiveHandlers::RpmHandler.new)

data/lib/omnizip/archive_handlers/seven_zip_handler.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module ArchiveHandlers
+    # Adapter that exposes the canonical +create+/+extract_to+/+list+
+    # interface for the 7z format. Wraps +Omnizip::Formats::SevenZip+.
+    class SevenZipHandler
+      # Creates a .7z archive. The yielded proxy only supports
+      # +add(name, source_path)+ for files — directory entries are not
+      # part of the single-file convenience flow.
+      def create(path, **options, &block)
+        Omnizip::Formats::SevenZip.create(path, options) do |writer|
+          block&.call(FileProxy.new(writer))
+        end
+      end
+
+      def extract_to(path, output_dir, **options)
+        extracted = []
+        Omnizip::Formats::SevenZip.open(path, options) do |reader|
+          reader.extract_all(output_dir)
+          extracted = reader.list_files.reject(&:is_dir)
+            .map { |e| ::File.join(output_dir, e.name) }
+        end
+        extracted
+      end
+
+      def list(path, details: false, **options)
+        with_reader(path, options) do |reader|
+          entries = reader.list_files
+          if details
+            entries.map do |e|
+              { name: e.name, size: e.size, directory: e.is_dir,
+                compressed_size: (e.compressed_size if e.compressed_size&.positive?),
+                mtime: e.mtime, crc: e.crc }
+            end
+          else
+            entries.map(&:name)
+          end
+        end
+      end
+
+      def read_entry(path, entry_name, **options)
+        with_reader(path, options) do |reader|
+          entry = reader.list_files.find { |e| e.name == entry_name }
+          raise Errno::ENOENT, "Entry not found: #{entry_name}" unless entry
+
+          reader.extract_entry_data(File.open(path, "rb"), entry)
+        end
+      end
+
+      private
+
+      # The SevenZip.open facade returns the reader, discarding the
+      # block's value — so drive the Reader directly.
+      def with_reader(path, options)
+        reader = Omnizip::Formats::SevenZip::Reader.new(path, options)
+        reader.open
+        begin
+          yield reader
+        ensure
+          reader.split_reader&.close
+        end
+      end
+
+      # Translates the generic +add(name, source_path)+ interface to
+      # the 7z writer's +add_file(file_path, archive_path)+.
+      class FileProxy
+        def initialize(writer)
+          @writer = writer
+        end
+
+        def add(name, source_path = nil)
+          if source_path
+            @writer.add_file(source_path, name)
+          else
+            @writer.add_directory_entry(name)
+          end
+        end
+
+        def add_data(name, data)
+          @writer.add_data(name, data)
+        end
+      end
+    end
+  end
+end
+
+Omnizip::ArchiveHandler.register(:seven_zip,
+                                 Omnizip::ArchiveHandlers::SevenZipHandler.new)

data/lib/omnizip/archive_handlers/tar_handler.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module ArchiveHandlers
+    # Adapter that exposes the canonical +create+/+open+/+extract_to+
+    # /+list+ interface for the TAR format. Wraps +Omnizip::Formats::Tar+.
+    class TarHandler
+      def create(path, &block)
+        Omnizip::Formats::Tar.create(path) do |writer|
+          block&.call(EntryProxy.new(writer))
+        end
+      end
+
+      def open(path, &block)
+        Omnizip::Formats::Tar.open(path, &block)
+      end
+
+      def extract_to(path, output_dir, **_)
+        Omnizip::Formats::Tar.extract(path, output_dir)
+        Omnizip::Formats::Tar.list(path).reject(&:directory?)
+          .map { |e| ::File.join(output_dir, e.name) }
+      end
+
+      def list(path, details: false, **_)
+        entries = Omnizip::Formats::Tar.list(path)
+        if details
+          entries.map do |entry|
+            {
+              name: entry.name,
+              size: entry.size,
+              directory: entry.directory?,
+              mtime: entry.mtime,
+              mode: entry.mode,
+            }
+          end
+        else
+          entries.map(&:name)
+        end
+      end
+
+      # Translates the generic +add(name, source_path)+ interface:
+      # a bare +add(name)+ is a directory ENTRY (no source on disk
+      # relative to the caller), which the Tar writer's own +add+
+      # would misread as a CWD-relative path.
+      class EntryProxy
+        def initialize(writer)
+          @writer = writer
+        end
+
+        def add(name, source_path = nil)
+          return @writer.add_directory(name) if source_path.nil?
+
+          @writer.add(name, source_path)
+        end
+
+        def add_data(name, data)
+          @writer.add_data(name, data)
+        end
+      end
+
+      def read_entry(path, entry_name)
+        data = nil
+        Omnizip::Formats::Tar.open(path) do |reader|
+          entry = reader.entries.find { |e| e.name == entry_name }
+          raise Errno::ENOENT, "Entry not found: #{entry_name}" unless entry
+
+          data = entry.data
+        end
+        data
+      end
+    end
+  end
+end
+
+Omnizip::ArchiveHandler.register(:tar, Omnizip::ArchiveHandlers::TarHandler.new)

data/lib/omnizip/archive_handlers/xar_handler.rb

@@ -0,0 +1,49 @@
+# frozen_string: true
+
+require "tmpdir"
+
+module Omnizip
+  module ArchiveHandlers
+    # Read-only adapter for the XAR archive format: extraction and
+    # listing over the XML TOC. XAR writing exists at the format
+    # level but is not exposed through the convenience archive API.
+    class XarHandler
+      def create(_path, **_options)
+        raise Omnizip::UnsupportedFormatError,
+              "xar archives cannot be created through the convenience " \
+              "API; use Omnizip::Formats::Xar.create directly"
+      end
+
+      def extract_to(path, output_dir, **_)
+        Omnizip::Formats::Xar.extract(path, output_dir)
+        Dir.glob(File.join(output_dir, "**", "*"))
+          .select { |f| File.file?(f) }
+      end
+
+      def list(path, details: false, **_)
+        entries = Omnizip::Formats::Xar.list(path)
+        if details
+          entries.map do |e|
+            { name: e.name, size: e.size,
+              directory: false }
+          end
+        else
+          entries.map(&:name)
+        end
+      end
+
+      def read_entry(path, entry_name, **_)
+        Dir.mktmpdir("omnizip-xar-entry") do |dir|
+          Omnizip::Formats::Xar.extract(path, dir)
+          dest = File.join(dir, entry_name)
+          raise Errno::ENOENT, "Entry not found: #{entry_name}" unless
+            File.exist?(dest)
+
+          File.binread(dest)
+        end
+      end
+    end
+  end
+end
+
+Omnizip::ArchiveHandler.register(:xar, Omnizip::ArchiveHandlers::XarHandler.new)

data/lib/omnizip/archive_handlers/zip_handler.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module ArchiveHandlers
+    # Adapter that exposes the canonical +create+/+open+/+extract_to+
+    # /+list+ interface for the ZIP format on the native
+    # +Formats::Zip+ tree. In-place entry editing (+add_entry+ /
+    # +remove_entry+) still goes through the rubyzip-compat
+    # +Omnizip::Zip::File+ layer: it is an in-place central-directory
+    # rewriter the native tree does not have (the same reason the
+    # Metadata subsystem lives there).
+    class ZipHandler
+      def create(path, compression_method: nil, level: nil, **_, &block)
+        writer = Formats::Zip::Writer.new(path)
+        block&.call(WriterProxy.new(writer))
+
+        # The native writer takes archive-level compression at #write
+        # time; keep profile keywords out of it
+        kwargs = {}
+        kwargs[:compression_method] = compression_method if compression_method
+        kwargs[:level] = level if level
+        writer.write(**kwargs)
+        path
+      end
+
+      def open(path, &block)
+        reader = Formats::Zip::Reader.new(path)
+        block ? yield(reader) : reader
+      end
+
+      def extract_to(path, output_dir, overwrite: false, **_)
+        reader = Formats::Zip::Reader.new(path)
+
+        if overwrite
+          reader.extract_all(output_dir)
+          reader.entries.map { |e| ::File.join(output_dir, e.filename) }
+        else
+          extracted = []
+          reader.entries.each do |entry|
+            dest_path = ::File.join(output_dir, entry.filename)
+            raise Errno::EEXIST, "File exists: #{dest_path}" if ::File.exist?(dest_path)
+
+            reader.extract_entry(entry, output_dir)
+            extracted << dest_path
+          end
+          extracted
+        end
+      end
+
+      def list(path, details: false, **_)
+        # Whole-archive tier (names-only path): the Rust archive
+        # surface lists any supported format; the Ruby reader stays
+        # the fallback and the details path's source.
+        unless details
+          tier_names = Omnizip::Backends.archive_entry_names(path)
+          return tier_names if tier_names
+        end
+
+        reader = Formats::Zip::Reader.new(path)
+        return reader.entries.map(&:filename) unless details
+
+        reader.entries.map do |entry|
+          {
+            name: entry.filename,
+            size: entry.uncompressed_size,
+            compressed_size: entry.compressed_size,
+            compression_method: entry.compression_method,
+            crc: entry.crc32,
+            time: entry.time,
+            directory: entry.directory?,
+          }
+        end
+      end
+
+      def read_entry(path, entry_name)
+        tier = Omnizip::Backends.archive_read_entry(path, entry_name)
+        return tier unless tier.nil?
+
+        Formats::Zip::Reader.new(path).read_entry(entry_name)
+      end
+
+      def add_entry(path, entry_name, source_path)
+        Omnizip::Zip::File.open(path) { |zip| zip.add(entry_name, source_path) }
+      end
+
+      def remove_entry(path, entry_name)
+        Omnizip::Zip::File.open(path) { |zip| zip.remove(entry_name) }
+      end
+
+      # Translates the generic +add(name, source_path)+ and
+      # +add_data(name, data)+ interface onto the native writer
+      class WriterProxy
+        def initialize(writer)
+          @writer = writer
+        end
+
+        def add(name, source_path = nil, &block)
+          if source_path
+            @writer.add_file(source_path, name)
+          elsif block
+            @writer.add_data(name, yield)
+          else
+            @writer.add_directory(name)
+          end
+        end
+
+        def add_data(name, data)
+          @writer.add_data(name, data)
+        end
+      end
+    end
+  end
+end
+
+Omnizip::ArchiveHandler.register(:zip, Omnizip::ArchiveHandlers::ZipHandler.new)

data/lib/omnizip/archive_handlers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Archive handler namespace. Each format ships a Handler class here
+  # that adapts its format-specific API to the canonical contract
+  # documented on +Omnizip::ArchiveHandler+.
+  module ArchiveHandlers
+    autoload :ZipHandler, "omnizip/archive_handlers/zip_handler"
+    autoload :TarHandler, "omnizip/archive_handlers/tar_handler"
+    autoload :SevenZipHandler, "omnizip/archive_handlers/seven_zip_handler"
+    autoload :RarHandler, "omnizip/archive_handlers/rar_handler"
+    autoload :CpioHandler, "omnizip/archive_handlers/cpio_handler"
+    autoload :RpmHandler, "omnizip/archive_handlers/rpm_handler"
+    autoload :XarHandler, "omnizip/archive_handlers/xar_handler"
+    autoload :OleHandler, "omnizip/archive_handlers/ole_handler"
+    autoload :IsoHandler, "omnizip/archive_handlers/iso_handler"
+  end
+end