fontisan 0.4.46 → 0.4.48

data/rakelib/corpus_convert.rake

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../scripts/corpus/generate_convert_goldens"
+
+# Convert goldens (card 0c). `corpus:convert:verify` only compares;
+# `corpus:convert:regenerate` is the one task that writes. TIER=ci|large|all,
+# ONLY=<font-id>[,<font-id>] narrows verify/regenerate. Needs `opentype-sanitizer`
+# (OTS_PYTHON=<python with it>) and the pinned woff2_decompress.
+module ConvertTasks
+  module_function
+
+  def tiers
+    Corpus.tiers_for(ENV.fetch("TIER", "ci"))
+  end
+
+  def only
+    ENV["ONLY"]&.split(",")
+  end
+end
+
+namespace :corpus do
+  namespace :convert do
+    desc "Regenerate convert goldens from the reference (TIER, ONLY)"
+    task regenerate: "corpus:fetch" do
+      files = ConvertGoldens.generate(ConvertTasks.tiers, only: ConvertTasks.only)
+      ConvertGoldens.write(files)
+      puts "[corpus:convert:regenerate] wrote #{files.size} goldens"
+    rescue ConvertGoldens::ToolMissing, Corpus::Error => e
+      abort "[corpus:convert:regenerate] #{e.message}"
+    end
+
+    desc "Compare regenerated convert output with the committed goldens; never writes (TIER, ONLY)"
+    task verify: "corpus:fetch" do
+      problems = ConvertGoldens.verify(ConvertTasks.tiers, only: ConvertTasks.only)
+      problems.concat(ConvertGoldens.ots_failures.reject { |f| ConvertGoldens.listed_exceptions.include?(f) }
+                      .map { |f| "#{f}: OTS failure not listed in corpus/TRIAGE_CONVERT.md" })
+      abort "[corpus:convert:verify] #{problems.size} problem(s):\n  #{problems.join("\n  ")}" unless problems.empty?
+      puts "[corpus:convert:verify] ok"
+    rescue ConvertGoldens::ToolMissing => e
+      abort "[corpus:convert:verify] #{e.message}"
+    end
+  end
+end

