openscad-cpp-evaluator 1.7.2__tar.gz → 1.9.0__tar.gz

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.9.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.9.0}/bindings/module.cpp

@@ -357,7 +357,7 @@ struct Geometry {
 // exportModel, with the path/format/warnings marshalling. Releases the GIL:
 // a large export is seconds of Manifold work with no Python involved.
 nb::list exportModelPy(const std::string& path, const Geometry& geom, const std::string& format, bool asciiStl,
-                        bool stripSlivers) {
+                        bool stripSlivers, bool splitComponents) {
     std::vector<std::string> warnings;
     {
         nb::gil_scoped_release rel;
@@ -365,6 +365,7 @@ nb::list exportModelPy(const std::string& path, const Geometry& geom, const std:
         opts.format = format;
         opts.asciiStl = asciiStl;
         opts.stripSlivers = stripSlivers;
+        opts.splitComponents = splitComponents;
         warnings = oscadeval::exportModel(path, geom.bodies, opts);
     }
     nb::list out;
@@ -374,7 +375,7 @@ nb::list exportModelPy(const std::string& path, const Geometry& geom, const std:
 
 nb::object evaluate(const std::string& path, nb::dict viewportParams,
                      std::shared_ptr<oscadeval::ManifoldCache> manifoldCache, bool profile,
-                     bool generate) {
+                     bool generate, bool strictCommas) {
     std::unordered_map<std::string, oscadeval::Value> vp = toViewportParams(viewportParams);
 
     std::vector<oscadeval::ColoredBody> bodies;
@@ -388,6 +389,12 @@ nb::object evaluate(const std::string& path, nb::dict viewportParams,
         nb::gil_scoped_release rel;
         auto logFn = [&echoes](const std::string& m) { echoes.push_back(m); };
         try {
+            // Constructed on the parsing thread, which is the one whose
+            // thread-local mode StrictCommaScope sets -- a flag flipped from
+            // Python before the call would sit on the wrong thread the
+            // moment a host evaluates off the main one.
+            std::optional<oscad::StrictCommaScope> strict;
+            if (strictCommas) strict.emplace();
             oscad::ParsedProgram program = oscad::getProgramFromFile(path);
             oscadeval::ResolvedUseScopes used = oscadeval::resolveUseScopes(program.nodes, path, logFn);
             oscadeval::Evaluator ev(logFn, nullptr, manifoldCache, oscadeval::DebugHooks{}, profile);
@@ -786,21 +793,28 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
 
     m.def("export_model", &exportModelPy, nb::arg("path"), nb::arg("geometry"), nb::arg("format") = std::string(),
           nb::arg("ascii_stl") = false, nb::arg("strip_slivers") = true,
+          nb::arg("split_components") = false,
           "Write `geometry` to `path`, format taken from the extension unless `format` says otherwise. "
           "Returns the warnings to surface (open shells, mesh problems, slivers removed) rather than "
           "logging them. Raises RuntimeError when there is no geometry, the format is unknown, or the "
-          "file cannot be opened.");
+          "file cannot be opened.\n\n"
+          "`split_components` gives every disconnected piece its own object in the multi-object formats "
+          "(3MF, AMF, OBJ, PLY, VRML, X3D). Off by default, matching OpenSCAD, which writes one object "
+          "per colour however many pieces it is in.");
 
     m.def("export_extensions", []() { return oscadeval::exportExtensions(); },
           "The file extensions export_model understands, dot-prefixed. Read from the C++ writer table "
           "rather than restated here, so the Python side cannot drift from what can actually be written.");
 
     m.def("evaluate", &evaluate, nb::arg("path"), nb::arg("viewport_params"), nb::arg("manifold_cache") = nullptr,
-          nb::arg("profile") = false, nb::arg("generate") = true,
+          nb::arg("profile") = false, nb::arg("generate") = true, nb::arg("strict_commas") = false,
           "Evaluate a .scad file; return (bodies, echoes, id_to_node, csg_tree, profile_result, dyn, dyn_explicit).\n"
           "generate=False stops after the resolve pass: the script runs and reports everything "
           "it normally would, but no Manifold geometry is built, and neither bodies nor csg_tree "
-          "are populated.");
+          "are populated.\n\n"
+          "strict_commas=True makes a trailing comma in a call argument list or a let/for "
+          "assignment list a syntax error, as OpenSCAD 2021.01 did. List literals and parameter "
+          "declarations keep theirs, which 2021.01 accepted too.");
     m.def("parse_decls", &parseDecls, nb::arg("path"),
           "Parse a .scad file; return top-level declaration (namespace, name, start, end, line, column, origin) tuples.");
     m.def("strip_slivers", &stripSliversPy, nb::arg("verts"), nb::arg("tris"),

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.9.0}/external/openscad_cpp_parser/include/openscad_cpp_parser/api.hpp

@@ -60,6 +60,44 @@ std::unique_ptr<Scope> buildScopes(const std::vector<ASTNode*>& ast);
 std::unique_ptr<Scope> buildScopesInto(const std::vector<std::unique_ptr<ASTNode>>& ast, ScopeTable& table);
 std::unique_ptr<Scope> buildScopesInto(const std::vector<ASTNode*>& ast, ScopeTable& table);
 
+// Makes a trailing comma in a CALL ARGUMENT LIST a syntax error for as long
+// as it is in scope, matching OpenSCAD 2021.01:
+//
+//     cube(1,);                  // error while this is in scope
+//     echo(let(x = 1, y = 2,) x) // error -- let() parses as a call
+//     a = [2, 4,];               // still fine: 2021.01 accepts it too
+//     module m(a, b,) {}         // still fine, same reason
+//
+// One production (`arguments`) feeds every call form -- module
+// instantiation, function calls, echo, assert, render and let -- so this is
+// one rule, not a family of them. Parameter lists and list literals are
+// deliberately untouched: 2021.01 accepts a trailing comma in both, and
+// rejecting them would fail files it loads happily.
+//
+// A scope object rather than a parameter on all nine parse entry points:
+// this is a parse-wide mode, the same shape ParseNumberingScope already
+// uses, and threading a bool through getASTFromString/getASTFromFile/
+// getASTFromLibraryFile/getProgramFromFile and their helpers would touch
+// every one of them to say the same thing. Nests and restores on scope
+// exit, exceptions included; thread-local, so one thread parsing strictly
+// cannot change what another thread sees.
+//
+// getProgramFromFile()'s cache keys on this too -- a strict parse must not
+// be handed a tree an earlier lenient parse of the same file left behind.
+class StrictCommaScope {
+public:
+    StrictCommaScope();
+    ~StrictCommaScope();
+    StrictCommaScope(const StrictCommaScope&) = delete;
+    StrictCommaScope& operator=(const StrictCommaScope&) = delete;
+
+private:
+    bool previous_;
+};
+
+// Whether a StrictCommaScope is currently in effect on this thread.
+bool strictCommasEnabled();
+
 // Parses `code`. Throws ParseError (with the full caret diagnostic) on a
 // syntax error.
 //

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.9.0}/external/openscad_cpp_parser/src/api.cpp

@@ -89,6 +89,17 @@ std::string formatSyntaxError(const ParserDriver& driver, const std::string& cod
 
 } // namespace
 
+namespace {
+// See StrictCommaScope (api.hpp). Thread-local so a strict parse on one
+// thread cannot change what another thread is parsing.
+thread_local bool g_strictCommas = false;
+} // namespace
+
+StrictCommaScope::StrictCommaScope() : previous_(g_strictCommas) { g_strictCommas = true; }
+StrictCommaScope::~StrictCommaScope() { g_strictCommas = previous_; }
+
+bool strictCommasEnabled() { return g_strictCommas; }
+
 std::vector<std::unique_ptr<ASTNode>> parseAst(const std::string& code, const std::string& origin, SourceMap* sourceMap) {
     // Stamps every node this parse builds with one treeId and a dense
     // slot, so a ScopeTable can address it without the node carrying a
@@ -96,6 +107,7 @@ std::vector<std::unique_ptr<ASTNode>> parseAst(const std::string& code, const st
     ParseNumberingScope numbering;
 
     ParserDriver driver(origin);
+    driver.strictCommas = g_strictCommas;
     lexerBeginString(code);
     yy::parser parser(driver);
     int rc = parser.parse();
@@ -258,7 +270,8 @@ namespace {
 using FileAst = std::vector<std::unique_ptr<ASTNode>>;
 using FileAstPtr = std::shared_ptr<const FileAst>;
 
-// One entry per (file, comments) -- keyed by PATH, with the content stamp
+// One entry per (file, comments, strict-commas) -- keyed by PATH, with the
+// content stamp
 // stored beside the tree rather than in the key. A stale stamp REPLACES the
 // entry instead of adding a second one: an editor re-renders on every save,
 // and a stamp-in-the-key cache would keep a full copy of every version the
@@ -266,11 +279,18 @@ using FileAstPtr = std::shared_ptr<const FileAst>;
 struct CacheKey {
     std::string path;
     bool comments;
-    bool operator==(const CacheKey& o) const { return comments == o.comments && path == o.path; }
+    // Part of the key, not incidental: the same file parses differently
+    // under StrictCommaScope, so a strict parse must not be served a tree an
+    // earlier lenient parse of it left here (and vice versa).
+    bool strictCommas;
+    bool operator==(const CacheKey& o) const {
+        return comments == o.comments && strictCommas == o.strictCommas && path == o.path;
+    }
 };
 struct CacheKeyHash {
     size_t operator()(const CacheKey& k) const {
-        return std::hash<std::string>{}(k.path) ^ (k.comments ? 0x5bf03635U : 0U);
+        return std::hash<std::string>{}(k.path) ^ (k.comments ? 0x5bf03635U : 0U)
+               ^ (k.strictCommas ? 0x9e3779b9U : 0U);
     }
 };
 struct CacheEntry {
@@ -290,7 +310,7 @@ FileAstPtr parseFileShared(const std::string& absPath, bool includeComments) {
     const auto written = fs::last_write_time(absPath, ec);
     const std::int64_t stampMtime = ec ? 0 : static_cast<std::int64_t>(written.time_since_epoch().count());
 
-    const CacheKey key{absPath, includeComments};
+    const CacheKey key{absPath, includeComments, g_strictCommas};
     {
         std::lock_guard<std::mutex> lock(g_astCacheMutex);
         auto it = g_astCache.find(key);

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.9.0}/external/openscad_cpp_parser/src/grammar/driver.hpp

@@ -39,6 +39,9 @@ public:
     std::string origin_;
     NodeList result;
     bool hadError = false;
+    // Copied from the ambient StrictCommaScope at parse start (api.cpp), so
+    // one parse's mode cannot change under it mid-run.
+    bool strictCommas = false;
     int errorLine = 0;
     int errorColumn = 0;
     int errorOffset = 0;

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.9.0}/external/openscad_cpp_parser/src/grammar/parser.y

@@ -247,7 +247,18 @@ parameter:
 arguments:
     %empty                    { $$ = NodeList{}; }
   | argument_seq               { $$ = std::move($1); }
-  | argument_seq ","            { $$ = std::move($1); }
+    // The trailing comma OpenSCAD 2021.01 rejected. Still parsed, then
+    // reported -- @2 is the comma itself, so the caret lands on it rather
+    // than on the whole argument list, which a %expect-style grammar split
+    // could not manage. This one production feeds every call form (module
+    // instantiation, function calls, echo, assert, render, and let), which
+    // is why the whole feature is one rule. See StrictCommaScope (api.hpp).
+  | argument_seq ","            {
+        if (driver.strictCommas) {
+            driver.reportError(@2, "trailing comma in argument list");
+        }
+        $$ = std::move($1);
+    }
   ;
 
 argument_seq:
@@ -263,7 +274,18 @@ argument:
 assignments_expr:
     %empty                          { $$ = NodeList{}; }
   | assignment_expr_seq              { $$ = std::move($1); }
-  | assignment_expr_seq ","           { $$ = std::move($1); }
+    // 2021.01 rejected this one too. `let` does NOT go through `arguments`
+    // in this grammar -- it has its own assignment list, shared with `for`
+    // and `intersection_for` -- so the feature is two productions, not the
+    // one it looks like. 2021.01 rejects a trailing comma in all four:
+    // let(x=1,), for(i=[0:2],), intersection_for(i=[0:1],) and the list
+    // comprehension forms of for. See StrictCommaScope (api.hpp).
+  | assignment_expr_seq ","           {
+        if (driver.strictCommas) {
+            driver.reportError(@2, "trailing comma in assignment list");
+        }
+        $$ = std::move($1);
+    }
   ;
 
 assignment_expr_seq:

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.9.0}/external/openscad_cpp_parser/tests/CMakeLists.txt

@@ -26,6 +26,7 @@ add_executable(oscad_tests
   test_ast_generation.cpp
   test_node_str.cpp
   test_render_expression.cpp
+  test_strict_commas.cpp
 )
 target_link_libraries(oscad_tests PRIVATE openscad_cpp_parser GTest::gtest_main)
 

openscad_cpp_evaluator-1.9.0/external/openscad_cpp_parser/tests/test_strict_commas.cpp

@@ -0,0 +1,117 @@
+// StrictCommaScope: a trailing comma in a call argument list is an error,
+// matching OpenSCAD 2021.01 (BelfrySCAD issue #362).
+//
+// The scope is deliberately narrow. Measured against 2021.01 itself, it
+// rejected a trailing comma in CALL ARGUMENTS and accepted one everywhere
+// else -- list literals, list comprehensions, and module/function parameter
+// declarations all take one, in 2021.01 as in every version since. Rejecting
+// those would fail files 2021.01 loads happily, so they are left alone and
+// this file says so case by case.
+#include "test_helpers.hpp"
+
+#include <gtest/gtest.h>
+
+using namespace oscad;
+
+namespace {
+
+// Two productions carry it: `arguments` (every call form) and
+// `assignments_expr` (let/for/intersection_for). `let` is NOT a call in this
+// grammar -- it has its own assignment list -- which the first draft of this
+// feature got wrong and this test caught.
+const char* const kRejected[] = {
+    "cube(1,);",                            // module instantiation
+    "translate([0,0,0],) cube(1);",         // ...with a child
+    "function g(x) = x; y = g(1,);",        // user function call
+    "y = max(1, 2,);",                      // builtin function call
+    "y = str(\"a\", \"b\",);",
+    "echo(1, 2,);",
+    "assert(true, \"m\",);",
+    // assignments_expr, not arguments
+    "y = let(x = 1, y = 2,) x + y;",
+    "let(x = 1,) cube(x);",
+    "for (i = [0:2],) cube(i);",
+    "intersection_for (i = [0:1],) cube(1);",
+    "a = [for (i = [0:1],) i];",
+};
+
+// Accepted by 2021.01, so accepted here even under the scope.
+const char* const kAccepted[] = {
+    "a = [2, 4,];",                         // list literal
+    "a = [for (i = [0:2]) i,];",            // list comprehension
+    "a = [each [1, 2],];",
+    "module m(a, b,) {} m(1, 2);",          // module parameter declaration
+    "function f(a, b,) = a + b;",           // function parameter declaration
+    "cube(1);",                             // no trailing comma at all
+    "y = max(1, 2);",
+};
+
+} // namespace
+
+TEST(StrictCommas, CallArgumentTrailingCommaIsAnErrorInScope) {
+    StrictCommaScope strict;
+    for (const char* src : kRejected) {
+        EXPECT_THROW(parseSrc(src), ParseError) << src;
+    }
+}
+
+TEST(StrictCommas, EverythingElseKeepsItsTrailingComma) {
+    StrictCommaScope strict;
+    for (const char* src : kAccepted) {
+        EXPECT_NO_THROW(parseSrc(src)) << src;
+    }
+}
+
+TEST(StrictCommas, OffByDefault) {
+    // The whole set parses without the scope -- this is opt-in, and every
+    // existing caller must be unaffected.
+    for (const char* src : kRejected) {
+        EXPECT_NO_THROW(parseSrc(src)) << src;
+    }
+}
+
+TEST(StrictCommas, ScopeNestsAndRestores) {
+    EXPECT_FALSE(strictCommasEnabled());
+    {
+        StrictCommaScope outer;
+        EXPECT_TRUE(strictCommasEnabled());
+        {
+            StrictCommaScope inner;
+            EXPECT_TRUE(strictCommasEnabled());
+        }
+        EXPECT_TRUE(strictCommasEnabled()) << "an inner scope must not switch it off";
+    }
+    EXPECT_FALSE(strictCommasEnabled());
+}
+
+TEST(StrictCommas, RestoresWhenAParseThrows) {
+    try {
+        StrictCommaScope strict;
+        parseSrc("cube(1,);");
+        FAIL() << "expected ParseError";
+    } catch (const ParseError&) {
+    }
+    EXPECT_FALSE(strictCommasEnabled()) << "the scope must unwind with the exception";
+}
+
+TEST(StrictCommas, TheErrorPointsAtTheComma) {
+    StrictCommaScope strict;
+    try {
+        parseSrc("cube(1,);");
+        FAIL() << "expected ParseError";
+    } catch (const ParseError& e) {
+        const std::string what = e.what();
+        EXPECT_NE(what.find("trailing comma in argument list"), std::string::npos) << what;
+    }
+}
+
+TEST(StrictCommas, AnAssignmentListSaysSo) {
+    StrictCommaScope strict;
+    try {
+        parseSrc("y = let(x = 1,) x;");
+        FAIL() << "expected ParseError";
+    } catch (const ParseError& e) {
+        const std::string what = e.what();
+        EXPECT_NE(what.find("trailing comma in assignment list"), std::string::npos) << what;
+    }
+}

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.9.0}/include/openscad_cpp_evaluator/export.hpp

@@ -39,13 +39,21 @@ struct ExportObject {
 //      `color("red") body(); color("blue") detail();` leaves the detail
 //      whole. Only the invisible interior is affected: the visible surface
 //      is identical either way.
-//   3. One object per connected component.
+//   3. One object per connected component -- OPTIONAL, and off by default.
+//      Rules 1 and 2 are about correctness; this one is presentation, and
+//      it is the one that diverges from OpenSCAD, which writes a single
+//      object however many disjoint pieces the model has. Splitting turned
+//      `cube(10); translate([20,0,0]) cube(10);` into two 3MF objects and a
+//      multiboard tile into hundreds, which slicers list individually and
+//      Prusa Slicer complains about (issue #319). Ask for it when separate
+//      pieces are what you want; leave it off to match OpenSCAD.
 //
 // A body Manifold rejected (an open shell is not a solid) can take part in
 // none of that: it keeps its own triangles and its own object, and its
 // 1-based index is appended to `openParts` for the caller to warn about.
 std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& bodies,
-                                                std::vector<int>* openParts = nullptr);
+                                                std::vector<int>* openParts = nullptr,
+                                                bool splitComponents = false);
 
 // Writes a binary STL: composes every body's mesh into one solid (bodies
 // with no `.body` -- 2D-only sections -- or an empty Manifold are
@@ -130,6 +138,12 @@ struct ExportOptions {
     // break no topology, but slicers commonly discard them and are then
     // left with the holes their removal opens.
     bool stripSlivers = true;
+    // Rule 3 of splitBodiesForExport: give every disconnected piece its own
+    // object in the multi-object formats (3MF, AMF, OBJ, PLY, VRML, X3D).
+    // Off matches OpenSCAD, which writes one object per colour however many
+    // pieces it is in; see that function's own comment for why the default
+    // moved here.
+    bool splitComponents = false;
 };
 
 // Writes `bodies` to `path`, choosing the writer from the extension (or

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.9.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.9.0}/python/openscad_cpp_evaluator/__init__.py

@@ -292,13 +292,13 @@ def strip_slivers(verts, tris):
 
 
 def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
-                 strip_slivers: bool = True) -> list:
+                 strip_slivers: bool = True, split_components: bool = False) -> list:
     """Write `geometry` to `path`. Returns the warnings to surface.
 
     `geometry` is the handle an Evaluator stashes on itself as
     `.geometry` -- the evaluated bodies, still on the C++ side. Export has
     to do real CSG (the implicit top-level union, the per-colour volume
-    claim, the connected-component split), and going through the flattened
+    claim), and going through the flattened
     arrays the renderer gets would mean rebuilding every Manifold first:
     ~146ms on a 224k-triangle model, and Manifold's own provenance lost
     along the way.
@@ -309,9 +309,13 @@ def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
     here refuses to write: a deliberately open surface is a legitimate
     export. Raises EvalError when there is no geometry, the format is
     unknown, or the file cannot be opened.
+
+    `split_components` gives every disconnected piece its own object in the
+    multi-object formats. Off by default, which is what OpenSCAD writes.
     """
     try:
-        return list(_ext.export_model(path, geometry, format, ascii_stl, strip_slivers))
+        return list(_ext.export_model(path, geometry, format, ascii_stl, strip_slivers,
+                                       split_components))
     except Exception as e:
         raise EvalError(str(e)) from e
 
@@ -493,7 +497,7 @@ class Evaluator:
         self.dyn_explicit = set()
 
     def evaluate(self, source_path: str, viewport_params: Optional[dict] = None,
-                 generate: bool = True):
+                 generate: bool = True, strict_commas: bool = False):
         """Run `source_path` and return (bodies, id_to_node).
 
         `generate=False` stops after the resolve pass. The script still runs
@@ -504,6 +508,13 @@ class Evaluator:
         the geometry without skipping the language.
 
         Ignored on the debugger path, which has no geometry handle anyway.
+
+        `strict_commas=True` makes a trailing comma in a call argument list
+        or a let/for assignment list a syntax error, as OpenSCAD 2021.01 did
+        -- `cube(1,)` and `let(x = 1,)`, but NOT `[2, 4,]` or
+        `module m(a, b,)`, which 2021.01 accepted. For checking a script
+        against that version; off, and no divergence from current OpenSCAD,
+        otherwise. Also ignored on the debugger path.
         """
         vp = viewport_params or {}
         try:
@@ -524,7 +535,8 @@ class Evaluator:
             else:
                 (body_dicts, echoes, id_spans, csg_tree, profile_result, dyn,
                  dyn_explicit, geometry) = _ext.evaluate(
-                    source_path, vp, self._manifold_cache, self._profile, generate)
+                    source_path, vp, self._manifold_cache, self._profile, generate,
+                    strict_commas)
                 # The evaluated bodies, still on the C++ side. Stashed like
                 # csg_tree/profile_result rather than returned, so
                 # evaluate()'s own 2-tuple result is unchanged -- callers

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.9.0}/src/export.cpp

