blockworx_editor/edit/

assets.rs

//! The artwork family: the emitters that place a picked image file, and the
//! payload op that carries its bytes into the log beside the reference.
//!
//! An asset payload is content-addressed and create-only, so the only
//! question an emitter has to answer is whether the document already holds
//! the hash — if it does, the bytes are already there and identical, and the
//! reference alone is the whole edit.

use blockworx_doc::{
    block_model::{Asset, BlockUpdate, Icon, Image},
    commit::CommitBuilder,
    document::Document,
    id::{BlockId, ImageId},
    opcode::{Crud, OpCodes},
};
use blockworx_geom::{Pos2, Rect, Vec2, vec2};

use crate::grid::{GRID_SIZE, px_rect, screen_rect};

/// A click-placed image spans this many cells on its longer side.
const DEFAULT_IMAGE_CELLS: f32 = 8.0;

/// A fresh icon's square side, as a fraction of its block's shorter side.
const ICON_SIDE: f32 = 0.6;

/// How the picked image was sized. A drag
/// gives its own box; a click has none, so the box comes from the image's
/// intrinsic size — the painter's measurement, which is why it arrives as
/// a parameter rather than being read here.
#[derive(Clone, Copy, Debug)]
pub enum Placement {
    Box(Rect),
    Centered { center: Pos2, intrinsic: Vec2 },
}

impl Placement {
    fn rect(self) -> Rect {
        match self {
            Placement::Box(rect) => rect,
            Placement::Centered { center, intrinsic } => {
                let longest = intrinsic.x.max(intrinsic.y).max(1.0);
                let scale = GRID_SIZE * DEFAULT_IMAGE_CELLS / longest;
                Rect::from_center_size(center, intrinsic * scale)
            }
        }
    }
}

/// The payload rider: the create-only asset op, pushed only where the
/// document does not already hold the hash. Content addressing makes the
/// non-edit filter exact — the same hash *is* the same bytes, so a second
/// copy could only ever say what the first already said.
pub(crate) fn push_payload(doc: &Document, asset: &Asset, builder: &mut CommitBuilder) {
    let hash = asset.hash();
    if doc.asset(&hash).is_none() {
        builder.push(OpCodes::Asset(hash, asset.clone()));
    }
}

/// One image the gesture placed: where it goes, and in whose scope.
#[derive(Clone, Copy, Debug)]
pub struct NewImage {
    pub id: ImageId,
    pub owner: crate::path::Scope,
    pub placement: Placement,
}

/// Inventory row "New Image": place a picked file as free-floating
/// artwork. Its box is the one float geometry the document stores —
/// unsnapped, so the image keeps the aspect the drag or the file gave it.
pub fn image(doc: &Document, new: NewImage, asset: &Asset, builder: &mut CommitBuilder) {
    push_payload(doc, asset, builder);
    builder.push(OpCodes::Image(
        new.id,
        Crud::Create(Image {
            owner: new.owner.wire_id(),
            asset: asset.hash(),
            rect: screen_rect(new.placement.rect()),
        }),
    ));
}

/// Inventory row "Set Block Icon": attach — or replace — a block's
/// foreground artwork. The icon is one atomic value, so the picture and
/// the box it sits in are written whole; the default box is a square
/// `ICON_SIDE` of the block's shorter side, centered.
pub fn set_icon(doc: &Document, block: BlockId, asset: &Asset, builder: &mut CommitBuilder) {
    let Some(live) = doc.block(&block) else {
        return;
    };
    let icon = Icon {
        asset: asset.hash(),
        rect: screen_rect(default_icon_box(px_rect(live.rect))),
    };
    if icon == live.icon {
        return;
    }
    push_payload(doc, asset, builder);
    builder.push(OpCodes::Block(block, Crud::Update(BlockUpdate::Icon(icon))));
}

