omnizip 0.3.39 → 0.3.41

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f86f08dba1d67ec9a22053ee355dda5d461c42d29b45134ad75a1192584d0a5
-  data.tar.gz: 31d78c577804b43509bfea9a8bc9fd5edfad4ac149752cabb0eef87eafebbf56
+  metadata.gz: 919a322870094f270bd574530af4c463b6446586fdf869026b79ad017834bc1e
+  data.tar.gz: 55507eb0b2da4109cb094e711cda2d39df10773c9774c4a01614edc0d8548d9a
 SHA512:
-  metadata.gz: f6ee4bb68ede247277420ec455130140a8be8e1f417581f1c3f996cab48d34202ae26631862ef88ef301fb712c649f72100805c6d553afce51f2705747e68e28
-  data.tar.gz: b7f3567b7f8d3c7679bbd7563fd9fabf666aa3c1fbfdff38afd0e9e2dc9034e1f78428b710f2ff72518e45eef956eeb61a679c27df6b00e2a8e81cbbc0b5eed1
+  metadata.gz: 73b03468e2bb51d227059f316ab4fce911ce19ee6e0c175559de7b1df58a69536d9284d2b5ee2a0a19366ef0c53d448d02e4b95f397042c69c569630aacea86f
+  data.tar.gz: dad012852021f331f77a36bf86842274f612d215e32829965bf4bbaf5ad8b9b17539eb7e531a55e73c93d206c73a66760ccde6dfcf234b49e371f17f79451df8

data/CHANGELOG.md

