multi_compress 0.3.5 → 0.5.0

data/lib/multi_compress/db_deployment.rb

@@ -0,0 +1,456 @@
+# frozen_string_literal: true
+
+require "multi_compress/version"
+require "digest"
+require "fileutils"
+require "json"
+require "optparse"
+require "pathname"
+require "rubygems/package"
+require "securerandom"
+require "tmpdir"
+require "zlib"
+
+module MultiCompress
+  module DBDeployment
+    ROOT = File.expand_path("../..", __dir__)
+    FORMAT = "MCDB1"
+    BUNDLE_FORMAT_VERSION = 1
+
+    class Error < StandardError; end
+
+    class CLI
+      def self.run(argv)
+        new.run(argv)
+      end
+
+      def run(argv)
+        command = argv.shift
+
+        case command
+        when "package"
+          PackageCommand.new.run(argv)
+        when "view"
+          ViewCommand.new.run(argv)
+        when "help", "--help", "-h", nil
+          puts help
+          0
+        else
+          raise OptionParser::InvalidOption, "unknown db command: #{command.inspect}"
+        end
+      rescue OptionParser::ParseError, Error => e
+        warn "multi_compress db: #{e.message}"
+        2
+      rescue SystemCallError, IOError => e
+        warn "multi_compress db: #{e.message}"
+        1
+      end
+
+      private
+
+      def help
+        <<~TEXT
+          Usage:
+            multi_compress db package postgres [--output PATH] [--force]
+            multi_compress db package mysql    [--output PATH] [--force]
+
+            multi_compress db view postgres --table SCHEMA.TABLE --column COLUMN \\
+              --view SCHEMA.VIEW --columns ID,CREATED_AT [--as PAYLOAD] \\
+              [--extension-schema multi_compress] [--output PATH]
+
+            multi_compress db view mysql --table SCHEMA.TABLE --column COLUMN \\
+              --view SCHEMA.VIEW --columns ID,CREATED_AT [--as PAYLOAD] [--output PATH]
+
+          `package` creates a self-contained source bundle for the DBA. The DBA
+          extracts it on the database host and runs `make doctor`, `sudo make
+          install`, then `make enable DB=...`.
+
+          `view` emits a safe readable-view definition so DBeaver users query
+          decoded text instead of the compressed bytea/BLOB column.
+        TEXT
+      end
+    end
+
+    class PackageCommand
+      TARGETS = %w[postgres mysql].freeze
+
+      def run(argv)
+        target = argv.shift
+        raise OptionParser::MissingArgument, "TARGET must be postgres or mysql" if target.nil?
+        raise OptionParser::InvalidArgument, "TARGET must be postgres or mysql" unless TARGETS.include?(target)
+
+        options = { output: nil, force: false }
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage: multi_compress db package #{target} [OPTIONS]"
+          opts.on("-o", "--output PATH", "write the deployment archive to PATH") { |value| options[:output] = value }
+          opts.on("-f", "--force", "overwrite an existing archive") { options[:force] = true }
+          opts.on("-h", "--help", "show this help") { puts opts; return 0 }
+        end
+        parser.parse!(argv)
+        raise OptionParser::InvalidOption, argv.join(" ") unless argv.empty?
+
+        output = options[:output] || "multi_compress-#{target}-#{MultiCompress::VERSION}.tar.gz"
+        DeploymentBundle.new(target, output, force: options[:force]).write!
+        puts File.expand_path(output)
+        0
+      end
+    end
+
+    class ViewCommand
+      TARGETS = %w[postgres mysql].freeze
+      IDENTIFIER = /\A[A-Za-z_][A-Za-z0-9_]*\z/.freeze
+
+      def run(argv)
+        target = argv.shift
+        raise OptionParser::MissingArgument, "TARGET must be postgres or mysql" if target.nil?
+        raise OptionParser::InvalidArgument, "TARGET must be postgres or mysql" unless TARGETS.include?(target)
+
+        options = { columns: [], as: "payload", output: nil, extension_schema: "multi_compress" }
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage: multi_compress db view #{target} --table SCHEMA.TABLE --column COLUMN --view SCHEMA.VIEW --columns ID,CREATED_AT [OPTIONS]"
+          opts.on("--table NAME", "source table, optionally schema-qualified") { |value| options[:table] = value }
+          opts.on("--column NAME", "compressed bytea/BLOB column") { |value| options[:column] = value }
+          opts.on("--view NAME", "destination view, optionally schema-qualified") { |value| options[:view] = value }
+          opts.on("--columns LIST", "comma-separated plain columns to expose") { |value| options[:columns] = value.split(",").map(&:strip) }
+          opts.on("--as NAME", "decoded column name (default: payload)") { |value| options[:as] = value }
+          if target == "postgres"
+            opts.on("--extension-schema NAME", "extension schema (default: multi_compress)") { |value| options[:extension_schema] = value }
+          end
+          opts.on("-o", "--output PATH", "write SQL to PATH instead of stdout") { |value| options[:output] = value }
+          opts.on("-h", "--help", "show this help") { puts opts; return 0 }
+        end
+        parser.parse!(argv)
+        raise OptionParser::InvalidOption, argv.join(" ") unless argv.empty?
+
+        sql = ReadableView.new(target, options).to_sql
+        if options[:output]
+          write_text_atomically(options[:output], sql)
+          puts File.expand_path(options[:output])
+        else
+          $stdout.write(sql)
+        end
+        0
+      end
+
+      private
+
+      def write_text_atomically(path, contents)
+        directory = File.dirname(File.expand_path(path))
+        FileUtils.mkdir_p(directory)
+        temporary = File.join(directory, ".multi-compress-view-#{Process.pid}-#{SecureRandom.hex(8)}")
+        File.open(temporary, "wb", 0o644) { |file| file.write(contents) }
+        File.rename(temporary, path)
+      ensure
+        File.delete(temporary) if defined?(temporary) && File.exist?(temporary)
+      end
+    end
+
+    class ReadableView
+      IDENTIFIER = /\A[A-Za-z_][A-Za-z0-9_]*\z/.freeze
+
+      def initialize(target, options)
+        @target = target
+        @table = qualified_identifier!(options.fetch(:table), "--table")
+        @view = qualified_identifier!(options.fetch(:view), "--view")
+        @column = identifier!(options.fetch(:column), "--column")
+        @columns = Array(options.fetch(:columns)).reject(&:empty?).map { |value| identifier!(value, "--columns") }
+        @decoded_name = identifier!(options.fetch(:as), "--as")
+        @extension_schema = identifier!(options.fetch(:extension_schema, "multi_compress"), "--extension-schema")
+        raise Error, "--columns must contain at least one plain column" if @columns.empty?
+        raise Error, "--columns must not contain duplicate names" unless @columns.uniq.length == @columns.length
+        raise Error, "--as must not duplicate a selected column" if @columns.include?(@decoded_name)
+      rescue KeyError
+        raise Error, "--table, --column, --view and --columns are required"
+      end
+
+      def to_sql
+        case @target
+        when "postgres" then postgres_sql
+        when "mysql" then mysql_sql
+        else raise Error, "unsupported database target: #{@target.inspect}"
+        end
+      end
+
+      private
+
+      def postgres_sql
+        selections = @columns.map { |column| "  source.#{pg_quote(column)}" }
+        selections << "  #{pg_quote(@extension_schema)}.multi_compress_db_decompress(source.#{pg_quote(@column)}) AS #{pg_quote(@decoded_name)}"
+
+        <<~SQL
+          -- Generated by multi_compress #{MultiCompress::VERSION}. Keep this view in your schema migrations.
+          -- Query it in DBeaver; do not expose the compressed column for ad-hoc reading.
+          CREATE OR REPLACE VIEW #{pg_qualified(@view)} AS
+          SELECT
+          #{selections.join(",\n")}
+          FROM #{pg_qualified(@table)} AS source;
+        SQL
+      end
+
+      def mysql_sql
+        selections = @columns.map { |column| "  source.#{mysql_quote(column)}" }
+        selections << "  CONVERT(multi_compress_db_decompress(source.#{mysql_quote(@column)}) USING utf8mb4) AS #{mysql_quote(@decoded_name)}"
+
+        <<~SQL
+          -- Generated by multi_compress #{MultiCompress::VERSION}. Keep this view in your schema migrations.
+          -- Query it in DBeaver; do not expose the compressed column for ad-hoc reading.
+          CREATE OR REPLACE VIEW #{mysql_qualified(@view)} AS
+          SELECT
+          #{selections.join(",\n")}
+          FROM #{mysql_qualified(@table)} AS source;
+        SQL
+      end
+
+      def qualified_identifier!(value, option)
+        pieces = value.to_s.split(".", -1)
+        unless pieces.length.between?(1, 2) && pieces.all? { |piece| IDENTIFIER.match?(piece) }
+          raise Error, "#{option} must be NAME or SCHEMA.NAME using letters, digits and underscores"
+        end
+        pieces
+      end
+
+      def identifier!(value, option)
+        string = value.to_s
+        raise Error, "#{option} must use letters, digits and underscores and cannot start with a digit" unless IDENTIFIER.match?(string)
+
+        string
+      end
+
+      def pg_quote(identifier)
+        %Q("#{identifier}")
+      end
+
+      def pg_qualified(pieces)
+        pieces.map { |piece| pg_quote(piece) }.join(".")
+      end
+
+      def mysql_quote(identifier)
+        "`#{identifier}`"
+      end
+
+      def mysql_qualified(pieces)
+        pieces.map { |piece| mysql_quote(piece) }.join(".")
+      end
+    end
+
+    class DeploymentBundle
+      DEFAULT_ARCHIVE_EPOCH = 315_619_200
+
+      class DeterministicTarWriter < Gem::Package::TarWriter
+        def self.new(io, epoch)
+          writer = allocate
+          writer.send(:initialize, io, epoch)
+          return writer unless block_given?
+
+          begin
+            yield writer
+          ensure
+            writer.close
+          end
+
+          nil
+        end
+
+        def initialize(io, epoch)
+          @archive_epoch = epoch
+          super(io)
+        end
+
+        def add_file_simple(name, mode, size)
+          check_closed
+
+          name, prefix = split_name(name)
+          header = Gem::Package::TarHeader.new(
+            name: name,
+            mode: mode,
+            size: size,
+            prefix: prefix,
+            mtime: @archive_epoch
+          ).to_s
+          @io.write(header)
+          output = BoundedStream.new(@io, size)
+          yield output if block_given?
+          @io.write("\0" * (size - output.written))
+          @io.write("\0" * ((512 - (size % 512)) % 512))
+          self
+        end
+
+        def mkdir(name, mode)
+          check_closed
+
+          name, prefix = split_name(name)
+          header = Gem::Package::TarHeader.new(
+            name: name,
+            mode: mode,
+            typeflag: "5",
+            size: 0,
+            prefix: prefix,
+            mtime: @archive_epoch
+          )
+          @io.write(header)
+          self
+        end
+      end
+
+      TARGETS = {
+        "postgres" => {
+          source_paths: %w[
+            db_core
+            postgres_extension
+            ext/multi_compress/vendor/zstd
+            docs/database-envelope-v1.md
+            LICENSE.txt
+            THIRD_PARTY_NOTICES.md
+          ],
+          template_path: "db_deployment/postgres"
+        },
+        "mysql" => {
+          source_paths: %w[
+            db_core
+            mysql_udf
+            ext/multi_compress/vendor/zstd
+            docs/database-envelope-v1.md
+            LICENSE.txt
+            THIRD_PARTY_NOTICES.md
+          ],
+          template_path: "db_deployment/mysql"
+        }
+      }.freeze
+
+      def initialize(target, output, force:)
+        @target = target
+        @output = File.expand_path(output)
+        @force = force
+        @root_name = "multi_compress-#{target}-#{MultiCompress::VERSION}"
+      end
+
+      def write!
+        raise Error, "deployment sources are unavailable from #{ROOT}" unless File.directory?(ROOT)
+        raise Error, "#{@output} already exists (use --force to overwrite)" if File.exist?(@output) && !@force
+
+        Dir.mktmpdir("multi-compress-db-package") do |temporary_directory|
+          bundle_root = File.join(temporary_directory, @root_name)
+          FileUtils.mkdir_p(bundle_root)
+          stage_payload!(bundle_root)
+          write_metadata!(bundle_root)
+          write_tarball!(temporary_directory)
+        end
+      end
+
+      private
+
+      def stage_payload!(bundle_root)
+        target = TARGETS.fetch(@target)
+        target.fetch(:source_paths).each do |relative|
+          copy_path!(relative, bundle_root)
+        end
+
+        template_root = File.join(ROOT, target.fetch(:template_path))
+        Dir.children(template_root).sort.each do |entry|
+          next if ignored?(entry)
+
+          copy_path!(File.join(target.fetch(:template_path), entry), bundle_root, destination: entry)
+        end
+      end
+
+      def copy_path!(relative, bundle_root, destination: relative)
+        source = File.join(ROOT, relative)
+        raise Error, "package source is missing: #{relative}" unless File.exist?(source)
+
+        destination_path = File.join(bundle_root, destination)
+        if File.directory?(source)
+          FileUtils.mkdir_p(destination_path)
+          Dir.children(source).sort.each do |entry|
+            next if ignored?(entry)
+
+            copy_path!(File.join(relative, entry), bundle_root, destination: File.join(destination, entry))
+          end
+        else
+          FileUtils.mkdir_p(File.dirname(destination_path))
+          FileUtils.copy_file(source, destination_path)
+          File.chmod(File.stat(source).mode & 0o777, destination_path)
+        end
+      end
+
+      def ignored?(entry)
+        entry == ".DS_Store" || entry == ".git" || entry == "build" || entry == "test"
+      end
+
+      def write_metadata!(bundle_root)
+        payload = regular_files(bundle_root).reject do |path|
+          %w[manifest.json SHA256SUMS].include?(File.basename(path))
+        end
+        files = payload.sort.map do |path|
+          relative = relative_to(bundle_root, path)
+          { "path" => relative, "sha256" => Digest::SHA256.file(path).hexdigest }
+        end
+
+        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(bundle_root, "manifest.json"), JSON.pretty_generate(manifest) + "\n")
+
+        checksum_paths = regular_files(bundle_root).reject { |path| File.basename(path) == "SHA256SUMS" }
+        checksums = checksum_paths.sort.map do |path|
+          "#{Digest::SHA256.file(path).hexdigest}  #{relative_to(bundle_root, path)}"
+        end
+        File.write(File.join(bundle_root, "SHA256SUMS"), checksums.join("\n") + "\n")
+      end
+
+      def write_tarball!(temporary_directory)
+        FileUtils.mkdir_p(File.dirname(@output))
+        temporary_output = File.join(
+          File.dirname(@output),
+          ".#{File.basename(@output)}.#{Process.pid}.#{SecureRandom.hex(8)}.tmp"
+        )
+
+        File.open(temporary_output, "wb", 0o644) do |file|
+          Zlib::GzipWriter.wrap(file) do |gzip|
+            gzip.mtime = archive_epoch
+            DeterministicTarWriter.new(gzip, archive_epoch) do |tar|
+              add_tree_to_tar!(tar, File.join(temporary_directory, @root_name), @root_name)
+            end
+          end
+        end
+        File.rename(temporary_output, @output)
+      ensure
+        File.delete(temporary_output) if defined?(temporary_output) && File.exist?(temporary_output)
+      end
+
+      def archive_epoch
+        value = ENV["SOURCE_DATE_EPOCH"]
+        return DEFAULT_ARCHIVE_EPOCH unless value&.match?(/\A\d+\z/)
+
+        value.to_i
+      end
+
+      def add_tree_to_tar!(tar, directory, archive_path)
+        tar.mkdir(archive_path, File.stat(directory).mode & 0o777)
+        Dir.children(directory).sort.each do |entry|
+          source = File.join(directory, entry)
+          destination = File.join(archive_path, entry)
+          if File.directory?(source)
+            add_tree_to_tar!(tar, source, destination)
+          else
+            mode = File.stat(source).mode & 0o777
+            tar.add_file_simple(destination, mode, File.size(source)) do |destination_io|
+              File.open(source, "rb") { |source_io| IO.copy_stream(source_io, destination_io) }
+            end
+          end
+        end
+      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

