excavate 0.3.9 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56401e5430415802c560b8f23c9b83da63c363e41b6fe0cf9237542a3903959b
-  data.tar.gz: 56d280616e5ec8dc1d1833a3453df61ab3cfd99bccea7bb6985f47c58b1a5aa6
+  metadata.gz: 7adbf7839cf5917692766601ec8b44ec32794e860a658ef9cdb9594031cc904e
+  data.tar.gz: 3fa93a928c9fd291f757c740c320e39f9431af5fc718352c5671f5dc7b4c9721
 SHA512:
-  metadata.gz: 316e2bcb6575a02d21ea2463074b242c5ee8a0c819851fbe161d0df8c27267fcfaa4bc84411a8ee5a5a5158f4e03f0bd3cf48b92a9de89be2781ea8c03100a6f
-  data.tar.gz: 3193c2e4c10eee70a64f3944e5aa274bb76912a58e32cbf9ed971f3bd44b9106725e37371fd658b02d2273ff43ca4bbbca0f55f6b69e8cf71393e2d0297c8287
+  metadata.gz: 7e40f307222b934913b71e731e94df4488d2fd668895a3ded5c010c592791666655a44330c74c10f66c2be892f975341afec98c9961bcd6f6a0f4448680b5147
+  data.tar.gz: d7774a97313fffd8f773f8df098c564edb8bce53c8b96b47b1669504729517c35fb27f7627cd161733068b9c0ce7b1183c6dd23516ee5984089adcabf89c14cc

data/.github/workflows/release.yml

@@ -2,6 +2,8 @@ name: release
 
 permissions:
   contents: write
+  packages: write
+  id-token: write
 
 on:
   workflow_dispatch:

data/.rubocop.yml

@@ -6,6 +6,7 @@ inherit_from:
 
 # local repo-specific modifications
 AllCops:
+  NewCops: disable
   Exclude:
     - 'lib/excavate/extractors/cpio/cpio_old_format.rb'
     - 'vendor/**/*'

data/Gemfile

@@ -5,6 +5,7 @@ source "https://rubygems.org"
 gemspec
 
 gem "openssl", "~> 3.0"
+gem "rake"
 gem "rspec"
 gem "rubocop"
 gem "rubocop-performance"

data/excavate.gemspec

@@ -31,15 +31,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "arr-pm", "~> 0.0"
-  # spec.add_dependency "bundler", "~> 2", ">= 2.3.24"
-  # Workaround for https://github.com/metanorma/ruby-libmspack/issues/2
-  spec.add_dependency "ffi-compiler2", ">= 2.2.2"
-  spec.add_dependency "ffi-libarchive-binary", "~> 0.4", ">= 0.4.2"
-  spec.add_dependency "libmspack", "~> 0.1"
-  spec.add_dependency "ruby-ole", "~> 1.0"
-  spec.add_dependency "rubyzip", "~> 2.3"
-  spec.add_dependency "seven-zip", "~> 1.4"
+  spec.add_dependency "cabriolet", "~> 0.2.2"
+  spec.add_dependency "omnizip", "~> 0.3.8"
   spec.add_dependency "thor", "~> 1.0"
 
   spec.metadata["rubygems_mfa_required"] = "false"

data/lib/excavate/archive.rb

@@ -25,7 +25,7 @@ module Excavate
 
       all_files_in(target).map(&block)
     ensure
