openscad-cpp-evaluator 1.21.0__tar.gz → 1.22.0__tar.gz

{openscad_cpp_evaluator-1.21.0 → openscad_cpp_evaluator-1.22.0}/CLAUDE.md

@@ -1121,6 +1121,18 @@ grep for `ponytail:`.
   `user_calls.cpp`'s `evalFunctionCall`, special-cased *before* the `isBuiltinFunctionName` gate
   since `import` isn't in that table — returns a VNF `[[verts],[faces]]` for a mesh file, a Region
   `[[[x,y],...],...]` for DXF/SVG, or the JSON file's content as native values).
+  **SVG filtering**: `id=` selects one element by its `id` (upstream's own parameter, and
+  matching a `<g>` takes everything under it); `class=` selects by one entry of an element's
+  space-separated `class` list, which is **this port's addition** (`supported_feature("svg-class")`)
+  because a class is how a drawing marks "every cut line" without naming each one. Both apply in
+  the module *and* expression forms, enclosing transforms still apply to a selected element (it
+  has to land where it does in the drawing), and **a filter that matches nothing imports nothing
+  and warns** rather than falling back to the whole file — a cut layer that quietly became every
+  layer is the worst answer available. `layer=` stays DXF-only on purpose: upstream reuses the
+  name for SVG but reads only Inkscape's `inkscape:label`, a vendor convention rather than
+  anything SVG defines, so it cannot match a layer from any other tool. `id` had been in
+  `registry.cpp`'s declared parameter list since long before anything read it, so a script
+  filtering by id was accepted in full and silently handed the whole drawing.
   `resolveFilePath()` (also declared here, defined in import.cpp) — resolves a file argument
   relative to the *source .scad file's own directory* — is shared by every file-reading builtin,
   not just import() (`surface.cpp` uses it too). `zip_stored.hpp` is a hand-rolled, dependency-free

{openscad_cpp_evaluator-1.21.0 → openscad_cpp_evaluator-1.22.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.21.0 → openscad_cpp_evaluator-1.22.0}/include/openscad_cpp_evaluator/dxf_svg_import.hpp

@@ -22,6 +22,20 @@ std::vector<Contour2d> loadDxfContours(const std::string& path, const std::optio
 // group transforms). Y is flipped (SVG's is down, OpenSCAD's is up).
 // Throws std::runtime_error on I/O/parse failure. Mirrors
 // _load_svg_contours.
-std::vector<Contour2d> loadSvgContours(const std::string& path);
+//: Which part of the drawing to import. Both unset means the whole file.
+//: `id` matches an element's `id` attribute; `cls` matches one entry of its
+//: space-separated `class` list. Matching an element takes everything under
+//: it, so a filter naming a <g> means "that group".
+struct SvgFilter {
+    std::optional<std::string> id;
+    std::optional<std::string> cls;
+};
+
+// `matched`, when given, reports whether the filter found anything. A miss
+// imports nothing rather than falling back to the whole drawing; the caller
+// warns. Always true when no filter was set.
+std::vector<Contour2d> loadSvgContours(const std::string& path,
+                                       const SvgFilter& filter = {},
+                                       bool* matched = nullptr);
 
 } // namespace oscadeval

{openscad_cpp_evaluator-1.21.0 → openscad_cpp_evaluator-1.22.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.21.0 → openscad_cpp_evaluator-1.22.0}/src/builtins/function_builtins.cpp

@@ -1046,6 +1046,7 @@ const std::unordered_map<std::string, double>& featureLevels() {
         {"expr-import", 1.0},        // import() in expression position
         {"object-function", 1.0},    // object(), unconditional here
         {"roof-op", 1.0},            // roof(), method="voronoi" only
+        {"svg-class", 1.0},          // import(svg, class=); id= is upstream's
     };
     return levels;
 }

{openscad_cpp_evaluator-1.21.0 → openscad_cpp_evaluator-1.22.0}/src/builtins/import.cpp

