fix: remove the --output flag

Author: Dustin-Jiang

doc/fd.1

@@ -514,22 +514,6 @@ due to OS restrictions on the maximum length of command lines.
 .BI "\-\-json "
 Specify JSONL (as known as NDJSON) format to use for the output. 
 .TP
-.BI "\-\-output "
-Specify a structured format to use for the output. The value can be plain (default), json, jsonl, or
-yaml.
-
-Currently, the default is "plain", and if the option is used without an argument "plain"
-is used. The available options are:
-.RS
-.IP plain
-Output the results as plain text (default).
-.IP json
-Output the results as a JSON array.
-.IP jsonl
-Output the results as JSON Lines (as known as NDJSON).
-.IP yaml
-Output the results as YAML.
-.RE
 .SH PATTERN SYNTAX
 The regular expression syntax used by fd is documented here:
 

src/cli.rs

@@ -652,24 +652,11 @@ pub struct Opts {
     #[arg(
         long,
         value_name = "json",
-        conflicts_with("output"),
         help = "Print results in JSONL format so you can pipe it to tools.",
         long_help
     )]
     pub json: bool,
 
-    /// Print results in a certain format so you can pipe it to tools.
-    #[arg(
-        long,
-        value_name = "output",
-        value_enum,
-        default_value_t = OutputFormat::Plain,
-        conflicts_with("format"),
-        conflicts_with("list_details"),
-        help = "Print results in a certain format so you can pipe it to tools."
-    )]
-    pub output: OutputFormat,
-
     /// By default, relative paths are prefixed with './' when -x/--exec,
     /// -X/--exec-batch, or -0/--print0 are given, to reduce the risk of a
     /// path starting with '-' being treated as a command line option. Use
@@ -851,14 +838,9 @@ pub enum HyperlinkWhen {
 pub enum OutputFormat {
     /// Plain text output (default)
     Plain,
-    /// JSON output
-    Json,
     /// JSONL (JSON Lines, as known as Newline Delimited JSON) output
     #[value(alias = "ndjson")]
     Jsonl,
-    /// YAML output
-    #[value(alias = "yml")]
-    Yaml,
 }
 
 // there isn't a derive api for getting grouped values yet,

src/config.rs

@@ -3,7 +3,6 @@ use std::{path::PathBuf, sync::Arc, time::Duration};
 use lscolors::LsColors;
 use regex::bytes::RegexSet;
 
-use crate::cli::OutputFormat;
 use crate::exec::CommandSet;
 use crate::filetypes::FileTypes;
 #[cfg(unix)]
@@ -134,9 +133,6 @@ pub struct Config {
 
     /// Whether to print results in JSONL format
     pub jsonl: bool,
-
-    /// The output format to use
-    pub output: OutputFormat,
 }
 
 impl Config {

src/main.rs

@@ -326,7 +326,6 @@ fn construct_config(mut opts: Opts, pattern_regexps: &[String]) -> Result<Config
         actual_path_separator,
         max_results: opts.max_results(),
         strip_cwd_prefix: opts.strip_cwd_prefix(|| !(opts.null_separator || has_command)),
-        output: opts.output,
         jsonl: opts.json,
     })
 }

src/output.rs

@@ -9,7 +9,6 @@ use lscolors::{Indicator, LsColors, Style};
 use crate::cli::OutputFormat;
 use crate::config::Config;
 use crate::dir_entry::DirEntry;
-use crate::exit_codes::ExitCode;
 use crate::fmt::FormatTemplate;
 use crate::hyperlink::PathUrl;
 
@@ -45,42 +44,11 @@ struct FileDetail<'a> {
 pub struct Printer<'a, W> {
     config: &'a Config,
     pub stdout: W,
