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

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

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

{openscad_cpp_evaluator-1.28.2 → openscad_cpp_evaluator-1.28.4}/include/openscad_cpp_evaluator/eval_use.hpp

@@ -24,6 +24,10 @@ namespace oscadeval {
 struct UsedFileGlobals {
     const oscad::Scope* root = nullptr;
     std::vector<const oscad::ASTNode*> assignments;
+    // Every module/function the file sees -- its own and what it use<>d --
+    // for coverage, which is otherwise handed only the top file's nodes, so
+    // a file reached only by a nested use<> went unreported.
+    std::vector<const oscad::ASTNode*> declarations;
 };
 
 struct ResolvedUseScopes {

{openscad_cpp_evaluator-1.28.2 → openscad_cpp_evaluator-1.28.4}/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.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "1.28.2"
+version = "1.28.4"
 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.4}/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.4}/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.4}/src/csg_resolve.cpp

@@ -303,7 +303,10 @@ std::vector<ColoredBody> Evaluator::evaluateImpl(const NodeList& nodes, EvalCont
         roots.reserve(nodes.size());
         for (const auto& n : nodes) roots.push_back(&*n);
         std::vector<const oscad::ASTNode*> extra;
-        for (const UsedFileGlobals& g : usedFileGlobals_) extra.insert(extra.end(), g.assignments.begin(), g.assignments.end());
+        for (const UsedFileGlobals& g : usedFileGlobals_) {
+            extra.insert(extra.end(), g.assignments.begin(), g.assignments.end());
+            roots.insert(roots.end(), g.declarations.begin(), g.declarations.end());  // merged by position
+        }
         coverageResult = buildCoverageResult(roots, extra, coverageRecorder_);
     }
 

{openscad_cpp_evaluator-1.28.2 → openscad_cpp_evaluator-1.28.4}/src/eval_use.cpp

@@ -92,6 +92,11 @@ ResolvedUseScopes resolveUseScopesInto(const std::vector<const oscad::ASTNode*>&
         for (const oscad::ASTNode* n : nested.ownNodesFiltered) {
             if (n->kind() == oscad::NodeKind::Assignment) globals.assignments.push_back(n);
         }
+        for (const oscad::ASTNode* n : nested.processedNodes) {
+            if (n->kind() == oscad::NodeKind::ModuleDeclaration || n->kind() == oscad::NodeKind::FunctionDeclaration) {
+                globals.declarations.push_back(n);
+            }
+        }
         result.usedFileGlobals.push_back(std::move(globals));
     }
 

{openscad_cpp_evaluator-1.28.2 → openscad_cpp_evaluator-1.28.4}/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.4}/tests/test_coverage.cpp

@@ -299,4 +299,32 @@ TEST(Coverage, AFileUsedTwiceIsListedOnce) {
     fs::remove_all(dir);
 }
 
+// A file reached only through a used file's own use<> ran too. Only the top
+// file's nodes were handed to coverage, so its declarations went unlisted.
+TEST(Coverage, AFileReachedByNestedUseIsListed) {
+    namespace fs = std::filesystem;
+    const fs::path dir = fs::temp_directory_path() / "oscad_cov_nested";
+    fs::create_directories(dir);
+    const fs::path lib = dir / "lib.scad", mid = dir / "mid.scad", main = dir / "main.scad";
+    std::ofstream(lib) << "g = 1;\nfunction hit(x) = x + g;\nfunction miss(x) = x;\n";
+    std::ofstream(mid) << "use <lib.scad>\nfunction f() = hit(1);\n";
+    std::ofstream(main) << "use <mid.scad>\necho(f(), f());\n";
+    auto ast = oscad::getASTFromFile(main.string());
+    ResolvedUseScopes uses = resolveUseScopes(ast, main.string(), {});
+    Evaluator ev({}, nullptr, nullptr, {}, false, /*coverage=*/true);
+    ev.setUsedFileGlobals(uses.usedFileGlobals);
+    EvalContext ctx = EvalContext::makeRoot(uses.rootScope.get());
+    ev.evaluate(uses.processedNodes, ctx, {}, false);
+    ASSERT_TRUE(ev.coverageResult.has_value());
+    std::map<std::pair<int, CoverageKind>, std::vector<std::uint32_t>> libSpans;
+    for (const CoverageSpan& s : ev.coverageResult->spans) {
+        if (fs::path(s.origin).filename() == "lib.scad") libSpans[{s.line, s.kind}].push_back(s.hits);
+    }
+    auto hits = [&](int line, CoverageKind kind) { return libSpans[std::make_pair(line, kind)]; };
+    EXPECT_EQ(hits(2, CoverageKind::Body), std::vector<std::uint32_t>{2u});
+    EXPECT_EQ(hits(3, CoverageKind::Body), std::vector<std::uint32_t>{0u});
+    EXPECT_EQ(hits(1, CoverageKind::Statement), std::vector<std::uint32_t>{1u});  // its global, read and so evaluated, once
+    fs::remove_all(dir);
+}
+
 } // namespace oscadeval

{openscad_cpp_evaluator-1.28.2 → openscad_cpp_evaluator-1.28.4}/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.4}/uv.lock

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