zip-merge 7.0.0 → 7.1.3

data/lib/zip/merge.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require "stringio"
-require "zlib"
-require "tree_haver"
-require_relative "merge/version"
+require 'stringio'
+require 'zlib'
+require 'tree_haver'
+require_relative 'merge/version'
 
 module Zip
   module Merge
     LOCAL = 0x04034b50
     CENTRAL = 0x02014b50
     EOCD = 0x06054b50
-    DOS_EPOCH = [0, 0, 0x21, 0].pack("C*")
+    DOS_EPOCH = [0, 0, 0x21, 0].pack('C*')
 
     RenderError = Class.new(StandardError) do
       attr_reader :diagnostic
@@ -32,19 +32,21 @@ module Zip
         TreeHaver::ZipArchiveEntry.new(
           path: name,
           normalized_path: normalize_zip_path(name),
-          directory: name.end_with?("/"),
+          directory: name.end_with?('/'),
           compression: compression_name(record[:method]),
           compressed_size: record[:compressed_size],
           uncompressed_size: record[:uncompressed_size],
-          crc32: "%08x" % record[:crc32],
+          crc32: '%08x' % record[:crc32],
           local_header_range: TreeHaver::ByteRange.new(start_byte: record[:local_offset], end_byte: local[:data_start]),
-          data_range: TreeHaver::ByteRange.new(start_byte: local[:data_start], end_byte: local[:data_start] + record[:compressed_size]),
+          data_range: TreeHaver::ByteRange.new(start_byte: local[:data_start],
+                                               end_byte: local[:data_start] + record[:compressed_size]),
           central_directory_range: record[:range]
         )
       end.sort_by { |entry| entry.local_header_range.start_byte }
 
       TreeHaver::ZipFamilyReport.new(
-        archive: TreeHaver::ZipArchiveInfo.new(format: "zip", schema: "zip.ksy", entry_count: entries.length, central_directory_range: central[:range]),
+        archive: TreeHaver::ZipArchiveInfo.new(format: 'zip', schema: 'zip.ksy', entry_count: entries.length,
+                                               central_directory_range: central[:range]),
         entries: entries,
         member_decisions: [],
         unsafe_entries: unsafe_entries(entries, central[:records]),
@@ -71,59 +73,70 @@ module Zip
         incoming_entry = incoming_entries[path]
         if unsafe_by_path[path]
           unsafe = unsafe_by_path[path]
-          report.member_decisions << TreeHaver::ZipMemberDecision.new(normalized_path: path, operation: "reject", disposition: "unsafe", reason: unsafe.reason)
+          report.member_decisions << TreeHaver::ZipMemberDecision.new(normalized_path: path, operation: 'reject',
+                                                                      disposition: 'unsafe', reason: unsafe.reason)
           report.merge_report.diagnostics << diagnostic(unsafe.category, schema_path(path), unsafe.reason)
         elsif current_entry.nil? && incoming_entry
-          decision(report, path, "add", "requires_renderer", "member exists only in incoming archive")
+          decision(report, path, 'add', 'requires_renderer', 'member exists only in incoming archive')
         elsif current_entry && incoming_entry.nil?
-          decision(report, path, "delete", "requires_renderer", "member was removed from incoming archive")
-        elsif ancestor_entry && same_entry?(current_entry, ancestor_entry) && same_entry?(incoming_entry, ancestor_entry)
-          report.member_decisions << TreeHaver::ZipMemberDecision.new(normalized_path: path, operation: "preserve", disposition: "safe", reason: "member is unchanged from ancestor")
+          decision(report, path, 'delete', 'requires_renderer', 'member was removed from incoming archive')
+        elsif ancestor_entry && same_entry?(current_entry,
+                                            ancestor_entry) && same_entry?(incoming_entry, ancestor_entry)
+          report.member_decisions << TreeHaver::ZipMemberDecision.new(normalized_path: path, operation: 'preserve',
+                                                                      disposition: 'safe', reason: 'member is unchanged from ancestor')
           report.merge_report.preserved_ranges.concat([current_entry.local_header_range, current_entry.data_range])
         elsif (family = nested_family(path))
-          report.member_decisions << TreeHaver::ZipMemberDecision.new(normalized_path: path, operation: "delegate", disposition: "requires_renderer", nested_family: family, reason: "structured member can be merged by a nested family before ZIP rendering")
-          report.merge_report.nested_dispatches << TreeHaver::BinaryNestedDispatch.new(schema_path: "#{schema_path(path)}/data", family: family, status: "planned")
+          report.member_decisions << TreeHaver::ZipMemberDecision.new(normalized_path: path, operation: 'delegate',
+                                                                      disposition: 'requires_renderer', nested_family: family, reason: 'structured member can be merged by a nested family before ZIP rendering')
+          report.merge_report.nested_dispatches << TreeHaver::BinaryNestedDispatch.new(
+            schema_path: "#{schema_path(path)}/data", family: family, status: 'planned'
+          )
           report.merge_report.rewritten_nodes << schema_path(path)
           report.merge_report.checksum_updates << "#{schema_path(path)}/crc32"
         else
-          decision(report, path, "rewrite", "requires_renderer", "member bytes or metadata changed")
+          decision(report, path, 'rewrite', 'requires_renderer', 'member bytes or metadata changed')
           report.merge_report.checksum_updates << "#{schema_path(path)}/crc32"
         end
         report.merge_report.matched_schema_paths << schema_path(path)
       end
       unless report.merge_report.rewritten_nodes.empty? && report.merge_report.checksum_updates.empty?
-        report.merge_report.rewritten_nodes << "/central_directory"
-        report.merge_report.checksum_updates.concat(["/central_directory/size", "/central_directory/offset"])
+        report.merge_report.rewritten_nodes << '/central_directory'
+        report.merge_report.checksum_updates.concat(['/central_directory/size', '/central_directory/offset'])
       end
       report
     end
 
     def render_with_raw_preservation(source:, plan:, member_bytes: {}, compression: 0)
-      raise render_error("unsupported_compression", "/render/options/compression", "unsupported raw-preserving compression method") unless [0, 8].include?(compression)
+      unless [
+        0, 8
+      ].include?(compression)
+        raise render_error('unsupported_compression', '/render/options/compression',
+                           'unsupported raw-preserving compression method')
+      end
 
       source = source.b
       source_inventory = parse_zip_inventory(source)
       central = scan_central_directory(source)
       source_entries = entries_by_path(source_inventory.entries)
       raw_ranges = raw_local_record_ranges(source, source_entries)
-      output = +"".b
+      output = +''.b
       central_records = []
       entries = entries_by_path(plan.entries)
       plan.member_decisions.each do |member|
         entry = entries[member.normalized_path]
         case member.operation
-        when "reject"
-          raise render_error("rejected_member", schema_path(member.normalized_path), member.reason)
-        when "delete"
+        when 'reject'
+          raise render_error('rejected_member', schema_path(member.normalized_path), member.reason)
+        when 'delete'
           next
-        when "preserve"
+        when 'preserve'
           source_entry = source_entries.fetch(member.normalized_path)
           validate_raw_preserve_entry!(source, central, source_entry)
           range = raw_ranges.fetch(member.normalized_path)
           offset = output.bytesize
           output << source.byteslice(range.start_byte...range.end_byte)
           central_records << central_record_from_entry(source_entry, offset)
-        when "add", "rewrite", "delegate"
+        when 'add', 'rewrite', 'delegate'
           content = member_bytes.fetch(member.normalized_path)
           rendered, record = rendered_local_record(entry, content.b, compression, output.bytesize)
           output << rendered
@@ -138,12 +151,14 @@ module Zip
       output << eocd_record(central_records.length, central_size, central_start)
       report = parse_zip_inventory(output)
       merge_report = plan.merge_report
-      merge_report.preserved_ranges = plan.member_decisions.filter_map { |member| raw_ranges[member.normalized_path] if member.operation == "preserve" }
+      merge_report.preserved_ranges = plan.member_decisions.filter_map do |member|
+        raw_ranges[member.normalized_path] if member.operation == 'preserve'
+      end
       [output, report, merge_report]
     end
 
     def new_stored_zip(entries)
-      output = +"".b
+      output = +''.b
       central = []
       entries.keys.sort.each do |name|
         rendered, record = rendered_local_record(path_entry(name, entries[name]), entries[name].b, 0, output.bytesize)
@@ -157,34 +172,38 @@ module Zip
     end
 
     def empty_report
-      TreeHaver::BinaryMergeReport.new(format: "zip", schema: "zip.ksy", matched_schema_paths: [], preserved_ranges: [], rewritten_nodes: [], checksum_updates: [], nested_dispatches: [], diagnostics: [])
+      Binary::Merge.preservation_report(format: 'zip', schema: 'zip.ksy', matched_schema_paths: [],
+                                        preserved_ranges: [])
     end
 
     def scan_central_directory(source)
       eocd = source.bytesize - 22
-      eocd -= 1 while eocd >= 0 && source.byteslice(eocd, 4).unpack1("V") != EOCD
-      raise "missing ZIP end of central directory" if eocd.negative?
-      size = source.byteslice(eocd + 12, 4).unpack1("V")
-      offset = source.byteslice(eocd + 16, 4).unpack1("V")
-      comment_length = source.byteslice(eocd + 20, 2).unpack1("v")
+      eocd -= 1 while eocd >= 0 && source.byteslice(eocd, 4).unpack1('V') != EOCD
+      raise 'missing ZIP end of central directory' if eocd.negative?
+
+      size = source.byteslice(eocd + 12, 4).unpack1('V')
+      offset = source.byteslice(eocd + 16, 4).unpack1('V')
+      comment_length = source.byteslice(eocd + 20, 2).unpack1('v')
       records = {}
       cursor = offset
       while cursor < offset + size
-        raise "unexpected central directory record" unless source.byteslice(cursor, 4).unpack1("V") == CENTRAL
-        name_len = source.byteslice(cursor + 28, 2).unpack1("v")
-        extra_len = source.byteslice(cursor + 30, 2).unpack1("v")
-        comment_len = source.byteslice(cursor + 32, 2).unpack1("v")
+        raise 'unexpected central directory record' unless source.byteslice(cursor, 4).unpack1('V') == CENTRAL
+
+        name_len = source.byteslice(cursor + 28, 2).unpack1('v')
+        extra_len = source.byteslice(cursor + 30, 2).unpack1('v')
+        comment_len = source.byteslice(cursor + 32, 2).unpack1('v')
         name = source.byteslice(cursor + 46, name_len)
         records[name] = {
-          range: TreeHaver::ByteRange.new(start_byte: cursor, end_byte: cursor + 46 + name_len + extra_len + comment_len),
-          flags: source.byteslice(cursor + 8, 2).unpack1("v"),
-          method: source.byteslice(cursor + 10, 2).unpack1("v"),
-          crc32: source.byteslice(cursor + 16, 4).unpack1("V"),
-          compressed_size: source.byteslice(cursor + 20, 4).unpack1("V"),
-          uncompressed_size: source.byteslice(cursor + 24, 4).unpack1("V"),
+          range: TreeHaver::ByteRange.new(start_byte: cursor,
+                                          end_byte: cursor + 46 + name_len + extra_len + comment_len),
+          flags: source.byteslice(cursor + 8, 2).unpack1('v'),
+          method: source.byteslice(cursor + 10, 2).unpack1('v'),
+          crc32: source.byteslice(cursor + 16, 4).unpack1('V'),
+          compressed_size: source.byteslice(cursor + 20, 4).unpack1('V'),
+          uncompressed_size: source.byteslice(cursor + 24, 4).unpack1('V'),
           extra_length: extra_len,
           comment_length: comment_len,
-          local_offset: source.byteslice(cursor + 42, 4).unpack1("V")
+          local_offset: source.byteslice(cursor + 42, 4).unpack1('V')
         }
         cursor = records[name][:range].end_byte
       end
@@ -194,32 +213,67 @@ module Zip
     def scan_local_headers(source, records)
       records.transform_values do |record|
         cursor = record[:local_offset]
-        raise "unexpected ZIP local header" unless source.byteslice(cursor, 4).unpack1("V") == LOCAL
-        name_len = source.byteslice(cursor + 26, 2).unpack1("v")
-        extra_len = source.byteslice(cursor + 28, 2).unpack1("v")
+        raise 'unexpected ZIP local header' unless source.byteslice(cursor, 4).unpack1('V') == LOCAL
+
+        name_len = source.byteslice(cursor + 26, 2).unpack1('v')
+        extra_len = source.byteslice(cursor + 28, 2).unpack1('v')
         { data_start: cursor + 30 + name_len + extra_len, extra_length: extra_len }
       end
     end
 
     def validate_raw_preserve_entry!(source, central, entry)
-      raise render_error("archive_comment", "/archive/comment", "raw-preserving ZIP renderer does not yet preserve archive comments") if central[:archive_comment]
+      if central[:archive_comment]
+        raise render_error('archive_comment', '/archive/comment',
+                           'raw-preserving ZIP renderer does not yet preserve archive comments')
+      end
+
       record = central[:records].fetch(entry.path)
-      raise render_error("encrypted_member", schema_path(entry.normalized_path), "raw-preserving ZIP renderer rejects encrypted member #{entry.normalized_path}") unless (record[:flags] & 0x1).zero?
-      raise render_error("unsupported_compression", schema_path(entry.normalized_path), "raw-preserving ZIP renderer rejects unsupported compression #{entry.compression.inspect}") unless [0, 8].include?(record[:method])
-      raise render_error("central_directory_extra_field", schema_path(entry.normalized_path), "raw-preserving ZIP renderer does not yet preserve central-directory extra fields for #{entry.normalized_path}") unless record[:extra_length].zero?
-      raise render_error("member_comment", schema_path(entry.normalized_path), "raw-preserving ZIP renderer does not yet preserve member comments for #{entry.normalized_path}") unless record[:comment_length].zero?
-      local_extra = source.byteslice(entry.local_header_range.start_byte + 28, 2).unpack1("v")
-      raise render_error("local_header_extra_field", schema_path(entry.normalized_path), "raw-preserving ZIP renderer does not yet preserve local extra fields for #{entry.normalized_path}") unless local_extra.zero?
+      unless (record[:flags] & 0x1).zero?
+        raise render_error('encrypted_member', schema_path(entry.normalized_path),
+                           "raw-preserving ZIP renderer rejects encrypted member #{entry.normalized_path}")
+      end
+      unless [
+        0, 8
+      ].include?(record[:method])
+        raise render_error('unsupported_compression', schema_path(entry.normalized_path),
+                           "raw-preserving ZIP renderer rejects unsupported compression #{entry.compression.inspect}")
+      end
+      unless record[:extra_length].zero?
+        raise render_error('central_directory_extra_field', schema_path(entry.normalized_path),
+                           "raw-preserving ZIP renderer does not yet preserve central-directory extra fields for #{entry.normalized_path}")
+      end
+      unless record[:comment_length].zero?
+        raise render_error('member_comment', schema_path(entry.normalized_path),
+                           "raw-preserving ZIP renderer does not yet preserve member comments for #{entry.normalized_path}")
+      end
+
+      local_extra = source.byteslice(entry.local_header_range.start_byte + 28, 2).unpack1('v')
+      return if local_extra.zero?
+
+      raise render_error('local_header_extra_field', schema_path(entry.normalized_path),
+                         "raw-preserving ZIP renderer does not yet preserve local extra fields for #{entry.normalized_path}")
     end
 
     def unsafe_entries(entries, records)
       seen = {}
       entries.flat_map do |entry|
         list = []
-        list << TreeHaver::ZipUnsafeEntry.new(path: entry.path, normalized_path: entry.normalized_path, category: "path_traversal", reason: "entry escapes the archive root") if escapes_root?(entry.path)
-        list << TreeHaver::ZipUnsafeEntry.new(path: entry.path, normalized_path: entry.normalized_path, category: "duplicate_normalized_path", reason: "normalized path collides with an existing entry") if seen[entry.normalized_path] && seen[entry.normalized_path] != entry.path
-        list << TreeHaver::ZipUnsafeEntry.new(path: entry.path, normalized_path: entry.normalized_path, category: "encrypted_member", reason: "encrypted member cannot be rendered by the default provider") unless (records[entry.path][:flags] & 0x1).zero?
-        list << TreeHaver::ZipUnsafeEntry.new(path: entry.path, normalized_path: entry.normalized_path, category: "signing_sensitive_member", reason: "signature-bearing member mutation is not enabled") if signing_sensitive?(entry.normalized_path)
+        if escapes_root?(entry.path)
+          list << TreeHaver::ZipUnsafeEntry.new(path: entry.path, normalized_path: entry.normalized_path,
+                                                category: 'path_traversal', reason: 'entry escapes the archive root')
+        end
+        if seen[entry.normalized_path] && seen[entry.normalized_path] != entry.path
+          list << TreeHaver::ZipUnsafeEntry.new(path: entry.path, normalized_path: entry.normalized_path,
+                                                category: 'duplicate_normalized_path', reason: 'normalized path collides with an existing entry')
+        end
+        unless (records[entry.path][:flags] & 0x1).zero?
+          list << TreeHaver::ZipUnsafeEntry.new(path: entry.path, normalized_path: entry.normalized_path,
+                                                category: 'encrypted_member', reason: 'encrypted member cannot be rendered by the default provider')
+        end
+        if signing_sensitive?(entry.normalized_path)
+          list << TreeHaver::ZipUnsafeEntry.new(path: entry.path, normalized_path: entry.normalized_path,
+                                                category: 'signing_sensitive_member', reason: 'signature-bearing member mutation is not enabled')
+        end
         seen[entry.normalized_path] = entry.path
         list
       end
@@ -228,57 +282,79 @@ module Zip
     def rendered_local_record(entry, content, method, offset)
       payload = method == 8 ? Zlib::Deflate.deflate(content) : content
       crc = Zlib.crc32(content)
-      header = [LOCAL, 20, 0, method].pack("Vvvv") + DOS_EPOCH + [crc, payload.bytesize, content.bytesize, entry.path.bytesize, 0].pack("VVVvv") + entry.path
-      [header + payload, { name: entry.path, method: method, crc32: crc, compressed_size: payload.bytesize, uncompressed_size: content.bytesize, offset: offset, flags: 0 }]
+      header = [LOCAL, 20, 0,
+                method].pack('Vvvv') + DOS_EPOCH + [crc, payload.bytesize, content.bytesize, entry.path.bytesize,
+                                                    0].pack('VVVvv') + entry.path
+      [header + payload,
+       { name: entry.path, method: method, crc32: crc, compressed_size: payload.bytesize, uncompressed_size: content.bytesize,
+         offset: offset, flags: 0 }]
     end
 
     def central_directory_record(record)
-      [CENTRAL, 20, 20, record[:flags], record[:method]].pack("Vvvvv") + DOS_EPOCH + [record[:crc32], record[:compressed_size], record[:uncompressed_size], record[:name].bytesize, 0, 0, 0, 0, 0, record[:offset]].pack("VVVvvvvvVV") + record[:name]
+      [CENTRAL, 20, 20, record[:flags],
+       record[:method]].pack('Vvvvv') + DOS_EPOCH + [record[:crc32], record[:compressed_size], record[:uncompressed_size],
+                                                     record[:name].bytesize, 0, 0, 0, 0, 0, record[:offset]].pack('VVVvvvvvVV') + record[:name]
     end
 
     def eocd_record(entries, size, offset)
-      [EOCD, 0, 0, entries, entries, size, offset, 0].pack("VvvvvVVv")
+      [EOCD, 0, 0, entries, entries, size, offset, 0].pack('VvvvvVVv')
     end
 
-    def raw_local_record_ranges(source, entries)
+    def raw_local_record_ranges(_source, entries)
       ordered = entries.values.sort_by { |entry| entry.local_header_range.start_byte }
       ordered.each_with_index.to_h do |entry, index|
         end_byte = ordered[index + 1]&.local_header_range&.start_byte || entry.central_directory_range.start_byte
-        [entry.normalized_path, TreeHaver::ByteRange.new(start_byte: entry.local_header_range.start_byte, end_byte: end_byte)]
+        [entry.normalized_path,
+         TreeHaver::ByteRange.new(start_byte: entry.local_header_range.start_byte, end_byte: end_byte)]
       end
     end
 
     def central_record_from_entry(entry, offset)
-      { name: entry.path, method: entry.compression == "deflate" ? 8 : 0, crc32: entry.crc32.to_i(16), compressed_size: entry.compressed_size, uncompressed_size: entry.uncompressed_size, offset: offset, flags: 0 }
+      { name: entry.path, method: entry.compression == 'deflate' ? 8 : 0, crc32: entry.crc32.to_i(16),
+        compressed_size: entry.compressed_size, uncompressed_size: entry.uncompressed_size, offset: offset, flags: 0 }
     end
 
     def path_entry(name, content)
-      TreeHaver::ZipArchiveEntry.new(path: name, normalized_path: normalize_zip_path(name), directory: name.end_with?("/"), compression: "stored", compressed_size: content.bytesize, uncompressed_size: content.bytesize, crc32: "%08x" % Zlib.crc32(content), local_header_range: TreeHaver::ByteRange.new(start_byte: 0, end_byte: 0), data_range: TreeHaver::ByteRange.new(start_byte: 0, end_byte: 0), central_directory_range: TreeHaver::ByteRange.new(start_byte: 0, end_byte: 0))
+      TreeHaver::ZipArchiveEntry.new(path: name, normalized_path: normalize_zip_path(name),
+                                     directory: name.end_with?('/'), compression: 'stored', compressed_size: content.bytesize, uncompressed_size: content.bytesize, crc32: '%08x' % Zlib.crc32(content), local_header_range: TreeHaver::ByteRange.new(start_byte: 0, end_byte: 0), data_range: TreeHaver::ByteRange.new(start_byte: 0, end_byte: 0), central_directory_range: TreeHaver::ByteRange.new(start_byte: 0, end_byte: 0))
     end
 
     def decision(report, path, operation, disposition, reason)
-      report.member_decisions << TreeHaver::ZipMemberDecision.new(normalized_path: path, operation: operation, disposition: disposition, reason: reason)
+      report.member_decisions << TreeHaver::ZipMemberDecision.new(normalized_path: path, operation: operation,
+                                                                  disposition: disposition, reason: reason)
       report.merge_report.rewritten_nodes << schema_path(path)
     end
 
     def normalize_zip_path(path)
-      path.tr("\\", "/").split("/").each_with_object([]) { |part, stack| part == ".." ? stack.pop : stack << part unless part == "." }.join("/")
+      path.tr('\\', '/').split('/').each_with_object([]) do |part, stack|
+        unless part == '.'
+          part == '..' ? stack.pop : stack << part
+        end
+      end.join('/')
     end
 
     def compression_name(method)
       case method
-      when 0 then "stored"
-      when 8 then "deflate"
+      when 0 then 'stored'
+      when 8 then 'deflate'
       else "method-#{method}"
       end
     end
 
     def escapes_root?(path)
-      path.start_with?("/") || path.tr("\\", "/").split("/").then { |parts| depth = 0; parts.any? { |part| part == ".." ? (depth -= 1) : (depth += 1 unless part == "."); depth.negative? } }
+      path.start_with?('/') || path.tr('\\', '/').split('/').then do |parts|
+        depth = 0
+        parts.any? do |part|
+          part == '..' ? (depth -= 1) : (depth += 1 unless part == '.')
+          depth.negative?
+        end
+      end
     end
 
     def signing_sensitive?(path)
-      path.upcase.start_with?("META-INF/") && [".RSA", ".DSA", ".EC", ".SF"].any? { |suffix| path.upcase.end_with?(suffix) }
+      path.upcase.start_with?('META-INF/') && ['.RSA', '.DSA', '.EC', '.SF'].any? do |suffix|
+        path.upcase.end_with?(suffix)
+      end
     end
 
     def same_entry?(left, right)
@@ -290,10 +366,11 @@ module Zip
     end
 
     def nested_family(path)
-      return "markdown" if path.match?(/\.m(?:d|arkdown)\z/i)
-      return "json" if path.end_with?(".json")
-      return "yaml" if path.match?(/\.ya?ml\z/i)
-      return "xml" if path.end_with?(".xml")
+      return 'markdown' if path.match?(/\.m(?:d|arkdown)\z/i)
+      return 'json' if path.end_with?('.json')
+      return 'yaml' if path.match?(/\.ya?ml\z/i)
+
+      'xml' if path.end_with?('.xml')
     end
 
     def schema_path(path)
@@ -301,7 +378,7 @@ module Zip
     end
 
     def diagnostic(category, schema_path, message)
-      TreeHaver::BinaryDiagnostic.new(severity: "error", category: category, message: message, schema_path: schema_path)
+      Binary::Merge.unsafe_diagnostic(schema_path: schema_path, byte_range: nil, message: message, category: category)
     end
 
     def render_error(category, schema_path, message)
@@ -309,3 +386,10 @@ module Zip
     end
   end
 end
+
+require 'binary/merge'
+require_relative 'merge/backend'
+require_relative 'merge/provider'
+
+Zip::Merge.register_backend!
+Zip::Merge.register_provider!

data/lib/zip-merge.rb

@@ -1,3 +1,9 @@
 # frozen_string_literal: true
 
-require_relative "zip/merge"
+require_relative 'zip/merge'
+require 'version_gem'
+require_relative 'zip/merge/version'
+
+Zip::Merge::Version.class_eval do
+  extend VersionGem::Basic
+end

data/sig/zip/merge.rbs

@@ -0,0 +1,21 @@
+module Zip
+  module Merge
+    class Provider < Binary::Merge::Provider
+      def provider_id: () -> String
+      def family: () -> String
+      def capabilities: () -> Hash[Symbol, untyped]
+      def analyze: (Hash[Symbol, untyped] request) -> Hash[Symbol, untyped]
+      def diff2: (Hash[Symbol, untyped] request) -> Hash[Symbol, untyped]
+      def merge2: (Hash[Symbol, untyped] request) -> Hash[Symbol, untyped]
+      def merge3: (Hash[Symbol, untyped] request) -> Hash[Symbol, untyped]
+    end
+
+    def self.merge_provider: () -> Provider
+    def self.register_provider!: () -> Hash[Symbol, untyped]
+
+    module Version
+      VERSION: String
+    end
+    VERSION: String
+  end
+end