openscad-cpp-evaluator 1.13.0__tar.gz → 1.14.0__tar.gz

{openscad_cpp_evaluator-1.13.0 → openscad_cpp_evaluator-1.14.0}/CLAUDE.md

@@ -276,7 +276,16 @@ OpenSCAD's `detect_properties()`/`detect_script()` does by hand.
 `resolveFont()` never fails. An unmatched family falls back to the bundled Liberation Sans
 (`resources/fonts/`, embedded into the binary by `cmake/embed_font.cmake`, byte-identical to the
 Python reference's own bundled font), which is both the default and the last-resort fallback — so
-`text()` draws something even on a machine with no fonts installed at all. That mirrors
+`text()` draws something even on a machine with no fonts installed at all.
+**All four styles are bundled** (Regular, Bold, Italic, Bold Italic), and they are seeded into the
+face index ahead of anything installed, so `style=` resolves the same way on every machine.
+Bundling only Regular meant a `style=Bold` nothing installed could satisfy fell silently back to
+Regular — `fontmetrics(10, "Liberation Sans:style=bold")` then reported Regular's numbers under
+the name the script asked for (BelfrySCAD #381). A bundled entry's `path` is the sentinel
+`"<bundled>"` and its `faceIndex` is the already-open handle, so `resolveFont` opens no file for it.
+`FreetypeFontProvider::listFonts()` returns every resolvable face (family, style, path), sorted and
+deduplicated by family+style — reached from Python as `list_fonts()`, which adds the exact `font=`
+spec for each. It is the only call here that forces the system scan the rest of the class defers. That mirrors
 fontconfig's own never-fails matching, and so real OpenSCAD's: a missing font silently becomes the
 nearest available one rather than an error.
 
@@ -289,6 +298,14 @@ variable real OpenSCAD reads). Family match is case-insensitive and required; st
 dropping to Regular beats falling through to an unrelated family, which is what fontconfig does
 too.
 
+**`font` is a POSITIONAL argument in both metrics functions**, and so is everything after it:
+`fontmetrics(size, font)` and `textmetrics(text, size, font, direction, language, script, halign,
+valign, spacing)`. Verified against the 2026.02.01 binary rather than read off a doc page. Having
+`font` name-only meant `fontmetrics(10, "Liberation Sans:style=Bold")` — how the bug report was
+written, and how real OpenSCAD reads it — was taken as *no font at all*, so the default face was
+measured and reported under the requested name. That was the visible half of BelfrySCAD #381; the
+bundled-styles gap above was the other.
+
 `text_metrics.hpp`/`.cpp` holds the shared layout math (`measureText`/`textAlignOffset`) used by
 both `text()` (`builtins/text.cpp`) and `textmetrics()`/`fontmetrics()` (`function_builtins.cpp`).
 Sharing it is the point: the numbers a script positions against cannot disagree with what it

{openscad_cpp_evaluator-1.13.0 → openscad_cpp_evaluator-1.14.0}/CMakeLists.txt

@@ -218,13 +218,30 @@ FetchContent_MakeAvailable(cpp_linenoise)
 # a real installed/packaged build (e.g. the PyPI wheel) has no guarantee the
 # source tree's resources/fonts/ is present or at any predictable path
 # alongside the installed shared library.
-set(BUNDLED_FONT_SRC ${CMAKE_CURRENT_SOURCE_DIR}/resources/fonts/LiberationSans-Regular.ttf)
+# The whole Liberation Sans family, not just Regular: a `style=` that
+# cannot be satisfied silently falls back to the regular face, which is
+# what made fontmetrics(10, "Liberation Sans:style=bold") report Regular's
+# numbers (BelfrySCAD #381). Regular stays FIRST -- it is the default face
+# and the last-resort fallback.
+set(BUNDLED_FONT_SRCS
+  ${CMAKE_CURRENT_SOURCE_DIR}/resources/fonts/LiberationSans-Regular.ttf
+  ${CMAKE_CURRENT_SOURCE_DIR}/resources/fonts/LiberationSans-Bold.ttf
+  ${CMAKE_CURRENT_SOURCE_DIR}/resources/fonts/LiberationSans-Italic.ttf
+  ${CMAKE_CURRENT_SOURCE_DIR}/resources/fonts/LiberationSans-BoldItalic.ttf
+)
 set(BUNDLED_FONT_HEADER ${CMAKE_CURRENT_BINARY_DIR}/generated/openscad_cpp_evaluator/bundled_font_data.hpp)
+# Joined into ONE argument, and quoted. Left as a ";" list,
+# add_custom_command expands it into separate arguments and the font paths
+# land where -P expects the script; joined with "|" but unquoted, make
+# emits a bare pipe and the shell splits the command in two. The separator
+# is "@" for the same reason -- no shell meaning, and no filesystem here
+# puts one in a path.
+string(REPLACE ";" "@" BUNDLED_FONT_SRCS_ARG "${BUNDLED_FONT_SRCS}")
 add_custom_command(
   OUTPUT ${BUNDLED_FONT_HEADER}
-  COMMAND ${CMAKE_COMMAND} -DIN_FILE=${BUNDLED_FONT_SRC} -DOUT_FILE=${BUNDLED_FONT_HEADER}
+  COMMAND ${CMAKE_COMMAND} "-DIN_FILES=${BUNDLED_FONT_SRCS_ARG}" -DOUT_FILE=${BUNDLED_FONT_HEADER}
           -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/embed_font.cmake
-  DEPENDS ${BUNDLED_FONT_SRC} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/embed_font.cmake
+  DEPENDS ${BUNDLED_FONT_SRCS} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/embed_font.cmake
   COMMENT "Embedding bundled font bytes into bundled_font_data.hpp"
 )
 add_custom_target(generate_bundled_font DEPENDS ${BUNDLED_FONT_HEADER})

{openscad_cpp_evaluator-1.13.0 → openscad_cpp_evaluator-1.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.13.0
+Version: 1.14.0
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT

{openscad_cpp_evaluator-1.13.0 → openscad_cpp_evaluator-1.14.0}/bindings/module.cpp

@@ -23,6 +23,7 @@
 #include "openscad_cpp_evaluator/eval_use.hpp"
 #include "openscad_cpp_evaluator/evaluator.hpp"
 #include "openscad_cpp_evaluator/export.hpp"
+#include "openscad_cpp_evaluator/freetype_font_provider.hpp"
 #include "openscad_cpp_evaluator/mesh_check.hpp"
 #include "openscad_cpp_evaluator/manifold_cache.hpp"
 #include "openscad_cpp_evaluator/profile.hpp"
@@ -869,6 +870,31 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           "add-meta-data, title, author, subject, keywords). An unknown key raises rather than "
           "being ignored. .pdf is 2D-only too, and centres the drawing on a fixed paper size.");
 
+    m.def("list_fonts", []() {
+        nb::list out;
+        oscadeval::FreetypeFontProvider provider;
+        for (const oscadeval::FontFace& f : provider.listFonts()) {
+            nb::dict d;
+            d["family"] = f.family;
+            d["style"] = f.style;
+            // The exact string to put in font=. Style included only when
+            // it is not the plain face: "Liberation Sans" is what you
+            // write for Regular, and printing the longer form for it would
+            // teach the wrong habit.
+            const bool plain = f.style.empty() || f.style == "Regular";
+            d["spec"] = plain ? f.family : f.family + ":style=" + f.style;
+            d["path"] = f.path;
+            out.append(d);
+        }
+        return out;
+    },
+          "Every font text()/textmetrics()/fontmetrics() can resolve: family, style, the exact "
+          "`font=` spec that selects it, and the file it comes from (\"<bundled>\" for the "
+          "faces shipped with this package). Read from the same FreeType index those functions "
+          "match against, NOT from the windowing toolkit -- a system font database names faces "
+          "differently, which is the whole reason a list is worth showing. Scans the system font "
+          "directories, so it costs real time on a machine with many fonts.");
+
     m.def("export_extensions", []() { return oscadeval::exportExtensions(); },
           "The file extensions export_model understands, dot-prefixed. Read from the C++ writer table "
           "rather than restated here, so the Python side cannot drift from what can actually be written.");

openscad_cpp_evaluator-1.14.0/cmake/embed_font.cmake

@@ -0,0 +1,71 @@
+# Reads IN_FILES (a ";"-separated list of binaries) and writes OUT_FILE: a
+# C++ header exposing their bytes as static arrays, plus a kBundledFonts
+# table over them. Run via
+# `cmake -DIN_FILES="a.ttf;b.ttf" -DOUT_FILE=... -P embed_font.cmake` as a
+# build-time add_custom_command, not configure_file -- fonts baked in as
+# bytes have no runtime file path to go stale once the shared library is
+# installed somewhere other than its own build tree (see this script's own
+# call site in the top-level CMakeLists.txt for the packaging bug this
+# replaces).
+#
+# More than one font, because a style= that cannot be satisfied is worse
+# than useless: it silently returns the regular face, which is what made
+# `fontmetrics(10, "Liberation Sans:style=bold")` report Regular's numbers
+# (BelfrySCAD #381). The whole family is embedded so the styles a script
+# asks for exist even on a machine with no fonts of its own.
+if(NOT DEFINED IN_FILES OR NOT DEFINED OUT_FILE)
+    message(FATAL_ERROR "embed_font.cmake requires -DIN_FILES=... -DOUT_FILE=...")
+endif()
+
+# "@"-joined by the caller into a single argument; see the call site for
+# why neither a ";" list nor a "|" join survives the trip.
+string(REPLACE "@" ";" IN_FILES "${IN_FILES}")
+
+set(_decls "")
+set(_table "")
+set(_index 0)
+foreach(_file IN LISTS IN_FILES)
+    file(READ "${_file}" _hex HEX)
+    string(LENGTH "${_hex}" _hexLen)
+    math(EXPR _byteCount "${_hexLen} / 2")
+    string(REGEX REPLACE "([0-9a-f][0-9a-f])" "0x\\1," _bytesCsv "${_hex}")
+    get_filename_component(_name "${_file}" NAME)
+    string(APPEND _decls
+"// ${_name}
+inline constexpr unsigned char kBundledFont${_index}[] = {
+${_bytesCsv}
+};
+")
+    string(APPEND _table "    {kBundledFont${_index}, ${_byteCount}},\n")
+    if(_index EQUAL 0)
+        set(_firstSize "${_byteCount}")
+    endif()
+    math(EXPR _index "${_index} + 1")
+endforeach()
+
+file(WRITE "${OUT_FILE}"
+"// Auto-generated by cmake/embed_font.cmake -- do not edit.
+#pragma once
+#include <cstddef>
+
+namespace oscadeval {
+
+${_decls}
+struct BundledFont {
+    const unsigned char* data;
+    std::size_t size;
+};
+
+// Index 0 is the default face and the last-resort fallback; the rest are
+// the other styles of the same family, so a `style=` request can be met
+// without anything installed on the machine.
+inline constexpr BundledFont kBundledFonts[] = {
+${_table}};
+inline constexpr std::size_t kBundledFontCount = ${_index};
+
+// The default face, named for the callers that only ever wanted that one.
+inline constexpr const unsigned char* kBundledFontData = kBundledFont0;
+inline constexpr std::size_t kBundledFontDataSize = ${_firstSize};
+
+} // namespace oscadeval
+")

{openscad_cpp_evaluator-1.13.0 → openscad_cpp_evaluator-1.14.0}/include/openscad_cpp_evaluator/freetype_font_provider.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "openscad_cpp_evaluator/font_match.hpp"
 #include "openscad_cpp_evaluator/font_provider.hpp"
 
 #include <memory>
@@ -30,6 +31,18 @@ public:
     std::optional<std::array<double, 4>> glyphInkBounds(FontHandle handle, GlyphId glyph) override;
     GlyphContours glyphOutline(FontHandle handle, GlyphId glyph, int segsPerCurve) override;
 
+    // Every face this provider can resolve: the bundled family first, then
+    // everything installed, sorted by family then style. Forces the system
+    // scan that the rest of the class defers, so it is the one call here
+    // that costs real time on a machine with a few hundred fonts.
+    //
+    // These are the names `font=` actually takes -- the point of showing
+    // them at all (BelfrySCAD #379: "the displayed font name can be
+    // different from the font name needed by OpenSCAD"). A list read from
+    // the windowing toolkit's font database would reproduce exactly that
+    // mismatch.
+    std::vector<FontFace> listFonts();
+
 private:
     struct Impl;
     std::unique_ptr<Impl> impl_;

{openscad_cpp_evaluator-1.13.0 → openscad_cpp_evaluator-1.14.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "1.13.0"
+version = "1.14.0"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-1.13.0 → openscad_cpp_evaluator-1.14.0}/python/openscad_cpp_evaluator/__init__.py

@@ -20,7 +20,7 @@ __all__ = [
     "ManifoldCache", "CallSiteProfile", "ProfileResult", "format_csg_tree", "bodies_from_dicts",
     "FastContinueSignal", "parse_ast", "parse_ast_string", "format_source",
     "check_mesh", "strip_slivers",
-    "export_model", "export_extensions",
+    "export_model", "export_extensions", "list_fonts",
 ]
 
 
@@ -342,6 +342,23 @@ def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
         raise EvalError(str(e)) from e
 
 
+def list_fonts() -> list:
+    """Every font `text()`/`textmetrics()`/`fontmetrics()` can resolve.
+
+    A list of dicts with `family`, `style`, `spec` and `path`. `spec` is
+    the exact string to put in `font=`, which is the point of asking:
+    the name a system font dialog shows is often not the name OpenSCAD
+    takes, and this list comes from the same FreeType index the text
+    functions match against. `path` is `"<bundled>"` for the faces
+    shipped with this package.
+
+    Scans the system font directories, so it costs real time on a machine
+    with many fonts -- call it when someone asks to see the list, not on
+    a hot path.
+    """
+    return list(_ext.list_fonts())
+
+
 def export_extensions() -> list:
     """The file extensions export_model understands, dot-prefixed.
 

{openscad_cpp_evaluator-1.13.0 → openscad_cpp_evaluator-1.14.0}/src/builtins/function_builtins.cpp

@@ -785,14 +785,21 @@ Value objectOf(std::vector<std::pair<std::string, Value>> items) {
 Value builtinTextmetrics(Evaluator& ev, const CallArgs& args) {
     const std::string text = asStringOr(getArg(args, 0, "text", Value{std::string("")}), "");
     const double size = toDoubleLenient(getArg(args, 1, "size", Value{10.0}));
-    const std::string halign = asStringOr(getArg(args, std::nullopt, "halign", Value{std::string("left")}), "left");
-    const std::string valign = asStringOr(getArg(args, std::nullopt, "valign", Value{std::string("baseline")}), "baseline");
-    const double spacing = toDoubleLenient(getArg(args, std::nullopt, "spacing", Value{1.0}));
-    const std::string fontSpec = asStringOr(getArg(args, std::nullopt, "font", Value{std::string("")}), "");
+    // Positional indices, all of them: OpenSCAD's own signature is
+    // textmetrics(text, size, font, direction, language, script, halign,
+    // valign, spacing) and it honours every one of those positionally --
+    // verified against the 2026.02.01 binary, not read off a doc page.
+    // `font` being name-only here is what made
+    // `textmetrics("Hi", 10, "Liberation Sans:style=Bold")` silently
+    // measure the default face (BelfrySCAD #381).
+    const std::string halign = asStringOr(getArg(args, 6, "halign", Value{std::string("left")}), "left");
+    const std::string valign = asStringOr(getArg(args, 7, "valign", Value{std::string("baseline")}), "baseline");
+    const double spacing = toDoubleLenient(getArg(args, 8, "spacing", Value{1.0}));
+    const std::string fontSpec = asStringOr(getArg(args, 2, "font", Value{std::string("")}), "");
     ShapeOptions shape;
-    shape.direction = asStringOr(getArg(args, std::nullopt, "direction", Value{std::string("")}), "");
-    shape.language = asStringOr(getArg(args, std::nullopt, "language", Value{std::string("")}), "");
-    shape.script = asStringOr(getArg(args, std::nullopt, "script", Value{std::string("")}), "");
+    shape.direction = asStringOr(getArg(args, 3, "direction", Value{std::string("")}), "");
+    shape.language = asStringOr(getArg(args, 4, "language", Value{std::string("")}), "");
+    shape.script = asStringOr(getArg(args, 5, "script", Value{std::string("")}), "");
 
     FontProvider& fp = ev.fontProvider();
     const FontHandle handle = fp.resolveFont(fontSpec);
@@ -813,7 +820,9 @@ Value builtinTextmetrics(Evaluator& ev, const CallArgs& args) {
 // resolved font, scaled for `size`. Mirrors _builtin_fontmetrics.
 Value builtinFontmetrics(Evaluator& ev, const CallArgs& args) {
     const double size = toDoubleLenient(getArg(args, 0, "size", Value{10.0}));
-    const std::string fontSpec = asStringOr(getArg(args, std::nullopt, "font", Value{std::string("")}), "");
+    // Positional too: fontmetrics(10, "Liberation Sans:style=Bold") is
+    // how the bug report was written, and how the real binary reads it.
+    const std::string fontSpec = asStringOr(getArg(args, 1, "font", Value{std::string("")}), "");
 
     FontProvider& fp = ev.fontProvider();
     const FontHandle handle = fp.resolveFont(fontSpec);

{openscad_cpp_evaluator-1.13.0 → openscad_cpp_evaluator-1.14.0}/src/text/freetype_font_provider.cpp

@@ -1,5 +1,7 @@
 #include "openscad_cpp_evaluator/freetype_font_provider.hpp"
 
+#include <algorithm>
+
 #include "openscad_cpp_evaluator/bundled_font_data.hpp"
 #include "openscad_cpp_evaluator/font_match.hpp"
 
@@ -104,6 +106,11 @@ struct FreetypeFontProvider::Impl {
         FontMetrics metrics;
     };
 
+    //: A FontFace whose `path` is this is already open: its faceIndex IS
+    //: the handle. Real paths cannot collide with it -- no filesystem
+    //: yields a name in angle brackets from findFontFiles().
+    static constexpr const char* kBundledPath = "<bundled>";
+
     std::vector<Face> faces;                                 // handle == index
     std::unordered_map<std::string, FontHandle> bySpec;      // resolved spec -> handle
     std::vector<FontFace> installed;                         // system font index
@@ -160,21 +167,30 @@ struct FreetypeFontProvider::Impl {
         return faces.size() - 1;
     }
 
+    // Every bundled face, in order -- handle 0 is the regular one, the
+    // default and the last-resort fallback. The rest are the other styles
+    // of the same family: a `style=` request that nothing installed can
+    // satisfy used to fall silently back to regular, which is what made
+    // fontmetrics("Liberation Sans:style=bold") report Regular's numbers
+    // (BelfrySCAD #381).
     void openBundled() {
-        Face f;
-        if (FT_New_Memory_Face(lib, reinterpret_cast<const FT_Byte*>(kBundledFontData),
-                               static_cast<FT_Long>(kBundledFontDataSize), 0, &f.ft) != 0) {
-            throw std::runtime_error("FreetypeFontProvider: bundled font failed to load");
+        for (std::size_t i = 0; i < kBundledFontCount; ++i) {
+            const BundledFont& src = kBundledFonts[i];
+            Face f;
+            if (FT_New_Memory_Face(lib, reinterpret_cast<const FT_Byte*>(src.data),
+                                   static_cast<FT_Long>(src.size), 0, &f.ft) != 0) {
+                if (i == 0) throw std::runtime_error("FreetypeFontProvider: bundled font failed to load");
+                continue;  // a spare style is not worth failing every render for
+            }
+            f.blob = hb_blob_create(reinterpret_cast<const char*>(src.data),
+                                    static_cast<unsigned>(src.size), HB_MEMORY_MODE_READONLY, nullptr, nullptr);
+            f.hbFace = hb_face_create(f.blob, 0);
+            f.hbFont = hb_font_create(f.hbFace);
+            hb_ot_font_set_funcs(f.hbFont);
+            f.metrics = readMetrics(f.ft);
+            scaleHbFontToEm(f.hbFont, static_cast<unsigned>(f.metrics.unitsPerEm));
+            faces.push_back(f);
         }
-        f.blob = hb_blob_create(reinterpret_cast<const char*>(kBundledFontData),
-                                static_cast<unsigned>(kBundledFontDataSize), HB_MEMORY_MODE_READONLY, nullptr,
-                                nullptr);
-        f.hbFace = hb_face_create(f.blob, 0);
-        f.hbFont = hb_font_create(f.hbFace);
-        hb_ot_font_set_funcs(f.hbFont);
-        f.metrics = readMetrics(f.ft);
-        scaleHbFontToEm(f.hbFont, static_cast<unsigned>(f.metrics.unitsPerEm));
-        faces.push_back(f);
     }
 
     // Reads family/style out of every face of every installed font file.
@@ -185,6 +201,15 @@ struct FreetypeFontProvider::Impl {
     void scanInstalled() {
         if (scanned) return;
         scanned = true;
+        // The bundled faces go in FIRST, so what a given family+style
+        // resolves to does not depend on what the machine happens to have
+        // installed -- the same script draws the same shapes everywhere.
+        // Their "path" is the sentinel below and their faceIndex is the
+        // already-open handle, so resolveFont skips opening a file at all.
+        for (std::size_t i = 0; i < faces.size() && i < kBundledFontCount; ++i) {
+            installed.push_back(FontFace{std::string(kBundledPath), static_cast<int>(i),
+                                          faces[i].metrics.family, faces[i].metrics.style});
+        }
         for (const std::string& path : findFontFiles()) {
             FT_Face probe = nullptr;
             if (FT_New_Face(lib, path.c_str(), -1, &probe) != 0) continue;
@@ -222,12 +247,30 @@ FontHandle FreetypeFontProvider::resolveFont(const std::string& spec) {
     impl_->scanInstalled();
     FontHandle handle = 0;
     if (const std::optional<FontFace> hit = matchFace(parsed, impl_->installed)) {
-        handle = impl_->openFile(hit->path, hit->faceIndex).value_or(0);
+        handle = hit->path == Impl::kBundledPath ? static_cast<FontHandle>(hit->faceIndex)
+                                                  : impl_->openFile(hit->path, hit->faceIndex).value_or(0);
     }
     impl_->bySpec[spec] = handle;
     return handle;
 }
 
+std::vector<FontFace> FreetypeFontProvider::listFonts() {
+    impl_->scanInstalled();
+    std::vector<FontFace> out = impl_->installed;
+    // A family installed in several files, or listed both bundled and
+    // installed, should appear once per STYLE, not once per file.
+    std::sort(out.begin(), out.end(), [](const FontFace& a, const FontFace& b) {
+        if (a.family != b.family) return a.family < b.family;
+        return a.style < b.style;
+    });
+    out.erase(std::unique(out.begin(), out.end(),
+                           [](const FontFace& a, const FontFace& b) {
+                               return a.family == b.family && a.style == b.style;
+                           }),
+              out.end());
+    return out;
+}
+
 FontMetrics FreetypeFontProvider::metrics(FontHandle handle) {
     if (handle >= impl_->faces.size()) return impl_->faces[0].metrics;
     return impl_->faces[handle].metrics;

{openscad_cpp_evaluator-1.13.0 → openscad_cpp_evaluator-1.14.0}/tests/test_python_bindings.py

@@ -745,6 +745,37 @@ def test_export_model_rejects_an_unknown_pdf_option(tmp_path):
         export_model(str(tmp_path / "x.pdf"), ev.geometry, pdf_options={"paper-size": "a2"})
 
 
+def test_list_fonts_reports_specs_that_actually_resolve(tmp_path):
+    """The list exists so a name can be pasted into font=.
+
+    Read from the evaluator's own FreeType index, not the windowing
+    toolkit's -- a system font database names faces differently, which is
+    the whole reason BelfrySCAD #379 asked for a list.
+    """
+    from openscad_cpp_evaluator import Evaluator, list_fonts
+
+    fonts = list_fonts()
+    assert fonts, "no fonts at all, not even the bundled ones"
+    for f in fonts:
+        assert set(f) == {"family", "style", "spec", "path"}
+
+    bundled = {f["style"]: f for f in fonts if f["family"] == "Liberation Sans"}
+    assert {"Regular", "Bold", "Italic", "Bold Italic"} <= set(bundled)
+    # Regular is written as the bare family: printing the longer form for
+    # it would teach the wrong habit.
+    assert bundled["Regular"]["spec"] == "Liberation Sans"
+    assert bundled["Bold"]["spec"] == "Liberation Sans:style=Bold"
+
+    # ... and every spec resolves to the face it names.
+    src = tmp_path / "fonts.scad"
+    src.write_text("".join(
+        f'echo(fontmetrics(10, "{bundled[style]["spec"]}").font.style);\n'
+        for style in ("Regular", "Bold", "Italic", "Bold Italic")))
+    echoes = []
+    Evaluator(echo_fn=echoes.append).evaluate(str(src), {})
+    assert echoes == ['ECHO: "Regular"', 'ECHO: "Bold"', 'ECHO: "Italic"', 'ECHO: "Bold Italic"']
+
+
 def test_strict_commas_reaches_the_parser(tmp_path):
     """Evaluator.evaluate(strict_commas=True) must survive both hand-written
     parameter lists -- the facade's and the nanobind binding's. The last

{openscad_cpp_evaluator-1.13.0 → openscad_cpp_evaluator-1.14.0}/tests/test_text.cpp

@@ -1,4 +1,8 @@
 #include "openscad_cpp_evaluator/evaluator.hpp"
+#include "openscad_cpp_evaluator/freetype_font_provider.hpp"
+
+#include <algorithm>
+#include <array>
 #include "openscad_cpp_evaluator/font_match.hpp"
 
 #include "test_helpers.hpp"
@@ -269,3 +273,109 @@ TEST(FontMatch, StyleIsAPreferenceNotAFilter) {
     ASSERT_TRUE(hit.has_value());
     EXPECT_EQ(hit->style, "Regular");
 }
+
+// -- bundled family + font list (BelfrySCAD #381, #379) -------------------
+
+TEST(BundledFonts, EveryStyleOfTheFamilyResolves) {
+    // Only Regular used to be bundled, so `style=Bold` on a machine
+    // without Liberation installed fell silently back to Regular --
+    // fontmetrics() then reported Regular's numbers under the name the
+    // script asked for, which is what #381 saw.
+    FreetypeFontProvider p;
+    const std::array<std::pair<const char*, const char*>, 4> want{{
+        {"Liberation Sans", "Regular"},
+        {"Liberation Sans:style=Bold", "Bold"},
+        {"Liberation Sans:style=Italic", "Italic"},
+        {"Liberation Sans:style=Bold Italic", "Bold Italic"},
+    }};
+    for (const auto& [spec, style] : want) {
+        const FontMetrics m = p.metrics(p.resolveFont(spec));
+        EXPECT_EQ(m.family, "Liberation Sans") << spec;
+        EXPECT_EQ(m.style, style) << spec;
+    }
+}
+
+TEST(BundledFonts, StyleMatchingIsCaseInsensitive) {
+    // The report used lowercase "bold", as fontconfig accepts.
+    FreetypeFontProvider p;
+    EXPECT_EQ(p.metrics(p.resolveFont("Liberation Sans:style=bold")).style, "Bold");
+    EXPECT_EQ(p.metrics(p.resolveFont("Liberation Sans:style=BOLD")).style, "Bold");
+}
+
+TEST(BundledFonts, EachStyleHasItsOwnMetrics) {
+    // The visible half of #381: `max` ascent/descent came back identical
+    // for bold and regular, because they were the same face.
+    FreetypeFontProvider p;
+    const FontMetrics reg = p.metrics(p.resolveFont("Liberation Sans"));
+    const FontMetrics bold = p.metrics(p.resolveFont("Liberation Sans:style=Bold"));
+    EXPECT_NE(reg.yMax, bold.yMax);
+    EXPECT_NE(reg.yMin, bold.yMin);
+}
+
+TEST(BundledFonts, AnUnknownFamilyStillFallsBackRatherThanFailing) {
+    // A render must not die because a font is missing.
+    FreetypeFontProvider p;
+    const FontMetrics m = p.metrics(p.resolveFont("No Such Font At All"));
+    EXPECT_EQ(m.family, "Liberation Sans");
+}
+
+TEST(ListFonts, ReportsTheBundledFamilyWithEveryStyle) {
+    FreetypeFontProvider p;
+    const std::vector<FontFace> faces = p.listFonts();
+    std::vector<std::string> styles;
+    for (const FontFace& f : faces) {
+        if (f.family == "Liberation Sans") styles.push_back(f.style);
+    }
+    for (const char* want : {"Regular", "Bold", "Italic", "Bold Italic"}) {
+        EXPECT_NE(std::find(styles.begin(), styles.end(), want), styles.end()) << want;
+    }
+}
+
+TEST(ListFonts, IsSortedAndHasNoDuplicateFamilyStylePairs) {
+    // A family installed in several files, or bundled AND installed, must
+    // appear once per style -- the list is for reading.
+    FreetypeFontProvider p;
+    const std::vector<FontFace> faces = p.listFonts();
+    ASSERT_FALSE(faces.empty());
+    for (size_t i = 1; i < faces.size(); ++i) {
+        const bool ordered = faces[i - 1].family < faces[i].family ||
+                              (faces[i - 1].family == faces[i].family && faces[i - 1].style < faces[i].style);
+        EXPECT_TRUE(ordered) << faces[i - 1].family << "/" << faces[i - 1].style << " then "
+                              << faces[i].family << "/" << faces[i].style;
+    }
+}
+
+TEST(FontArgs, FontIsPositionalInBothMetricsFunctions) {
+    // fontmetrics(size, font) and
+    // textmetrics(text, size, font, direction, language, script, halign,
+    // valign, spacing) -- every one positional, verified against OpenSCAD
+    // 2026.02.01 itself. `font` used to be name-only, so the spec in the
+    // bug report was read as no font at all and the default face measured
+    // instead (BelfrySCAD #381).
+    std::vector<std::string> echoes;
+    Evaluated e = evalSrc(
+        "a = fontmetrics(10, \"Liberation Sans:style=Bold\").font;\n"
+        "b = fontmetrics(size=10, font=\"Liberation Sans:style=Bold\").font;\n"
+        "c = textmetrics(\"Hi\", 10, \"Liberation Sans:style=Bold\").size;\n"
+        "d = textmetrics(text=\"Hi\", size=10, font=\"Liberation Sans:style=Bold\").size;\n"
+        "e = textmetrics(\"Hi\", 10).size;\n"
+        "echo(a.style, b.style, c == d, c == e);\n", [&](const std::string& m) { echoes.push_back(m); });
+    ASSERT_EQ(echoes.size(), 1u);
+    // Bold both ways, and the positional form measures the same as the
+    // named one -- while differing from the default face.
+    EXPECT_EQ(echoes[0], "ECHO: \"Bold\", \"Bold\", true, false");
+}
+
+TEST(FontArgs, TheLaterPositionalsLineUpToo) {
+    // halign at 6 rather than "wherever": a positional font that shifted
+    // everything after it would be a new bug in place of the old one.
+    std::vector<std::string> echoes;
+    Evaluated e = evalSrc(
+        "p = textmetrics(\"Hi\", 10, \"Liberation Sans\", \"ltr\", \"en\", \"latin\", \"center\").position;\n"
+        "n = textmetrics(\"Hi\", 10, \"Liberation Sans\", halign=\"center\").position;\n"
+        "s = textmetrics(\"Hi\", 10, \"Liberation Sans\", \"ltr\", \"en\", \"latin\", \"left\", \"baseline\", 2).size;\n"
+        "sn = textmetrics(\"Hi\", 10, \"Liberation Sans\", spacing=2).size;\n"
+        "echo(p == n, s == sn);\n", [&](const std::string& m) { echoes.push_back(m); });
+    ASSERT_EQ(echoes.size(), 1u);
+    EXPECT_EQ(echoes[0], "ECHO: true, true");
+}

openscad_cpp_evaluator-1.13.0/cmake/embed_font.cmake

@@ -1,28 +0,0 @@
-# Reads IN_FILE (binary) and writes OUT_FILE: a C++ header exposing its
-# bytes as a static array (kBundledFontData/kBundledFontDataSize). Run via
-# `cmake -DIN_FILE=... -DOUT_FILE=... -P embed_font.cmake` as a build-time
-# add_custom_command, not configure_file -- a font baked in as bytes has no
-# runtime file path to go stale once the shared library is installed
-# somewhere other than its own build tree (see this script's own call site
-# in the top-level CMakeLists.txt for the packaging bug this replaces).
-if(NOT DEFINED IN_FILE OR NOT DEFINED OUT_FILE)
-    message(FATAL_ERROR "embed_font.cmake requires -DIN_FILE=... -DOUT_FILE=...")
-endif()
-
-file(READ "${IN_FILE}" _hex HEX)
-string(LENGTH "${_hex}" _hexLen)
-math(EXPR _byteCount "${_hexLen} / 2")
-string(REGEX REPLACE "([0-9a-f][0-9a-f])" "0x\\1," _bytesCsv "${_hex}")
-
-file(WRITE "${OUT_FILE}"
-"// Auto-generated by cmake/embed_font.cmake from ${IN_FILE} -- do not edit.
-#pragma once
-#include <cstddef>
-
-namespace oscadeval {
-inline constexpr unsigned char kBundledFontData[] = {
-${_bytesCsv}
-};
-inline constexpr std::size_t kBundledFontDataSize = ${_byteCount};
-} // namespace oscadeval
-")