-      FileUtils.rm_rf(target)
+      windows_safe_rm_rf(target)
     end
 
     def extract(target = nil,
@@ -187,8 +187,9 @@ module Excavate
 
     def may_be_nested_cab?(extension, message)
       extension == "exe" &&
-        message.start_with?("Invalid file format",
-                            "Unrecognized archive format")
+        (message.start_with?("Invalid file format",
+                             "Unrecognized archive format") ||
+         message.include?("Invalid .7z signature"))
     end
 
     def extract_once(archive, target)
@@ -208,13 +209,60 @@ module Excavate
     def extract_and_replace(archive)
       target = Dir.mktmpdir
       extract_recursively(archive, target)
+      replace_archive_with_contents(archive, target)
+    rescue StandardError
+      FileUtils.rm_rf(target)
+      raise unless normalized_extension(archive) == "exe"
+    end
 
-      FileUtils.rm(archive)
+    def replace_archive_with_contents(archive, target)
+      windows_safe_rm(archive)
       FileUtils.mv(target, archive)
-    rescue FFI::NullPointerError => e
-      FileUtils.rmdir(target)
-      raise unless normalized_extension(archive) == "exe" &&
-        e.message.start_with?(INVALID_MEMORY_MESSAGE)
+    rescue Errno::EACCES
+      # Windows: file is locked. Copy extracted contents to archive location
+      # and keep both the archive and extracted files
+      target_dir = File.dirname(archive)
+      # Copy all extracted files to the target directory
+      Dir.glob(File.join(target, "**", "*")).each do |src|
+        next unless File.file?(src)
+
+        dest = File.join(target_dir, File.basename(src))
+        FileUtils.cp(src, dest) unless File.exist?(dest)
+      end
+      # Leave the original locked archive in place
+    end
+
+    # Windows sometimes holds file locks briefly after operations.
+    # This method retries file deletion with a small delay.
+    def windows_safe_rm(path, max_retries: 5)
+      attempts = 0
+      begin
+        FileUtils.rm(path)
+      rescue Errno::EACCES => e
+        attempts += 1
+        if attempts < max_retries
+          sleep(0.2)
+          retry
+        else
+          raise e
+        end
+      end
+    end
+
+    # Windows-safe recursive removal
+    def windows_safe_rm_rf(path, max_retries: 5)
+      attempts = 0
+      begin
+        FileUtils.rm_rf(path)
+      rescue Errno::EACCES, Errno::ENOTEMPTY => e
+        attempts += 1
+        if attempts < max_retries
+          sleep(0.2)
+          retry
+        else
+          raise e
+        end
+      end
     end
 
     def normalized_extension(file)

data/lib/excavate/extractors/cab_extractor.rb

@@ -1,32 +1,17 @@
-require "libmspack"
+# frozen_string_literal: true
+
+require "cabriolet"
 
 module Excavate
   module Extractors
     class CabExtractor < Extractor
       def extract(target)
-        open_cab(@archive) do |decompressor, cab|
-          file = cab.files
-
-          while file
-            path = File.join(target, file.filename)
-            decompressor.extract(file, path)
-            file = file.next
-          end
-        end
-      end
-
-      private
-
-      def open_cab(archive)
-        decompressor = LibMsPack::CabDecompressor.new
-        cab = Utils.silence_stream($stderr) do
-          decompressor.search(archive)
-        end
-
-        yield decompressor, cab
+        decompressor = Cabriolet::CAB::Decompressor.new
+        decompressor.salvage = true # Enable salvage mode for compatibility
 
-        decompressor.close(cab)
-        decompressor.destroy
+        # Try to find embedded CAB first (for self-extracting archives)
+        cabinet = decompressor.search(@archive) || decompressor.open(@archive)
+        decompressor.extract_all(cabinet, target, salvage: true)
       end
     end
   end

data/lib/excavate/extractors/cpio_extractor.rb

@@ -1,53 +1,14 @@
-require_relative "cpio/cpio"
-require_relative "cpio/cpio_old_format"
+# frozen_string_literal: true
+
+require "omnizip/formats/cpio"
 
 module Excavate
   module Extractors
     class CpioExtractor < Extractor
       def extract(target)
-        extract_cpio_new_format(target)
-      rescue RuntimeError => e
-        raise unless e.message.start_with?("Invalid magic")
-
-        extract_cpio_old_format(target)
-      end
-
-      private
-
-      def extract_cpio_inner_new(entry, file, target)
-        path = File.join(target, entry.name)
-        if entry.directory?
-          FileUtils.mkdir_p(path)
-        else
-          FileUtils.mkdir_p(File.dirname(path))
-          File.write(path, file.read, mode: "wb")
-        end
-      end
-
-      def extract_cpio_new_format(target)
-        File.open(@archive, "rb") do |archive_file|
-          CPIO::ASCIIReader.new(archive_file).each do |entry, file|
-            extract_cpio_inner_new(entry, file, target)
-          end
-        end
-      end
-
-      def extract_cpio_inner_old(entry, target)
-        path = File.expand_path(entry.filename, target)
-        if entry.directory?
-          FileUtils.mkdir_p(path)
-        else
-          FileUtils.mkdir_p(File.dirname(path))
-          File.write(path, entry.data, mode: "wb")
-        end
-      end
-
-      def extract_cpio_old_format(target)
-        File.open(@archive, "rb") do |archive_file|
-          CPIO::ArchiveReader.new(archive_file).each_entry do |entry|
-            extract_cpio_inner_old(entry, target)
-          end
-        end
+        reader = Omnizip::Formats::Cpio::Reader.new(@archive)
+        reader.open
+        reader.extract_all(target)
       end
     end
   end

data/lib/excavate/extractors/gzip_extractor.rb

@@ -1,11 +1,16 @@
+# frozen_string_literal: true
+
+require "zlib"
+
 module Excavate
   module Extractors
     class GzipExtractor < Extractor
       def extract(target)
+        basename = File.basename(@archive, ".*")
+        output_path = File.join(target, basename)
+
         Zlib::GzipReader.open(@archive) do |gz|
-          basename = File.basename(@archive, ".*")
-          path = File.join(target, basename)
-          File.write(path, gz.read, mode: "wb")
+          File.write(output_path, gz.read, mode: "wb")
         end
       end
     end

data/lib/excavate/extractors/ole_extractor.rb

@@ -1,7 +1,14 @@
-require "ole/storage"
+# frozen_string_literal: true
+
+require "omnizip"
+require "omnizip/formats/ole"
+require_relative "../file_magic"
 
 module Excavate
   module Extractors
+    # Extractor for OLE compound documents (MSI, DOC, XLS, PPT, etc.)
+    #
+    # Uses Omnizip's OLE format support for extraction.
     class OleExtractor < Extractor
       def extract(target)
         do_extract(target)
@@ -13,20 +20,18 @@ module Excavate
       def do_extract(target)
         reset_filename_lookup
 
-        Ole::Storage.open(@archive) do |ole|
-          children(ole).each do |file|
-            next if ole.file.directory?(file)
-
-            filename = prepare_filename(file)
-            path = File.join(target, filename)
-            content = ole.file.read(file)
-            File.write(path, content, mode: "wb")
+        Omnizip::Formats::Ole.open(@archive) do |ole|
+          children(ole).each do |entry|
+            path = File.join(target, prepare_filename(entry))
+            FileUtils.mkdir_p(File.dirname(path))
+            content = ole.read(entry)
+            File.write(path, content, mode: "wb") if content
           end
         end
       end
 
       def children(ole)
-        ole.dir.entries(".") - [".", ".."]
+        ole.list("/")
       end
 
       def reset_filename_lookup
@@ -56,6 +61,8 @@ module Excavate
 
       def rename_archives(target)
         Dir.glob(File.join(target, "**", "*")).each do |file|
+          next unless File.file?(file)
+
           FileUtils.mv(file, "#{file}.cab") if cab?(file)
         end
       end

data/lib/excavate/extractors/rpm_extractor.rb

@@ -1,33 +1,35 @@
-require "arr-pm"
+# frozen_string_literal: true
 
-H_MAGIC = "\x8e\xad\xe8\x01\x00\x00\x00\x00".force_encoding("BINARY")
-
-# fix for Ruby 3.0
-unless RPM::File::Header::HEADER_MAGIC == H_MAGIC
-  RPM::File::Header.send(:remove_const, "HEADER_MAGIC")
-  RPM::File::Header.const_set(:HEADER_MAGIC, H_MAGIC)
-end
+require "omnizip"
+require "omnizip/formats/rpm"
 
 module Excavate
   module Extractors
+    # Extractor for RPM packages
+    #
+    # Uses Omnizip's RPM format support for extraction.
+    # Extracts the raw payload as a file (e.g., fonts.src.cpio.gz).
     class RpmExtractor < Extractor
       def extract(target)
-        File.open(@archive, "rb") do |file|
-          rpm = RPM::File.new(file)
-          content = rpm.payload.read
-          path = target_path(@archive, rpm.tags, target)
+        rpm = Omnizip::Formats::Rpm::Reader.new(@archive)
+        rpm.open
+        content = rpm.raw_payload
+        path = target_path(@archive, rpm, target)
+        rpm.close
 
-          File.write(path, content, mode: "wb")
-        end
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, content, mode: "wb")
       end
 
       private
 
