omnizip 0.3.50 → 0.3.52

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6aa49d6ab2a370eda775a80206da80220936025ece39c3e121471815b309adbd
-  data.tar.gz: 60ab5eb1c7bcd3243f71aed658a85e84b2b37a02d061bf09156f0dd82c18d536
+  metadata.gz: 8002bf03f99715929f352dfb92a91a10d02f6dac7152006a6cb87ca20b3647ae
+  data.tar.gz: b095258b0b0af358ae9c0a21482a6f8b29de1620bb2162d64dd8794f29eb8f59
 SHA512:
-  metadata.gz: 8e4cc8c3b167c07112ad5f45f3a870eb24b8ffd946cc7f9fe6c4b10bfe376e7efc5a0c975287027646d9bc7aef3f419e67eb1bd40e38824eb3e93219a3f78603
-  data.tar.gz: 7fe55f7e975c40eff0c2109167a0e23fa99f11949489a29f7555632a340b3ea16983091f09bfa6cd948e3351501fd66fb438d3ad90a40953ef514721fc0138f0
+  metadata.gz: 527be0108ee0fa63b6e7ebafdeaafd05430a17c08e0d59b0f731db7a3b76401da96daec205947c7c3b5baa07aba886515959513ef3d4b31438889761219e958d
+  data.tar.gz: e1f8665f545fc81a4459cbdffbb9e5d5aca219a177a5b2d2ac3bd47c589a2ceb11b02d8cfdc748ac39381417f12682bf53cf14105dcbcd3d04bd59b77d7f9e87

data/CHANGELOG.md

@@ -7,6 +7,46 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.51] - 2026-09-01
+
+### Changed
+- Profile resolution lives in one place: `Omnizip::Profile` gains
+  `resolve`, `apply`, and `first_file_among`, and the convenience
+  methods plus the `archive create` command collapse onto them. The
+  two prior copies had drifted — the command only accepted `"auto"`
+  strings and could not pass a `CompressionProfile` through.
+- Both direct converter strategies (ZIP↔7z) now extract through
+  `Omnizip.extract_archive` and write through a shared
+  `ConversionStrategy#repack_tree` on the Archive facade — they were
+  the last library code instantiating format readers/writers
+  directly, and the 7z→ZIP path required `#open` against the
+  reader-always-usable invariant.
+- `create_rar` routes through the RAR handler (unrar-verified) with
+  the generic writer block interface; its stale "requires RAR
+  license" docstring is gone. `decompress_file`'s three-arm case
+  with magic `:xz`/`:zstandard` markers becomes a
+  `SINGLE_FILE_DECOMPRESSORS` table mirroring the compressor table.
+
+### Fixed
+- macOS CI failed at setup from 2026-09-01: Homebrew disabled the
+  `rar` cask (Gatekeeper check), breaking `brew install rar`. The
+  workflow now installs it separately and non-fatally, like the
+  Windows branch already did for winrar; RAR interop specs skip
+  when unrar is absent.
+
+## [0.3.50] - 2026-08-31
+
+### Added
+- The conversion matrix is closed: `Omnizip::Converter.convert` now
+  converts any routed source format (ZIP, 7z, TAR, RAR, cpio, ISO,
+  RPM, XAR, MSI) into any writable target format (ZIP, 7z, TAR,
+  RAR) through a new extract-and-repack strategy built on the
+  handler registry. The documented RAR→ZIP and TAR→7z pairs
+  previously had no strategy behind them — `Converter.supported?`
+  answered false for conversions the README promised. The direct
+  ZIP↔7z strategies keep precedence, so entry-copying conversions
+  don't take the repack detour.
+
 ## [0.3.49] - 2026-08-31
 
 ### Added

data/lib/omnizip/archive_handlers/seven_zip_handler.rb

@@ -31,7 +31,7 @@ module Omnizip
             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 }
+                mtime: e.mtime, crc: e.crc }
             end
           else
             entries.map(&:name)

data/lib/omnizip/cli/output_formatter.rb

@@ -44,19 +44,27 @@ module Omnizip
         ].join("\n")
       end
 
-      # Format file size in human-readable format.
+      # Format file size in human-readable format. This is THE byte
+      # formatter — commands, the CLI, and display-oriented models
+      # delegate here instead of carrying private copies.
       #
-      # @param bytes [Integer] Size in bytes
-      # @return [String] Formatted size
+      # @param bytes [Integer, nil] Size in bytes
+      # @return [String] Formatted size ("512 B", "1.5 KB", "2.0 MB")
       def format_size(bytes)
