dirmux 0.1.1

Directory and git repository command running program
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use std::path::PathBuf;
use structopt::StructOpt;

/// This tool provides a convenient and fast interface to running commands across many directories,
/// managed by tags. This is especially useful when, for example, managing multiple git repositories
/// from a similar organisation.
///
/// The majority of the behaviour is exposed by specific subcommands which are illustrated below,
/// and all have their own help content. However, in addition to these explicit commands dirmux also
/// succinctly supports running any arbitrary shell command instead of the subcommand. As an
/// example:
///
/// $ dirmux du -sh .
///
/// This will evaluate all the size of all the directories you have tagged.
#[derive(Clone, Debug, PartialEq, StructOpt)]
pub struct Options {
    /// Which tag name to operate on
    #[structopt(short)]
    pub tag: Option<String>,

    /// How many concurrent jobs to run
    ///
    /// It might be necessary to tune this if your commands are heavily CPU dependent or use
    /// external, rate-limited resources.
    #[structopt(short, long, default_value = "10")]
    pub jobs: usize,

    #[structopt(subcommand)]
    pub cmd: Subcommands,
}

#[derive(Clone, Debug, PartialEq, StructOpt)]
pub enum Subcommands {
    /// Provides a compact git status
    ///
    /// This subcommand prints a summary of the git status of all the directories. This by default
    /// will skip printing anything for directories that are on their normal branch and have no
    /// outstanding status items (modified files, untracked changes).  The goal is to have a quick
    /// oversight of all your outstanding changes waiting for a commit.
    Status(StatusOpts),

    /// Fast-forward merges your branch from its upstream branch, if possible.
    ///
    /// This subcommand will attempt a fast-forward merge for any git repositories which have
    /// changes to be merged. It will print a message if the merge is not a fast-forward.
    Ffmerge(MergeOpts),

    /// Manipulate the tagged directories
    ///
    /// This provides a number of subcommands for manipulating which directories are tagged with
    /// which tags.
    Tag(TagOpts),

    /// Execute an arbitrary shell command
    ///
    /// This command is just here as a placeholder for the documentation, if the command doesn't
    /// overlap with any of dirmux's subcommand names, you may omit the 'exec' subcommand to have
    /// the same effect.
    Exec(ExecOpts),

    /// Any command is also allowed
    #[structopt(external_subcommand)]
    RawCommand(Vec<String>),
}

#[derive(Clone, Debug, PartialEq, StructOpt)]
pub enum TagSubcommands {
    /// Add tag to this directory
    Add(TagAddOpts),
    /// Remove tag from this directory
    Remove(TagRemoveOpts),
    /// Garbage collect non-existing directories
    ///
    /// This option will check the existence of all the directories and remove tags from
    /// non-existing directories.
    Gc,
}

/// Test
#[derive(Clone, Debug, PartialEq, StructOpt)]
pub struct StatusOpts {}

#[derive(Clone, Debug, PartialEq, StructOpt)]
pub struct MergeOpts {
    /// Only do a dry-run. Do not actually do any merge.
    #[structopt(short, long)]
    pub dry: bool,

    /// Print a verbose diffstat.
    #[structopt(short, long)]
    pub verbose: bool,
}

#[derive(Clone, Debug, PartialEq, StructOpt)]
pub struct TagAddOpts {
    pub tag: String,
    pub path: Option<PathBuf>,
}

#[derive(Clone, Debug, PartialEq, StructOpt)]
pub struct TagRemoveOpts {
    pub tag: String,
    pub path: Option<PathBuf>,
}

#[derive(Clone, Debug, PartialEq, StructOpt)]
pub struct TagOpts {
    #[structopt(subcommand)]
    pub action: TagSubcommands,
}

#[derive(Clone, Debug, PartialEq, StructOpt)]
pub struct ExecOpts {
    #[structopt(subcommand)]
    pub cmd: ExecCmd,
}

#[derive(Clone, Debug, PartialEq, StructOpt)]
pub enum ExecCmd {
    #[structopt(external_subcommand)]
    RawCommand(Vec<String>),
}