pycadkit 0.5.1__tar.gz → 0.5.2__tar.gz

{pycadkit-0.5.1 → pycadkit-0.5.2}/Cargo.lock

@@ -152,7 +152,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit"
-version = "0.5.1"
+version = "0.5.2"
 dependencies = [
  "cadkit-core",
  "cadkit-dgn",
@@ -164,7 +164,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-capi"
-version = "0.5.1"
+version = "0.5.2"
 dependencies = [
  "cadkit",
  "serde",
@@ -173,7 +173,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-cli"
-version = "0.5.1"
+version = "0.5.2"
 dependencies = [
  "cadkit",
  "clap",
@@ -182,7 +182,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-core"
-version = "0.5.1"
+version = "0.5.2"
 dependencies = [
  "schemars",
  "serde",
@@ -192,7 +192,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-dgn"
-version = "0.5.1"
+version = "0.5.2"
 dependencies = [
  "cadkit-core",
  "cfb",
@@ -203,7 +203,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-dwg"
-version = "0.5.1"
+version = "0.5.2"
 dependencies = [
  "cadkit-core",
  "cadkit-dxf",
@@ -213,7 +213,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-dxf"
-version = "0.5.1"
+version = "0.5.2"
 dependencies = [
  "cadkit-core",
  "encoding_rs",
@@ -222,7 +222,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-geom"
-version = "0.5.1"
+version = "0.5.2"
 dependencies = [
  "i_overlay",
  "robust",
@@ -234,7 +234,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-gml"
-version = "0.5.1"
+version = "0.5.2"
 dependencies = [
  "cadkit-core",
  "quick-xml",
@@ -244,7 +244,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-gpu"
-version = "0.5.1"
+version = "0.5.2"
 dependencies = [
  "cadkit",
  "cadkit-geom",
@@ -257,7 +257,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-py"
-version = "0.5.1"
+version = "0.5.2"
 dependencies = [
  "cadkit",
  "pyo3",
@@ -267,7 +267,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-scene"
-version = "0.5.1"
+version = "0.5.2"
 dependencies = [
  "cadkit-core",
  "cadkit-geom",
@@ -276,7 +276,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-wasm"
-version = "0.5.1"
+version = "0.5.2"
 dependencies = [
  "cadkit",
  "js-sys",

{pycadkit-0.5.1 → pycadkit-0.5.2}/Cargo.toml

@@ -4,7 +4,7 @@ members = ["crates/*"]
 exclude = ["fuzz"]
 
 [workspace.package]
-version = "0.5.1"
+version = "0.5.2"
 edition = "2024"
 rust-version = "1.88"
 license = "MIT OR Apache-2.0"
@@ -14,18 +14,18 @@ keywords = ["cad", "dwg", "dgn", "dxf", "citygml"]
 categories = ["parser-implementations", "graphics", "encoding", "science::geo"]
 
 [workspace.dependencies]
-cadkit-geom = { path = "crates/cadkit-geom", version = "0.5.1" }
-cadkit-scene = { path = "crates/cadkit-scene", version = "0.5.1" }
-cadkit-gpu = { path = "crates/cadkit-gpu", version = "0.5.1" }
+cadkit-geom = { path = "crates/cadkit-geom", version = "0.5.2" }
+cadkit-scene = { path = "crates/cadkit-scene", version = "0.5.2" }
+cadkit-gpu = { path = "crates/cadkit-gpu", version = "0.5.2" }
 i_overlay = "=9.0.0"
 robust = "=1.2.0"
 schemars = "1.2.2"
-cadkit-core = { path = "crates/cadkit-core", version = "0.5.1" }
-cadkit-dgn = { path = "crates/cadkit-dgn", version = "0.5.1", default-features = false }
-cadkit-dwg = { path = "crates/cadkit-dwg", version = "0.5.1" }
-cadkit-dxf = { path = "crates/cadkit-dxf", version = "0.5.1" }
-cadkit-gml = { path = "crates/cadkit-gml", version = "0.5.1" }
-cadkit = { path = "crates/cadkit", version = "0.5.1" }
+cadkit-core = { path = "crates/cadkit-core", version = "0.5.2" }
+cadkit-dgn = { path = "crates/cadkit-dgn", version = "0.5.2", default-features = false }
+cadkit-dwg = { path = "crates/cadkit-dwg", version = "0.5.2" }
+cadkit-dxf = { path = "crates/cadkit-dxf", version = "0.5.2" }
+cadkit-gml = { path = "crates/cadkit-gml", version = "0.5.2" }
+cadkit = { path = "crates/cadkit", version = "0.5.2" }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 thiserror = "2"

{pycadkit-0.5.1 → pycadkit-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycadkit
-Version: 0.5.1
+Version: 0.5.2
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research

{pycadkit-0.5.1 → pycadkit-0.5.2}/crates/cadkit/src/lib.rs

@@ -333,6 +333,20 @@ pub fn to_svg_all_layers(doc: &Document, options: &SvgOptions) -> String {
     cadkit_core::svg::render_all_layers(doc, options)
 }
 
+/// Renders a complete SVG within the output byte and work budgets in `options`.
+/// `include_hidden_layers` includes hidden and frozen layers when true.
+/// Returns [`Error::LimitExceeded`] rather than a truncated drawing. The byte
+/// cap includes all markup and bounds temporary SVG strings during generation;
+/// it does not bound the memory already owned by the parsed document.
+#[cfg(feature = "svg")]
+pub fn to_svg_bounded(
+    doc: &Document,
+    options: &SvgOptions,
+    include_hidden_layers: bool,
+) -> Result<String> {
+    cadkit_core::svg::render_bounded(doc, options, include_hidden_layers)
+}
+
 /// Writes an SVG rendering of `doc` into `writer`.
 #[cfg(feature = "svg")]
 pub fn write_svg_to(doc: &Document, options: &SvgOptions, mut writer: impl Write) -> Result<()> {

pycadkit-0.5.2/crates/cadkit-core/src/svg/bounded_tests.rs

@@ -0,0 +1,219 @@
+use super::*;
+use crate::model::{Block, Layer, Model};
+
+fn line() -> Entity {
+    Entity::new(EntityKind::Line {
+        start: Point3::xy(0.0, 0.0),
+        end: Point3::xy(10.0, 5.0),
+    })
+}
+
+fn document(entities: Vec<Entity>) -> Document {
+    Document {
+        models: vec![Model {
+            entities,
+            ..Model::default()
+        }],
+        ..Document::default()
+    }
+}
+
+fn text(value: String) -> Entity {
+    Entity::new(EntityKind::Text {
+        position: Point3::default(),
+        end_point: None,
+        height: 1.0,
+        rotation: 0.0,
+        width_factor: 1.0,
+        oblique: 0.0,
+        value,
+        style: None,
+        halign: HAlign::Left,
+        valign: VAlign::Baseline,
+        normal: Vec3::Z,
+    })
+}
+
+fn assert_output_limit(result: crate::Result<String>) {
+    assert!(matches!(
+        result,
+        Err(crate::Error::LimitExceeded {
+            limit: crate::LimitKind::Output,
+            ..
+        })
+    ));
+}
+
+#[test]
+fn exact_utf8_budget_includes_markup_and_hidden_layer_names() {
+    let mut entity = text("測定<&>🙂".into());
+    entity.layer = Some("隠れた<&>🙂".into());
+    let mut doc = document(vec![entity]);
+    doc.layers.push(Layer {
+        name: "隠れた<&>🙂".into(),
+        visible: false,
+        ..Layer::default()
+    });
+    let options = SvgOptions::default();
+    for hidden in [false, true] {
+        let expected = if hidden {
+            render_all_layers(&doc, &options)
+        } else {
+            render(&doc, &options)
+        };
+        let exact = options.clone().with_max_output_bytes(expected.len());
+        assert_eq!(
+            render_bounded(&doc, &exact, hidden).expect("exact budget"),
+            expected
+        );
+        assert_output_limit(render_bounded(
+            &doc,
+            &exact.with_max_output_bytes(expected.len() - 1),
+            hidden,
+        ));
+    }
+}
+
+#[test]
+fn a_single_path_is_stopped_before_the_next_entity() {
+    let polyline = Entity::new(EntityKind::Polyline {
+        vertices: (0..20_000)
+            .map(|i| Vertex {
+                position: Point3::xy(f64::from(i), f64::from(i % 2)),
+                ..Vertex::default()
+            })
+            .collect(),
+        closed: false,
+        normal: Vec3::Z,
+    });
+    let options = SvgOptions::default().with_max_output_bytes(1024);
+    assert_output_limit(render_bounded(&document(vec![polyline]), &options, true));
+}
+
+#[test]
+fn escaping_and_background_do_not_allocate_an_oversized_result() {
+    let options = SvgOptions::default().with_max_output_bytes(1024);
+    // Input fits but XML escaping expands it beyond the cap within one entity.
+    assert_output_limit(render_bounded(
+        &document(vec![text("&".repeat(600))]),
+        &options,
+        true,
+    ));
+    let options = options.with_background(Some("&".repeat(600)));
+    assert_output_limit(render_bounded(&Document::default(), &options, true));
+    assert_output_limit(render_bounded(
+        &Document::default(),
+        &SvgOptions::default().with_max_output_bytes(1),
+        true,
+    ));
+}
+
+#[test]
+fn many_layers_and_entities_cannot_accumulate_unbounded_output() {
+    let doc = document(
+        (0..10_000)
+            .map(|i| {
+                let mut entity = line();
+                entity.layer = Some(format!("layer-{i}-{}", "&".repeat(32)));
+                entity
+            })
+            .collect(),
+    );
+    assert_output_limit(render_bounded(
+        &doc,
+        &SvgOptions::default().with_max_output_bytes(16_384),
+        true,
+    ));
+}
+
+#[test]
+fn work_exhaustion_is_an_error_instead_of_an_empty_or_partial_success() {
+    let doc = document(vec![line(); 100]);
+    for work in [0, 10] {
+        assert!(matches!(
+            render_bounded(&doc, &SvgOptions::default().with_max_work(work), true),
+            Err(crate::Error::LimitExceeded {
+                limit: crate::LimitKind::Work,
+                ..
+            })
+        ));
+    }
+}
+
+#[test]
+fn block_array_expansion_obeys_output_and_work_limits() {
+    let insert = Entity::new(EntityKind::Insert {
+        block: "lines".into(),
+        position: Point3::default(),
+        scale: Vec3::new(1.0, 1.0, 1.0),
+        rotation: 0.0,
+        normal: Vec3::Z,
+        columns: 100,
+        rows: 100,
+        column_spacing: 20.0,
+        row_spacing: 20.0,
+    });
+    let mut doc = document(vec![insert]);
+    doc.blocks.push(Block {
+        name: "lines".into(),
+        entities: vec![line()],
+        ..Block::default()
+    });
+    assert_output_limit(render_bounded(
+        &doc,
+        &SvgOptions::default().with_max_output_bytes(4096),
+        true,
+    ));
+    assert!(matches!(
+        render_bounded(&doc, &SvgOptions::default().with_max_work(10), true),
+        Err(crate::Error::LimitExceeded {
+            limit: crate::LimitKind::Work,
+            ..
+        })
+    ));
+    let small = document(vec![line()]);
+    assert_eq!(
+        render_bounded(&small, &SvgOptions::default(), true).expect("next document"),
+        render_all_layers(&small, &SvgOptions::default())
+    );
+}
+
+#[test]
+fn hatch_definitions_are_part_of_the_exact_output_budget() {
+    let hatch = Entity::new(EntityKind::Hatch {
+        loops: vec![crate::model::HatchLoop {
+            edges: vec![HatchEdge::Polyline {
+                vertices: vec![
+                    Vertex {
+                        position: Point3::xy(0.0, 0.0),
+                        ..Vertex::default()
+                    },
+                    Vertex {
+                        position: Point3::xy(5.0, 5.0),
+                        ..Vertex::default()
+                    },
+                ],
+                closed: true,
+            }],
+            external: true,
+        }],
+        solid: false,
+        pattern: Some("ANSI37".into()),
+        pattern_scale: 1.0,
+        pattern_angle: 0.0,
+        normal: Vec3::Z,
+    });
+    let doc = document(vec![hatch]);
+    let expected = render_all_layers(&doc, &SvgOptions::default());
+    assert!(expected.contains("<defs>"));
+    let options = SvgOptions::default().with_max_output_bytes(expected.len());
+    assert_eq!(
+        render_bounded(&doc, &options, true).expect("exact hatch budget"),
+        expected
+    );
+    assert_output_limit(render_bounded(
+        &doc,
+        &options.with_max_output_bytes(expected.len() - 1),
+        true,
+    ));
+}

pycadkit-0.5.2/crates/cadkit-core/src/svg/buffer.rs

@@ -0,0 +1,143 @@
+//! Bounded SVG buffers share a failure flag, including temporary paths and escaped text.
+//! Once a write would exceed the cap, no buffer in that render grows again.
+
+use std::cell::Cell;
+use std::fmt::{self, Write};
+use std::ops::Deref;
+use std::rc::Rc;
+
+#[derive(Clone, Default)]
+pub(super) struct Budget(Option<Rc<State>>);
+
+struct State {
+    cap: usize,
+    exceeded: Cell<bool>,
+}
+
+impl Budget {
+    pub(super) fn is_unlimited(&self) -> bool {
+        self.0.is_none()
+    }
+    pub(super) fn new(cap: usize) -> Self {
+        Self(Some(Rc::new(State {
+            cap,
+            exceeded: Cell::new(false),
+        })))
+    }
+
+    pub(super) fn exceeded(&self) -> bool {
+        self.0.as_ref().is_some_and(|state| state.exceeded.get())
+    }
+
+    pub(super) fn allows(&self, bytes: usize) -> bool {
+        let Some(state) = &self.0 else { return true };
+        if bytes > state.cap {
+            state.exceeded.set(true);
+        }
+        !state.exceeded.get()
+    }
+
+    pub(super) fn reject(&self) {
+        if let Some(state) = &self.0 {
+            state.exceeded.set(true);
+        }
+    }
+
+    pub(super) fn buffer(&self) -> Buffer {
+        Buffer {
+            text: String::new(),
+            budget: self.clone(),
+        }
+    }
+
+    pub(super) fn format(&self, args: fmt::Arguments<'_>) -> Buffer {
+        let mut buffer = self.buffer();
+        // Failure is remembered by the shared budget and reported by the public renderer.
+        let _ = buffer.write_fmt(args);
+        buffer
+    }
+}
+
+pub(super) struct Buffer {
+    text: String,
+    budget: Budget,
+}
+
+impl Buffer {
+    pub(super) fn exceeded(&self) -> bool {
+        self.budget.exceeded()
+    }
+
+    pub(super) fn push_str(&mut self, value: &str) {
+        let _ = self.write_str(value);
+    }
+
+    pub(super) fn push(&mut self, value: char) {
+        let _ = self.write_char(value);
+    }
+
+    pub(super) fn into_string(self) -> String {
+        self.text
+    }
+}
+
+impl Write for Buffer {
+    fn write_str(&mut self, value: &str) -> fmt::Result {
+        let Some(bytes) = self.text.len().checked_add(value.len()) else {
+            self.budget.reject();
+            return Err(fmt::Error);
+        };
+        if !self.budget.allows(bytes) {
+            return Err(fmt::Error);
+        }
+        // Avoid geometric String growth beyond the requested output budget.
+        if let Some(state) = &self.budget.0
+            && bytes > self.text.capacity()
+        {
+            let capacity = self
+                .text
+                .capacity()
+                .max(32)
+                .saturating_mul(2)
+                .min(state.cap)
+                .max(bytes);
+            self.text.reserve_exact(capacity - self.text.len());
+        }
+        self.text.push_str(value);
+        Ok(())
+    }
+}
+
+impl Deref for Buffer {
+    type Target = str;
+
+    fn deref(&self) -> &str {
+        &self.text
+    }
+}
+
+impl fmt::Display for Buffer {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&self.text)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn rejection_happens_before_growth_and_stops_other_buffers() {
+        let budget = Budget::new(4);
+        let mut a = budget.buffer();
+        a.push_str("éé");
+        assert_eq!(&*a, "éé");
+        assert_eq!(a.text.capacity(), 4);
+        a.push('x');
+        assert!(budget.exceeded());
+        assert_eq!(&*a, "éé");
+        let b = budget.format(format_args!("{}", "must not be allocated"));
+        assert!(b.is_empty());
+        assert_eq!(b.text.capacity(), 0);
+    }
+}