+        return "0 B" if bytes.nil? || bytes.zero?
+
         units = %w[B KB MB GB TB]
-        return "0 B" if bytes.zero?
+        size = bytes.to_f
+        unit_index = 0
+
+        while size >= 1024.0 && unit_index < units.size - 1
+          size /= 1024.0
+          unit_index += 1
+        end
 
-        exp = (Math.log(bytes) / Math.log(1024)).floor
-        exp = [exp, units.length - 1].min
+        return format("%d B", bytes) if unit_index.zero?
 
-        size = (bytes.to_f / (1024**exp)).round(2)
-        "#{size} #{units[exp]}"
+        format("%.1f %s", size, units[unit_index])
       end
 
       # Format error message for display.

data/lib/omnizip/cli.rb

@@ -60,13 +60,7 @@ module Omnizip
     # @param bytes [Integer] the byte count
     # @return [String] human-readable size (e.g. "1.5 MB")
     def format_bytes(bytes)
-      return "0 B" if bytes.zero?
-
-      units = %w[B KB MB GB TB]
-      exp = (Math.log(bytes) / Math.log(1024)).to_i
-      exp = [exp, units.size - 1].min
-
-      "%.1f %s" % [bytes.to_f / (1024**exp), units[exp]]
+      Omnizip::CliOutputFormatter.format_size(bytes)
     end
   end
 

data/lib/omnizip/commands/archive_create_command.rb

@@ -47,11 +47,7 @@ module Omnizip
         validate_inputs(output_file, inputs)
 
         # Apply profile settings if specified
-        opts = options.dup
-        if opts[:profile]
-          first_file = find_first_file(inputs)
-          opts = apply_profile(first_file, opts)
-        end
+        opts = Omnizip::Profile.apply(options, paths: inputs)
 
         format = (opts[:format] || detect_format(output_file)).to_sym
         handler_opts = handler_options(format, opts)
@@ -205,49 +201,7 @@ module Omnizip
       end
 
       def format_bytes(bytes)
-        units = %w[B KB MB GB]
-        size = bytes.to_f
-        unit_idx = 0
-
-        while size >= 1024 && unit_idx < units.length - 1
-          size /= 1024.0
-          unit_idx += 1
-        end
-
-        format("%.2f %s", size, units[unit_idx])
-      end
-
-      def apply_profile(file_path, options)
-        profile_spec = options.delete(:profile)
-        return options unless profile_spec
-
-        # Get the profile
-        profile = case profile_spec
-                  when "auto"
-                    file_path ? Omnizip::Profile.detect(file_path) : Omnizip::Profile.get(:balanced)
-                  else
-                    Omnizip::Profile.get(profile_spec.to_sym) || Omnizip::Profile.get(:balanced)
-                  end
-
-        # Apply profile to options
-        profile.apply_to(options)
-      end
-
-      def find_first_file(inputs)
-        inputs.each do |input|
-          return input if File.file?(input)
-
-          # Check directories for first file
-          if File.directory?(input)
-            Dir.foreach(input) do |entry|
-              next if [".", ".."].include?(entry)
-
-              full_path = File.join(input, entry)
-              return full_path if File.file?(full_path)
-            end
-          end
-        end
-        nil
+        Omnizip::CliOutputFormatter.format_size(bytes)
       end
 
       def parse_volume_size(size_str)

data/lib/omnizip/commands/archive_extract_command.rb

@@ -135,17 +135,10 @@ module Omnizip
       end
 
       def extract_with_patterns(archive_file, output_dir, verbose)
-        # Determine archive type and open appropriately
-        archive = case File.extname(archive_file).downcase
-                  when ".zip"
-                    Omnizip::Zip::File.open(archive_file)
-                  when ".rar"
-                    Formats::Rar::Reader.new(archive_file).open
-                  when ".tar"
-                    Formats::Tar::Reader.new(archive_file).read
-                  else
-                    Formats::SevenZip::Reader.new(archive_file).open
-                  end
+        # Route through the facade: the extension routes pick each
+        # format's reader, and the reader session holds no open
+        # resources to close
+        archive = Omnizip::Archive.open(archive_file)
 
         # Build filter chain
         filter = Extraction::FilterChain.new
@@ -193,8 +186,6 @@ module Omnizip
         end
 
         extracted.size
-      ensure
-        archive.close if archive.is_a?(Omnizip::Zip::File)
       end
 
       def extract_gzip(archive_file, output_dir, verbose)

