omnizip 0.3.47 → 0.3.48

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22e232b5a4b1ddbbece5ce1b6052ea90a9e76a120e8d246cf03ae0b568d4ba73
-  data.tar.gz: af66a96e666d25e75196b68b317e2f34a37f2fa3e0da2d79d8f2d67d2a6d86a2
+  metadata.gz: 8ff2a922c26dc80694f6167b0d46e16d28fe34fa9a0cdbcea12f6f5dc57085b6
+  data.tar.gz: f260edbb81b37ba0824fb9a896fc1668a60d3e74ffeba44821670d4304dd065d
 SHA512:
-  metadata.gz: ed6a8cd7c2613912ed4c50e914cd1a4184253e6b66325741649d2790c9b0650546f6066354a28956b98e2f0a7c17853a56a0723308877a93043b55979270a2c1
-  data.tar.gz: f6ad381f14bfd3a621584747bd71f544adacafc6d8241261f6bf7c553a92763ca0fef2165d4a65895f0ff54231b071e6f98903d87caf7125bfe229c372afc489
+  metadata.gz: 0b47b5b5702166234e3c5e5cc132f3f944837904a9f4ce91a560e6c4207de329ec8d1e5ae01028e1b872c4dfbf5fda8b0ffee981ac9698cf500bc114d0a0ae65
+  data.tar.gz: e788bec8df533ea0417eb8db6e762a89ac17908e676558132eb127e1aa18af4c64bdc6da2151d50d772a4754c4a81ced191fa4b1b750fb6df27683d031ad237b

data/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.47] - 2026-08-31
+
+### Fixed
+- `.rar` is a writable extension route: the RAR handler gained
+  create in 0.3.46, but the route table still classified `.rar` as
+  read-only — `Archive.create('a.rar')` without an explicit format
+  kept raising "cannot be written by the convenience API" while
+  `Archive.create(fmt: :rar)` worked. The route table matches the
+  handler now; `.cpio`/`.iso` stay read-only.
+
 ## [0.3.46] - 2026-08-31
 
 ### Added

data/lib/omnizip/archive.rb

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

data/lib/omnizip/archive_handlers/seven_zip_handler.rb

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

data/lib/omnizip/buffer/seven_zip_bridge.rb

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

data/lib/omnizip/commands/archive_create_command.rb

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

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

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

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

@@ -75,7 +75,9 @@ module Omnizip
         # @return [self]
         def add_directory_entry(archive_path)
           entry = Models::FileEntry.new
-          entry.name = archive_path.chomp("/")
+          # Trailing slash is preserved: explicit directory entries
+          # carry it ("testdir/"), matching the collector's tree walk
+          entry.name = archive_path
           entry.source_path = nil
           entry.size = 0
           entry.is_dir = true

data/lib/omnizip/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omnizip
 version: !ruby/object:Gem::Version
-  version: 0.3.47
+  version: 0.3.48
 platform: ruby
 authors:
 - Ribose Inc.