@@ -7,6 +7,108 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.40] - 2026-08-29
+
+### Fixed
+- Every CLI command now works end-to-end (each was exercised against
+  real archives and its failure fixed):
+  - `omnizip list` printed "No algorithms registered." — all builtin
+    algorithms register lazily, so the available list was empty until
+    each was first used. `AlgorithmRegistry.available` now includes
+    the builtins.
+  - `omnizip convert a.7z a.zip` crashed on a fictional reader/writer
+    API inside the conversion strategy; rewritten on the real APIs and
+    round-trips byte-identically through unzip.
+  - `omnizip archive create x.rar ...` raised NoMethodError (a
+    module-level `Formats::Rar.create` never existed). It exists now
+    (RAR5 default, `version: 4` for RAR4); directory inputs work —
+    the stale "RAR5 does not support directories" restriction is gone
+    and trees archive under their own name like `.7z`, verified with
+    unrar.
+  - `omnizip archive metadata` opened every input as a ZIP: `.7z`
+    crashed with a ZIP parse error, and runs with no edit option
+    still printed "Metadata updated successfully". 7z now shows real
+    read-only metadata, unknown formats raise truthful errors, and
+    ZIPs default to show mode when nothing is being edited.
+  - `omnizip decompress archive.zip out/` — the behavior the
+    command's own help documents — failed with "Is a directory".
+    Archive inputs (zip/7z/tar/rar/cpio/iso) and directory outputs
+    now extract through the convenience layer, content-verified with
+    diff for zip, 7z, rar, and tar.
+- Deflate64.metadata returned a raw Hash, crashing the CLI algorithm
+  table; it returns `Models::AlgorithmMetadata` like every other
+  algorithm.
+- Guides referenced a nonexistent `:zstd` algorithm-registry key;
+  corrected to `:zstandard` everywhere (the registry key differs from
+  RPM's `:zstd` compression type).
+
+### Added
+- `Omnizip::Buffer` 7z support: `create(:seven_zip)` /
+  `create_from_hash(hash, :seven_zip)`, `open`, `extract_to_memory`,
+  and `MemoryExtractor` all handle 7z through a temporary-file bridge
+  (the format has no in-memory stream implementation), including
+  explicit directory entries via a new
+  `SevenZip::Writer#add_directory_entry`. Format auto-detection fixed
+  to compare binary magic literals — UTF-8 literals never matched
+  binary data, so 7z buffers raised "Unknown archive format".
+- README gains an In-Memory Archives section (examples run verbatim).
+
+## [0.3.39] - 2026-08-28
+
+### Fixed
+- RAR4 writing was structurally fictional: HEAD_CRC used CRC-16/CCITT
+  instead of the low 16 bits of CRC32, HEAD_SIZE values excluded the
+  2-byte CRC field, a duplicate marker block followed the signature
+  (the 7-byte signature IS the marker), and file headers lacked the
+  LONG_BLOCK flag. unrar rejected every archive with "Main archive
+  header is corrupt". STORE archives now round-trip through unrar
+  byte-identically, including explicit directory entries (marked with
+  the full 0xE0 dictionary mask — proven empirically: attribute-based
+  and trailing-backslash markers do not work), empty files, and
+  nested trees. `password:` now raises `NotImplementedError` instead
+  of writing the encrypted flag with no salt; `solid:`/`recovery:`/
+  `volume_size:` warn and are never advertised in header flags.
+- RAR4 reading never parsed real WinRAR archives (the reader demanded
+  the same fictional layout the writer emitted). It now matches
+  `unrar l` exactly on libarchive fixtures — names (backslashes
+  normalized), sizes, directories, DOS timestamps — and native
+  decompression is CRC-verified before use: previously a real
+  WinRAR-compressed entry silently extracted garbage (e.g. 44308
+  bytes written for a 20111-byte file); now a CRC mismatch falls
+  back to unrar for byte-exact extraction while Omnizip-written
+  archives still decode natively.
+- RAR3 writer/reader: 6 reserved bytes in the main header (was 4),
+  LONG_BLOCK flag, high size words before the filename (was after),
+  terminator flags 0. STORE output is `unrar t`-clean. The reader
+  dropped a fictional extended-time parser that produced year-2039
+  timestamps; base DOS time (minute precision) is used.
+- RAR5 reader: mtime is a 32-bit Unix timestamp (the parser read a
+  vint plus FILETIME that do not exist in the format) and is nil
+  when the header carries none, instead of a fabricated `Time.now`.
+  Timestamps now match unrar exactly on fixtures.
+- `Formats::Rar3`/`Formats::Rar5` never loaded: the autoload
+  registry in `formats/rar.rb` pointed at files defining a different
+  namespace. Both get proper parent autoload files
+  (`formats/rar3.rb`, `formats/rar5.rb`).
+- Windows: the unrar program path was pre-wrapped in literal quotes
+  for a shell-string call form; shell-free array-form invocations
+  failed to start the program. Quotes now live only at the two
+  shell call sites, and unrar runs quietly (`-idq`).
+
+### Added
+- unrar-gated RAR4 interop spec (STORE test + byte-identical
+  extraction with directories) and real WinRAR fixture parsing specs
+  (listing + unrar-fallback extraction with CRC assertions).
+
+### Documentation
+- README RAR4/RAR5 sections rewritten to verified reality: STORE is
+  unrar-verified while `:fastest`-`:best` are Omnizip-round-trip-only
+  (previously all methods claimed "fully working"); the real writer
+  API (no `close`, no block form, `compression:` key); RAR5 "LZMA SDK
+  byte-for-byte" claims removed (the option falls back to STORE with
+  a warning). Fixed fictional `SevenZip::Writer` `close`/`algorithm=`
+  examples in the API-usage and architecture guides.
+
 ## [0.3.38] - 2026-08-28
 
 ### Added

data/README.adoc

@@ -633,6 +633,37 @@ Omnizip.extract_archive('archive.zip', 'output/')
 Omnizip.list_archive('archive.zip')
 ----
 