data/lib/omnizip/commands/archive_list_command.rb

@@ -157,24 +157,7 @@ module Omnizip
       end
 
       def format_bytes(bytes)
-        return "0 B" if bytes.zero?
-
-        units = %w[B KB MB GB]
-        size = bytes.to_f
-        unit_idx = 0
-
-        while size >= 1024 && unit_idx < units.length - 1
-          size /= 1024.0
-          unit_idx += 1
-        end
-
-        if size < 10
-          format("%.2f %s", size, units[unit_idx])
-        elsif size < 100
-          format("%.1f %s", size, units[unit_idx])
-        else
-          format("%.0f %s", size, units[unit_idx])
-        end
+        Omnizip::CliOutputFormatter.format_size(bytes)
       end
 
       # Helper methods to handle different entry types. Each delegates

data/lib/omnizip/commands/metadata_command.rb

@@ -54,7 +54,8 @@ module Omnizip
         %i[comment set_mtime chmod set_attribute].none? { |key| options[key] }
       end
 
-      # Read-only view for 7z archives; the edit path is zip-only
+      # Read-only view for 7z archives through the handler registry;
+      # the edit path is zip-only
       def show_seven_zip_metadata(archive_path, pattern)
         if options[:comment] || options[:set_mtime] ||
             options[:chmod] || options[:set_attribute]
@@ -62,37 +63,37 @@ module Omnizip
                 "Metadata editing is only supported for ZIP archives"
         end
 
-        reader = Omnizip::Formats::SevenZip::Reader.new(archive_path)
-        reader.open
+        entries = Omnizip.list_archive(archive_path, details: true)
 
         if pattern
-          entries = reader.list_files.select do |e|
-            File.fnmatch(pattern, e.name)
+          entries = entries.select do |entry|
+            File.fnmatch(pattern, entry[:name])
           end
           if entries.empty?
             warn "No entries match pattern: #{pattern}"
             return
           end
 
-          entries.each do |entry|
-            puts "Entry: #{entry.name}"
-            puts "  Type: #{entry.is_dir ? 'Directory' : 'File'}"
-            puts "  Size: #{format_size(entry.size)}"
-            # Per-entry packed sizes are not tracked by the parser
-            if entry.compressed_size&.positive?
-              puts "  Compressed: #{format_size(entry.compressed_size)}"
-            end
-            puts "  Modified: #{entry.mtime}" if entry.mtime
-            puts "  CRC32: 0x#{entry.crc.to_s(16).upcase}" if entry.crc
-          end
+          entries.each { |entry| show_seven_zip_entry(entry) }
         else
-          entries = reader.list_files
-          files = entries.reject(&:is_dir)
+          files = entries.reject { |entry| entry[:directory] }
           puts "Archive: #{archive_path}"
           puts "Entries: #{entries.size} " \
                "(#{files.size} files, #{entries.size - files.size} dirs)"
-          puts "Total size: #{format_size(files.sum(&:size))}"
+          puts "Total size: #{format_size(files.sum { |entry| entry[:size] })}"
+        end
+      end
+
+      def show_seven_zip_entry(entry)
+        puts "Entry: #{entry[:name]}"
+        puts "  Type: #{entry[:directory] ? 'Directory' : 'File'}"
+        puts "  Size: #{format_size(entry[:size])}"
+        # Per-entry packed sizes are not tracked by the parser
+        if entry[:compressed_size]&.positive?
+          puts "  Compressed: #{format_size(entry[:compressed_size])}"
         end
+        puts "  Modified: #{entry[:mtime]}" if entry[:mtime]
+        puts "  CRC32: 0x#{entry[:crc].to_s(16).upcase}" if entry[:crc]
       end
 
       def show_metadata(archive, pattern)
@@ -199,13 +200,7 @@ module Omnizip
       end
 
       def format_size(bytes)
-        return "0 B" if bytes.zero?
-
-        units = %w[B KB MB GB TB]
-        exp = (Math.log(bytes) / Math.log(1024)).to_i
-        exp = [exp, units.size - 1].min
-
-        "%.1f %s" % [bytes.to_f / (1024**exp), units[exp]]
+        Omnizip::CliOutputFormatter.format_size(bytes)
       end
     end
   end

data/lib/omnizip/commands/parity_create_command.rb

@@ -107,13 +107,7 @@ module Omnizip
       # @param bytes [Integer] Size in bytes
       # @return [String] Formatted size
       def format_size(bytes)
