Replace Cells with growable TextCells

A recent change to ansi-term [1] means that `ANSIString`s can now hold either
owned *or* borrowed data (Rust calls this the Cow type). This means that we
can delay formatting ANSIStrings into ANSI-control-code-formatted strings
until it's absolutely necessary. The process for doing this was:

1. Replace the `Cell` type with a `TextCell` type that holds a vector of
   `ANSIString` values instead of a formatted string. It still does the
   width tracking.

2. Rework the details module's `render` functions to emit values of this
   type.

3. Similarly, rework the functions that produce cells containing filenames
   to use a `File` value's `name` field, which is an owned `String` that
   can now be re-used.

4. Update the printing, formatting, and width-calculating code in the
   details and grid-details views to produce a table by adding vectors
   together instead of adding strings together, delaying the formatting as
   long as it can.

This results in fewer allocations (as fewer `String` values are produced), and
makes the API tidier (as fewer `String` values are being passed around without
having their contents specified).

This also paves the way to Windows support, or at least support for
non-ANSI terminals: by delaying the time until strings are formatted,
it'll now be easier to change *how* they are formatted.

Casualties include:

- Bump to ansi_term v0.7.1, which impls `PartialEq` and `Debug` on
  `ANSIString`.
- The grid_details and lines views now need to take a vector of files, rather
  than a borrowed slice, so the filename cells produced now own the filename
  strings that get taken from files.
- Fixed the signature of `File#link_target` to specify that the
  file produced refers to the same directory, rather than some phantom
  directory with the same lifetime as the file. (This was wrong from the
  start, but it broke nothing until now)

References:

[1]: ansi-term@f6a6579ba8174de1cae64d181ec04af32ba2a4f0

8 files changed, 310 insertions, 190 deletions

