omnizip 0.3.47 → 0.3.49

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22e232b5a4b1ddbbece5ce1b6052ea90a9e76a120e8d246cf03ae0b568d4ba73
-  data.tar.gz: af66a96e666d25e75196b68b317e2f34a37f2fa3e0da2d79d8f2d67d2a6d86a2
+  metadata.gz: f2d2eb9632ecf11d24224648408b2ca0bb56ed99b3a0ad6b077edbf84930ad52
+  data.tar.gz: 243668f7a95b77377911efcc686dec8f5d43a47b625aca6a30795b4d4d66a49a
 SHA512:
-  metadata.gz: ed6a8cd7c2613912ed4c50e914cd1a4184253e6b66325741649d2790c9b0650546f6066354a28956b98e2f0a7c17853a56a0723308877a93043b55979270a2c1
-  data.tar.gz: f6ad381f14bfd3a621584747bd71f544adacafc6d8241261f6bf7c553a92763ca0fef2165d4a65895f0ff54231b071e6f98903d87caf7125bfe229c372afc489
+  metadata.gz: fa7a60a3b4fba564f7b76786969699a446f46e72a7610065113c5fdcb02404b4d7ec3e9b6430d2ab48550ad19061341af5d29286786e1f833bb5b8a246735434
+  data.tar.gz: d2f4375f10f9922ca466d9c154d2bfbd42ccb3a376e58be025299af1d3dafdbcc6d43175dd3fe9d76c87057d7f067e1ff01900968982b8ed193833e9f7819405

data/CHANGELOG.md

@@ -7,6 +7,44 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.48] - 2026-08-31
+
+### Changed
+- `omnizip archive create` routes through the Archive facade: the
+  command's two hand-munged format branches collapse into one
+  `Archive.create` call — the handler registry picks each format's
+  writer and applies its option semantics, and the command only
+  translates CLI vocabulary (414 -> 290 lines). Verified for 7z
+  (7zz byte-identical), RAR5, RAR4, volume splitting, and verbose
+  output.
+
+### Fixed
+- The 7z handler proxy dropped the Builder's explicit directory
+  entries (derive-from-paths no-op), so CLI-created archives lost
+  the `dir/` entries the previous writer path emitted. The proxy
+  maps name-only adds to `add_directory_entry`, which preserves the
+  trailing slash; the Buffer read proxy no longer double-slashes
+  such names.
+- The facade denied RAR passwords (`PASSWORD_FORMATS` listed 7z
+  only) while the RAR5 writer produces unrar-decryptable encrypted
+  archives — `:rar` added (verified with `unrar -p`).
+- RAR4 recovery guard crashed on explicit boolean options:
+  `false&.to_i` still calls `to_i` (safe navigation guards nil
+  only) — Numeric check now.
+- RAR interop specs gate on the unrar command (through its resolved
+  path), not the gem wrapper: CI runners can carry the gem without
+  the binary on PATH.
+
+## [0.3.47] - 2026-08-31
+
+### Fixed
+- `.rar` is a writable extension route: the RAR handler gained
+  create in 0.3.46, but the route table still classified `.rar` as
+  read-only — `Archive.create('a.rar')` without an explicit format
+  kept raising "cannot be written by the convenience API" while
+  `Archive.create(fmt: :rar)` worked. The route table matches the
+  handler now; `.cpio`/`.iso` stay read-only.
+
 ## [0.3.46] - 2026-08-31
 
 ### Added

data/lib/omnizip/archive.rb

@@ -36,7 +36,7 @@ module Omnizip
       end
     end
 
-    PASSWORD_FORMATS = [:seven_zip].freeze
+    PASSWORD_FORMATS = %i[seven_zip rar].freeze
     private_constant :PASSWORD_FORMATS
 
     class << self

data/lib/omnizip/archive_handler.rb

