omnizip 0.3.50 → 0.3.51

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6aa49d6ab2a370eda775a80206da80220936025ece39c3e121471815b309adbd
-  data.tar.gz: 60ab5eb1c7bcd3243f71aed658a85e84b2b37a02d061bf09156f0dd82c18d536
+  metadata.gz: 4b268c5b315ddcfff3347f6843e30e7ca180b1b3bae14b21a7a721bd2ccf3f6e
+  data.tar.gz: 2d150420264453af6e1ba5114b32a31b1a67c12a020f41435a037747dec2bfde
 SHA512:
-  metadata.gz: 8e4cc8c3b167c07112ad5f45f3a870eb24b8ffd946cc7f9fe6c4b10bfe376e7efc5a0c975287027646d9bc7aef3f419e67eb1bd40e38824eb3e93219a3f78603
-  data.tar.gz: 7fe55f7e975c40eff0c2109167a0e23fa99f11949489a29f7555632a340b3ea16983091f09bfa6cd948e3351501fd66fb438d3ad90a40953ef514721fc0138f0
+  metadata.gz: '053812e04bf42b6fe5335d57a5183c90b19a3ed8b414ee57ac9a83831a04f15e7225ecc79d29bc42e78e692bf7fe6f60b88ba234a3fc92eb0e781e7a357acd14'
+  data.tar.gz: dd2e32bd6ea8732be35a2f6c7325ed23b922860c051caf7666df93edd7f7da1342bdc1f6c9928346a404a7a1c707c509bd74d1b281ddd07cdc4a591c67e8a05d

data/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.50] - 2026-08-31
+
+### Added
+- The conversion matrix is closed: `Omnizip::Converter.convert` now
+  converts any routed source format (ZIP, 7z, TAR, RAR, cpio, ISO,
+  RPM, XAR, MSI) into any writable target format (ZIP, 7z, TAR,
+  RAR) through a new extract-and-repack strategy built on the
+  handler registry. The documented RAR→ZIP and TAR→7z pairs
+  previously had no strategy behind them — `Converter.supported?`
+  answered false for conversions the README promised. The direct
+  ZIP↔7z strategies keep precedence, so entry-copying conversions
+  don't take the repack detour.
+
 ## [0.3.49] - 2026-08-31
 
 ### Added

data/lib/omnizip/commands/archive_create_command.rb

@@ -47,11 +47,7 @@ module Omnizip
         validate_inputs(output_file, inputs)
 
         # Apply profile settings if specified
-        opts = options.dup
-        if opts[:profile]
-          first_file = find_first_file(inputs)
-          opts = apply_profile(first_file, opts)
-        end
+        opts = Omnizip::Profile.apply(options, paths: inputs)
 
         format = (opts[:format] || detect_format(output_file)).to_sym
         handler_opts = handler_options(format, opts)
@@ -217,39 +213,6 @@ module Omnizip
         format("%.2f %s", size, units[unit_idx])
       end
 
-      def apply_profile(file_path, options)
-        profile_spec = options.delete(:profile)
-        return options unless profile_spec
-
-        # Get the profile
-        profile = case profile_spec
-                  when "auto"
-                    file_path ? Omnizip::Profile.detect(file_path) : Omnizip::Profile.get(:balanced)
-                  else
-                    Omnizip::Profile.get(profile_spec.to_sym) || Omnizip::Profile.get(:balanced)
-                  end
-
-        # Apply profile to options
-        profile.apply_to(options)
-      end
-
-      def find_first_file(inputs)
-        inputs.each do |input|
-          return input if File.file?(input)
-
-          # Check directories for first file
-          if File.directory?(input)
-            Dir.foreach(input) do |entry|
-              next if [".", ".."].include?(entry)
-
-              full_path = File.join(input, entry)
-              return full_path if File.file?(full_path)
-            end
-          end
-        end
-        nil
-      end
-
       def parse_volume_size(size_str)
         return nil if size_str.nil? || size_str.empty?
 

data/lib/omnizip/convenience.rb

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

data/lib/omnizip/converter/conversion_strategy.rb

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

data/lib/omnizip/converter/extract_repack_strategy.rb

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

data/lib/omnizip/converter/seven_zip_to_zip_strategy.rb

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

data/lib/omnizip/converter/zip_to_seven_zip_strategy.rb

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

data/lib/omnizip/profile.rb

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

data/lib/omnizip/version.rb

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

metadata

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