CHANGELOG.md

@@ -2,6 +2,30 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.1.2] - 2023-07-03
+
+### Features
+
+- Implemented quiet flag
+
+## [0.1.1] - 2023-07-03
+
+### Bug Fixes
+
+- Fixed help formatting
+
+### Documentation
+
+- Added asciinema demo
+
+### Features
+
+- Added no-emoji flag
+
+### Miscellaneous Tasks
+
+- Bump to v0.1.1
+
 ## [0.1.0] - 2023-07-03
 
 ### Documentation
@@ -16,6 +40,10 @@ All notable changes to this project will be documented in this file.
 - Made SUCCESS/FAILURE emoji const
 - Added flag no-emoji
 
+### Miscellaneous Tasks
+
+- Bump v0.1.0, housekeeping
+
 ### Refactor
 
 - Made code more idiomatic

Cargo.lock

@@ -179,7 +179,7 @@ dependencies = [
 
 [[package]]
 name = "gg"
-version = "0.1.0"
+version = "0.1.2"
 dependencies = [
  "clap",
  "clap_mangen",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "gg"
-version = "0.1.0"
+version = "0.1.2"
 edition = "2021"
 authors = ["Christina Sørensen"]
 repository = "https://github.com/cafkafk/gg"

README.org

@@ -7,6 +7,8 @@ with "dotfiles", and with git support as a first class feature. Configuration is
 done throug a single yaml file, giving it a paradigm that should bring joy to
 those that use declarative operating systems and package managers.
 
+#+HTML: <a href="https://asciinema.org/a/TVmnEYR3PK40GtoZnwavun0dP" target="_blank"><img src="https://asciinema.org/a/TVmnEYR3PK40GtoZnwavun0dP.svg" /></a>
+
 Although this isn't really a case where it matters *that* much for performance,
 being written in rust instead of e.g. /janky/ scripting languages does also mean
 it is snappy and reliable, and the /extensive/ (hardly, but eventually) testing

doc/roadmap.org

@@ -3,9 +3,9 @@
 * 0.2.0 (maybe)
 - [ ] Links in categories?
 * 0.1.2
-- [ ] Implement Quiet flag
+- [X] Implement Quiet flag
 * 0.1.1
-- [ ] Implement no-emoji flag
+- [X] Implement no-emoji flag
 * 0.1.0 [100%] [5/5]
 - [X] No functionality regressions
   - [X] commit works in quick, fast

src/cli.rs

@@ -24,13 +24,14 @@ use clap::{ArgAction, CommandFactory, Parser, Subcommand};
 const CONFIG_FILE: &str = "/.config/gg/config.yaml";
 
 const HELP_TEMPLATE: &str = "\
-    {before-help}{name} {version}
-    {author-with-newline}{about-with-newline}
-    {usage-heading} {usage}
+{before-help}{name} {version}
+{about-with-newline}
 
-    {all-args}{after-help}
+{usage-heading} {usage}
 
-    ";
+{all-args}{after-help}
+
+";
 
 //#[clap(author, version, about, long_about = None)]
 #[derive(Parser, Debug)]

src/git.rs

@@ -25,7 +25,8 @@ use std::os::unix::fs::symlink;
 use std::path::Path;
 use std::{fs, process::Command};
 
-use crate::utils::strings::{FAILURE_EMOJI, SUCCESS_EMOJI};
+use crate::settings;
+use crate::utils::strings::{failure_str, success_str};
 
 /// An enum containing flags that change behaviour of repos and categories
 #[derive(PartialOrd, Ord, PartialEq, Eq, Serialize, Deserialize, Debug)]
@@ -349,11 +350,15 @@ impl Config {
     {
         for category in self.categories.values() {
             for (_, repo) in category.repos.as_ref().expect("failed to get repos").iter() {
-                let mut sp = Spinner::new(Spinners::Dots10, format!("{}: {}", repo.name, op));
-                if f(repo) {
-                    sp.stop_and_persist(SUCCESS_EMOJI, format!("{}: {}", repo.name, op));
+                if !settings::QUIET.load(std::sync::atomic::Ordering::Relaxed) {
+                    let mut sp = Spinner::new(Spinners::Dots10, format!("{}: {}", repo.name, op));
+                    if f(repo) {
+                        sp.stop_and_persist(success_str(), format!("{}: {}", repo.name, op));
+                    } else {
+                        sp.stop_and_persist(failure_str(), format!("{}: {}", repo.name, op));
+                    }
                 } else {
-                    sp.stop_and_persist(FAILURE_EMOJI, format!("{}: {}", repo.name, op));
+                    f(repo);
                 }
             }
         }
@@ -405,12 +410,17 @@ impl Config {
                 for instruction in &closures {
                     let f = &instruction.closure;
                     let op = instruction.operation;
-                    let mut sp = Spinner::new(Spinners::Dots10, format!("{}: {}", repo.name, op));
-                    if f(repo) {
-                        sp.stop_and_persist(SUCCESS_EMOJI, format!("{}: {}", repo.name, op));
+                    if !settings::QUIET.load(std::sync::atomic::Ordering::Relaxed) {
+                        let mut sp =
+                            Spinner::new(Spinners::Dots10, format!("{}: {}", repo.name, op));
+                        if f(repo) {
+                            sp.stop_and_persist(success_str(), format!("{}: {}", repo.name, op));
+                        } else {
+                            sp.stop_and_persist(failure_str(), format!("{}: {}", repo.name, op));
+                            break;
+                        }
                     } else {
-                        sp.stop_and_persist(FAILURE_EMOJI, format!("{}: {}", repo.name, op));
-                        break;
+                        f(repo);
                     }
                 }
             }
@@ -451,11 +461,16 @@ impl Config {
                 for instruction in &closures {
                     let f = &instruction.closure;
                     let op = instruction.operation;
-                    let mut sp = Spinner::new(Spinners::Dots10, format!("{}: {}", repo.name, op));
-                    if f(repo) {
-                        sp.stop_and_persist(SUCCESS_EMOJI, format!("{}: {}", repo.name, op));
+                    if !settings::QUIET.load(std::sync::atomic::Ordering::Relaxed) {
+                        let mut sp =
+                            Spinner::new(Spinners::Dots10, format!("{}: {}", repo.name, op));
+                        if f(repo) {
+                            sp.stop_and_persist(success_str(), format!("{}: {}", repo.name, op));
+                        } else {
+                            sp.stop_and_persist(failure_str(), format!("{}: {}", repo.name, op));
+                        }
                     } else {
-                        sp.stop_and_persist(FAILURE_EMOJI, format!("{}: {}", repo.name, op));
+                        f(repo);
                     }
                 }
             }

src/main.rs

@@ -39,6 +39,8 @@ mod cli;
 #[allow(unused)]
 mod git;
 #[allow(unused)]
+mod settings;
+#[allow(unused)]
 mod utils;
 
 use cli::{Args, Commands};
@@ -50,6 +52,8 @@ use clap::Parser;
 #[allow(unused)]
 use log::{debug, error, info, trace, warn};
 
+use std::sync::atomic::Ordering;
+
 /// The main loop of the binary
 ///
 /// Here, we handle parsing the configuration file, as well as matching commands
@@ -62,7 +66,8 @@ fn main() {
         args if args.license => println!("{}", utils::strings::INTERACTIVE_LICENSE),
         args if args.warranty => println!("{}", utils::strings::INTERACTIVE_WARRANTY),
         args if args.code_of_conduct => println!("{}", utils::strings::INTERACTIVE_COC),
-        args if args.quiet => todo!(),
+        args if args.quiet => settings::QUIET.store(true, Ordering::Relaxed),
+        args if args.no_emoji => settings::EMOJIS.store(true, Ordering::Relaxed),
         _ => (),
     }
     match &mut args.command {

src/settings.rs

@@ -0,0 +1,5 @@
+use std::sync::atomic::AtomicBool;
+
+pub static QUIET: AtomicBool = AtomicBool::new(false);
+
+pub static EMOJIS: AtomicBool = AtomicBool::new(false);

src/test/test.yaml

@@ -1,32 +1,4 @@
 categories:
-  utils:
-    repos:
-      li:
-        name: li
-        path: /home/ces/org/src/git/
-        url: git@github.com:cafkafk/li.git
-        flags:
-        - Clone
-        - Push
-      gg:
-        name: gg
-        path: /home/ces/.dots/
-        url: git@github.com:cafkafk/gg.git
-        flags:
-        - Clone
-        - Push
-  empty: {}
-  stuff:
-    flags: []
-    repos:
-      li:
-        name: li
-        path: /home/ces/org/src/git/
-        url: git@github.com:cafkafk/li.git
-      gg:
-        name: gg
-        path: /home/ces/.dots/
-        url: git@github.com:cafkafk/gg.git
   config:
     flags: []
     repos:
@@ -44,6 +16,34 @@ categories:
         flags:
         - Clone
         - Push
+  stuff:
+    flags: []
+    repos:
+      li:
+        name: li
+        path: /home/ces/org/src/git/
+        url: git@github.com:cafkafk/li.git
+      gg:
+        name: gg
+        path: /home/ces/.dots/
+        url: git@github.com:cafkafk/gg.git
+  utils:
+    repos:
+      gg:
+        name: gg
+        path: /home/ces/.dots/
+        url: git@github.com:cafkafk/gg.git
+        flags:
+        - Clone
+        - Push
+      li:
+        name: li
+        path: /home/ces/org/src/git/
+        url: git@github.com:cafkafk/li.git
+        flags:
+        - Clone
+        - Push
+  empty: {}
 links:
 - name: gg
   rx: /home/ces/.config/gg

src/utils/strings.rs

@@ -19,14 +19,18 @@
 //! Ideally, at a VERY long term scale, this should be a nice pattern for
 //! possible translations.
 
+use std::sync::atomic::Ordering;
+
+use crate::settings;
+
 /// Contains the notice for interactive programs from the GPLv3's "How to Apply
 /// These Terms to Your New Programs"
 pub const INTERACTIVE_NOTICE: &str = "\
-gg  Copyright (C) 2023  Christina Sørensen <christina@cafkafk.com>
-This program comes with ABSOLUTELY NO WARRANTY; for details type `gg --warranty'.
-This is free software, and you are welcome to redistribute it
-under certain conditions; type `gg --license' for details.
-";
+gg Copyright (C) 2023 Christina Sørensen <cafkafk.com>
+
+This program comes with ABSOLUTELY NO WARRANTY; for details type `gg
+--warranty'. This is free software, and you are welcome to redistribute it under
+certain conditions; type `gg --license' for details. ";
 
 /// Contains the license part of the long notice for interactive programs from
 /// the GPLv3's "How to Apply These Terms to Your New Programs"
@@ -65,3 +69,25 @@ pub const SUCCESS_EMOJI: &str = "✔";
 
 /// Failure emoji
 pub const FAILURE_EMOJI: &str = "❌";
+
+/// Success string
+pub const SUCCESS_STRING: &str = "SUCC";
+
+/// Failure string
+pub const FAILURE_STRING: &str = "FAIL";
+
+pub fn success_str() -> &'static str {
+    if !settings::EMOJIS.load(Ordering::Relaxed) {
+        SUCCESS_EMOJI
+    } else {
+        SUCCESS_STRING
+    }
+}
+
+pub fn failure_str() -> &'static str {
+    if !settings::EMOJIS.load(Ordering::Relaxed) {
+        FAILURE_EMOJI
+    } else {
+        FAILURE_STRING
+    }
+}