-    started: bool,
 }
 
 impl<'a, W: Write> Printer<'a, W> {
     pub fn new(config: &'a Config, stdout: W) -> Self {
-        Self {
-            config,
-            stdout,
-            started: false,
-        }
-    }
-
-    /// Begin JSON array output if in JSON format.
-    /// Returns an error if writing to output fails.
-    pub fn begin(&mut self) -> Result<(), ExitCode> {
-        if self.config.output == OutputFormat::Json
-            && let Err(e) = writeln!(self.stdout, "[")
-            && e.kind() != ::std::io::ErrorKind::BrokenPipe
-        {
-            crate::error::print_error(format!("Could not write to output: {e}"));
-            return Err(ExitCode::GeneralError);
-        }
-        Ok(())
-    }
-
-    /// End JSON array output if in JSON format.
-    /// Returns an error if writing to output fails.
-    pub fn end(&mut self) -> Result<(), ExitCode> {
-        if self.config.output == OutputFormat::Json
-            && let Err(e) = writeln!(self.stdout, "\n]")
-            && e.kind() != ::std::io::ErrorKind::BrokenPipe
-        {
-            crate::error::print_error(format!("Could not write to output: {e}"));
-            return Err(ExitCode::GeneralError);
-        }
-        Ok(())
+        Self { config, stdout }
     }
 
     // TODO: this function is performance critical and can probably be optimized
@@ -94,37 +62,19 @@ impl<'a, W: Write> Printer<'a, W> {
         }
         match (
             &self.config.format,
-            &self.config.output,
             &self.config.jsonl,
             &self.config.ls_colors,
         ) {
-            (Some(template), _, _, _) => self.print_entry_format(entry, template)?,
-            (None, _, true, _) => self.print_entry_detail(OutputFormat::Jsonl, entry)?,
-            (None, OutputFormat::Json, false, _) => {
-                self.print_entry_detail(OutputFormat::Json, entry)?
-            }
-            (None, OutputFormat::Yaml, false, _) => {
-                self.print_entry_detail(OutputFormat::Yaml, entry)?
-            }
-            (None, OutputFormat::Jsonl, false, _) => {
-                self.print_entry_detail(OutputFormat::Jsonl, entry)?
-            }
-            (None, OutputFormat::Plain, false, Some(ls_colors)) => {
-                self.print_entry_colorized(entry, ls_colors)?
-            }
-            (None, OutputFormat::Plain, false, None) => self.print_entry_uncolorized(entry)?,
+            (Some(template), _, _) => self.print_entry_format(entry, template)?,
+            (None, true, _) => self.print_entry_detail(OutputFormat::Jsonl, entry)?,
+            (None, false, Some(ls_colors)) => self.print_entry_colorized(entry, ls_colors)?,
+            (None, false, None) => self.print_entry_uncolorized(entry)?,
         };
 
         if has_hyperlink {
             write!(self.stdout, "\x1B]8;;\x1B\\")?;
         }
 
-        self.started = true;
-
-        if matches!(self.config.output, OutputFormat::Json) {
-            return Ok(());
-        }
-
         if self.config.null_separator {
             write!(self.stdout, "\0")
         } else {
@@ -234,54 +184,7 @@ impl<'a, W: Write> Printer<'a, W> {
         }
     }
 
-    fn print_entry_yaml_obj(&mut self, detail: &FileDetail) -> io::Result<()> {
-        // Manually construct a simple YAML representation
-        // to avoid adding a dependency on serde_yaml (deprecated).
-        //
-        // Write YAML fragments directly to stdout (should be buffered)
-        write!(self.stdout, "- ")?;
-
-        match &detail.path {
-            PathEncoding::Utf8(path) => {
-                writeln!(self.stdout, "path: \"{}\"", path)?;
-            }
-            PathEncoding::Bytes(bytes) => {
-                writeln!(
-                    self.stdout,
-                    "path_base64: \"{}\"",
-                    BASE64_STANDARD.encode(bytes)
-                )?;
-            }
-        }
-
-        writeln!(self.stdout, "  type: {}", detail.file_type)?;
-
-        if let Some(size) = detail.size {
-            writeln!(self.stdout, "  size: {}", size)?;
-        }
-        if let Some(mode) = detail.mode {
-            writeln!(self.stdout, "  mode: 0o{mode:o}")?;
-        }
-        if let Some(modified) = &detail.modified {
-            writeln!(self.stdout, "  modified: \"{}\"", modified)?;
-        }
-        if let Some(accessed) = &detail.accessed {
-            writeln!(self.stdout, "  accessed: \"{}\"", accessed)?;
-        }
-        if let Some(created) = &detail.created {
-            writeln!(self.stdout, "  created: \"{}\"", created)?;
-        }
-        Ok(())
-    }
-
-    fn print_entry_json_obj(&mut self, detail: &FileDetail, comma: bool) -> io::Result<()> {
-        if self.started && comma {
-            writeln!(self.stdout, ",")?;
-        }
-
-        if comma {
-            write!(self.stdout, "  ")?;
-        }
+    fn print_entry_json_obj(&mut self, detail: &FileDetail) -> io::Result<()> {
         write!(self.stdout, "{{")?;
 
         match &detail.path {
@@ -380,9 +283,7 @@ impl<'a, W: Write> Printer<'a, W> {
             }
         };
         match format {
-            OutputFormat::Json => self.print_entry_json_obj(&detail, true),
-            OutputFormat::Jsonl => self.print_entry_json_obj(&detail, false),
-            OutputFormat::Yaml => self.print_entry_yaml_obj(&detail),
+            OutputFormat::Jsonl => self.print_entry_json_obj(&detail),
             OutputFormat::Plain => unreachable!("Plain format should not call print_entry_detail"),
         }
     }

src/walk.rs

@@ -172,21 +172,12 @@ impl<'a, W: Write + 'static> ReceiverBuffer<'a, W> {
 
     /// Process results until finished.
     fn process(&mut self) -> ExitCode {
-        if let Err(err) = self.printer.begin() {
-            return err;
-        }
-        let ec;
         loop {
             if let Err(err) = self.poll() {
                 self.quit_flag.store(true, Ordering::Relaxed);
-                ec = err;
-                break;
+                return err;
             }
         }
-        if let Err(err) = self.printer.end() {
-            return err;
-        }
-        ec
     }
 
     /// Receive the next worker result.