-        if bytes < 1024
-          "#{bytes} B"
-        elsif bytes < 1024 * 1024
-          "#{(bytes / 1024.0).round(1)} KB"
-        else
-          "#{(bytes / (1024.0 * 1024)).round(1)} MB"
-        end
+        Omnizip::CliOutputFormatter.format_size(bytes)
       end
     end
   end

data/lib/omnizip/convenience.rb

@@ -25,7 +25,7 @@ module Omnizip
         raise ArgumentError, "Input is a directory: #{input_path}"
       end
 
-      options = apply_profile(input_path, options) if options[:profile]
+      options = Omnizip::Profile.apply(options, paths: input_path)
 
       if options[:chunked]
         return Omnizip::Chunked.compress_file(input_path, output_path, **options)
@@ -57,30 +57,14 @@ module Omnizip
     def decompress_file(compressed_path, output_path)
       require_archive!(compressed_path)
 
-      format_class = DECOMPRESSORS[::File.extname(compressed_path).downcase]
-      unless format_class
+      decompressor = SINGLE_FILE_DECOMPRESSORS[::File.extname(compressed_path).downcase]
+      unless decompressor
         raise Omnizip::UnsupportedFormatError,
-              "decompress_file supports #{DECOMPRESSORS.keys.join(', ')}; " \
+              "decompress_file supports #{SINGLE_FILE_DECOMPRESSORS.keys.join(', ')}; " \
               "use extract_archive for archive formats"
       end
 
-      case format_class
-      when :xz
-        ::File.binwrite(output_path, Formats::Xz.decompress(compressed_path))
-      when :zstandard
-        zstd = Algorithms::Zstandard.new
-        ::File.open(compressed_path, "rb") do |input_io|
-          ::File.open(output_path, "wb") do |output_io|
-            zstd.decompress(input_io, output_io)
-          end
-        end
-      else
-        ::File.open(compressed_path, "rb") do |input_io|
-          ::File.open(output_path, "wb") do |output_io|
-            format_class.decompress_stream(input_io, output_io)
-          end
-        end
-      end
+      decompressor.call(compressed_path, output_path)
       output_path
     end
 
@@ -112,10 +96,7 @@ module Omnizip
               "individually"
       end
 
-      if options[:profile]
-        first_file = find_first_file(input_dir)
-        apply_profile(first_file, options)
-      end
+      options = Omnizip::Profile.apply(options, paths: input_dir)
 
       Omnizip::ArchiveHandler.for(resolve_archive_format(output_path, format)).create(output_path, **options) do |archive|
         add_directory_contents(archive, input_dir, "", recursive: recursive)
@@ -212,11 +193,17 @@ module Omnizip
       archive_path
     end
 
-    # Create a RAR archive (requires RAR license — see NotLicensedError).
+    # Create a RAR archive through the RAR handler. RAR5 unless
+    # +version: 4+; the block yields the same generic writer
+    # interface as +Archive.create+ (+add+/+add_data+/+add_directory+).
+    #
+    # @param archive_path [String] Path to output archive
+    # @param options [Hash] RAR writer options
+    # @return [String, Array<String>] Path(s) of the created archive
     # rubocop:disable-next Naming/BlockForwarding, Style/ArgumentsForwarding -- Ruby 3.0 compatibility
     def create_rar(archive_path, **options, &block)
       options[:version] ||= 5
-      Omnizip::Formats::Rar.create(archive_path, options, &block)
+      Omnizip::ArchiveHandler.for(:rar).create(archive_path, **options, &block)
     end
 
     # Extension -> single-file compressor map. Each lambda takes
@@ -249,18 +236,50 @@ module Omnizip
       ".msi" => :ole,
     }.freeze
 