@@ -68,6 +68,9 @@ module Omnizip
     # file, which then self-registers at the bottom of the file.
     LAZY_LOAD_TRIGGERS = {
       zip: -> { Omnizip::ArchiveHandlers::ZipHandler },
+      rpm: -> { Omnizip::ArchiveHandlers::RpmHandler },
+      xar: -> { Omnizip::ArchiveHandlers::XarHandler },
+      ole: -> { Omnizip::ArchiveHandlers::OleHandler },
       tar: -> { Omnizip::ArchiveHandlers::TarHandler },
       seven_zip: -> { Omnizip::ArchiveHandlers::SevenZipHandler },
       rar: -> { Omnizip::ArchiveHandlers::RarHandler },

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/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

@@ -69,14 +69,12 @@ module Omnizip
           @writer = writer
         end
 
-        # Directory entries are a no-op: 7z archives derive the
-        # directory tree from the files' archive paths ("sub/f.txt"
-        # implies "sub/"), and the writer/reader handle slashed
-        # paths (verified against 7zz).
         def add(name, source_path = nil)
-          return if source_path.nil?
-
-          @writer.add_file(source_path, name)
+          if source_path
+            @writer.add_file(source_path, name)
+          else
+            @writer.add_directory_entry(name)
+          end
         end
 
         def add_data(name, data)

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.rb

@@ -10,6 +10,9 @@ module Omnizip
     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

data/lib/omnizip/buffer/seven_zip_bridge.rb

@@ -123,7 +123,11 @@ module Omnizip
             @entry = entry
             @reader = reader
             @tmp = tmp
-            @name = entry.is_dir ? "#{entry.name}/" : entry.name
+            @name = if entry.is_dir
+                      entry.name.end_with?("/") ? entry.name : "#{entry.name}/"
+                    else
+                      entry.name
+                    end
             @size = entry.size
           end
 

data/lib/omnizip/commands/archive_create_command.rb

@@ -34,6 +34,15 @@ module Omnizip
       # @param output_file [String] Path to output archive
       # @param inputs [Array<String>] Paths to files/directories to archive
       # @return [void]
+      # Execute the archive create command.
+      #
+      # Routes through the Archive facade: the handler registry
+      # picks each format's writer and applies its option semantics,
+      # so this command only translates CLI vocabulary and reports.
+      #
+      # @param output_file [String] Path to output archive
+      # @param inputs [Array<String>] Paths to files/directories to archive
+      # @return [void]
       def run(output_file, *inputs)
         validate_inputs(output_file, inputs)
 
@@ -44,220 +53,126 @@ module Omnizip
           opts = apply_profile(first_file, opts)
         end
 
-        # Determine format from extension or --format option
-        format = opts[:format] || detect_format(output_file)
-
-        if format == "rar"
-          create_rar_archive(output_file, inputs, opts)
-        else
-          create_7z_archive(output_file, inputs, opts)
-        end
-      end
-
-      private
-
-      def detect_format(filename)
-        case File.extname(filename).downcase
-        when ".rar" then "rar"
-        else "7z"
-        end
-      end
-
-      def create_rar_archive(output_file, inputs, opts)
-        version = opts[:rar_version] || 5
-        compression = (opts[:rar_compression] || "store").to_sym
-        level = opts[:level] || 3
-        include_mtime = opts[:include_mtime] || false
-        include_crc32 = opts[:include_crc32] || false
-        solid = opts[:solid] || false
-        multi_volume = opts[:multi_volume] || false
-        volume_size = opts[:volume_size]
-        volume_naming = opts[:volume_naming] || "part"
-        password = opts[:password]
-        kdf_iterations = opts[:kdf_iterations] || 262_144
-        recovery = opts[:recovery] || false
-        recovery_percent = opts[:recovery_percent] || 5
+        format = (opts[:format] || detect_format(output_file)).to_sym
+        handler_opts = handler_options(format, opts)
         verbose = opts[:verbose] || false
 
-        if verbose
-          CliOutputFormatter.verbose_puts(
-            "Creating RAR#{version} archive: #{output_file}",
-            true,
-          )
-          CliOutputFormatter.verbose_puts(
-            "Compression: #{compression}, Level: #{level}",
-            true,
-          )
-          CliOutputFormatter.verbose_puts(
-            "Include mtime: #{include_mtime}, Include CRC32: #{include_crc32}",
-            true,
-          )
-          if solid
-            CliOutputFormatter.verbose_puts(
-              "Solid compression: enabled",
-              true,
-            )
-          end
-          if multi_volume && volume_size
-            CliOutputFormatter.verbose_puts(
-              "Multi-volume: enabled (size: #{volume_size}, naming: #{volume_naming})",
-              true,
-            )
-          end
-          if password
-            CliOutputFormatter.verbose_puts(
-              "Encryption: enabled (AES-256-CBC, KDF iterations: #{kdf_iterations})",
-              true,
-            )
-          end
-          if recovery
-            CliOutputFormatter.verbose_puts(
-              "PAR2 recovery: enabled (redundancy: #{recovery_percent}%)",
-              true,
-            )
-          end
-        end
+        announce(output_file, format, handler_opts, opts, verbose)
 
         start_time = Time.now
 
-        # Format-agnostic options; Formats::Rar applies the
-        # version-specific semantics
-        writer_opts = {
-          version: version,
-          compression: compression,
-          level: level,
-          include_mtime: include_mtime,
-          include_crc32: include_crc32,
-          solid: solid,
-          multi_volume: multi_volume,
-          volume_size: volume_size,
-          volume_naming: volume_naming,
-          password: password,
-          kdf_iterations: kdf_iterations,
-          recovery: recovery,
-          recovery_percent: recovery_percent,
-        }.compact
-
-        result_files = Omnizip::Formats::Rar.create(output_file,
-                                                    writer_opts) do |rar|
+        Omnizip::Archive.create(output_file, format: format,
+                                             **handler_opts) do |archive|
           inputs.each do |input|
             if File.directory?(input)
               CliOutputFormatter.verbose_puts(
                 "Adding directory: #{input}",
                 verbose,
               )
-              # Strip the parent so the tree lands under its own
-              # name, matching the .7z creation behavior
-              rar.add_directory(input, File.dirname(input))
+              archive.add_directory(input)
             else
               CliOutputFormatter.verbose_puts(
                 "Adding file: #{input}",
                 verbose,
               )
-              rar.add_file(input)
+              archive.add_file(input)
             end
           end
         end
 
         elapsed = Time.now - start_time
-
-        # Handle result based on whether recovery or multi-volume is enabled
-        files = result_files.is_a?(Array) ? result_files : [result_files]
-        files.find { |f| f.end_with?(".rar") } || files.first
-        archive_size = files.sum { |f| File.size(f) }
+        archive_size = calculate_archive_size(output_file,
+                                              handler_opts[:volume_size])
 
         if verbose
           puts ""
           puts "Archive created successfully"
-          if files.size > 1
-            puts "Files created: #{files.size}"
-            puts "  Archive volumes: #{files.count { |f| f.end_with?('.rar') }}"
-            if recovery
-              puts "  PAR2 files: #{files.count { |f| f.include?('.par2') }}"
-            end
+          if handler_opts[:volume_size]
             puts "Total size: #{format_bytes(archive_size)}"
+            puts "Volumes: #{count_volumes(output_file)}"
           else
             puts "Archive size: #{format_bytes(archive_size)}"
           end
           puts "Time elapsed: #{elapsed.round(2)}s"
-        elsif files.size == 1
-          puts "Created: #{files.first}"
         else
-          puts "Created: #{files.size} files (#{files.count do |f|
-            f.end_with?('.rar')
-          end} volumes)"
+          puts "Created: #{output_file}"
         end
       end
 
