A hosted change can move a subrepo's pin f2f91ceb0e9f

        self.build_change_with(heads, edits, &[], message, author)

    }

    /// Build (but do not store or sign) a change that moves the subrepo at

    /// `path` in the state with `heads` to `pin`: a hub moving a consumer's

    /// pin for Diffusion (oxygenhub#148). The path must already be a

    /// subrepo; nothing else changes.

    pub fn build_pin_change(

        &self,

        heads: &[ChangeHash],

        path: &str,

        pin: &crate::subrepo::Pin,

        message: &str,

        author: KeyId,

    ) -> Result<Change> {

        self.build_change_with(

            heads,

            &[],

            &[(path.to_string(), pin.clone())],

            message,

            author,

        )

    }

    fn build_change_with(

        &self,

        heads: &[ChangeHash],

        edits: &[FileEdit],

        pins: &[(String, crate::subrepo::Pin)],

        message: &str,

        author: KeyId,

    ) -> Result<Change> {

        if edits.is_empty() && pins.is_empty() {

            }

        }

        for (path, pin) in pins {

            let path = path.trim_matches('/');

            match base_snapshot.files.get(path) {

                Some(f) if f.kind == NodeKind::Subrepo => {}

                Some(_) => return fail(format!("{path} is not a subrepo")),

                None => return fail(format!("{path} does not exist")),

            entries.insert(

                path.to_string(),

                FsEntry::new(NodeKind::Subrepo, false, pin.encode()),

            );

            .chain(pins.iter().map(|(p, _)| p.trim_matches('/').to_string()))

#[test]

fn a_pin_change_moves_only_the_pin() {

    hermetic();

    let dir = tempfile::tempdir().unwrap();

    let root = dir.path();

    let _lib_origin = Repo::init(&root.join("lib-origin")).unwrap();

    let lib_url = root.join("lib-origin").to_string_lossy().to_string();

    let lib = Repo::clone(&lib_url, &root.join("lib"))

        .unwrap()

        .with_home(root.join("home"));

    write(&root.join("lib"), "lib.txt", b"v1\n");

    lib.commit("lib v1", &[]).unwrap();

    assert!(lib.push("origin", false).unwrap()[0].ok);

    let _app_origin = Repo::init(&root.join("app-origin")).unwrap();

    let app_dir = root.join("app");

    let app = Repo::clone(&root.join("app-origin").to_string_lossy(), &app_dir)

        .unwrap()

        .with_home(root.join("home"));

    write(&app_dir, "main.txt", b"app\n");

    let pin1 = app.submodule_add(&lib_url, "libs/lib", None).unwrap();

    let a1 = app.commit("app with lib", &[]).unwrap();

    // The library moves on.

    write(&root.join("lib"), "more.txt", b"v2\n");

    let l2 = lib.commit("lib v2", &[]).unwrap();

    let crate::subrepo::Pin::Oxy { repo, bookmark, .. } = pin1 else {

        panic!("an Oxygen pin")

    };

    let pin2 = crate::subrepo::Pin::Oxy {

        repo,

        heads: vec![l2],

        bookmark,

    };

    let author = app.store().get_change(&a1).unwrap().author;

    let change = app

        .build_pin_change(&[a1], "libs/lib", &pin2, "Move lib to v2", author)

        .unwrap();

    let mut state = app.load_state(&[a1]).unwrap();

    state.add(change).unwrap();

    let files = state.materialize().files;

    assert_eq!(files["libs/lib"].kind, NodeKind::Subrepo);

    let FileContent::Opaque { blobs } = &files["libs/lib"].content else {

        panic!("a pin is opaque")

    };

    let read = crate::subrepo::Pin::decode(&app.read_blob(&blobs[0]).unwrap()).unwrap();

    assert_eq!(read, pin2, "the new pin");

    assert!(

        matches!(&files["main.txt"].content, FileContent::Text { bytes, .. } if bytes.as_slice() == b"app\n"),

        "nothing else changes"

    );

    // Only a subrepo's pin can be moved this way.

    let e = app.build_pin_change(&[a1], "main.txt", &pin2, "x", author);

    assert!(format!("{:?}", e.unwrap_err()).contains("not a subrepo"));

    let e = app.build_pin_change(&[a1], "libs/none", &pin2, "x", author);

    assert!(format!("{:?}", e.unwrap_err()).contains("does not exist"));

}