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

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

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

{openscad_cpp_evaluator-1.28.3 → openscad_cpp_evaluator-1.28.5}/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.3 → openscad_cpp_evaluator-1.28.5}/pyproject.toml

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

{openscad_cpp_evaluator-1.28.3 → openscad_cpp_evaluator-1.28.5}/src/builtins/primitives_3d.cpp

@@ -53,11 +53,18 @@ struct BoundaryEdges {
     // three bad edges in a few thousand triangles cannot be found by eye,
     // which is what happened in BelfrySCAD #521 / issue #187.
     std::optional<std::pair<uint32_t, uint32_t>> first;
+    // An edge both of whose faces run it the SAME way: the mesh is closed
+    // but a face is wound backwards. Named so the author knows which face
+    // to flip (BelfrySCAD #566, where "not closed -- 0 boundary edges"
+    // described a closed tetrahedron with two reversed faces).
+    size_t misoriented = 0;
+    std::optional<std::pair<uint32_t, uint32_t>> firstMisoriented;
 };
 
 template <typename M>
 BoundaryEdges findBoundaryEdges(const M& mesh) {
     std::map<std::pair<uint32_t, uint32_t>, int> uses;
+    std::map<std::pair<uint32_t, uint32_t>, int> forward;  // uses running low -> high
     for (size_t i = 0; i + 2 < mesh.triVerts.size(); i += 3) {
         const uint32_t v[3] = {static_cast<uint32_t>(mesh.triVerts[i]),
                                 static_cast<uint32_t>(mesh.triVerts[i + 1]),
@@ -65,6 +72,7 @@ BoundaryEdges findBoundaryEdges(const M& mesh) {
         for (int e = 0; e < 3; ++e) {
             const uint32_t a = v[e], b = v[(e + 1) % 3];
             ++uses[{std::min(a, b), std::max(a, b)}];
+            if (a < b) ++forward[{a, b}];
         }
     }
     BoundaryEdges out;
@@ -75,7 +83,16 @@ BoundaryEdges findBoundaryEdges(const M& mesh) {
     // A cluster of open edges is nearly always one hole, so the first is
     // usually representative of the rest.
     for (const auto& [edge, count] : uses) {
-        if (count % 2 == 0) continue;
+        if (count % 2 == 0) {
+            // Closed here; consistently wound only if the uses split evenly
+            // between the two directions.
+            const auto f = forward.find(edge);
+            if ((f == forward.end() ? 0 : f->second) * 2 != count) {
+                ++out.misoriented;
+                if (!out.firstMisoriented) out.firstMisoriented = edge;
+            }
+            continue;
+        }
         ++out.count;
         if (!out.first) out.first = edge;
     }
@@ -857,10 +874,22 @@ std::vector<ColoredBody> generatePolyhedron(Evaluator& ev, const CSGParams& para
             // Name one of them. Where the hole IS is the only part of this
             // message an author can act on; the count alone just says to go
             // looking, across the whole mesh.
-            const std::string where =
-                open.first ? ", first at " + describeEdge(mesh, *open.first) : std::string();
-            ev.warn("polyhedron: mesh is not closed -- " + std::to_string(open.count) +
-                        " boundary edge(s)" + where +
+            std::string what;
+            if (open.count) {
+                what = "mesh is not closed -- " + std::to_string(open.count) + " boundary edge(s)" +
+                       (open.first ? ", first at " + describeEdge(mesh, *open.first) : std::string());
+            } else if (open.misoriented) {
+                // Closed, but some faces wound backwards: "not closed -- 0
+                // boundary edge(s)" contradicted itself (BelfrySCAD #566).
+                what = "faces are not consistently wound -- " + std::to_string(open.misoriented) +
+                       " edge(s) run the same way by both faces sharing them" +
+                       (open.firstMisoriented ? ", first at " + describeEdge(mesh, *open.firstMisoriented)
+                                              : std::string()) +
+                       "; reverse the point order of the faces on one side of it";
+            } else {
+                what = "mesh is not a valid solid (" + checkMesh(mesh).summary() + ")";
+            }
+            ev.warn("polyhedron: " + what +
                         // "drawing it as a surface" was read by a reporter as
                         // the HOLE being surfaced over -- i.e. as automatic
                         // repair hiding their defect. Nothing is repaired: the
@@ -868,7 +897,8 @@ std::vector<ColoredBody> generatePolyhedron(Evaluator& ev, const CSGParams& para
                         // object as the thing being drawn, and say what it is
                         // NOT, since "surface" alone does not imply "not solid"
                         // to someone who did not know it could be either.
-                        "; drawing the object as an open surface rather than a "
+                        (open.count ? "; drawing the object as an open surface rather than a "
+                                    : "; drawing the object as a surface rather than a ") +
                         "solid -- nothing is patched. hull() can still "
                         "use its points, but it cannot take part in union/difference/intersection",
                     &node.position());

{openscad_cpp_evaluator-1.28.3 → openscad_cpp_evaluator-1.28.5}/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.3 → openscad_cpp_evaluator-1.28.5}/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.3 → openscad_cpp_evaluator-1.28.5}/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.3 → openscad_cpp_evaluator-1.28.5}/tests/test_primitives.cpp

@@ -442,6 +442,22 @@ TEST(SphereStyle, StyleRespectsFnAndRadius) {
 // cube()'s size as OpenSCAD 2026.02.01 reads it: undef, absent or explicit,
 // is the default of 1; anything but a number or three numbers warns and
 // falls back to 1. Explicit undef built a zero-size cube -- nothing at all.
+// BelfrySCAD #566: a closed tetrahedron with two faces wound backwards was
+// reported as "mesh is not closed -- 0 boundary edge(s)". It is closed; say
+// what is actually wrong, name an edge, and still draw it.
+TEST(Primitives, PolyhedronWithReversedFacesSaysSo) {
+    std::vector<std::string> log;
+    Evaluated e = evalSrc("polyhedron([[0,0,0], [10,0,0], [0,10,0], [0,0,10]],\n"
+                          "           [[0,1,2], [0,1,3], [0,2,3], [1,2,3]]);",
+                          [&](const std::string& m) { log.push_back(m); });
+    ASSERT_EQ(log.size(), 1u);
+    EXPECT_NE(log[0].find("faces are not consistently wound -- 4 edge(s)"), std::string::npos) << log[0];
+    EXPECT_NE(log[0].find("first at [0, 0, 0] - [10, 0, 0]"), std::string::npos) << log[0];
+    EXPECT_EQ(log[0].find("not closed"), std::string::npos) << log[0];
+    EXPECT_EQ(log[0].find("open surface"), std::string::npos) << log[0];
+    ASSERT_EQ(e.bodies.size(), 1u);  // still drawn, as a display-only surface
+}
+
 TEST(Primitives, CubeBadSizeIsAUnitCube) {
     const std::pair<const char*, const char*> cases[] = {
         {"undef", ""},

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

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