refactor: refactored the way string are created to follow up

src/output/cell.rs

@@ -91,6 +91,20 @@ impl TextCell {
         (*self.width) += *other.width;
         self.contents.0.extend(other.contents.0);
     }
+
+    pub fn concat_content(&self) -> TextCell {
+        let new_contents: Vec<String> = self
+            .contents
+            .iter()
+            .map(|x| x.clone().to_string())
+            .collect();
+
+        let new_string = new_contents.join("");
+        TextCell {
+            width: self.width,
+            contents: vec![ANSIString::from(new_string)].into(),
+        }
+    }
 }
 
 // I’d like to eventually abstract cells so that instead of *every* cell

src/output/details.rs

@@ -222,6 +222,20 @@ impl<'a> Render<'a> {
         Ok(())
     }
 
+    fn print_row<W: Write>(&self, w: &mut W, row: TextCell) -> io::Result<()> {
+        write!(w, "[")?;
+        for (i, cell) in row.contents.iter().enumerate() {
+            if cell.is_empty() || cell.trim().is_empty() {
+                continue;
+            };
+            write!(w, "\"{}\"", cell)?;
+            if (i + 1) < row.contents.len() {
+                write!(w, ", ")?;
+            }
+        }
+        write!(w, "{}", "]")
+    }
+
     pub fn render_as_json<W: Write>(mut self, w: &mut W) -> io::Result<()> {
         let n_cpus = match num_cpus::get() as u32 {
             0 => 1,
@@ -236,6 +250,7 @@ impl<'a> Render<'a> {
             if self.opts.header {
                 let header = table.header_row();
                 table.add_widths(&header);
+                rows.push(self.render_header(header));
             }
 
             // This is weird, but I can’t find a way around it:
@@ -250,14 +265,22 @@ impl<'a> Render<'a> {
                 None,
             );
 
-            write!(w, "{}", "{\"files\":[")?;
-            for (i, row) in self.iterate_with_table(table.unwrap(), rows).enumerate() {
-                write!(w, "\"{}\"", row.strings())?;
+            write!(w, "{}", "{\n")?;
+            let mut row_iter = self.iterate_with_table(table.unwrap(), rows);
+            if self.opts.header {
+                write!(w, "{}", "\"header\":")?;
+                let header = row_iter.next().unwrap();
+                self.print_row(w, header)?;
+                write!(w, "{}", ",\n")?;
+            }
+            write!(w, "{}", "\"files\":[")?;
+            for (i, row) in row_iter.enumerate() {
+                self.print_row(w, row)?;
                 if (i + 1) < self.files.len() {
                     write!(w, ", ")?;
                 }
             }
-            write!(w, "{}", "]}}\n")?;
+            write!(w, "{}", "\n]\n}\n")?;
         } else {
             self.add_files_to_table(
                 &mut pool,

src/output/render/permissions.rs

@@ -26,9 +26,11 @@ impl PermissionsPlusRender for Option<f::PermissionsPlus> {
                 // As these are all ASCII characters, we can guarantee that they’re
                 // all going to be one character wide, and don’t need to compute the
                 // cell’s display width.
+                let contents: Vec<_> = chars.iter().map(|c| c.to_string()).collect();
+
                 TextCell {
                     width: DisplayWidth::from(chars.len()),
-                    contents: chars.into(),
+                    contents: vec![ANSIString::from(contents.join(""))].into(),
                 }
             }
             None => {

src/output/table.rs

@@ -511,56 +511,78 @@ impl<'a> Table<'a> {
     ) -> TextCell {
         match column {
             Column::Permissions => self.permissions_plus(file, xattrs).render(self.theme),
-            Column::FileSize => file.size().render(
-                self.theme,
-                self.size_format,
-                &self.env.numeric,
-                color_scale_info,
-            ),
+            Column::FileSize => file
+                .size()
+                .render(
+                    self.theme,
+                    self.size_format,
+                    &self.env.numeric,
+                    color_scale_info,
+                )
+                .concat_content(),
             #[cfg(unix)]
-            Column::HardLinks => file.links().render(self.theme, &self.env.numeric),
+            Column::HardLinks => file
+                .links()
+                .render(self.theme, &self.env.numeric)
+                .concat_content(),
             #[cfg(unix)]
-            Column::Inode => file.inode().render(self.theme.ui.inode),
+            Column::Inode => file.inode().render(self.theme.ui.inode).concat_content(),
             #[cfg(unix)]
-            Column::Blocksize => {
-                file.blocksize()
-                    .render(self.theme, self.size_format, &self.env.numeric)
-            }
+            Column::Blocksize => file
+                .blocksize()
+                .render(self.theme, self.size_format, &self.env.numeric)
+                .concat_content(),
             #[cfg(unix)]
-            Column::User => {
-                file.user()
-                    .render(self.theme, &*self.env.lock_users(), self.user_format)
-            }
+            Column::User => file
+                .user()
+                .render(self.theme, &*self.env.lock_users(), self.user_format)
+                .concat_content(),
             #[cfg(unix)]
-            Column::Group => file.group().render(
-                self.theme,
-                &*self.env.lock_users(),
-                self.user_format,
-                self.group_format,
-                file.user(),
-            ),
+            Column::Group => file
+                .group()
+                .render(
+                    self.theme,
+                    &*self.env.lock_users(),
+                    self.user_format,
+                    self.group_format,
+                    file.user(),
+                )
+                .concat_content(),
             #[cfg(unix)]
-            Column::SecurityContext => file.security_context().render(self.theme),
-            Column::FileFlags => file.flags().render(self.theme.ui.flags, self.flags_format),
-            Column::GitStatus => self.git_status(file).render(self.theme),
-            Column::SubdirGitRepo(status) => self.subdir_git_repo(file, status).render(self.theme),
+            Column::SecurityContext => file.security_context().render(self.theme).concat_content(),
+            Column::FileFlags => file
+                .flags()
+                .render(self.theme.ui.flags, self.flags_format)
+                .concat_content(),
+            Column::GitStatus => self.git_status(file).render(self.theme).concat_content(),
+            Column::SubdirGitRepo(status) => self
+                .subdir_git_repo(file, status)
+                .render(self.theme)
+                .concat_content(),
             #[cfg(unix)]
-            Column::Octal => self.octal_permissions(file).render(self.theme.ui.octal),
-
-            Column::Timestamp(time_type) => time_type.get_corresponding_time(file).render(
-                if color_scale_info.is_some_and(|csi| csi.options.mode == ColorScaleMode::Gradient)
-                {
-                    color_scale_info.unwrap().apply_time_gradient(
-                        self.theme.ui.date,
-                        file,
-                        time_type,
-                    )
-                } else {
-                    self.theme.ui.date
-                },
-                self.env.time_offset,
-                self.time_format.clone(),
-            ),
+            Column::Octal => self
+                .octal_permissions(file)
+                .render(self.theme.ui.octal)
+                .concat_content(),
+
+            Column::Timestamp(time_type) => time_type
+                .get_corresponding_time(file)
+                .render(
+                    if color_scale_info
+                        .is_some_and(|csi| csi.options.mode == ColorScaleMode::Gradient)
+                    {
+                        color_scale_info.unwrap().apply_time_gradient(
+                            self.theme.ui.date,
+                            file,
+                            time_type,
+                        )
+                    } else {
+                        self.theme.ui.date
+                    },
+                    self.env.time_offset,
+                    self.time_format.clone(),
+                )
+                .concat_content(),
         }
     }