let crlf = text.matches("\r\n").count();

let lf_only = text.matches('\n').count().saturating_sub(crlf);

let cr_only = text.matches('\r').count().saturating_sub(crlf);

if crlf > 0 && crlf >= lf_only && crlf >= cr_only {

"\r\n"

} else if cr_only > 0 && cr_only >= lf_only {

"\r"

} else {

"\n"

}

let has_crlf = memchr::memmem::find(data, b"\r\n").is_some();

let has_bare_lf = memchr::memchr_iter(b'\n', data).any(|i| i == 0 || data[i - 1] != b'\r');

has_crlf && has_bare_lf

if !has_mixed_eol(content.as_bytes()) {

return std::borrow::Cow::Borrowed(content);

}

let mode = match detect_eol(content) {

"\r\n" => EolMode::Crlf,

"\r" => EolMode::Cr,

_ => EolMode::Lf,

};

normalize_eol(content, mode)

/// Keep existing line endings.

#[default]

Keep,

/// Normalize to LF.

Lf,

/// Normalize to CRLF.

Crlf,

/// Normalize to CR (classic Mac).

Cr,

/// Leave any existing BOM (or lack of one) unchanged.

#[default]

Keep,

/// UTF-8 without BOM: strip a leading U+FEFF if present.

Utf8,

/// UTF-8 with BOM: ensure a leading U+FEFF.

Utf8Bom,

/// EditorConfig charset this process cannot apply (`utf-16le`, `utf-16be`).

Unsupported(&'static str),

pub ensure_final_newline: bool,

pub normalize_eol: EolMode,

pub trim_trailing_whitespace: bool,

pub collapse_blanks: bool,

pub charset: CharsetMode,

/// Returns `true` when no transformations are configured, meaning content

/// can be written (or moved) byte-for-byte without interpretation.

pub fn is_noop(&self) -> bool {

!self.ensure_final_newline

&& matches!(self.normalize_eol, EolMode::Keep)

&& !self.trim_trailing_whitespace

&& !self.collapse_blanks

&& matches!(self.charset, CharsetMode::Keep)

}

/// EditorConfig charset this write cannot apply, if any.

pub fn unsupported_charset(&self) -> Option<&'static str> {

match self.charset {

CharsetMode::Unsupported(name) => Some(name),

_ => None,

}

}

/// Fail closed when EditorConfig asks for a charset we cannot write.

pub fn refuse_unsupported_charset(&self) -> anyhow::Result<()> {

if let Some(name) = self.unsupported_charset() {

return Err(crate::exit::InvalidInputError {

msg: format!(

"editorconfig charset '{name}' is not supported; use utf-8 or utf-8-bom"

),

}

.into());

}

Ok(())

}

/// Apply an override, setting only the fields that are `Some`.

/// Validates all fields before mutating to avoid partial state on error.

pub fn apply_override(&mut self, ov: &WritePolicyOverride) -> anyhow::Result<()> {

// Validate first: parse normalize_eol before touching any field.

let parsed_eol = match ov.normalize_eol {

Some(ref s) => Some(parse_eol_mode(s)?),

None => None,

};

// All validation passed; now mutate.

if let Some(v) = ov.ensure_final_newline {

self.ensure_final_newline = v;

}

if let Some(eol) = parsed_eol {

self.normalize_eol = eol;

}

if let Some(v) = ov.trim_trailing_whitespace {

self.trim_trailing_whitespace = v;

}

if let Some(v) = ov.collapse_blanks {

self.collapse_blanks = v;

}

Ok(())

}

fn default() -> Self {

Self {

ensure_final_newline: false,

normalize_eol: EolMode::Keep,

trim_trailing_whitespace: false,

collapse_blanks: false,

charset: CharsetMode::Keep,

}

}

pub ensure_final_newline: Option<bool>,

pub normalize_eol: Option<String>,

pub trim_trailing_whitespace: Option<bool>,

pub collapse_blanks: Option<bool>,

pub respect_editorconfig: Option<bool>,

match mode {

"lf" => Ok(EolMode::Lf),

"crlf" => Ok(EolMode::Crlf),

"cr" => Ok(EolMode::Cr),

"keep" => Ok(EolMode::Keep),

_ => Err(anyhow::Error::new(crate::exit::InvalidInputError {

msg: format!(

"invalid normalize_eol value '{mode}': expected 'lf', 'crlf', 'cr', or 'keep'"

),

})),

}

