Method record

atomic-repository/src/repository/record.rs:45–834

This is the main entry point for creating a change from working copy modifications. It detects changes, creates hunks, globalizes positions, and assembles a complete change. # Arguments `header` - The change header (message, author, etc.) `options` - Options controlling recording behavior # Returns A `RecordOutcome` containing the recorded change, hash, and statistics. # Errors Returns an er

(
        &self,
        header: ChangeHeader,
        options: RecordOptions,
    )

    /// println!("Created change: {}", result.hash().to_base32());
    /// ```
    pub fn record(
        &self,
        header: ChangeHeader,
        options: RecordOptions,
    ) -> Result<RecordOutcome, RecordError> {
        let trace_record = std::env::var_os("ATOMIC_TRACE_RECORD").is_some();
        use atomic_core::output::Memory;
        use atomic_core::record::workflow::{
            assemble_change, record_added_file, record_deleted_file, record_modified_file,
            DetectedFile, RecordedFile,
        };

        // Build the final header (may get message from options)
        let final_header = build_header(header, &options);

        // Get repository status to find modified files
        let status_t0 = std::time::Instant::now();
        let status = self
            .status(StatusOptions::default())
            .map_err(RecordError::Repository)?;
        if trace_record {
            eprintln!(
                "[record] status: {:.1}ms ({} entries)",
                status_t0.elapsed().as_secs_f64() * 1000.0,
                status.entries().len(),
            );
        }

        log::debug!(
            "record: status returned {} entries (modified={}, added={}, deleted={}, clean={}, untracked={})",
            status.entries().len(),
            status.modified_count(),
            status.added_count(),
            status.deleted_count(),
            status.entries().iter().filter(|e| e.status() == FileStatus::Clean).count(),
            status.untracked_count(),
        );

        // Filter to recordable files
        let files_to_record = filter_files(status.entries(), &options);

        log::debug!(
            "record: filter_files returned {} recordable files",
            files_to_record.len(),
        );
        for f in &files_to_record {
            log::debug!("record:   {:?} {}", f.status(), f.path().display(),);
        }

        if files_to_record.is_empty() {
            return Err(RecordError::NothingToRecord);
        }

        // Statistics tracking
        let mut stats = RecordStats::new();
        let mut recorded_files: Vec<RecordedFile> = Vec::new();
        let mut recorded_paths: Vec<String> = Vec::new();
        let mut deleted_paths: Vec<String> = Vec::new();