multi_compress 0.5.0 → 0.6.1

data/lib/multi_compress/database/decoding.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module MultiCompress
+  module Database
+    class Engine
+      private
+
+      def decode_v1(blob, header)
+        frame = blob.byteslice(V1_HEADER_SIZE, blob.bytesize - V1_HEADER_SIZE) || +"".b
+        validate_canonical_zstd_frame!(frame, header.fetch(:original_size), expected_dictionary_id: 0)
+        out = MultiCompress.decompress(frame, algo: :zstd, max_output_size: MAX_OUTPUT)
+        validate_decoded!(blob, header, out)
+      end
+
+      def decode_v2(blob, header, dictionary)
+        dictionary = match_dictionary!(dictionary, header)
+        frame = blob.byteslice(V2_HEADER_SIZE, blob.bytesize - V2_HEADER_SIZE) || +"".b
+        validate_canonical_zstd_frame!(frame, header.fetch(:original_size), expected_dictionary_id: dictionary.zstd_id)
+        out = decompress_dictionary_frame(frame, dictionary)
+        validate_decoded!(blob, header, out)
+      end
+
+      def match_dictionary!(dictionary, header)
+        err("MCDB2 requires a dictionary") if dictionary.nil?
+        dictionary = database_dictionary!(dictionary)
+        expected_ref = header.fetch(:dictionary_ref)
+        return dictionary if dictionary.id == expected_ref
+
+        err("dictionary reference #{expected_ref} does not match supplied dictionary #{dictionary.id}")
+      end
+
+      def decompress_dictionary_frame(frame, dictionary)
+        MultiCompress.decompress(
+          frame,
+          algo: :zstd,
+          dictionary: dictionary.native,
+          max_output_size: MAX_OUTPUT
+        )
+      end
+    end
+  end
+end

data/lib/multi_compress/database/dictionary.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module MultiCompress
+  module Database
+    # A strict, immutable MCDB2 dictionary. It is intentionally distinct from
+    # MultiCompress::Dictionary: MCDB2 accepts only conformant zstd dictionaries
+    # with a non-zero zstd DictID and an application-level registry id.
+    class Dictionary
+      attr_reader :id, :bytes, :sha256, :zstd_id, :native
+
+      def self.train(samples, id:, size: 32 * 1024)
+        new(id: id, native: MultiCompress::Zstd.train_dictionary(samples, size: size))
+      end
+
+      def self.wrap(native, id:)
+        new(id: id, native: native)
+      end
+
+      def initialize(id:, native: nil, bytes: nil)
+        @id = normalize_id(id)
+        @native = build_native(native, bytes)
+        @bytes = validate_bytes(@native.bytes.b.freeze)
+        @zstd_id = validate_zstd_id(@native.zstd_id)
+        @sha256 = Digest::SHA256.digest(@bytes).freeze
+        freeze
+      end
+
+      def sha256_hex
+        sha256.unpack1("H*")
+      end
+
+      def registry_attributes
+        { id: id, zstd_dict_id: zstd_id, sha256: sha256, bytes: bytes }
+      end
+
+      private
+
+      def build_native(native, bytes)
+        raise ArgumentError, "provide exactly one of native: or bytes:" if (!!native) == (!!bytes)
+
+        value = native || MultiCompress::Dictionary.new(bytes, algo: :zstd)
+        return value if value.is_a?(MultiCompress::Dictionary) && value.algo == :zstd
+
+        raise TypeError, "MCDB2 dictionary must be a MultiCompress::Dictionary with algo: :zstd"
+      end
+
+      def validate_bytes(value)
+        return value unless value.empty? || value.bytesize > MAX_DICTIONARY_BYTES
+
+        raise ArgumentError,
+              "MCDB2 dictionary is #{value.bytesize} bytes; allowed range is 1..#{MAX_DICTIONARY_BYTES}"
+      end
+
+      def validate_zstd_id(value)
+        return value unless value.zero?
+
+        raise ArgumentError, "MCDB2 dictionary must be a conformant zstd dictionary with a non-zero DictID"
+      end
+
+      def normalize_id(value)
+        raise TypeError, "MCDB2 dictionary id must be an Integer" unless value.respond_to?(:to_int)
+
+        integer = value.to_int
+        unless integer.between?(1, MAX_DICTIONARY_REF)
+          raise ArgumentError, "MCDB2 dictionary id must be in 1..#{MAX_DICTIONARY_REF}"
+        end
+
+        integer
+      end
+    end
+  end
+end