data/rakelib/corpus_goldens.rake

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Read goldens (fontist/fontisan#156 card 0b). `corpus:verify` compares only
+# and never writes; `corpus:regenerate` rewrites the goldens and is explicit.
+namespace :corpus do
+  desc "Compare the read goldens with fresh output (TIER=ci|large, default ci); never writes"
+  task verify: :fetch do
+    require_relative "../scripts/corpus/generate_goldens"
+    tier = ENV.fetch("TIER", "ci")
+    problems = CorpusGoldens.verify(tier)
+    abort "[corpus:verify] #{problems.size} problem(s):\n  #{problems.join("\n  ")}" unless problems.empty?
+
+    puts "[corpus:verify] tier #{tier}: #{CorpusGoldens.entries(tier).size} read goldens match"
+  end
+
+  desc "Rewrite the read goldens from the corpus (TIER=ci|large); review the diff"
+  task regenerate: :fetch do
+    require_relative "../scripts/corpus/generate_goldens"
+    tier = ENV.fetch("TIER", "ci")
+    puts "[corpus:regenerate] wrote #{CorpusGoldens.write(tier)} goldens (tier #{tier})"
+  end
+end

data/rakelib/corpus_malformed.rake

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Malformed-input goldens (fontist/fontisan#156, card 0e).
+namespace :corpus do
+  namespace :malformed do
+    desc "Check corpus/goldens/malformed against current Ruby behaviour"
+    task :verify do
+      require_relative "../scripts/corpus/generate_malformed_goldens"
+      problems = MalformedGoldens.verify
+      abort "[corpus:malformed:verify]\n  #{problems.join("\n  ")}" unless problems.empty?
+      puts "[corpus:malformed:verify] ok (#{MalformedGoldens.entries.size} kinds)"
+    end
+
+    desc "Regenerate corpus/goldens/malformed (only in a PR that shows the golden diff)"
+    task :regenerate do
+      require_relative "../scripts/corpus/generate_malformed_goldens"
+      puts "[corpus:malformed:regenerate] wrote #{MalformedGoldens.regenerate} goldens"
+    end
+  end
+end

data/rakelib/corpus_scan.rake

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Scan goldens (fontist/fontisan#156 card 0f). `corpus:scan:verify` compares
+# only and never writes; `corpus:scan:regenerate` rewrites and is explicit.
+namespace :corpus do
+  namespace :scan do
+    desc "Compare corpus/goldens/scan with fresh Reference.scan output (TIER=ci|large); never writes"
+    task verify: "corpus:fetch" do
+      require_relative "../scripts/corpus/generate_scan_goldens"
+      tier = ENV.fetch("TIER", "ci")
+      problems = ScanGoldens.verify(tier)
+      abort "[corpus:scan:verify] #{problems.size} problem(s):\n  #{problems.join("\n  ")}" unless problems.empty?
+
+      puts "[corpus:scan:verify] tier #{tier}: #{ScanGoldens.entries(tier).size} scan goldens match"
+    end
+
+    desc "Rewrite the scan goldens (TIER=ci|large); review the diff"
+    task regenerate: "corpus:fetch" do
+      require_relative "../scripts/corpus/generate_scan_goldens"
+      tier = ENV.fetch("TIER", "ci")
+      puts "[corpus:scan:regenerate] wrote #{ScanGoldens.write(tier)} goldens (tier #{tier})"
+    end
+  end
+end

data/rakelib/java.rake

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# The `java`-platform gem (fontisan#156 card 2g). `brotli` is a C extension with
+# no JRuby build, and a gemspec is evaluated when the gem is built, so JRuby
+# gets its own gem: no `brotli`, no `rb_sys`, no magnus extension, a runtime
+# dependency on `ffi`, and the cdylib for every bundled OS and architecture
+# under lib/fontisan/ffi/<platform>/ (see Fontisan::FfiPlatform). WOFF2 there is
+# served by the :ffi tier.
+#
+#   rake java:gem                      # builds the host's cdylib, packs what is staged
+#   FONTISAN_JAVA_ALL=1 rake java:gem  # CI: the four are already staged (extracted
+#                                      # from the platform gems); fail unless all are
+#   rake java:stage                    # only copies the host's cdylib into its directory
+require "fileutils"
+require "rubygems/package"
+require_relative "../lib/fontisan/ffi_platform"
+
+# Builds the java gem's specification from fontisan.gemspec.
+module FontisanJavaGem
+  STAGED = "lib/fontisan/ffi/*/*fontisan_cdylib.{so,dylib,dll}"
+
+  def self.spec
+    # load caches its result: copy, or the mutations below reach the source spec.
+    base = Gem::Specification.load("fontisan.gemspec").dup
+    base.platform = "java"
+    base.extensions = []
+    base.dependencies.delete_if { |d| %w[brotli rb_sys].include?(d.name) }
+    base.add_dependency "ffi", "~> 1.15"
+    base.files = base.files.reject { |f| f.start_with?("ext/") } + Dir[STAGED]
+    base
+  end
+
+  def self.staged_platforms
+    Dir[STAGED].map { |f| File.basename(File.dirname(f)) }.uniq
+  end
+end
+
+namespace :java do
+  desc "Build the host cdylib and copy it to lib/fontisan/ffi/<platform>/"
+  task :stage do
+    next if ENV["FONTISAN_JAVA_ALL"]
+
+    dir = Fontisan::FfiPlatform.dir or abort "no java-gem directory for #{RbConfig::CONFIG['host_os']}"
+    Rake::Task["cdylib:vendor"].invoke
+    dest = File.join("lib/fontisan/ffi", dir)
+    FileUtils.mkdir_p(dest)
+    FileUtils.cp(Dir["lib/fontisan/ffi/*fontisan_cdylib.{so,dylib,dll}"], dest)
+  end
+
+  desc "Build pkg/fontisan-VERSION-java.gem without brotli, bundling the staged cdylibs"
+  task gem: :stage do
+    missing = Fontisan::FfiPlatform::DIRS - FontisanJavaGem.staged_platforms
+    abort "missing cdylibs for: #{missing.join(', ')}" if ENV["FONTISAN_JAVA_ALL"] && !missing.empty?
+    puts "bundling cdylibs for: #{FontisanJavaGem.staged_platforms.join(', ')}; not staged: #{missing.join(', ')}"
+
+    FileUtils.mkdir_p("pkg")
+    built = Gem::Package.build(FontisanJavaGem.spec)
+    FileUtils.mv(built, "pkg/")
+    puts "pkg/#{built}"
+  end
+end

data/rakelib/native.rake

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Builds the :native tier (ext/fontisan_native, magnus + rb-sys) into
+# lib/fontisan/native/ with `rake compile`, and the platform gems with
+# `rake native gem` (this machine) or rb-sys-dock / oxidize-rb/actions/cross-gem
+# (see .github/workflows/gem-build.yml). Needs a Rust toolchain: without cargo
+# (or the rb_sys gem) the task is not defined and every other task still loads.
+cargo = begin
+  system("cargo", "--version", out: File::NULL, err: File::NULL)
+rescue SystemCallError
+  false
+end
+
+# A musl cdylib cannot link with a static C runtime, and the native extension
+# is itself a shared object. rb-sys-dock exports the target as RUST_TARGET.
+rust_target = ENV["CARGO_BUILD_TARGET"] || ENV["RUST_TARGET"] || ENV.fetch("RUBY_TARGET", nil)
+if rust_target.to_s.include?("musl") && !ENV.fetch("RUSTFLAGS", "").include?("crt-static")
+  ENV["RUSTFLAGS"] = [ENV.fetch("RUSTFLAGS", nil), "-C target-feature=-crt-static"].compact.join(" ")
+end
+
+if cargo
+  begin
+    require "rb_sys/extensiontask"
+
+    RbSys::ExtensionTask.new("fontisan_native", Gem::Specification.load("fontisan.gemspec")) do |ext|
+      ext.ext_dir = "ext/fontisan_native"
+      ext.lib_dir = "lib/fontisan/native"
+
+      # Runs when a platform gem's spec is assembled. The platform gem carries
+      # its binaries and builds nothing at install: no extension, no rb_sys, no
+      # cdylib sources, and the cdylib built for this target (lib/fontisan/ffi)
+      # next to the magnus extension, so the :ffi tier works too.
+      ext.cross_compiling do |spec|
+        Rake::Task["cdylib:vendor"].invoke
+        spec.extensions.clear
+        spec.files.reject! { |f| f.start_with?("ext/") }
+        spec.files += Dir["lib/fontisan/ffi/*.{so,dylib,dll}"]
+      end
+    end
+  rescue LoadError
+    # rb_sys / rake-compiler absent: nothing to compile.
+  end
+end

data/scripts/build-woff2.sh

@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+# Build Google's woff2_decompress from a pinned source commit (brotli comes
+# pinned via the woff2 submodule). Used by the corpus to cross-check the
+# WOFF2 collection and, later, to compare WOFF/WOFF2 encode output after
+# decoding (compressed bytes depend on the brotli build, so they are not
+# compared directly).
+#
+# Why `make` and not CMake: upstream's CMakeLists.txt resolves brotli with
+# find_package (the SYSTEM brotli, measured: a CMake build on macOS linked
+# /opt/homebrew brotli), which would silently un-pin brotli. The Makefile
+# compiles the brotli submodule sources into the binary, so the whole decoder
+# is pinned by one commit.
+#
+# Linux / macOS: needs git, make, a C/C++ compiler.
+# Windows: run from an MSYS2 MINGW64 shell with
+#   pacman -S --needed git make mingw-w64-x86_64-gcc
+# (upstream google/woff2 has no Windows CI; this path is untested upstream.)
+#
+# Output: prints the absolute path of woff2_decompress on stdout (last line).
+# Override the install dir with WOFF2_DIR.
+set -euo pipefail
+
+PIN="7b67e12355fe7da148db5c19d4261f0a498a9537"
+REPO="https://github.com/google/woff2.git"
+root="$(cd "$(dirname "$0")/.." && pwd)"
+dest="${WOFF2_DIR:-$root/corpus/fonts/.tools/woff2}"
+src="$dest/src"
+exe="$dest/bin/woff2_decompress"
+case "$(uname -s)" in MINGW*|MSYS*|CYGWIN*) exe="$exe.exe" ;; esac
+
+if [ -x "$exe" ] && [ "$(cat "$dest/PIN" 2>/dev/null || true)" = "$PIN make" ]; then
+  echo "woff2_decompress already built at pin $PIN" >&2
+  echo "$exe"
+  exit 0
+fi
+
+command -v git >/dev/null || { echo "build-woff2: git is required" >&2; exit 1; }
+command -v make >/dev/null || { echo "build-woff2: make is required" >&2; exit 1; }
+
+rm -rf "$dest"
+mkdir -p "$dest/bin"
+git clone --recursive "$REPO" "$src" >&2
+(
+  cd "$src"
+  git checkout --quiet "$PIN"
+  git submodule update --init --recursive >&2
+  test "$(git rev-parse HEAD)" = "$PIN"
+)
+
+(cd "$src" && make woff2_decompress -j"$(getconf _NPROCESSORS_ONLN 2>/dev/null || echo 2)" >&2)
+
+built="$src/woff2_decompress"
+[ -f "$built" ] || built="$src/woff2_decompress.exe"
+[ -f "$built" ] || { echo "build-woff2: woff2_decompress not produced" >&2; exit 1; }
+cp "$built" "$exe"
+echo "$PIN make" > "$dest/PIN"
+echo "$exe"