/// Dedent only: strip the smallest non-zero indent found in range.

Auto,

/// One leading tab.

Tab,

/// N whitespace characters (dedent) or N spaces (indent). Zero is a no-op.

Spaces(usize),

anyhow::Error::new(crate::exit::InvalidInputError {

msg: format!("invalid {flag} value '{spec}': expected {accepted}"),

})

match spec {

"auto" => Ok(IndentSpec::Auto),

"tab" => Ok(IndentSpec::Tab),

n => n.parse::<usize>().map(IndentSpec::Spaces).map_err(|_| {

invalid_spec("--dedent", spec, "'auto', 'tab', or a non-negative integer")

}),

}

match spec {

"tab" => Ok(IndentSpec::Tab),

"auto" => Err(invalid_spec(

"--indent",

spec,

"'tab' or a non-negative integer ('auto' applies to --dedent only)",

)),

n => n

.parse::<usize>()

.map(IndentSpec::Spaces)

.map_err(|_| invalid_spec("--indent", spec, "'tab' or a non-negative integer")),

}

use std::borrow::Cow;

let (suffix, already_ok) = match eol {

EolMode::Cr => ("\r", content.ends_with('\r')),

EolMode::Crlf => ("\r\n", content.ends_with("\r\n")),

EolMode::Lf => ("\n", content.ends_with('\n')),

EolMode::Keep => {

// Use the file's dominant line ending so we don't introduce

// mixed endings (#1175).

let detected = detect_eol(content);

(detected, content.ends_with(detected))

}

};

if content.is_empty() || already_ok {

Cow::Borrowed(content)

} else {

let mut s = String::with_capacity(content.len() + suffix.len());

s.push_str(content);

s.push_str(suffix);

Cow::Owned(s)

}

use std::borrow::Cow;

match mode {

EolMode::Keep => Cow::Borrowed(content),

EolMode::Lf => {

let bytes = content.as_bytes();

let has_cr = memchr::memchr(b'\r', bytes).is_some();

if !has_cr {

Cow::Borrowed(content)

} else {

// Replace \r\n with \n, then any remaining bare \r with \n.

let without_crlf = content.replace("\r\n", "\n");

Cow::Owned(without_crlf.replace('\r', "\n"))

}

}

EolMode::Crlf => {

let bytes = content.as_bytes();

// Check for bare \r (not followed by \n) in addition to bare \n.

let has_bare_cr = memchr::memchr_iter(b'\r', bytes)

.any(|i| i + 1 >= bytes.len() || bytes[i + 1] != b'\n');

if has_bare_cr {

// Normalize all line endings to \n first, then convert to \r\n.

let lf_first = content.replace("\r\n", "\n").replace('\r', "\n");

Cow::Owned(lf_first.replace('\n', "\r\n"))

} else {

let has_bare_lf =

memchr::memchr_iter(b'\n', bytes).any(|i| i == 0 || bytes[i - 1] != b'\r');

if !has_bare_lf {

Cow::Borrowed(content)

} else {

// Single-pass: copy slices between \n positions, inserting

// \r before bare \n characters.

let mut result = String::with_capacity(content.len() + content.len() / 10);

let mut last = 0;

for i in memchr::memchr_iter(b'\n', bytes) {

if i == 0 || bytes[i - 1] != b'\r' {

result.push_str(&content[last..i]);

result.push_str("\r\n");

} else {

result.push_str(&content[last..=i]);

}

last = i + 1;

}

if last < content.len() {

result.push_str(&content[last..]);

}

Cow::Owned(result)

}

}

}

EolMode::Cr => {

let bytes = content.as_bytes();

let has_lf = memchr::memchr(b'\n', bytes).is_some();

if !has_lf {

Cow::Borrowed(content)

} else {

// Replace \r\n with \r, then any remaining bare \n with \r.

let without_crlf = content.replace("\r\n", "\r");

Cow::Owned(without_crlf.replace('\n', "\r"))

}

}

}

use std::borrow::Cow;

// Fast check: scan for any trailing whitespace before a newline or at EOF.

let bytes = content.as_bytes();

