omnizip 0.3.39 → 0.3.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f86f08dba1d67ec9a22053ee355dda5d461c42d29b45134ad75a1192584d0a5
-  data.tar.gz: 31d78c577804b43509bfea9a8bc9fd5edfad4ac149752cabb0eef87eafebbf56
+  metadata.gz: 5013ae71553867968422f57b01425820f17c5cd6e471ea0cb5b5d46d1cc6a1bd
+  data.tar.gz: 94698e90386f195cdd7f5fd7a8ebae3010f2f206e70eb96463ce8e4d2ece09b0
 SHA512:
-  metadata.gz: f6ee4bb68ede247277420ec455130140a8be8e1f417581f1c3f996cab48d34202ae26631862ef88ef301fb712c649f72100805c6d553afce51f2705747e68e28
-  data.tar.gz: b7f3567b7f8d3c7679bbd7563fd9fabf666aa3c1fbfdff38afd0e9e2dc9034e1f78428b710f2ff72518e45eef956eeb61a679c27df6b00e2a8e81cbbc0b5eed1
+  metadata.gz: 415d4cdcb48375d0ba0d1d57dc2592c18d47fcafb9817d956dbe5a3ec7e1fa1048063372759de1ff0c0ef194d06eaa7f5855cfead144681e1fb454ac4fc510b2
+  data.tar.gz: a901b525b49f60b94098d43a5c4517f5163e07b64ef08099c02f693fc50775461c584ee35f2a6227167bbd461cfcbd9e3985b2383c586610817363170f45a2ef

data/CHANGELOG.md

@@ -7,6 +7,62 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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

@@ -154,8 +154,13 @@ module Omnizip
                                                     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

data/lib/omnizip/converter/seven_zip_to_zip_strategy.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "tmpdir"
+
 module Omnizip
   module Converter
     # Convert 7-Zip archives to ZIP format
@@ -8,18 +10,22 @@ module Omnizip
       # @return [ConversionResult] Conversion result
       def convert
         start_time = Time.now
-        0
 
-        # Open source 7z archive
         reader = Omnizip::Formats::SevenZip::Reader.new(source_path)
-        reader.read
+        reader.open
+        entry_count = reader.list_files.size
 
-        # Collect entries
-        entries_data = collect_seven_zip_entries(reader)
-        entry_count = entries_data.size
+        Dir.mktmpdir("omnizip_convert") do |tmp|
+          reader.extract_all(tmp)
 
-        # Create target ZIP archive
-        create_zip(entries_data)
+          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
+        end
 
         create_result(start_time, entry_count)
       end
@@ -43,50 +49,6 @@ module Omnizip
       def self.can_convert?(source, target)
         source.end_with?(".7z") && target.end_with?(".zip")
       end
-
-      private
-
-      def collect_seven_zip_entries(reader)
-        entries = []
-
-        reader.entries.each do |entry|
-          data = {
-            name: entry.name,
-            content: nil,
-            mtime: entry.mtime || Time.now,
-          }
-
-          # Extract entry data
-          unless entry.name.end_with?("/")
-            File.open(source_path, "rb") do |io|
-              data[:content] = reader.extract_entry_data(io, entry)
-            end
-          end
-
-          entries << data
-        end
-
-        entries
-      end
-
-      def create_zip(entries)
-        Omnizip::Zip::File.create(target_path) do |zip|
-          entries.each do |entry_data|
-            if entry_data[:name].end_with?("/")
-              # Directory entry
-              zip.add(entry_data[:name])
-            else
-              # File entry
-              zip.add(entry_data[:name]) { entry_data[:content] }
-            end
-          end
-
-          # Set archive comment if preserving metadata
-          if options.preserve_metadata
-            zip.comment = "Converted from 7z by Omnizip"
-          end
-        end
-      end
     end
   end
 end

data/lib/omnizip/formats/rar.rb

@@ -125,6 +125,24 @@ module Omnizip
       end
 
       class << self