-      def create_7z_archive(output_file, inputs, opts)
-        algorithm = (opts[:algorithm] || "lzma2").to_sym
-        level = opts[:level] || 5
-        solid = opts.fetch(:solid, true)
-        verbose = opts[:verbose] || false
-        filters = parse_filters(opts[:filters])
-        volume_size = parse_volume_size(opts[:volume_size])
-        password = opts[:password]
-        encrypt_headers = opts[:encrypt_headers] || false
-        preserve_ntfs_streams = opts[:preserve_ntfs_streams] || false
+      private
 
-        if verbose
+      def detect_format(filename)
+        case File.extname(filename).downcase
+        when ".rar" then :rar
+        else :seven_zip
+        end
+      end
+
+      # Translate the format-agnostic CLI vocabulary into the option
+      # keywords each format's writer understands; nil values drop
+      def handler_options(format, opts)
+        case format
+        when :rar
+          rar_options(opts)
+        else
+          seven_zip_options(opts)
+        end
+      end
+
+      def rar_options(opts)
+        {
+          version: opts[:rar_version],
+          compression: opts[:rar_compression]&.to_sym,
+          level: opts[:level],
+          include_mtime: opts[:include_mtime],
+          include_crc32: opts[:include_crc32],
+          solid: opts[:solid],
+          multi_volume: opts[:multi_volume],
+          volume_size: opts[:volume_size],
+          volume_naming: opts[:volume_naming],
+          password: opts[:password],
+          kdf_iterations: opts[:kdf_iterations],
+          recovery: opts[:recovery],
+          recovery_percent: opts[:recovery_percent],
+        }.compact
+      end
+
+      def seven_zip_options(opts)
+        {
+          algorithm: (opts[:algorithm] || "lzma2").to_sym,
+          level: opts[:level] || 5,
+          solid: opts.fetch(:solid, true),
+          filters: parse_filters(opts[:filters]),
+          volume_size: parse_volume_size(opts[:volume_size]),
+          password: opts[:password],
+          encrypt_headers: opts[:encrypt_headers] || false,
+        }.compact
+      end
+
+      def announce(output_file, format, handler_opts, _opts, verbose)
+        return unless verbose
+
+        CliOutputFormatter.verbose_puts(
+          "Creating archive: #{output_file}",
+          true,
+        )
+        CliOutputFormatter.verbose_puts(
+          "Format: #{format == :rar ? "RAR#{handler_opts[:version] || 5}" : '7z'}, " \
+          "Algorithm: #{handler_opts[:algorithm] || handler_opts[:compression]}, " \
+          "Level: #{handler_opts[:level]}, Solid: #{handler_opts[:solid]}",
+          true,
+        )
+        if handler_opts[:volume_size]
           CliOutputFormatter.verbose_puts(
-            "Creating archive: #{output_file}",
+            "Volume size: #{format_bytes(handler_opts[:volume_size])}",
             true,
           )
