openscad-cpp-evaluator 1.28.2__tar.gz → 1.28.3__tar.gz

{openscad_cpp_evaluator-1.28.2 → openscad_cpp_evaluator-1.28.3}/PKG-INFO

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

{openscad_cpp_evaluator-1.28.2 → openscad_cpp_evaluator-1.28.3}/include/openscad_cpp_evaluator/text_metrics.hpp

@@ -2,6 +2,7 @@
 
 #include "openscad_cpp_evaluator/font_provider.hpp"
 
+#include <functional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -44,7 +45,10 @@ TextMeasurement measureText(FontProvider& fp, FontHandle handle, const std::stri
 // center/top for a vertical one, as in OpenSCAD; text with no ink is not
 // moved at all. Shared by textmetrics() (reports it) and text()
 // (applies it).
+// `warn`, when given, receives OpenSCAD's own warning for an unknown
+// halign/valign, and for valign="baseline" on a vertical run.
 std::pair<double, double> textAlignOffset(const std::string& halign, const std::string& valign,
-                                          const TextMeasurement& m);
+                                          const TextMeasurement& m,
+                                          const std::function<void(const std::string&)>& warn = {});
 
 } // namespace oscadeval

{openscad_cpp_evaluator-1.28.2 → openscad_cpp_evaluator-1.28.3}/pyproject.toml

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

{openscad_cpp_evaluator-1.28.2 → openscad_cpp_evaluator-1.28.3}/src/builtins/function_builtins.cpp

