Refactor viewrc

Summary: Move viewrc process logics to individual components so that they can be done at component initialization.

Reviewed By: brianc118

Differential Revision: D52575586

fbshipit-source-id: e2955d0a8b17132f679b464283f844dabfbc77ca

3 files changed, 61 insertions, 150 deletions

diff --git a/below/view/src/cgroup_view.rs b/below/view/src/cgroup_view.rs
index 56cea85b..615df7b7 100644
--- a/below/view/src/cgroup_view.rs
+++ b/below/view/src/cgroup_view.rs
@@ -43,6 +43,7 @@ use crate::stats_view::ColumnTitles;
 use crate::stats_view::StateCommon;
 use crate::stats_view::StatsView;
 use crate::stats_view::ViewBridge;
+use crate::viewrc::ViewRc;
 use crate::ViewState;
 
 pub type ViewType = StatsView<CgroupView>;
@@ -204,7 +205,7 @@ pub struct CgroupView {
 }
 
 impl CgroupView {
-    pub fn new(c: &mut Cursive) -> NamedView<ViewType> {
+    pub fn new(c: &mut Cursive, viewrc: &ViewRc) -> NamedView<ViewType> {
         let mut list = SelectView::new();
         list.set_on_submit(|c, cgroup: &String| {
             let mut view = CgroupView::get_cgroup_view(c);
@@ -257,48 +258,52 @@ impl CgroupView {
         tabs_map.insert(
             "General".into(),
             CgroupView {
-                tab: &*CGROUP_GENERAL_TAB,
+                tab: &CGROUP_GENERAL_TAB,
             },
         );
         tabs_map.insert(
             "CPU".into(),
             CgroupView {
-                tab: &*CGROUP_CPU_TAB,
+                tab: &CGROUP_CPU_TAB,
             },
         );
         tabs_map.insert(
             "Mem".into(),
             CgroupView {
-                tab: &*CGROUP_MEM_TAB,
+                tab: &CGROUP_MEM_TAB,
             },
         );
         tabs_map.insert(
             "I/O".into(),
             CgroupView {
-                tab: &*CGROUP_IO_TAB,
+                tab: &CGROUP_IO_TAB,
             },
         );
         tabs_map.insert(
             "Pressure".into(),
             CgroupView {
-                tab: &*CGROUP_PRESSURE_TAB,
+                tab: &CGROUP_PRESSURE_TAB,
             },
         );
         tabs_map.insert(
             "Properties".into(),
             CgroupView {
-                tab: &*CGROUP_PROPERTIES_TAB,
+                tab: &CGROUP_PROPERTIES_TAB,
             },
         );
         let user_data = c
             .user_data::<ViewState>()
             .expect("No data stored in Cursive Object!");
+        let mut cgroup_state = CgroupState::new(user_data.cgroup.clone());
+        if viewrc.collapse_cgroups == Some(true) {
+            cgroup_state.collapse_all_top_level_cgroup = true;
+        }
         StatsView::new(
             "Cgroup",
             tabs,
             tabs_map,
             list,
-            CgroupState::new(user_data.cgroup.clone()),
+            cgroup_state,
             user_data.event_controllers.clone(),
             user_data.cmd_controllers.clone(),
         )
diff --git a/below/view/src/lib.rs b/below/view/src/lib.rs
index 6f064a2e..a1c481ea 100644
--- a/below/view/src/lib.rs
+++ b/below/view/src/lib.rs
@@ -332,13 +332,9 @@ impl View {
         // Verify belowrc file format
         let cmdrc_opt = match std::fs::read_to_string(filename) {
             Ok(belowrc_str) => match belowrc_str.parse::<Value>() {
-                Ok(belowrc) => {
-                    if let Some(cmdrc) = belowrc.get(get_belowrc_cmd_section_key()) {
-                        Some(cmdrc.to_owned())
-                    } else {
-                        None
-                    }
-                }
+                Ok(belowrc) => belowrc
+                    .get(get_belowrc_cmd_section_key())
+                    .map(|cmdrc| cmdrc.to_owned()),
                 Err(e) => {
                     view_warn!(c, "Failed to parse belowrc: {}", e);
                     None
@@ -356,6 +352,8 @@ impl View {
     }
 
     pub fn run(&mut self) -> Result<()> {
+        let (viewrc, viewrc_error) = viewrc::ViewRc::new();
+
         let mut theme = self.inner.current_theme().clone();
         theme.palette[PaletteColor::Background] = Color::TerminalDefault;
         theme.palette[PaletteColor::View] = Color::TerminalDefault;
@@ -406,7 +404,7 @@ impl View {
 
         let status_bar = status_bar::new(&mut self.inner);
         let system_view = system_view::new(&mut self.inner);
-        let cgroup_view = cgroup_view::CgroupView::new(&mut self.inner);
+        let cgroup_view = cgroup_view::CgroupView::new(&mut self.inner, &viewrc);
         let process_view = process_view::ProcessView::new(&mut self.inner);
         let core_view = core_view::CoreView::new(&mut self.inner);
         #[cfg(fbcode_build)]
@@ -453,9 +451,35 @@ impl View {
             .focus_name("dynamic_view")
             .expect("Could not set focus at initialization!");
 
+        // Set default view from viewrc
+        if let Some(view) = &viewrc.default_view {
+            let main_view_state = &mut self
+                .inner
+                .user_data::<ViewState>()
+                .expect("No data stored in Cursive object!")
+                .main_view_state;
+            match view {
+                viewrc::DefaultFrontView::Cgroup => {
+                    *main_view_state = MainViewState::Cgroup;
+                    set_active_screen(&mut self.inner, "cgroup_view_panel")
+                }
+                viewrc::DefaultFrontView::Process => {
+                    *main_view_state = MainViewState::Process(ProcessZoomState::NoZoom);
+                    set_active_screen(&mut self.inner, "process_view_panel")
+                }
+                viewrc::DefaultFrontView::System => {
+                    *main_view_state = MainViewState::Core;
+                    set_active_screen(&mut self.inner, "core_view_panel")
+                }
+            }
+        }
+
         // Raise warning message if failed to map the customized command.
         Self::generate_event_controller_map(&mut self.inner, get_belowrc_filename());
-        viewrc::ViewRc::process(&mut self.inner);
+        if let Some(msg) = viewrc_error {
+            let c = &mut self.inner;
+            view_warn!(c, "{}", msg);
+        }
         if let Some(msg) = init_warnings {
             let c = &mut self.inner;
             view_warn!(c, "{}", msg);
@@ -523,7 +547,7 @@ pub mod fake_view {
         }
 
         pub fn add_cgroup_view(&mut self) {
-            let cgroup_view = CgroupView::new(&mut self.inner);
+            let cgroup_view = CgroupView::new(&mut self.inner, &Default::default());
             self.inner.add_layer(cgroup_view);
         }
 
diff --git a/below/view/src/viewrc.rs b/below/view/src/viewrc.rs
index 2875d3d0..106700ff 100644
--- a/below/view/src/viewrc.rs
+++ b/below/view/src/viewrc.rs
@@ -12,11 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use cursive::Cursive;
 use serde::Deserialize;
 
-use super::cgroup_view::CgroupView;
-use super::controllers::Controllers;
 use super::get_belowrc_filename;
 use super::get_belowrc_view_section_key;
 
@@ -45,9 +42,9 @@ pub struct ViewRc {
 impl ViewRc {
     /// Create a new ViewRc object base on the content in
     /// $HOME/.config/below/belowrc. Will return default ViewRc if the belowrc
-    /// file is missing or view section does not exists. Will raise a warning
-    /// in the command palette if the belowrc file is malformated.
-    fn new(c: &mut Cursive) -> ViewRc {
+    /// file is missing or view section does not exists. Optionally return a
+    /// parse error string.
+    pub fn new() -> (ViewRc, Option<String>) {
         match std::fs::read_to_string(get_belowrc_filename()) {
             Ok(belowrc_str) => match belowrc_str.parse::<toml::value::Value>() {
                 // We get the belowrc file, parsing the [view] section
@@ -55,141 +52,26 @@ impl ViewRc {
                     if let Some(viewrc_val) = belowrc_val.get(get_belowrc_view_section_key()) {
                         // Got the [view] section, let's see if we can deserialize it to ViewRc
                         match viewrc_val.to_owned().try_into::<ViewRc>() {
-                            Ok(viewrc) => viewrc,
-                            Err(e) => {
-                                view_warn!(
-                                    c,
+                            Ok(viewrc) => (viewrc, None),
+                            Err(e) => (
+                                Default::default(),
+                                Some(format!(
                                     "Failed to parse belowrc::{}: {}",
                                     get_belowrc_view_section_key(),
                                     e
-                                );
-                                Default::default()
-                            }
+                                )),
+                            ),
                         }
                     } else {
                         Default::default()
                     }
                 }
-                Err(e) => {
-                    view_warn!(c, "Failed to parse belowrc: {}", e);
-                    Default::default()
-                }
+                Err(e) => (
+                    Default::default(),
+                    Some(format!("Failed to parse belowrc: {}", e)),
+                ),
             },
-            _ => Default::default(),
-        }
-    }
-
-    /// Fold the top level cgroups base on the value of collapse_cgroups.
-    pub fn process_collapse_cgroups(&self, c: &mut Cursive) {
-        if Some(true) == self.collapse_cgroups {
-            let cgroup_view = CgroupView::get_cgroup_view(c);
-            cgroup_view.state.borrow_mut().collapse_all_top_level_cgroup = true;
-            cgroup_view
-                .state
-                .borrow_mut()
-                .collapsed_cgroups
-                .borrow_mut()
-                .clear();
-        }
-    }
-
-    /// Move the desired view to front base on the value of default_view
-    pub fn process_default_view(&self, c: &mut Cursive) {
-        match self.default_view {
-            Some(DefaultFrontView::Cgroup) => Controllers::Cgroup.callback::<CgroupView>(c, &[]),
-            Some(DefaultFrontView::Process) => Controllers::Process.callback::<CgroupView>(c, &[]),
-            Some(DefaultFrontView::System) => Controllers::System.callback::<CgroupView>(c, &[]),
-            None => {}
-        }
-    }
-
-    /// Syntactic sugar for processing the belowrc file.
-    pub fn process(c: &mut Cursive) {
-        let viewrc = Self::new(c);
-        viewrc.process_default_view(c);
-        viewrc.process_collapse_cgroups(c);
-        super::refresh(c);
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::fake_view::FakeView;
-    use crate::MainViewState;
-    use crate::ProcessZoomState;
-    use crate::ViewState;
-
-    #[test]
-    fn test_viewrc_collapse_cgroups() {
-        let cgroup_collapsed = |c: &mut Cursive| -> bool {
-            let cgroup_view = CgroupView::get_cgroup_view(c);
-            let res = cgroup_view.state.borrow_mut().collapse_all_top_level_cgroup;
-            res
-        };
-        let mut view = FakeView::new();
-        view.add_cgroup_view();
-
-        // Test for default setup
-        {
-            let viewrc: ViewRc = Default::default();
-            viewrc.process_collapse_cgroups(&mut view.inner);
-            assert!(!cgroup_collapsed(&mut view.inner));
-        }
-
-        // Test for collapse_cgroups = false
-        {
-            let viewrc = ViewRc {
-                collapse_cgroups: Some(false),
-                ..Default::default()
-            };
-            viewrc.process_collapse_cgroups(&mut view.inner);
-            assert!(!cgroup_collapsed(&mut view.inner));
+            _ => (Default::default(), None),
         }
-
-        // Test for collapse_cgroups = true
-        {
-            let viewrc = ViewRc {
-                collapse_cgroups: Some(true),
-                ..Default::default()
-            };
-            viewrc.process_collapse_cgroups(&mut view.inner);
-            assert!(cgroup_collapsed(&mut view.inner));
-        }
-    }
-
-    #[test]
-    fn test_viewrc_default_view() {
-        let mut view = FakeView::new();
-
-        let desired_state = vec![
-            None,
-            Some(DefaultFrontView::Cgroup),
-            Some(DefaultFrontView::Process),
-            Some(DefaultFrontView::System),
-        ];
-        let expected_state = vec![
-            MainViewState::Cgroup,
-            MainViewState::Cgroup,
-            MainViewState::Process(ProcessZoomState::NoZoom),
-            MainViewState::Core,
-        ];
-        desired_state
-            .into_iter()
-            .zip(expected_state)
-            .for_each(move |(desired, expected)| {
-                let viewrc = ViewRc {
-                    default_view: desired,
-                    ..Default::default()
-                };
-                viewrc.process_default_view(&mut view.inner);
-                let current_state = view
-                    .inner
-                    .user_data::<ViewState>()
-                    .expect("No data stored in Cursive object!")
-                    .main_view_state
-                    .clone();
-                assert_eq!(current_state, expected);
-            });
     }
 }