-    # Extension -> single-file decompressor (stream interface).
-    # The Gzip/Bzip2File/Xz classes take path or stream; use the
-    # ones exposing decompress_stream for symmetry.
-    # Xz exposes a path-based decompress rather than a stream one,
-    # so it is marked specially here.
-    DECOMPRESSORS = {
-      ".gz" => Formats::Gzip,
-      ".bz2" => Formats::Bzip2File,
-      ".xz" => :xz,
-      ".lzma" => Formats::LzmaAlone,
-      ".lz" => Formats::Lzip,
-      ".zst" => :zstandard,
+    # Extension -> single-file decompressor. Each lambda takes
+    # (compressed_path, output_path) and writes the decompressed
+    # bytes; these formats are streams, not archives, so they bypass
+    # ArchiveHandler (mirrors SINGLE_FILE_COMPRESSORS). Xz exposes a
+    # path-based decompress rather than a stream one.
+    SINGLE_FILE_DECOMPRESSORS = {
+      ".gz" => lambda do |compressed, output|
+        ::File.open(compressed, "rb") do |input_io|
+          ::File.open(output, "wb") do |output_io|
+            Omnizip::Formats::Gzip.decompress_stream(input_io, output_io)
+          end
+        end
+      end,
+      ".bz2" => lambda do |compressed, output|
+        ::File.open(compressed, "rb") do |input_io|
+          ::File.open(output, "wb") do |output_io|
+            Omnizip::Formats::Bzip2File.decompress_stream(input_io, output_io)
+          end
+        end
+      end,
+      ".xz" => lambda do |compressed, output|
+        ::File.binwrite(output, Omnizip::Formats::Xz.decompress(compressed))
+      end,
+      ".lzma" => lambda do |compressed, output|
+        ::File.open(compressed, "rb") do |input_io|
+          ::File.open(output, "wb") do |output_io|
+            Omnizip::Formats::LzmaAlone.decompress_stream(input_io, output_io)
+          end
+        end
+      end,
+      ".lz" => lambda do |compressed, output|
+        ::File.open(compressed, "rb") do |input_io|
+          ::File.open(output, "wb") do |output_io|
+            Omnizip::Formats::Lzip.decompress_stream(input_io, output_io)
+          end
+        end
+      end,
+      ".zst" => lambda do |compressed, output|
+        ::File.open(compressed, "rb") do |input_io|
+          ::File.open(output, "wb") do |output_io|
+            Omnizip::Algorithms::Zstandard.new.decompress(input_io, output_io)
+          end
+        end
+      end,
     }.freeze
 
     SINGLE_FILE_COMPRESSORS = {
@@ -335,40 +354,6 @@ module Omnizip
       raise Errno::ENOENT, "Archive not found: #{archive_path}"
     end
 
-    # Apply compression profile to options.
-    def apply_profile(file_path, options)
-      profile_spec = options.delete(:profile)
-      return options unless profile_spec
-
-      profile = case profile_spec
-                when :auto
-                  file_path ? Omnizip::Profile.detect(file_path) : Omnizip::Profile.get(:balanced)
-                when Symbol
-                  Omnizip::Profile.get(profile_spec) || Omnizip::Profile.get(:balanced)
-                when Omnizip::Profile::CompressionProfile
-                  profile_spec
-                else
-                  Omnizip::Profile.get(:balanced)
-                end
-
-      profile.apply_to(options)
-    end
-
-    def find_first_file(dir_path)
-      Dir.foreach(dir_path) do |entry|
-        next if [".", ".."].include?(entry)
-
-        full_path = ::File.join(dir_path, entry)
-        return full_path if ::File.file?(full_path)
-
-        if ::File.directory?(full_path)
-          result = find_first_file(full_path)
-          return result if result
-        end
-      end
-      nil
-    end
-
     # Recursively add directory contents to an archive. The +archive+
     # argument is whatever the handler's +#create+ block yields (e.g.
     # +Omnizip::Zip::File+ or +Omnizip::Formats::Tar::Writer+) and must

data/lib/omnizip/converter/conversion_strategy.rb

@@ -60,19 +60,26 @@ module Omnizip
         @warnings
       end
 
-      # Detect format from file extension
-      # @param path [String] File path
-      # @return [Symbol] Format
-      def detect_format(path)
-        ext = File.extname(path).downcase
-        case ext
-        when ".zip"
-          :zip
-        when ".7z"
-          :seven_zip
-        else
-          raise ArgumentError, "Unknown format for file: #{path}"
+      # Repack the extracted tree under +extracted_dir+ into a new
+      # archive at +target_path+ through the Archive facade (the
+      # format is resolved from the target's extension). Directory
+      # entries are implied by file paths, matching every strategy's
+      # treatment. Returns the number of file entries written.
+      #
+      # @param extracted_dir [String] Directory of extracted entries
+      # @param write_options [Hash] Format writer options
+      # @return [Integer] Number of file entries written
+      def repack_tree(extracted_dir, **write_options)
+        count = 0
+        Omnizip::Archive.create(target_path, **write_options) do |archive|
+          Dir.glob(File.join(extracted_dir, "**", "*")).each do |path|
+            next if File.directory?(path)
+
+            archive.add_file(path, path.delete_prefix("#{extracted_dir}/"))
+            count += 1
+          end
         end
+        count
       end
 
       # Create conversion result
@@ -96,24 +103,6 @@ module Omnizip
           warnings: warnings,
         )
       end
-
-      # Check if metadata is compatible between formats
-      # @param entry [Entry] Entry to check
-      # @return [Boolean] True if fully compatible
-      def metadata_compatible?(_entry)
-        # ZIP supports most metadata
-        # 7z has limited metadata support
-        case [source_format, target_format]
-        when %i[zip seven_zip]
-          # Some metadata loss (comments, extra fields)
-          false
-        when %i[seven_zip zip]
-          # Can preserve most 7z metadata in ZIP
-          true
-        else
-          true
-        end
-      end
     end
   end
 end

data/lib/omnizip/converter/extract_repack_strategy.rb

@@ -34,18 +34,8 @@ module Omnizip
 
         Dir.mktmpdir("omnizip_convert_repack") do |tmp|
           extracted = Omnizip.extract_archive(source_path, tmp)
-
-          Omnizip::Archive.create(target_path,
-                                  format: self.class.target_format_for(target_path)) do |b|
-            Dir.glob(File.join(tmp, "**", "*")).each do |path|
-              next if File.directory?(path)
-
-              b.add_file(path, path.delete_prefix("#{tmp}/"))
-            end
-          end
-
-          entry_count = extracted.size
-          create_result(start_time, entry_count)
+          repack_tree(tmp)
+          create_result(start_time, extracted.size)
         end
       end
 

data/lib/omnizip/converter/seven_zip_to_zip_strategy.rb

@@ -11,20 +11,9 @@ module Omnizip
       def convert
         start_time = Time.now
 
-        reader = Omnizip::Formats::SevenZip::Reader.new(source_path)
-        reader.open
-        entry_count = reader.list_files.size
-
-        Dir.mktmpdir("omnizip_convert") do |tmp|
-          reader.extract_all(tmp)
-
-          writer = Omnizip::Formats::Zip::Writer.new(target_path)
-          Dir.glob(File.join(tmp, "**", "*")).each do |path|
-            next if File.directory?(path)
-
-            writer.add_file(path, path.delete_prefix("#{tmp}/"))
-          end
-          writer.write
+        entry_count = Dir.mktmpdir("omnizip_convert") do |tmp|
+          Omnizip.extract_archive(source_path, tmp)
+          repack_tree(tmp)
         end
 
         create_result(start_time, entry_count)

data/lib/omnizip/converter/zip_to_seven_zip_strategy.rb

@@ -10,22 +10,11 @@ module Omnizip
       # @return [ConversionResult] Conversion result
       def convert
         start_time = Time.now
-        entry_count = 0
 
-        Dir.mktmpdir("omnizip_convert_zip") do |tmp|
-          # Extract the ZIP through the native reader; directories are
-          # implied by extracted file paths
-          Omnizip::Formats::Zip.extract(source_path, tmp)
-
-          writer = Omnizip::Formats::SevenZip::Writer.new(target_path,
-                                                          writer_options)
-          Dir.glob(File.join(tmp, "**", "*")).each do |path|
-            next if File.directory?(path)
-
-            entry_count += 1
-            writer.add_file(path, path.delete_prefix("#{tmp}/"))
-          end
-          writer.write
+        entry_count = Dir.mktmpdir("omnizip_convert_zip") do |tmp|
+          # Directories are implied by extracted file paths
+          Omnizip.extract_archive(source_path, tmp)
+          repack_tree(tmp, **writer_options)
         end
 
         create_result(start_time, entry_count)

data/lib/omnizip/extraction/selective_extractor.rb

@@ -33,7 +33,10 @@ module Omnizip
         FileUtils.mkdir_p(dest)
         extracted = []
 
-        entries_to_extract = list_matches
+        # Directory entries carry no content to extract
+        entries_to_extract = list_matches.reject do |entry|
+          entry_filename(entry).end_with?("/")
+        end
         total = entries_to_extract.size
         current = 0
 
@@ -162,7 +165,7 @@ module Omnizip
           entry.get_input_stream.read
         # allowed: some archives read entry content from the archive
         elsif @archive.respond_to?(:read)
-          @archive.read(entry)
+          @archive.read(entry_filename(entry))
         else
           raise Error, "Cannot read entry content"
         end
@@ -191,10 +194,19 @@ module Omnizip
 
       # Get filename from entry
       #
-      # @param entry [#entry_name] Entry (Omnizip::Entry or compatible)
+      # @param entry [#entry_name, #name] Entry (legacy Omnizip::Entry,
+      #   Archive::Entry from a reader session, or compatible)
       # @return [String] Filename
       def entry_filename(entry)
-        entry.entry_name || entry.to_s
+        # allowed: entries come from a caller-supplied archive
+        if entry.respond_to?(:entry_name)
+          entry.entry_name
+        # allowed: reader-session entries expose name, not entry_name
+        elsif entry.respond_to?(:name)
+          entry.name
+        else
+          entry.to_s
+        end
       end
 
       # Update progress tracker

data/lib/omnizip/models/conversion_result.rb

@@ -122,13 +122,7 @@ module Omnizip
       end
 
       def format_size(bytes)
-        return "0 B" if bytes.zero?
-
-        units = %w[B KB MB GB TB]
-        exp = (Math.log(bytes) / Math.log(1024)).to_i
-        exp = [exp, units.size - 1].min
-
-        "%.1f %s" % [bytes.to_f / (1024**exp), units[exp]]
+        Omnizip::CliOutputFormatter.format_size(bytes)
       end
     end
   end

data/lib/omnizip/parity/par2_creator.rb

@@ -161,40 +161,6 @@ progress: nil)
         Digest::MD5.digest("#{Time.now.to_f}#{rand}")
       end
 
