Method run

atomic-cli/src/commands/conflicts.rs:45–107

(&self)

impl Command for Conflicts {
    fn run(&self) -> CliResult<()> {
        let repo_root = find_repository_root()?;
        let repo =
            Repository::open_readonly(&repo_root).map_err(|e| CliError::InvalidRepository {
                reason: e.to_string(),
            })?;

        let conflicts = repo
            .list_conflicts()
            .map_err(|e| CliError::Internal(e.into()))?;

        if self.short {
            for (path, records) in &conflicts {
                for c in records {
                    let line = c.line.map(|l| l.to_string()).unwrap_or_else(|| "-".into());
                    println!("{}:{}:{}", path, line, c.kind);
                }
            }
            return Ok(());
        }

        if conflicts.is_empty() {
            print_success("No conflicts.");
            return Ok(());
        }

        let file_word = if conflicts.len() == 1 {
            "file"
        } else {
            "files"
        };
        println!(
            "{}",
            warning(&format!("{} conflicted {}:", conflicts.len(), file_word))
        );
        print_blank();

        for (path, records) in &conflicts {
            println!("\t{}", style_path(path));
            for c in records {
                let where_ = match c.line {
                    Some(l) => format!("line {}", l),
                    None => "unknown line".to_string(),
                };
                if c.sides.is_empty() {
                    println!("\t    {} conflict at {}", c.kind, where_);
                } else {
                    let sides = c
                        .sides
                        .iter()
                        .map(|h| h.chars().take(12).collect::<String>())
                        .collect::<Vec<_>>()
                        .join(", ");
                    println!("\t    {} conflict at {} between {}", c.kind, where_, sides);
                }
            }
        }