+        end
+        if handler_opts[:password]
           CliOutputFormatter.verbose_puts(
-            "Algorithm: #{algorithm}, Level: #{level}, " \
-            "Solid: #{solid}",
+            "Encryption: enabled",
             true,
           )
-          if volume_size
-            CliOutputFormatter.verbose_puts(
-              "Volume size: #{format_bytes(volume_size)}",
-              true,
-            )
-          end
-          unless filters.empty?
-            CliOutputFormatter.verbose_puts(
-              "Filters: #{filters.join(', ')}",
-              true,
-            )
-          end
-          if encrypt_headers
-            CliOutputFormatter.verbose_puts(
-              "Header encryption: enabled",
-              true,
-            )
-          end
-          if preserve_ntfs_streams && Omnizip::Platform.supports_ntfs_streams?
-            CliOutputFormatter.verbose_puts(
-              "NTFS streams: preserving",
-              true,
-            )
-          end
-        end
-
-        start_time = Time.now
-
-        create_7z_archive_writer(output_file, inputs, algorithm, level, solid,
-                                 filters, volume_size, password, encrypt_headers,
-                                 preserve_ntfs_streams, verbose)
-
-        elapsed = Time.now - start_time
-
-        archive_size = calculate_archive_size(output_file, volume_size)
-
-        if verbose
-          puts ""
-          puts "Archive created successfully"
-          if volume_size
-            puts "Total size: #{format_bytes(archive_size)}"
-            puts "Volumes: #{count_volumes(output_file)}"
-          else
-            puts "Archive size: #{format_bytes(archive_size)}"
-          end
-          puts "Time elapsed: #{elapsed.round(2)}s"
-        else
-          puts "Created: #{output_file}"
         end
       end
 
@@ -289,44 +204,6 @@ module Omnizip
         filter_str.split(",").map(&:strip).map(&:to_sym)
       end
 
-      def create_7z_archive_writer(output_file, inputs, algorithm, level, solid,
-                         filters, volume_size, password, encrypt_headers,
-                         _preserve_ntfs_streams, verbose)
-        writer_opts = {
-          algorithm: algorithm,
-          level: level,
-          solid: solid,
-          filters: filters,
-        }
-        writer_opts[:volume_size] = volume_size if volume_size
-        writer_opts[:password] = password if password
-        writer_opts[:encrypt_headers] = encrypt_headers if encrypt_headers
-
-        writer = Formats::SevenZip::Writer.new(output_file, writer_opts)
-
-        inputs.each do |input|
-          if File.directory?(input)
-            CliOutputFormatter.verbose_puts(
-              "Adding directory: #{input}",
-              verbose,
-            )
-            writer.add_directory(input)
-          else
-            CliOutputFormatter.verbose_puts(
-              "Adding file: #{input}",
-              verbose,
-            )
-            writer.add_file(input)
-          end
-        end
-
-        CliOutputFormatter.verbose_puts("Writing archive...", verbose)
-        writer.write
-      rescue StandardError => e
-        raise Omnizip::CompressionError,
-              "Failed to create archive: #{e.message}"
-      end
-
       def format_bytes(bytes)
         units = %w[B KB MB GB]
         size = bytes.to_f