@@ -176,6 +176,13 @@ CSGParams resolveImport(Evaluator& ev, const oscad::ModularCall& node, EvalConte
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
     const Value fileArg = getArg(args, 0, "file", Value{});
     const Value layerArg = getArg(args, std::nullopt, "layer", Value{});
+    // SVG only. `id` matches an element's id; `class` matches one entry of
+    // its space-separated class list. `layer` stays DXF's, where layers are
+    // part of the format -- upstream reuses the name for SVG but reads only
+    // Inkscape's `inkscape:label`, which is a vendor convention rather than
+    // anything SVG defines.
+    const Value idArg = getArg(args, std::nullopt, "id", Value{});
+    const Value classArg = getArg(args, std::nullopt, "class", Value{});
     // Not an OpenSCAD parameter. A script using it will not run upstream,
     // which is why it has to be asked for rather than being the default.
     const bool repair = truthy(getArg(args, std::nullopt, "repair", Value{false}));
@@ -196,7 +203,24 @@ CSGParams resolveImport(Evaluator& ev, const oscad::ModularCall& node, EvalConte
                 if (const std::string* s = std::get_if<std::string>(&layerArg)) layer = *s;
                 contours = loadDxfContours(path, layer);
             } else {
-                contours = loadSvgContours(path);
+                SvgFilter filter;
+                if (const std::string* v = std::get_if<std::string>(&idArg)) filter.id = *v;
+                if (const std::string* v = std::get_if<std::string>(&classArg)) filter.cls = *v;
+                bool matched = true;
+                contours = loadSvgContours(path, filter, &matched);
+                if (!matched) {
+                    // Nothing imported, rather than silently falling back to
+                    // the whole drawing -- a cut layer that quietly became
+                    // every layer is the worst answer available.
+                    std::string what;
+                    if (filter.id) what += "id = \"" + *filter.id + "\"";
+                    if (filter.cls) {
+                        if (!what.empty()) what += ", ";
+                        what += "class = \"" + *filter.cls + "\"";
+                    }
+                    ev.warn("import() filter " + what + " did not match anything in "
+                            + path, &node.position());
+                }
             }
         } catch (const std::exception& e) {
             ev.error(std::string("import: ") + e.what(), node);
@@ -340,6 +364,13 @@ std::vector<ColoredBody> generateImport(Evaluator& ev, const CSGParams& params,
 Value importAsValue(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& node) {
     const Value fileArg = getArg(args, 0, "file", Value{});
     const Value layerArg = getArg(args, std::nullopt, "layer", Value{});
+    // SVG only. `id` matches an element's id; `class` matches one entry of
+    // its space-separated class list. `layer` stays DXF's, where layers are
+    // part of the format -- upstream reuses the name for SVG but reads only
+    // Inkscape's `inkscape:label`, which is a vendor convention rather than
+    // anything SVG defines.
+    const Value idArg = getArg(args, std::nullopt, "id", Value{});
+    const Value classArg = getArg(args, std::nullopt, "class", Value{});
     if (std::holds_alternative<std::monostate>(fileArg)) {
         ev.error("import: 'file' parameter is required", node);
     }
@@ -356,7 +387,24 @@ Value importAsValue(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& n
                 if (const std::string* s = std::get_if<std::string>(&layerArg)) layer = *s;
                 contours = loadDxfContours(path, layer);
             } else {
-                contours = loadSvgContours(path);
+                SvgFilter filter;
+                if (const std::string* v = std::get_if<std::string>(&idArg)) filter.id = *v;
+                if (const std::string* v = std::get_if<std::string>(&classArg)) filter.cls = *v;
+                bool matched = true;
+                contours = loadSvgContours(path, filter, &matched);
+                if (!matched) {
+                    // Nothing imported, rather than silently falling back to
+                    // the whole drawing -- a cut layer that quietly became
+                    // every layer is the worst answer available.
+                    std::string what;
+                    if (filter.id) what += "id = \"" + *filter.id + "\"";
+                    if (filter.cls) {
+                        if (!what.empty()) what += ", ";
+                        what += "class = \"" + *filter.cls + "\"";
+                    }
+                    ev.warn("import() filter " + what + " did not match anything in "
+                            + path, &node.position());
+                }
             }
             return contoursToValue(contours);
         }

{openscad_cpp_evaluator-1.21.0 → openscad_cpp_evaluator-1.22.0}/src/builtins/registry.cpp

@@ -116,10 +116,13 @@ const std::vector<std::string>* builtinParamNames(const std::string& name) {
         {"minkowski", {"convexity"}},
         {"children", {"index", "separate"}},
         {"render", {"convexity"}},
-        // "repair" is this port's own addition, not an upstream parameter.
+        // "repair" and "class" are this port's own additions, not upstream
+        // parameters. ("id" IS upstream's, and was declared here long before
+        // anything read it -- so a script filtering by id was accepted in
+        // full and quietly given the whole drawing.)
         {"import",
           {"file", "layer", "convexity", "origin", "scale", "width", "height", "filename", "layername", "center", "dpi",
-           "id", "repair"}},
+           "id", "class", "repair"}},
         {"linear_extrude", {"height", "v", "scale", "center", "twist", "slices", "segments", "convexity"}},
         {"rotate_extrude", {"angle", "start", "convexity"}},
         {"projection", {"cut", "convexity"}},

{openscad_cpp_evaluator-1.21.0 → openscad_cpp_evaluator-1.22.0}/src/import/svg_import.cpp

@@ -450,9 +450,50 @@ void walk(const XmlNode& el, const Mat3& mat, std::vector<Contour2d>& out) {
     for (const XmlNode& child : el.children) walk(child, m, out);
 }
 
+// `class` is a space-separated LIST, so this is membership rather than
+// equality: class="cut outline" is matched by class="cut".
+bool hasClass(const XmlNode& el, const std::string& want) {
+    const std::string attr = el.getAttr("class");
+    size_t i = 0;
+    while (i < attr.size()) {
+        while (i < attr.size() && std::isspace(static_cast<unsigned char>(attr[i]))) ++i;
+        size_t j = i;
+        while (j < attr.size() && !std::isspace(static_cast<unsigned char>(attr[j]))) ++j;
+        if (j > i && attr.compare(i, j - i, want) == 0) return true;
+        i = j;
+    }
+    return false;
+}
+
+bool matches(const XmlNode& el, const SvgFilter& f) {
+    if (f.id && el.getAttr("id") == *f.id) return true;
+    if (f.cls && hasClass(el, *f.cls)) return true;
+    return false;
+}
+
+// Walk looking for matching elements; everything under one is taken whole,
+// which is what makes `id=` on a <g> mean "that group". Transforms above
+// the match still apply -- a selected shape must land where it does in the
+// drawing, not at the origin.
+void walkFiltered(const XmlNode& el, const Mat3& mat, const SvgFilter& f,
+                  std::vector<Contour2d>& out, bool& matched) {
+    if (el.tag == "defs" || el.tag == "symbol") return;
+    const Mat3 m = compose(parseTransform(el.getAttr("transform")), mat);
+    if (matches(el, f)) {
+        matched = true;
+        const std::vector<Contour2d> shapes = shapeContours(el, m);
+        out.insert(out.end(), shapes.begin(), shapes.end());
+        for (const XmlNode& child : el.children) walk(child, m, out);
+        return;     // a match is taken whole; no nested re-matching
+    }
+    for (const XmlNode& child : el.children) walkFiltered(child, m, f, out, matched);
+}
+
 } // namespace
 
