pogmommy/zellij
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add template section in layout file

Browse source 
It works as follows:
```
---
template:
  direction: Horizontal
  parts:
    - direction: Vertical
      split_size:
        Fixed: 1
      run:
        plugin: tab-bar
    - direction: Vertical
      body: true
    - direction: Vertical
      split_size:
        Fixed: 2
      run:
        plugin: status-bar
tabs:
  - direction: Vertical
```

The tabs are created in the body section of the template.
This commit is contained in:
a-kenji 2021-08-21 23:27:23 +02:00
parent 2e17756785
commit 88b4063879
17 changed files with 484 additions and 428 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
zellij-client/src/lib.rs
View file

@ -19,7 +19,7 @@ use zellij_utils::{
channels::{self, ChannelWithContext, SenderWithContext},
consts::{SESSION_NAME, ZELLIJ_IPC_PIPE},
errors::{ClientContext, ContextType, ErrorInstruction},
input::{actions::Action, config::Config, layout::MainLayout, options::Options},
input::{actions::Action, config::Config, layout::LayoutTemplate, options::Options},
ipc::{ClientAttributes, ClientToServerMsg, ExitReason, ServerToClientMsg},
};
@ -87,7 +87,7 @@ pub fn start_client(
opts: CliArgs,
config: Config,
info: ClientInfo,
layout: Option<MainLayout>,
layout: Option<LayoutTemplate>,
) {
info!("Starting Zellij client!");
let clear_client_terminal_attributes = "\u{1b}[?1l\u{1b}=\u{1b}[r\u{1b}12l\u{1b}[?1000l\u{1b}[?1002l\u{1b}[?1003l\u{1b}[?1005l\u{1b}[?1006l\u{1b}[?12l";

6
zellij-server/src/lib.rs
View file

@ -36,7 +36,7 @@ use zellij_utils::{
input::{
command::{RunCommand, TerminalAction},
get_mode_info,
layout::MainLayout,
layout::LayoutTemplate,
options::Options,
},
ipc::{ClientAttributes, ClientToServerMsg, ExitReason, ServerToClientMsg},
@ -50,7 +50,7 @@ pub(crate) enum ServerInstruction {
ClientAttributes,
Box<CliArgs>,
Box<Options>,
Option<MainLayout>,
Option<LayoutTemplate>,
),
Render(Option<String>),
UnblockInputThread,
@ -329,7 +329,7 @@ fn init_session(
to_server: SenderWithContext<ServerInstruction>,
client_attributes: ClientAttributes,
session_state: Arc<RwLock<SessionState>>,
layout: Option<MainLayout>,
layout: Option<LayoutTemplate>,
) -> SessionMetaData {
let (to_screen, screen_receiver): ChannelWithContext<ScreenInstruction> = channels::unbounded();
let to_screen = SenderWithContext::new(to_screen);

4
zellij-server/src/pty.rs
View file

@ -20,7 +20,7 @@ use zellij_utils::{
errors::{get_current_ctx, ContextType, PtyContext},
input::{
command::TerminalAction,
layout::{Layout, MainLayout, Run, TabLayout},
layout::{Layout, LayoutTemplate, Run, TabLayout},
},
logging::debug_to_file,
};
@ -60,7 +60,7 @@ pub(crate) struct Pty {
task_handles: HashMap<RawFd, JoinHandle<()>>,
}
pub(crate) fn pty_thread_main(mut pty: Pty, maybe_layout: Option<MainLayout>) {
pub(crate) fn pty_thread_main(mut pty: Pty, maybe_layout: Option<LayoutTemplate>) {
loop {
let (event, mut err_ctx) = pty.bus.recv().expect("failed to receive event on channel");
err_ctx.add_call(ContextType::Pty((&event).into()));

30
zellij-utils/assets/layouts/default.yaml
View file

@ -1,16 +1,18 @@
---
direction: Horizontal
parts:
template:
direction: Horizontal
parts:
- direction: Vertical
split_size:
Fixed: 1
run:
plugin: tab-bar
- direction: Vertical
body: true
- direction: Vertical
split_size:
Fixed: 2
run:
plugin: status-bar
tabs:
- direction: Vertical
split_size:
Fixed: 1
run:
plugin: tab-bar
- direction: Vertical
tabs:
- direction: Vertical
- direction: Vertical
split_size:
Fixed: 2
run:
plugin: status-bar

20
zellij-utils/assets/layouts/disable-status-bar.yaml
View file

@ -1,11 +1,11 @@
---
direction: Horizontal
parts:
- direction: Vertical
split_size:
Fixed: 1
run:
plugin: tab-bar
- direction: Vertical
tabs:
- direction: Vertical
template:
direction: Horizontal
parts:
- direction: Vertical
split_size:
Fixed: 1
run:
plugin: tab-bar
- direction: Vertical
body: true

44
zellij-utils/assets/layouts/strider.yaml
View file

@ -1,23 +1,25 @@
---
direction: Horizontal
parts:
template:
direction: Horizontal
parts:
- direction: Vertical
split_size:
Fixed: 1
run:
plugin: tab-bar
- direction: Vertical
body: true
- direction: Vertical
split_size:
Fixed: 2
run:
plugin: status-bar
tabs:
- direction: Vertical
split_size:
Fixed: 1
run:
plugin: tab-bar
- direction: Vertical
tabs:
- direction: Vertical
parts:
- direction: Horizontal
split_size:
Percent: 20
run:
plugin: strider
- direction: Horizontal
- direction: Vertical
split_size:
Fixed: 2
run:
plugin: status-bar
parts:
- direction: Horizontal
split_size:
Percent: 20
run:
plugin: strider
- direction: Horizontal

272
zellij-utils/src/input/layout.rs
View file

@ -58,6 +58,159 @@ pub struct Layout {
pub run: Option<Run>,
}
// The struct that is used to deserialize the layout from
// a yaml configuration file
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
#[serde(crate = "self::serde")]
pub struct LayoutFromYaml {
//#[serde(default)]
pub template: LayoutTemplateFromYaml,
#[serde(default)]
pub tabs: Vec<TabLayout>,
}
type LayoutFromYamlResult = Result<LayoutFromYaml, ConfigError>;
impl LayoutFromYaml {
pub fn new(layout_path: &Path) -> LayoutFromYamlResult {
let mut layout_file = File::open(&layout_path)
.or_else(|_| File::open(&layout_path.with_extension("yaml")))
.map_err(|e| ConfigError::IoPath(e, layout_path.into()))?;
let mut layout = String::new();
layout_file.read_to_string(&mut layout)?;
let layout: LayoutFromYaml = serde_yaml::from_str(&layout)?;
Ok(layout)
}
// It wants to use Path here, but that doesn't compile.
#[allow(clippy::ptr_arg)]
pub fn from_dir(layout: &PathBuf, layout_dir: Option<&PathBuf>) -> LayoutFromYamlResult {
match layout_dir {
Some(dir) => Self::new(&dir.join(layout))
.or_else(|_| Self::from_default_assets(layout.as_path())),
None => Self::from_default_assets(layout.as_path()),
}
}
pub fn from_path_or_default(
layout: Option<&PathBuf>,
layout_path: Option<&PathBuf>,
layout_dir: Option<PathBuf>,
) -> Option<LayoutFromYamlResult> {
layout
.map(|p| LayoutFromYaml::from_dir(p, layout_dir.as_ref()))
.or_else(|| layout_path.map(|p| LayoutFromYaml::new(p)))
.or_else(|| {
Some(LayoutFromYaml::from_dir(
&std::path::PathBuf::from("default"),
layout_dir.as_ref(),
))
})
}
pub fn construct_layout_template(&self) -> LayoutTemplate {
let (pre_tab, post_tab) = self.template.split_template().unwrap();
LayoutTemplate {
pre_tab: pre_tab.into(),
post_tab: Layout::from_vec_template_layout(post_tab),
tabs: self.tabs.clone(),
}
}
// Currently still needed but on nightly
// this is already possible:
// HashMap<&'static str, Vec<u8>>
pub fn from_default_assets(path: &Path) -> LayoutFromYamlResult {
match path.to_str() {
Some("default") => Self::default_from_assets(),
Some("strider") => Self::strider_from_assets(),
Some("disable-status-bar") => Self::disable_status_from_assets(),
None | Some(_) => Err(ConfigError::IoPath(
std::io::Error::new(std::io::ErrorKind::Other, "The layout was not found"),
path.into(),
)),
}
}
// TODO Deserialize the assets from bytes &[u8],
// once serde-yaml supports zero-copy
pub fn default_from_assets() -> LayoutFromYamlResult {
let layout: LayoutFromYaml =
serde_yaml::from_str(String::from_utf8(setup::DEFAULT_LAYOUT.to_vec())?.as_str())?;
Ok(layout)
}
pub fn strider_from_assets() -> LayoutFromYamlResult {
let layout: LayoutFromYaml =
serde_yaml::from_str(String::from_utf8(setup::STRIDER_LAYOUT.to_vec())?.as_str())?;
Ok(layout)
}
pub fn disable_status_from_assets() -> LayoutFromYamlResult {
let layout: LayoutFromYaml =
serde_yaml::from_str(String::from_utf8(setup::NO_STATUS_LAYOUT.to_vec())?.as_str())?;
Ok(layout)
}
}
// The struct that carries the information template that is used to
// construct the layout
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
#[serde(crate = "self::serde")]
pub struct LayoutTemplateFromYaml {
pub direction: Direction,
#[serde(default)]
pub parts: Vec<LayoutTemplateFromYaml>,
#[serde(default)]
pub body: bool,
pub split_size: Option<SplitSize>,
pub run: Option<Run>,
}
impl LayoutTemplateFromYaml {
// Split the layout into parts that can be reassebled per tab
// returns the layout pre tab and the parts post tab
pub fn split_template(
&self,
) -> Result<(LayoutTemplateFromYaml, Vec<LayoutTemplateFromYaml>), LayoutPartAndTabError> {
let mut main_layout = self.clone();
let mut pre_tab_layout = self.clone();
let mut post_tab_layout = vec![];
let mut post_tab = false;
pre_tab_layout.parts.clear();
if main_layout.body {
post_tab = true;
}
for part in main_layout.parts.drain(..) {
let (curr_pre_layout, mut curr_post_layout) = part.split_template()?;
// Leaf
if !post_tab && !part.body {
pre_tab_layout.parts.push(curr_pre_layout);
}
// Node
if part.body {
post_tab = true;
// Leaf
} else if post_tab {
if curr_post_layout.is_empty() {
let mut part_no_tab = part.clone();
part_no_tab.parts.clear();
post_tab_layout.push(part_no_tab);
} else {
post_tab_layout.append(&mut curr_post_layout);
}
}
}
Ok((pre_tab_layout, post_tab_layout))
}
}
// The tab-layout struct used to specify each individual tab.
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
#[serde(crate = "self::serde")]
@ -69,17 +222,17 @@ pub struct TabLayout {
pub run: Option<Run>,
}
// Main layout struct, that carries information based on position of tabs
// in relation to the whole layout.
// Main template layout struct, that carries information based on position of
// tabs in relation to the whole layout.
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
#[serde(crate = "self::serde")]
pub struct MainLayout {
pub struct LayoutTemplate {
pub pre_tab: Layout,
pub post_tab: Vec<Layout>,
pub tabs: Vec<TabLayout>,
}
impl MainLayout {
impl LayoutTemplate {
pub fn construct_tab_layout(&self, tab_layout: Option<TabLayout>) -> Layout {
if let Some(tab_layout) = tab_layout {
let mut pre_tab_layout = self.pre_tab.clone();
@ -98,81 +251,7 @@ impl MainLayout {
}
}
type LayoutResult = Result<Layout, ConfigError>;
impl Layout {
pub fn new(layout_path: &Path) -> LayoutResult {
let mut layout_file = File::open(&layout_path)
.or_else(|_| File::open(&layout_path.with_extension("yaml")))
.map_err(|e| ConfigError::IoPath(e, layout_path.into()))?;
let mut layout = String::new();
layout_file.read_to_string(&mut layout)?;
let layout: Layout = serde_yaml::from_str(&layout)?;
Ok(layout)
}
// It wants to use Path here, but that doesn't compile.
#[allow(clippy::ptr_arg)]
pub fn from_dir(layout: &PathBuf, layout_dir: Option<&PathBuf>) -> LayoutResult {
match layout_dir {
Some(dir) => Self::new(&dir.join(layout))
.or_else(|_| Self::from_default_assets(layout.as_path())),
None => Self::from_default_assets(layout.as_path()),
}
}
pub fn from_path_or_default(
layout: Option<&PathBuf>,
layout_path: Option<&PathBuf>,
layout_dir: Option<PathBuf>,
) -> Option<Result<Layout, ConfigError>> {
layout
.map(|p| Layout::from_dir(p, layout_dir.as_ref()))
.or_else(|| layout_path.map(|p| Layout::new(p)))
.or_else(|| {
Some(Layout::from_dir(
&std::path::PathBuf::from("default"),
layout_dir.as_ref(),
))
})
}
// Currently still needed but on nightly
// this is already possible:
// HashMap<&'static str, Vec<u8>>
pub fn from_default_assets(path: &Path) -> LayoutResult {
match path.to_str() {
Some("default") => Self::default_from_assets(),
Some("strider") => Self::strider_from_assets(),
Some("disable-status-bar") => Self::disable_status_from_assets(),
None | Some(_) => Err(ConfigError::IoPath(
std::io::Error::new(std::io::ErrorKind::Other, "The layout was not found"),
path.into(),
)),
}
}
// TODO Deserialize the assets from bytes &[u8],
// once serde-yaml supports zero-copy
pub fn default_from_assets() -> LayoutResult {
let layout: Layout =
serde_yaml::from_str(String::from_utf8(setup::DEFAULT_LAYOUT.to_vec())?.as_str())?;
Ok(layout)
}
pub fn strider_from_assets() -> LayoutResult {
let layout: Layout =
serde_yaml::from_str(String::from_utf8(setup::STRIDER_LAYOUT.to_vec())?.as_str())?;
Ok(layout)
}
pub fn disable_status_from_assets() -> LayoutResult {
let layout: Layout =
serde_yaml::from_str(String::from_utf8(setup::NO_STATUS_LAYOUT.to_vec())?.as_str())?;
Ok(layout)
}
pub fn total_terminal_panes(&self) -> usize {
let mut total_panes = 0;
total_panes += self.parts.len();
@ -273,28 +352,14 @@ impl Layout {
self.parts.append(&mut parts);
}
pub fn construct_full_layout(&self, tab_layout: Option<TabLayout>) -> Self {
// The `split_main_and_tab_layout()` error should have returned
// already from deserialisation, so we can assume it is `Ok()`.
let (mut pre_tab_layout, post_tab_layout, _) = self.split_main_and_tab_layout().unwrap();
if let Some(tab_layout) = tab_layout {
pre_tab_layout.merge_tab_layout(tab_layout);
} else {
let default_tab_layout = TabLayout::default();
pre_tab_layout.merge_tab_layout(default_tab_layout);
}
pre_tab_layout.merge_layout_parts(post_tab_layout);
pre_tab_layout
}
pub fn construct_main_layout(&self) -> Result<MainLayout, ConfigError> {
pub fn construct_layout_template(&self) -> Result<LayoutTemplate, ConfigError> {
let (pre_tab, post_tab, tabs) = self.split_main_and_tab_layout()?;
if tabs.is_empty() {
return Err(ConfigError::Layout(LayoutMissingTabSectionError));
}
Ok(MainLayout {
Ok(LayoutTemplate {
pre_tab,
post_tab,
tabs,
@ -307,6 +372,13 @@ impl Layout {
.map(|tab_layout| Layout::from(tab_layout.to_owned()))
.collect()
}
fn from_vec_template_layout(layout_template: Vec<LayoutTemplateFromYaml>) -> Vec<Self> {
layout_template
.iter()
.map(|layout_template| Layout::from(layout_template.to_owned()))
.collect()
}
}
fn split_space_to_parts_vertically(
@ -474,6 +546,18 @@ impl From<TabLayout> for Layout {
}
}
impl From<LayoutTemplateFromYaml> for Layout {
fn from(template: LayoutTemplateFromYaml) -> Self {
Layout {
direction: template.direction,
parts: Layout::from_vec_template_layout(template.parts),
tabs: vec![],
split_size: template.split_size,
run: template.run,
}
}
}
impl Default for TabLayout {
fn default() -> Self {
Self {

79
zellij-utils/src/input/unit/fixtures/layouts/deeply-nested-tab-layout.yaml
View file

@ -1,40 +1,43 @@
---
direction: Horizontal
parts:
- direction: Vertical
parts:
- direction: Horizontal
split_size:
Percent: 21
- direction: Vertical
split_size:
Percent: 79
parts:
- direction: Horizontal
split_size:
Percent: 22
- direction: Horizontal
split_size:
Percent: 78
parts:
- direction: Horizontal
split_size:
Percent: 23
- direction: Vertical
split_size:
Percent: 77
tabs:
- direction: Horizontal
split_size:
Percent: 24
template:
direction: Horizontal
parts:
- direction: Vertical
parts:
- direction: Horizontal
split_size:
Percent: 21
- direction: Vertical
split_size:
Percent: 79
parts:
- direction: Horizontal
split_size:
Percent: 22
- direction: Horizontal
split_size:
Percent: 78
parts:
- direction: Horizontal
split_size:
Percent: 23
- direction: Vertical
split_size:
Percent: 77
body: true
split_size:
Percent: 90
- direction: Vertical
split_size:
Percent: 15
- direction: Vertical
split_size:
Percent: 15
- direction: Vertical
split_size:
Percent: 15
tabs:
- direction: Horizontal
split_size:
Percent: 90
- direction: Vertical
split_size:
Percent: 15
- direction: Vertical
split_size:
Percent: 15
- direction: Vertical
split_size:
Percent: 15
Percent: 24

18
zellij-utils/src/input/unit/fixtures/layouts/no-tabs-should-error.yaml
View file

@ -1,18 +0,0 @@
---
direction: Horizontal
parts:
- direction: Horizontal
parts:
- direction: Vertical
parts:
- direction: Horizontal
split_size:
Percent: 50
- direction: Horizontal
parts:
- direction: Vertical
split_size:
Percent: 50
- direction: Vertical
split_size:
Percent: 50

17
zellij-utils/src/input/unit/fixtures/layouts/tabs-and-parts-together-should-error.yaml
View file

@ -1,17 +0,0 @@
---
direction: Horizontal
parts:
- direction: Horizontal
tabs:
- direction: Vertical
parts:
- direction: Horizontal
split_size:
Percent: 50
parts:
- direction: Vertical
split_size:
Percent: 50
- direction: Vertical
split_size:
Percent: 50

57
zellij-utils/src/input/unit/fixtures/layouts/three-panes-with-tab-and-command.yaml
View file

@ -1,32 +1,35 @@
---
direction: Horizontal
parts:
template:
direction: Horizontal
parts:
- direction: Vertical
split_size:
Fixed: 1
run:
plugin: tab-bar
- direction: Horizontal
body: true
- direction: Vertical
split_size:
Fixed: 2
run:
plugin: status-bar
tabs:
- direction: Vertical
split_size:
Fixed: 1
run:
plugin: tab-bar
- direction: Horizontal
tabs:
- direction: Vertical
parts:
- direction: Horizontal
split_size:
Percent: 50
- direction: Horizontal
parts:
- direction: Horizontal
- direction: Vertical
split_size:
Percent: 50
- direction: Horizontal
parts:
- direction: Vertical
split_size:
Percent: 50
run:
command: {cmd: htop}
- direction: Vertical
split_size:
Percent: 50
run:
command: {cmd: htop, args: ["-C"]}
- direction: Vertical
split_size:
Fixed: 2
run:
plugin: status-bar
run:
command: {cmd: htop}
- direction: Vertical
split_size:
Percent: 50
run:
command: {cmd: htop, args: ["-C"]}

49
zellij-utils/src/input/unit/fixtures/layouts/three-panes-with-tab-and-default-plugins.yaml
View file

@ -1,28 +1,31 @@
---
direction: Horizontal
parts:
template:
direction: Horizontal
parts:
- direction: Vertical
split_size:
Fixed: 1
run:
plugin: tab-bar
- direction: Horizontal
body: true
- direction: Vertical
split_size:
Fixed: 2
run:
plugin: status-bar
tabs:
- direction: Vertical
split_size:
Fixed: 1
run:
plugin: tab-bar
- direction: Horizontal
tabs:
- direction: Vertical
parts:
- direction: Horizontal
split_size:
Percent: 50
- direction: Horizontal
parts:
- direction: Horizontal
- direction: Vertical
split_size:
Percent: 50
- direction: Vertical
split_size:
Percent: 50
- direction: Horizontal
parts:
- direction: Vertical
split_size:
Percent: 50
- direction: Vertical
split_size:
Percent: 50
- direction: Vertical
split_size:
Fixed: 2
run:
plugin: status-bar

31
zellij-utils/src/input/unit/fixtures/layouts/three-panes-with-tab.yaml
View file

@ -1,18 +1,21 @@
---
direction: Horizontal
parts:
- direction: Horizontal
tabs:
- direction: Vertical
template:
direction: Horizontal
parts:
- direction: Horizontal
body: true
tabs:
- direction: Vertical
parts:
- direction: Horizontal
split_size:
Percent: 50
- direction: Horizontal
parts:
- direction: Horizontal
- direction: Vertical
split_size:
Percent: 50
- direction: Vertical
split_size:
Percent: 50
- direction: Horizontal
parts:
- direction: Vertical
split_size:
Percent: 50
- direction: Vertical
split_size:
Percent: 50

36
zellij-utils/src/input/unit/fixtures/layouts/three-tabs-merged-correctly.yaml
View file

@ -1,25 +1,29 @@
---
direction: Vertical
parts:
template:
direction: Vertical
parts:
- direction: Horizontal
body: true
- direction: Horizontal
tabs:
- direction: Horizontal
tabs:
split_size:
Percent: 50
- direction: Horizontal
split_size:
Percent: 50
parts:
- direction: Horizontal
split_size:
Percent: 50
- direction: Horizontal
split_size:
Percent: 50
parts:
- direction: Horizontal
split_size:
Percent: 50
- direction: Horizontal
- direction: Vertical
split_size:
Percent: 50
parts:
- direction: Vertical
split_size:
Percent: 50
parts:
- direction: Vertical
split_size:
Percent: 50
- direction: Horizontal
- direction: Horizontal
- direction: Horizontal

225
zellij-utils/src/input/unit/layout_test.rs
View file

@ -15,40 +15,43 @@ fn default_layout_dir(layout: String) -> PathBuf {
#[test]
fn default_layout_is_ok() {
let path = default_layout_dir("default.yaml".into());
let layout = Layout::new(&path);
let layout = LayoutFromYaml::new(&path);
assert!(layout.is_ok());
}
#[test]
fn default_layout_has_one_tab() {
let path = default_layout_dir("default.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.as_ref().unwrap().construct_main_layout().unwrap();
assert_eq!(main_layout.tabs.len(), 1);
let layout = LayoutFromYaml::new(&path);
let layout_template = layout.as_ref().unwrap().construct_layout_template();
assert_eq!(layout_template.tabs.len(), 1);
}
#[test]
fn default_layout_has_one_pre_tab() {
let path = default_layout_dir("default.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.as_ref().unwrap().construct_main_layout().unwrap();
assert_eq!(main_layout.pre_tab.parts.len(), 1);
let layout = LayoutFromYaml::new(&path);
let layout_template = layout.as_ref().unwrap().construct_layout_template();
assert_eq!(layout_template.pre_tab.parts.len(), 1);
}
#[test]
fn default_layout_has_one_post_tab() {
let path = default_layout_dir("default.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.as_ref().unwrap().construct_main_layout().unwrap();
assert_eq!(main_layout.post_tab.len(), 1);
let layout = LayoutFromYaml::new(&path);
let layout_template = layout.as_ref().unwrap().construct_layout_template();
assert_eq!(layout_template.post_tab.len(), 1);
}
#[test]
fn default_layout_merged_correctly() {
let path = default_layout_dir("default.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.as_ref().unwrap().construct_main_layout().unwrap();
let tab_layout = main_layout.construct_tab_layout(Some(main_layout.tabs[0].clone()));
let layout_from_yaml = LayoutFromYaml::new(&path);
let layout_template = layout_from_yaml
.as_ref()
.unwrap()
.construct_layout_template();
let tab_layout = layout_template.construct_tab_layout(Some(layout_template.tabs[0].clone()));
let merged_layout = Layout {
direction: Direction::Horizontal,
parts: vec![
@ -84,9 +87,12 @@ fn default_layout_merged_correctly() {
#[test]
fn default_layout_new_tab_correct() {
let path = default_layout_dir("default.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.as_ref().unwrap().construct_main_layout().unwrap();
let tab_layout = main_layout.construct_tab_layout(None);
let layout_from_yaml = LayoutFromYaml::new(&path);
let layout_template = layout_from_yaml
.as_ref()
.unwrap()
.construct_layout_template();
let tab_layout = layout_template.construct_tab_layout(None);
let merged_layout = Layout {
direction: Direction::Horizontal,
parts: vec![
@ -122,78 +128,84 @@ fn default_layout_new_tab_correct() {
#[test]
fn default_strider_layout_is_ok() {
let path = default_layout_dir("strider.yaml".into());
let layout = Layout::new(&path);
assert!(layout.is_ok());
let layout_from_yaml = LayoutFromYaml::new(&path);
assert!(layout_from_yaml.is_ok());
}
#[test]
fn default_disable_status_layout_is_ok() {
let path = default_layout_dir("disable-status-bar.yaml".into());
let layout = Layout::new(&path);
assert!(layout.is_ok());
let layout_from_yaml = LayoutFromYaml::new(&path);
assert!(layout_from_yaml.is_ok());
}
#[test]
fn default_disable_status_layout_has_one_tab() {
fn default_disable_status_layout_has_no_tab() {
let path = default_layout_dir("disable-status-bar.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.as_ref().unwrap().construct_main_layout().unwrap();
assert_eq!(main_layout.tabs.len(), 1);
let layout_from_yaml = LayoutFromYaml::new(&path);
let layout_template = layout_from_yaml
.as_ref()
.unwrap()
.construct_layout_template();
assert_eq!(layout_template.tabs.len(), 0);
}
#[test]
fn default_disable_status_layout_has_one_pre_tab() {
let path = default_layout_dir("disable-status-bar.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.as_ref().unwrap().construct_main_layout().unwrap();
assert_eq!(main_layout.pre_tab.parts.len(), 1);
let layout_from_yaml = LayoutFromYaml::new(&path);
let layout_template = layout_from_yaml
.as_ref()
.unwrap()
.construct_layout_template();
assert_eq!(layout_template.pre_tab.parts.len(), 1);
}
#[test]
fn default_disable_status_layout_has_no_post_tab() {
let path = default_layout_dir("disable-status-bar.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.as_ref().unwrap().construct_main_layout().unwrap();
assert!(main_layout.post_tab.is_empty());
let layout = LayoutFromYaml::new(&path);
let layout_template = layout.as_ref().unwrap().construct_layout_template();
assert!(layout_template.post_tab.is_empty());
}
#[test]
fn three_panes_with_tab_is_ok() {
let path = layout_test_dir("three-panes-with-tab.yaml".into());
let layout = Layout::new(&path);
let layout = LayoutFromYaml::new(&path);
assert!(layout.is_ok());
}
#[test]
fn three_panes_with_tab_has_one_tab() {
let path = layout_test_dir("three-panes-with-tab.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.unwrap().construct_main_layout().unwrap();
assert_eq!(main_layout.tabs.len(), 1);
let layout = LayoutFromYaml::new(&path);
let layout_template = layout.unwrap().construct_layout_template();
assert_eq!(layout_template.tabs.len(), 1);
}
#[test]
fn three_panes_with_tab_no_post_tab() {
let path = layout_test_dir("three-panes-with-tab.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.unwrap().construct_main_layout().unwrap();
assert!(main_layout.post_tab.is_empty());
let layout = LayoutFromYaml::new(&path);
let layout_template = layout.unwrap().construct_layout_template();
assert!(layout_template.post_tab.is_empty());
}
#[test]
fn three_panes_with_tab_no_pre_tab() {
let path = layout_test_dir("three-panes-with-tab.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.unwrap().construct_main_layout().unwrap();
assert!(main_layout.pre_tab.parts.is_empty());
let layout = LayoutFromYaml::new(&path);
let layout_template = layout.unwrap().construct_layout_template();
assert!(layout_template.pre_tab.parts.is_empty());
}
#[test]
fn three_panes_with_tab_merged_correctly() {
let path = layout_test_dir("three-panes-with-tab.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.as_ref().unwrap().construct_main_layout().unwrap();
let tab_layout = main_layout.construct_tab_layout(Some(main_layout.tabs[0].clone()));
let layout = LayoutFromYaml::new(&path);
let layout_template = layout.as_ref().unwrap().construct_layout_template();
let tab_layout = layout_template.construct_tab_layout(Some(layout_template.tabs[0].clone()));
let merged_layout = Layout {
direction: Direction::Horizontal,
parts: vec![Layout {
@ -243,9 +255,9 @@ fn three_panes_with_tab_merged_correctly() {
#[test]
fn three_panes_with_tab_new_tab_is_correct() {
let path = layout_test_dir("three-panes-with-tab.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.as_ref().unwrap().construct_main_layout().unwrap();
let tab_layout = main_layout.construct_tab_layout(None);
let layout = LayoutFromYaml::new(&path);
let layout_template = layout.as_ref().unwrap().construct_layout_template();
let tab_layout = layout_template.construct_tab_layout(None);
let merged_layout = Layout {
direction: Direction::Horizontal,
parts: vec![Layout {
@ -265,40 +277,40 @@ fn three_panes_with_tab_new_tab_is_correct() {
#[test]
fn three_panes_with_tab_and_default_plugins_is_ok() {
let path = layout_test_dir("three-panes-with-tab-and-default-plugins.yaml".into());
let layout = Layout::new(&path);
let layout = LayoutFromYaml::new(&path);
assert!(layout.is_ok());
}
#[test]
fn three_panes_with_tab_and_default_plugins_has_one_tab() {
let path = layout_test_dir("three-panes-with-tab-and-default-plugins.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.unwrap().construct_main_layout().unwrap();
assert_eq!(main_layout.tabs.len(), 1);
let layout = LayoutFromYaml::new(&path);
let layout_template = layout.unwrap().construct_layout_template();
assert_eq!(layout_template.tabs.len(), 1);
}
#[test]
fn three_panes_with_tab_and_default_plugins_one_post_tab() {
let path = layout_test_dir("three-panes-with-tab-and-default-plugins.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.unwrap().construct_main_layout().unwrap();
assert_eq!(main_layout.post_tab.len(), 1);
let layout = LayoutFromYaml::new(&path);
let layout_template = layout.unwrap().construct_layout_template();
assert_eq!(layout_template.post_tab.len(), 1);
}
#[test]
fn three_panes_with_tab_and_default_plugins_has_pre_tab() {
let path = layout_test_dir("three-panes-with-tab-and-default-plugins.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.unwrap().construct_main_layout().unwrap();
assert!(!main_layout.pre_tab.parts.is_empty());
let layout = LayoutFromYaml::new(&path);
let layout_template = layout.unwrap().construct_layout_template();
assert!(!layout_template.pre_tab.parts.is_empty());
}
#[test]
fn three_panes_with_tab_and_default_plugins_merged_correctly() {
let path = layout_test_dir("three-panes-with-tab-and-default-plugins.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.as_ref().unwrap().construct_main_layout().unwrap();
let tab_layout = main_layout.construct_tab_layout(Some(main_layout.tabs[0].clone()));
let layout = LayoutFromYaml::new(&path);
let layout_template = layout.as_ref().unwrap().construct_layout_template();
let tab_layout = layout_template.construct_tab_layout(Some(layout_template.tabs[0].clone()));
let merged_layout = Layout {
direction: Direction::Horizontal,
parts: vec![
@ -364,9 +376,9 @@ fn three_panes_with_tab_and_default_plugins_merged_correctly() {
#[test]
fn three_panes_with_tab_and_default_plugins_new_tab_is_correct() {
let path = layout_test_dir("three-panes-with-tab-and-default-plugins.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.as_ref().unwrap().construct_main_layout().unwrap();
let tab_layout = main_layout.construct_tab_layout(None);
let layout = LayoutFromYaml::new(&path);
let layout_template = layout.as_ref().unwrap().construct_layout_template();
let tab_layout = layout_template.construct_tab_layout(None);
let merged_layout = Layout {
direction: Direction::Horizontal,
parts: vec![
@ -402,40 +414,40 @@ fn three_panes_with_tab_and_default_plugins_new_tab_is_correct() {
#[test]
fn deeply_nested_tab_is_ok() {
let path = layout_test_dir("deeply-nested-tab-layout.yaml".into());
let layout = Layout::new(&path);
let layout = LayoutFromYaml::new(&path);
assert!(layout.is_ok());
}
#[test]
fn deeply_nested_tab_has_one_tab() {
let path = layout_test_dir("deeply-nested-tab-layout.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.unwrap().construct_main_layout().unwrap();
assert_eq!(main_layout.tabs.len(), 1);
let layout = LayoutFromYaml::new(&path);
let layout_template = layout.unwrap().construct_layout_template();
assert_eq!(layout_template.tabs.len(), 1);
}
#[test]
fn deeply_nested_tab_three_post_tab() {
let path = layout_test_dir("deeply-nested-tab-layout.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.unwrap().construct_main_layout().unwrap();
assert_eq!(main_layout.post_tab.len(), 3);
let layout = LayoutFromYaml::new(&path);
let layout_template = layout.unwrap().construct_layout_template();
assert_eq!(layout_template.post_tab.len(), 3);
}
#[test]
fn deeply_nested_tab_has_many_pre_tab() {
let path = layout_test_dir("deeply-nested-tab-layout.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.unwrap().construct_main_layout().unwrap();
assert!(!main_layout.pre_tab.parts.is_empty());
let layout = LayoutFromYaml::new(&path);
let layout_template = layout.unwrap().construct_layout_template();
assert!(!layout_template.pre_tab.parts.is_empty());
}
#[test]
fn deeply_nested_tab_merged_correctly() {
let path = layout_test_dir("deeply-nested-tab-layout.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.as_ref().unwrap().construct_main_layout().unwrap();
let tab_layout = main_layout.construct_tab_layout(Some(main_layout.tabs[0].clone()));
let layout = LayoutFromYaml::new(&path);
let layout_template = layout.as_ref().unwrap().construct_layout_template();
let tab_layout = layout_template.construct_tab_layout(Some(layout_template.tabs[0].clone()));
let merged_layout = Layout {
direction: Direction::Horizontal,
parts: vec![
@ -518,58 +530,38 @@ fn deeply_nested_tab_merged_correctly() {
assert_eq!(merged_layout, tab_layout);
}
#[test]
fn no_tabs_specified_should_err() {
let path = layout_test_dir("no-tabs-should-error.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.unwrap().construct_main_layout();
assert!(main_layout.is_err());
}
#[test]
fn tabs_and_parts_specified_together_should_should_err() {
let path = layout_test_dir("tabs-and-parts-together-should-error.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.unwrap().construct_main_layout();
assert!(main_layout.is_err());
}
#[test]
fn multiple_tabs_specified_should_not_err() {
let path = layout_test_dir("multiple-tabs-should-not-error.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.unwrap().construct_main_layout();
assert!(main_layout.is_ok())
}
#[test]
fn three_tabs_is_ok() {
let path = layout_test_dir("three-tabs-merged-correctly.yaml".into());
let layout = Layout::new(&path);
assert!(layout.is_ok());
let layout_from_yaml = LayoutFromYaml::new(&path);
assert!(layout_from_yaml.is_ok());
}
#[test]
fn three_tabs_has_three_tabs() {
let path = layout_test_dir("three-tabs-merged-correctly.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.unwrap().construct_main_layout().unwrap();
assert_eq!(main_layout.tabs.len(), 3);
let layout_from_yaml = LayoutFromYaml::new(&path);
let layout_template = layout_from_yaml.unwrap().construct_layout_template();
assert_eq!(layout_template.tabs.len(), 3);
}
#[test]
fn three_tabs_has_one_post_tab() {
let path = layout_test_dir("three-tabs-merged-correctly.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.unwrap().construct_main_layout().unwrap();
assert_eq!(main_layout.post_tab.len(), 1);
let layout_from_yaml = LayoutFromYaml::new(&path);
let layout_template = layout_from_yaml.unwrap().construct_layout_template();
assert_eq!(layout_template.post_tab.len(), 1);
}
#[test]
fn three_tabs_tab_one_merged_correctly() {
let path = layout_test_dir("three-tabs-merged-correctly.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.as_ref().unwrap().construct_main_layout().unwrap();
let tab_layout = main_layout.construct_tab_layout(Some(main_layout.tabs[0].clone()));
let layout_from_yaml = LayoutFromYaml::new(&path);
let layout_template = layout_from_yaml
.as_ref()
.unwrap()
.construct_layout_template();
let tab_layout = layout_template.construct_tab_layout(Some(layout_template.tabs[0].clone()));
let merged_layout = Layout {
direction: Direction::Vertical,
parts: vec![
@ -599,9 +591,12 @@ fn three_tabs_tab_one_merged_correctly() {
#[test]
fn three_tabs_tab_two_merged_correctly() {
let path = layout_test_dir("three-tabs-merged-correctly.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.as_ref().unwrap().construct_main_layout().unwrap();
let tab_layout = main_layout.construct_tab_layout(Some(main_layout.tabs[1].clone()));
let layout_from_yaml = LayoutFromYaml::new(&path);
let layout_template = layout_from_yaml
.as_ref()
.unwrap()
.construct_layout_template();
let tab_layout = layout_template.construct_tab_layout(Some(layout_template.tabs[1].clone()));
let merged_layout = Layout {
direction: Direction::Vertical,
parts: vec![
@ -646,9 +641,9 @@ fn three_tabs_tab_two_merged_correctly() {
#[test]
fn three_tabs_tab_three_merged_correctly() {
let path = layout_test_dir("three-tabs-merged-correctly.yaml".into());
let layout = Layout::new(&path);
let main_layout = layout.as_ref().unwrap().construct_main_layout().unwrap();
let tab_layout = main_layout.construct_tab_layout(Some(main_layout.tabs[2].clone()));
let layout = LayoutFromYaml::new(&path);
let layout_template = layout.as_ref().unwrap().construct_layout_template();
let tab_layout = layout_template.construct_tab_layout(Some(layout_template.tabs[2].clone()));
let merged_layout = Layout {
direction: Direction::Vertical,
parts: vec![

4
zellij-utils/src/ipc.rs
View file

@ -3,7 +3,7 @@
use crate::{
cli::CliArgs,
errors::{get_current_ctx, ErrorContext},
input::{actions::Action, layout::MainLayout, options::Options},
input::{actions::Action, layout::LayoutTemplate, options::Options},
pane_size::PositionAndSize,
};
use interprocess::local_socket::LocalSocketStream;
@ -62,7 +62,7 @@ pub enum ClientToServerMsg {
ClientAttributes,
Box<CliArgs>,
Box<Options>,
Option<MainLayout>,
Option<LayoutTemplate>,
),
AttachClient(ClientAttributes, bool, Options),
Action(Action),

16
zellij-utils/src/setup.rs
View file

@ -6,7 +6,7 @@ use crate::{
},
input::{
config::{Config, ConfigError},
layout::{Layout, MainLayout},
layout::{LayoutFromYaml, LayoutTemplate},
options::Options,
},
};
@ -153,7 +153,7 @@ impl Setup {
/// 2. config options (`config.yaml`)
pub fn from_options(
opts: &CliArgs,
) -> Result<(Config, Option<MainLayout>, Options), ConfigError> {
) -> Result<(Config, Option<LayoutTemplate>, Options), ConfigError> {
let clean = match &opts.command {
Some(Command::Setup(ref setup)) => setup.clean,
_ => false,
@ -176,7 +176,7 @@ impl Setup {
.layout_dir
.clone()
.or_else(|| get_layout_dir(opts.config_dir.clone().or_else(find_default_config_dir)));
let layout_result = Layout::from_path_or_default(
let layout_result = LayoutFromYaml::from_path_or_default(
opts.layout.as_ref(),
opts.layout_path.as_ref(),
layout_dir,
@ -188,15 +188,7 @@ impl Setup {
return Err(e);
}
}
.map(|layout| layout.construct_main_layout());
let layout = match layout {
None => None,
Some(Ok(layout)) => Some(layout),
Some(Err(e)) => {
return Err(e);
}
};
.map(|layout| layout.construct_layout_template());
if let Some(Command::Setup(ref setup)) = &opts.command {
setup.from_cli(opts, &config_options).map_or_else(