Move term::cell module to its own file

The cell module was previously implemented within term.rs. Now each
module has its own file.

src/term/cell.rs

@@ -0,0 +1,76 @@
+// Copyright 2016 Joe Wilm, The Alacritty Project Contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+use std::mem;
+
+use ansi;
+use Rgb;
+
+bitflags! {
+    #[derive(Serialize, Deserialize)]
+    pub flags Flags: u32 {
+        const INVERSE   = 0b00000001,
+        const BOLD      = 0b00000010,
+        const ITALIC    = 0b00000100,
+        const UNDERLINE = 0b00001000,
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Color {
+    Rgb(Rgb),
+    Ansi(ansi::Color),
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
+pub struct Cell {
+    pub c: char,
+    pub fg: Color,
+    pub bg: Color,
+    pub flags: Flags,
+}
+
+impl Cell {
+    pub fn bold(&self) -> bool {
+        self.flags.contains(BOLD)
+    }
+
+    pub fn new(c: char, fg: Color, bg: Color) -> Cell {
+        Cell {
+            c: c.into(),
+            bg: bg,
+            fg: fg,
+            flags: Flags::empty(),
+        }
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.c == ' ' &&
+            self.bg == Color::Ansi(ansi::Color::Background) &&
+            !self.flags.contains(INVERSE)
+    }
+
+    #[inline]
+    pub fn reset(&mut self, template: &Cell) {
+        // memcpy template to self
+        *self = template.clone();
+    }
+
+    #[inline]
+    pub fn swap_fg_and_bg(&mut self) {
+        mem::swap(&mut self.fg, &mut self.bg);
+    }
+}

src/term/mod.rs

@@ -22,6 +22,9 @@ use grid::{Grid, ClearRegion};
 use index::{Cursor, Column, Line};
 use ansi::Color;
 
+pub mod cell;
+pub use self::cell::Cell;
+
 /// Iterator that yields cells needing render
 ///
 /// Yields cells that require work to be displayed (that is, not a an empty
@@ -154,105 +157,6 @@ fn limit<T: PartialOrd + Ord>(val: T, min: T, max: T) -> T {
     cmp::min(cmp::max(min, val), max)
 }
 
-pub mod cell {
-    use std::mem;
-
-    use ansi;
-    use ::Rgb;
-
-    bitflags! {
-        #[derive(Serialize, Deserialize)]
-        pub flags Flags: u32 {
-            const INVERSE   = 0b00000001,
-            const BOLD      = 0b00000010,
-            const ITALIC    = 0b00000100,
-            const UNDERLINE = 0b00001000,
-        }
-    }
-
-    #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-    pub enum Color {
-        Rgb(Rgb),
-        Ansi(ansi::Color),
-    }
-
-    #[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
-    pub struct Cell {
-        pub c: char,
-        pub fg: Color,
-        pub bg: Color,
-        pub flags: Flags,
-    }
-
-    impl Cell {
-        pub fn bold(&self) -> bool {
-            self.flags.contains(BOLD)
-        }
-
-        pub fn new(c: char, fg: Color, bg: Color) -> Cell {
-            Cell {
-                c: c.into(),
-                bg: bg,
-                fg: fg,
-                flags: Flags::empty(),
-            }
-        }
-
-        #[inline]
-        pub fn is_empty(&self) -> bool {
-            self.c == ' ' &&
-                self.bg == Color::Ansi(ansi::Color::Background) &&
-                !self.flags.contains(INVERSE)
-        }
-
-        #[inline]
-        pub fn reset(&mut self, template: &Cell) {
-            // memcpy template to self
-            *self = template.clone();
-        }
-
-        #[inline]
-        pub fn swap_fg_and_bg(&mut self) {
-            mem::swap(&mut self.fg, &mut self.bg);
-        }
-    }
-
-    #[cfg(test)]
-    mod tests {
-        use super::Color;
-        use std::mem;
-
-        // Ensure memory layout is well defined so components like renderer
-        // can exploit it.
-        //
-        // Thankfully, everything is just a u8 for now so no endianness
-        // considerations are needed.
-        #[test]
-        fn color_memory_layout() {
-            let rgb_color = Color::Rgb(::Rgb { r: 1, g: 2, b: 3 });
-            let ansi_color = Color::Ansi(::ansi::Color::Foreground);
-
-            unsafe {
-                // Color::Rgb
-                // [discriminant(0), red, green ,blue]
-                let bytes: [u8; 4] = mem::transmute_copy(&rgb_color);
-                assert_eq!(bytes[0], 0);
-                assert_eq!(bytes[1], 1);
-                assert_eq!(bytes[2], 2);
-                assert_eq!(bytes[3], 3);
-
-                // Color::Ansi
-                // [discriminant(1), ansi::Color, 0, 0]
-                let bytes: [u8; 4] = mem::transmute_copy(&ansi_color);
-                assert_eq!(bytes[0], 1);
-                assert_eq!(bytes[1], ::ansi::Color::Foreground as u8);
-            }
-        }
-    }
-}
-
-pub use self::cell::Cell;
-
 pub mod mode {
     bitflags! {
         pub flags TermMode: u8 {
@@ -981,7 +885,7 @@ mod tests {
 
     use super::limit;
 
-    use ansi::Color;
+    use ansi::{Color};
     use grid::Grid;
     use index::{Line, Column};
     use term::{cell, Cell};