openscad-cpp-evaluator 0.55.1__tar.gz → 0.55.3__tar.gz

{openscad_cpp_evaluator-0.55.1 → openscad_cpp_evaluator-0.55.3}/CLAUDE.md

@@ -231,6 +231,15 @@ top-level 2D primitive/projection() script had been silently unexportable via th
 Fixed by porting `toRenderableBodies()` (`colored_body.hpp`/`.cpp`) and calling it from the CLI right
 before export, matching the reference's own call site exactly.
 
+`ColoredBody::sectionZ` rides alongside for the same reason. A `manifold::CrossSection` is purely
+2D, so `down(1) square(10)` had nowhere to put the `-1` and silently dropped it — and that is not
+cosmetic: BOSL2 layers 2D overlays by pushing one down (isosurface's `contour()` Example 1 puts a
+blue backdrop below a green contour), and with the offset lost the two slabs became exactly
+coplanar, z-fought, and whichever drew last covered the other completely. `generateTransform`
+accumulates the z of any `translate` applied to a section, and `toRenderableBodies()` translates the
+extruded slab by it. Only translation is carried — a 2D shape under a 3D *rotation* still loses it,
+which would need a full matrix per section and nothing has asked for that yet.
+
 **Font support**: a `FontProvider` abstract interface (`font_provider.hpp`: `resolveFont`/
 `metrics`/`shapeText`/`glyphInkBounds`/`glyphOutline`) with `FreetypeFontProvider` as the built-in
 implementation everything here actually uses. `Evaluator`'s constructor takes an optional

{openscad_cpp_evaluator-0.55.1 → openscad_cpp_evaluator-0.55.3}/PKG-INFO

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

{openscad_cpp_evaluator-0.55.1 → openscad_cpp_evaluator-0.55.3}/bindings/ast_to_py.cpp

@@ -25,6 +25,7 @@
 // losing how the author wrote it (1.500 -> 1.5, 1e3 -> 1000).
 
 #include "openscad_cpp_parser/api.hpp"
+#include "openscad_cpp_parser/pretty_print.hpp"
 #include "openscad_cpp_parser/ast/ast_node.hpp"
 #include "openscad_cpp_parser/ast/comments.hpp"
 #include "openscad_cpp_parser/ast/declarations.hpp"
@@ -323,4 +324,11 @@ nb::list parseAstFromString(const std::string& code, bool includeComments) {
     return astToPy(oscad::getASTFromString(code, includeComments));
 }
 
+// The parser already has a pretty-printer -- comment-preserving, idempotent
+// and covered by its own tests -- so an editor's "reformat" needs no second
+// implementation guessing at the same grammar from a token stream.
+std::string formatSourceString(const std::string& code, int indentWidth, bool includeComments) {
+    return oscad::toOpenscad(oscad::getASTFromString(code, includeComments), indentWidth);
+}
+
 } // namespace oscadbind

{openscad_cpp_evaluator-0.55.1 → openscad_cpp_evaluator-0.55.3}/bindings/module.cpp

@@ -49,6 +49,7 @@ namespace nb = nanobind;
 namespace oscadbind {
 nb::list parseAstFromFile(const std::string& path, bool includeComments);
 nb::list parseAstFromString(const std::string& code, bool includeComments);
+std::string formatSourceString(const std::string& code, int indentWidth, bool includeComments);
 } // namespace oscadbind
 
 namespace {
@@ -809,6 +810,13 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           "safe to keep, share across threads, and outlive the parse.");
     m.def("parse_ast_string", &oscadbind::parseAstFromString, nb::arg("code"), nb::arg("include_comments") = false,
           "As parse_ast(), but parses a source string instead of a file.");
