excavate 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6360dbc5e452e6a0984a8bb8394051fa74da9d33700afd1ca9b36dbd73f9eeeb
-  data.tar.gz: 4d1f8e805be65dd56c6194915a43433561ba29572b016d6dc3d613617140957f
+  metadata.gz: 533124c47fcd3ac27122c10f3fccf7c585f74684dccefd5988f812a2e2804392
+  data.tar.gz: 1d70e420f988127059dc364cd26c7e7c3e34b5bf618a5e7b5d1e5b28005d2d53
 SHA512:
-  metadata.gz: dd1b31fabaf5c27c182bfec752255f918acf63763630bd7b6e39850f8296219b0ff182458efb3cfc5b3fe04f448b657a5e8b197330d532f1ccceed22e78a7ba3
-  data.tar.gz: f8a7aa72c8486144b9dcd09c5ecc05fa4c0acefbcc7482dca5a09cb1725d0d84438125438f1020dbdc478e37dce02486d1c4fdab7d37dc62e033a57f0094bd6b
+  metadata.gz: 64ebd2cc16fee28e756db9cbacc317b3a70dd12e944e51c3c0f6994541fd674f0b89d8e06fff141167e5b3ae839477278bc958243c1dd77283f36ece4c63d1a6
+  data.tar.gz: 015bb8fb81644b1dda590157e9184b624f62415edbc5b94fafcad8df6090a75d8ce02df218c8f54726b904a18afe7bba8a7d78d2dd5e597e40341585bda76619

data/lib/excavate/archive.rb

@@ -1,19 +1,5 @@
 module Excavate
   class Archive
-    INVALID_MEMORY_MESSAGE =
-      "invalid memory read at address=0x0000000000000000".freeze
-
-    TYPES = { "cab" => Extractors::CabExtractor,
-              "cpio" => Extractors::CpioExtractor,
-              "exe" => Extractors::SevenZipExtractor,
-              "gz" => Extractors::GzipExtractor,
-              "msi" => Extractors::OleExtractor,
-              "pkg" => Extractors::XarExtractor,
-              "rpm" => Extractors::RpmExtractor,
-              "tar" => Extractors::TarExtractor,
-              "xz" => Extractors::XzExtractor,
-              "zip" => Extractors::ZipExtractor }.freeze
-
     def initialize(archive)
       @archive = archive
     end
@@ -193,27 +179,26 @@ module Excavate
       FileUtils.cp(archive, target)
     end
 
-    def may_be_nested_cab?(extension, message)
-      extension == "exe" &&
-        (message.start_with?("Invalid file format",
-                             "Unrecognized archive format") ||
-         message.include?("Invalid .7z signature"))
-    end
-
     def extract_once(archive, target)
-      extension = normalized_extension(archive)
-      extractor_class = TYPES[extension]
+      type = FileMagic.detect(archive)
+      extractor_class = Extractors::Extractor.for_magic_type(type)
       unless extractor_class
         raise(UnknownArchiveError, "Could not unarchive `#{archive}`.")
       end
 
       extractor_class.new(archive).extract(target)
     rescue StandardError => e
-      raise unless may_be_nested_cab?(extension, e.message)
+      raise unless type == :exe && may_be_nested_cab?(e.message)
 
       Extractors::CabExtractor.new(archive).extract(target)
     end
 
+    def may_be_nested_cab?(message)
+      message.start_with?("Invalid file format",
+                          "Unrecognized archive format") ||
+        message.include?("Invalid .7z signature")
+    end
+
     def extract_and_replace(archive)
       target = Dir.mktmpdir
       extract_recursively(archive, target)
@@ -222,8 +207,8 @@ module Excavate
       # During recursive extraction of nested archives, silently skip
       # any that fail (e.g. .msi files that aren't real OLE, .cab files
       # with incompatible format, .exe files with unsupported compression).
-      # Only re-raise for file types we don't recognize as archives.
-      raise unless TYPES.key?(normalized_extension(archive))
+      # Only re-raise if the file is not a recognized archive format.
+      raise unless File.exist?(archive) && archive?(archive)
     ensure
       FileUtils.rm_rf(target)
     end
@@ -278,22 +263,6 @@ module Excavate
       end
     end
 
-    def normalized_extension(file)
-      fetch_extension(file).downcase
-    end
-
-    def fetch_extension(file)
-      File.extname(filename(file)).sub(/^\./, "")
-    end
-
-    def filename(file)
-      if file.respond_to?(:original_filename)
-        file.original_filename
-      else
-        File.basename(file)
-      end
-    end
-
     def all_files_in(dir)
       Dir.glob(File.join(dir, "**", "*"))
     end
@@ -301,10 +270,8 @@ module Excavate
     def archive?(file)
       return false unless File.file?(file)
 
-      ext = normalized_extension(file)
-      return false if ext == "gz" && FileMagic.detect(file) != :gzip
-
-      TYPES.key?(ext)
+      type = FileMagic.detect(file)
+      !type.nil? && !Extractors::Extractor.for_magic_type(type).nil?
     end
   end
 end