+==== In-Memory Archives
+
+`Omnizip::Buffer` creates and reads ZIP and 7z archives entirely in
+memory (7z bridges through a temporary file internally):
+
+[source,ruby]
+----
+require 'omnizip'
+
+# Create in memory
+buffer = Omnizip::Buffer.create(:zip) do |archive|
+  archive.add('readme.txt', 'Hello World')
+  archive.add('docs/', '')            # directory entry
+end
+
+# Same API for 7z
+buffer7z = Omnizip::Buffer.create(:seven_zip) do |archive|
+  archive.add('data.json', '{"key": "value"}')
+end
+
+# Read back (format auto-detected)
+files = Omnizip::Buffer.extract_to_memory(buffer.string)
+# => {"readme.txt" => "Hello World"}
+
+Omnizip::Buffer.open(buffer.string) do |archive|
+  archive.each_entry do |entry|
+    puts "#{entry.name}: #{entry.size} bytes" unless entry.directory?
+  end
+end
+----
+
 ==== Rubyzip Compatibility Mode
 
 [source,ruby]

data/lib/omnizip/algorithm_registry.rb

@@ -38,6 +38,13 @@ module Omnizip
         "Algorithm"
       end
 
+      # All builtin algorithms register lazily, so the plain storage
+      # keys are empty until each algorithm is first used. Listing
+      # (e.g. the CLI's `omnizip list`) must show the builtins too.
+      def available
+        (super + BUILTIN_ALGORITHMS.keys).uniq
+      end
+
       def register(name, klass)
         raise ArgumentError, "Algorithm name cannot be nil" if name.nil?
         raise ArgumentError, "Algorithm class cannot be nil" if klass.nil?

data/lib/omnizip/algorithms/deflate64.rb

@@ -28,14 +28,11 @@ module Omnizip
 
       # Algorithm metadata
       def self.metadata
-        {
-          name: "Deflate64",
-          type: :compression,
-          streaming_supported: true,
-          dictionary_size: DICTIONARY_SIZE,
-          compression_method: 9,
-          description: "Enhanced Deflate with 64KB window",
-        }
+        Models::AlgorithmMetadata.new.tap do |meta|
+          meta.name = "deflate64"
+          meta.description = "Enhanced Deflate with 64KB window"
+          meta.version = "1.0.0"
+        end
       end
 
       # Compress input stream to output stream

data/lib/omnizip/buffer/memory_extractor.rb

@@ -49,7 +49,7 @@ module Omnizip
         when :zip
           extract_all_zip(result)
         when :seven_zip, :"7z"
-          raise NotImplementedError, "7z format support coming in Phase 2"
+          extract_all_seven_zip(result)
         else
           raise ArgumentError, "Unsupported format: #{@format}"
         end
@@ -76,7 +76,7 @@ module Omnizip
         when :zip
           content = extract_entry_zip(name)
         when :seven_zip, :"7z"
-          raise NotImplementedError, "7z format support coming in Phase 2"
+          content = extract_entry_seven_zip(name)
         else
           raise ArgumentError, "Unsupported format: #{@format}"
         end
@@ -100,7 +100,7 @@ module Omnizip
         when :zip
           list_entries_zip(names)
         when :seven_zip, :"7z"
-          raise NotImplementedError, "7z format support coming in Phase 2"
+          SevenZipBridge.open(@buffer) { |archive| names.concat(archive.entry_names) }
         else
           raise ArgumentError, "Unsupported format: #{@format}"
         end
@@ -156,14 +156,14 @@ module Omnizip
       # @return [Symbol] Detected format
       # @raise [Omnizip::FormatError] If format cannot be detected
       def detect_format
-        magic = @buffer.read(4)
+        magic = @buffer.read(4).to_s.b
         @buffer.rewind
 
         case magic
-        when "PK\x03\x04", "PK\x05\x06", "PK\x07\x08"
+        when "PK\x03\x04".b, "PK\x05\x06".b, "PK\x07\x08".b
           # ZIP signatures: local file header, EOCD, data descriptor
           :zip
-        when "7z\xBC\xAF"
+        when "7z\xBC\xAF".b
           :seven_zip
         else
           raise Omnizip::FormatError,
@@ -187,6 +187,31 @@ module Omnizip
         end
       end
 
