feat(json): updated format to fit requirements

src/output/cell.rs

@@ -105,6 +105,20 @@ impl TextCell {
             contents: vec![ANSIString::from(new_string)].into(),
         }
     }
+
+    pub fn clean_content(&self) -> TextCell {
+        let new_contents = self
+            .contents
+            .iter()
+            .map(|x| x.clone())
+            .filter(|w| !w.is_empty() && !w.trim().is_empty())
+            .collect::<Vec<_>>();
+
+        TextCell {
+            width: self.width,
+            contents: new_contents.into(),
+        }
+    }
 }
 
 // I’d like to eventually abstract cells so that instead of *every* cell

src/output/details.rs

@@ -222,18 +222,31 @@ impl<'a> Render<'a> {
         Ok(())
     }
 
-    fn print_row<W: Write>(&self, w: &mut W, row: &TextCell) -> io::Result<()> {
-        write!(w, "[")?;
+    fn print_row<W: Write>(
+        &self,
+        w: &mut W,
+        row: &TextCell,
+        header: &Option<TextCell>,
+    ) -> io::Result<()> {
+        writeln!(w, "{{")?;
+        let mut j: usize = 0;
         for (i, cell) in row.contents.iter().enumerate() {
             if cell.is_empty() || cell.trim().is_empty() {
                 continue;
             };
+            match header {
+                Some(ref header) => {
+                    write!(w, "\"{}\": ", header.contents[j])?;
+                    j += 1;
+                }
+                None => {}
+            }
             write!(w, "\"{cell}\"")?;
             if (i + 1) < row.contents.len() {
-                write!(w, ", ")?;
+                writeln!(w, ", ")?;
             }
         }
-        write!(w, "]")
+        write!(w, "}}")
     }
 
     pub fn render_as_json<W: Write>(self, w: &mut W) -> io::Result<()> {
@@ -267,17 +280,17 @@ impl<'a> Render<'a> {
 
             writeln!(w, "{{")?;
             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)?;
-                writeln!(w, ",")?;
-            }
-            write!(w, "\"files\":[")?;
+            let header: _ = if self.opts.header {
+                let header = row_iter.next().unwrap().clean_content();
+                Some(header)
+            } else {
+                None
+            };
+            writeln!(w, "\"files\":[")?;
             for (i, row) in row_iter.enumerate() {
-                self.print_row(w, &row)?;
+                self.print_row(w, &row, &(header.clone()))?;
                 if (i + 1) < self.files.len() {
-                    write!(w, ", ")?;
+                    writeln!(w, ",")?;
                 }
             }
             writeln!(w, "\n]\n}}")?;
@@ -579,7 +592,7 @@ impl<'a> Iterator for TableIter<'a> {
                 cell.add_spaces(1);
             }
 
-            cell.append(row.name);
+            cell.append(row.name.concat_content());
             cell
         })
     }

src/output/render/permissions.rs

@@ -26,11 +26,9 @@ 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(std::string::ToString::to_string).collect();
-
                 TextCell {
                     width: DisplayWidth::from(chars.len()),
-                    contents: vec![ANSIString::from(contents.join(""))].into(),
+                    contents: chars.into(),
                 }
             }
             None => {

src/output/table.rs

@@ -510,7 +510,7 @@ impl<'a> Table<'a> {
         color_scale_info: Option<ColorScaleInformation>,
     ) -> TextCell {
         match column {
-            Column::Permissions => self.permissions_plus(file, xattrs).render(self.theme),
+            Column::Permissions => self.permissions_plus(file, xattrs).render(self.theme).concat_content(),
             Column::FileSize => file
                 .size()
                 .render(