Method record

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

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 mut status_options = StatusOptions::default();
        if !options.all() {
            for path in options.get_paths() {
                status_options = status_options.filter_path(std::path::PathBuf::from(path));
            }
        }
        let status = self
            .status_for_record(status_options, options.get_detect_raw_renames())
            .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(),
        );

        // Refuse to record files that still contain conflict markers, so an
        // unresolved merge is never baked into history. This runs over the
        // raw status (before the recordable filter) so it also catches files
        // reported as Conflicted. Overridable via
        // `RecordOptions::allow_conflict_markers`.
        if !options.get_allow_conflict_markers() {
            for entry in status.entries() {
                let is_directory = entry.details().map(|d| d == "directory").unwrap_or(false);
                if is_directory {
                    continue;
                }
                if !matches!(
                    entry.status(),
                    FileStatus::Added | FileStatus::Modified | FileStatus::Conflicted