+        # Create a RAR archive, yielding the writer for entries.
+        # RAR5 is the default; pass version: 4 for the RAR4 writer.
+        #
+        # @param path [String] Output archive path
+        # @param options [Hash] Writer options
+        # @return [String, Array<String>] Path(s) of the created
+        #   archive (a volume set returns every volume)
+        def create(path, options = {})
+          version = options.fetch(:version, 5)
+          writer = if version == 4
+                     Writer.new(path, options)
+                   else
+                     Rar5::Writer.new(path, options)
+                   end
+          yield writer if block_given?
+          writer.write
+        end
+
         # Check if RAR extraction is available
         #
         # @return [Boolean] true if unrar available

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

@@ -68,6 +68,23 @@ module Omnizip
           @entries << entry
         end
 
+        # Add an explicit directory entry with no data or stream
+        #
+        # @param archive_path [String] Directory path inside the
+        #   archive (trailing slash optional)
+        # @return [self]
+        def add_directory_entry(archive_path)
+          entry = Models::FileEntry.new
+          entry.name = archive_path.chomp("/")
+          entry.source_path = nil
+          entry.size = 0
+          entry.is_dir = true
+          entry.has_stream = false
+          entry.mtime = Time.now
+          @entries << entry
+          self
+        end
+
         def write
           # Collect any files from the collector (if add_file/add_directory was used)
           collected_entries = @collector.collect_files

data/lib/omnizip/version.rb

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

data/readme-docs/api-usage.adoc

@@ -340,7 +340,7 @@ Zstandard offers fast compression with good ratios, using the native library.
 
 [source,ruby]
 ----
-algorithm = Omnizip::AlgorithmRegistry.get(:zstd).new(level: 3)
+algorithm = Omnizip::AlgorithmRegistry.get(:zstandard).new(level: 3)
 algorithm.compress(input, output)
 ----
 

data/readme-docs/architecture.adoc

@@ -246,7 +246,7 @@ end
 
 # List all available
 algorithms = Omnizip::AlgorithmRegistry.available
-# => [:lzma, :lzma2, :bzip2, :ppmd7, :ppmd8, :deflate, :deflate64, :zstd]
+# => [:lzma, :lzma2, :bzip2, :ppmd7, :ppmd8, :deflate, :deflate64, :zstandard]
 ----
 
 === Adding New Algorithms

data/readme-docs/compression-algorithms.adoc

@@ -329,7 +329,7 @@ Zstandard supports levels 1-22:
 
 [source,ruby]
 ----
-zstd = Omnizip::AlgorithmRegistry.get(:zstd).new(level: 3)
+zstd = Omnizip::AlgorithmRegistry.get(:zstandard).new(level: 3)
 zstd.compress(input, output)
 ----
 

data/readme-docs/installation.adoc

@@ -63,7 +63,7 @@ require 'omnizip'
 
 # Check available algorithms
 puts Omnizip::AlgorithmRegistry.available.inspect
-# => [:lzma, :lzma2, :bzip2, :ppmd7, :ppmd8, :deflate, :deflate64, :zstd]
+# => [:lzma, :lzma2, :bzip2, :ppmd7, :ppmd8, :deflate, :deflate64, :zstandard]
 
 # Get version
 puts Omnizip::VERSION

data/readme-docs/performance-profiler.adoc

@@ -302,7 +302,7 @@ def compare_algorithms(data, algorithms)
 end
 
 data = File.read('test_file.dat')
-compare_algorithms(data, [:deflate, :lzma, :bzip2, :zstd])
+compare_algorithms(data, [:deflate, :lzma, :bzip2, :zstandard])
 ----
 
 === Example 3: Memory Leak Detection

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omnizip
 version: !ruby/object:Gem::Version
-  version: 0.3.39
+  version: 0.3.40
 platform: ruby
 authors:
 - Ribose Inc.
@@ -333,6 +333,7 @@ files:
 - lib/omnizip/buffer.rb
 - lib/omnizip/buffer/memory_archive.rb
 - lib/omnizip/buffer/memory_extractor.rb
+- lib/omnizip/buffer/seven_zip_bridge.rb
 - lib/omnizip/checksum_registry.rb
 - lib/omnizip/checksums.rb
 - lib/omnizip/checksums/crc32.rb