diff --git a/src/file.rs b/src/file.rs
index 08c45bb..d4c9b9e 100644
--- a/src/file.rs
+++ b/src/file.rs
@@ -195,7 +195,7 @@ impl<'dir> File<'dir> {
     /// If statting the file fails (usually because the file on the
     /// other end doesn't exist), returns the *filename* of the file
     /// that should be there.
-    pub fn link_target(&self) -> Result<File, String> {
+    pub fn link_target(&self) -> Result<File<'dir>, String> {
         let path = match fs::read_link(&self.path) {
             Ok(path)  => path,
             Err(_)    => return Err(self.name.clone()),
diff --git a/src/main.rs b/src/main.rs
index 1e9f76c..11a2fc0 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -135,8 +135,8 @@ impl Exa {
         match self.options.view {
             View::Grid(g)         => g.view(&files),
             View::Details(d)      => d.view(dir, files),
-            View::GridDetails(gd) => gd.view(dir, &files),
-            View::Lines(l)        => l.view(&files),
+            View::GridDetails(gd) => gd.view(dir, files),
+            View::Lines(l)        => l.view(files),
         }
     }
 }
diff --git a/src/output/cell.rs b/src/output/cell.rs
new file mode 100644
index 0000000..1d3f6e2
--- /dev/null
+++ b/src/output/cell.rs
@@ -0,0 +1,130 @@
+//! The `TextCell` type for the details and lines views.
+
+use ansi_term::{Style, ANSIString, ANSIStrings};
+use unicode_width::UnicodeWidthStr;
+
+
+/// An individual cell that holds text in a table, used in the details and
+/// lines views to store ANSI-terminal-formatted data before it is printed.
+///
+/// A text cell is made up of zero or more strings coupled with the
+/// pre-computed length of all the strings combined. When constructing details
+/// or grid-details tables, the length will have to be queried multiple times,
+/// so it makes sense to cache it.
+///
+/// (This used to be called `Cell`, but was renamed because there’s a Rust
+/// type by that name too.)
+#[derive(PartialEq, Debug, Clone, Default)]
+pub struct TextCell {
+
+    /// The contents of this cell, as a vector of ANSI-styled strings.
+    pub contents: TextCellContents,
+
+    /// The Unicode “display width” of this cell, in characters.
+    ///
+    /// As with the `File` type’s width, this is related to the number of
+    /// *graphemes*, rather than *characters*, in the cell: most are 1 column
+    /// wide, but in some contexts, certain characters are two columns wide.
+    pub length: usize,
+}
+
+impl TextCell {
+
+    /// Creates a new text cell that holds the given text in the given style,
+    /// computing the Unicode width of the text.
+    pub fn paint(style: Style, text: String) -> Self {
+        TextCell {
+            length: text.width(),
+            contents: vec![ style.paint(text) ],
+        }
+    }
+
+    /// Creates a new text cell that holds the given text in the given style,
+    /// computing the Unicode width of the text. (This could be merged with
+    /// `paint`, but.)
+    pub fn paint_str(style: Style, text: &'static str) -> Self {
+        TextCell {
+            length: text.len(),
+            contents: vec![ style.paint(text) ],
+        }
+    }
+
+    /// Creates a new “blank” text cell that contains a single hyphen in the
+    /// given style, which should be the “punctuation” style from a `Colours`
+    /// value.
+    ///
+    /// This is used in place of empty table cells, as it is easier to read
+    /// tabular data when there is *something* in each cell.
+    pub fn blank(style: Style) -> Self {
+        TextCell {
+            length: 1,
+            contents: vec![ style.paint("-") ],
+        }
+    }
+
+    /// Adds the given number of unstyled spaces after this cell.
+    ///
+    /// This method allocates a `String` to hold the spaces.
+    pub fn add_spaces(&mut self, count: usize) {
+        use std::iter::repeat;
+
+        self.length += count;
+
+        let spaces: String = repeat(' ').take(count).collect();
+        self.contents.push(Style::default().paint(spaces));
+    }
+
+    /// Adds the contents of another `ANSIString` to the end of this cell.
+    pub fn push(&mut self, string: ANSIString<'static>, length: usize) {
+        self.contents.push(string);
+        self.length += length;
+    }
+
+    /// Adds all the contents of another `TextCell` to the end of this cell.
+    pub fn append(&mut self, other: TextCell) {
+        self.length += other.length;
+        self.contents.extend(other.contents);
+    }
+
+    /// Produces an `ANSIStrings` value that can be used to print the styled
+    /// values of this cell as an ANSI-terminal-formatted string.
+    pub fn strings(&self) -> ANSIStrings {
+        ANSIStrings(&self.contents)
+    }
+}
+
+
+// I’d like to eventually abstract cells so that instead of *every* cell
+// storing a vector, only variable-length cells would, and individual cells
+// would just store an array of a fixed length (which would usually be just 1
+// or 2), which wouldn’t require a heap allocation.
+//
+// For examples, look at the `render_*` methods in the `Table` object in the
+// details view:
+//
+// - `render_blocks`, `inode`, and `links` will always return a
+//   one-string-long TextCell;
+// - `render_size` will return one or two strings in a TextCell, depending on
+//   the size and whether one is present;
+// - `render_permissions` will return ten or eleven strings;
+// - `filename` and `symlink_filename` in the output module root return six or
+//   five strings.
+//
+// In none of these cases are we dealing with a *truly variable* number of
+// strings: it is only when the strings are concatenated together do we need a
+// growable, heap-allocated buffer.
+//
+// So it would be nice to abstract the `TextCell` type so instead of a `Vec`,
+// it can use anything of type `T: IntoIterator<Item=ANSIString<’static>>`.
+// This would allow us to still hold all the data, but allocate less.
+//
+// But exa still has bugs and I need to fix those first :(
+
+
+/// The contents of a text cell, as a vector of ANSI-styled strings.
+///
+/// It’s possible to use this type directly in the case where you want a
+/// `TextCell` but aren’t concerned with tracking its width, because it occurs
+/// in the final cell of a table or grid and there’s no point padding it. This
+/// happens when dealing with file names.
+pub type TextCellContents = Vec<ANSIString<'static>>;
\ No newline at end of file
diff --git a/src/output/column.rs b/src/output/column.rs
index c2b8568..cfec1f9 100644
--- a/src/output/column.rs
+++ b/src/output/column.rs
@@ -1,6 +1,3 @@
-use ansi_term::Style;
-use unicode_width::UnicodeWidthStr;
-
 use dir::Dir;
 
 
@@ -194,38 +191,3 @@ impl Default for TimeTypes {
         TimeTypes { accessed: false, modified: true, created: false }
     }
 }
-
-
-#[derive(PartialEq, Debug, Clone)]
-pub struct Cell {
-    pub length: usize,
-    pub text: String,
-}
-
-impl Cell {
-    pub fn empty() -> Cell {
-        Cell {
-            text: String::new(),
-            length: 0,
-        }
-    }
-
-    pub fn paint(style: Style, string: &str) -> Cell {
-        Cell {
-            text: style.paint(string).to_string(),
-            length: UnicodeWidthStr::width(string),
-        }
-    }
-
-    pub fn add_spaces(&mut self, count: usize) {
-        self.length += count;
-        for _ in 0 .. count {
-            self.text.push(' ');
-        }
-    }
-
-    pub fn append(&mut self, other: &Cell) {
-        self.length += other.length;
-        self.text.push_str(&*other.text);
-    }
-}
diff --git a/src/output/details.rs b/src/output/details.rs
index a7d1da9..e9e59b2 100644
--- a/src/output/details.rs
+++ b/src/output/details.rs
@@ -124,9 +124,10 @@ use feature::xattr::{Attribute, FileAttributes};
 use file::fields as f;
 use file::File;
 use options::{FileFilter, RecurseOptions};
-use output::column::{Alignment, Column, Columns, Cell, SizeFormat};
+use output::column::{Alignment, Column, Columns, SizeFormat};
+use output::cell::TextCell;
 
-use ansi_term::{ANSIString, ANSIStrings, Style};
+use ansi_term::Style;
 
 use datetime::local::{LocalDateTime, DatePiece};
 use datetime::format::DateFormat;
@@ -198,7 +199,7 @@ impl Details {
         // Then add files to the table and print it out.
         self.add_files_to_table(&mut table, files, 0);
         for cell in table.print_table() {
-            println!("{}", cell.text);
+            println!("{}", cell.strings());
         }
     }
 
@@ -213,20 +214,18 @@ impl Details {
         let mut file_eggs = Vec::new();
 
         struct Egg<'_> {
-            cells:   Vec<Cell>,
-            name:    Cell,
+            cells:   Vec<TextCell>,
             xattrs:  Vec<Attribute>,
             errors:  Vec<(io::Error, Option<PathBuf>)>,
             dir:     Option<Dir>,
-            file:    Arc<File<'_>>,
+            file:    File<'_>,
         }
 
         pool.scoped(|scoped| {
             let file_eggs = Arc::new(Mutex::new(&mut file_eggs));
             let table = Arc::new(Mutex::new(&mut table));
 
-            for file in src.into_iter() {
-                let file: Arc<File> = Arc::new(file);
+            for file in src {
                 let file_eggs = file_eggs.clone();
                 let table = table.clone();
 
@@ -251,11 +250,6 @@ impl Details {
 
                     let cells = table.lock().unwrap().cells_for_file(&file, !xattrs.is_empty());
 
-                    let name = Cell {
-                        text: filename(&file, &self.colours, true),
-                        length: file.file_name_width()
-                    };
-
                     let mut dir = None;
 
                     if let Some(r) = self.recurse {
@@ -268,7 +262,6 @@ impl Details {
 
                     let egg = Egg {
                         cells: cells,
-                        name: name,
                         xattrs: xattrs,
                         errors: errors,
                         dir: dir,
@@ -280,17 +273,22 @@ impl Details {
             }
         });
 
-        file_eggs.sort_by(|a, b| self.filter.compare_files(&*a.file, &*b.file));
+        file_eggs.sort_by(|a, b| self.filter.compare_files(&a.file, &b.file));
 
         let num_eggs = file_eggs.len();
         for (index, egg) in file_eggs.into_iter().enumerate() {
             let mut files = Vec::new();
             let mut errors = egg.errors;
 
+            let name = TextCell {
+                length: egg.file.file_name_width(),
+                contents: filename(egg.file, &self.colours, true),
+            };
+
             let row = Row {
                 depth:    depth,
                 cells:    Some(egg.cells),
-                name:     egg.name,
+                name:     name,
                 last:     index == num_eggs - 1,
             };
 
@@ -342,14 +340,11 @@ struct Row {
     /// almost always be `Some`, containing a vector of cells. It will only be
     /// `None` for a row displaying an attribute or error, neither of which
     /// have cells.
-    cells: Option<Vec<Cell>>,
-
-    // Did You Know?
-    // A Vec<Cell> and an Option<Vec<Cell>> actually have the same byte size!
+    cells: Option<Vec<TextCell>>,
 
     /// This file's name, in coloured output. The name is treated separately
     /// from the other cells, as it never requires padding.
-    name: Cell,
+    name: TextCell,
 
     /// How many directories deep into the tree structure this is. Directories
     /// on top have depth 0.
@@ -429,8 +424,8 @@ impl<U> Table<U> where U: Users {
     pub fn add_header(&mut self) {
         let row = Row {
             depth:    0,
-            cells:    Some(self.columns.iter().map(|c| Cell::paint(self.colours.header, c.header())).collect()),
-            name:     Cell::paint(self.colours.header, "Name"),
+            cells:    Some(self.columns.iter().map(|c| TextCell::paint_str(self.colours.header, c.header())).collect()),
+            name:     TextCell::paint_str(self.colours.header, "Name"),
             last:     false,
         };
 
@@ -446,7 +441,7 @@ impl<U> Table<U> where U: Users {
         let row = Row {
             depth:    depth,
             cells:    None,
-            name:     Cell::paint(self.colours.broken_arrow, &error_message),
+            name:     TextCell::paint(self.colours.broken_arrow, error_message),
             last:     last,
         };
 
@@ -457,19 +452,26 @@ impl<U> Table<U> where U: Users {
         let row = Row {
             depth:    depth,
             cells:    None,
-            name:     Cell::paint(self.colours.perms.attribute, &format!("{} (len {})", xattr.name, xattr.size)),
+            name:     TextCell::paint(self.colours.perms.attribute, format!("{} (len {})", xattr.name, xattr.size)),
             last:     last,
         };
 
         self.rows.push(row);
     }
 
-    pub fn add_file_with_cells(&mut self, cells: Vec<Cell>, file: &File, depth: usize, last: bool, links: bool) {
+    pub fn filename_cell(&self, file: File, links: bool) -> TextCell {
+        TextCell {
+            length:   file.file_name_width(),
+            contents: filename(file, &self.colours, links),
+        }
+    }
+
+    pub fn add_file_with_cells(&mut self, cells: Vec<TextCell>, name_cell: TextCell, depth: usize, last: bool) {
         let row = Row {
-            depth:    depth,
-            cells:    Some(cells),
-            name:     Cell { text: filename(file, &self.colours, links), length: file.file_name_width() },
-            last:     last,
+            depth:  depth,
+            cells:  Some(cells),
+            name:   name_cell,
+            last:   last,
         };
 
         self.rows.push(row);
@@ -477,13 +479,13 @@ impl<U> Table<U> where U: Users {
 
     /// Use the list of columns to find which cells should be produced for
     /// this file, per-column.
-    pub fn cells_for_file(&mut self, file: &File, xattrs: bool) -> Vec<Cell> {
+    pub fn cells_for_file(&mut self, file: &File, xattrs: bool) -> Vec<TextCell> {
         self.columns.clone().iter()
                     .map(|c| self.display(file, c, xattrs))
                     .collect()
     }
 
-    fn display(&mut self, file: &File, column: &Column, xattrs: bool) -> Cell {
+    fn display(&mut self, file: &File, column: &Column, xattrs: bool) -> TextCell {
         use output::column::TimeType::*;
 
         match *column {
@@ -501,7 +503,7 @@ impl<U> Table<U> where U: Users {
         }
     }
 
-    fn render_permissions(&self, permissions: f::Permissions, xattrs: bool) -> Cell {
+    fn render_permissions(&self, permissions: f::Permissions, xattrs: bool) -> TextCell {
         let c = self.colours.perms;
         let bit = |bit, chr: &'static str, style: Style| {
             if bit { style.paint(chr) } else { self.colours.punctuation.paint("-") }
@@ -518,7 +520,7 @@ impl<U> Table<U> where U: Users {
         let x_colour = if let f::Type::File = permissions.file_type { c.user_execute_file }
                                                                else { c.user_execute_other };
 
-        let mut columns = vec![
+        let mut chars = vec![
             file_type,
             bit(permissions.user_read,     "r", c.user_read),
             bit(permissions.user_write,    "w", c.user_write),
@@ -532,63 +534,71 @@ impl<U> Table<U> where U: Users {
         ];
 
         if xattrs {
-            columns.push(c.attribute.paint("@"));
+            chars.push(c.attribute.paint("@"));
         }
 
-        Cell {
-            text: ANSIStrings(&columns).to_string(),
-            length: columns.len(),
+        TextCell {
+            length:   chars.len(),
+            contents: chars,
         }
     }
 
-    fn render_links(&self, links: f::Links) -> Cell {
+    fn render_links(&self, links: f::Links) -> TextCell {
         let style = if links.multiple { self.colours.links.multi_link_file }
                                  else { self.colours.links.normal };
 
-        Cell::paint(style, &self.numeric.format_int(links.count))
+        TextCell::paint(style, self.numeric.format_int(links.count))
     }
 
-    fn render_blocks(&self, blocks: f::Blocks) -> Cell {
+    fn render_blocks(&self, blocks: f::Blocks) -> TextCell {
         match blocks {
-            f::Blocks::Some(blocks)  => Cell::paint(self.colours.blocks, &blocks.to_string()),
-            f::Blocks::None          => Cell::paint(self.colours.punctuation, "-"),
+            f::Blocks::Some(blk)  => TextCell::paint(self.colours.blocks, blk.to_string()),
+            f::Blocks::None       => TextCell::blank(self.colours.punctuation),
         }
     }
 
-    fn render_inode(&self, inode: f::Inode) -> Cell {
-        Cell::paint(self.colours.inode, &inode.0.to_string())
+    fn render_inode(&self, inode: f::Inode) -> TextCell {
+        TextCell::paint(self.colours.inode, inode.0.to_string())
     }
 
-    fn render_size(&self, size: f::Size, size_format: SizeFormat) -> Cell {
-        use number_prefix::{binary_prefix, decimal_prefix, Prefixed, Standalone, PrefixNames};
+    fn render_size(&self, size: f::Size, size_format: SizeFormat) -> TextCell {
+        use number_prefix::{binary_prefix, decimal_prefix};
+        use number_prefix::{Prefixed, Standalone, PrefixNames};
 
-        if let f::Size::Some(offset) = size {
-            let result = match size_format {
-                SizeFormat::DecimalBytes  => decimal_prefix(offset as f64),
-                SizeFormat::BinaryBytes   => binary_prefix(offset as f64),
-                SizeFormat::JustBytes     => return Cell::paint(self.colours.size.numbers, &self.numeric.format_int(offset)),
-            };
+        let size = match size {
+            f::Size::Some(s) => s,
+            f::Size::None => return TextCell::blank(self.colours.punctuation),
+        };
 
-            match result {
-                Standalone(bytes)    => Cell::paint(self.colours.size.numbers, &*bytes.to_string()),
-                Prefixed(prefix, n)  => {
-                    let number = if n < 10f64 { self.numeric.format_float(n, 1) } else { self.numeric.format_int(n as isize) };
-                    let symbol = prefix.symbol();
+        let result = match size_format {
+            SizeFormat::DecimalBytes  => decimal_prefix(size as f64),
+            SizeFormat::BinaryBytes   => binary_prefix(size as f64),
+            SizeFormat::JustBytes     => {
+                let string = self.numeric.format_int(size);
+                return TextCell::paint(self.colours.size.numbers, string);
+            },
+        };
 
-                    Cell {
-                        text: ANSIStrings( &[ self.colours.size.numbers.paint(&number[..]), self.colours.size.unit.paint(symbol) ]).to_string(),
-                        length: number.len() + symbol.len(),
-                    }
-                }
-            }
-        }
-        else {
-            Cell::paint(self.colours.punctuation, "-")
+        let (prefix, n) = match result {
+            Standalone(b)  => return TextCell::paint(self.colours.size.numbers, b.to_string()),
+            Prefixed(p, n) => (p, n)
+        };
+
+        let symbol = prefix.symbol();
+        let number = if n < 10f64 { self.numeric.format_float(n, 1) }
+                             else { self.numeric.format_int(n as isize) };
+
+        TextCell {
+            length: number.len() + symbol.len(),
+            contents: vec![
+                self.colours.size.numbers.paint(number),
+                self.colours.size.unit.paint(symbol),
+            ],
         }
     }
 
     #[allow(trivial_numeric_casts)]
-    fn render_time(&self, timestamp: f::Time) -> Cell {
+    fn render_time(&self, timestamp: f::Time) -> TextCell {
         let date = self.tz.at(LocalDateTime::at(timestamp.0 as i64));
 
         let datestamp = if date.year() == self.current_year {
@@ -598,60 +608,60 @@ impl<U> Table<U> where U: Users {
                 DATE_AND_YEAR.format(&date, &self.time)
             };
 
-        Cell::paint(self.colours.date, &datestamp)
+        TextCell::paint(self.colours.date, datestamp)
     }
 
-    fn render_git_status(&self, git: f::Git) -> Cell {
-        Cell {
-            text: ANSIStrings(&[ self.render_git_char(git.staged),
-                                 self.render_git_char(git.unstaged) ]).to_string(),
-            length: 2,
-        }
-    }
-
-    fn render_git_char(&self, status: f::GitStatus) -> ANSIString {
-        match status {
+    fn render_git_status(&self, git: f::Git) -> TextCell {
+        let git_char = |status| match status {
             f::GitStatus::NotModified  => self.colours.punctuation.paint("-"),
             f::GitStatus::New          => self.colours.git.new.paint("N"),
             f::GitStatus::Modified     => self.colours.git.modified.paint("M"),
             f::GitStatus::Deleted      => self.colours.git.deleted.paint("D"),
             f::GitStatus::Renamed      => self.colours.git.renamed.paint("R"),
             f::GitStatus::TypeChange   => self.colours.git.typechange.paint("T"),
+        };
+
+        TextCell {
+            length: 2,
+            contents: vec![
+                git_char(git.staged),
+                git_char(git.unstaged)
+            ],
         }
     }
 
-    fn render_user(&mut self, user: f::User) -> Cell {
+    fn render_user(&mut self, user: f::User) -> TextCell {
         let user_name = match self.users.get_user_by_uid(user.0) {
             Some(user)  => user.name,
             None        => user.0.to_string(),
         };
 
         let style = if self.users.get_current_uid() == user.0 { self.colours.users.user_you }
-                                                         else { self.colours.users.user_someone_else };
-        Cell::paint(style, &*user_name)
+                                                else { self.colours.users.user_someone_else };
+        TextCell::paint(style, user_name)
     }
 
-    fn render_group(&mut self, group: f::Group) -> Cell {
+    fn render_group(&mut self, group: f::Group) -> TextCell {
         let mut style = self.colours.users.group_not_yours;
 
-        let group_name = match self.users.get_group_by_gid(group.0) {
-            Some(group) => {
-                let current_uid = self.users.get_current_uid();
-                if let Some(current_user) = self.users.get_user_by_uid(current_uid) {
-                    if current_user.primary_group == group.gid || group.members.contains(&current_user.name) {
-                        style = self.colours.users.group_yours;
-                    }
-                }
-                group.name
-            },
-            None => group.0.to_string(),
+        let group = match self.users.get_group_by_gid(group.0) {
+            Some(g) => g,
+            None    => return TextCell::paint(style, group.0.to_string()),
         };
 
-        Cell::paint(style, &*group_name)
+        let current_uid = self.users.get_current_uid();
+        if let Some(current_user) = self.users.get_user_by_uid(current_uid) {
+            if current_user.primary_group == group.gid
+            || group.members.contains(&current_user.name) {
+                style = self.colours.users.group_yours;
+            }
+        }
+
+        TextCell::paint(style, group.name)
     }
 
     /// Render the table as a vector of Cells, to be displayed on standard output.
-    pub fn print_table(&self) -> Vec<Cell> {
+    pub fn print_table(self) -> Vec<TextCell> {
         let mut stack = Vec::new();
         let mut cells = Vec::new();
 
@@ -664,14 +674,16 @@ impl<U> Table<U> where U: Users {
 
         let total_width: usize = self.columns.len() + column_widths.iter().fold(0, Add::add);
 
-        for row in self.rows.iter() {
-            let mut cell = Cell::empty();
+        for row in self.rows {
+            let mut cell = TextCell::default();
+
+            if let Some(cells) = row.cells {
+                for (n, (this_cell, width)) in cells.into_iter().zip(column_widths.iter()).enumerate() {
+                    let padding = width - this_cell.length;
 
-            if let Some(ref cells) = row.cells {
-                for (n, width) in column_widths.iter().enumerate() {
                     match self.columns[n].alignment() {
-                        Alignment::Left  => { cell.append(&cells[n]); cell.add_spaces(width - cells[n].length); }
-                        Alignment::Right => { cell.add_spaces(width - cells[n].length); cell.append(&cells[n]); }
+                        Alignment::Left  => { cell.append(this_cell); cell.add_spaces(padding); }
+                        Alignment::Right => { cell.add_spaces(padding); cell.append(this_cell); }
                     }
 
                     cell.add_spaces(1);
@@ -681,8 +693,7 @@ impl<U> Table<U> where U: Users {
                 cell.add_spaces(total_width)
             }
 
-            let mut filename = String::new();
-            let mut filename_length = 0;
+            let mut filename = TextCell::default();
 
             // A stack tracks which tree characters should be printed. It's
             // necessary to maintain information about the previously-printed
@@ -699,8 +710,7 @@ impl<U> Table<U> where U: Users {
             stack[row.depth] = if row.last { TreePart::Corner } else { TreePart::Edge };
 
             for i in 1 .. row.depth + 1 {
-                filename.push_str(&*self.colours.punctuation.paint(stack[i].ascii_art()).to_string());
-                filename_length += 4;
+                filename.push(self.colours.punctuation.paint(stack[i].ascii_art()), 4);
             }
 
             stack[row.depth] = if row.last { TreePart::Blank } else { TreePart::Line };
@@ -708,15 +718,13 @@ impl<U> Table<U> where U: Users {
             // If any tree characters have been printed, then add an extra
             // space, which makes the output look much better.
             if row.depth != 0 {
-                filename.push(' ');
-                filename_length += 1;
+                filename.add_spaces(1);
             }
 
             // Print the name without worrying about padding.
-            filename.push_str(&*row.name.text);
-            filename_length += row.name.length;
+            filename.append(row.name);
 
-            cell.append(&Cell { text: filename, length: filename_length });
+            cell.append(filename);
             cells.push(cell);
         }
 
@@ -767,7 +775,8 @@ pub mod test {
     pub use super::Table;
     pub use file::File;
     pub use file::fields as f;
-    pub use output::column::{Cell, Column};
+    pub use output::column::Column;
+    pub use output::cell::TextCell;
 
     pub use users::{User, Group, uid_t, gid_t};
     pub use users::mock::MockUsers;
@@ -806,7 +815,7 @@ pub mod test {
             table.users = users;
 
             let user = f::User(1000);
-            let expected = Cell::paint(Red.bold(), "enoch");
+            let expected = TextCell::paint_str(Red.bold(), "enoch");
             assert_eq!(expected, table.render_user(user))
         }
 
@@ -819,7 +828,7 @@ pub mod test {
             table.users = users;
 
             let user = f::User(1000);
-            let expected = Cell::paint(Cyan.bold(), "1000");
+            let expected = TextCell::paint_str(Cyan.bold(), "1000");
             assert_eq!(expected, table.render_user(user));
         }
 
@@ -830,7 +839,7 @@ pub mod test {
             table.users.add_user(newser(1000, "enoch", 100));
 
             let user = f::User(1000);
-            let expected = Cell::paint(Green.bold(), "enoch");
+            let expected = TextCell::paint_str(Green.bold(), "enoch");
             assert_eq!(expected, table.render_user(user));
         }
 
@@ -840,7 +849,7 @@ pub mod test {
             table.colours.users.user_someone_else = Red.normal();
 
             let user = f::User(1000);
-            let expected = Cell::paint(Red.normal(), "1000");
+            let expected = TextCell::paint_str(Red.normal(), "1000");
             assert_eq!(expected, table.render_user(user));
         }
 
@@ -850,7 +859,7 @@ pub mod test {
             table.colours.users.user_someone_else = Blue.underline();
 
             let user = f::User(2_147_483_648);
-            let expected = Cell::paint(Blue.underline(), "2147483648");
+            let expected = TextCell::paint_str(Blue.underline(), "2147483648");
             assert_eq!(expected, table.render_user(user));
         }
     }
@@ -869,7 +878,7 @@ pub mod test {
             table.users = users;
 
             let group = f::Group(100);
-            let expected = Cell::paint(Fixed(101).normal(), "folk");
+            let expected = TextCell::paint_str(Fixed(101).normal(), "folk");
             assert_eq!(expected, table.render_group(group))
         }
 
@@ -882,7 +891,7 @@ pub mod test {
             table.users = users;
 
             let group = f::Group(100);
-            let expected = Cell::paint(Fixed(87).normal(), "100");
+            let expected = TextCell::paint_str(Fixed(87).normal(), "100");
             assert_eq!(expected, table.render_group(group));
         }
 
@@ -897,7 +906,7 @@ pub mod test {
             table.users = users;
 
             let group = f::Group(100);
-            let expected = Cell::paint(Fixed(64).normal(), "folk");
+            let expected = TextCell::paint_str(Fixed(64).normal(), "folk");
             assert_eq!(expected, table.render_group(group))
         }
 
@@ -912,7 +921,7 @@ pub mod test {
             table.users = users;
 
             let group = f::Group(100);
-            let expected = Cell::paint(Fixed(31).normal(), "folk");
+            let expected = TextCell::paint_str(Fixed(31).normal(), "folk");
             assert_eq!(expected, table.render_group(group))
         }
 
@@ -922,7 +931,7 @@ pub mod test {
             table.colours.users.group_not_yours = Blue.underline();
 
             let group = f::Group(2_147_483_648);
-            let expected = Cell::paint(Blue.underline(), "2147483648");
+            let expected = TextCell::paint_str(Blue.underline(), "2147483648");
             assert_eq!(expected, table.render_group(group));
         }
     }
diff --git a/src/output/grid_details.rs b/src/output/grid_details.rs
index e482464..332bfce 100644
--- a/src/output/grid_details.rs
+++ b/src/output/grid_details.rs
@@ -1,5 +1,6 @@
 use std::iter::repeat;
 
+use ansi_term::ANSIStrings;
 use users::OSUsers;
 use term_grid as grid;
 
@@ -7,7 +8,8 @@ use dir::Dir;
 use feature::xattr::FileAttributes;
 use file::File;
 
-use output::column::{Column, Cell};
+use output::cell::TextCell;
+use output::column::Column;
 use output::details::{Details, Table};
 use output::grid::Grid;
 
@@ -25,19 +27,25 @@ fn file_has_xattrs(file: &File) -> bool {
 }
 
 impl GridDetails {
-    pub fn view(&self, dir: Option<&Dir>, files: &[File]) {
+    pub fn view(&self, dir: Option<&Dir>, files: Vec<File>) {
         let columns_for_dir = match self.details.columns {
             Some(cols) => cols.for_dir(dir),
             None => Vec::new(),
         };
 
         let mut first_table = Table::with_options(self.details.colours, columns_for_dir.clone());
-        let cells: Vec<_> = files.iter().map(|file| first_table.cells_for_file(file, file_has_xattrs(file))).collect();
+        let cells = files.iter()
+                          .map(|file| first_table.cells_for_file(file, file_has_xattrs(file)))
+                          .collect::<Vec<_>>();
 
-        let mut last_working_table = self.make_grid(1, &*columns_for_dir, files, cells.clone());
+        let file_names = files.into_iter()
+                              .map(|file| first_table.filename_cell(file, false))
+                              .collect::<Vec<_>>();
+
+        let mut last_working_table = self.make_grid(1, &columns_for_dir, &file_names, cells.clone());
 
         for column_count in 2.. {
-            let grid = self.make_grid(column_count, &*columns_for_dir, files, cells.clone());
+            let grid = self.make_grid(column_count, &columns_for_dir, &file_names, cells.clone());
 
             let the_grid_fits = {
                 let d = grid.fit_into_columns(column_count);
@@ -60,7 +68,7 @@ impl GridDetails {
         table
     }
 
-    fn make_grid(&self, column_count: usize, columns_for_dir: &[Column], files: &[File], cells: Vec<Vec<Cell>>) -> grid::Grid {
+    fn make_grid(&self, column_count: usize, columns_for_dir: &[Column], file_names: &[TextCell], cells: Vec<Vec<TextCell>>) -> grid::Grid {
         let mut tables: Vec<_> = repeat(()).map(|_| self.make_table(columns_for_dir)).take(column_count).collect();
 
         let mut num_cells = cells.len();
@@ -71,7 +79,7 @@ impl GridDetails {
         let original_height = divide_rounding_up(cells.len(), column_count);
         let height = divide_rounding_up(num_cells, column_count);
 
-        for (i, (file, row)) in files.iter().zip(cells.into_iter()).enumerate() {
+        for (i, (file_name, row)) in file_names.iter().zip(cells.into_iter()).enumerate() {
             let index = if self.grid.across {
                     i % column_count
                 }
@@ -79,10 +87,10 @@ impl GridDetails {
                     i / original_height
                 };
 
-            tables[index].add_file_with_cells(row, file, 0, false, false);
+            tables[index].add_file_with_cells(row, file_name.clone(), 0, false);
         }
 
-        let columns: Vec<_> = tables.iter().map(|t| t.print_table()).collect();
+        let columns: Vec<_> = tables.into_iter().map(|t| t.print_table()).collect();
 
         let direction = if self.grid.across { grid::Direction::LeftToRight }
                                        else