-      def target_path(archive, tags, dir)
-        archive_format = tags[:payloadformat]
-        compression_format = tags[:payloadcompressor] == "gzip" ? "gz" : tags[:payloadcompressor]
+      def target_path(archive, rpm, dir)
         basename = File.basename(archive, ".*")
-        filename = "#{basename}.#{archive_format}.#{compression_format}"
+        payload_format = rpm.tags[:payloadformat] || "cpio"
+        compression_format = rpm.tags[:payloadcompressor] || "gzip"
+        # Convert "gzip" to "gz" for file extension
+        compression_ext = compression_format == "gzip" ? "gz" : compression_format
+        filename = "#{basename}.#{payload_format}.#{compression_ext}"
         File.join(dir, filename)
       end
     end

data/lib/excavate/extractors/seven_zip_extractor.rb

@@ -1,12 +1,23 @@
-require "seven_zip_ruby"
+# frozen_string_literal: true
+
+require "omnizip"
 
 module Excavate
   module Extractors
     class SevenZipExtractor < Extractor
       def extract(target)
-        Dir.chdir(target) do
-          File.open(@archive, "rb") do |file|
-            SevenZipRuby::Reader.extract_all(file, target)
+        # Check for embedded 7z in self-extracting archives
+        offset = Omnizip::Formats::SevenZip.search_embedded(@archive)
+
+        if offset
+          # Self-extracting archive - use offset
+          Omnizip::Formats::SevenZip.open(@archive, offset: offset) do |reader|
+            reader.extract_all(target)
+          end
+        else
+          # Regular 7z archive
+          Omnizip::Formats::SevenZip.open(@archive) do |reader|
+            reader.extract_all(target)
           end
         end
       end