data/lib/omnizip/commands/decompress_command.rb

@@ -80,7 +80,7 @@ module Omnizip
         end
       end
 
-      ARCHIVE_EXTENSIONS = %w[.zip .7z .tar .rar .cpio .iso].freeze
+      ARCHIVE_EXTENSIONS = %w[.zip .7z .tar .rar .cpio .iso .rpm .xar .msi].freeze
 
       private
 

data/lib/omnizip/convenience.rb

@@ -236,7 +236,7 @@ module Omnizip
     # creation raises truthfully instead (the format-level writers
     # exist for CPIO/ISO but are not part of the archive API; RAR
     # moved to the writable routes when its handler gained create).
-    READ_ONLY_FORMAT_EXTENSIONS = [".iso", ".cpio"].freeze
+    READ_ONLY_FORMAT_EXTENSIONS = %w[.iso .cpio .rpm .xar .msi].freeze
 
     # Extensions whose format has a READ-ONLY handler: extraction and
     # listing route to it, while creation keeps raising.
@@ -244,6 +244,9 @@ module Omnizip
       ".rar" => :rar,
       ".cpio" => :cpio,
       ".iso" => :iso,
+      ".rpm" => :rpm,
+      ".xar" => :xar,
+      ".msi" => :ole,
     }.freeze
 
     # Extension -> single-file decompressor (stream interface).

data/lib/omnizip/formats/rar/writer.rb

@@ -184,7 +184,9 @@ module Omnizip
             warn "RAR4 writer ignores volume_size: not implemented " \
                  "(no corresponding flag is written)"
           end
-          return unless @options[:recovery]&.to_i&.positive?
+          recovery = @options[:recovery]
+          return unless recovery.is_a?(Numeric) && recovery.positive?
+          return if recovery == true
 
           warn "RAR4 writer ignores recovery: not implemented " \
                "(no corresponding flag is written)"

data/lib/omnizip/formats/seven_zip/writer.rb

@@ -37,6 +37,16 @@ module Omnizip
           }.merge(options)
           @collector = FileCollector.new
           @entries = []
+
+          # Preprocessing filters are decode-side only: the write
+          # path does not apply them, so say so instead of silently
+          # ignoring the option
+          filters = @options[:filters]
+          return unless filters && !filters.empty?
+
+          warn "omnizip: the 7z writer does not apply filters " \
+               "(#{Array(filters).join(', ')}); writing unfiltered data. " \
+               "Filters apply when reading archives that contain them."
         end
 
         def add_file(file_path, archive_path = nil)
@@ -75,7 +85,9 @@ module Omnizip
         # @return [self]
         def add_directory_entry(archive_path)
           entry = Models::FileEntry.new
-          entry.name = archive_path.chomp("/")
+          # Trailing slash is preserved: explicit directory entries
+          # carry it ("testdir/"), matching the collector's tree walk
+          entry.name = archive_path
           entry.source_path = nil
           entry.size = 0
           entry.is_dir = true

data/lib/omnizip/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Omnizip
-  VERSION = "0.3.47"
+  VERSION = "0.3.49"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omnizip
 version: !ruby/object:Gem::Version
-  version: 0.3.47
+  version: 0.3.49
 platform: ruby
 authors:
 - Ribose Inc.
@@ -327,9 +327,12 @@ files:
 - lib/omnizip/archive_handlers.rb
 - lib/omnizip/archive_handlers/cpio_handler.rb
 - lib/omnizip/archive_handlers/iso_handler.rb
+- lib/omnizip/archive_handlers/ole_handler.rb
 - lib/omnizip/archive_handlers/rar_handler.rb
+- lib/omnizip/archive_handlers/rpm_handler.rb
 - lib/omnizip/archive_handlers/seven_zip_handler.rb
 - lib/omnizip/archive_handlers/tar_handler.rb
+- lib/omnizip/archive_handlers/xar_handler.rb
 - lib/omnizip/archive_handlers/zip_handler.rb
 - lib/omnizip/buffer.rb
 - lib/omnizip/buffer/memory_archive.rb