/// Inventory row "Delete Icon": the block survives and its icon value goes
/// back to the model's zero (null hash, empty box). An icon has no id of
/// its own, so there is no lifecycle op to write here.
pub fn delete_icon(doc: &Document, block: BlockId, builder: &mut CommitBuilder) {
    let Some(live) = doc.block(&block) else {
        return;
    };
    if live.icon == Icon::default() {
        return;
    }
    builder.push(OpCodes::Block(
        block,
        Crud::Update(BlockUpdate::Icon(Icon::default())),
    ));
}

fn default_icon_box(block: Rect) -> Rect {
    let side = block.width().min(block.height()) * ICON_SIDE;
    Rect::from_center_size(block.center(), vec2(side, side))
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::edit::harness::{fold, seals_to_nothing, wired};
    use crate::grid::artwork_rect;
    use crate::path::Scope;
    use blockworx_doc::{
        block_model::{Block, Image},
        fixtures::{block_id, image_id},
        geometry::{GridPoint, GridRect, GridSize},
    };
    use blockworx_geom::pos2;

    fn svg(source: &str) -> Asset {
        Asset::Svg(source.as_bytes().into())
    }

    fn block_of(doc: &Document, id: u32) -> &Block {
        doc.block(&block_id(id)).expect("the scene's block exists")
    }

    fn image_of(doc: &Document, id: u32) -> &Image {
        doc.image(&image_id(id)).expect("the placed image exists")
    }

    fn icon_of(doc: &Document, id: u32) -> Icon {
        block_of(doc, id).icon.clone()
    }

    fn bytes_held(doc: &Document, asset: &Asset) -> Option<Vec<u8>> {
        doc.asset(&asset.hash()).map(|held| held.bytes().to_vec())
    }

    /// A block 10×6 cells: wider than tall, so the default icon box has a
    /// shorter side to pick.
    fn sized() -> Document {
        let doc = wired();
        let mut builder = CommitBuilder::new("Sized the block");
        builder.push(OpCodes::Block(
            block_id(1),
            Crud::Update(BlockUpdate::Rect(GridRect {
                top_left: GridPoint { x: 0, y: 0 },
                size: GridSize { w: 10, h: 6 },
            })),
        ));
        let doc = fold(builder, &doc);
        let rect = px_rect(block_of(&doc, 1).rect);
        assert!(
            rect.height() < rect.width(),
            "precondition: the height is the shorter side, so the 60% rule has a choice to make"
        );
        doc
    }

    /// Artwork geometry is float and a 60% scale is not exact on the grid,
    /// so boxes derived from one compare within a hundredth of a pixel.
    fn assert_close(actual: Rect, expected: Rect) {
        let drift = (actual.min - expected.min)
            .abs()
            .max_elem()
            .max((actual.max - expected.max).abs().max_elem());
        assert!(
            drift < 0.01,
            "{actual:?} is not within a hundredth of a pixel of {expected:?}",
        );
    }

    /// The round trip the whole sub-step exists for: the placement and its
    /// bytes travel in one commit, and the bytes come back out of the
    /// folded document under the hash the image references.
    #[test]
    fn image_places_unsnapped_artwork_and_carries_its_payload() {
        let doc = sized();
        let asset = svg("<svg>one</svg>");
        let box_drawn = Rect::from_min_max(pos2(12.5, 30.0), pos2(112.5, 80.0));

        let mut builder = CommitBuilder::new("Placed an image");
        image(
            &doc,
            NewImage {
                id: image_id(20),
                owner: Scope::Block(block_id(1)),
                placement: Placement::Box(box_drawn),
            },
            &asset,
            &mut builder,
        );
        let doc = fold(builder, &doc);

        let placed = image_of(&doc, 20);
        assert_eq!(placed.owner, block_id(1));
        assert_eq!(placed.asset, asset.hash());
        assert_eq!(
            artwork_rect(placed.rect),
            box_drawn,
            "the box is stored as drawn — artwork is the one unsnapped geometry"
        );
        assert_eq!(
            bytes_held(&doc, &asset).as_deref(),
            Some(b"<svg>one</svg>".as_slice()),
            "the payload rode the same commit and resolves by hash"
        );
    }

    /// A click has no box, so the image's own proportions give it one:
    /// eight cells on the longer side, centered on the click.
    #[test]
    fn a_clicked_image_takes_its_intrinsic_aspect_at_eight_cells() {
        let doc = sized();
        let asset = svg("<svg>wide</svg>");
        let intrinsic = vec2(40.0, 20.0);
        assert!(
            intrinsic.x > intrinsic.y,
            "precondition: the sides differ, or the aspect is not tested"
        );

        let mut builder = CommitBuilder::new("Placed an image");
        image(
            &doc,
            NewImage {
                id: image_id(20),
                owner: Scope::Block(block_id(1)),
                placement: Placement::Centered {
                    center: pos2(10.0 * GRID_SIZE, 5.0 * GRID_SIZE),
                    intrinsic,
                },
            },
            &asset,
            &mut builder,
        );
        let doc = fold(builder, &doc);

        let placed = artwork_rect(image_of(&doc, 20).rect);
        assert_close(
            placed,
            Rect::from_center_size(
                pos2(10.0 * GRID_SIZE, 5.0 * GRID_SIZE),
                vec2(8.0 * GRID_SIZE, 4.0 * GRID_SIZE),
            ),
        );
    }

    /// The dedupe: the second placement of one file is a reference and
    /// nothing else, because the hash the document already holds can only
    /// name the bytes it already holds.
    #[test]
    fn a_second_placement_of_held_bytes_carries_no_payload() {
        let doc = sized();
        let asset = svg("<svg>one</svg>");
        let place = |doc: &Document, id, builder: &mut CommitBuilder| {
            image(
                doc,
                NewImage {
                    id: image_id(id),
                    owner: Scope::Block(block_id(1)),
                    placement: Placement::Box(Rect::from_min_max(
                        pos2(12.5, 30.0),
                        pos2(112.5, 80.0),
                    )),
                },
                &asset,
                builder,
            );
        };

        let mut builder = CommitBuilder::new("Placed an image");
        place(&doc, 20, &mut builder);
        assert_eq!(
            builder
                .seal()
                .expect("the placement produced ops")
                .ops()
                .len(),
            2,
            "precondition: the first placement carries the payload as well as the reference"
        );

        let mut builder = CommitBuilder::new("Placed an image");
        place(&doc, 20, &mut builder);
        let doc = fold(builder, &doc);

        let mut builder = CommitBuilder::new("Placed it again");
        place(&doc, 21, &mut builder);
        let ops = builder.seal().expect("the placement produced ops");
        assert_eq!(ops.ops().len(), 1, "no second copy of held bytes");
        assert!(matches!(ops.ops().first(), Some(OpCodes::Image(..))));

        let doc = doc.try_apply(&ops).expect("the second placement folds");
        assert_eq!(
            image_of(&doc, 21).asset,
            image_of(&doc, 20).asset,
            "both placements resolve through the one payload",
        );
        assert!(bytes_held(&doc, &asset).is_some());
    }

    #[test]
    fn set_icon_centers_a_square_box_on_its_block() {
        let doc = sized();
        let asset = svg("<svg>icon</svg>");

        let mut builder = CommitBuilder::new("Gave the block an icon");
        set_icon(&doc, block_id(1), &asset, &mut builder);
        let doc = fold(builder, &doc);

        let block = px_rect(block_of(&doc, 1).rect);
        let icon = icon_of(&doc, 1);
        assert_eq!(icon.asset, asset.hash());
        let side = block.height() * 0.6;
        assert_close(
            artwork_rect(icon.rect),
            Rect::from_center_size(block.center(), vec2(side, side)),
        );
        assert_eq!(
            bytes_held(&doc, &asset).as_deref(),
            Some(b"<svg>icon</svg>".as_slice()),
        );
    }

    /// Replacing is the same write: one atomic `Icon` value, so the old
    /// picture cannot survive under the new box. The displaced bytes stay
    /// in the table — payloads are create-only, and nothing here knows
    /// whether someone else still points at them.
    #[test]
    fn set_icon_replaces_an_existing_icon_in_place() {
        let doc = sized();
        let first = svg("<svg>first</svg>");
        let second = svg("<svg>second</svg>");

        let mut builder = CommitBuilder::new("Gave the block an icon");
        set_icon(&doc, block_id(1), &first, &mut builder);
        let doc = fold(builder, &doc);
        assert_eq!(
            icon_of(&doc, 1).asset,
            first.hash(),
            "precondition: there is an icon to replace"
        );

        let mut builder = CommitBuilder::new("Replaced the icon");
        set_icon(&doc, block_id(1), &second, &mut builder);
        let doc = fold(builder, &doc);

        assert_eq!(icon_of(&doc, 1).asset, second.hash());
        assert!(
            doc.block(&block_id(1)).is_some(),
            "the block itself is untouched by the swap"
        );
        assert!(
            bytes_held(&doc, &first).is_some(),
            "the displaced payload stays: create-only, reclaimed by compaction",
        );
    }

    #[test]
    fn re_setting_the_same_icon_is_a_non_edit() {
        let doc = sized();
        let asset = svg("<svg>icon</svg>");

        let mut builder = CommitBuilder::new("Gave the block an icon");
        set_icon(&doc, block_id(1), &asset, &mut builder);
        let doc = fold(builder, &doc);
        assert_ne!(
            icon_of(&doc, 1),
            Icon::default(),
            "precondition: the block carries the icon the gesture repeats"
        );

        let mut builder = CommitBuilder::new("Picked the same file");
        set_icon(&doc, block_id(1), &asset, &mut builder);
        seals_to_nothing(builder);
    }

    #[test]
    fn delete_icon_writes_the_zero_value_and_keeps_the_block() {
        let doc = sized();
        let asset = svg("<svg>icon</svg>");
        let mut builder = CommitBuilder::new("Gave the block an icon");
        set_icon(&doc, block_id(1), &asset, &mut builder);
        let doc = fold(builder, &doc);
        assert_ne!(
            icon_of(&doc, 1),
            Icon::default(),
            "precondition: there is an icon to delete"
        );

        let mut builder = CommitBuilder::new("Removed the icon");
        delete_icon(&doc, block_id(1), &mut builder);
        let doc = fold(builder, &doc);

        assert_eq!(icon_of(&doc, 1), Icon::default());
        assert!(
            doc.block(&block_id(1)).is_some(),
            "the icon is a value on the block, not an entity of its own",
        );
        assert!(
            bytes_held(&doc, &asset).is_some(),
            "the unreferenced payload stays held",
        );
    }

    #[test]
    fn deleting_an_absent_icon_is_a_non_edit() {
        let doc = sized();
        assert_eq!(
            icon_of(&doc, 1),
            Icon::default(),
            "precondition: the block carries no icon"
        );

        let mut builder = CommitBuilder::new("Removed the icon");
        delete_icon(&doc, block_id(1), &mut builder);
        seals_to_nothing(builder);
    }

    /// E4: a target the document does not hold takes nothing — including
    /// the payload, which would otherwise land with nothing referencing it.
    #[test]
    fn an_absent_block_takes_neither_icon_nor_payload() {
        let doc = sized();
        let asset = svg("<svg>icon</svg>");
        let stranger = block_id(99);
        assert!(
            doc.block(&stranger).is_none(),
            "precondition: the target is absent"
        );

        let mut builder = CommitBuilder::new("Gave a stranger an icon");
        set_icon(&doc, stranger, &asset, &mut builder);
        delete_icon(&doc, stranger, &mut builder);
        seals_to_nothing(builder);
    }
}