data/lib/multi_compress/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MultiCompress
-  VERSION = "0.3.5"
+  VERSION = "0.5.0"
 end

data/multi_compress.gemspec

@@ -0,0 +1,55 @@
+require_relative "lib/multi_compress/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "multi_compress"
+  spec.version       = MultiCompress::VERSION
+  spec.authors       = ["Roman Haydarov"]
+  spec.email         = ["romnhajdarov@gmail.com"]
+
+  spec.summary       = "Modern fiber-friendly compression for Ruby: zstd, lz4, brotli in one gem"
+  spec.description   = "Unified C-extension gem for zstd, lz4, and brotli compression. " \
+                        "One-shot, streaming, IO wrappers, dictionary support. " \
+                        "Fiber-friendly: cooperates with Fiber::Scheduler (async, falcon) " \
+                        "so CPU-heavy compression never blocks the event loop. " \
+                        "Ships vendored sources — no system libraries required."
+  spec.homepage      = "https://github.com/roman-haidarov/multi_compress"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 2.7.1"
+
+  spec.metadata["homepage_uri"]    = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"]   = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  spec.files = Dir[
+    "lib/**/*.rb",
+    "exe/*",
+    "docs/**/*.md",
+    "ext/**/*.{c,h,rb}",
+    "ext/multi_compress/vendor/**/*",
+    "ext/multi_compress/vendor/.vendored",
+    "db_core/**/*.{c,h}",
+    "postgres_extension/**/*",
+    "mysql_udf/**/*",
+    "db_deployment/**/*",
+    "multi_compress.gemspec",
+    "README.md",
+    "GET_STARTED.md",
+    "LICENSE.txt",
+    "THIRD_PARTY_NOTICES.md",
+    "CHANGELOG.md"
+  ].reject do |path|
+    File.basename(path) == ".DS_Store" ||
+      path.split(File::SEPARATOR).include?("build") ||
+      %w[.o .so .bundle .dylib .bc .d].include?(File.extname(path))
+  end
+
+  spec.bindir        = "exe"
+  spec.executables   = ["multi_compress"]
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/multi_compress/extconf.rb"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rake-compiler", "~> 1.2"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

