omnizip 0.3.38 → 0.3.40

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

@@ -76,6 +76,9 @@ module Omnizip
           # Read file name
           name_bytes = io.read(name_size)
           entry.name = decode_filename(name_bytes, head_flags)
+          # RAR4 archives store DOS-style backslash separators;
+          # normalize to forward slashes like unrar on Unix.
+          entry.name = entry.name.tr("\\", "/")
 
           # Set entry properties
           entry.size = unpack_size
@@ -88,18 +91,25 @@ module Omnizip
           entry.attributes = attr
           entry.mtime = dos_time_to_time(file_time)
 
-          # Set flags
-          entry.is_dir = head_flags.anybits?(FILE_DIRECTORY)
+          # Set flags. RAR4 directory entries carry the full
+          # dictionary mask 0xE0 in HEAD_FLAGS (a directory has no
+          # dictionary); the exact match avoids misreading a large
+          # dictionary size on files as the marker.
+          entry.is_dir = head_flags.allbits?(FILE_DIRECTORY)
+          # WinRAR writes directory names with a trailing backslash;
+          # normalize it away for host paths.
+          entry.name = entry.name.chomp("\\") if entry.is_dir
           entry.encrypted = head_flags.anybits?(FILE_ENCRYPTED)
           entry.split_before = head_flags.anybits?(FILE_SPLIT_BEFORE)
           entry.split_after = head_flags.anybits?(FILE_SPLIT_AFTER)
 
-          # Skip remaining header data and file data
-          # Fixed fields: TYPE(1) + FLAGS(2) + SIZE(2) + PACK_SIZE(4) + UNPACK_SIZE(4) +
-          #               HOST_OS(1) + FILE_CRC(4) + FILE_TIME(4) + VERSION(1) + METHOD(1) +
-          #               NAME_SIZE(2) + ATTR(4) = 30 bytes
-          remaining = head_size - (name_size + 30)
-          remaining += 8 if head_flags.anybits?(FILE_LARGE)
+          # Skip remaining header data and file data. HEAD_SIZE
+          # counts the whole block including the 2-byte HEAD_CRC;
+          # consumed so far: 2 (CRC) + 30 (fixed fields) + name, plus
+          # 8 more when high-size words were present. Leftover bytes
+          # cover salt/extra time fields without interpreting them.
+          remaining = head_size - (name_size + 32)
+          remaining -= 8 if head_flags.anybits?(FILE_LARGE)
           io.read(remaining) if remaining.positive?
           io.read(pack_size) # Skip compressed data
 

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

@@ -21,6 +21,10 @@ module Omnizip
         BLOCK_SUBBLOCK = 0x7A
         BLOCK_ENDARC = 0x7B
 
+        # HEAD_FLAGS bit 0x8000 (LONG_BLOCK): the block carries a
+        # data area whose size is the PACK_SIZE field at offset 7
+        BLOCK_LONG = 0x8000
+
         # Archive flags
         ARCHIVE_VOLUME = 0x0001
         ARCHIVE_COMMENT = 0x0002

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

@@ -152,7 +152,7 @@ module Omnizip
                 "WinRAR", "UnRAR.exe"
               ),
             ].each do |path|
-              return "\"#{path}\"" if File.exist?(path)
+              return path if File.exist?(path)
             end
 
             nil
@@ -176,7 +176,7 @@ module Omnizip
           def command_version
             return nil unless command_available?
 
-            output = `#{command_path} 2>&1`
+            output = `"#{command_path}" 2>&1`
             output.match(/UNRAR\s+([\d.]+)/i)&.captures&.first || "unknown"
           end
 
@@ -191,7 +191,7 @@ module Omnizip
           # Extract with system command
           def extract_with_command(archive_path, output_dir, password)
             cmd = build_extract_command(archive_path, output_dir, password)
-            return if system(cmd)
+            return if system(*cmd)
 
             raise "Command extraction failed: #{archive_path}"
           end
@@ -215,7 +215,7 @@ module Omnizip
 
           # List with system command
           def list_with_command(archive_path)
-            output = `#{command_path} vb "#{archive_path}" 2>&1`
+            output = `"#{command_path}" vb "#{archive_path}" 2>&1`
             raise "Command listing failed" unless $CHILD_STATUS.success?
 
             output.split("\n").map do |line|