data/lib/multi_compress/database/encoding.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module MultiCompress
+  module Database
+    class Engine
+      private
+
+      def input_bytes!(text, format:)
+        validate_input_type!(text)
+
+        bytes = utf8_bytes(text)
+        validate_input_size!(bytes, format)
+        bytes
+      end
+
+      def validate_input_type!(text)
+        return if text.is_a?(String)
+
+        raise TypeError, "MultiCompress::Database.compress expects a String, got #{text.class}"
+      end
+
+      def validate_input_size!(bytes, format)
+        size = bytes.bytesize
+        return unless size > MAX_OUTPUT
+
+        raise ArgumentError,
+              "MultiCompress::Database: input is #{size} bytes, over the #{MAX_OUTPUT}-byte #{format} limit"
+      end
+    end
+  end
+end

data/lib/multi_compress/database/header.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module MultiCompress
+  module Database
+    class Engine
+      private
+
+      def parse_header!(blob)
+        bytes = header_bytes!(blob)
+        version = bytes.getbyte(4)
+        validate_header_size!(bytes, version)
+        header_metadata(bytes, version)
+      end
+
+      def header_bytes!(blob)
+        unless blob.is_a?(String)
+          raise TypeError, "MultiCompress::Database.decompress expects a String, got #{blob.class}"
+        end
+
+        bytes = blob.b
+        err("truncated envelope (#{bytes.bytesize} < #{V1_HEADER_SIZE} bytes)") if bytes.bytesize < V1_HEADER_SIZE
+        err("bad magic") unless bytes.byteslice(0, 4) == MAGIC
+        bytes
+      end
+
+      def validate_header_size!(bytes, version)
+        header_size, max_envelope = envelope_limits(version)
+        if bytes.bytesize < header_size
+          err("truncated #{format_name(version)} envelope (#{bytes.bytesize} < #{header_size} bytes)")
+        end
+        if bytes.bytesize > max_envelope
+          err("stored #{format_name(version)} envelope is #{bytes.bytesize} bytes, over the #{max_envelope}-byte limit")
+        end
+        validate_fixed_header!(bytes)
+      end
+
+      def envelope_limits(version)
+        case version
+        when VERSION_V1 then [V1_HEADER_SIZE, MAX_ENVELOPE_V1]
+        when VERSION_V2 then [V2_HEADER_SIZE, MAX_ENVELOPE_V2]
+        else err("unsupported version #{version}")
+        end
+      end
+
+      def validate_fixed_header!(bytes)
+        err("unsupported codec #{bytes.getbyte(5)}") unless bytes.getbyte(5) == CODEC_ZSTD
+        err("reserved flags must be 0, got #{bytes.getbyte(6)}") unless bytes.getbyte(6) == FLAGS_NONE
+
+        original_size = bytes.byteslice(ORIGINAL_SIZE_OFFSET, 8).unpack1("Q<")
+        err("declared size #{original_size} over the #{MAX_OUTPUT}-byte limit") if original_size > MAX_OUTPUT
+      end
+
+      def header_metadata(bytes, version)
+        header = {
+          version: version,
+          header_size: version == VERSION_V2 ? V2_HEADER_SIZE : V1_HEADER_SIZE,
+          original_size: bytes.byteslice(ORIGINAL_SIZE_OFFSET, 8).unpack1("Q<"),
+          expected_crc: bytes.byteslice(CRC_OFFSET, 4).unpack1("L<")
+        }
+        header[:dictionary_ref] = dictionary_ref_from_header(bytes) if version == VERSION_V2
+        header
+      end
+
+      def dictionary_ref_from_header(bytes)
+        dictionary_ref = bytes.byteslice(DICTIONARY_REF_OFFSET, 8).unpack1("Q<")
+        err("invalid dictionary reference #{dictionary_ref}") unless dictionary_ref.between?(1, MAX_DICTIONARY_REF)
+        dictionary_ref
+      end
+    end
+  end
+end

