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

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

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

{openscad_cpp_evaluator-0.55.1 → openscad_cpp_evaluator-0.55.2}/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.2}/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.2}/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.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "0.55.1"
+version = "0.55.2"
 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.2}/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.2}/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.2}/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 1e-3-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.2}/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,47 @@ 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(), 1u);
-    EXPECT_TRUE(e.bodies[0].section.has_value());
+    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 1e-3-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";
+    // The cube is a unit tall; the dropped slab would have been 1e-3.
+    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, UniformChildrenAreUntouched) {

{openscad_cpp_evaluator-0.55.1 → openscad_cpp_evaluator-0.55.2}/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 = []