@@ -240,7 +240,7 @@ module Omnizip
                                          output_path, password)
             temp_dir = Dir.mktmpdir
             cmd = build_extract_command(archive_path, temp_dir, password)
-            unless system(cmd)
+            unless system(*cmd)
               raise "Command entry extraction failed: #{entry_name}"
             end
 
@@ -252,9 +252,13 @@ module Omnizip
 
           # Build extract command
           def build_extract_command(archive_path, output_dir, password)
-            cmd = "#{command_path} x -y"
-            cmd += " -p#{password}" if password
-            cmd += " \"#{archive_path}\" \"#{output_dir}/\""
+            # Array form: no shell involved, so paths and passwords
+            # with special characters stay literal. -idq silences the
+            # per-file progress banner.
+            cmd = [command_path, "x", "-idq", "-y"]
+            cmd << "-p#{password}" if password
+            cmd << archive_path
+            cmd << "#{output_dir}/"
             cmd
           end
 

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

@@ -84,20 +84,12 @@ module Omnizip
 
         # Parse RAR4 header
         #
+        # The 7-byte signature consumed by #parse IS the marker
+        # block, so the main header follows immediately.
+        #
         # @param io [IO] Input stream
         def parse_rar4_header(io)
-          # Read marker block
-          read_uint16(io)
-          head_type = io.read(1)&.ord
-          read_uint16(io)
-          read_uint16(io)
-
-          unless head_type == BLOCK_MARKER
-            raise "Expected marker block, got 0x#{head_type.to_s(16)}"
-          end
-
-          # Read archive header
-          read_uint16(io)
+          read_uint16(io) # HEAD_CRC
           head_type = io.read(1)&.ord
           head_flags = read_uint16(io)
           head_size = read_uint16(io)
@@ -112,9 +104,9 @@ module Omnizip
           @is_locked = head_flags.anybits?(ARCHIVE_LOCKED)
           @comment_present = head_flags.anybits?(ARCHIVE_COMMENT)
 
-          # Skip rest of archive header
-          # head_size includes TYPE(1) + FLAGS(2) + SIZE(2) = 5 bytes already read
-          remaining = head_size - 5
+          # Skip rest of archive header. HEAD_SIZE counts the whole
+          # block including the 2 HEAD_CRC bytes; 7 bytes consumed.
+          remaining = head_size - 7
           io.read(remaining) if remaining.positive?
         end
 

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

@@ -2,6 +2,7 @@
 
 require "fileutils"
 require "stringio"
+require "zlib"
 
 module Omnizip
   module Formats
@@ -246,11 +247,7 @@ module Omnizip
           # Native decompression only for RAR4 for now
           return false unless @header.version == 4
 
-          # Check if we have the compression method
-          return false if entry.nil? || entry.method.nil?
-
-          # All RAR4 methods are supported by our Dispatcher
-          true
+          !entry.nil? && !entry.method.nil?
         end
 
         # Extract entry using native decompression
@@ -258,17 +255,24 @@ module Omnizip
         # @param entry [Models::RarEntry] File entry
         # @param output_path [String] Destination path
         def extract_entry_native(entry, output_path)
-          # Read compressed data from archive
           compressed_data = read_compressed_data(entry)
-
-          # Decompress using Dispatcher
-          File.open(output_path, "wb") do |output|
-            # For now, assume METHOD_STORE (0x30)
-            # Real implementation would get method from entry
-            method = entry.method || 0x30
-
-            Compression::Dispatcher.decompress(method, compressed_data, output)
+          method = entry.method || 0x30
+
+          output = StringIO.new(+"")
+          Compression::Dispatcher.decompress(method, compressed_data, output)
+
+          # The native LZ/PPMd decoders understand Omnizip's own
+          # encoder output, not official RAR streams — without this
+          # check, real WinRAR archives would silently extract as
+          # garbage. The header CRC is authoritative: on mismatch,
+          # fall back to unrar.
+          data = output.string
+          if entry.crc && Zlib.crc32(data) != entry.crc
+            raise Compression::DecompressionError,
+                  "CRC mismatch for #{entry.name}"
           end
+
+          File.binwrite(output_path, data)
         rescue StandardError => e
           # Fall back to external decompressor on error
           warn "Native decompression failed for #{entry.name}: #{e.message}"