data/lib/multi_compress/database/operations.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module MultiCompress
+  module Database
+    class Engine
+      # Without a dictionary this emits MCDB1. With Database::Dictionary it emits
+      # MCDB2. Choose one format per database column; mixed use is deliberately
+      # not what the generated dictionary view is optimized for.
+      def compress(text, dictionary: nil)
+        return compress_v1(text) if dictionary.nil?
+
+        compress_v2(text, dictionary: dictionary)
+      end
+
+      def compress_v1(text)
+        bytes = input_bytes!(text, format: "v1")
+        frame = MultiCompress.compress(bytes, algo: :zstd, level: ZSTD_LEVEL)
+        validate_canonical_zstd_frame!(frame, bytes.bytesize, expected_dictionary_id: 0)
+        envelope = header_v1(bytes.bytesize, MultiCompress.crc32(bytes)) << frame
+        check_envelope_size!(envelope, MAX_ENVELOPE_V1, "v1")
+        envelope
+      end
+
+      def compress_v2(text, dictionary:)
+        dictionary = database_dictionary!(dictionary)
+        bytes = input_bytes!(text, format: "v2")
+        frame = MultiCompress.compress(bytes, algo: :zstd, level: ZSTD_LEVEL, dictionary: dictionary.native)
+        validate_canonical_zstd_frame!(frame, bytes.bytesize, expected_dictionary_id: dictionary.zstd_id)
+        envelope = header_v2(bytes.bytesize, MultiCompress.crc32(bytes), dictionary.id) << frame
+        check_envelope_size!(envelope, MAX_ENVELOPE_V2, "v2")
+        envelope
+      end
+
+      def decompress(blob, dictionary: nil)
+        header = parse_header!(blob)
+        case header.fetch(:version)
+        when VERSION_V1
+          raise ArgumentError, "MCDB1 does not accept a dictionary" unless dictionary.nil?
+
+          decode_v1(blob.b, header)
+        when VERSION_V2
+          decode_v2(blob.b, header, dictionary)
+        else
+          err("unsupported version #{header.fetch(:version)}")
+        end
+      end
+
+      def valid?(blob, dictionary: nil)
+        decompress(blob, dictionary: dictionary)
+        true
+      rescue StandardError
+        false
+      end
+
+      # Parses only the envelope header. It is safe for registry/FK consistency
+      # checks and does not decompress the payload.
+      def dictionary_ref(blob)
+        header = parse_header!(blob)
+        return nil if header.fetch(:version) == VERSION_V1
+
+        header.fetch(:dictionary_ref)
+      end
+
+      def original_size(blob)
+        parse_header!(blob).fetch(:original_size)
+      end
+
+      def version_string
+        "MCDB1 + MCDB2 (zstd #{MultiCompress.version(:zstd)})"
+      end
+    end
+  end
+end