+      # Extract every file entry from 7z
+      #
+      # @param result [Hash] Hash to populate with entries
+      def extract_all_seven_zip(result)
+        @buffer.rewind
+        SevenZipBridge.open(@buffer) do |archive|
+          archive.extract_all_to_memory.each do |name, content|
+            result[name] = content
+            @extracted_cache[name] = content
+          end
+        end
+      end
+
+      # Extract single entry from 7z
+      #
+      # @param name [String] Entry name
+      # @return [String, nil] Entry content or nil if not found
+      def extract_entry_seven_zip(name)
+        @buffer.rewind
+        SevenZipBridge.open(@buffer) do |archive|
+          entry = archive.raw_entries.find { |e| e.name == name }
+          archive.extract_all_to_memory[name] if entry
+        end
+      end
+
       # Extract single entry from ZIP
       #
       # @param name [String] Entry name

data/lib/omnizip/buffer/seven_zip_bridge.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "tmpdir"
+
+module Omnizip
+  module Buffer
+    # Bridges the in-memory Buffer API onto the file-based 7z
+    # reader/writer through a temporary file, since the 7z format has
+    # no in-memory stream implementation.
+    module SevenZipBridge
+      class << self
+        # Create a 7z archive in memory
+        #
+        # @param buffer [StringIO] Destination buffer
+        # @param options [Hash] Writer options
+        # @yield [WriteProxy] Block adding entries
+        def create(buffer, options = {}, &block)
+          Dir.mktmpdir("omnizip_buffer_7z") do |tmp|
+            archive_path = File.join(tmp, "buffer.7z")
+            writer = Formats::SevenZip::Writer.new(archive_path, options)
+            block&.call(WriteProxy.new(writer))
+            writer.write
+
+            buffer.write(File.binread(archive_path))
+          end
+        end
+
+        # Read a 7z archive from memory
+        #
+        # @param buffer [StringIO] Archive bytes
+        # @yield [ReadProxy] Block reading entries
+        # @return [ReadProxy, Object] Proxy or block result
+        def open(buffer, &block)
+          Dir.mktmpdir("omnizip_buffer_7z") do |tmp|
+            archive_path = File.join(tmp, "buffer.7z")
+            File.binwrite(archive_path, buffer.string)
+
+            reader = Formats::SevenZip::Reader.new(archive_path)
+            reader.open
+            proxy = ReadProxy.new(reader, tmp)
+
+            block ? yield(proxy) : proxy
+          end
+        end
+      end
+
+      # Mirrors the MemoryArchive write interface onto a 7z writer
+      class WriteProxy
+        # @param writer [Formats::SevenZip::Writer]
+        def initialize(writer)
+          @writer = writer
+        end
+
+        # Add an entry; a trailing slash with empty content adds a
+        # directory entry
+        #
+        # @param name [String] Entry name
+        # @param data [String] Entry content
+        # @return [self]
+        def add(name, data, **_options)
+          if name.end_with?("/") && data.to_s.empty?
+            @writer.add_directory_entry(name)
+          else
+            @writer.add_data(name, data)
+          end
+          self
+        end
+      end
+
+      # Mirrors the MemoryArchive read interface onto a 7z reader
+      class ReadProxy
+        # @param reader [Formats::SevenZip::Reader] opened reader
+        # @param tmp [String] Scratch directory for extraction
+        def initialize(reader, tmp)
+          @reader = reader
+          @tmp = tmp
+        end
+
+        # Yield an Entry wrapper per archive entry
+        def each_entry
+          @reader.list_files.each do |entry|
+            yield Entry.new(entry, @reader, @tmp)
+          end
+        end
+
+        # Filename => content for every file entry
+        #
+        # @return [Hash<String, String>]
+        def extract_all_to_memory
+          result = {}
+          each_entry do |entry|
+            result[entry.name] = entry.read unless entry.directory?
+          end
+          result
+        end
+
+        # Entry names; directories keep a trailing slash like the ZIP
+        # listing convention
+        #
+        # @return [Array<String>]
+        def entry_names
+          @reader.list_files.map do |entry|
+            entry.is_dir ? "#{entry.name}/" : entry.name
+          end
+        end
+
+        # Read-only access to the underlying entries
+        #
+        # @return [Array<Formats::SevenZip::Models::FileEntry>]
+        def raw_entries
+          @reader.list_files
+        end
+
+        # Entry wrapper matching MemoryArchive::Entry's surface
+        class Entry
+          attr_reader :name, :size
+
+          # @param entry [Formats::SevenZip::Models::FileEntry]
+          # @param reader [Formats::SevenZip::Reader]
+          # @param tmp [String] Scratch directory
+          def initialize(entry, reader, tmp)
+            @entry = entry
+            @reader = reader
+            @tmp = tmp
+            @name = entry.is_dir ? "#{entry.name}/" : entry.name
+            @size = entry.size
+          end
+
+          # @return [Boolean]
+          def directory?
+            @entry.is_dir
+          end
+
+          # @return [Time, nil]
+          def time
+            @entry.mtime
+          end
+
+          # Extract and return this entry's content
+          #
+          # @return [String]
+          def read(_size = nil)
+            return "" if directory? || @entry.has_stream == false
+
+            dest = File.join(@tmp, "entry", @entry.name)
+            @reader.extract_entry(@entry.name, dest)
+            File.binread(dest)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/buffer.rb