@@ -418,7 +418,8 @@ std::vector<std::array<float, 4>> carryTriColors(const std::vector<std::array<fl
 
 } // namespace
 
-std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& bodies, std::vector<int>* openParts) {
+std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& bodies, std::vector<int>* openParts,
+                                                bool splitComponents) {
     struct Solid {
         manifold::Manifold man;
         std::optional<std::array<float, 4>> color;
@@ -545,9 +546,12 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
 
     std::vector<ExportObject> out;
     for (const Claimed& g : claimedGroups) {
-        // Decompose() is the rule-3 split. A single-component solid comes
-        // back as a one-element list, so there is no special case here.
-        std::vector<manifold::Manifold> parts = g.man.Decompose();
+        // Decompose() is the rule-3 split, and it is opt-in: without it this
+        // colour group stays one object however many disjoint pieces it is
+        // in, which is what OpenSCAD writes. A single-component solid comes
+        // back as a one-element list either way, so there is no special case.
+        std::vector<manifold::Manifold> parts;
+        if (splitComponents) parts = g.man.Decompose();
         if (parts.empty()) parts.push_back(g.man);
         for (const manifold::Manifold& part : parts) {
             if (part.IsEmpty()) continue;
@@ -1022,7 +1026,7 @@ std::vector<std::string> exportModel(const std::string& path, const std::vector<
         // its own -- that is what the file contains.
         for (std::string& w : checkExportBodies(bodies)) warnings.push_back(std::move(w));
         std::vector<int> openParts;
-        const std::vector<ExportObject> objects = splitBodiesForExport(bodies, &openParts);
+        const std::vector<ExportObject> objects = splitBodiesForExport(bodies, &openParts, opts.splitComponents);
         reportOpen(openParts);
         if (objects.empty()) throw std::runtime_error("No geometry to export");
         if (ext == ".3mf") {

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.9.0}/tests/test_export.cpp

@@ -163,10 +163,16 @@ TEST(ExportAmf, WritesOneObjectAndOneMaterialPerColour) {
 }
 
 TEST(ExportAmf, TwoObjectsSharingAColourShareOneMaterial) {
+    // splitComponents, because two objects is the premise: same-coloured
+    // disjoint pieces are ONE object by default (see the DisjointPieces
+    // tests below). What is under test here is that the two of them share a
+    // single material entry rather than each declaring their own.
     std::vector<ColoredBody> bodies =
         evalToBodies("color(\"red\") cube(2); translate([10,0,0]) color(\"red\") cube(2);");
     const std::string path = tempPath("shared.amf").string();
-    exportModel(path, bodies, ExportOptions{});
+    ExportOptions opts;
+    opts.splitComponents = true;
+    exportModel(path, bodies, opts);
 
     const std::string xml = readFile(path);
     EXPECT_EQ(countOf(xml, "<object id="), 2u);
@@ -174,6 +180,50 @@ TEST(ExportAmf, TwoObjectsSharingAColourShareOneMaterial) {
     std::remove(path.c_str());
 }
 
+// Issue #319: a model in several disconnected pieces was written as one
+// object PER PIECE, so a slicer listed them individually -- hundreds of
+// entries for a multiboard tile, and Prusa Slicer objecting. OpenSCAD writes
+// one object, and so does this by default now; the split is still available
+// for callers that want the pieces apart.
+TEST(ExportSplit, DisjointPiecesAreOneObjectByDefault) {
+    std::vector<ColoredBody> bodies =
+        evalToBodies("cube(10); translate([20,0,0]) cube(10); translate([40,0,0]) cube(10);");
+    const std::string path = tempPath("joined.amf").string();
+    exportModel(path, bodies, ExportOptions{});
+
+    const std::string xml = readFile(path);
+    EXPECT_EQ(countOf(xml, "<object id="), 1u);
+    EXPECT_EQ(countOf(xml, "<volume"), 1u);
+    std::remove(path.c_str());
+}
+
+TEST(ExportSplit, DisjointPiecesSplitWhenAsked) {
+    std::vector<ColoredBody> bodies =
+        evalToBodies("cube(10); translate([20,0,0]) cube(10); translate([40,0,0]) cube(10);");
+    const std::string path = tempPath("split.amf").string();
+    ExportOptions opts;
+    opts.splitComponents = true;
+    exportModel(path, bodies, opts);
+
+    const std::string xml = readFile(path);
+    EXPECT_EQ(countOf(xml, "<object id="), 3u);
+    std::remove(path.c_str());
+}
+
+// Rule 2 is not what became optional: differently-coloured solids must stay
+// separate objects either way, or a multi-material export loses its colours.
+TEST(ExportSplit, ColoursStayApartWithTheSplitOff) {
+    std::vector<ColoredBody> bodies =
+        evalToBodies("color(\"red\") cube(10); translate([20,0,0]) color(\"blue\") cube(10);");
+    const std::string path = tempPath("colours.amf").string();
+    exportModel(path, bodies, ExportOptions{});
+
+    const std::string xml = readFile(path);
+    EXPECT_EQ(countOf(xml, "<object id="), 2u);
+    EXPECT_EQ(countOf(xml, "<material id="), 2u);
+    std::remove(path.c_str());
+}
+
 TEST(ExportAmf, MaterialAndObjectIdsStartAtOne) {
     // id 0 is reserved by the spec; a reader may drop anything using it.
     std::vector<ColoredBody> bodies = evalToBodies("cube(2);");

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.9.0}/tests/test_python_bindings.py

@@ -633,3 +633,66 @@ def test_degenerate_ranges_do_not_overflow_the_element_count(tmp_path):
     # Silent for NaN; the unbounded pair warn, with the reference's number.
     assert len(warnings) == 2, warnings
     assert all("too many elements (4294967295)" in w for w in warnings), warnings
+
+
+def test_export_model_facade_accepts_split_components(tmp_path):
+    """The Python facade's signature must track the nanobind binding's.
+
+    They are two hand-written parameter lists for one call, and adding
+    `split_components` to the binding alone left the facade dropping it --
+    a TypeError the C++ suite cannot see, because it never goes through
+    Python. Caught in practice, hence this.
+    """
+    from openscad_cpp_evaluator import Evaluator, export_model
+
+    src = tmp_path / "pieces.scad"
+    src.write_text("cube(10); translate([20,0,0]) cube(10); translate([40,0,0]) cube(10);")
+    ev = Evaluator()
+    ev.evaluate(str(src), {})
+
+    def objects_in(path, **kwargs):
+        export_model(str(path), ev.geometry, **kwargs)
+        import zipfile
+        with zipfile.ZipFile(path) as z:
+            return z.read("3D/3dmodel.model").decode().count("<object ")
+
+    # Default matches OpenSCAD: one object however many pieces.
+    assert objects_in(tmp_path / "joined.3mf") == 1
+    assert objects_in(tmp_path / "split.3mf", split_components=True) == 3
+
+
+def test_strict_commas_reaches_the_parser(tmp_path):
+    """Evaluator.evaluate(strict_commas=True) must survive both hand-written
+    parameter lists -- the facade's and the nanobind binding's. The last
+    argument added this way was dropped by the facade and no C++ test could
+    see it (see test_export_model_facade_accepts_split_components)."""
+    import pytest
+    from openscad_cpp_evaluator import Evaluator, EvalError
+
+    rejected = tmp_path / "call.scad"
+    rejected.write_text("cube(1,);\n")
+    accepted = tmp_path / "list.scad"
+    accepted.write_text("a = [2, 4,];\ncube(a[0]);\n")
+
+    # Off by default: both parse, as they do in current OpenSCAD.
+    Evaluator(echo_fn=lambda _m: None).evaluate(str(rejected), {})
+    Evaluator(echo_fn=lambda _m: None).evaluate(str(accepted), {})
+
+    # On: a call's trailing comma is a syntax error, a list literal's is not
+    # -- 2021.01 accepted the list.
+    with pytest.raises(EvalError):
+        Evaluator(echo_fn=lambda _m: None).evaluate(str(rejected), {}, strict_commas=True)
+    Evaluator(echo_fn=lambda _m: None).evaluate(str(accepted), {}, strict_commas=True)
+
+
+def test_strict_commas_does_not_leak_between_evaluations(tmp_path):
+    """The parser mode is a scope object; a strict parse must not leave it on
+    for the next caller."""
+    import pytest
+    from openscad_cpp_evaluator import Evaluator, EvalError
+
+    src = tmp_path / "call.scad"
+    src.write_text("cube(1,);\n")
+    with pytest.raises(EvalError):
+        Evaluator(echo_fn=lambda _m: None).evaluate(str(src), {}, strict_commas=True)
+    Evaluator(echo_fn=lambda _m: None).evaluate(str(src), {})   # must not raise