let has_trailing = memchr::memchr2_iter(b'\r', b'\n', bytes).any(|i| {

// Skip the \n of a \r\n pair (already handled at the \r position).

if bytes[i] == b'\n' && i > 0 && bytes[i - 1] == b'\r' {

return false;

}

let prev = i.wrapping_sub(1);

prev < bytes.len() && matches!(bytes[prev], b' ' | b'\t')

}) || (!content.is_empty()

&& !matches!(bytes[bytes.len() - 1], b'\r' | b'\n')

&& matches!(bytes[bytes.len() - 1], b' ' | b'\t'));

if !has_trailing {

return Cow::Borrowed(content);

}

let mut result = String::with_capacity(content.len());

let mut rest = content;

while !rest.is_empty() {

// Find the next line-ending sequence (\n, \r\n, or bare \r).

let rest_bytes = rest.as_bytes();

if let Some(pos) = memchr::memchr2(b'\r', b'\n', rest_bytes) {

let (line, ending, advance) = if rest_bytes[pos] == b'\n' {

(&rest[..pos], "\n", pos + 1)

} else if pos + 1 < rest_bytes.len() && rest_bytes[pos + 1] == b'\n' {

(&rest[..pos], "\r\n", pos + 2)

} else {

(&rest[..pos], "\r", pos + 1)

};

result.push_str(line.trim_end_matches([' ', '\t']));

result.push_str(ending);

rest = &rest[advance..];

} else {

// Last line without a trailing line ending.

result.push_str(rest.trim_end_matches([' ', '\t']));

break;

}

}

Cow::Owned(result)

use std::borrow::Cow;

let bytes = content.as_bytes();

// Quick scan: look for two consecutive line endings with only whitespace between.

let mut prev_blank = false;

let mut needs_collapse = false;

let mut scan = content.as_bytes();

while let Some(pos) = memchr::memchr2(b'\r', b'\n', scan) {

let end = if scan[pos] == b'\n' {

pos + 1

} else if pos + 1 < scan.len() && scan[pos + 1] == b'\n' {

pos + 2

} else {

pos + 1

};

let line = &content[content.len() - scan.len()..content.len() - scan.len() + pos];

let is_blank = line.trim().is_empty();

if is_blank && prev_blank {

needs_collapse = true;

break;

}

prev_blank = is_blank;

scan = &scan[end..];

}

// Check trailing content after the last newline: if the remainder is

// blank and the previous line was also blank, we still need to collapse.

if !needs_collapse && prev_blank && !scan.is_empty() {

let trailing = std::str::from_utf8(scan).unwrap_or("");

if trailing.trim().is_empty() {

needs_collapse = true;

}

}

if !needs_collapse {

return Cow::Borrowed(content);

}

let mut result = String::with_capacity(bytes.len());

let mut prev_blank = false;

let mut rest = content;

while !rest.is_empty() {

let rest_bytes = rest.as_bytes();

if let Some(pos) = memchr::memchr2(b'\r', b'\n', rest_bytes) {

let end = if rest_bytes[pos] == b'\n' {

pos + 1

} else if pos + 1 < rest_bytes.len() && rest_bytes[pos + 1] == b'\n' {

pos + 2

} else {

pos + 1

};

let line_content = &rest[..pos];

let line_with_ending = &rest[..end];

let is_blank = line_content.trim().is_empty();

if is_blank && prev_blank {

// Skip this consecutive blank line.

} else {

result.push_str(line_with_ending);

}

prev_blank = is_blank;

rest = &rest[end..];

} else {

// Last line without trailing newline.

let is_blank = rest.trim().is_empty();

if !(is_blank && prev_blank) {

result.push_str(rest);

}

break;

}

}

Cow::Owned(result)

const BOM: char = '\u{feff}';

match content.strip_prefix(BOM) {

Some(rest) => {

let mut out = String::with_capacity(BOM.len_utf8() + rest.len());

out.push(BOM);

out.push_str(&f(rest));

out

}

None => f(content),

}

let mut offset = 0;

for (i, c) in line.char_indices().take(n) {

if !c.is_whitespace() {

break;

}

offset = i + c.len_utf8();

}

offset

content: &str,

spec: &str,

