ecformat 0.2.0

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

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

//! Tests for the indentation related property of EditorConfig,
//! i.e., `indent_style`, `indent_size` and `tab_width`
//! Files for the Integration Tests here, and some unit tests
//! are in `tests/resources/indent_style` and `tests/resources/indent_size`.

use std::{fs, io};

use ec4rs::{PropertyKey, property};
use itertools::Itertools;
use tempfile::{NamedTempFile, TempDir};

use ecformat::errors::{CheckErrorType, EditorConfigError};

mod integration_test_utils;

use integration_test_utils::test_utils;

/// Runs the `check` command to the test files for the `indent_style` property
#[test]
fn test_check_indentation_on_indent_style_files() {
    test_check_indentation::<property::IndentStyle>();
}

/// Runs the `check` command to the test files for the `indent_size` property
#[test]
fn test_check_indentation_on_indent_size_files() {
    test_check_indentation::<property::IndentSize>();
}

/// Runs the `check` command to the test files for the property type
fn test_check_indentation<P: PropertyKey>() {
    let temp_dir = copy_test_files::<P>().expect("Copy tests file into temp dir necessary");
    let error_list = integration_test_utils::run_check_command(temp_dir.path());
    // All files with errors found?
    let error_files = integration_test_utils::check_error_list_as_file_names(&error_list);
    let expected_error_files =
        integration_test_utils::get_filtered_test_file_names::<P, _>(|test_entry| {
            let (_, _, _, lines_with_wrong_indentation) =
                test_utils::indentation::get_infos_from_file_name(test_entry);
            !lines_with_wrong_indentation.is_empty()
        });
    assert_eq!(
        error_files, expected_error_files,
        "Detected files with wrong indentations are not as expected"
    );

    // Type and fields of error correct?
    for error in &error_list {
        match error {
            EditorConfigError::FileError(file_error) => match file_error.error_type() {
                CheckErrorType::IndentationError {
                    lines_with_wrong_indentation,
                } => {
                    let (_, _, _, actual_lines_with_wrong_indentation) =
                        test_utils::indentation::get_infos_from_file_name(file_error.path());
                    assert_eq!(
                        &actual_lines_with_wrong_indentation,
                        lines_with_wrong_indentation,
                        "Not the lines with wrong indentations found as expected for {}",
                        file_error.path().display()
                    );
                }
                _ => panic!(
                    "The check error is not about indentation: {}",
                    file_error.path().display()
                ),
            },
            e => panic!("The error is no file error: {e}"),
        }
    }
}

/// Runs the `fix` command to the test files for the `indent_style` property
#[test]
fn test_fix_indentation_on_indent_style_files() {
    test_fix_indentation::<property::IndentStyle>();
}

/// Runs the `fix` command to the test files for the `indent_size` property
#[test]
fn test_fix_indentation_on_indent_size_files() {
    test_fix_indentation::<property::IndentSize>();
}

/// Runs the `fix` command to the test files for the property type
fn test_fix_indentation<P: PropertyKey>() {
    let temp_dir = copy_test_files::<P>().expect("Copy tests file into temp dir necessary");
    integration_test_utils::run_fix_command(temp_dir.path());
}

/// Copy the given test file and a suitable `.editorconfig` file into a temporary directory.
fn copy_test_files<P: PropertyKey>() -> io::Result<TempDir> {
    let test_file_helper = test_utils::TestFileHelper::new::<P>();
    let editorconfig_file =
        NamedTempFile::with_suffix_in(".editorconfig", test_file_helper.get_test_dir())?;
    let editorconfig = String::from("root = true\n")
        + &test_file_helper
            .get_test_file_paths()
            .map(|test_file| {
                let (indent_style, indent_size, tab_width, _) =
                    test_utils::indentation::get_infos_from_file_name(&test_file);
                let file_name = test_file.file_name().unwrap().to_str().unwrap();
                format!(
                    "[{file_name}]
                indent_style={indent_style}
                indent_size={indent_size}
                tab_width={tab_width}"
                )
            })
            .join("\n");

    fs::write(editorconfig_file.path(), editorconfig)?;
    integration_test_utils::copy_test_files(
        test_file_helper,
        editorconfig_file
            .path()
            .file_stem()
            .unwrap()
            .to_str()
            .unwrap()
            .to_string(),
    )
}