refactor: json fmt mod

This also addresses feedback from json PR:

- mode is output as a string, using the octal representation
- path uses the same format as the ripgrep output
- use "size_bytes" instead of "size" to make the unit more clear

Also, I fixed an issue where the mode included high bytes that are
actually used to encode the filetype (at least on Linux).

Author: tmccombs

doc/fd.1

@@ -513,25 +513,29 @@ due to OS restrictions on the maximum length of command lines.
 .TP
 .BI "\-\-json "
 .RS
-Specify JSONL (as known as NDJSON) format to use for the output. 
+Specify JSONL (as known as NDJSON) format to use for the output.
 
 Output fields:
 
-  - "path": The file path as a UTF\-8 string.
+  - "path": An object containing the path of the file. When the path is valid UTF-8, it this contains a single "text" field
+    containing the path as  a string. Otherwise it contains a single "bytes" field containing the base64 encoded bytes of the
+    path.
 
-        Note that when the path contains invalid UTF-8 sequences, it is encoded in base64 and stored in the "path_b64" field instead.
+        On windows, this may use a lossy UTF-8 encoding, since there isn't an obvious way to encode the pathname.
 
-  - "type": The file type (e.g., "file", "directory").
+        If a custom path separator is given, it is used in the "text" field, but not in the "bytes" field.
 
-  - "size": The file size in bytes.
+  - "type": The file type (e.g., "file", "directory", "symlink").
+
+  - "size_bytes": The file size in bytes.
 
   - "mode": The file permissions in octal (e.g., 644).
 
-  - "modified": The last modification time in ISO 8601 format (e.g., 2000-01-01T12:00:00Z).
+  - "modified": The last modification time in RFC3339 (ISO 8601) format (e.g., 2000-01-01T12:00:00Z).
 
-  - "accessed": The last access time in ISO 8601 format.
+  - "accessed": The last access time in RFC3339 format.
 
-  - "created": The creation time in ISO 8601 format.
+  - "created": The creation time in RFC3339 format.
 .RE
 .TP
 .SH PATTERN SYNTAX

src/cli.rs

@@ -653,6 +653,7 @@ pub struct Opts {
         long,
         value_name = "json",
         help = "Print results in JSONL format so you can pipe it to tools.",
+        conflicts_with_all(&["format", "list_details"]),
         long_help
     )]
     pub json: bool,
@@ -834,15 +835,6 @@ pub enum HyperlinkWhen {
     Never,
 }
 