@@ -30,6 +30,7 @@ module Omnizip
     # Nested classes - autoloaded
     autoload :MemoryArchive, "omnizip/buffer/memory_archive"
     autoload :MemoryExtractor, "omnizip/buffer/memory_extractor"
+    autoload :SevenZipBridge, "omnizip/buffer/seven_zip_bridge"
 
     class << self
       # Create archive in memory
@@ -54,7 +55,7 @@ module Omnizip
         when :zip
           create_zip(buffer, options, &block)
         when :seven_zip, :"7z"
-          raise NotImplementedError, "7z format support coming in Phase 2"
+          SevenZipBridge.create(buffer, options, &block)
         else
           raise ArgumentError, "Unsupported format: #{format}"
         end
@@ -84,7 +85,7 @@ module Omnizip
         when :zip
           open_zip(buffer, &block)
         when :seven_zip, :"7z"
-          raise NotImplementedError, "7z format support coming in Phase 2"
+          SevenZipBridge.open(buffer, &block)
         else
           raise ArgumentError, "Unsupported format: #{format}"
         end
@@ -132,14 +133,14 @@ module Omnizip
       # @return [Symbol] Detected format
       # @raise [Omnizip::FormatError] If format cannot be detected
       def detect_format(buffer)
-        magic = buffer.read(4)
+        magic = buffer.read(4).to_s.b
         buffer.rewind
 
         case magic
-        when "PK\x03\x04", "PK\x05\x06", "PK\x07\x08"
+        when "PK\x03\x04".b, "PK\x05\x06".b, "PK\x07\x08".b
           # ZIP signatures: local file header, EOCD, data descriptor
           :zip
-        when "7z\xBC\xAF"
+        when "7z\xBC\xAF".b
           :seven_zip
         else
           raise Omnizip::FormatError,

data/lib/omnizip/commands/archive_create_command.rb

@@ -120,42 +120,35 @@ module Omnizip
 
         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,
-        }
-
-        # Add solid compression for RAR5
-        writer_opts[:solid] = solid if version == 5 && solid
-
-        # Add multi-volume options for RAR5
-        if version == 5 && multi_volume && volume_size
-          writer_opts[:multi_volume] = true
-          writer_opts[:volume_size] = volume_size
-          writer_opts[:volume_naming] = volume_naming
-        end
-
-        # Add encryption options for RAR5
-        if version == 5 && password
-          writer_opts[:password] = password
-          writer_opts[:kdf_iterations] = kdf_iterations
-        end
-
-        # Add recovery options for RAR5
-        if version == 5 && recovery
-          writer_opts[:recovery] = true
-          writer_opts[:recovery_percent] = recovery_percent
-        end
+          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|
           inputs.each do |input|
             if File.directory?(input)