data/lib/excavate/extractors/extractor.rb

@@ -1,6 +1,25 @@
 module Excavate
   module Extractors
     class Extractor
+      MAGIC_MAP = {
+        cab: "CabExtractor",
+        cpio: "CpioExtractor",
+        exe: "SevenZipExtractor",
+        gzip: "GzipExtractor",
+        ole: "OleExtractor",
+        rpm: "RpmExtractor",
+        seven_zip: "SevenZipExtractor",
+        tar: "TarExtractor",
+        xar: "XarExtractor",
+        xz: "XzExtractor",
+        zip: "ZipExtractor",
+      }.freeze
+
+      def self.for_magic_type(type)
+        name = MAGIC_MAP[type]
+        Extractors.const_get(name) if name
+      end
+
       def initialize(archive)
         @archive = archive
       end
@@ -8,6 +27,31 @@ module Excavate
       def extract(_target)
         raise NotImplementedError.new("You must implement this method")
       end
+
+      private
+
+      # Detect inner format of decompressed data and extract
+      # or write raw output.
+      # Shared by GzipExtractor and XzExtractor.
+      def extract_inner(data, target)
+        inner_type = FileMagic.detect_bytes(data)
+        extractor_class = Extractor.for_magic_type(inner_type) if inner_type
+
+        if extractor_class
+          temp = File.join(target, ".temp_#{Time.now.to_i}_#{rand(1000)}")
+          File.binwrite(temp, data)
+          extractor_class.new(temp).extract(target)
+        else
+          write_raw_output(data, target)
+        end
+      ensure
+        FileUtils.rm_f(temp) if temp
+      end
+
+      def write_raw_output(data, target)
+        basename = File.basename(@archive, ".*")
+        File.binwrite(File.join(target, basename), data)
+      end
     end
   end
 end

data/lib/excavate/extractors/gzip_extractor.rb

@@ -6,12 +6,8 @@ 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|
-          File.write(output_path, gz.read, mode: "wb")
-        end
+        data = Zlib::GzipReader.open(@archive, &:read)
+        extract_inner(data, target)
       end
     end
   end

data/lib/excavate/extractors/xz_extractor.rb

@@ -1,70 +1,13 @@
 # frozen_string_literal: true
 
 require "omnizip"
-require "zlib"
 
 module Excavate
   module Extractors
-    # Extractor for XZ compressed archives (both .xz and .tar.xz formats)
-    #
-    # This extractor handles:
-    # - Pure XZ compressed files (.xz)
-    # - Compound TAR+XZ archives (.tar.xz)
-    #
-    # Uses Omnizip for XZ decompression.
     class XzExtractor < Extractor
       def extract(target)
-        if tar_xz?
-          extract_tar_xz(target)
-        else
-          extract_pure_xz(target)
-        end
-      end
-
-      private
-
-      def tar_xz?
-        @archive.end_with?(".tar.xz", ".txz")
-      end
-
-      def extract_tar_xz(target)
-        data = Omnizip::Formats::Xz.decompress(@archive)
-        data = strip_compression(data)
-        validate_tar!(data)
-
-        # Write tar file and extract
-        temp_tar = File.join(target, ".temp_#{Time.now.to_i}_#{rand(1000)}.tar")
-        File.binwrite(temp_tar, data)
-
-        TarExtractor.new(temp_tar).extract(target)
-      ensure
-        File.delete(temp_tar) if temp_tar && File.exist?(temp_tar)
-      end
-
-      def strip_compression(data)
-        if FileMagic.detect_bytes(data) == :gzip
-          return Zlib::GzipReader.new(StringIO.new(data)).read
-        end
-
-        data
-      end
-
-      def validate_tar!(data)
-        inner_type = FileMagic.detect_bytes(data)
-        return if inner_type == :tar
-
-        inner_type ||= "unknown format"
-
-        raise UnknownArchiveError,
-              "Expected tar inside #{@archive}, got #{inner_type}"
-      end
-
-      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)
+        extract_inner(data, target)
       end
     end
   end

data/lib/excavate/file_magic.rb

@@ -8,6 +8,15 @@ module Excavate
       [0, "\xFD7zXZ\x00".b, :xz],
       [0, "\x1F\x8B".b, :gzip],
       [257, "ustar".b, :tar],
+      [0, "7z\xBC\xAF\x27\x1C".b, :seven_zip],
+      [0, "PK\x03\x04".b, :zip],
+      [0, "\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1".b, :ole],
+      [0, "xar!".b, :xar],
+      [0, "\xED\xAB\xEE\xDB".b, :rpm],
+      [0, "070707".b, :cpio],
+      [0, "070701".b, :cpio],
+      [0, "070702".b, :cpio],
+      [0, "MZ".b, :exe],
     ].freeze
 
     MAX_READ = SIGNATURES.map { |o, m, _| o + m.bytesize }.max

data/lib/excavate/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: excavate
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-03-24 00:00:00.000000000 Z
+date: 2026-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cabriolet