-#[derive(Copy, Clone, PartialEq, Eq, Debug, ValueEnum)]
-pub enum OutputFormat {
-    /// Plain text output (default)
-    Plain,
-    /// JSONL (JSON Lines, as known as Newline Delimited JSON) output
-    #[value(alias = "ndjson")]
-    Jsonl,
-}
-
 // there isn't a derive api for getting grouped values yet,
 // so we have to use hand-rolled parsing for exec and exec-batch
 pub struct Exec {

src/config.rs

@@ -1,14 +1,13 @@
 use std::{path::PathBuf, sync::Arc, time::Duration};
 
-use lscolors::LsColors;
 use regex::bytes::RegexSet;
 
 use crate::exec::CommandSet;
 use crate::filetypes::FileTypes;
 #[cfg(unix)]
 use crate::filter::OwnerFilter;
 use crate::filter::{SizeFilter, TimeFilter};
-use crate::fmt::FormatTemplate;
+use crate::fmt::OutputFormat;
 
 /// Configuration options for *fd*.
 pub struct Config {
@@ -70,10 +69,6 @@ pub struct Config {
     /// `max_buffer_time`.
     pub max_buffer_time: Option<Duration>,
 
-    /// `None` if the output should not be colorized. Otherwise, a `LsColors` instance that defines
-    /// how to style different filetypes.
-    pub ls_colors: Option<LsColors>,
-
     /// Whether or not we are writing to an interactive terminal
     #[cfg_attr(not(unix), allow(unused))]
     pub interactive_terminal: bool,
@@ -87,8 +82,10 @@ pub struct Config {
     /// The value (if present) will be a lowercase string without leading dots.
     pub extensions: Option<RegexSet>,
 
-    /// A format string to use to format results, similarly to exec
-    pub format: Option<FormatTemplate>,
+    /// The format to use for the output
+    ///
+    /// determined by multiple options
+    pub format: OutputFormat,
 
     /// If a value is supplied, each item found will be used to generate and execute commands.
     pub command: Option<Arc<CommandSet>>,
@@ -130,9 +127,6 @@ pub struct Config {
 
     /// Whether or not to use hyperlinks on paths
     pub hyperlink: bool,
-
-    /// Whether to print results in JSONL format
-    pub jsonl: bool,
 }
 
 impl Config {

src/fmt/json.rs

@@ -0,0 +1,88 @@
+use std::borrow::Cow;
+use std::fs::{FileType, Metadata};
+use std::io::Write;
+#[cfg(unix)]
+use std::os::unix::{ffi::OsStrExt, fs::MetadataExt};
+use std::path::{MAIN_SEPARATOR, Path};
+use std::time::SystemTime;
+
+use base64::{Engine as _, prelude::BASE64_STANDARD};
+use jiff::Timestamp;
+
+pub fn output_json<W: Write>(
+    out: &mut W,
+    path: &Path,
+    filetype: Option<FileType>,
+    metadata: Option<&Metadata>,
+    path_separator: &Option<String>,
+) -> std::io::Result<()> {
+    out.write_all(b"{")?;
+
+    // Print the path as an object that either has a "text" key containing the
+    // utf8 path, or a "bytes" key with the base64 encoded bytes of the path
+    #[cfg(unix)]
+    match path.to_str() {
+        Some(text) => {
+            let final_path: Cow<str> = if let Some(sep) = path_separator {
+                text.replace(MAIN_SEPARATOR, sep).into()
+            } else {
+                text.into()
+            };
+            // NB: This assumes that rust's debug output for a string
+            // is a valid JSON string. At time of writing this is the case
+            // but it is possible, though unlikely, that this could change
+            // in the future.
+            write!(out, r#""path":{{"text":{:?}}}"#, final_path)?;
+        }
+        None => {
+            let encoded_bytes = BASE64_STANDARD.encode(path.as_os_str().as_bytes());
+            write!(out, r#""path":{{"bytes":"{}"}}"#, encoded_bytes)?;
+        }
+    };
+    // On non-unix platforms, if the path isn't valid utf-8,
+    // we don't know what kind of encoding was used, and
+    // as_encoded_bytes() isn't necessarily stable between rust versions
+    // so the best we can really do is a lossy string
+    #[cfg(not(unix))]
+    write!(out, r#""path":{{"text":{:?}}}"#, path.to_string_lossy())?;
+
+    // print the type of file
+    let ft = match filetype {
+        Some(ft) if ft.is_dir() => "directory",
+        Some(ft) if ft.is_file() => "file",
+        Some(ft) if ft.is_symlink() => "symlink",
+        _ => "unknown",
+    };
+    write!(out, r#","type":"{}""#, ft)?;
+
+    if let Some(meta) = metadata {
+        // Output the mode as octal
+        // We also need to mask it to just include the permission
+        // bits and not the file type bits (that is handled by "type" above)
+        #[cfg(unix)]
+        write!(out, r#","mode":"{:o}""#, meta.mode() & 0x7777)?;
+
+        write!(out, r#","size_bytes":{}"#, meta.len())?;
+
+        // would it be better to do these with os-specific functions?
+        if let Ok(modified) = meta.modified().map(json_timestamp) {
+            write!(out, r#","modified":"{}""#, modified)?;
+        }
+        if let Ok(accessed) = meta.accessed().map(json_timestamp) {
+            write!(out, r#","modified":"{}""#, accessed)?;
+        }
+        if let Ok(created) = meta.created().map(json_timestamp) {
+            write!(out, r#","modified":"{}""#, created)?;
+        }
+    }
+
+    out.write_all(b"}")
+}
+
+fn json_timestamp(time: SystemTime) -> Timestamp {
+    // System timestamps should always be valid, so assume that we can
+    // unwrap it
+    // If we ever do want to handle an error here, maybe convert to either the MAX or MIN
+    // timestamp depending on which side of the epoch the SystemTime is?
+    Timestamp::try_from(time).expect("Invalid timestamp")
+}