gnostr-traverse:initial impl

Author: RandyMcMillan

.github/workflows/ci.yml

@@ -0,0 +1,51 @@
+name: CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    name: Rust (${{ matrix.rust }}) (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - macos-latest
+          - ubuntu-latest
+          - windows-latest
+        rust:
+          - stable
+          - beta
+          - nightly
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          override: true
+          components: rustfmt, clippy
+
+      - uses: actions-rs/cargo@v1
+        with:
+          command: build
+
+      - uses: actions-rs/cargo@v1
+        with:
+          command: test
+
+      - uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
+      - uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --all --all-features --profile test

.gitignore

@@ -0,0 +1,5 @@
+/target
+/Cargo.lock
+/**/*.rs.bk
+.nvmrc
+.gnostr/proxy

Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "gnostr-traverse"
+version = "0.0.1" # remember to update html_root_url
+authors = ["gnostr <[email protected]>", "Isaac Whitfield <[email protected]>"]
+description = "walk a directory structure and do something"
+repository = "https://github.com/gnostr-org/gnostr-traverse"
+keywords = ["backup", "compression", "clean"]
+categories = ["algorithms", "command-line-utilities", "filesystem"]
+readme = "README.md"
+edition = "2021"
+license = "MIT"
+
+[dependencies]
+clap = "2.33"
+walkdir = "2.2"
+
+[profile.release]
+codegen-units = 1
+opt-level = 3
+lto = true

GNUmakefile

@@ -0,0 +1,2 @@
+-:
+	cargo install --path . && gnostr-clean .

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Isaac Whitfield
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,87 @@
+//! Cleaning of unnecessary files in development directories.
+#![doc(html_root_url = "https://docs.rs/detox/0.1.2")]
+mod tasks;
+mod options;
+
+use walkdir::WalkDir;
+
+use crate::options::Options;
+
+use std::env;
+use std::error::Error;
+use std::path::Path;
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // parse in our options from the command line args
+    let options = Options::from(env::args_os());
+
+    // iterate each provided location
+    for location in &options.locations {
+        // grab the size of the location before we start
+        let start = get_size(location);
+
+        // iterate all file entries that we come across in the recursive walk
+        for entry in WalkDir::new(location).into_iter().filter_map(Result::ok) {
+            // grab the full path
+            let path = entry.path();
+            println!("{}", path.display());
+
+            // fetch the file name
+            let segment = path
+                .file_name()
+                .unwrap()
+                .to_str()
+                .expect("a segment should exist");
+
+            // walk through all cleaners
+            for task in &options.tasks {
+                // skip if the cleaner doesn't care
+                if !task.triggers().contains(&segment) {
+                    continue;
+                }
+
+                // grab the dir
+                let dir = path
+                    .parent()
+                    .unwrap()
+                    .to_str()
+                    .expect("dir should be a str");
+
+                // clean the directory
+                print!("{} ", task.name());
+                task.job(dir)?;
+            }
+        }
+
+        // fetch the size of the location when done
+        let end = get_size(location);
+
+        if start >= end {
+            // output the stats
+            println!(
+                "Reduced {} from {} to {} ({:.2}%)",
+                location.display(),
+                start,
+                end,
+                ((start - end) as f64 / start as f64) * 100.0
+            )
+        } else if start == end {
+            println!("No reduction in size!")
+        } else {
+        }
+    }
+
+    // done!
+    Ok(())
+}
+
+/// Determines the size of a directory on the filesystem.
+fn get_size(path: &Path) -> u64 {
+    WalkDir::new(path)
+        .into_iter()
+        .filter_map(Result::ok)
+        .filter(|node| node.file_type().is_file())
+        .filter_map(|file| file.metadata().ok())
+        .map(|meta| meta.len())
+        .sum()
+}

src/main.rs

@@ -0,0 +1,69 @@
+//! Options parsing and configuration for command line interfaces.
+use clap::{App, AppSettings, Arg};
+use std::ffi::OsString;
+use std::path::PathBuf;
+
+use crate::Path;
+use crate::tasks::*;
+
+/// Options struct to store configuration state.
+pub struct Options {
+    pub(crate) tasks: Vec<Box<dyn Task>>,
+    pub(crate) locations: Vec<PathBuf>,
+}
+
+impl Options {
+    /// Creates an `Options` struct from an iterable set of arguments.
+    pub fn from<I, T>(args: I) -> Options
+    where
+        I: IntoIterator<Item = T>,
+        T: Into<OsString> + Clone,
+    {
+        // create a new parser for our args
+        let parser = Options::create_parser();
+
+        // parse out the arguments into matching opts
+        let options = parser.get_matches_from(args);
+
+        // create opts
+        Options {
+            tasks: vec![
+                Box::new(GitTask),
+                Box::new(GnostrTask),
+                Box::new(MakeFileTask),
+                Box::new(NodeTask),
+                Box::new(CargoTask),
+                Box::new(MacosTask),
+            ],
+            locations: options
+                .values_of("locations")
+                .unwrap()
+                .filter_map(|location| PathBuf::from(location).canonicalize().ok())
+                .collect(),
+        }
+    }
+
+    /// Creates a parser used to generate `Options`.
+    fn create_parser<'a, 'b>() -> App<'a, 'b> {
+        App::new("")
+            // package metadata from cargo
+            .name(env!("CARGO_PKG_NAME"))
+            .about(env!("CARGO_PKG_DESCRIPTION"))
+            .version(env!("CARGO_PKG_VERSION"))
+            // arguments and flag details
+            .args(&[
+                // inputs: +required +multiple
+                Arg::with_name("locations")
+                    .help("Locations to search for cleanup")
+                    .multiple(true)
+                    .required(true)
+                    .default_value("."),
+            ])
+            // settings required for parsing
+            .settings(&[
+                AppSettings::ArgRequiredElseHelp,
+                AppSettings::HidePossibleValuesInHelp,
+                AppSettings::TrailingVarArg,
+            ])
+    }
+}