data/lib/multi_compress/database/validation.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module MultiCompress
+  module Database
+    class Engine
+      private
+
+      def validate_decoded!(_blob, header, out)
+        validate_decoded_size!(header, out)
+        validate_decoded_crc!(header, out)
+        validate_decoded_text(out)
+      end
+
+      def validate_decoded_size!(header, out)
+        expected_size = header.fetch(:original_size)
+        return if out.bytesize == expected_size
+
+        err("size mismatch: header says #{expected_size}, got #{out.bytesize}")
+      end
+
+      def validate_decoded_crc!(header, out)
+        expected_crc = header.fetch(:expected_crc)
+        actual_crc = MultiCompress.crc32(out)
+        return if actual_crc == expected_crc
+
+        err("crc32 mismatch: header #{expected_crc}, computed #{actual_crc}")
+      end
+
+      def validate_decoded_text(out)
+        text = out.force_encoding(Encoding::UTF_8)
+        err("decompressed bytes are not valid UTF-8") unless text.valid_encoding?
+        err("decompressed text contains a NUL byte") if text.include?("\0")
+        text
+      end
+
+      def utf8_bytes(text)
+        s = text.encoding == Encoding::UTF_8 ? text : text.dup.force_encoding(Encoding::UTF_8)
+        raise ArgumentError, "MultiCompress::Database: input is not valid UTF-8" unless s.valid_encoding?
+        raise ArgumentError, "MultiCompress::Database: input contains a NUL byte" if s.include?("\0")
+
+        s.b
+      end
+
+      def validate_canonical_zstd_frame!(frame, expected_size, expected_dictionary_id:)
+        _frame_size, content_size = MultiCompress.zstd_single_frame_info(frame)
+        if content_size != expected_size
+          err("zstd frame content size #{content_size} does not match header size #{expected_size}")
+        end
+        actual_dictionary_id = MultiCompress.zstd_frame_dictionary_id(frame)
+        if actual_dictionary_id != expected_dictionary_id
+          err("zstd frame dictionary id #{actual_dictionary_id} does not match expected #{expected_dictionary_id}")
+        end
+      rescue MultiCompress::DataError => e
+        err(e.message.sub(/\AMultiCompress::Database: /, ""))
+      end
+
+      def database_dictionary!(value)
+        return value if value.is_a?(Dictionary)
+
+        raise TypeError, "MCDB2 requires MultiCompress::Database::Dictionary, got #{value.class}"
+      end
+
+      def check_envelope_size!(envelope, max, format)
+        return if envelope.bytesize <= max
+
+        raise MultiCompress::DataError,
+              "MultiCompress::Database: stored #{format} envelope is #{envelope.bytesize} bytes, " \
+              "over the #{max}-byte limit"
+      end
+
+      def header_v1(original_size, crc32)
+        encode_header(VERSION_V1, original_size, crc32)
+      end
+
+      def header_v2(original_size, crc32, dictionary_ref)
+        encode_header(VERSION_V2, original_size, crc32, dictionary_ref)
+      end
+
+      def encode_header(version, original_size, crc32, dictionary_ref = nil)
+        header = MAGIC + [version, CODEC_ZSTD, FLAGS_NONE].pack("C3") +
+                 [original_size].pack("Q<") + [crc32].pack("L<")
+        header << [dictionary_ref].pack("Q<") unless dictionary_ref.nil?
+        header.b
+      end
+
+      def format_name(version)
+        version == VERSION_V2 ? "MCDB2" : "MCDB1"
+      end
+
+      def err(message)
+        raise MultiCompress::DataError, "MultiCompress::Database: #{message}"
+      end
+    end
+  end
+end

data/lib/multi_compress/database.rb

@@ -1,106 +1,40 @@
 # frozen_string_literal: true
 
+require "digest"
 require "multi_compress"
 
 module MultiCompress
+  # Long-term, SQL-readable envelopes. MCDB1 is dictionary-free. MCDB2 is an
+  # opt-in, dictionary-required format for one homogeneous database column.
   module Database
     MAGIC        = "MCDB".b
-    VERSION      = 1
+    VERSION_V1   = 1
+    VERSION_V2   = 2
+    VERSION      = VERSION_V1 # MCDB1 compatibility alias
     CODEC_ZSTD   = 1
-    FLAGS_V1     = 0
-    HEADER_SIZE  = 19                    # 4 magic +1 ver +1 codec +1 flags +8 size +4 crc32
-    MAX_OUTPUT   = 16 * 1024 * 1024      # 16 MiB decompressed, enforced on write and read
-    MAX_ENVELOPE = 16_842_771
+    FLAGS_NONE   = 0
+    FLAGS_V1     = FLAGS_NONE
+    V1_HEADER_SIZE = 19 # 4 magic + 1 version + 1 codec + 1 flags + 8 size + 4 crc32
+    V2_HEADER_SIZE = 27 # MCDB1 header + 8 byte application dictionary_ref
+    HEADER_SIZE    = V1_HEADER_SIZE
+    ORIGINAL_SIZE_OFFSET = 7
+    CRC_OFFSET           = 15
+    DICTIONARY_REF_OFFSET = 19
+    MAX_OUTPUT = 16 * 1024 * 1024
+    MAX_DICTIONARY_BYTES = 256 * 1024
+    MAX_DICTIONARY_REF = (2**63) - 1
+    MAX_ENVELOPE_V1 = 16_842_771
+    MAX_ENVELOPE_V2 = 16_842_779
+    MAX_ENVELOPE = MAX_ENVELOPE_V2
     ZSTD_LEVEL   = 6