-      # Analyze file and calculate hashes
-      #
-      # @param file_path [String] Path to file
-      # @return [FileInfo] File information
-      def analyze_file(file_path)
-        File.open(file_path, "rb") do |io|
-          file_size = io.size
-
-          # Calculate hash of first 16KB
-          first_16k = io.read(16384) || ""
-          hash_16k = Digest::MD5.digest(first_16k)
-
-          # Calculate full file hash
-          io.rewind
-          hash_full = Digest::MD5.file(file_path).digest
-
-          # Generate file ID
-          file_id = Digest::MD5.digest("#{File.basename(file_path)}#{file_size}")
-
-          # Read file blocks
-          io.rewind
-          blocks = read_file_blocks(io)
-
-          FileInfo.new(
-            path: file_path,
-            file_id: file_id,
-            hash_16k: hash_16k,
-            hash_full: hash_full,
-            size: file_size,
-            blocks: blocks,
-          )
-        end
-      end
-
       # Read file data into blocks
       #
       # @param io [IO] File IO object

data/lib/omnizip/parity/par2_verifier.rb

@@ -69,6 +69,11 @@ module Omnizip
       # @param par2_file [String] Path to .par2 index file
       # @raise [ArgumentError] if file doesn't exist
       def initialize(par2_file)
+        if par2_file.nil?
+          raise ArgumentError,
+                "PAR2 file is nil — no index .par2 was produced for this set"
+        end
+
         raise ArgumentError, "PAR2 file not found: #{par2_file}" unless
           File.exist?(par2_file)
 