+    m.def("format_source", &oscadbind::formatSourceString, nb::arg("code"),
+          nb::arg("indent") = 4, nb::arg("include_comments") = true,
+          "Reformat OpenSCAD source: parse it and print the AST back out. "
+          "Wraps over-long argument lists and vectors, puts a modifier's "
+          "children on their own indented line, and preserves comments. "
+          "Idempotent -- formatting formatted source returns it unchanged. "
+          "Raises ParseError if the source does not parse.");
     m.def("debug_evaluate", &debugEvaluate, nb::arg("path"), nb::arg("viewport_params"), nb::arg("debug_hook"),
           nb::arg("error_break"), nb::arg("echo_fn"), nb::arg("manifold_cache") = nullptr,
           nb::arg("return_hook") = nb::none(), nb::arg("fast_continue_signal") = nullptr,

{openscad_cpp_evaluator-0.55.1 → openscad_cpp_evaluator-0.55.3}/include/openscad_cpp_evaluator/colored_body.hpp

@@ -24,6 +24,21 @@ struct ColoredBody {
     std::optional<std::array<float, 4>> color; // RGBA; nullopt = "no explicit color() -- follow the live theme"
     std::optional<manifold::CrossSection> section;
     bool flatPreview = false;
+
+    // Where a 2D `section` sits along Z. Only meaningful while `section` is
+    // set, and applied when toRenderableBodies() extrudes it.
+    //
+    // A manifold::CrossSection is purely 2D, so `down(1) square(10)` had
+    // nowhere to put the -1 and silently dropped it. That is not merely
+    // cosmetic: BOSL2 layers 2D overlays by pushing one down (isosurface's
+    // contour() Example 1 puts a blue backdrop below a green contour), and
+    // with the offset lost the two slabs became exactly coplanar, z-fought,
+    // and whichever was drawn last covered the other completely.
+    //
+    // Only translation is carried. A 2D shape under a 3D ROTATION still
+    // loses it -- representing that needs a full matrix per section, which
+    // nothing has asked for yet.
+    double sectionZ = 0.0;
     BodyRole role = BodyRole::Normal;
     std::optional<std::vector<std::array<float, 4>>> triColors; // per-triangle RGBA, multi-color CSG merges only
 
@@ -60,7 +75,7 @@ Value colorToValue(const std::optional<std::array<double, 4>>& color);
 std::optional<std::array<float, 4>> valueToColor(const Value& v);
 
 // Converts every top-level 2D-only result (`body` unset, `section` set --
-// e.g. a bare `circle();`) into a thin-extruded (1e-3 units tall) Manifold
+// e.g. a bare `circle();`) into a 1-unit-tall extruded Manifold
 // tagged `flatPreview = true`, so a mesh exporter/renderer that only
 // understands 3D Manifolds (writeStl/writeObj/writeOff/writeThreeMf) can
 // still show a 2D top-level result instead of silently dropping it. 3D

{openscad_cpp_evaluator-0.55.1 → openscad_cpp_evaluator-0.55.3}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -427,7 +427,8 @@ public:
     // before its GenerateFn runs -- see csg_generate.cpp.
     void applyDimensionRules(CSGNode& node);
     // ruleValue is a DimRule; the enum is file-local to csg_generate.cpp.
-    void applyDimensionRulesTo(const std::vector<CSGNode*>& children, int ruleValue);
+    void applyDimensionRulesTo(const std::vector<CSGNode*>& children, int ruleValue,
+                                bool keepMixed = false);
 
     // Apply `!`: replace the whole tree with the first show_only
     // subtree, discarding its ancestors and every sibling. See its

{openscad_cpp_evaluator-0.55.1 → openscad_cpp_evaluator-0.55.3}/pyproject.toml

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

{openscad_cpp_evaluator-0.55.1 → openscad_cpp_evaluator-0.55.3}/python/openscad_cpp_evaluator/__init__.py

@@ -18,7 +18,8 @@ from ._openscad_cpp_evaluator import FastContinueSignal, ManifoldCache
 __all__ = [
     "Evaluator", "ColoredBody", "EvalError", "ParseError", "OscObject", "parse", "to_renderable_bodies",
     "ManifoldCache", "CallSiteProfile", "ProfileResult", "format_csg_tree", "bodies_from_dicts",
-    "FastContinueSignal", "parse_ast", "parse_ast_string", "check_mesh", "strip_slivers",
+    "FastContinueSignal", "parse_ast", "parse_ast_string", "format_source",
+    "check_mesh", "strip_slivers",
     "export_model", "export_extensions",
 ]
 
@@ -376,6 +377,24 @@ def parse_ast_string(code: str, include_comments: bool = False) -> list:
         raise ParseError(str(e)) from e
 
 
+def format_source(code: str, indent: int = 4, include_comments: bool = True) -> str:
+    """Reformat OpenSCAD source: parse it and print the AST back out.
+
+    Wraps over-long argument lists and vector literals, puts a modifier's
+    children on their own indented line, and preserves comments. Idempotent
+    -- formatting already-formatted source returns it unchanged. Raises
+    ParseError on a syntax error.
+
+    This is the parser's own printer (`oscad::toOpenscad`), so an editor
+    reformatting a selection does not need a second implementation guessing
+    at the same grammar from a token stream.
+    """
+    try:
+        return _ext.format_source(code, indent, include_comments)
+    except Exception as e:
+        raise ParseError(str(e)) from e
+
+
 class _MeshShim:
     """Duck-types a manifold3d mesh: the four arrays the renderer reads."""
     __slots__ = ("vert_properties", "tri_verts", "run_original_id", "run_index", "num_prop")

{openscad_cpp_evaluator-0.55.1 → openscad_cpp_evaluator-0.55.3}/src/builtins/transforms.cpp

@@ -233,6 +233,10 @@ std::vector<ColoredBody> generateTransform(Evaluator&, const CSGParams& params,
     std::vector<ColoredBody> result;
     for (ColoredBody b : flattenCsgTree(children)) {
         if (b.section) {
+            // The CrossSection takes x/y; z has nowhere to go in it, so it
+            // rides along on the body until the section is extruded. See
+            // ColoredBody::sectionZ.
+            if (name == "translate") b.sectionZ += toVec3(getArg(args, 0, "v", Value{})).z;
             b.section = applyTransform2d(name, args, std::move(*b.section));
         } else if (b.body) {
             b.body = applyTransform3d(name, args, std::move(*b.body));

{openscad_cpp_evaluator-0.55.1 → openscad_cpp_evaluator-0.55.3}/src/colored_body.cpp

@@ -21,7 +21,13 @@ std::optional<std::array<float, 4>> valueToColor(const Value& v) {
 }
 
 namespace {
-constexpr double kTopLevel2dHeight = 1e-3;
+// The reference extrudes a 2D shape to exactly 1 unit for preview -- measured
+// against OpenSCAD at three camera tilts (60/70/80 degrees), which put it at
+// 0.92/1.00/0.99, the 60 being pixel-rounding on the shallowest angle. Ours
+// was 1e-3, which reads as a flat silhouette with no visible edge and, more
+// annoyingly, gives --viewall a different bounding box to fit, so every 2D
+// docs image came out at a different scale from the published one.
+constexpr double kTopLevel2dHeight = 1.0;
 } // namespace
 
 std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodies) {
@@ -31,6 +37,10 @@ std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodi
         if (!cb.body && cb.section) {
             ColoredBody flat;
             flat.body = manifold::Manifold::Extrude(cb.section->ToPolygons(), kTopLevel2dHeight);
+            // Put it back where a 3D translate moved it -- the CrossSection
+            // could not hold that. See ColoredBody::sectionZ.
+            if (cb.sectionZ != 0.0)
+                flat.body = flat.body->Translate(manifold::vec3(0, 0, cb.sectionZ));
             flat.color = cb.color;
             flat.flatPreview = true;
             flat.role = cb.role;

{openscad_cpp_evaluator-0.55.1 → openscad_cpp_evaluator-0.55.3}/src/csg_generate.cpp

@@ -171,9 +171,10 @@ void Evaluator::applyDimensionRules(CSGNode& node) {
     applyDimensionRulesTo(kids, static_cast<int>(rule));
 }
 
-// The top level is an implicit union, and the reference treats it as one for
-// this too: `square(4); cube(1);` warns and keeps only the square.
-void Evaluator::applyDimensionRulesTo(const std::vector<CSGNode*>& children, int ruleValue) {
+// `keepMixed` warns about a mixed group but drops nothing -- the top level's
+// behaviour, see generateTree.
+void Evaluator::applyDimensionRulesTo(const std::vector<CSGNode*>& children, int ruleValue,
+                                       bool keepMixed) {
     const DimRule rule = static_cast<DimRule>(ruleValue);
     int target = rule == DimRule::Only2D ? 2 : rule == DimRule::Only3D ? 3 : 0;
     bool warnedMixing = false;
@@ -202,6 +203,16 @@ void Evaluator::applyDimensionRulesTo(const std::vector<CSGNode*>& children, int
                 warn("Mixing 2D and 3D objects is not supported", pos);
                 warnedMixing = true;
             }
+            if (keepMixed) {
+                // Kept, not dropped: at the top level there is no single
+                // result to build, so nothing downstream can be confused by
+                // the other dimension, and the reference's own preview shows
+                // both. The warning above still stands -- an export cannot
+                // represent the mix -- but silently losing the 2D geometry
+                // from the picture is worse than showing it.
+                kept.push_back(std::move(b));
+                continue;
+            }
             warn(std::string("Ignoring ") + (dim == 3 ? "3D" : "2D") + " child object for " +
                      (target == 3 ? "3D" : "2D") + " operation",
                  pos);
@@ -216,9 +227,19 @@ std::vector<ColoredBody> Evaluator::generateTree(const std::vector<std::unique_p
     ptrs.reserve(tree.size());
     for (const std::unique_ptr<CSGNode>& n : tree) ptrs.push_back(n.get());
     std::vector<ColoredBody> bodies = generateTreeImpl(ptrs);
-    // The top level is an implicit union; give it the same Group treatment
-    // every other group node gets, then re-collect what survived.
-    applyDimensionRulesTo(ptrs, static_cast<int>(DimRule::Group));
+    // The top level is an implicit union, so it gets the same Group warning
+    // every other group node gets -- but it KEEPS both dimensions.
+    //
+    // A real group has to pick one: generateCsg builds a single result and
+    // switches on whether it holds a body or a section, so a group that
+    // changed dimension part-way used to take the process down. The top
+    // level builds no such result; it just hands back a list. Dropping there
+    // only lost geometry, and it lost it from the picture: the reference's
+    // preview draws top-level 2D and 3D side by side (a 2D shape as a thin
+    // slab), which is exactly what BOSL2's debug_bezier() of a 2D bezier
+    // relies on -- every curve and control arrow it draws is 2D, so beside
+    // a 3D sphere the whole debug overlay vanished.
+    applyDimensionRulesTo(ptrs, static_cast<int>(DimRule::Group), /*keepMixed=*/true);
     bodies.clear();
     for (CSGNode* n : ptrs) {
         for (const ColoredBody& b : n->bodies) bodies.push_back(b);

{openscad_cpp_evaluator-0.55.1 → openscad_cpp_evaluator-0.55.3}/src/export.cpp

@@ -429,10 +429,23 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
     std::vector<Solid> solids;
     std::vector<ExportObject> loose;
 
+    // A `flatPreview` body is a top-level 2D shape thin-extruded so it can be
+    // SEEN (toRenderableBodies). The top level keeps 2D and 3D side by side
+    // for exactly that reason -- but a mesh export of a mixed script must
+    // not smuggle a 1-unit-tall slab in beside the real solids, which is what
+    // the reference drops there too. A 2D-ONLY script still exports its
+    // slab, unchanged: that is the only geometry there is, and dropping it
+    // would leave nothing to write.
+    bool hasRealSolid = false;
+    for (const ColoredBody& cb : bodies) {
+        if (!cb.flatPreview && isExportable(cb)) { hasRealSolid = true; break; }
+    }
+
     int index = 0;
     for (const ColoredBody& cb : bodies) {
         ++index;
         if (!isExportable(cb)) continue;
+        if (cb.flatPreview && hasRealSolid) continue;
         if (cb.isDisplayOnly()) {
             // Manifold rejected this one -- an open shell is not a solid --
             // so it can join no boolean. Its triangles are real geometry the

{openscad_cpp_evaluator-0.55.1 → openscad_cpp_evaluator-0.55.3}/tests/test_booleans.cpp

@@ -1,4 +1,6 @@
 #include "openscad_cpp_evaluator/evaluator.hpp"
+#include "openscad_cpp_evaluator/colored_body.hpp"
+#include "openscad_cpp_evaluator/export.hpp"
 
 #include "test_helpers.hpp"
 
@@ -576,8 +578,11 @@ TEST(MixedDimensions, TransformsAndControlFlowAreGroupsToo) {
     EXPECT_EQ(dimWarnings("translate([0,0,0]) { square(4); cube(1); }"), expected);
     EXPECT_EQ(dimWarnings("scale(2) { square(4); cube(1); }"), expected);
     EXPECT_EQ(dimWarnings("color(\"red\") { square(4); cube(1); }"), expected);
-    EXPECT_EQ(dimWarnings("for (i = [0:0]) { square(4); cube(1); }"), expected);
-    EXPECT_EQ(dimWarnings("if (true) { square(4); cube(1); }"), expected);
+    // for/if are transparent -- their children land at the top level, so
+    // they get the top level's keep-both treatment rather than a group's.
+    const std::vector<std::string> topLevel{"WARNING: Mixing 2D and 3D objects is not supported"};
+    EXPECT_EQ(dimWarnings("for (i = [0:0]) { square(4); cube(1); }"), topLevel);
+    EXPECT_EQ(dimWarnings("if (true) { square(4); cube(1); }"), topLevel);
     EXPECT_EQ(dimWarnings("hull() { square(4); cube(1); }"), expected);
 }
 
@@ -603,14 +608,85 @@ TEST(MixedDimensions, RoofWarnsForNeither) {
     EXPECT_TRUE(dimWarnings("roof() { square(4); cube(1); }").empty());
 }
 
-TEST(MixedDimensions, TopLevelIsAGroupAsWell) {
-    // The top level is an implicit union, and gets the same treatment.
+TEST(MixedDimensions, TopLevelWarnsButKeepsBothDimensions) {
+    // The top level warns like any other group, but drops NOTHING. A real
+    // group has to pick one dimension because generateCsg builds a single
+    // result from it; the top level just hands back a list, and the
+    // reference's own preview draws 2D and 3D side by side. Dropping here
+    // silently lost the whole of a BOSL2 debug overlay (debug_bezier() of a
+    // 2D bezier is entirely 2D) whenever a 3D shape shared the script.
     EXPECT_EQ(dimWarnings("square(4); cube(1);"),
-              (std::vector<std::string>{"WARNING: Ignoring 3D child object for 2D operation",
-                                        "WARNING: Mixing 2D and 3D objects is not supported"}));
+              (std::vector<std::string>{"WARNING: Mixing 2D and 3D objects is not supported"}));
     Evaluated e = evalSrc("square(4); cube(1);");
+    ASSERT_EQ(e.bodies.size(), 2u);
+    EXPECT_TRUE(e.bodies[0].section.has_value()) << "the 2D shape survived";
+    EXPECT_TRUE(e.bodies[1].body.has_value()) << "and so did the 3D one";
+}
+
+TEST(MixedDimensions, ExportDropsTheFlatSlabWhenRealSolidsArePresent) {
+    // The top level keeps a 2D shape so it can be SEEN, thin-extruded by
+    // toRenderableBodies. A mesh export must not smuggle that 1-unit-tall slab
+    // in beside the real solids -- the reference drops it there too.
+    Evaluated e = evalSrc("square(4); cube(1);");
+    const std::vector<ColoredBody> renderable = toRenderableBodies(e.bodies);
+    ASSERT_EQ(renderable.size(), 2u) << "both are still drawn";
+
+    const std::vector<ExportObject> objects = splitBodiesForExport(renderable, nullptr);
+    ASSERT_EQ(objects.size(), 1u) << "but only the cube is exported";
+    // Only the cube survives, so the height is the cube's own.
+    float zmin = 1e9f, zmax = -1e9f;
+    for (size_t i = 2; i < objects[0].verts.size(); i += 3) {
+        zmin = std::min(zmin, objects[0].verts[i]);
+        zmax = std::max(zmax, objects[0].verts[i]);
+    }
+    EXPECT_NEAR(zmax - zmin, 1.0f, 1e-5f);
+}
+
+TEST(MixedDimensions, ExportKeepsTheFlatSlabWhenItIsTheOnlyGeometry) {
+    // A 2D-only script has nothing else to write, so its slab still exports
+    // -- unchanged behaviour, and the only reason the filter is conditional.
+    Evaluated e = evalSrc("square(4);");
+    const std::vector<ExportObject> objects =
+        splitBodiesForExport(toRenderableBodies(e.bodies), nullptr);
+    EXPECT_EQ(objects.size(), 1u);
+}
+
+TEST(MixedDimensions, ATranslatedTwoDeeShapeKeepsItsZ) {
+    // A CrossSection is purely 2D, so `translate([0,0,-1]) square(10)` had
+    // nowhere to put the -1 and dropped it. Two 2D shapes meant to be
+    // layered then came out exactly coplanar, z-fought, and whichever drew
+    // last hid the other -- BOSL2's isosurface contour() Example 1 renders a
+    // green contour over a blue backdrop pushed down by 1, and the backdrop
+    // covered the contour completely.
+    Evaluated e = evalSrc("translate([0,0,-1]) square(10, center=true);");
     ASSERT_EQ(e.bodies.size(), 1u);
-    EXPECT_TRUE(e.bodies[0].section.has_value());
+    ASSERT_TRUE(e.bodies[0].section.has_value());
+    EXPECT_DOUBLE_EQ(e.bodies[0].sectionZ, -1.0);
+
+    const std::vector<ColoredBody> renderable = toRenderableBodies(e.bodies);
+    ASSERT_EQ(renderable.size(), 1u);
+    ASSERT_TRUE(renderable[0].body.has_value());
+    const manifold::Box box = renderable[0].body->BoundingBox();
+    EXPECT_NEAR(box.min.z, -1.0, 1e-9) << "the extruded slab sits where it was moved to";
+}
+
+TEST(MixedDimensions, TwoDeeZOffsetsAccumulateAndDefaultToZero) {
+    Evaluated flat = evalSrc("square(10);");
+    ASSERT_EQ(flat.bodies.size(), 1u);
+    EXPECT_DOUBLE_EQ(flat.bodies[0].sectionZ, 0.0);
+
+    Evaluated stacked = evalSrc(
+        "translate([0,0,2]) translate([0,0,3]) square(10);");
+    ASSERT_EQ(stacked.bodies.size(), 1u);
+    EXPECT_DOUBLE_EQ(stacked.bodies[0].sectionZ, 5.0);
+
+    // x/y still go into the CrossSection itself, not the offset.
+    Evaluated moved = evalSrc("translate([4,5,6]) square(10);");
+    ASSERT_EQ(moved.bodies.size(), 1u);
+    EXPECT_DOUBLE_EQ(moved.bodies[0].sectionZ, 6.0);
+    const manifold::Rect r = moved.bodies[0].section->Bounds();
+    EXPECT_NEAR(r.min.x, 4.0, 1e-9);
+    EXPECT_NEAR(r.min.y, 5.0, 1e-9);
 }
 
 TEST(MixedDimensions, UniformChildrenAreUntouched) {

{openscad_cpp_evaluator-0.55.1 → openscad_cpp_evaluator-0.55.3}/tests/test_export.cpp

@@ -91,7 +91,7 @@ TEST(ExportStl, NoGeometryThrows) {
 TEST(ToRenderableBodies, ThinExtrudesABareTopLevel2dShapeSoItCanExportAsStl) {
     // A bare `circle();` (no `body`, only `section`) would make writeStl
     // throw "No geometry to export" -- toRenderableBodies() converts it
-    // into a thin (1e-3 unit tall) Manifold first, mirroring the reference
+    // into a 1-unit-tall Manifold first, mirroring the reference
     // CLI's own to_renderable_bodies() call right before export. Without
     // this step, no top-level 2D-only script could ever export a mesh.
     std::vector<ColoredBody> bodies = evalToBodies("circle(2, $fn=32);");
@@ -104,7 +104,9 @@ TEST(ToRenderableBodies, ThinExtrudesABareTopLevel2dShapeSoItCanExportAsStl) {
     ASSERT_TRUE(renderable[0].body.has_value());
     EXPECT_TRUE(renderable[0].flatPreview);
     manifold::Box bbox = renderable[0].body->BoundingBox();
-    EXPECT_NEAR(bbox.max.z - bbox.min.z, 1e-3, 1e-9);
+    // 1 unit, matching what the reference extrudes a 2D preview to --
+    // measured against OpenSCAD at three camera tilts.
+    EXPECT_NEAR(bbox.max.z - bbox.min.z, 1.0, 1e-9);
 
     const std::string path = tempPath("flat_preview.stl").string();
     writeStl(path, renderable);

{openscad_cpp_evaluator-0.55.1 → openscad_cpp_evaluator-0.55.3}/tests/test_python_bindings.py

@@ -351,6 +351,43 @@ def test_parse_ast_raises_parse_error_on_bad_syntax():
     raise AssertionError("expected ParseError")
 
 
+def test_format_source_round_trips_and_is_idempotent():
+    from openscad_cpp_evaluator import format_source
+
+    out = format_source("module thing(a=1,b=[1,2,3]){translate([0,0,1])cube([a,a,a]);}\n")
+    assert "module thing(a=1, b=[1, 2, 3])" in out, out
+    # A modifier's children go on their own indented line.
+    assert "translate([0, 0, 1])\n        cube([a, a, a]);" in out, out
+    # Formatting formatted source changes nothing: the printer is the
+    # parser's own, so its output parses back to the same tree.
+    assert format_source(out) == out
+
+
+def test_format_source_keeps_comments():
+    from openscad_cpp_evaluator import format_source
+
+    out = format_source("// keep me\ncube(1);\n")
+    assert "// keep me" in out, out
+    # ...and can be told not to.
+    assert "// keep me" not in format_source("// keep me\ncube(1);\n", include_comments=False)
+
+
+def test_format_source_honours_the_indent_width():
+    from openscad_cpp_evaluator import format_source
+
+    two = format_source("module m(){cube(1);}\n", indent=2)
+    assert "\n  cube(1);" in two, two
+
+
+def test_format_source_raises_parse_error_on_bad_input():
+    from openscad_cpp_evaluator import ParseError, format_source
+    try:
+        format_source("module {{{")
+    except ParseError:
+        return
+    raise AssertionError("expected ParseError")
+
+
 def main():
     tests = [v for k, v in sorted(globals().items()) if k.startswith("test_") and callable(v)]
     failures = []