-std::vector<Contour2d> loadSvgContours(const std::string& path) {
+std::vector<Contour2d> loadSvgContours(const std::string& path,
+                                      const SvgFilter& filter,
+                                      bool* matched) {
     std::ifstream in(path);
     if (!in) throw std::runtime_error("could not open '" + path + "'");
     std::stringstream buf;
@@ -461,7 +502,17 @@ std::vector<Contour2d> loadSvgContours(const std::string& path) {
     if (!root) throw std::runtime_error("'" + path + "' is not a well-formed SVG file");
 
     std::vector<Contour2d> out;
-    walk(*root, Mat3{}, out);
+    if (!filter.id && !filter.cls) {
+        if (matched) *matched = true;   // no filter, nothing to miss
+        walk(*root, Mat3{}, out);
+        return out;
+    }
+    bool hit = false;
+    walkFiltered(*root, Mat3{}, filter, out, hit);
+    // A filter that matched nothing imports nothing -- it does NOT fall
+    // back to the whole drawing, which would be the silent-wrong-geometry
+    // answer. The caller turns this into the warning.
+    if (matched) *matched = hit;
     return out;
 }
 

{openscad_cpp_evaluator-1.21.0 → openscad_cpp_evaluator-1.22.0}/tests/test_dxf_svg_import.cpp

@@ -550,3 +550,105 @@ TEST(DxfCross, ParallelOrTooFewLinesWarns) {
     EXPECT_NE(last.find("Can't find cross"), std::string::npos) << last;
     std::filesystem::remove(path);
 }
+
+// --- SVG id=/class= filters ------------------------------------------------
+//
+// Upstream OpenSCAD filters an SVG import by `id`. `class` is this port's own
+// addition (`supported_feature("svg-class")`), because a class is how a
+// drawing marks "every cut line" without naming each one.
+//
+// `layer` deliberately stays DXF's: upstream reuses the name for SVG but
+// reads only Inkscape's `inkscape:label`, a vendor convention rather than
+// anything SVG defines, so it would not match a layer from any other tool.
+
+namespace {
+
+constexpr const char* kFilterSvg = R"SVG(<svg xmlns="http://www.w3.org/2000/svg"
+     width="100" height="100" viewBox="0 0 100 100">
+  <g id="grp" transform="translate(10,0)">
+    <rect id="inner" class="cut outline" x="0" y="0" width="20" height="10"/>
+  </g>
+  <rect id="other" class="outline" x="50" y="50" width="10" height="10"/>
+</svg>)SVG";
+
+size_t contourCount(const std::string& file, const std::string& args, Evaluator& ev) {
+    Value v = asExpr("import(\"" + file + "\"" + args + ")", ev);
+    return std::get<ListPtr>(v)->items.size();
+}
+
+} // namespace
+
+TEST(SvgFilter, NoFilterImportsEverything) {
+    const auto path = tempPath("filter_all.svg");
+    writeFile(path, kFilterSvg);
+    Evaluator ev;
+    EXPECT_EQ(contourCount(path.generic_string(), "", ev), 2u);
+    std::filesystem::remove(path);
+}
+
+TEST(SvgFilter, IdSelectsOneElement) {
+    const auto path = tempPath("filter_id.svg");
+    writeFile(path, kFilterSvg);
+    Evaluator ev;
+    EXPECT_EQ(contourCount(path.generic_string(), ", id=\"inner\"", ev), 1u);
+    EXPECT_EQ(contourCount(path.generic_string(), ", id=\"other\"", ev), 1u);
+    std::filesystem::remove(path);
+}
+
+TEST(SvgFilter, IdOnAGroupTakesItsContents) {
+    const auto path = tempPath("filter_grp.svg");
+    writeFile(path, kFilterSvg);
+    Evaluator ev;
+    EXPECT_EQ(contourCount(path.generic_string(), ", id=\"grp\"", ev), 1u);
+    std::filesystem::remove(path);
+}
+
+TEST(SvgFilter, ClassIsListMembershipNotEquality) {
+    // class="cut outline" is matched by either name on its own.
+    const auto path = tempPath("filter_cls.svg");
+    writeFile(path, kFilterSvg);
+    Evaluator ev;
+    EXPECT_EQ(contourCount(path.generic_string(), ", class=\"cut\"", ev), 1u);
+    EXPECT_EQ(contourCount(path.generic_string(), ", class=\"outline\"", ev), 2u);
+    // A prefix of a real class must not match.
+    EXPECT_EQ(contourCount(path.generic_string(), ", class=\"out\"", ev), 0u);
+    std::filesystem::remove(path);
+}
+
+TEST(SvgFilter, AnEnclosingTransformStillApplies) {
+    // The selected rect sits inside translate(10,0). Picking it must not
+    // move it back to the origin -- it has to land where it does in the
+    // drawing, or a filtered import cannot be composed with an unfiltered one.
+    const auto path = tempPath("filter_xf.svg");
+    writeFile(path, kFilterSvg);
+    Evaluator ev;
+    Value v = asExpr("import(\"" + path.generic_string() + "\", id=\"inner\")", ev);
+    const auto& region = std::get<ListPtr>(v)->items;
+    ASSERT_EQ(region.size(), 1u);
+    const auto& pts = std::get<ListPtr>(region[0])->items;
+    ASSERT_EQ(pts.size(), 4u);
+    double minx = 1e9;
+    for (const auto& p : pts) minx = std::min(minx, std::get<double>(std::get<ListPtr>(p)->items[0]));
+    EXPECT_NEAR(minx, 10.0, 1e-9);
+    std::filesystem::remove(path);
+}
+
+TEST(SvgFilter, AMissImportsNothingAndWarns) {
+    // Emphatically not a fall-back to the whole drawing: a cut layer that
+    // quietly became every layer is the worst answer available.
+    const auto path = tempPath("filter_miss.svg");
+    writeFile(path, kFilterSvg);
+    std::string last;
+    Evaluator ev([&](const std::string& m) { last = m; });
+    EXPECT_EQ(contourCount(path.generic_string(), ", id=\"nosuch\"", ev), 0u);
+    EXPECT_NE(last.find("did not match anything"), std::string::npos) << last;
+    std::filesystem::remove(path);
+}
+
+TEST(SvgFilter, IdAndClassTogetherMatchEither) {
+    const auto path = tempPath("filter_both.svg");
+    writeFile(path, kFilterSvg);
+    Evaluator ev;
+    EXPECT_EQ(contourCount(path.generic_string(), ", id=\"other\", class=\"cut\"", ev), 2u);
+    std::filesystem::remove(path);
+}

{openscad_cpp_evaluator-1.21.0 → openscad_cpp_evaluator-1.22.0}/tests/test_feature_detection.cpp

@@ -35,7 +35,8 @@ std::vector<std::string> echoesFrom(const std::string& src) {
 // in featureLevels() -- shows up as a 0.
 const char* kFeatures[] = {"separate-children", "minkowski-diff", "sphere-styles",   "export-name",
                             "simplify-op",       "expr-import",    "object-function", "roof-op",
-                            "render-expr",       "polyhedron-vnf", "linear-solve", "levelset"};
+                            "render-expr",       "polyhedron-vnf", "linear-solve",    "levelset",
+                            "svg-class"};
 
 } // namespace
 