data/lib/omnizip/profile.rb

@@ -108,6 +108,62 @@ module Omnizip
         detector.detect(file_path, options)
       end
 
+      # Resolve a profile specification into a concrete profile.
+      # +:auto+ (or "auto") samples +first_file+ through detection and
+      # falls back to +:balanced+ without one; a CompressionProfile
+      # passes through unchanged; anything else names a registered
+      # profile, falling back to +:balanced+ when unknown.
+      #
+      # @param spec [Symbol, String, CompressionProfile] Profile spec
+      # @param first_file [String, nil] Sampling file for :auto
+      # @return [CompressionProfile] Resolved profile
+      def resolve(spec, first_file: nil)
+        case spec
+        when :auto, "auto"
+          first_file ? detect(first_file) : registry.get(:balanced)
+        when CompressionProfile
+          spec
+        else
+          registry.get(spec.to_sym) || registry.get(:balanced)
+        end
+      end
+
+      # Resolve and apply the +:profile+ entry of +options+ into
+      # concrete compression settings. +:auto+ profiles sample the
+      # first readable file at or below +paths+. Returns a new
+      # options hash; +options+ itself is left untouched.
+      #
+      # @param options [Hash] Compression options carrying :profile
+      # @param paths [String, Array<String>] Inputs to sample
+      # @return [Hash] Options with the profile applied and removed
+      def apply(options, paths: [])
+        options = options.dup
+        spec = options.delete(:profile)
+        return options unless spec
+
+        resolve(spec, first_file: first_file_among(paths)).apply_to(options)
+      end
+
+      # The first regular file at or below any of +paths+ — the
+      # sampling target for +:auto+ profiles — or nil when nothing
+      # readable exists.
+      #
+      # @param paths [String, Array<String>] Files or directories
+      # @return [String, nil] Path of the first file found
+      def first_file_among(paths)
+        Array(paths).each do |path|
+          next unless ::File.exist?(path)
+
+          return path if ::File.file?(path)
+
+          if ::File.directory?(path)
+            found = first_file_within(path)
+            return found if found
+          end
+        end
+        nil
+      end
+
       # Get the profile detector
       #
       # @return [ProfileDetector] The detector instance