line_range: Option<(usize, Option<usize>)>,

) -> String {

// Callers that can report an error validate with `parse_dedent_spec` first;

// an unparseable spec is a no-op here only to keep this signature

// infallible for existing library users (#2378).

let Ok(spec) = parse_dedent_spec(spec) else {

return content.to_string();

};

with_leading_bom_peeled(content, |content| {

let lines: Vec<&str> = content.split('\n').collect();

let (start, end) = match line_range {

Some((s, e)) => (s.max(1), e.unwrap_or(lines.len())),

None => (1, lines.len()),

};

let in_range = |i: usize| {

let line_num = i + 1; // 1-based

line_num >= start && line_num <= end

};

match spec {

IndentSpec::Auto => {

// Find minimum non-zero indentation in the range.

let min_indent = lines

.iter()

.enumerate()

.filter(|&(i, _)| in_range(i))

.filter(|&(_, line)| !line.trim().is_empty())

.map(|(_, line)| indent_char_count(line))

.filter(|&n| n > 0)

.min()

.unwrap_or(0);

if min_indent == 0 {

return content.to_string();

}

dedent_by_n(&lines, min_indent, &in_range)

}

IndentSpec::Tab => {

let result: Vec<String> = lines

.iter()

.enumerate()

.map(|(i, line)| {

if !in_range(i) || line.trim().is_empty() {

line.to_string()

} else if let Some(rest) = line.strip_prefix('\t') {

rest.to_string()

} else {

line.to_string()

}

})

.collect();

result.join("\n")

}

IndentSpec::Spaces(0) => content.to_string(),

IndentSpec::Spaces(n) => dedent_by_n(&lines, n, &in_range),

}

})

let result: Vec<String> = lines

.iter()

.enumerate()

.map(|(i, line)| {

if !in_range(i) || line.trim().is_empty() {

line.to_string()

} else {

line[indent_strip_offset(line, n)..].to_string()

}

})

.collect();

result.join("\n")

content: &str,

spec: &str,

line_range: Option<(usize, Option<usize>)>,

) -> String {

// See `dedent_content`: entry points validate with `parse_indent_spec`.

let Ok(spec) = parse_indent_spec(spec) else {

return content.to_string();

};

with_leading_bom_peeled(content, |content| {

let lines: Vec<&str> = content.split('\n').collect();

let (start, end) = match line_range {

Some((s, e)) => (s.max(1), e.unwrap_or(lines.len())),

None => (1, lines.len()),

};

let prefix = match spec {

IndentSpec::Tab => "\t".to_string(),

// `parse_indent_spec` rejects Auto, so this arm is unreachable via

// the public entry points; treat it as a no-op rather than panic.

IndentSpec::Auto => String::new(),

IndentSpec::Spaces(n) => " ".repeat(n),

};

if prefix.is_empty() {

return content.to_string();

}

let result: Vec<String> = lines

.iter()

.enumerate()

.map(|(i, line)| {

let line_num = i + 1;

if line_num < start || line_num > end || line.trim().is_empty() {

line.to_string()

} else {

format!("{prefix}{line}")

}

})

.collect();

result.join("\n")

})

use std::borrow::Cow;

if policy.is_noop() {

return Cow::Borrowed(content);

}

let mut s = if policy.trim_trailing_whitespace {

trim_trailing_whitespace(content)

} else {

Cow::Borrowed(content)

};

if !matches!(policy.normalize_eol, EolMode::Keep)

&& let Cow::Owned(new) = normalize_eol(&s, policy.normalize_eol)

{

s = Cow::Owned(new);

}

if policy.collapse_blanks

&& let Cow::Owned(new) = collapse_blanks(&s)

{

s = Cow::Owned(new);

}

// Charset before final newline so an empty file with utf-8-bom

// becomes "\u{feff}" then gets the required trailing EOL in one pass.

if let Cow::Owned(new) = apply_charset(&s, policy.charset) {

s = Cow::Owned(new);

}

if policy.ensure_final_newline

&& let Cow::Owned(new) = ensure_final_newline(&s, policy.normalize_eol)

{

s = Cow::Owned(new);

}

s

const BOM: char = '\u{feff}';

match mode {

CharsetMode::Keep | CharsetMode::Unsupported(_) => std::borrow::Cow::Borrowed(content),

CharsetMode::Utf8 => {

if let Some(rest) = content.strip_prefix(BOM) {

std::borrow::Cow::Owned(rest.to_string())

} else {

std::borrow::Cow::Borrowed(content)

}

}

CharsetMode::Utf8Bom => {

if content.starts_with(BOM) {

std::borrow::Cow::Borrowed(content)

} else {

let mut out = String::with_capacity(content.len() + BOM.len_utf8());

out.push(BOM);

out.push_str(content);

std::borrow::Cow::Owned(out)

}

}

}

global: &crate::cli::global::GlobalFlags,

#[allow(unused_variables)] file_path: Option<&std::path::Path>,

) -> WritePolicy {

let efn = global.ensure_final_newline;

let eol = global.normalize_eol;

let ttw = global.trim_trailing_whitespace;

let respect_ec = if cfg!(feature = "cli") {

global.respect_editorconfig

} else {

false

};

let (efn, eol, ttw, charset) = if respect_ec {

#[cfg(feature = "cli")]

if let Some(p) = file_path {

#[allow(unused_variables)]

if let Ok(props) = ec4rs::properties_of(p) {

let mut new_efn = efn;

let mut new_eol = eol;

let mut new_ttw = ttw;

// insert_final_newline

if !global.ensure_final_newline

&& let Ok(ec4rs::property::FinalNewline::Value(true)) =

props.get::<ec4rs::property::FinalNewline>()

{

new_efn = true;

}

// end_of_line

if global.normalize_eol.is_none()

&& let Ok(val) = props.get::<ec4rs::property::EndOfLine>()

{

new_eol = Some(match val {

ec4rs::property::EndOfLine::Lf => EolMode::Lf,

ec4rs::property::EndOfLine::CrLf => EolMode::Crlf,

ec4rs::property::EndOfLine::Cr => EolMode::Cr,

});

}

// trim_trailing_whitespace

if !global.trim_trailing_whitespace

&& let Ok(ec4rs::property::TrimTrailingWs::Value(true)) =

props.get::<ec4rs::property::TrimTrailingWs>()

{

new_ttw = true;

}

let charset = charset_from_editorconfig_props(&props);

(new_efn, new_eol, new_ttw, charset)

} else {

(efn, eol, ttw, CharsetMode::Keep)

}

} else {

(efn, eol, ttw, CharsetMode::Keep)

}

#[cfg(not(feature = "cli"))]

{

(efn, eol, ttw, CharsetMode::Keep)

}

} else {

(efn, eol, ttw, CharsetMode::Keep)

};

WritePolicy {

ensure_final_newline: efn,

normalize_eol: eol.unwrap_or(EolMode::Keep),

trim_trailing_whitespace: ttw,

collapse_blanks: global.collapse_blanks,

charset,

}

match props.get::<ec4rs::property::Charset>() {

Ok(ec4rs::property::Charset::Utf8) | Ok(ec4rs::property::Charset::Latin1) => {

CharsetMode::Utf8

}

Ok(ec4rs::property::Charset::Utf8Bom) => CharsetMode::Utf8Bom,

Ok(ec4rs::property::Charset::Utf16Le) => CharsetMode::Unsupported("utf-16le"),

Ok(ec4rs::property::Charset::Utf16Be) => CharsetMode::Unsupported("utf-16be"),

Err(_) => CharsetMode::Keep,

}

path: &Path,

content: &str,

policy: &WritePolicy,

) -> anyhow::Result<()> {

policy.refuse_unsupported_charset()?;

let final_content = apply_policy(content, policy);

let dest = persist_dest(path);

let parent = dest

.parent()

.context("cannot determine parent directory of target path")?;

let tmp = NamedTempFile::new_in(parent)

.with_context(|| format!("failed to create tempfile in {}", parent.display()))?;

std::fs::write(tmp.path(), final_content.as_bytes())

.with_context(|| format!("failed to write to tempfile {}", tmp.path().display()))?;

// NamedTempFile creates files with 0o600; apply standard 0o644 so

// new files are group/world-readable as users expect (#1161).

#[cfg(unix)]

{

use std::os::unix::fs::PermissionsExt;

let perms = std::fs::Permissions::from_mode(0o644);

std::fs::set_permissions(tmp.path(), perms)

.with_context(|| format!("failed to set permissions on {}", tmp.path().display()))?;

}

tmp.persist_noclobber(&dest).map_err(|e| {

if e.error.kind() == std::io::ErrorKind::AlreadyExists {

anyhow::Error::new(crate::exit::AlreadyExistsError {

msg: format!("file already exists: {}", path.display()),

})

} else {

anyhow::Error::from(e.error)