{openscad_cpp_evaluator-1.21.0 → openscad_cpp_evaluator-1.22.0}/tests/test_python_bindings.py

@@ -992,3 +992,57 @@ def test_top_level_geometry_has_no_call_site():
     for node in id_to_node.values():
         assert node.call_site is None
         assert os.path.realpath(node.position.origin) == os.path.realpath(p)
+
+
+SVG_FILTER = """<svg xmlns="http://www.w3.org/2000/svg" width="100" height="100" viewBox="0 0 100 100">
+  <g id="grp" transform="translate(10,0)">
+    <rect id="inner" class="cut outline" x="0" y="0" width="20" height="10"/>
+  </g>
+  <rect id="other" class="outline" x="50" y="50" width="10" height="10"/>
+</svg>"""
+
+
+def _svg_counts(tmp_path, args):
+    """(count, messages) for the region import() returns.
+
+    echo_fn receives warnings as well as echoes, so the ECHO line has to be
+    picked out rather than assumed to be first -- a filter that misses warns
+    before it echoes."""
+    svg = tmp_path / "f.svg"
+    svg.write_text(SVG_FILTER)
+    scad = tmp_path / "f.scad"
+    scad.write_text(f'echo(n = len(import("{svg}"{args})));\n')
+    msgs = []
+    Evaluator(echo_fn=msgs.append).evaluate(str(scad), generate=False)
+    echoes = [m for m in msgs if m.startswith("ECHO:")]
+    assert len(echoes) == 1, msgs
+    return int(echoes[0].split("=")[1]), msgs
+
+
+def test_svg_import_filters_by_id(tmp_path):
+    assert _svg_counts(tmp_path, "")[0] == 2
+    assert _svg_counts(tmp_path, ', id = "inner"')[0] == 1
+    assert _svg_counts(tmp_path, ', id = "grp"')[0] == 1
+
+
+def test_svg_import_filters_by_class(tmp_path):
+    """A class is a space-separated list, so this is membership."""
+    assert _svg_counts(tmp_path, ', class = "cut"')[0] == 1
+    assert _svg_counts(tmp_path, ', class = "outline"')[0] == 2
+    assert _svg_counts(tmp_path, ', class = "out"')[0] == 0
+
+
+def test_svg_filter_miss_imports_nothing_and_warns(tmp_path):
+    """Not a fall-back to the whole drawing -- that would be wrong geometry
+    with nothing said about it."""
+    count, msgs = _svg_counts(tmp_path, ', id = "nosuch"')
+    assert count == 0
+    assert any("did not match anything" in m for m in msgs), msgs
+
+
+def test_svg_class_is_feature_detectable(tmp_path):
+    scad = tmp_path / "f.scad"
+    scad.write_text('echo(v = supported_feature("svg-class"));\n')
+    out = []
+    Evaluator(echo_fn=out.append).evaluate(str(scad), generate=False)
+    assert "1" in out[0], out