makewiz 0.8.0

MakeWiz is a command line tool that generates a Makefile based on the files in your directory
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


//! Defines the command line interface (CLI) structure for MakeWiz.
//!
//! This module specifies all the available commands and arguments that users can use when
//! running MakeWiz via the command line. It also handles various C/C++ flags provided by the user.

use clap::{Parser, Subcommand, Args};

/// This struct defines and handles all the available
/// commands, options, and flags. 
#[derive(Parser)]
#[command(author, version, about)]
pub struct CLI {
    #[command(subcommand)]
    pub command: Option<Commands>,

    /// Set the C/C++ compiler name for this Makefile
    #[arg(short, long, value_name = "COMPILER_NAME")]
    pub compiler: Option<String>,

    /// Set the C/C++ executable name for this Makefile
    #[arg(short, long, value_name = "EXECUTABLE_NAME")]
    pub executable: Option<String>,

    /// Add the math library(-lm) to this Makefile
    #[arg(short, long)]
    math: bool,

    /// Add the thread library(-lpthread) to this Makefile
    #[arg(short, long)]
    thread: bool,

    /// Add the crypto library(-lcrypto) to this Makefile
    #[arg(short = 'r', long)]
    crypto: bool,

    /// Add the CUnit library(-lcunit) to this Makefile
    #[arg(long)]
    cunit: bool,

    /// Add the CPPUnit library(-lcppunit) to this Makefile
    #[arg(long)]
    cppunit: bool,
}

/// Represents the available commands for the MakeWiz CLI.
#[derive(Subcommand)]
pub enum Commands {
    /// Generate a Java Makefile
    Java,

    /// Set the default C/C++ compiler name
    SetCompiler(NameArgument),

    /// Set the default C/C++ executable name
    SetExecutable(NameArgument),

    /// Show default values
    Default,
}

/// Represents a single argument for setting a compiler/executable name.
#[derive(Args)]
#[group(required = true)]
pub struct NameArgument {
    pub name: String,
}

impl CLI {
    /// Checks if subcommands have been provided by the user.
    pub fn subcommands_provided(&self) -> bool {
        self.command.is_some()
    }

    /// Checks if flags have been provided by the user.
    pub fn flags_provided(&self) -> bool {
        self.executable.is_some() || self.compiler.is_some()
    }

    /// Parses the provided flags and returns a tuple containing lflags and ldlibs.
    pub fn parse_flags(&self) -> (String, String) {
        let mut lflags = String::from("");
        let mut ldlibs = String::from("");

        // LFLAGS
        if self.thread { lflags.push_str("-lpthread "); }
        if self.math { lflags.push_str("-lm"); }

        // LDLIBS
        if self.cunit { ldlibs.push_str("-lcunit "); }
        if self.cppunit { ldlibs.push_str("-lcppunit "); }
        if self.crypto { ldlibs.push_str("-lcrypto"); }

        (lflags.trim_end().to_string(), ldlibs.trim_end().to_string())
    }
}