data/lib/excavate/extractors/tar_extractor.rb

@@ -1,28 +1,13 @@
-require "rubygems/package"
+# frozen_string_literal: true
+
+require "omnizip"
 
 module Excavate
   module Extractors
     class TarExtractor < Extractor
       def extract(target)
-        File.open(@archive, "rb") do |archive_file|
-          Gem::Package::TarReader.new(archive_file) do |tar|
-            tar.each do |tarfile|
-              save_tar_file(tarfile, target)
-            end
-          end
-        end
-      end
-
-      private
-
-      def save_tar_file(file, dir)
-        path = File.join(dir, file.full_name)
-
-        if file.directory?
-          FileUtils.mkdir_p(path)
-        else
-          File.write(path, file.read, mode: "wb")
-        end
+        reader = Omnizip::Formats::Tar::Reader.open(@archive)
+        reader.extract_all(target)
       end
     end
   end

data/lib/excavate/extractors/xar_extractor.rb

@@ -1,28 +1,18 @@
-require "ffi-libarchive-binary"
+# frozen_string_literal: true
+
+require "omnizip"
+require "omnizip/formats/xar"
 
 module Excavate
   module Extractors
     class XarExtractor < Extractor
       def extract(target)
-        Dir.chdir(target) do
-          extract_with_libarchive
-          rename_payload(target)
-        end
+        Omnizip::Formats::Xar.extract(@archive, target)
+        rename_payload(target)
       end
 
       private
 