-
-    module_function
-
-    def compress(text)
-      raise TypeError, "MultiCompress::Database.compress expects a String, got #{text.class}" unless text.is_a?(String)
-
-      bytes = utf8_bytes(text)
-      n = bytes.bytesize
-      if n > MAX_OUTPUT
-        raise ArgumentError, "MultiCompress::Database: input is #{n} bytes, over the #{MAX_OUTPUT}-byte v1 limit"
-      end
-
-      frame = MultiCompress.compress(bytes, algo: :zstd, level: ZSTD_LEVEL)
-      validate_canonical_zstd_frame!(frame, n)
-
-      envelope = header(n, MultiCompress.crc32(bytes)) << frame
-      if envelope.bytesize > MAX_ENVELOPE
-        raise MultiCompress::DataError,
-              "MultiCompress::Database: stored envelope is #{envelope.bytesize} bytes, over the #{MAX_ENVELOPE}-byte v1 limit"
-      end
-
-      envelope
-    end
-
-    def decompress(blob)
-      raise TypeError, "MultiCompress::Database.decompress expects a String, got #{blob.class}" unless blob.is_a?(String)
-
-      b = blob.b
-      err("truncated envelope (#{b.bytesize} < #{HEADER_SIZE} bytes)") if b.bytesize < HEADER_SIZE
-      err("stored envelope too large (#{b.bytesize} > #{MAX_ENVELOPE} bytes)") if b.bytesize > MAX_ENVELOPE
-      err("bad magic")                unless b.byteslice(0, 4) == MAGIC
-      err("unsupported version #{b.getbyte(4)}") unless b.getbyte(4) == VERSION
-      err("unsupported codec #{b.getbyte(5)}")   unless b.getbyte(5) == CODEC_ZSTD
-      err("reserved flags must be 0, got #{b.getbyte(6)}") unless b.getbyte(6) == FLAGS_V1
-
-      original_size = b.byteslice(7, 8).unpack1("Q<")
-      err("declared size #{original_size} over the #{MAX_OUTPUT}-byte v1 limit") if original_size > MAX_OUTPUT
-      expected_crc = b.byteslice(15, 4).unpack1("L<")
-
-      frame = b.byteslice(HEADER_SIZE, b.bytesize - HEADER_SIZE) || +"".b
-      validate_canonical_zstd_frame!(frame, original_size)
-      out = MultiCompress.decompress(frame, algo: :zstd, max_output_size: MAX_OUTPUT)
-      if out.bytesize != original_size
-        err("size mismatch: header says #{original_size}, got #{out.bytesize}")
-      end
-      actual_crc = MultiCompress.crc32(out)
-      err("crc32 mismatch: header #{expected_crc}, computed #{actual_crc}") if actual_crc != expected_crc
-
-      s = out.force_encoding(Encoding::UTF_8)
-      err("decompressed bytes are not valid UTF-8") unless s.valid_encoding?
-      err("decompressed text contains a NUL byte") if s.include?("\0")
-      s
-    end
-
-    def valid?(blob)
-      decompress(blob)
-      true
-    rescue StandardError
-      false
-    end
-
-    def version_string
-      "MCDB1 (zstd #{MultiCompress.version(:zstd)})"
-    end
-
-    def utf8_bytes(text)
-      s = text.encoding == Encoding::UTF_8 ? text : text.dup.force_encoding(Encoding::UTF_8)
-      raise ArgumentError, "MultiCompress::Database: input is not valid UTF-8" unless s.valid_encoding?
-      raise ArgumentError, "MultiCompress::Database: input contains a NUL byte" if s.include?("\0")
-
-      s.b
-    end
-
-    def validate_canonical_zstd_frame!(frame, expected_size)
-      _frame_size, content_size = MultiCompress.zstd_single_frame_info(frame)
-      err("zstd frame content size #{content_size} does not match header size #{expected_size}") if content_size != expected_size
-    rescue MultiCompress::DataError => e
-      err(e.message.sub(/\AMultiCompress::Database: /, ""))
-    end
-
-    def header(original_size, crc32)
-      (MAGIC + [VERSION, CODEC_ZSTD, FLAGS_V1].pack("C3") +
-        [original_size].pack("Q<") + [crc32].pack("L<")).b
-    end
-
-    def err(message)
-      raise MultiCompress::DataError, "MultiCompress::Database: #{message}"
-    end
-
-    private_class_method :utf8_bytes, :validate_canonical_zstd_frame!, :header, :err
   end
 end
+
+require "multi_compress/database/dictionary"
+require "multi_compress/database/operations"
+require "multi_compress/database/encoding"
+require "multi_compress/database/decoding"
+require "multi_compress/database/header"
+require "multi_compress/database/validation"
+
+require "multi_compress/database/api"

