Method split_view

atomic-repository/src/repository/split.rs:263–477

Split a set of changes out of a view into a new Draft view. This is a pure metadata operation guarded by a reverse-dependency check: a change cannot leave the source while another change that stays behind still depends on it, unless `cascade` moves the dependents too. See [`SplitOptions`] for the options and [`SplitOutcome`] for the result. # Errors - [`RepositoryError::ViewAlreadyExists`] if `

(&mut self, options: SplitOptions)

    /// - [`RepositoryError::ViewSplitHasDependents`] if changes remaining in the
    ///   source depend on the split-out set and `cascade` is not set.
    pub fn split_view(&mut self, options: SplitOptions) -> Result<SplitOutcome, RepositoryError> {
        let db = |e: PristineError| RepositoryError::Database(e.to_string());

        let from_view_name = options
            .from_view
            .clone()
            .unwrap_or_else(|| self.current_view.clone());

        if options.changes.is_empty() {
            return Err(RepositoryError::InvalidOperation {
                message: "no changes specified to split".to_string(),
            });
        }

        // ── Dry run: analyze against a read transaction, mutate nothing. ──
        if options.dry_run {
            let txn = self.pristine.read_txn().map_err(db)?;
            let source = txn.get_view(&from_view_name).map_err(db)?.ok_or_else(|| {
                RepositoryError::ViewNotFound {
                    name: from_view_name.clone(),
                }
            })?;

            if txn.get_view(&options.target_view).map_err(db)?.is_some() {
                return Err(RepositoryError::ViewAlreadyExists {
                    name: options.target_view.clone(),
                });
            }

            let analysis = analyze_split(&txn, &source, &options.changes)?;
            let blocked = !analysis.dependents.is_empty() && !options.cascade;
            let moved = if blocked {
                Vec::new()
            } else {
                analysis.closure.clone()
            };
            let target_change_count = moved.len() as u64;
            let source_change_count = source.change_count.saturating_sub(moved.len() as u64);

            return Ok(SplitOutcome {
                target_view: options.target_view,
                from_view: from_view_name,
                was_dry_run: true,
                blocked,
                requested: analysis.requested,
                dependents: analysis.dependents,
                moved,
                source_change_count,
                target_change_count,
                working_copy_updated: false,
                files_written: 0,
                files_removed: 0,
            });
        }

        // ── Real split: analysis + mutation in one write transaction. ──
        let mut txn = self.pristine.write_txn().map_err(db)?;