-      def extract_with_libarchive
-        flags = ::Archive::EXTRACT_PERM
-        reader = ::Archive::Reader.open_filename(@archive)
-
-        reader.each_entry do |entry|
-          reader.extract(entry, flags.to_i)
-        end
-
-        reader.close
-      end
-
       def rename_payload(target)
         Dir.glob(File.join(target, "**", "Payload")).each do |file|
           next unless File.file?(file)

data/lib/excavate/extractors/xz_extractor.rb

@@ -1,4 +1,7 @@
-require "ffi-libarchive-binary"
+# frozen_string_literal: true
+
+require "omnizip"
+require "zlib"
 
 module Excavate
   module Extractors
@@ -8,50 +11,43 @@ module Excavate
     # - Pure XZ compressed files (.xz)
     # - Compound TAR+XZ archives (.tar.xz)
     #
-    # Uses libarchive through ffi-libarchive-binary for extraction,
-    # which provides native XZ decompression support.
-    #
-    # @example Extract a .tar.xz file
-    #   extractor = XzExtractor.new("archive.tar.xz")
-    #   extractor.extract("/target/directory")
-    #
-    # @example Extract a pure .xz file
-    #   extractor = XzExtractor.new("file.xz")
-    #   extractor.extract("/target/directory")
+    # Uses Omnizip for XZ decompression.
     class XzExtractor < Extractor
-      # Extract the XZ archive to the specified target directory
-      #
-      # @param target [String] the directory path where files should be extracted
-      # @return [void]
-      #
-      # @raise [StandardError] if extraction fails
       def extract(target)
-        extract_with_libarchive(target)
+        if tar_xz?
+          extract_tar_xz(target)
+        else
+          extract_pure_xz(target)
+        end
       end
 
       private
 
-      # Perform extraction using libarchive
-      #
-      # This method uses libarchive's reader API to:
-      # 1. Open the XZ archive
-      # 2. Iterate through all entries
-      # 3. Extract each entry with appropriate permissions
-      # 4. Close the reader
-      #
-      # @param target [String] the target directory for extraction
-      # @return [void]
-      def extract_with_libarchive(target)
-        flags = ::Archive::EXTRACT_PERM
-        reader = ::Archive::Reader.open_filename(@archive)
-
-        Dir.chdir(target) do
-          reader.each_entry do |entry|
-            reader.extract(entry, flags.to_i)
-          end
-        end
+      def tar_xz?
+        @archive.end_with?(".tar.xz", ".txz")
+      end
+
+      def extract_tar_xz(target)
+        # Decompress XZ to get gzip data
+        gzip_data = Omnizip::Formats::Xz.decompress(@archive)
+        # Decompress gzip to get tar data
+        tar_data = Zlib::GzipReader.new(StringIO.new(gzip_data)).read
+
+        # Write tar file and extract
+        temp_tar = File.join(target, ".temp_#{Time.now.to_i}_#{rand(1000)}.tar")
+        File.binwrite(temp_tar, tar_data)
+
+        TarExtractor.new(temp_tar).extract(target)
+      ensure
+        File.delete(temp_tar) if temp_tar && File.exist?(temp_tar)
+      end
 
-        reader.close
+      def extract_pure_xz(target)
+        # Decompress XZ
+        data = Omnizip::Formats::Xz.decompress(@archive)
+        basename = File.basename(@archive, ".*")
+        output_path = File.join(target, basename)
+        File.binwrite(output_path, data)
       end
     end
   end

data/lib/excavate/extractors/zip_extractor.rb

@@ -1,16 +1,14 @@
-require "zip"
+# frozen_string_literal: true
+
+require "omnizip"
 
 module Excavate
   module Extractors
     class ZipExtractor < Extractor
       def extract(target)
-        Zip::File.open(@archive) do |zip_file|
-          zip_file.each do |entry|
-            path = File.join(target, entry.name)
-            FileUtils.mkdir_p(File.dirname(path))
-            entry.extract(path)
-          end
-        end
+        reader = Omnizip::Formats::Zip::Reader.new(@archive)
+        reader.read
+        reader.extract_all(target)
       end
     end
   end

data/lib/excavate/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Excavate
-  VERSION = "0.3.9"
+  VERSION = "1.0.0"
 end