data/lib/multi_compress/db_deployment/bundle_archiver.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module MultiCompress
+  module DBDeployment
+    class BundleArchiver
+      DEFAULT_EPOCH = 315_619_200
+      attr_reader :output, :root_name
+      private :output, :root_name
+
+      def initialize(output, root_name)
+        @output = output
+        @root_name = root_name
+      end
+
+      def write!(temporary_directory)
+        temporary_output = temporary_path
+        FileUtils.mkdir_p(File.dirname(output))
+        write_archive(temporary_output, temporary_directory)
+        File.rename(temporary_output, output)
+      ensure
+        File.delete(temporary_output) if defined?(temporary_output) && File.exist?(temporary_output)
+      end
+
+      private
+
+      def temporary_path
+        File.join(File.dirname(output), ".#{File.basename(output)}.#{Process.pid}.#{SecureRandom.hex(8)}.tmp")
+      end
+
+      def write_archive(path, temporary_directory)
+        File.open(path, "wb", 0o644) do |file|
+          Zlib::GzipWriter.wrap(file) do |gzip|
+            gzip.mtime = archive_epoch
+            DeterministicTarWriter.new(gzip, archive_epoch) do |tar|
+              add_tree(tar, File.join(temporary_directory, root_name), root_name)
+            end
+          end
+        end
+      end
+
+      def archive_epoch
+        value = ENV.fetch("SOURCE_DATE_EPOCH", nil)
+        value&.match?(/\A\d+\z/) ? value.to_i : DEFAULT_EPOCH
+      end
+
+      def add_tree(tar, directory, archive_path)
+        tar.mkdir(archive_path, mode(directory))
+        Dir.children(directory).sort.each { |entry| add_entry(tar, directory, archive_path, entry) }
+      end
+
+      def add_entry(tar, directory, archive_path, entry)
+        source = File.join(directory, entry)
+        destination = File.join(archive_path, entry)
+        return add_tree(tar, source, destination) if File.directory?(source)
+
+        add_file(tar, source, destination)
+      end
+
+      def add_file(tar, source, destination)
+        tar.add_file_simple(destination, mode(source), File.size(source)) do |destination_io|
+          File.open(source, "rb") { |source_io| IO.copy_stream(source_io, destination_io) }
+        end
+      end
+
+      def mode(path)
+        File.stat(path).mode & 0o777
+      end
+    end
+  end
+end

data/lib/multi_compress/db_deployment/bundle_metadata.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module MultiCompress
+  module DBDeployment
+    class BundleMetadata
+      attr_reader :target
+      private :target
+
+      def initialize(target)
+        @target = target
+      end
+
+      def write!(bundle_root)
+        write_manifest(bundle_root, manifest_files(bundle_root))
+        write_checksums(bundle_root)
+      end
+
+      private
+
+      def manifest_files(root)
+        regular_files(root).reject { |path| %w[manifest.json SHA256SUMS].include?(File.basename(path)) }
+                           .sort.map { |path| file_record(root, path) }
+      end
+
+      def file_record(root, path)
+        { "path" => relative_to(root, path), "sha256" => Digest::SHA256.file(path).hexdigest }
+      end
+
+      def write_manifest(root, files)
+        manifest = {
+          "bundle_format_version" => BUNDLE_FORMAT_VERSION,
+          "gem" => { "name" => "multi_compress", "version" => MultiCompress::VERSION },
+          "database_target" => target,
+          "database_envelope" => FORMAT,
+          "files" => files
+        }
+        File.write(File.join(root, "manifest.json"), "#{JSON.pretty_generate(manifest)}\n")
+      end
+
+      def write_checksums(root)
+        checksums = regular_files(root).reject { |path| File.basename(path) == "SHA256SUMS" }.sort.map do |path|
+          "#{Digest::SHA256.file(path).hexdigest}  #{relative_to(root, path)}"
+        end
+        File.write(File.join(root, "SHA256SUMS"), "#{checksums.join("\n")}\n")
+      end
+
+      def regular_files(root)
+        Dir.glob(File.join(root, "**", "*"), File::FNM_DOTMATCH).select { |path| File.file?(path) }
+      end
+
+      def relative_to(root, path)
+        Pathname.new(path).relative_path_from(Pathname.new(root)).to_s
+      end
+    end
+  end
+end