ecformat 0.1.1

command line tool to keep files correct in respect of your EditorConfig
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

// SPDX-FileCopyrightText: Contributors to ecformat project <https://codeberg.org/BaumiCoder/ecformat>
//
// SPDX-License-Identifier: BlueOak-1.0.0

//! Module for the `end_of_line` property of EditorConfig.

use std::collections::HashMap;

use ec4rs::property::{self, EndOfLine};
use line_ending::LineEnding;
use snafu::ensure;

use crate::{errors, files};

use super::{PropertyHandler, charset};

/// Handles the `end_of_line` property for a single file.
pub struct EndOfLineHandler {
    charset: property::Charset,
    end_of_line: property::EndOfLine,
}

impl PropertyHandler for EndOfLineHandler {
    fn check(&self, file_path: &std::path::Path) -> anyhow::Result<()> {
        let content = files::read_file(file_path, &self.charset)?;
        let wrong_end_of_lines: HashMap<property::EndOfLine, usize> = self
            .get_wrong_line_endings(&content)
            .map(|(line_ending, count)| {
                (
                    // EditorConfig type for inside the errors passed to the caller of ecformat
                    Self::line_ending_as_end_of_line(&line_ending),
                    count,
                )
            })
            .collect();

        ensure!(
            wrong_end_of_lines.is_empty(),
            errors::EndOfLineSnafu {
                expected_end_of_line: self.end_of_line,
                wrong_end_of_lines,
            }
        );
        Ok(())
    }

    fn fix(&self, file_path: &std::path::Path) -> anyhow::Result<()> {
        let mut content = files::read_file(file_path, &self.charset)?;
        if self.fix_wrong_line_endings(&mut content) {
            files::overwrite_file(file_path, &self.charset, &content)?;
        }
        Ok(())
    }
}

impl EndOfLineHandler {
    /// Creates a [`EndOfLineHandler`] for the given properties,
    /// if a handler is necessary for these properties.
    pub fn build(properties: &ec4rs::Properties) -> Option<EndOfLineHandler> {
        match properties.get::<property::EndOfLine>() {
            Ok(end_of_line) => Some(EndOfLineHandler {
                charset: charset::get_charset(properties),
                end_of_line,
            }),
            Err(_) => None, // no end_of_line property set
        }
    }

    /// Returns an iterator over the wrong line endings in the given content
    /// incl. how often they occur
    fn get_wrong_line_endings(&self, content: &str) -> impl Iterator<Item = (LineEnding, usize)> {
        let expected_line_ending = Self::end_of_line_as_line_ending(&self.end_of_line);
        let scores = LineEnding::score_mixed_types(content);
        scores
            .into_iter()
            .filter(move |(line_ending, count)| *count != 0 && *line_ending != expected_line_ending)
    }

    /// Fixed wrong line endings, if necessary.
    /// Returns true if a fix was performed (i.e., content was changed).
    fn fix_wrong_line_endings(&self, content: &mut String) -> bool {
        let wrong_line_endings = self.get_wrong_line_endings(content).any(|_| true);
        if wrong_line_endings {
            *content = Self::end_of_line_as_line_ending(&self.end_of_line)
                .denormalize(&LineEnding::normalize(content));
        }
        wrong_line_endings
    }

    /// Returns the [`line_ending::LineEnding`] for the given
    /// EditorConfig property [`ec4rs::property::EndOfLine`].
    fn end_of_line_as_line_ending(end_of_line: &EndOfLine) -> LineEnding {
        match *end_of_line {
            EndOfLine::Lf => LineEnding::LF,
            EndOfLine::CrLf => LineEnding::CRLF,
            EndOfLine::Cr => LineEnding::CR,
        }
    }

    /// Returns the EditorConfig property [`ec4rs::property::EndOfLine`]
    /// for the given [`line_ending::LineEnding`].
    fn line_ending_as_end_of_line(line_ending: &LineEnding) -> EndOfLine {
        match *line_ending {
            LineEnding::LF => EndOfLine::Lf,
            LineEnding::CRLF => EndOfLine::CrLf,
            LineEnding::CR => EndOfLine::Cr,
        }
    }
}

#[cfg(test)]
mod tests;