for Commands {
345 | fn from(command: Layout) -> Self {
346 | Commands::Layout(command)
347 | }
348 | }
349 |
350 | impl From for Commands {
351 | fn from(command: Pre) -> Self {
352 | Commands::Pre(command)
353 | }
354 | }
355 |
356 | impl From for Commands {
357 | fn from(command: SelectPane) -> Self {
358 | Commands::SelectPane(command)
359 | }
360 | }
361 |
362 | impl From for Commands {
363 | fn from(command: SelectWindow) -> Self {
364 | Commands::SelectWindow(command)
365 | }
366 | }
367 |
368 | impl From for Commands {
369 | fn from(command: SendKeys) -> Self {
370 | Commands::SendKeys(command)
371 | }
372 | }
373 |
374 | impl From for Commands {
375 | fn from(command: Session) -> Self {
376 | Commands::Session(command)
377 | }
378 | }
379 |
380 | impl From for Commands {
381 | fn from(command: Split) -> Self {
382 | Commands::Split(command)
383 | }
384 | }
385 |
386 | impl From for Commands {
387 | fn from(command: SwitchClient) -> Self {
388 | Commands::SwitchClient(command)
389 | }
390 | }
391 |
392 | impl From for Commands {
393 | fn from(command: Window) -> Self {
394 | Commands::Window(command)
395 | }
396 | }
397 |
--------------------------------------------------------------------------------
/load/src/lib.rs:
--------------------------------------------------------------------------------
1 | extern crate dirs;
2 | extern crate libc;
3 | extern crate yaml_rust;
4 |
5 | extern crate common;
6 |
7 | pub mod command;
8 | pub mod project;
9 | pub mod tmux;
10 |
11 | use args::Args;
12 | use command::Commands;
13 | use common::project_paths::project_paths;
14 | use common::{args, first_run};
15 | use project::parser;
16 | use tmux::config::Config;
17 |
18 | pub fn exec(args: Args) -> Result<(), String> {
19 | let project_paths = project_paths(&args);
20 |
21 | // FIXME: Should have an error message
22 | let yaml = project::read(&args.arg_project, &project_paths).unwrap();
23 | let project_name = &yaml[0]["name"]
24 | .as_str()
25 | .unwrap_or(&args.arg_project)
26 | .to_string();
27 |
28 | let commands: Vec;
29 | match project::session_exists(project_name) {
30 | Some(c) => {
31 | commands = vec![c];
32 | }
33 | None => {
34 | let config = Config::from_string(tmux::get_config());
35 | commands = parser::call(&yaml, project_name, args.flag_d, &config)
36 | .expect("Couldn't parse commands");
37 | }
38 | };
39 |
40 | if args.flag_debug {
41 | println!("{:?}", &commands);
42 | };
43 |
44 | for command in &commands {
45 | command
46 | .as_trait()
47 | .call(args.flag_debug)
48 | .map_err(|e| format!("Had a problem running commands for tmux {}", e))?;
49 | }
50 |
51 | Ok(())
52 | }
53 |
--------------------------------------------------------------------------------
/load/src/project/mod.rs:
--------------------------------------------------------------------------------
1 | //! The project module takes care of muxed related initialization. Locating the
2 | //! users home directory. Finding the desired config files, and reading the
3 | //! configs in.
4 | pub mod parser;
5 |
6 | use command::{Attach, Commands, SwitchClient};
7 | use common::project_paths::ProjectPaths;
8 | use first_run::check_first_run;
9 | use std::env;
10 | use std::fs::File;
11 | use std::io::prelude::*;
12 | use tmux::has_session;
13 | use yaml_rust::{Yaml, YamlLoader};
14 |
15 | static TMUX_ENV_VAR: &str = "TMUX";
16 |
17 | /// Using the provided project name, locate the path to that project file. It
18 | /// should be something similar to: `~/.muxed/my_project.yml`
19 | /// Read in the contents of the config (which should be Yaml), and parse the
20 | /// contents as yaml.
21 | ///
22 | /// `project_name`: The name of the project, corresponding to the project config
23 | /// file.
24 | /// `project_paths`: The struct of paths
25 | ///
26 | /// # Examples
27 | ///
28 | /// Given the project name "compiler" and a project file found at:
29 | /// `~/.muxed/compiler.yml`.
30 | ///
31 | /// ```rust,no_run
32 | /// extern crate common;
33 | /// extern crate load;
34 | /// extern crate yaml_rust;
35 | ///
36 | /// use common::project_paths::ProjectPaths;
37 | /// use load::project::read;
38 | /// use std::path::PathBuf;
39 | /// use yaml_rust::{Yaml, YamlLoader};
40 | ///
41 | /// let paths = ProjectPaths::new(
42 | /// PathBuf::from("/tmp"),
43 | /// PathBuf::from("/tmp/.muxed"),
44 | /// PathBuf::from("/tmp/.muxed/projectname.yml")
45 | /// );
46 | ///
47 | /// let yaml: Result, String> = read("compiler", &paths);
48 | ///
49 | /// assert!(yaml.is_ok());
50 | /// ```
51 | pub fn read(project_name: &str, project_paths: &ProjectPaths) -> Result, String> {
52 | check_first_run(&project_paths.project_directory)?;
53 |
54 | let mut file = File::open(&project_paths.project_file).map_err(|e| format!("No project configuration file was found with the name `{}` in the directory `{}`. Received error: {}", project_name, &project_paths.project_directory.display(), e.to_string()))?;
55 | let mut contents = String::new();
56 |
57 | file.read_to_string(&mut contents)
58 | .map_err(|e| e.to_string())?;
59 |
60 | let parsed_yaml = YamlLoader::load_from_str(&contents).map_err(|e| e.to_string())?;
61 |
62 | Ok(parsed_yaml)
63 | }
64 |
65 | /// Find out if a tmux session is already active with this name. If it is active
66 | /// return `Some` with a command to attach to the session. If a
67 | /// session is not active return None and let the app carry on.
68 | pub fn session_exists(project_name: &str) -> Option {
69 | if has_session(project_name).success() {
70 | Some(open(project_name))
71 | } else {
72 | None
73 | }
74 | }
75 |
76 | /// Check to see how we want to open the project. Do we need to attach to a new
77 | /// tmux session or can we switch the client from a running session.
78 | ///
79 | /// # Examples
80 | ///
81 | /// ```rust
82 | /// extern crate load;
83 | ///
84 | /// use load::command::{Attach, Commands, Command};
85 | /// use load::project::open;
86 | ///
87 | /// let correct_type = match open("muxed") {
88 | /// Commands::Attach(_) => true,
89 | /// _ => false,
90 | /// };
91 | ///
92 | /// assert!(correct_type)
93 | /// ```
94 | pub fn open(project_name: &str) -> Commands {
95 | if env::var_os(TMUX_ENV_VAR).is_some() {
96 | SwitchClient::new(&project_name).into()
97 | } else {
98 | Attach::new(&project_name, None).into()
99 | }
100 | }
101 |
102 | #[cfg(test)]
103 | mod test {
104 | use super::*;
105 | use common::rand_names;
106 | use std::fs;
107 |
108 | #[test]
109 | fn missing_file_returns_err() {
110 | let project_paths = ProjectPaths::from_strs("/tmp", ".muxed", "");
111 | let result = read(&String::from("not_a_file"), &project_paths);
112 | assert!(result.is_err())
113 | }
114 |
115 | #[test]
116 | fn poorly_formatted_file_returns_err() {
117 | let name = rand_names::project_file_name();
118 | let project_paths = ProjectPaths::from_strs("/tmp", ".muxed", &name);
119 |
120 | let _ = fs::create_dir(&project_paths.project_directory);
121 | let mut buffer = File::create(&project_paths.project_file).unwrap();
122 | let _ = buffer.write(b"mix: [1,2,3]: muxed");
123 | let _ = buffer.sync_all();
124 |
125 | let result = read(&name, &project_paths);
126 | let _ = fs::remove_file(&project_paths.project_file);
127 | assert!(result.is_err());
128 | }
129 |
130 | #[test]
131 | fn good_file_returns_ok() {
132 | let name = rand_names::project_file_name();
133 | let project_paths = ProjectPaths::from_strs("/tmp", ".muxed", &name);
134 |
135 | let _ = fs::create_dir(&project_paths.project_directory);
136 | let mut buffer = File::create(&project_paths.project_file).unwrap();
137 | let _ = buffer.write(
138 | b"---
139 | windows: ['cargo', 'vim', 'git']
140 | ",
141 | );
142 | let _ = buffer.sync_all();
143 |
144 | let result = read(&name, &project_paths);
145 | let _ = fs::remove_file(&project_paths.project_file);
146 | assert!(result.is_ok());
147 | }
148 |
149 | #[test]
150 | fn open_returns_attach_in_bare_context() {
151 | let attach_command = match open("muxed") {
152 | Commands::Attach(_) => true,
153 | _ => false,
154 | };
155 |
156 | assert!(attach_command);
157 | }
158 |
159 | #[test]
160 | fn open_returns_switch_client_in_nested_context() {
161 | let _ = env::set_var(TMUX_ENV_VAR, "somestring");
162 | let switch_command = match open("muxed") {
163 | Commands::SwitchClient(_) => true,
164 | _ => false,
165 | };
166 | let _ = env::remove_var(TMUX_ENV_VAR);
167 |
168 | assert!(switch_command);
169 | }
170 | }
171 |
--------------------------------------------------------------------------------
/load/src/project/parser.rs:
--------------------------------------------------------------------------------
1 | //! The YAML parser. Here is where we convert the yaml in to commands to be
2 | //! processed later.
3 |
4 | use command::*;
5 | use dirs::home_dir;
6 | use project;
7 | use std::path::{Path, PathBuf};
8 | use std::rc::Rc;
9 | use tmux::config::Config;
10 | use tmux::target::*;
11 | use yaml_rust::Yaml;
12 |
13 | /// Here was pass in the parsed yaml and project name. The purpose of this call
14 | /// loop is to build the stack of commands that are run to setup a users tmux
15 | /// session.
16 | ///
17 | /// `yaml_string`: The parsed yaml from the config file.
18 | /// `project_name`: The name of the project.
19 | pub fn call<'a>(
20 | yaml_string: &'a [Yaml],
21 | project_name: &'a str,
22 | daemonize: bool,
23 | tmux_config: &Config,
24 | ) -> Result, String> {
25 | let mut commands: Vec = vec![];
26 | let project_name = Rc::new(project_name);
27 |
28 | // There should only be one doc but it's a vec so take the first.
29 | let doc = &yaml_string[0];
30 |
31 | let root = expand_path(&doc["root"]);
32 | let pre_window = pre_matcher(&doc["pre_window"]);
33 |
34 | // A clojure used to capture the current local root and pre Options.
35 | // This way we can call the clojure to create common SendKeys command
36 | // like changing the directory or executing a system command from the
37 | // `pre_window` option.
38 | let common_commands = |target: Target| -> Vec {
39 | let mut commands2 = vec![];
40 |
41 | // SendKeys for the Pre option
42 | if let Some(p) = pre_window.clone() {
43 | for v in &p {
44 | if let Some(ref r) = *v {
45 | commands2.push(SendKeys::new(target.clone(), r.clone()).into());
46 | };
47 | }
48 | };
49 |
50 | commands2
51 | };
52 |
53 | let windows = doc["windows"]
54 | .as_vec()
55 | .expect("No Windows have been defined.");
56 |
57 | for window in windows.iter() {
58 | match *window {
59 | Yaml::Hash(ref h) => {
60 | for (k, v) in h {
61 | if v.as_hash().is_some() {
62 | let path = match expand_path(&v["path"]) {
63 | Some(x) => Some(x),
64 | None => root.clone(),
65 | };
66 |
67 | commands.push(
68 | Window::new(
69 | &project_name,
70 | Rc::new(k.as_str().expect("window should have a name").to_string()),
71 | path.clone(),
72 | )
73 | .into(),
74 | );
75 |
76 | let target = WindowTarget::new(
77 | Rc::clone(&project_name),
78 | k.as_str().ok_or_else(|| "no target specified")?,
79 | );
80 | commands.append(&mut pane_matcher(
81 | v,
82 | &target,
83 | &common_commands,
84 | &tmux_config,
85 | path.clone(),
86 | )?);
87 | } else {
88 | commands.push(Window::new(
89 | &project_name,
90 | Rc::new(k.as_str().ok_or_else(|| {
91 | "Windows require being named in your config."
92 | })?
93 | .to_string()),
94 | root.clone()
95 | ).into());
96 |
97 | let target = WindowTarget::new(Rc::clone(&project_name), k.as_str().unwrap());
98 | commands.append(&mut common_commands(Target::WindowTarget(target.clone())));
99 |
100 | // SendKeys for the exec command
101 | if let Some(ex) = v.as_str() {
102 | if !ex.is_empty() {
103 | commands.push(
104 | SendKeys::new(
105 | Target::WindowTarget(target.clone()),
106 | v.as_str().unwrap().to_string(),
107 | )
108 | .into(),
109 | );
110 | };
111 | }
112 | }
113 | }
114 | }
115 | Yaml::String(ref s) => {
116 | commands
117 | .push(Window::new(&project_name, Rc::new(s.to_string()), root.clone()).into());
118 |
119 | let target = WindowTarget::new(Rc::clone(&project_name), &s);
120 | commands.append(&mut common_commands(Target::WindowTarget(target)));
121 | }
122 | Yaml::Integer(ref s) => {
123 | commands.push(
124 | Window::new(&project_name, Rc::new(format!("{}", s)), root.clone()).into(),
125 | );
126 |
127 | let target = WindowTarget::new(Rc::clone(&project_name), &s.to_string());
128 | commands.append(&mut common_commands(Target::WindowTarget(target)));
129 | }
130 | _ => panic!("Muxed config file formatting isn't recognized."),
131 | };
132 | }
133 |
134 | let (first, commands1) = commands.split_first().unwrap();
135 | let mut remains = commands1.to_vec();
136 |
137 | if let Commands::Window(ref w) = &first {
138 | remains.insert(
139 | 0,
140 | Session::new(&project_name, Rc::clone(&w.name), root.clone()).into(),
141 | );
142 |
143 | if let Some(path) = &w.path {
144 | remains.insert(
145 | 1,
146 | SendKeys::new(
147 | Target::WindowTarget(WindowTarget::new(Rc::clone(&project_name), &w.name)),
148 | format!("cd {}", path.display()),
149 | )
150 | .into(),
151 | );
152 | }
153 |
154 | remains.push(SelectWindow::new(WindowTarget::new(Rc::clone(&project_name), &w.name)).into());
155 | remains.push(
156 | SelectPane::new(PaneTarget::new(
157 | &project_name,
158 | &w.name,
159 | tmux_config.base_index,
160 | ))
161 | .into(),
162 | );
163 | };
164 |
165 | // FIXME: Due to inserting the Pre commands into the 0 position in the stack,
166 | // if pre is defined as an array, it is executed in reverse order.
167 | let pre = pre_matcher(&doc["pre"]);
168 | if let Some(ref p) = pre {
169 | for v in p.iter() {
170 | if let Some(ref r) = *v {
171 | remains.insert(0, Pre::new(r.clone()).into());
172 | };
173 | }
174 | };
175 |
176 | if !daemonize {
177 | remains.push(project::open(&project_name).into());
178 | };
179 |
180 | Ok(remains)
181 | }
182 |
183 | /// Pane matcher is for breaking apart the panes. Splitting windows when needed
184 | /// and executing commands as needed.
185 | fn pane_matcher<'a, T>(
186 | window: &'a Yaml,
187 | target: &WindowTarget,
188 | common_commands: T,
189 | tmux_config: &Config,
190 | inherited_path: Option>,
191 | ) -> Result, String>
192 | where
193 | T: Fn(Target) -> Vec,
194 | {
195 | let mut commands = vec![];
196 | let panes = window["panes"]
197 | .as_vec()
198 | .expect("Something is wrong with panes.");
199 |
200 | let path = match expand_path(&window["path"]) {
201 | Some(x) => Some(x),
202 | None => inherited_path,
203 | };
204 |
205 | for (i, pane) in panes.iter().enumerate() {
206 | let pt = PaneTarget::new(
207 | &target.session,
208 | &target.window,
209 | i + tmux_config.pane_base_index,
210 | );
211 | // For every pane, we need one less split.
212 | // ex. An existing window to become 2 panes, needs 1 split.
213 | if i < (panes.len() - 1) {
214 | commands.push(Split::new(pt.clone(), path.clone()).into());
215 | };
216 |
217 | // Call the common_commands clojure to execute `cd` and `pre_window` options in
218 | // pane splits.
219 | commands.append(&mut common_commands(Target::PaneTarget(pt.clone())));
220 |
221 | // Execute given commands in each new pane after all splits are
222 | // complete.
223 | if let Some(p) = pane.as_str() {
224 | if !p.is_empty() {
225 | commands.push(SendKeys::new(Target::PaneTarget(pt.clone()), p.to_string()).into());
226 | };
227 | };
228 | }
229 |
230 | // After all panes are split select the layout for the window
231 | if window["layout"].as_str().is_some() {
232 | let err = format!(
233 | "A problem with the specified layout for the window: {}",
234 | target
235 | );
236 | let layout = window["layout"].as_str().expect(&err);
237 | commands.push(Layout::new(target.clone(), layout.to_string()).into());
238 | };
239 |
240 | Ok(commands)
241 | }
242 |
243 | fn pre_matcher(node: &Yaml) -> Option>> {
244 | match *node {
245 | // See if pre contains an array or a string. If it's an array we
246 | // need to check the values of it again to verify they are strings.
247 | Yaml::String(ref x) => Some(vec![Some(x.to_string())]),
248 | Yaml::Array(ref x) => Some(
249 | x.iter()
250 | .map(|y| match *y {
251 | Yaml::String(ref z) => Some(z.to_string()),
252 | _ => None,
253 | })
254 | .collect(),
255 | ),
256 | _ => None,
257 | }
258 | }
259 |
260 | fn expand_path(node: &Yaml) -> Option> {
261 | match node.as_str() {
262 | Some(string) => Some(if string.contains("~/") {
263 | let home = home_dir().expect("Home dir could not be expanded");
264 | let path = home.join(Path::new(string).strip_prefix("~/").unwrap());
265 | Rc::new(path)
266 | } else {
267 | Rc::new(PathBuf::from(string))
268 | }),
269 | None => None,
270 | }
271 | }
272 |
273 | #[cfg(test)]
274 | mod test {
275 | use super::*;
276 | use yaml_rust::YamlLoader;
277 |
278 | #[test]
279 | pub fn expect_1_session() {
280 | let s = "---
281 | windows: ['cargo', 'vim', 'git']
282 | ";
283 | let yaml = YamlLoader::load_from_str(s).unwrap();
284 | let remains: Vec = call(
285 | &yaml,
286 | "muxed",
287 | false,
288 | &Config {
289 | base_index: 0,
290 | pane_base_index: 0,
291 | },
292 | )
293 | .unwrap()
294 | .into_iter()
295 | .filter(|x| match x {
296 | Commands::Session(_) => true,
297 | _ => false,
298 | })
299 | .collect();
300 |
301 | assert_eq!(remains.len(), 1)
302 | }
303 |
304 | #[test]
305 | pub fn expect_2_windows_from_array() {
306 | let s = "---
307 | windows: ['cargo', 'vim', 'git']
308 | ";
309 | let yaml = YamlLoader::load_from_str(s).unwrap();
310 | let remains: Vec = call(
311 | &yaml,
312 | "muxed",
313 | false,
314 | &Config {
315 | base_index: 0,
316 | pane_base_index: 0,
317 | },
318 | )
319 | .unwrap()
320 | .into_iter()
321 | .filter(|x| match x {
322 | Commands::Window(_) => true,
323 | _ => false,
324 | })
325 | .collect();
326 |
327 | assert_eq!(remains.len(), 2)
328 | }
329 |
330 | #[test]
331 | pub fn expect_1_attach() {
332 | let s = "---
333 | windows: ['cargo', 'vim', 'git']
334 | ";
335 | let yaml = YamlLoader::load_from_str(s).unwrap();
336 | let remains: Vec = call(
337 | &yaml,
338 | "muxed",
339 | false,
340 | &Config {
341 | base_index: 0,
342 | pane_base_index: 0,
343 | },
344 | )
345 | .unwrap()
346 | .into_iter()
347 | .filter(|x| match x {
348 | Commands::Attach(_) => true,
349 | _ => false,
350 | })
351 | .collect();
352 |
353 | assert_eq!(remains.len(), 1)
354 | }
355 |
356 | #[test]
357 | pub fn expect_2_windows_with_mixed_type_names() {
358 | let s = "---
359 | windows: [1, 'vim', 3]
360 | ";
361 | let yaml = YamlLoader::load_from_str(s).unwrap();
362 | let remains: Vec = call(
363 | &yaml,
364 | "muxed",
365 | false,
366 | &Config {
367 | base_index: 0,
368 | pane_base_index: 0,
369 | },
370 | )
371 | .unwrap()
372 | .into_iter()
373 | .filter(|x| match x {
374 | Commands::Window(_) => true,
375 | _ => false,
376 | })
377 | .collect();
378 | assert_eq!(remains.len(), 2)
379 | }
380 |
381 | #[test]
382 | pub fn expect_2_windows_from_list() {
383 | let s = "---
384 | windows:
385 | - cargo: ''
386 | - vim: ''
387 | - git: ''
388 | ";
389 | let yaml = YamlLoader::load_from_str(s).unwrap();
390 | let remains: Vec = call(
391 | &yaml,
392 | "muxed",
393 | false,
394 | &Config {
395 | base_index: 0,
396 | pane_base_index: 0,
397 | },
398 | )
399 | .unwrap()
400 | .into_iter()
401 | .filter(|x| match x {
402 | Commands::Window(_) => true,
403 | _ => false,
404 | })
405 | .collect();
406 | assert_eq!(remains.len(), 2)
407 | }
408 |
409 | #[test]
410 | pub fn expect_ok_with_empty_syscommands() {
411 | let s = "---
412 | windows:
413 | - editor:
414 | ";
415 | let yaml = YamlLoader::load_from_str(s).unwrap();
416 | let result = call(
417 | &yaml,
418 | "muxed",
419 | false,
420 | &Config {
421 | base_index: 0,
422 | pane_base_index: 0,
423 | },
424 | );
425 | assert!(result.is_ok())
426 | }
427 |
428 | #[test]
429 | pub fn expect_no_send_keys_commands() {
430 | let s = "---
431 | windows:
432 | - editor:
433 | ";
434 |
435 | let yaml = YamlLoader::load_from_str(s).unwrap();
436 | let remains: Vec = call(
437 | &yaml,
438 | "muxed",
439 | false,
440 | &Config {
441 | base_index: 0,
442 | pane_base_index: 0,
443 | },
444 | )
445 | .unwrap()
446 | .into_iter()
447 | .filter(|x| match x {
448 | Commands::SendKeys(_) => true,
449 | _ => false,
450 | })
451 | .collect();
452 |
453 | assert_eq!(remains.len(), 0)
454 | }
455 |
456 | #[test]
457 | pub fn expect_err_with_nameless_window() {
458 | let s = "---
459 | windows:
460 | - : ls
461 | ";
462 | let yaml = YamlLoader::load_from_str(s).unwrap();
463 | let result = call(
464 | &yaml,
465 | "muxed",
466 | false,
467 | &Config {
468 | base_index: 0,
469 | pane_base_index: 0,
470 | },
471 | );
472 | assert!(result.is_err())
473 | }
474 |
475 | #[test]
476 | pub fn expect_ok_with_empty_panes_syscommands() {
477 | let s = "---
478 | windows:
479 | - cargo:
480 | layout: 'main-vertical'
481 | panes:
482 | -
483 | ";
484 | let yaml = YamlLoader::load_from_str(s).unwrap();
485 | let result = call(
486 | &yaml,
487 | "muxed",
488 | false,
489 | &Config {
490 | base_index: 0,
491 | pane_base_index: 0,
492 | },
493 | );
494 | assert!(result.is_ok())
495 | }
496 |
497 | #[test]
498 | pub fn expect_no_send_keys_with_empty_panes_syscommands() {
499 | let s = "---
500 | windows:
501 | - editor:
502 | panes:
503 | -
504 | ";
505 |
506 | let yaml = YamlLoader::load_from_str(s).unwrap();
507 | let remains: Vec = call(
508 | &yaml,
509 | "muxed",
510 | false,
511 | &Config {
512 | base_index: 0,
513 | pane_base_index: 0,
514 | },
515 | )
516 | .unwrap()
517 | .into_iter()
518 | .filter(|x| match x {
519 | Commands::SendKeys(_) => true,
520 | _ => false,
521 | })
522 | .collect();
523 |
524 | assert_eq!(remains.len(), 0)
525 | }
526 |
527 | #[test]
528 | pub fn expect_1_split_window() {
529 | let s = "---
530 | windows:
531 | - editor:
532 | layout: 'main-vertical'
533 | panes: ['vim', 'guard']
534 | ";
535 |
536 | let yaml = YamlLoader::load_from_str(s).unwrap();
537 | let remains: Vec = call(
538 | &yaml,
539 | "muxed",
540 | false,
541 | &Config {
542 | base_index: 0,
543 | pane_base_index: 0,
544 | },
545 | )
546 | .unwrap()
547 | .into_iter()
548 | .filter(|x| match x {
549 | Commands::Split(_) => true,
550 | _ => false,
551 | })
552 | .collect();
553 |
554 | assert_eq!(remains.len(), 1)
555 | }
556 |
557 | #[test]
558 | pub fn expect_1_layout() {
559 | let s = "---
560 | windows:
561 | - editor:
562 | layout: 'main-vertical'
563 | panes: ['vim', 'guard']
564 | ";
565 |
566 | let yaml = YamlLoader::load_from_str(s).unwrap();
567 | let remains: Vec = call(
568 | &yaml,
569 | "muxed",
570 | false,
571 | &Config {
572 | base_index: 0,
573 | pane_base_index: 0,
574 | },
575 | )
576 | .unwrap()
577 | .into_iter()
578 | .filter(|x| match x {
579 | Commands::Layout(_) => true,
580 | _ => false,
581 | })
582 | .collect();
583 |
584 | assert_eq!(remains.len(), 1)
585 | }
586 |
587 | #[test]
588 | pub fn expect_1_session_with_panes_array() {
589 | let s = "---
590 | windows:
591 | - editor:
592 | layout: 'main-vertical'
593 | panes: ['vim', 'guard']
594 | ";
595 |
596 | let yaml = YamlLoader::load_from_str(s).unwrap();
597 | let remains: Vec = call(
598 | &yaml,
599 | "muxed",
600 | false,
601 | &Config {
602 | base_index: 0,
603 | pane_base_index: 0,
604 | },
605 | )
606 | .unwrap()
607 | .into_iter()
608 | .filter(|x| match x {
609 | Commands::Session(_) => true,
610 | _ => false,
611 | })
612 | .collect();
613 |
614 | assert_eq!(remains.len(), 1)
615 | }
616 |
617 | #[test]
618 | pub fn expect_no_layout() {
619 | let s = "---
620 | windows:
621 | - editor:
622 | panes: ['vim', 'guard']
623 | ";
624 |
625 | let yaml = YamlLoader::load_from_str(s).unwrap();
626 | let remains: Vec = call(
627 | &yaml,
628 | "muxed",
629 | false,
630 | &Config {
631 | base_index: 0,
632 | pane_base_index: 0,
633 | },
634 | )
635 | .unwrap()
636 | .into_iter()
637 | .filter(|x| match x {
638 | Commands::Layout(_) => true,
639 | _ => false,
640 | })
641 | .collect();
642 |
643 | assert_eq!(remains.len(), 0)
644 | }
645 |
646 | #[test]
647 | pub fn expect_three_send_keys_commands_from_pre_window() {
648 | // pre gets run on all 2 panes and 1 window for a total of 3
649 | let s = "---
650 | pre_window: 'ls'
651 | windows:
652 | - editor:
653 | panes:
654 | -
655 | -
656 | - logs:
657 | ";
658 | let yaml = YamlLoader::load_from_str(s).unwrap();
659 | let remains: Vec = call(
660 | &yaml,
661 | "muxed",
662 | false,
663 | &Config {
664 | base_index: 0,
665 | pane_base_index: 0,
666 | },
667 | )
668 | .unwrap()
669 | .into_iter()
670 | .filter(|x| match x {
671 | Commands::SendKeys(_) => true,
672 | _ => false,
673 | })
674 | .collect();
675 |
676 | assert_eq!(remains.len(), 3)
677 | }
678 |
679 | #[test]
680 | pub fn expect_two_send_keys_commands_from_pre_window() {
681 | let s = "---
682 | pre_window:
683 | - 'ls'
684 | - 'ls'
685 | windows:
686 | - editor:
687 | ";
688 | let yaml = YamlLoader::load_from_str(s).unwrap();
689 | let remains: Vec = call(
690 | &yaml,
691 | "muxed",
692 | false,
693 | &Config {
694 | base_index: 0,
695 | pane_base_index: 0,
696 | },
697 | )
698 | .unwrap()
699 | .into_iter()
700 | .filter(|x| match x {
701 | Commands::SendKeys(_) => true,
702 | _ => false,
703 | })
704 | .collect();
705 |
706 | assert_eq!(remains.len(), 2)
707 | }
708 |
709 | #[test]
710 | pub fn expect_no_send_keys_with_blank_panes() {
711 | let s = "---
712 | windows:
713 | - editor:
714 | panes: ['','','']
715 | ";
716 |
717 | let yaml = YamlLoader::load_from_str(s).unwrap();
718 | let remains: Vec = call(
719 | &yaml,
720 | "muxed",
721 | false,
722 | &Config {
723 | base_index: 0,
724 | pane_base_index: 0,
725 | },
726 | )
727 | .unwrap()
728 | .into_iter()
729 | .filter(|x| match x {
730 | Commands::SendKeys(_) => true,
731 | _ => false,
732 | })
733 | .collect();
734 |
735 | assert_eq!(remains.len(), 0)
736 | }
737 |
738 | #[test]
739 | pub fn expect_no_send_keys_with_blank_window() {
740 | let s = "---
741 | windows:
742 | - editor: ''
743 | ";
744 |
745 | let yaml = YamlLoader::load_from_str(s).unwrap();
746 | let remains: Vec = call(
747 | &yaml,
748 | "muxed",
749 | false,
750 | &Config {
751 | base_index: 0,
752 | pane_base_index: 0,
753 | },
754 | )
755 | .unwrap()
756 | .into_iter()
757 | .filter(|x| match x {
758 | Commands::SendKeys(_) => true,
759 | _ => false,
760 | })
761 | .collect();
762 |
763 | assert_eq!(remains.len(), 0)
764 | }
765 |
766 | #[test]
767 | pub fn expect_full_directory_name() {
768 | let s = "---
769 | root: ~/JustPlainSimple Technologies Inc./financials/ledgers
770 | windows:
771 | - dir: ''
772 | ";
773 |
774 | let yaml = YamlLoader::load_from_str(s).unwrap();
775 | let remains: Commands = call(
776 | &yaml,
777 | "financials",
778 | false,
779 | &Config {
780 | base_index: 0,
781 | pane_base_index: 0,
782 | },
783 | )
784 | .unwrap()
785 | .into_iter()
786 | .find(|x| match x {
787 | Commands::Session(_) => true,
788 | _ => false,
789 | })
790 | .unwrap();
791 |
792 | let root = match remains {
793 | Commands::Session(ref k) => k,
794 | _ => panic!("nope"),
795 | };
796 |
797 | let home = dirs::home_dir().unwrap();
798 | let path = PathBuf::from("JustPlainSimple Technologies Inc./financials/ledgers");
799 |
800 | assert_eq!(root.root_path, Some(Rc::new(home.join(path))))
801 | }
802 |
803 | #[test]
804 | pub fn expect_1_select_window() {
805 | let s = "---
806 | windows: ['cargo', 'vim', 'git']
807 | ";
808 | let yaml = YamlLoader::load_from_str(s).unwrap();
809 | let remains: Vec = call(
810 | &yaml,
811 | "muxed",
812 | false,
813 | &Config {
814 | base_index: 0,
815 | pane_base_index: 0,
816 | },
817 | )
818 | .unwrap()
819 | .into_iter()
820 | .filter(|x| match x {
821 | Commands::SelectWindow(_) => true,
822 | _ => false,
823 | })
824 | .collect();
825 |
826 | assert_eq!(remains.len(), 1)
827 | }
828 |
829 | #[test]
830 | pub fn expect_1_select_pane() {
831 | let s = "---
832 | windows: ['cargo', 'vim', 'git']
833 | ";
834 | let yaml = YamlLoader::load_from_str(s).unwrap();
835 | let remains: Vec = call(
836 | &yaml,
837 | "muxed",
838 | false,
839 | &Config {
840 | base_index: 0,
841 | pane_base_index: 0,
842 | },
843 | )
844 | .unwrap()
845 | .into_iter()
846 | .filter(|x| match x {
847 | Commands::SelectPane(_) => true,
848 | _ => false,
849 | })
850 | .collect();
851 |
852 | assert_eq!(remains.len(), 1)
853 | }
854 |
855 | #[test]
856 | pub fn expect_vec_of_option_string() {
857 | let s = "---
858 | pre: ls -alh
859 | ";
860 | let yaml = YamlLoader::load_from_str(s).unwrap();
861 | let pre = pre_matcher(&yaml[0]["pre"]);
862 | assert_eq!(pre.unwrap(), vec!(Some("ls -alh".to_string())))
863 | }
864 |
865 | #[test]
866 | pub fn expect_vec_of_option_strings() {
867 | let s = "---
868 | pre:
869 | - ls -alh
870 | - tail -f
871 | ";
872 | let yaml = YamlLoader::load_from_str(s).unwrap();
873 | let pre = pre_matcher(&yaml[0]["pre"]);
874 | assert_eq!(
875 | pre.unwrap(),
876 | vec!(Some("ls -alh".to_string()), Some("tail -f".to_string()))
877 | )
878 | }
879 |
880 | #[test]
881 | pub fn expect_some_from_pre_matcher() {
882 | let s = "---
883 | pre: ls -alh
884 | ";
885 | let yaml = YamlLoader::load_from_str(s).unwrap();
886 | let pre = pre_matcher(&yaml[0]["pre"]);
887 | assert!(pre.is_some())
888 | }
889 |
890 | #[test]
891 | pub fn expect_none_from_pre_matcher() {
892 | let s = "---
893 | pre:
894 | ";
895 | let yaml = YamlLoader::load_from_str(s).unwrap();
896 | let pre = pre_matcher(&yaml[0]["pre"]);
897 | assert!(pre.is_none())
898 | }
899 | }
900 |
--------------------------------------------------------------------------------
/load/src/tmux/config.rs:
--------------------------------------------------------------------------------
1 | //! The tmux config data we want
2 | /// This assists in the parsing and accessibility of a users tmux configuration
3 | /// options. Once the data is parsed we move it into a config struct for easy
4 | /// access.
5 | use std::collections::HashMap;
6 | use std::str::FromStr;
7 |
8 | /// A simple struct for accessing parsed config options we want to know about.
9 | #[derive(Debug, Clone)]
10 | pub struct Config {
11 | pub base_index: usize,
12 | pub pane_base_index: usize,
13 | }
14 |
15 | /// The parser of config options. A string of output is passed in. It's simple
16 | /// key value pairs in the format of `key value\n`
17 | impl Config {
18 | pub fn from_string(options: String) -> Config {
19 | let lines = options.lines();
20 | let mut config: HashMap<&str, &str> = HashMap::new();
21 |
22 | for line in lines {
23 | let opt: Vec<&str> = line.split(' ').collect();
24 | config.insert(opt[0], opt[1]);
25 | }
26 |
27 | Config {
28 | base_index: usize::from_str(config.get("base-index").unwrap_or(&"0")).unwrap(),
29 | pane_base_index: usize::from_str(config.get("pane-base-index").unwrap_or(&"0"))
30 | .unwrap(),
31 | }
32 | }
33 | }
34 |
35 | #[test]
36 | fn expect_base_index_0() {
37 | let output = "some-stuff false\nbase-index 0\nother-thing true".to_string();
38 | let config = Config::from_string(output);
39 | assert_eq!(config.base_index, 0)
40 | }
41 |
42 | #[test]
43 | fn expect_base_index_5() {
44 | let output = "some-stuff false\nbase-index 5\nother-thing true".to_string();
45 | let config = Config::from_string(output);
46 | assert_eq!(config.base_index, 5)
47 | }
48 |
49 | #[test]
50 | fn expect_missing_base_index_0() {
51 | let output = "some-stuff false".to_string();
52 | let config = Config::from_string(output);
53 | assert_eq!(config.base_index, 0)
54 | }
55 |
56 | #[test]
57 | fn expect_pane_base_index_0() {
58 | let output = "some-stuff false\npane-base-index 0\nother-thing true".to_string();
59 | let config = Config::from_string(output);
60 | assert_eq!(config.pane_base_index, 0)
61 | }
62 |
63 | #[test]
64 | fn expect_pane_base_index_5() {
65 | let output = "some-stuff false\npane-base-index 5\nother-thing true".to_string();
66 | let config = Config::from_string(output);
67 | assert_eq!(config.pane_base_index, 5)
68 | }
69 |
70 | #[test]
71 | fn expect_missing_pane_base_index_0() {
72 | let output = "some-stuff false".to_string();
73 | let config = Config::from_string(output);
74 | assert_eq!(config.pane_base_index, 0)
75 | }
76 |
--------------------------------------------------------------------------------
/load/src/tmux/mod.rs:
--------------------------------------------------------------------------------
1 | //! The interface for interacting with TMUX sessions. All the commands that are
2 | /// built up during the parsing phase get matched to functions here. The
3 | /// functions in this module all build up strings the get passed to a private
4 | /// call. The private call converts them to `CStrings` and makes an "unsafe" system
5 | /// call. All functions go through this `call` function as a common gateway to
6 | /// system calls and can all be easily logged there.
7 | pub mod config;
8 | pub mod target;
9 |
10 | use libc::system;
11 | use std::ffi::CString;
12 | use std::io;
13 | use std::os::unix::process::ExitStatusExt;
14 | use std::process::{Command, ExitStatus, Output};
15 |
16 | /// The program to call commands on.
17 | static TMUX_NAME: &str = "tmux";
18 |
19 | /// The gateway to calling any functions on tmux. Most public functions in this
20 | /// module will be fed through this `call` function. This safely creates a new
21 | /// thread to execute the command on. We say "Most" public functions will use
22 | /// this as `attach` specificaly does not use it.
23 | ///
24 | /// args: The command we will send to tmux on the host system for execution.
25 | ///
26 | /// # Examples
27 | ///
28 | /// ```rust
29 | /// extern crate load;
30 | /// use load::tmux::call;
31 | ///
32 | /// let _ = call(&["new-window", "-t", "muxed-test", "-c", "~/Projects/muxed/"]);
33 | /// let _ = call(&["kill-session", "-t", "muxed-test"]);
34 | /// ```
35 | pub fn call(args: &[&str]) -> Result {
36 | //println!("{:?}", &args);
37 | Command::new(TMUX_NAME).args(args).output()
38 | }
39 |
40 | /// Has session is used firgure out if a named session is already running.
41 | ///
42 | /// `target`: A string represented by the `{named_session}`
43 | ///
44 | /// # Examples
45 | ///
46 | /// ```rust
47 | /// extern crate load;
48 | /// use load::tmux;
49 | ///
50 | /// let session = tmux::has_session("muxed");
51 | ///
52 | /// assert!(!session.success());
53 | /// ```
54 | pub fn has_session(target: &str) -> ExitStatus {
55 | let output =
56 | call(&["has-session", "-t", target]).expect("failed to see if the session existed");
57 | output.status
58 | }
59 |
60 | /// Read the tmux config and return a config object
61 | ///
62 | /// # Examples
63 | ///
64 | /// ```rust
65 | /// extern crate load;
66 | /// use load::tmux;
67 | ///
68 | /// tmux::get_config();
69 | /// ```
70 | pub fn get_config() -> String {
71 | let output = call(&["start-server", ";", "show-options", "-g", ";", "show-options", "-g", "-w"])
72 | .expect("couldn't get tmux options");
73 | String::from_utf8_lossy(&output.stdout).to_string()
74 | }
75 |
76 | /// Attach is called as the last function in a set of commands. After the tmux
77 | /// env has been setup by all previous commands this attaches the user to their
78 | /// daemonized tmux session.
79 | ///
80 | /// # Examples
81 | ///
82 | /// `session_name: The active tmux session name.
83 | ///
84 | /// ```rust,no_run
85 | /// extern crate load;
86 | /// use load::tmux;
87 | ///
88 | /// tmux::attach(&["muxed"]);
89 | /// ```
90 | pub fn attach(args: &[&str]) -> Result {
91 | let arg_string = [&[TMUX_NAME], &args[..]].concat().join(" ");
92 | let system_call = CString::new(arg_string).unwrap();
93 | // println!("{:?}", arg_string.clone());
94 | unsafe {
95 | let output = system(system_call.as_ptr());
96 |
97 | Ok(Output {
98 | status: ExitStatus::from_raw(output),
99 | stdout: vec![],
100 | stderr: vec![],
101 | })
102 | }
103 | }
104 |
--------------------------------------------------------------------------------
/load/src/tmux/target.rs:
--------------------------------------------------------------------------------
1 | //! The structures used to manage commands sent over to tmux.
2 |
3 | use std::fmt;
4 | use std::rc::Rc;
5 | use std::usize;
6 |
7 | /// A targeted pane for a tmux session
8 | #[derive(Debug, Clone)]
9 | pub struct PaneTarget {
10 | pub session: String,
11 | pub window: String,
12 | pub pane_index: usize,
13 | pub arg_string: String,
14 | }
15 |
16 | impl PaneTarget {
17 | pub fn new(session: &str, window: &str, pane_index: usize) -> PaneTarget {
18 | PaneTarget {
19 | session: session.to_string(),
20 | window: window.to_string(),
21 | pane_index,
22 | arg_string: format!("{}:{}.{}", session, window, pane_index),
23 | }
24 | }
25 | }
26 |
27 | impl fmt::Display for PaneTarget {
28 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
29 | write!(f, "{}", &self.arg_string)
30 | }
31 | }
32 |
33 | /// A targeted window for a tmux session
34 | #[derive(Debug, Clone)]
35 | pub struct WindowTarget {
36 | pub session: String,
37 | pub window: String,
38 | pub arg_string: String,
39 | }
40 |
41 | impl WindowTarget {
42 | pub fn new(session: Rc<&str>, window: &str) -> WindowTarget {
43 | WindowTarget {
44 | session: session.to_string(),
45 | window: window.to_string(),
46 | arg_string: format!("{}:{}", session, window),
47 | }
48 | }
49 | }
50 |
51 | impl fmt::Display for WindowTarget {
52 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
53 | write!(f, "{}", &self.arg_string)
54 | }
55 | }
56 |
57 | /// A targeted session for tmux
58 | #[derive(Debug, Clone)]
59 | pub struct SessionTarget {
60 | pub session: Rc,
61 | pub arg_string: Rc,
62 | }
63 |
64 | impl SessionTarget {
65 | pub fn new(session: Rc) -> SessionTarget {
66 | SessionTarget {
67 | session: Rc::clone(&session),
68 | arg_string: Rc::clone(&session),
69 | }
70 | }
71 | }
72 |
73 | impl fmt::Display for SessionTarget {
74 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
75 | write!(f, "{}", self.session)
76 | }
77 | }
78 |
79 | #[derive(Debug, Clone)]
80 | pub enum Target {
81 | PaneTarget(PaneTarget),
82 | WindowTarget(WindowTarget),
83 | }
84 |
85 | impl Target {
86 | pub fn arg_string(&self) -> &str {
87 | match *self {
88 | Target::PaneTarget(ref c) => &c.arg_string,
89 | Target::WindowTarget(ref c) => &c.arg_string,
90 | }
91 | }
92 | }
93 |
--------------------------------------------------------------------------------
/load/tests/helpers/mod.rs:
--------------------------------------------------------------------------------
1 | //! The integration suite helpers.
2 |
3 | use common::args::Args;
4 | use common::rand_names;
5 | use rand::random;
6 | use snapshot::tmux;
7 | use std::fs;
8 | use std::fs::File;
9 | use std::io::prelude::*;
10 | use std::path::{Path, PathBuf};
11 | use std::str;
12 | use std::thread::sleep;
13 | use std::time::Duration;
14 | use yaml_rust::YamlLoader;
15 |
16 | fn project_name(contents: &[u8]) -> String {
17 | let string_content = str::from_utf8(contents).unwrap();
18 | let yaml = YamlLoader::load_from_str(string_content).unwrap();
19 |
20 | match yaml[0]["name"].as_str() {
21 | Some(x) => x.to_string(),
22 | None => rand_names::project_file_name(),
23 | }
24 | }
25 |
26 | fn setup(contents: &[u8]) -> (String, PathBuf) {
27 | let project_name = project_name(contents);
28 | let project_path = rand_names::project_file_path_with_name(&project_name);
29 |
30 | let muxed_path = project_path.parent().unwrap();
31 | if !muxed_path.exists() {
32 | println!("{:?}", fs::create_dir(muxed_path))
33 | };
34 |
35 | let mut buffer = File::create(&project_path).unwrap();
36 | let _ = buffer.write(contents);
37 | let _ = buffer.sync_all();
38 |
39 | (project_name, project_path)
40 | }
41 |
42 | fn cleanup(project_name: &str, config_path: &PathBuf) {
43 | let _ = fs::remove_file(config_path);
44 | let _ = fs::remove_dir(config_path.parent().unwrap());
45 | kill_session(project_name);
46 | }
47 |
48 | pub fn test_with_contents(contents: &[u8]) -> snapshot::tmux::session::Session {
49 | let (project_name, config_path) = setup(contents);
50 | let _ = open_muxed(&project_name, config_path.parent().unwrap());
51 |
52 | let completed = PathBuf::from(format!(
53 | "/tmp/{}-{}.complete",
54 | project_name,
55 | random::()
56 | ));
57 | let exec = format!("touch '{}'", completed.display());
58 |
59 | send_keys(&project_name, &exec);
60 | wait_on(&completed);
61 |
62 | let session = tmux::inspect(&project_name).unwrap();
63 | cleanup(&project_name, &config_path);
64 | session
65 | }
66 |
67 | fn open_muxed(project: &str, project_root: &Path) -> Result<(), String> {
68 | let args = Args {
69 | arg_project: project.to_string(),
70 | flag_p: Some(format!("{}", project_root.display())),
71 | ..Default::default()
72 | };
73 |
74 | load::exec(args)
75 | }
76 |
77 | fn kill_session(target: &str) {
78 | let _ = load::tmux::call(&["kill-session", "-t", target]);
79 | }
80 |
81 | fn send_keys(target: &str, exec: &str) {
82 | let _ = load::tmux::call(&["send-keys", "-t", target, exec, "KPEnter"]);
83 | }
84 |
85 | fn wait_on(file: &PathBuf) {
86 | while !file.exists() {
87 | // Wait increased from 10 to 750 due to the pre_window tests.
88 | sleep(Duration::from_millis(750));
89 | }
90 | }
91 |
--------------------------------------------------------------------------------
/load/tests/load.rs:
--------------------------------------------------------------------------------
1 | //! The integration suite for inspecting sessions.
2 |
3 | extern crate common;
4 | extern crate snapshot;
5 |
6 | extern crate dirs;
7 | extern crate libc;
8 | extern crate load;
9 | extern crate rand;
10 | extern crate yaml_rust;
11 |
12 | mod helpers;
13 |
14 | #[cfg(test)]
15 | mod test {
16 | mod load {
17 | use common::rand_names;
18 | use dirs::home_dir;
19 | use helpers::test_with_contents;
20 | use std::fs;
21 | use std::fs::File;
22 | use std::io::prelude::*;
23 | use std::path::PathBuf;
24 |
25 | #[test]
26 | fn opens_3_windows_from_array() {
27 | let contents = b"---
28 | windows: ['ls', 'vi', 'git']
29 | ";
30 | let session = test_with_contents(contents);
31 | assert_eq!(session.windows.len(), 3)
32 | }
33 |
34 | #[test]
35 | fn opens_2_windows() {
36 | let contents = b"---
37 | windows:
38 | - editor:
39 | layout: 'main-vertical'
40 | panes: ['ls', 'vi']
41 | - stuff: ''
42 | ";
43 | let session = test_with_contents(contents);
44 | assert_eq!(session.windows.len(), 2)
45 | }
46 |
47 | #[test]
48 | fn opens_3_windows_with_integer_names() {
49 | let contents = b"---
50 | windows: [1, 'ls', 3]
51 | ";
52 | let session = test_with_contents(contents);
53 | assert_eq!(session.windows.len(), 3)
54 | }
55 |
56 | #[test]
57 | fn single_window_has_2_panes() {
58 | let contents = b"---
59 | windows:
60 | - editor:
61 | layout: 'main-vertical'
62 | panes: ['ls', 'vi']
63 | ";
64 | let session = test_with_contents(contents);
65 | let window = session.find_window("editor").unwrap();
66 | assert_eq!(window.panes.len(), 2)
67 | }
68 |
69 | #[test]
70 | fn multiple_windows_with_panes() {
71 | let contents = b"---
72 | windows:
73 | - editor:
74 | layout: 'main-vertical'
75 | panes: ['ls', 'vi']
76 | - tests:
77 | layout: 'main-vertical'
78 | panes: ['ls', 'vi', 'ls']
79 | ";
80 | let session = test_with_contents(contents);
81 | let editor_window = session.find_window("editor").unwrap();
82 | let tests_window = session.find_window("tests").unwrap();
83 | assert_eq!(editor_window.panes.len(), 2);
84 | assert_eq!(tests_window.panes.len(), 3)
85 | }
86 |
87 | #[test]
88 | fn window_with_empty_command_is_valid() {
89 | let contents = b"---
90 | windows:
91 | - editor:
92 | ";
93 | let session = test_with_contents(contents);
94 | assert_eq!(session.windows.len(), 1)
95 | }
96 |
97 | #[test]
98 | fn panes_with_empty_commands_are_valid() {
99 | let contents = b"---
100 | windows:
101 | - editor:
102 | layout: 'main-vertical'
103 | panes:
104 | -
105 | -
106 | ";
107 | let session = test_with_contents(contents);
108 | let window = session.find_window("editor").unwrap();
109 | assert_eq!(window.panes.len(), 2)
110 | }
111 |
112 | #[test]
113 | fn expect_to_open_in_directory_containing_spaces() {
114 | let dir = PathBuf::from("/tmp/Directory With Spaces/");
115 | if !dir.exists() {
116 | println!("{:?}", fs::create_dir(&dir))
117 | };
118 | let contents = b"---
119 | root: /tmp/Directory With Spaces/
120 | windows:
121 | - editor: ''
122 | ";
123 | let session = test_with_contents(contents);
124 | let window = session.find_window("editor").unwrap();
125 | let pane = &window.panes[0];
126 |
127 | let _ = fs::remove_dir(dir);
128 | // Use contains because OSX on travis ci symlinks /tmp/ to /private/tmp/
129 | // resulting in `pane_current_path` being `/private/tmp/Direct…`
130 | assert!(pane.path.to_str().unwrap().contains("/tmp/Directory With Spaces"));
131 | }
132 |
133 | #[test]
134 | fn expect_home_var_to_open_in_home_dir() {
135 | let contents = b"---
136 | root: '$HOME'
137 | windows:
138 | - editor: ''
139 | ";
140 | let session = test_with_contents(contents);
141 | let window = session.find_window("editor").unwrap();
142 | let pane = &window.panes[0];
143 | assert_eq!(pane.path, home_dir().unwrap());
144 | }
145 |
146 | #[test]
147 | fn expect_tilde_slash_to_open_in_home_dir() {
148 | let contents = b"---
149 | root: ~/
150 | windows:
151 | - editor: ''
152 | ";
153 | let session = test_with_contents(contents);
154 | let window = session.find_window("editor").unwrap();
155 | let pane = &window.panes[0];
156 | assert_eq!(pane.path, home_dir().unwrap());
157 | }
158 | //
159 | // // TODO: Figure out why these hang in travis
160 | // // #[test]
161 | // // fn expect_window_path_to_take_priority() {
162 | // // let dir = PathBuf::from("/tmp/special/");
163 | // // if !dir.exists() {
164 | // // println!("{:?}", fs::create_dir(&dir))
165 | // // };
166 | // // let contents = b"---
167 | // //root: ~/
168 | // //windows:
169 | // // - editor:
170 | // // panes:
171 | // // - vi
172 | // // path: /tmp/special/
173 | // //";
174 | // // let session = test_with_contents(contents);
175 | // // let pane_current_path = session.windows["editor"]
176 | // // .pane_current_path
177 | // // .as_str()
178 | // // .unwrap();
179 | // //
180 | // // assert_eq!(
181 | // // PathBuf::from("/tmp/special/"),
182 | // // PathBuf::from(pane_current_path)
183 | // // );
184 | // // }
185 | // //
186 | // // #[test]
187 | // // fn expect_root_path_on_default_session_window_when_not_specified() {
188 | // // let contents = b"---
189 | // //root: ~/
190 | // //windows:
191 | // // - editor:
192 | // // panes:
193 | // // - vi
194 | // //";
195 | // // let session = test_with_contents(contents);
196 | // // let pane_current_path = session.windows["editor"]
197 | // // .pane_current_path
198 | // // .as_str()
199 | // // .unwrap();
200 | // //
201 | // // assert_eq!(
202 | // // home_dir(),
203 | // // Some(PathBuf::from(pane_current_path))
204 | // // );
205 | // // }
206 | // //
207 | // // #[test]
208 | // // fn first_window_path_shouldnt_be_default_path() {
209 | // // let contents = b"---
210 | // //root: ~/
211 | // //windows:
212 | // // - editor:
213 | // // panes:
214 | // // - vi
215 | // // path: /tmp/
216 | // // - other: pwd
217 | // //";
218 | // // let session = test_with_contents(contents);
219 | // // let editor_current_path = session.windows["editor"]
220 | // // .pane_current_path
221 | // // .as_str()
222 | // // .unwrap();
223 | // //
224 | // // assert_eq!(
225 | // // PathBuf::from("/var/log"),
226 | // // PathBuf::from(editor_current_path)
227 | // // );
228 | // //
229 | // // let other_current_path = session.windows["other"]
230 | // // .pane_current_path
231 | // // .as_str()
232 | // // .unwrap();
233 | // //
234 | // // assert_eq!(
235 | // // home_dir(),
236 | // // Some(PathBuf::from(other_current_path))
237 | // // );
238 | // // }
239 |
240 | // TODO: should ssh or git be a command or window name?
241 | #[test]
242 | fn expect_focus_on_the_first_window() {
243 | let contents = b"---
244 | windows: ['ssh', 'git']
245 | ";
246 | let session = test_with_contents(contents);
247 | let first_window = &session.windows[0];
248 | let other_window = &session.windows[1];
249 |
250 | assert!(first_window.active);
251 | assert_eq!(other_window.active, false)
252 | }
253 |
254 | #[test]
255 | fn expect_pre_to_create_file() {
256 | let file = rand_names::project_file_with_dir("/tmp");
257 | let contents = format!(
258 | "---
259 | pre: touch {}
260 | windows: ['ssh', 'git']
261 | ",
262 | file.display()
263 | );
264 |
265 | let _ = test_with_contents(contents.as_bytes());
266 | assert!(file.exists());
267 | let _ = fs::remove_file(file);
268 | }
269 |
270 | #[test]
271 | fn expect_pre_to_create_two_files() {
272 | let file1 = rand_names::project_file_with_dir("/tmp");
273 | let file2 = rand_names::project_file_with_dir("/tmp");
274 | let contents = format!(
275 | "---
276 | pre:
277 | - touch {}
278 | - touch {}
279 | windows: ['ssh', 'git']
280 | ",
281 | file1.display(),
282 | file2.display()
283 | );
284 |
285 | let _ = test_with_contents(contents.as_bytes());
286 | assert!(file1.exists());
287 | assert!(file2.exists());
288 | let _ = fs::remove_file(file1);
289 | let _ = fs::remove_file(file2);
290 | }
291 |
292 | #[test]
293 | fn expect_pre_window_to_be_called_for_each_window() {
294 | let file = rand_names::project_file_with_dir("/tmp");
295 | let contents = format!(
296 | "---
297 | pre_window: echo 'pre_window' >> {}
298 | windows: ['ssh', 'git']
299 | ",
300 | file.display()
301 | );
302 | let _ = test_with_contents(contents.as_bytes());
303 | let mut f = File::open(&file).unwrap();
304 | let mut s = String::new();
305 | let _ = f.read_to_string(&mut s);
306 | assert_eq!(s.lines().count(), 2);
307 | let _ = fs::remove_file(&file);
308 | }
309 |
310 | #[test]
311 | fn expect_pre_window_to_be_called_twice_for_each_window() {
312 | let file = rand_names::project_file_with_dir("/tmp");
313 | let contents = format!(
314 | "---
315 | pre_window:
316 | - echo 'pre_window' >> {}
317 | - echo 'pre_window' >> {}
318 | windows: ['ssh', 'git']
319 | ",
320 | file.display(),
321 | file.display()
322 | );
323 | let _ = test_with_contents(contents.as_bytes());
324 | let mut f = File::open(&file).unwrap();
325 | let mut s = String::new();
326 | let _ = f.read_to_string(&mut s);
327 | assert_eq!(s.lines().count(), 4);
328 | let _ = fs::remove_file(&file);
329 | }
330 |
331 | #[test]
332 | fn expect_session_name_brians_session() {
333 | let contents = b"---
334 | name: 'Brians Session'
335 | windows: ['ssh', 'git']
336 | ";
337 | let session = test_with_contents(contents);
338 | assert_eq!(session.name, "Brians Session")
339 | }
340 |
341 | // TODO: Fix
342 | // This test should exist but we currently don't do anything to list panes.
343 | // #[test]
344 | // fn expect_focus_on_the_top_pane() {
345 | // let contents = b"---
346 | //windows:
347 | // - ssh:
348 | // layout: main-horizontal
349 | // panes:
350 | // - ''
351 | // - ''
352 | // - git: ''
353 | //";
354 | // let session = test_with_contents(contents);
355 | // assert_eq!(session.pane_active, "ssh.0")
356 | // }
357 | }
358 | }
359 |
--------------------------------------------------------------------------------
/muxed-completion.bash:
--------------------------------------------------------------------------------
1 | #/usr/bin/env bash
2 | _muxed_completions()
3 | {
4 | if [ "$COMP_CWORD" -eq 1 ]; then
5 | local commands="$(compgen -W "new edit snapshot" "${COMP_WORDS[1]}")"
6 | local projects="$(compgen -W "$(echo $(ls ~/.muxed/))" "${COMP_WORDS[1]}")"
7 | COMPREPLY=( $commands $projects )
8 | elif [ "$COMP_CWORD" -eq 2 ]; then
9 | local projects="$(compgen -W "$(echo $(ls ~/.muxed/))" "${COMP_WORDS[2]}")"
10 | COMPREPLY=( $projects )
11 | fi
12 | }
13 |
14 | complete -F _muxed_completions muxed
15 |
--------------------------------------------------------------------------------
/new/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "new"
3 | version = "0.8.2"
4 | authors = ["Brian Pearce"]
5 | publish = false
6 |
7 | [lib]
8 | doctest = false
9 |
10 | [dependencies]
11 | common = { path = "../common" }
12 |
--------------------------------------------------------------------------------
/new/src/lib.rs:
--------------------------------------------------------------------------------
1 | //! Muxednew. A Muxed project Template Generator
2 | extern crate common;
3 |
4 | use common::args::Args;
5 | use common::first_run::check_first_run;
6 | use common::project_paths::project_paths;
7 | use std::fs::OpenOptions;
8 | use std::io::Write;
9 | use std::path::PathBuf;
10 |
11 | static TEMPLATE: &str = include_str!("template.yml");
12 |
13 | /// The main execution method.
14 | /// Accept the name of a project to create a configuration file in the
15 | /// `~/.muxed/` directory.
16 | ///
17 | /// # Examples
18 | ///
19 | /// You can run the command:
20 | ///
21 | /// ```
22 | /// $ ./muxednew projectName
23 | /// ```
24 | ///
25 | /// or specify the directory target of the file:
26 | ///
27 | /// ```
28 | /// $ ./muxednew -p ~/.some_other_dir/ projectName
29 | /// ```
30 | pub fn exec(args: Args) -> Result<(), String> {
31 | let project_paths = project_paths(&args);
32 |
33 | check_first_run(&project_paths.project_directory)?;
34 |
35 | let template = modified_template(TEMPLATE, &project_paths.project_file);
36 | write_template(&template, &project_paths.project_file, args.flag_f)?;
37 |
38 | println!(
39 | "\u{270C} The template file {} has been written to {}\nHappy tmuxing!",
40 | &project_paths.project_file.display(),
41 | &project_paths.project_directory.display()
42 | );
43 | Ok(())
44 | }
45 |
46 | fn modified_template(template: &str, file: &PathBuf) -> String {
47 | template.replace("{file}", file.to_str().expect("Couldn't convert the {:?} path into a String to write into the new file"))
48 | }
49 |
50 | pub fn write_template(template: S, path: &PathBuf, force: bool) -> Result<(), String>
51 | where
52 | S: Into,
53 | {
54 | let path_str = path.to_str().expect("Path could not be opened");
55 | let mut file = OpenOptions::new()
56 | .write(true)
57 | .truncate(force)
58 | .create(force)
59 | .create_new(!force)
60 | .open(path)
61 | .map_err(|e| format!("Could not create the file {}. Error: {}", &path_str, e))?;
62 |
63 | file.write_all(template.into().as_bytes()).map_err(|e| {
64 | format!(
65 | "Could not write contents of template to the file {}. Error {}",
66 | &path_str, e
67 | )
68 | })?;
69 |
70 | file.sync_all()
71 | .map_err(|e| format!("Could not sync OS data post-write. Error: {}", e))?;
72 |
73 | Ok(())
74 | }
75 |
76 | #[cfg(test)]
77 | mod test {
78 | use super::*;
79 | use common::rand_names;
80 | use std::fs;
81 | use std::fs::File;
82 |
83 | #[test]
84 | fn expect_muxed_project_text() {
85 | let file = PathBuf::from("~/.muxed").join("superProject");
86 | let value = modified_template(TEMPLATE, &file);
87 | let result = value.contains("superProject");
88 | assert!(result);
89 | }
90 |
91 | #[test]
92 | fn expect_muxed_dir_text() {
93 | let file = PathBuf::from("~/.muxed").join("superProject");
94 | let value = modified_template(TEMPLATE, &file);
95 | let result = value.contains("~/.muxed/");
96 | assert!(result);
97 | }
98 |
99 | #[test]
100 | fn expect_no_file_name_placeholder() {
101 | let file = PathBuf::from("~/.my_dir").join("superProject");
102 | let value = modified_template(TEMPLATE, &file);
103 | let result = !value.contains("{file}");
104 | assert!(result);
105 | }
106 |
107 | #[test]
108 | fn expect_project_name_with_dir() {
109 | let file = PathBuf::from("~/.my_dir").join("superProject.yml");
110 | let value = modified_template(TEMPLATE, &file);
111 | let result = value.contains("# ~/.my_dir/superProject.yml");
112 | assert!(result);
113 | }
114 |
115 | #[test]
116 | fn expect_project_name_with_dir_and_trailing_slash() {
117 | let file = PathBuf::from("~/.my_dir/").join("superProject.yml");
118 | let value = modified_template(TEMPLATE, &file);
119 | let result = value.contains("# ~/.my_dir/superProject.yml");
120 | assert!(result);
121 | }
122 |
123 | #[test]
124 | fn expect_ok_result_when_path_exists() {
125 | let path = rand_names::project_file_with_dir("/tmp");
126 | let result = write_template(&"test template".to_string(), &path, false);
127 | let _ = fs::remove_file(path);
128 | println!("{:?}", result);
129 | assert!(result.is_ok());
130 | }
131 |
132 | #[test]
133 | fn expect_err_result_when_path_does_not_exist() {
134 | let path = rand_names::project_file_path();
135 | let result = write_template(&"test template".to_string(), &path, false);
136 | assert!(result.is_err());
137 | }
138 |
139 | #[test]
140 | fn expect_new_file_to_exist() {
141 | let path = rand_names::project_file_with_dir("/tmp");
142 | let _ = write_template(&"test template".to_string(), &path, false);
143 | let result = &path.exists();
144 | let _ = fs::remove_file(&path);
145 | assert!(result);
146 | }
147 |
148 | #[test]
149 | fn expect_new_file_not_to_exist() {
150 | let path = rand_names::project_file_path();
151 | let _ = write_template(&"test template".to_string(), &path, false);
152 | assert!(!path.exists());
153 | }
154 |
155 | #[test]
156 | fn expect_no_truncation_or_overwrite() {
157 | // Write a file with content
158 | let path = rand_names::project_file_with_dir("/tmp");
159 | let mut buffer = File::create(&path).unwrap();
160 | let _ = buffer.write(b"original content");
161 | let _ = buffer.sync_all();
162 |
163 | // Attempt to create the same named file with new content
164 | let _ = write_template(&"new_content".to_string(), &path, false);
165 |
166 | let content = fs::read_to_string(&path).unwrap();
167 |
168 | assert_eq!(content, "original content");
169 | let _ = fs::remove_file(&path);
170 | }
171 |
172 | #[test]
173 | fn expect_truncation_or_overwrite() {
174 | // Write a file with content
175 | let path = rand_names::project_file_with_dir("/tmp");
176 | let mut buffer = File::create(&path).unwrap();
177 | let _ = buffer.write(b"original content");
178 | let _ = buffer.sync_all();
179 |
180 | // Attempt to create the same named file with new content
181 | let _ = write_template(&"new content".to_string(), &path, true);
182 |
183 | let content = fs::read_to_string(&path).unwrap();
184 |
185 | assert_eq!(content, "new content");
186 | let _ = fs::remove_file(&path);
187 | }
188 |
189 | #[test]
190 | fn expect_err_when_file_exists() {
191 | let path = rand_names::project_file_with_dir("/tmp");
192 | let mut buffer = File::create(&path).unwrap();
193 | let _ = buffer.write(b"original content");
194 | let _ = buffer.sync_all();
195 | let result = write_template(&"new content".to_string(), &path, false);
196 |
197 | assert!(result.is_err());
198 | let _ = fs::remove_file(&path);
199 | }
200 | }
201 |
--------------------------------------------------------------------------------
/new/src/template.yml:
--------------------------------------------------------------------------------
1 | # {file}
2 |
3 | # The root option will perform a change directory system call on all panes and
4 | # windows opened. To set the default directory.
5 | root: "~/"
6 |
7 | # pre_window is a command or an array of commands that will be executed in all
8 | # windows and panes before window and pane specific commans.
9 | # ex:
10 | # pre_window: rbenv shell 2.1.2
11 | #
12 | # pre_window:
13 | # - rvm 2.1.2
14 | # - ls .
15 |
16 | # Windows is required and lets you define the windows you would like opened in
17 | # your tmux session. This can be made as a list of key value pairs, where the
18 | # key is the window name, and the value is a system command to execute.
19 | # ex:
20 | # windows:
21 | # - processes: "ls /proc"
22 | # - logs: "tail -f /var/log/dmesg"
23 | #
24 | # You can also define windows as an array with no system commands to execute:
25 | # ex:
26 | # windows: ['first', 'second', 'last']
27 | windows:
28 | - editor:
29 | layout: "main-vertical"
30 | panes: ["vi", "ls -alh"]
31 | - processes: "ls /proc"
32 | - logs: "tail -f /var/log/dmesg"
33 |
--------------------------------------------------------------------------------
/new/tests/new.rs:
--------------------------------------------------------------------------------
1 | //! The integration suite for inspecting sessions.
2 |
3 | extern crate common;
4 | extern crate new;
5 |
6 | #[cfg(test)]
7 | mod test {
8 | mod new {
9 | use common::args::Args;
10 | use common::rand_names;
11 | use new;
12 | use std::fs;
13 | use std::path::Path;
14 |
15 | fn cleanup(config_path: &Path) {
16 | let _ = fs::remove_file(config_path);
17 | let _ = fs::remove_dir(config_path.parent().unwrap());
18 | }
19 |
20 | #[test]
21 | fn creates_new_file() {
22 | let project_path = rand_names::project_file_path();
23 |
24 | let args = Args {
25 | arg_project: project_path.file_name().unwrap().to_str().unwrap().to_string(),
26 | cmd_new: true,
27 | flag_p: Some(project_path.parent().unwrap().display().to_string()),
28 | ..Default::default()
29 | };
30 |
31 | assert!(new::exec(args).is_ok());
32 | assert!(&project_path.exists());
33 |
34 | cleanup(&project_path);
35 | }
36 |
37 | #[test]
38 | fn overwrites_existing_file() {
39 | let project_path = rand_names::project_file_path();
40 | let _ = fs::create_dir(project_path.parent().as_ref().unwrap());
41 | let _ = fs::File::create(&project_path);
42 |
43 | let args = Args {
44 | arg_project: project_path.file_name().unwrap().to_str().unwrap().to_string(),
45 | cmd_new: true,
46 | flag_f: true,
47 | flag_p: Some(project_path.parent().unwrap().display().to_string()),
48 | ..Default::default()
49 | };
50 |
51 | assert!(new::exec(args).is_ok());
52 |
53 | let contents = fs::read_to_string(&project_path).unwrap();
54 |
55 | let name = format!("# {}", project_path.display());
56 | assert!(contents.contains(&name));
57 |
58 | cleanup(&project_path);
59 | }
60 |
61 | #[test]
62 | fn fails_to_write_over_existing_file() {
63 | let project_path = rand_names::project_file_path();
64 | let _ = fs::create_dir(project_path.parent().as_ref().unwrap());
65 | let _ = fs::File::create(&project_path);
66 |
67 | let args = Args {
68 | arg_project: project_path.file_name().unwrap().to_str().unwrap().to_string(),
69 | cmd_new: true,
70 | flag_p: Some(project_path.parent().unwrap().display().to_string()),
71 | ..Default::default()
72 | };
73 |
74 | assert!(new::exec(args).is_err());
75 |
76 | cleanup(&project_path);
77 | }
78 | }
79 | }
80 |
--------------------------------------------------------------------------------
/nix-nightly.dockerfile:
--------------------------------------------------------------------------------
1 | FROM rustlang/rust:nightly
2 |
3 | ENV TMUX_VERSION 3.1
4 | WORKDIR /usr/src
5 |
6 | # This is a dummy build to get the dependencies cached
7 | COPY . .
8 | RUN cargo fetch --target x86_64-unknown-linux-gnu
9 | RUN rm -rf ./*
10 |
11 | RUN apt-get update && \
12 | apt-get install -y libevent-dev \
13 | locales \
14 | bison \
15 | byacc && \
16 | apt-get remove tmux
17 |
18 | RUN git clone https://github.com/tmux/tmux.git /opt/tmux && \
19 | cd /opt/tmux && \
20 | git checkout $TMUX_VERSION && \
21 | sh autogen.sh && \
22 | ./configure --prefix=/opt/tmux && make && make install
23 |
24 | ENV PATH $PATH:/opt/tmux/bin
25 |
26 | RUN sed -i -e 's/# en_US.UTF-8 UTF-8/en_US.UTF-8 UTF-8/' /etc/locale.gen && \
27 | locale-gen
28 |
29 | ENV LANG en_US.UTF-8
30 | ENV LANGUAGE en_US:en
31 | ENV LC_ALL en_US.UTF-8
32 |
33 | RUN rustup component add rustfmt
34 | RUN rustup component add clippy --toolchain=nightly || cargo install --git https://github.com/rust-lang/rust-clippy/ --force clippy
35 | RUN cargo install clog-cli
36 |
--------------------------------------------------------------------------------
/nix.dockerfile:
--------------------------------------------------------------------------------
1 | FROM rust:latest
2 |
3 | ENV TMUX_VERSION 3.1
4 | WORKDIR /usr/src
5 |
6 | # This is a dummy build to get the dependencies cached
7 | COPY . .
8 | RUN cargo fetch --target x86_64-unknown-linux-gnu; \
9 | cargo build; \
10 | rm -rf ./*
11 |
12 | RUN apt-get update; \
13 | apt-get install -y --no-install-recommends \
14 | automake \
15 | bison \
16 | byacc \
17 | git \
18 | libevent-dev \
19 | libncurses-dev \
20 | locales \
21 | pkg-config; \
22 | apt-get remove tmux
23 |
24 | RUN git clone --depth=1 --branch $TMUX_VERSION https://github.com/tmux/tmux.git /opt/tmux && \
25 | cd /opt/tmux && \
26 | git checkout $TMUX_VERSION && \
27 | sh autogen.sh && \
28 | ./configure --prefix=/opt/tmux && make && make install
29 |
30 | RUN sed -i -e 's/# en_US.UTF-8 UTF-8/en_US.UTF-8 UTF-8/' /etc/locale.gen && \
31 | locale-gen
32 |
33 | ENV PATH=$PATH:/opt/tmux/bin \
34 | LANG=en_US.UTF-8 \
35 | LANGUAGE=en_US:en \
36 | LC_ALL=en_US.UTF-8
37 |
38 | RUN apt-get remove \
39 | automake \
40 | bison \
41 | byacc \
42 | git \
43 | libevent-dev \
44 | libncurses-dev \
45 | locales \
46 | pkg-config; \
47 | rm -rf /var/lib/apt/lists/*;
48 |
49 | RUN rustup component add rustfmt; \
50 | cargo install clog-cli
51 | # RUN rustup component add clippy --toolchain=nightly || cargo install --git https://github.com/rust-lang/rust-clippy/ --force clippy
52 |
--------------------------------------------------------------------------------
/osx.dockerfile:
--------------------------------------------------------------------------------
1 | FROM brianp/rust-builds:osx
2 |
3 | WORKDIR /usr/src
4 |
5 | # This is a dummy build to get the dependencies cached
6 | COPY . .
7 | RUN cargo fetch --target x86_64-apple-darwin
8 | RUN rm -rf ./*
9 |
10 | RUN apt-get update; \
11 | apt-get install -y --no-install-recommends \
12 | tmux \
13 | locales;
14 |
15 | RUN sed -i -e 's/# en_US.UTF-8 UTF-8/en_US.UTF-8 UTF-8/' /etc/locale.gen && \
16 | locale-gen
17 |
18 | ENV LANG=en_US.UTF-8 \
19 | LANGUAGE=en_US:en \
20 | LC_ALL=en_US.UTF-8
21 |
--------------------------------------------------------------------------------
/rust-builds.dockerfile:
--------------------------------------------------------------------------------
1 | FROM rust:latest
2 |
3 | ENV UNATTENDED=1 \
4 | OSX_VERSION_MIN=10.15 \
5 | PKG_FILE=MacOSX10.15.sdk.tar.xz \
6 | PKG_CONFIG_ALLOW_CROSS=1
7 |
8 | WORKDIR /usr/src/
9 |
10 | RUN apt-get update && \
11 | apt-get install -qqy --no-install-recommends \
12 | clang \
13 | cmake \
14 | g++ \
15 | gcc \
16 | libgmp-dev \
17 | libmpc-dev \
18 | libmpfr-dev \
19 | zlib1g-dev; \
20 | apt-get remove tmux
21 |
22 | RUN git clone https://github.com/tpoechtrager/osxcross.git --depth 1 /osxcross/
23 | COPY $PKG_FILE /osxcross/tarballs/
24 |
25 | RUN cd /osxcross \
26 | && ./build.sh -y \
27 | && rm tarballs/$PKG_FILE
28 |
29 | ENV PATH /osxcross/target/bin:$PATH
30 |
31 | RUN apt-get remove \
32 | clang \
33 | cmake \
34 | g++ \
35 | gcc \
36 | libgmp-dev \
37 | libmpc-dev \
38 | libmpfr-dev \
39 | zlib1g-dev; \
40 | rm -rf /var/lib/apt/lists/*;
41 |
42 | RUN rustup target add x86_64-apple-darwin; \
43 | rustup component add rustfmt; \
44 | cargo install clog-cli
45 |
--------------------------------------------------------------------------------
/snapshot/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "snapshot"
3 | version = "0.8.2"
4 | authors = ["Brian Pearce"]
5 | publish = false
6 |
7 | [lib]
8 | doctest = false
9 |
10 | [dependencies]
11 | common = { path = "../common" }
12 | new = { path = "../new" }
13 | regex = "1.3.1"
14 | serde = { version = "1.0.103", features = ["derive"] }
15 | serde_yaml = "0.8"
16 |
--------------------------------------------------------------------------------
/snapshot/src/capture/mod.rs:
--------------------------------------------------------------------------------
1 | use regex::Regex;
2 |
3 | pub fn retrieve_capture(line: &str, pattern: &str) -> Option {
4 | let reg = Regex::new(pattern).unwrap();
5 |
6 | if let Some(caps) = reg.captures(line) {
7 | return match caps.get(1) {
8 | Some(x) => Some(x.as_str().to_string()),
9 | None => None,
10 | };
11 | };
12 |
13 | None
14 | }
15 |
16 | #[cfg(test)]
17 | mod test {
18 | use super::*;
19 |
20 | #[test]
21 | fn expect_cap_to_have_some() {
22 | // Capture "Bar" between any chars
23 | let pattern = r"\w* (Bar) \w*";
24 | let line = "Foo Bar Foo";
25 | let cap = retrieve_capture(line, pattern);
26 | assert!(cap.is_some())
27 | }
28 |
29 | #[test]
30 | fn expect_cap_to_be_bar() {
31 | // Capture "Bar" between any chars
32 | let pattern = r"\w* (Bar) \w*";
33 | let line = "Foo Bar Foo";
34 | let cap = retrieve_capture(line, pattern).unwrap();
35 | assert_eq!(cap, "Bar")
36 | }
37 |
38 | #[test]
39 | fn expect_cap_to_have_none() {
40 | // Capture "Bar" between any chars
41 | let pattern = r"\w* (Bar) \w*";
42 | let line = "Foo Foo";
43 | let cap = retrieve_capture(line, pattern);
44 | assert!(cap.is_none())
45 | }
46 |
47 | #[test]
48 | fn expect_cap_to_have_none_when_line_empty() {
49 | // Capture "Bar" between any chars
50 | let pattern = r"\w* (Bar) \w*";
51 | let line = "";
52 | let cap = retrieve_capture(line, pattern);
53 | assert!(cap.is_none())
54 | }
55 |
56 | #[test]
57 | fn expect_to_return_the_first_capture() {
58 | // Capture any word containing "ello"
59 | let pattern = r"(\wello\w).*";
60 | let line = "Yellow Mellow";
61 | let cap = retrieve_capture(line, pattern).unwrap();
62 | assert_eq!(cap, "Yellow")
63 | }
64 | }
65 |
--------------------------------------------------------------------------------
/snapshot/src/lib.rs:
--------------------------------------------------------------------------------
1 | //! Muxedsnapshot. A tmux session cloner for Muxed.
2 | extern crate common;
3 | extern crate new;
4 | extern crate regex;
5 | extern crate serde;
6 | extern crate serde_yaml;
7 |
8 | mod capture;
9 | pub mod tmux;
10 |
11 | use common::args::Args;
12 | use common::first_run::check_first_run;
13 | use common::project_paths::project_paths;
14 | use new::write_template as write_config;
15 |
16 | /// The main execution method.
17 | /// Accepts two arguments. -n for the name of the project file and -t to target
18 | /// the session.
19 | ///
20 | /// # Examples
21 | ///
22 | /// You can run the command:
23 | ///
24 | /// ```
25 | /// $ ./muxedsnapshot -n my_new_project -t existing_sesion
26 | /// ```
27 | ///
28 | /// or
29 | ///
30 | /// ```
31 | /// $ ./muxed snapshot -n jasper -t 1
32 | /// ```
33 | pub fn exec(args: Args) -> Result<(), String> {
34 | let session_name = &args.flag_t.as_ref().expect("No TMUX session running");
35 | let project_paths = project_paths(&args);
36 |
37 | check_first_run(&project_paths.project_directory)?;
38 |
39 | let session = tmux::inspect(&session_name).unwrap();
40 | let s = serde_yaml::to_string(&session).unwrap();
41 |
42 | write_config(s, &project_paths.project_file, args.flag_f).unwrap();
43 | println!("We made a snapshot of your session! \u{1F60A}");
44 | Ok(())
45 | }
46 |
47 | #[cfg(test)]
48 | mod test {
49 | use super::write_config;
50 | use common::rand_names;
51 | use std::fs;
52 | use std::fs::File;
53 | use std::io::{Read, Write};
54 |
55 | #[test]
56 | fn expect_ok_result() {
57 | let path = rand_names::project_file_with_dir("/tmp");
58 | let result = write_config("test template", &path, false);
59 | let _ = fs::remove_file(path);
60 | assert!(result.is_ok());
61 | }
62 |
63 | #[test]
64 | fn expect_err_result() {
65 | let path = rand_names::project_file_with_dir("/tmp/non_existent/");
66 | let result = write_config("test template", &path, false);
67 | assert!(result.is_err());
68 | }
69 |
70 | #[test]
71 | fn expect_file_to_exist() {
72 | let path = rand_names::project_file_with_dir("/tmp");
73 | let _ = write_config("test template", &path, false);
74 | let result = &path.exists();
75 | let _ = fs::remove_file(&path);
76 | assert!(result);
77 | }
78 |
79 | #[test]
80 | fn expect_file_not_to_exist() {
81 | let path = rand_names::project_file_with_dir("/tmp/non_existent/");
82 | let _ = write_config("test template", &path, false);
83 | assert!(!path.exists());
84 | }
85 |
86 | #[test]
87 | fn expect_no_truncation_or_overwrite() {
88 | // Write a file with content
89 | let path = rand_names::project_file_with_dir("/tmp");
90 | let mut buffer = File::create(&path).unwrap();
91 | let _ = buffer.write(b"original content");
92 | let _ = buffer.sync_all();
93 |
94 | // Attempt to create the same named file with new content
95 | let _ = write_config("new_content", &path, false);
96 |
97 | // Read the file content
98 | let mut f = File::open(&path).unwrap();
99 | let mut s = String::new();
100 | let _ = f.read_to_string(&mut s);
101 |
102 | assert_eq!(s, "original content");
103 | let _ = fs::remove_file(&path);
104 | }
105 |
106 | #[test]
107 | fn expect_err_when_file_exists() {
108 | let path = rand_names::project_file_with_dir("/tmp");
109 | let mut buffer = File::create(&path).unwrap();
110 | let _ = buffer.write(b"original content");
111 | let _ = buffer.sync_all();
112 | let result = write_config("new_content", &path, false);
113 |
114 | assert!(result.is_err());
115 | let _ = fs::remove_file(&path);
116 | }
117 |
118 | #[test]
119 | fn expect_ok_when_file_exists_using_force() {
120 | let path = rand_names::project_file_with_dir("/tmp");
121 | let mut buffer = File::create(&path).unwrap();
122 | let _ = buffer.write(b"original content");
123 | let _ = buffer.sync_all();
124 | let result = write_config("new_content", &path, true);
125 |
126 | assert!(result.is_ok());
127 | let _ = fs::remove_file(&path);
128 | }
129 |
130 | #[test]
131 | fn expect_truncation_or_overwrite_using_force() {
132 | // Write a file with content
133 | let path = rand_names::project_file_with_dir("/tmp");
134 | let mut buffer = File::create(&path).unwrap();
135 | let _ = buffer.write(b"original content");
136 | let _ = buffer.sync_all();
137 |
138 | // Attempt to create the same named file with new content
139 | let _ = write_config("new content", &path, true);
140 |
141 | // Read the file content
142 | let mut f = File::open(&path).unwrap();
143 | let mut s = String::new();
144 | let _ = f.read_to_string(&mut s);
145 |
146 | assert_eq!(s, "new content");
147 | let _ = fs::remove_file(&path);
148 | }
149 |
150 | #[test]
151 | fn expect_file_not_to_exist_using_force_with_bad_dir() {
152 | let path = rand_names::project_file_with_dir("/tmp/non_existent_path/");
153 | let _ = write_config("test template", &path, true);
154 | assert!(!path.exists());
155 | }
156 |
157 | #[test]
158 | fn expect_ok_result_using_force_when_file_doesnt_exist() {
159 | let path = rand_names::project_file_with_dir("/tmp");
160 | let result = write_config("test template", &path, true);
161 | let _ = fs::remove_file(path);
162 | assert!(result.is_ok());
163 | }
164 | }
165 |
--------------------------------------------------------------------------------
/snapshot/src/tmux/mod.rs:
--------------------------------------------------------------------------------
1 | pub mod pane;
2 | pub mod session;
3 | pub mod window;
4 |
5 | use self::pane::Pane;
6 | use self::session::Session;
7 | use self::window::Window;
8 |
9 | pub fn inspect(name: &str) -> Result {
10 | let windows = match windows_for(name) {
11 | Ok(x) => x,
12 | Err(e) => return Err(e),
13 | };
14 |
15 | let windows = windows
16 | .into_iter()
17 | .map(|w| Window::from_window(panes_for(name, &w).unwrap(), w))
18 | .collect();
19 |
20 | Ok(Session::new(name, windows))
21 | }
22 |
23 | fn windows_for(target: &str) -> Result, String> {
24 | let err = format!("\u{1F613} The session {} was not found.", target);
25 | let output = Window::window_list(target).map_err(|e| format!("{} - {}", err, e))?;
26 |
27 | let windows = String::from_utf8_lossy(&output.stdout)
28 | .lines()
29 | .filter_map(|line| Window::from_line(line))
30 | .collect::>();
31 |
32 | if windows.is_empty() {
33 | return Err(err);
34 | }
35 |
36 | Ok(windows)
37 | }
38 |
39 | fn panes_for(session_name: &str, w: &Window) -> Result, String> {
40 | let target = format!("{}:{}", &session_name, &w.name);
41 | let output = Pane::pane_list(&target)
42 | .map_err(|e| format!("We couldn't find panes for the {} window - {}", &target, e))?;
43 |
44 | let panes = String::from_utf8_lossy(&output.stdout)
45 | .lines()
46 | .filter_map(|line| Pane::from_line(line))
47 | .collect::>();
48 |
49 | Ok(panes)
50 | }
51 |
--------------------------------------------------------------------------------
/snapshot/src/tmux/pane/mod.rs:
--------------------------------------------------------------------------------
1 | //use std::path::PathBuf;
2 | //use tmux::window::Window;
3 | use capture::retrieve_capture;
4 | use serde::{Deserialize, Serialize, Serializer};
5 | use std::io;
6 | use std::path::PathBuf;
7 | use std::process::{Command, Output};
8 |
9 | pub mod pid;
10 | pub mod process;
11 |
12 | use self::pid::Pid;
13 | use self::process::Process;
14 |
15 | static ACTIVE_REGEX: &str = r"\s(\(active\))";
16 | static PATH_REGEX: &str = r"\(Path: (.*)\) \(PID";
17 | static PID_REGEX: &str = r"\(PID: ([0-9]*)\)";
18 |
19 | // Example format: "1: [123x14] (Path: /muxed/muxedsnapshot) (PID: 22541) (active)"
20 | static LIST_FORMAT: &str = "'#{pane_index}: [#{pane_width}x#{pane_height}] (Path: #{pane_current_path}) (PID: #{pane_pid}) #{?pane_active,(active), } '";
21 |
22 | #[derive(Clone, Debug, Deserialize)]
23 | pub struct Pane {
24 | pub active: bool,
25 | pub path: PathBuf,
26 | pub process: Option,
27 | }
28 |
29 | impl Pane {
30 | pub fn new(active: bool, path: PathBuf, process: Option) -> Pane {
31 | Pane {
32 | active,
33 | path,
34 | process,
35 | }
36 | }
37 |
38 | pub fn from_line(line: &str) -> Option {
39 | let active = retrieve_capture(line, ACTIVE_REGEX).is_some();
40 |
41 | let path = match retrieve_capture(line, PATH_REGEX) {
42 | Some(x) => PathBuf::from(x),
43 | None => return None,
44 | };
45 |
46 | let pid = match retrieve_capture(line, PID_REGEX) {
47 | Some(x) => Pid::new(x),
48 | None => return None,
49 | };
50 |
51 | let process = match Process::process_string_from(pid) {
52 | Ok(x) => Some(Process::new(x)),
53 | Err(_) => None,
54 | };
55 |
56 | Some(Pane::new(active, path, process))
57 | }
58 |
59 | pub fn pane_list(target: &str) -> Result {
60 | Command::new("tmux")
61 | .args(&["list-panes", "-t", target, "-F", LIST_FORMAT])
62 | .output()
63 | }
64 | }
65 |
66 | impl Serialize for Pane {
67 | fn serialize(&self, serializer: S) -> Result
68 | where
69 | S: Serializer,
70 | {
71 | let process_str = match self.process.clone() {
72 | Some(process) => process.process,
73 | None => "".to_string(),
74 | };
75 |
76 | serializer.serialize_str(process_str.as_str())
77 | }
78 | }
79 |
80 | #[cfg(test)]
81 | mod test {
82 | use super::*;
83 | use std::path::PathBuf;
84 |
85 | #[test]
86 | fn expect_active_to_be_false() {
87 | let line = "2: [123x14] (Path: /muxed-project/muxed) (PID: 22541) ";
88 | let pane = Pane::from_line(line).unwrap();
89 | assert!(!pane.active)
90 | }
91 |
92 | #[test]
93 | fn expect_active_to_be_true() {
94 | let line = "1: [123x14] (Path: /muxed-project/muxed) (PID: 22541) (active)";
95 | let pane = Pane::from_line(line).unwrap();
96 | assert!(pane.active)
97 | }
98 |
99 | #[test]
100 | fn expect_pane_to_match() {
101 | let line = "1: [123x14] (Path: /muxed/muxedsnapshot) (PID: 22541) (active)";
102 | let pane = Pane::from_line(line).unwrap();
103 | assert_eq!(pane.path, PathBuf::from("/muxed/muxedsnapshot"));
104 | }
105 | }
106 |
--------------------------------------------------------------------------------
/snapshot/src/tmux/pane/pid.rs:
--------------------------------------------------------------------------------
1 | use serde::{Deserialize, Serialize};
2 | use std::ffi::OsStr;
3 | use std::fmt;
4 | use std::str::FromStr;
5 |
6 | #[derive(Debug, Clone, Serialize, Deserialize)]
7 | pub struct Pid {
8 | pub pid: i32,
9 | pub pid_str: String,
10 | }
11 |
12 | impl Pid {
13 | pub fn new(pid: S) -> Pid
14 | where
15 | S: Into,
16 | {
17 | let pid_s = pid.into();
18 | let pid_i = i32::from_str(pid_s.as_str()).unwrap();
19 |
20 | Pid {
21 | pid: pid_i,
22 | pid_str: pid_s,
23 | }
24 | }
25 | }
26 |
27 | impl fmt::Display for Pid {
28 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
29 | write!(f, "{}", self.pid)
30 | }
31 | }
32 |
33 | impl AsRef for Pid {
34 | fn as_ref(&self) -> &OsStr {
35 | OsStr::new(&self.pid_str)
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/snapshot/src/tmux/pane/process.rs:
--------------------------------------------------------------------------------
1 | use serde::{Deserialize, Serialize};
2 | use std::fmt;
3 | use std::process::Command;
4 | use tmux::pane::pid::Pid;
5 |
6 | #[derive(Clone, Debug, Serialize, Deserialize)]
7 | pub struct Process {
8 | pub process: String,
9 | }
10 |
11 | impl Process {
12 | pub fn new(process: S) -> Process
13 | where
14 | S: Into,
15 | {
16 | Process {
17 | process: process.into(),
18 | }
19 | }
20 |
21 | pub fn process_string_from(pid: Pid) -> Result {
22 | // we could cat /proc/pid/cmdline instead of calling pgrep
23 | let output = Command::new("pgrep")
24 | .arg("-lf")
25 | .arg("-P")
26 | .arg(pid)
27 | .output()
28 | .map_err(|e| format!("We couldn't find the process for that pane: {}", e))?;
29 |
30 | let read = String::from_utf8_lossy(&output.stdout);
31 | let process_string = match read.lines().next() {
32 | Some(x) => Process::strip_pid(x),
33 | None => return Err(String::from("No process found")),
34 | };
35 |
36 | Ok(process_string)
37 | }
38 |
39 | fn strip_pid(line: T) -> String
40 | where
41 | T: Into + Clone,
42 | {
43 | let temp = line.into();
44 | temp.split_whitespace()
45 | .skip(1)
46 | .collect::>()
47 | .join(" ")
48 | }
49 | }
50 |
51 | impl fmt::Display for Process {
52 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
53 | write!(f, "{}", self.process)
54 | }
55 | }
56 |
57 | #[cfg(test)]
58 | mod test {
59 | use super::*;
60 |
61 | #[test]
62 | fn expect_to_return_without_first_element() {
63 | let line = "85909 vim .";
64 | let process = Process::strip_pid(line);
65 | assert_eq!(process, "vim .")
66 | }
67 | }
68 |
--------------------------------------------------------------------------------
/snapshot/src/tmux/session.rs:
--------------------------------------------------------------------------------
1 | use serde::{Deserialize, Serialize};
2 | use tmux::window::Window;
3 |
4 | #[derive(Debug, Serialize, Deserialize)]
5 | pub struct Session {
6 | pub name: String,
7 | pub windows: Vec,
8 | }
9 |
10 | impl Session {
11 | pub fn new(name: S, windows: Vec) -> Session
12 | where
13 | S: Into,
14 | {
15 | Session {
16 | name: name.into(),
17 | windows,
18 | }
19 | }
20 |
21 | pub fn find_window(&self, name: &str) -> Option<&Window> {
22 | self.windows.iter().find(|&w| w.name == name)
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/snapshot/src/tmux/window.rs:
--------------------------------------------------------------------------------
1 | use capture::retrieve_capture;
2 | use serde::ser::SerializeMap;
3 | use serde::{Deserialize, Serialize, Serializer};
4 | use std::io;
5 | use std::process::{Command, Output};
6 | use tmux::pane::Pane;
7 |
8 | // Come back and question the accuracy of windows without names
9 | // that have active, or previous window designations.
10 | static NAME_REGEX: &str = r":\s(\w*)[$\*-]?\s+\(";
11 | static ACTIVE_REGEX: &str = r"\s.*(\*)\s";
12 | static LAYOUT_REGEX: &str = r"\s\[layout\s(.*)\]";
13 |
14 | // Example format: "2: vim* (1 panes) [layout b5be,173x42,0,0,1]"
15 | static LIST_FORMAT: &str = "'#{window_index}: #{window_name}#{?window_active,*, } (#{window_panes} panes) [layout #{window_layout}]'";
16 |
17 | #[derive(Debug, Deserialize)]
18 | pub struct Window {
19 | pub active: bool,
20 | pub layout: String,
21 | pub name: String,
22 | pub panes: Vec,
23 | }
24 |
25 | #[derive(Debug, Serialize, Deserialize)]
26 | pub struct WindowInner {
27 | pub active: bool,
28 | pub layout: String,
29 | pub panes: Vec,
30 | }
31 |
32 | impl Window {
33 | pub fn new(active: bool, layout: S, name: S, panes: Vec) -> Window
34 | where
35 | S: Into,
36 | {
37 | Window {
38 | active,
39 | layout: layout.into(),
40 | name: name.into(),
41 | panes,
42 | }
43 | }
44 |
45 | pub fn from_window(panes: Vec, w: Window) -> Window {
46 | Window::new(w.active, w.layout, w.name, panes)
47 | }
48 |
49 | pub fn from_line(line: &str) -> Option {
50 | let active = retrieve_capture(line, ACTIVE_REGEX).is_some();
51 |
52 | let layout = match retrieve_capture(line, LAYOUT_REGEX) {
53 | Some(x) => x,
54 | None => return None,
55 | };
56 |
57 | let name = match retrieve_capture(line, NAME_REGEX) {
58 | Some(x) => x,
59 | None => return None,
60 | };
61 |
62 | Some(Window::new(active, layout, name, vec![]))
63 | }
64 |
65 | pub fn window_list(target: &str) -> Result {
66 | Command::new("tmux")
67 | .args(&["list-windows", "-t", target, "-F", LIST_FORMAT])
68 | .output()
69 | }
70 | }
71 |
72 | impl Serialize for Window {
73 | fn serialize(&self, serializer: S) -> Result
74 | where
75 | S: Serializer,
76 | {
77 | let window = WindowInner {
78 | active: self.active,
79 | layout: self.layout.clone(),
80 | panes: self.panes.clone(),
81 | };
82 |
83 | let mut map = serializer.serialize_map(Some(1))?;
84 | map.serialize_entry(&self.name, &window)?;
85 | map.end()
86 | }
87 | }
88 |
89 | #[cfg(test)]
90 | mod test {
91 | use super::*;
92 |
93 | #[test] // Window with name* representing the active window.
94 | fn expect_some_from_active_window_line() {
95 | let line = "2: vim* (1 panes) [layout b5be,173x42,0,0,1]";
96 | let window = Window::from_line(line);
97 | assert!(window.is_some())
98 | }
99 |
100 | #[test] // Window with name- representing the previous active window.
101 | fn expect_some_from_previous_window_line() {
102 | let line = "2: vim- (1 panes) [layout b5be,173x42,0,0,1]";
103 | let window = Window::from_line(line);
104 | assert!(window.is_some())
105 | }
106 |
107 | #[test] // Window with name and no designation.
108 | fn expect_some_from_window_line() {
109 | let line = "2: vim (1 panes) [layout b5be,173x42,0,0,1]";
110 | let window = Window::from_line(line);
111 | assert!(window.is_some())
112 | }
113 |
114 | #[test] // Window with no name and active.
115 | fn expect_some_from_active_window_blank_name() {
116 | let line = "2: * (1 panes) [layout b5be,173x42,0,0,1]";
117 | let window = Window::from_line(line);
118 | assert!(window.is_some())
119 | }
120 |
121 | #[test] // Window with no name and the previous active window.
122 | fn expect_some_from_previous_window_blank_name() {
123 | let line = "2: - (1 panes) [layout b5be,173x42,0,0,1]";
124 | let window = Window::from_line(line);
125 | assert!(window.is_some())
126 | }
127 |
128 | #[test] // Window with blank name
129 | fn expect_some_with_blank_name() {
130 | let line = "2: (1 panes) [layout b5be,173x42,0,0,1]";
131 | let window = Window::from_line(line);
132 | assert!(window.is_some())
133 | }
134 |
135 | #[test]
136 | fn expect_none_from_line_missing_name() {
137 | let line = "2: (1 panes) [layout b5be,173x42,0,0,1]";
138 | let window = Window::from_line(line);
139 | assert!(window.is_none())
140 | }
141 |
142 | #[test]
143 | fn expect_some_from_line_with_dollar_sign() {
144 | let line = "2: vim$ (1 panes) [layout b5be,173x42,0,0,1]";
145 | let window = Window::from_line(line);
146 | assert!(window.is_some())
147 | }
148 |
149 | #[test]
150 | fn expect_active_to_be_true() {
151 | let line = "2: vim* (1 panes) [layout b5be,173x42,0,0,1]";
152 | let window = Window::from_line(line).unwrap();
153 | assert!(window.active)
154 | }
155 |
156 | #[test]
157 | fn expect_active_to_be_true_without_name() {
158 | let line = "2: * (1 panes) [layout b5be,173x42,0,0,1]";
159 | let window = Window::from_line(line).unwrap();
160 | assert!(window.active)
161 | }
162 |
163 | #[test]
164 | fn expect_name_to_be_vim() {
165 | let line = "2: vim* (1 panes) [layout b5be,173x42,0,0,1]";
166 | let window = Window::from_line(line).unwrap();
167 | assert_eq!(window.name, "vim")
168 | }
169 |
170 | #[test]
171 | fn expect_layout_to_match() {
172 | let line = "2: vim* (1 panes) [layout b5be,173x42,0,0,1]";
173 | let window = Window::from_line(line).unwrap();
174 | assert_eq!(window.layout, "b5be,173x42,0,0,1")
175 | }
176 | }
177 |
--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
1 | //! Muxed. A tmux project manager with no runtime dependencies.
2 | extern crate common;
3 | extern crate docopt;
4 | extern crate edit;
5 | extern crate list;
6 | extern crate load;
7 | extern crate new;
8 | extern crate snapshot;
9 |
10 | use common::args::Args;
11 | use docopt::Docopt;
12 | use std::env;
13 | use std::process::exit;
14 |
15 | #[macro_export]
16 | macro_rules! try_or_err (
17 | ($expr: expr) => ({
18 | match $expr {
19 | Ok(val) => val,
20 | Err(e) => {
21 | println!("Muxed ran in to a problem: {}", e);
22 | exit(1);
23 | }
24 | }
25 | })
26 | );
27 |
28 | static DISALLOWED_SHORTHAND_PROJECT_NAMES: [&str; 4] = ["new", "edit", "load", "snapshot"];
29 |
30 | static USAGE: &str = "
31 | Usage:
32 | muxed (list | ls)
33 | muxed [flags] [options]
34 | muxed edit [options]
35 | muxed load [flags] [options]
36 | muxed new [flags] [options]
37 | muxed snapshot [flags] [options]
38 | muxed (-h | --help)
39 | muxed (-v | --version)
40 |
41 | Flags:
42 | -d If you want to create a muxed session without connecting to it
43 | -f Overwrite existing file if one exists
44 | --debug Prints debug information while executing (project opening only)
45 | -h, --help Prints help information
46 | -v, --version Prints version information
47 |
48 | Options:
49 | -p The directory your project config files live in. Defaults to ~/.muxed/
50 | -t The name of the running TMUX session to codify
51 |
52 | Args:
53 | The name of your project to open
54 |
55 | Subcommands:
56 | list List the availiable project configs
57 | edit Edit an existing project file
58 | load Load the specified project, this is the default command
59 | new To create a new project file
60 | snapshot -t Capture a running session and create a config file for it
61 | ";
62 |
63 | /// The main execution method.
64 | /// Currently accepts a single option. The option represents a configuration
65 | /// file in the same naming format. Given a project file name `projectName.yml`
66 | /// in the `~/.muxed/` directory.
67 | ///
68 | /// # Examples
69 | ///
70 | /// ~/.muxed/projectName.yml
71 | ///
72 | /// ```
73 | /// root: ~/projects/muxed/
74 | /// windows:
75 | /// - cargo: "cargo build"
76 | /// - vim: "vim ."
77 | /// - git: ""
78 | /// ```
79 | ///
80 | /// You can run the command:
81 | ///
82 | /// ```
83 | /// $ ./muxed projectName
84 | /// ```
85 | pub fn main() {
86 | let args: Args = Docopt::new(USAGE)
87 | .and_then(|d| d.deserialize())
88 | .unwrap_or_else(|e| e.exit());
89 |
90 | if args.flag_v {
91 | println!("Muxed {}", env!("CARGO_PKG_VERSION"));
92 | exit(0);
93 | };
94 |
95 | if args.cmd_edit {
96 | try_or_err!(edit::exec(args));
97 | } else if args.cmd_load {
98 | try_or_err!(load::exec(args));
99 | } else if args.cmd_new {
100 | try_or_err!(new::exec(args));
101 | } else if args.cmd_snapshot {
102 | try_or_err!(snapshot::exec(args));
103 | } else if args.cmd_list || args.cmd_ls {
104 | try_or_err!(list::exec(args));
105 | } else {
106 | if DISALLOWED_SHORTHAND_PROJECT_NAMES.contains(&args.arg_project.as_ref()) {
107 | println!(
108 | "Tried to call sub-command '{}' without a project. Please specify a project name.",
109 | args.arg_project
110 | );
111 | exit(1);
112 | }
113 |
114 | try_or_err!(load::exec(args));
115 | }
116 | }
117 |
--------------------------------------------------------------------------------