@@ -125,6 +181,22 @@ module Omnizip
 
       private
 
+      # Depth-first search for the first regular file under +dir+.
+      def first_file_within(dir)
+        ::Dir.foreach(dir) do |entry|
+          next if [".", ".."].include?(entry)
+
+          full_path = ::File.join(dir, entry)
+          return full_path if ::File.file?(full_path)
+
+          if ::File.directory?(full_path)
+            found = first_file_within(full_path)
+            return found if found
+          end
+        end
+        nil
+      end
+
       # Register all built-in profiles
       #
       # @param registry [ProfileRegistry] Registry to populate

data/lib/omnizip/profiler/report_generator.rb

@@ -145,18 +145,7 @@ module Omnizip
       end
 
       def format_bytes(bytes)
-        return "0 B" if bytes.nil? || bytes.zero?
-
-        units = %w[B KB MB GB]
-        size = bytes.to_f
-        unit_index = 0
-
-        while size >= 1024.0 && unit_index < units.size - 1
-          size /= 1024.0
-          unit_index += 1
-        end
-
-        format("%.2f %s", size, units[unit_index])
+        Omnizip::CliOutputFormatter.format_size(bytes)
       end
 
       def truncate(string, max_length)

data/lib/omnizip/profiler.rb

@@ -186,18 +186,7 @@ module Omnizip
     end
 
     def format_bytes(bytes)
-      return "0 B" if bytes.zero?
-
-      units = %w[B KB MB GB]
-      size = bytes.to_f
-      unit_index = 0
-
-      while size >= 1024.0 && unit_index < units.size - 1
-        size /= 1024.0
-        unit_index += 1
-      end
-
-      format("%.2f %s", size, units[unit_index])
+      Omnizip::CliOutputFormatter.format_size(bytes)
     end
   end
 end

data/lib/omnizip/temp/safe_extract.rb

@@ -79,37 +79,9 @@ module Omnizip
       private
 
       def extract_to_temp(temp_dir)
-        # Detect archive format and extract
-        case detect_format
-        when :zip
-          extract_zip(temp_dir)
-        when :seven_zip
-          extract_7z(temp_dir)
-        else
-          raise Omnizip::UnsupportedFormatError,
-                "Unknown archive format: #{@archive_path}"
-        end
-      end
-
-      def extract_zip(dest)
-        Omnizip::Zip::File.open(@archive_path) do |zip|
-          zip.each do |entry|
-            entry_path = File.join(dest, entry.name)
-
-            if entry.directory?
-              FileUtils.mkdir_p(entry_path)
-            else
-              FileUtils.mkdir_p(File.dirname(entry_path))
-              zip.extract(entry, entry_path)
-            end
-          end
-        end
-      end
-
-      def extract_7z(dest)
-        # Placeholder for 7z extraction
-        # Would use Omnizip::SevenZip::File when available
-        raise NotImplementedError, "7z extraction not yet implemented"
+        # Every routed format extracts through the handler registry,
+        # same as the convenience API
+        Omnizip.extract_archive(@archive_path, temp_dir)
       end
 
       def move_to_destination(temp_dir)
@@ -147,18 +119,6 @@ module Omnizip
         end
         count
       end
-
-      def detect_format
-        File.open(@archive_path, "rb") do |f|
-          magic = f.read(4)
-          case magic
-          when "PK\x03\x04"
-            :zip
-          when "7z\xBC\xAF"
-            :seven_zip
-          end
-        end
-      end
     end
   end
 end

data/lib/omnizip/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: omnizip
 version: !ruby/object:Gem::Version
-  version: 0.3.50
+  version: 0.3.52
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-31 00:00:00.000000000 Z
+date: 2026-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64