@@ -782,7 +782,7 @@ Value objectOf(std::vector<std::pair<std::string, Value>> items) {
 // descent/offset/advance in real OpenSCAD's key order. Going through the
 // same measureText() the geometry goes through is the point: the numbers
 // a script positions against cannot disagree with what it draws.
-Value builtinTextmetrics(Evaluator& ev, const CallArgs& args) {
+Value builtinTextmetrics(Evaluator& ev, const CallArgs& args, const oscad::Position* pos) {
     const std::string text = asStringOr(getArg(args, 0, "text", Value{std::string("")}), "");
     const double size = toDoubleLenient(getArg(args, 1, "size", Value{10.0}));
     // Positional indices, all of them: OpenSCAD's own signature is
@@ -804,7 +804,8 @@ Value builtinTextmetrics(Evaluator& ev, const CallArgs& args) {
     FontProvider& fp = ev.fontProvider();
     const FontHandle handle = fp.resolveFont(fontSpec);
     const TextMeasurement m = measureText(fp, handle, text, size, spacing, shape);
-    const auto [offsetX, offsetY] = textAlignOffset(halign, valign, m);
+    const auto [offsetX, offsetY] = textAlignOffset(
+        halign, valign, m, [&](const std::string& w) { ev.warn(w, pos); });
 
     return objectOf({
         {"position", numList({offsetX + m.left, offsetY + m.bottom})},
@@ -1251,7 +1252,7 @@ Value evalBuiltinFunctionResolved(Evaluator& ev, BuiltinFnId id, const std::vect
 
     switch (id) {
         case BuiltinFnId::None: return Value{}; // unreachable: handled above
-        case BuiltinFnId::TextMetrics: return builtinTextmetrics(ev, args);
+        case BuiltinFnId::TextMetrics: return builtinTextmetrics(ev, args, &node.position());
         case BuiltinFnId::FontMetrics: return builtinFontmetrics(ev, args);
         case BuiltinFnId::Abs: return Value{std::fabs(toDoubleLenient(getArg(args, 0, "x", Value{})))};
         case BuiltinFnId::Sign: {

{openscad_cpp_evaluator-1.28.2 → openscad_cpp_evaluator-1.28.3}/src/builtins/text.cpp

@@ -60,7 +60,8 @@ CSGParams resolveText(Evaluator& ev, const oscad::ModularCall& node, EvalContext
     const double scale = size * (100.0 / 72.0) / fm.unitsPerEm;
     const int segs = std::max(2, fnSegmentsFromCtx(effCtx) / 2);
     const TextMeasurement m = measureText(fp, handle, text, size, spacing, shape);
-    const auto [offsetX, offsetY] = textAlignOffset(halign, valign, m);
+    const auto [offsetX, offsetY] = textAlignOffset(
+        halign, valign, m, [&](const std::string& w) { ev.warn(w, &node.position()); });
 
     std::vector<Value> glyphs;
     glyphs.reserve(m.glyphs.size());

{openscad_cpp_evaluator-1.28.2 → openscad_cpp_evaluator-1.28.3}/src/text/text_metrics.cpp

@@ -55,24 +55,39 @@ TextMeasurement measureText(FontProvider& fp, FontHandle handle, const std::stri
     return m;
 }
 
-// OpenSCAD's ShapeResults::calc_offsets_horiz/_vert. An unknown value (and,
-// for a vertical run, valign="baseline") does not move the text there
-// either; OpenSCAD also warns, which this does not.
+// OpenSCAD's ShapeResults::calc_offsets_horiz/_vert, warnings included. An
+// unknown value, or valign="baseline" on a vertical run, leaves that axis
+// where it is. Text with no ink never gets this far there, so it never
+// warns either.
 std::pair<double, double> textAlignOffset(const std::string& halign, const std::string& valign,
-                                          const TextMeasurement& m) {
+                                          const TextMeasurement& m,
+                                          const std::function<void(const std::string&)>& warn) {
     if (!m.hasInk) return {0.0, 0.0};
+    auto unknown = [&](const char* param, const char* choices, const std::string& value) {
+        if (warn) {
+            warn(std::string("Unknown value for the ") + param + " parameter (use " + choices + "): '" + value + "'");
+        }
+    };
+    const char* hChoices = "\"left\", \"right\" or \"center\"";
+    const char* vChoices = "\"baseline\", \"bottom\", \"top\" or \"center\"";
     double offsetX = 0.0, offsetY = 0.0;
     if (m.vertical) {
         if (halign == "right") offsetX = -m.right;
         else if (halign == "left") offsetX = -m.left;
+        else if (halign != "center" && halign != "default") unknown("halign", hChoices, halign);
         if (valign == "center") offsetY = -m.advanceY / 2;
         else if (valign == "bottom") offsetY = -m.advanceY;
+        else if (valign == "baseline") {
+            if (warn) warn("Don't use valign=\"baseline\" with vertical layouts");
+        } else if (valign != "top" && valign != "default") unknown("valign", vChoices, valign);
     } else {
         if (halign == "center") offsetX = -0.5 * m.advanceX;
         else if (halign == "right") offsetX = -m.advanceX;
+        else if (halign != "left" && halign != "default") unknown("halign", hChoices, halign);
         if (valign == "top") offsetY = -m.ascent;
         else if (valign == "center") offsetY = -(m.ascent + m.descent) / 2;
         else if (valign == "bottom") offsetY = -m.descent;
+        else if (valign != "baseline" && valign != "default") unknown("valign", vChoices, valign);
     }
     return {offsetX, offsetY};
 }

{openscad_cpp_evaluator-1.28.2 → openscad_cpp_evaluator-1.28.3}/tests/test_text.cpp

@@ -126,6 +126,33 @@ TEST(Textmetrics, VerticalRunAlignsByItsOwnRules) {
     EXPECT_NEAR(vec(rb, "offset", 1), 39.1032, 1e-3);
 }
 
+// OpenSCAD 2026.02.01's warnings, verbatim. Inkless text never reaches
+// its alignment code there, so it does not warn.
+TEST(Text, UnknownAlignmentWarnsAsOpenscadDoes) {
+    const std::pair<const char*, std::vector<std::string>> cases[] = {
+        {"m = textmetrics(\"ab\", halign=\"middle\");",
+         {"Unknown value for the halign parameter (use \"left\", \"right\" or \"center\"): 'middle'"}},
+        {"m = textmetrics(\"ab\", valign=\"mid\");",
+         {"Unknown value for the valign parameter (use \"baseline\", \"bottom\", \"top\" or \"center\"): 'mid'"}},
+        {"m = textmetrics(\"ab\", direction=\"ttb\", valign=\"baseline\");",
+         {"Don't use valign=\"baseline\" with vertical layouts"}},
+        {"text(\"ab\", direction=\"ttb\", halign=\"x\", valign=\"y\");",
+         {"Unknown value for the halign parameter (use \"left\", \"right\" or \"center\"): 'x'",
+          "Unknown value for the valign parameter (use \"baseline\", \"bottom\", \"top\" or \"center\"): 'y'"}},
+        {"m = textmetrics(\"  \", halign=\"bogus\");", {}},
+        {"m = textmetrics(\"ab\", halign=\"default\", valign=\"default\");", {}},
+        {"m = textmetrics(\"ab\", direction=\"ttb\", valign=\"top\");", {}},
+    };
+    for (const auto& [src, want] : cases) {
+        std::vector<std::string> log;
+        evalSrc(src, [&](const std::string& m) { log.push_back(m); });
+        ASSERT_EQ(log.size(), want.size()) << src;
+        for (size_t i = 0; i < want.size(); ++i) {
+            EXPECT_EQ(log[i], "WARNING: " + want[i] + " in file <string>, line 1") << src;
+        }
+    }
+}
+
 TEST(Textmetrics, InklessTextIsNotAligned) {
     Evaluator ev;
     Value v = asExpr("textmetrics(\"  \", size=10, halign=\"right\")", ev);

{openscad_cpp_evaluator-1.28.2 → openscad_cpp_evaluator-1.28.3}/uv.lock

@@ -55,7 +55,7 @@ wheels = [
 
 [[package]]
 name = "openscad-cpp-evaluator"
-version = "1.28.2"
+version = "1.28.3"
 source = { editable = "." }
 dependencies = [
     { name = "numpy" },