-              raise ArgumentError,
-                    "RAR5 writer does not support directories yet. Add individual files."
+              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))
             else
               CliOutputFormatter.verbose_puts(
                 "Adding file: #{input}",

data/lib/omnizip/commands/decompress_command.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "fileutils"
+
 #
 # Copyright (C) 2024 Ribose Inc.
 #
@@ -31,12 +33,20 @@ module Omnizip
 
       # Execute the decompress command.
       #
+      # Archives (.zip/.7z/.tar/...) extract into the output
+      # directory; single-file streams decompress to the output file.
+      #
       # @param input_file [String] Path to input file
-      # @param output_file [String] Path to output file
+      # @param output_file [String] Path to output file or directory
       # @return [void]
       def run(input_file, output_file)
         validate_inputs(input_file, output_file)
 
+        if archive_input?(input_file) || File.directory?(output_file)
+          run_archive_extract(input_file, output_file)
+          return
+        end
+
         algorithm_name = options[:algorithm] || detect_algorithm
         verbose = options[:verbose] || false
 
@@ -70,8 +80,26 @@ module Omnizip
         end
       end
 
+      ARCHIVE_EXTENSIONS = %w[.zip .7z .tar .rar .cpio .iso].freeze
+
       private
 
+      def archive_input?(path)
+        ext = File.extname(path).downcase
+        ARCHIVE_EXTENSIONS.include?(ext)
+      end
+
+      def run_archive_extract(input_file, output_dir)
+        FileUtils.mkdir_p(output_dir) unless File.directory?(output_dir)
+
+        entries = Omnizip.list_archive(input_file)
+        Omnizip.extract_archive(input_file, output_dir)
+
+        puts "Extracted #{entries.size} file(s) to: #{output_dir}"
+      rescue StandardError => e
+        raise Omnizip::IOError, "Failed to extract archive: #{e.message}"
+      end
+
       def validate_inputs(input_file, output_file)
         unless File.exist?(input_file)
           raise Omnizip::IOError, "Input file not found: #{input_file}"

data/lib/omnizip/commands/metadata_command.rb

@@ -18,19 +18,83 @@ module Omnizip
           raise Errno::ENOENT, "Archive not found: #{archive_path}"
         end
 
+        if seven_zip?(archive_path)
+          show_seven_zip_metadata(archive_path, pattern)
+          return
+        end
+
+        unless zip?(archive_path)
+          raise ArgumentError,
+                "Metadata is supported for .zip and .7z archives: " \
+                "#{archive_path}"
+        end
+
         Omnizip::Zip::File.open(archive_path) do |archive|
-          if options[:show]
+          if options[:show] || editing_nothing?
             show_metadata(archive, pattern)
           else
             edit_metadata(archive, pattern)
+            puts "Metadata updated successfully"
           end
         end
-
-        puts "Metadata updated successfully" unless options[:show]
       end
 
       private
 
+      def zip?(path)
+        path.end_with?(".zip")
+      end
+
+      def seven_zip?(path)
+        path.end_with?(".7z")
+      end
+
+      # True when no edit option was given — editing would be a no-op
+      def editing_nothing?
+        %i[comment set_mtime chmod set_attribute].none? { |key| options[key] }
+      end
+
+      # Read-only view for 7z archives; 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]
+          raise ArgumentError,
+                "Metadata editing is only supported for ZIP archives"
+        end
+
+        reader = Omnizip::Formats::SevenZip::Reader.new(archive_path)
+        reader.open
+
+        if pattern
+          entries = reader.list_files.select do |e|
+            File.fnmatch(pattern, e.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
+        else
+          entries = reader.list_files
+          files = entries.reject(&:is_dir)
+          puts "Archive: #{archive_path}"
+          puts "Entries: #{entries.size} " \
+               "(#{files.size} files, #{entries.size - files.size} dirs)"
+          puts "Total size: #{format_size(files.sum(&:size))}"
+        end
+      end
+
       def show_metadata(archive, pattern)
         if pattern
           # Show entry metadata