data/mysql_udf/Makefile

@@ -0,0 +1,96 @@
+ZSTD_DIR      ?= ../ext/multi_compress/vendor/zstd/lib
+CORE_DIR      ?= ../db_core
+BUILD         ?= build
+CC            ?= gcc
+AR            ?= ar
+MYSQL_UDF_ABI ?= mysql57
+MYSQL_INCLUDE ?= /usr/include/mysql
+FIXTURES      ?= ../test/fixtures/database_v1
+
+ifeq ($(MYSQL_UDF_ABI),mysql57)
+MYSQL_UDF_CPPFLAGS := -DMCDB_MYSQL_UDF_ABI_57
+MYSQL_UDF_HEADER_CHECK :=
+else ifeq ($(MYSQL_UDF_ABI),system)
+MYSQL_UDF_CPPFLAGS := -I$(MYSQL_INCLUDE)
+MYSQL_UDF_HEADER_CHECK := test -f "$(MYSQL_INCLUDE)/mysql.h" || { echo "missing mysql.h: set MYSQL_INCLUDE=/path/to/mysql/include" >&2; exit 2; }
+else
+$(error MYSQL_UDF_ABI must be mysql57 or system)
+endif
+
+WARNFLAGS     ?= -Wall -Wextra -Werror
+CFLAGS        ?= -O2 -fPIC -std=c99 $(WARNFLAGS) -I$(ZSTD_DIR) -I$(CORE_DIR)/include
+ZSTD_CFLAGS   ?= -O2 -fPIC -std=c99 -I$(ZSTD_DIR) -I$(ZSTD_DIR)/common
+
+ZSTD_OBJ_DIR  := $(BUILD)/zstd
+ZSTD_C_SRCS   := $(wildcard $(ZSTD_DIR)/common/*.c) $(wildcard $(ZSTD_DIR)/decompress/*.c)
+ZSTD_C_OBJS   := $(patsubst $(ZSTD_DIR)/%.c,$(ZSTD_OBJ_DIR)/%.o,$(ZSTD_C_SRCS))
+
+ARCH := $(shell uname -m)
+ifneq (,$(filter x86_64 amd64,$(ARCH)))
+ZSTD_ASM_SRC  := $(ZSTD_DIR)/decompress/huf_decompress_amd64.S
+ifneq (,$(wildcard $(ZSTD_ASM_SRC)))
+ZSTD_ASM_OBJ  := $(ZSTD_OBJ_DIR)/decompress/huf_decompress_amd64.o
+endif
+endif
+
+ZSTD_OBJS     := $(ZSTD_C_OBJS) $(ZSTD_ASM_OBJ)
+ZSTD_LIB      := $(BUILD)/libzstd_dec.a
+UDF_SO        := $(BUILD)/multi_compress_mysql.so
+CLI           := $(BUILD)/mcdb_cli
+VALID_FIXTURES   := utf8_text empty_text large_text
+CORRUPT_FIXTURES := corrupt_magic wrong_version corrupt_payload corrupt_crc invalid_utf8 nul_text trailing_skippable trailing_frame
+
+.PHONY: all udf test fixtures clean
+all: udf
+
+$(BUILD):
+	mkdir -p $@
+
+$(ZSTD_OBJ_DIR)/%.o: $(ZSTD_DIR)/%.c
+	@mkdir -p $(dir $@)
+	$(CC) $(ZSTD_CFLAGS) -MMD -MP -c $< -o $@
+
+$(ZSTD_OBJ_DIR)/%.o: $(ZSTD_DIR)/%.S
+	@mkdir -p $(dir $@)
+	$(CC) -fPIC -I$(ZSTD_DIR) -c $< -o $@
+
+$(ZSTD_LIB): $(ZSTD_OBJS) | $(BUILD)
+	$(AR) rcs $@ $^
+
+$(UDF_SO): src/multi_compress_mysql.c $(CORE_DIR)/src/mcdb_format.c $(CORE_DIR)/include/mcdb_format.h $(ZSTD_LIB) | $(BUILD)
+	@$(MYSQL_UDF_HEADER_CHECK)
+	$(CC) $(CFLAGS) $(MYSQL_UDF_CPPFLAGS) -shared \
+	  src/multi_compress_mysql.c $(CORE_DIR)/src/mcdb_format.c $(ZSTD_LIB) \
+	  -o $@
+	@echo "built $@"
+
+udf: $(UDF_SO)
+
+$(CLI): $(CORE_DIR)/src/mcdb_format.c $(CORE_DIR)/include/mcdb_format.h test/mcdb_cli.c $(ZSTD_LIB) | $(BUILD)
+	$(CC) $(CFLAGS) $(CORE_DIR)/src/mcdb_format.c test/mcdb_cli.c $(ZSTD_LIB) -o $@
+
+fixtures:
+	RUBYLIB=../lib ruby $(FIXTURES)/generate.rb
+
+test: $(CLI)
+	@echo "== MCDB1 Ruby<->C parity =="
+	@fail=0; \
+	for name in $(VALID_FIXTURES); do \
+	  f=$(FIXTURES)/$$name.mcdb; exp=$(FIXTURES)/$$name.expected; \
+	  if [ ! -f $$f ] || [ ! -f $$exp ]; then echo "  MISSING $$name (run: make fixtures)"; fail=1; continue; fi; \
+	  if $(CLI) decode $$f | cmp -s - $$exp; then echo "  valid   $$name  OK"; \
+	  else echo "  valid   $$name  FAIL"; fail=1; fi; \
+	done; \
+	for name in $(CORRUPT_FIXTURES); do \
+	  f=$(FIXTURES)/$$name.mcdb; \
+	  if [ ! -f $$f ]; then echo "  MISSING $$name (run: make fixtures)"; fail=1; continue; fi; \
+	  if $(CLI) decode $$f >/dev/null 2>&1; then echo "  corrupt $$name  UNEXPECTEDLY VALID"; fail=1; \
+	  else echo "  corrupt $$name  correctly rejected"; fi; \
+	done; \
+	if [ $$fail -ne 0 ]; then echo "PARITY FAILED"; exit 1; fi; \
+	echo "PARITY OK"
+
+clean:
+	rm -rf $(BUILD)
+
+-include $(ZSTD_C_OBJS:.o=.d)