jargo

#!/bin/bash

# Jargo - Java Project Manager
#
# A simple script to manage a Java project
#
# Author: Daniel Hammer
# Date: 2021-04-21
#
# Exit codes:
# 0 - Program success
# 1 - Insufficient usage
# 2 - Unknown command passed to Jargo
# 3 - No name supplied during project creation
# 4 - Supplied invalid name during project creation
# 5 - Supplied invalid argument during project creation/initialization

########## GLOBAL VARIABLES ###########

# Project configuration file
CONFIG="jargo.cfg"

# Project name
name=""

# Name of package where driver resides
package=""

# Name of driver file
driver=""

# Name of primary module file
MODULE="module-info.java"

# ANSI text colors
RESET="\e[0m"
YELLOW="\e[1;33m"

#######################################

# Initialize globals
if [ -r "$CONFIG" ]; then
    name=$(awk -F: '/name/ { print $2 }' $CONFIG)
    package=$(awk -F: '/package/ { print $2 }' $CONFIG)
    driver=$(awk -F: '/driver/ { print $2 }' $CONFIG)
else
    name="$USERJavaProject"
    package="App"
    driver="Main"
fi

################################################################################
# Displays usage message.
#
# Outputs:
#   A usage message.
################################################################################
usage() {
    echo "Simple Java Project Manager

USAGE:
    usage: jargo [OPTIONS] [COMMANDS]

OPTIONS:
    -h, --help          Display this menu
        --list          List all commands

COMMANDS:
    new, n              Create a new Java project
    init                Initialize an existing project as a Jargo project
    build, b            Builds project, compiling classes if updates were made
    run, r              Runs the driver for this project
    clean               Cleans working directory of *.class files
    doc                 Generate documentation files
    add                 Add a dependency (only javafx is support currently)

See \`jargo help <COMMAND>\` for command-specific information"
}

################################################################################
# Handles graceful cleanup and shutdown.
#
# Arguments:
#   $1: Error code to exit with.
#   ${@}: List of files to remove.
#
# Outputs:
#   A message displaying what files are being removed.
################################################################################
shutdown() {
    # Debug printing
    #echo "Exiting with error code $exit_status"
    
    # Store exit code and shift to next arg
    exit_status=$1
    shift

    # Remove all files in the remaining arguments
    for arg in "${@}"; do
        echo "Cleaning up: Removing $arg"
        rm -rf $arg
    done

    # Exit with saved status
    exit $exit_status
}

################################################################################
# Handles creation of new project.
#
# Globals:
#   name: Project directory name.
#   package: Package name where the driver resides.
#   driver: Name of the driver file.
#
# Outputs:
#   A message displaying that the project was created.
#
# Arguments:
#   $1: Name of project to create.
################################################################################
new() {
    # Initialize default configuration variables
    name=$1
    git=1

    # Ensure a project name was passed in
    if [ -z "$name" ]; then
        echo "usage: jargo new <NAME> [OPTIONS]"
        shutdown 3
    fi

    # If the directory already exists, throw an error
    if [ -d "$name" ]; then
        echo "Error: $name already exists"
        shutdown 4
    fi

    shift # Consume project name and begin scanning flags
    while (($#)); do
        case $1 in
            "-n") # Change primary package name
                shift
                package=$1
                ;;

            "-d") # Change driver filename
                shift
                driver=$1
                ;;

            "--no-git") # Do not initialize a git repository
                shift
                git=0
                ;;

            *) # Unknown argument
                echo "Error: Unknown argument \`$1\`"
                shutdown 5
                ;;
        esac
        
        shift # Continue looping through arguments
    done

    # Set up directory structure
    mkdir -p $name/src/$package
    mkdir -p $name/bin

    # Create configuration file
    echo "# Configuration file for Jargo Project Manager (https://github.com/HammerAPI/jargo)
name:$name
package:$package
driver:$driver" > $name/$CONFIG

    # Get current system time
    local time=$(date +"%Y-%m-%d %T")

    # Set up Main class
    echo "package $package;

/**
 * Driver Class.
 *
 * @author $USER
 * @version $time
 */
public class $driver {
    /**
     * Main
     *
     * @param args List of arguments supplied by executor.
     */
    public static void main(String[] args) {
        System.out.println(\"Hello, world!\");
    }
}" > $name/src/$package/$driver.java

    # Create module file
    echo "/**
 * Default module.
 */
module $name {
    
}" > $name/src/$MODULE

    # Set up README.md
    echo "# $name " > $name/README.md

    # Initialize Git repository (if not disabled)
    if [ $git -eq 1 ]; then
        git init $name/ > /dev/null
        echo "*.class" > $name/.gitignore
        echo "bin/" >> $name/.gitignore
        echo "docs/" >> $name/.gitignore
    fi

    # End
    echo -e "\t${YELLOW}CREATED${RESET} new Java project: \"$name\""
}

################################################################################
# Handles compilation of a project.
#
# Arguments:
#   ${@}: All compilation arguments.
#
# Outputs:
#   Possible output of an "already up to date" message.
#
# Returns:
#   0 if compilation was successful, else a non-zero error code.
################################################################################
build() {
    # Ensure command was run from project root
    if [ $(in_root) -ne 1 ]; then
        echo "Error: \"${PWD##*/}\" not a project root."
        return 1
    fi

    # Only recompile if needed
    if [ $(needs_rebuild) -eq 1 ]; then
        # Parse the args and shift
        args=$(arg_parser ${@})
        shift $?

        compile ${args[@]}
        return=$?
    else
        echo "Project binaries are up to date."
        return 0
    fi
}

################################################################################
# Handles execution of application.
#
# Globals:
#   name: Project directory name.
#   package: Package name where the driver resides.
#   driver: Name of the driver file.
# 
# Outputs:
#   A message displaying that the project was ran.
#
# Arguments:
#   ${@}: All command line arguments passed by the user, to be sent to `main()`.
################################################################################
run() {
    # Ensure command was run from project root
    if [ $(in_root) -ne 1 ]; then
        echo "Error: \"${PWD##*/}\" not a project root."
        return
    fi

    # By default, status is OK to run
    local status=0

    # Parse the args and shift
    args=$(arg_parser ${@})
    local shift_amt=$?
    shift $shift_amt

    # If the project needs to be recompiled, do so.
    if [ $(needs_rebuild) -eq 1 ]; then
        compile ${args[@]}
        status=$?
    fi


    # Only execute if compilation was successful
    if [ $status -eq 0 ]; then
        if [ ${#args[@]} -gt 0 ]; then
            echo -e "\t${YELLOW}EXECUTING${RESET} $name with args: ${args[@]} ${@}"
        else
            echo -e "\t${YELLOW}EXECUTING${RESET} $name"
        fi

        # Execute driver with supplied args
        java ${args[@]} -cp bin/ $package.$driver ${@}
    fi
}

################################################################################
# Cleans project directory of class files
# 
# Outputs:
#   A message displaying that the project was cleaned.
#
# Arguments:
#   ${@}: Flags to clean additional directories.
################################################################################
clean() {
    # Ensure command was run from project root
    if [ $(in_root) -ne 1 ]; then
        echo "Error: \"${PWD##*/}\" not a project root."
        return
    fi

    # Handle optional arguments
    for arg in "${@}"; do
        # Delete docs, if requested
        if [ "$arg" = "--doc" ] || [ "$arg" = "-d" ]; then
            rm -rf docs/*
        fi
    done

    # Recursively delete all *.class files in bin/
    find bin/ -name "*.class" -delete

    echo -e "\t${YELLOW}CLEANED${RESET} project binaries."
}

################################################################################
# Generates documentation for the project.
#
# Globals:
#   name: Project root name.
#
# Outputs:
#   A message stating that documentation was created.
################################################################################
doc() {
    # Ensure command was run from project root
    if [ $(in_root) -ne 1 ]; then
        echo "Error: \"${PWD##*/}\" not a project root."
        return
    fi

    # Need to pass in special args for JavaFX?
    args=$(arg_parser ${@})
    shift $?

    # Mute output when documenting, but display errors
    find src/ -name "*.java" -print | xargs javadoc ${args[@]} -d docs > /dev/null


    echo -e "\t${YELLOW}GENERATED${RESET} docs for project under \`$name/docs/\`"
}

################################################################################
# Adds dependencies to the project
#
# Globals:
#   name: Project root name.
#   MODULE: Project module file.
#
# Arguments:
#   ${@}: Dependencies and flags to add.
#
# Outputs:
#   A message declaring that a dependency was added
################################################################################
add() {
    # Ensure command was run from project root
    if [ $(in_root) -ne 1 ]; then
        echo "Error: \"${PWD##*/}\" not a project root."
        return
    fi

    if [ ${#@} -lt 1 ]; then
        echo "usage: jargo add <dependency>"
        return
    fi

    # Keep track of number of dependencies added
    local added=0

    # Add each dependency
    for arg in "${@}"; do
        case "$arg" in
            "jfx" | "javafx") # Add JavaFX support
                sed -i "/module $name/a requires javafx.controls;" src/$MODULE
                added=$((added + 1))
                ;;

            *)
                echo "Unsupported dependency \`$arg\`. Not yet implemented"
                ;;
        esac
    done

    if [ $added -ne 0 ]; then
        echo -e "\t${YELLOW}ADDED${RESET} $added dependencies for project under \`$name/src/$MODULE\`"
    fi
}

################################################################################
# Initializes an existing project to be a Jargo project.
#
# Globals:
#   name: Project root name.
#   driver: Driver file name.
#   package: Package name containing driver file.
#   MODULE: Project module file.
#
# Arguments:
#   ${@}: Initialization flags.
#
# Outputs:
#   A message declaring that the project was initialized.
################################################################################
init() {
    # Ensure command was not run from project root
    if [ $(in_root) -eq 1 ]; then
        echo "Error: \"${PWD##*/}\" is already a project root."
        return
    fi

    # Default to initializing a git repository
    local git=1
    
    # Get name of current directory
    name=$(basename $(pwd))

    # Get name of the driver (where main is located)
    driver=$(grep -lr "public static void main" src/ | xargs basename -s ".java")

    # Get name of the package containing driver
    package=$(grep -lr "public static void main" src/ | xargs dirname | xargs basename)

    for arg in "${@}"; do
        case $arg in
            "--no-git") # Do not initialize a git repository
                shift
                git=0
                ;;

            *) # Unknown argument
                echo "Error: Unknown argument \`$arg\`"
                shutdown 5
                ;;
        esac
    done

    # Create configuration file
    echo "# Configuration file for Jargo Project Manager (https://github.com/HammerAPI/jargo)
name:$name
package:$package
driver:$driver" > $CONFIG

    # Set up README.md
    echo "# $name " > README.md

    # Initialize Git repository (if not disabled)
    if [ $git -eq 1 ]; then
        git init > /dev/null
        echo "*.class" > .gitignore
        echo "bin/" >> .gitignore
        echo "docs/" >> .gitignore
    fi

    echo -e "\t${YELLOW}INITIALIZED${RESET} Project under \`$name/src/$MODULE\`"
}

################################################################################
# Checks if the project needs to be recompiled.
#
# Returns
#   1 if project must be recompiled, else 0.
################################################################################
needs_rebuild() {
    local retval=0

    # Fetch arrays of all files in `bin/` and `src/`
    bins=($(find bin -type f -exec echo {} \;))
    srcs=($(find src -type f -exec echo {} \;))

    # If there are fewer binaries than source files, compile
    if [ ${#bins[@]} -lt ${#srcs[@]} ]; then
        retval=1
    fi

    # Loop over both arrays
    for ((i=0; i<${#bins[@]}; i++)); do

        # If any source file is newer, recompile
        if [ "${srcs[i]}" -nt "${bins[i]}" ]; then
            retval=1
        fi
    done

    echo $retval
}

################################################################################
# Actually compiles the project.
#
# Globals:
#   name: Project root name.
#
# Outputs:
#   A message displaying a successful compilation.
#
# Arguments:
#   ${@}: List of arguments to compile with.
#
# Returns:
#   0 If program was compiled successfully.
################################################################################
compile () {
    # Compile with new args
    find src/ -name "*.java" -print | xargs javac ${@} -d bin/
    local retval=$?

    # Display compilation message if no errors occurred
    if [ $retval -eq 0 ]; then

        # Display appropriate compilation message
        if [ ${#@} -gt 0 ]; then
            echo -e "\t${YELLOW}COMPILED${RESET} $name with args: ${@}"
        else
            echo -e "\t${YELLOW}COMPILED${RESET} $name"
        fi
    fi

    return $retval
}


################################################################################
# Determines if `jargo` was run from a project's root.
#
# Globals:
#   name: Ensure this command is being run from the project root.
#
# Returns
#   1 if ran from project root, else 0.
################################################################################
in_root() {
    local retval=0

    # If the working directory is the same as the project's name
    if [ "${PWD##*/}" == "$name" ]; then
        retval=1
    fi

    echo $retval
}

################################################################################
# Parses arguments supplied for the `java` and `javac` commands.
#
# Arguments:
#   ${@}: List of arguments to be parsed.
#
# Returns
#   A list of parsed arguments.
#   The number of arguments parsed.
################################################################################
arg_parser() {
    # Local variables for args and shifting
    local shift_amt=0
    local args=()

    # Loop over every arg provided
    for arg in ${@}; do
        # If the arg is empty, ignore it
        if [ -z "$arg" ]; then
            continue
        fi

        # Parse the args
        case "$arg" in
            "--jfx" | "--fx") # Add JFX support
                # Increase shift amount
                shift_amt=$((shift_amt + 1))
                args+=("--module-path $PATH_TO_FX --add-modules javafx.controls")
                ;;

            *) # No parsing needed
                ;;
        esac
    done

    echo "${args[@]}"
    return $shift_amt
}

################################################################################
# Project Main Method.
#
# Arguments:
#   ${@}: All command line arguments supplied by the user.
################################################################################
main () {
    # Check minimum args
    if [ $# -lt 1 ]; then
        usage
        shutdown 1
    fi

    # Launch appropriate command
    case $(echo $1 | tr '[:upper:]' '[:lower:]') in
        "new" | "n") # Create new project
            shift
            new ${@}
            ;;

        "build" | "b") # Compile project
            shift
            build ${@}
            ;;

        "run" | "r") # Run project
            shift
            run ${@}
            ;;

        "clean") # Clean project
            shift
            clean ${@}
            ;;

        "doc") # Generate documentation for project
            shift
            doc ${@}
            ;;

        "add") # Adds dependencies to the project
            shift
            add ${@}
            ;;

        "init") # Initializes an existing project as a Jargo project
            shift
            init ${@}
            ;;

        "--help" | "-h") # Display help menu
            shift
            usage
            ;;

        *) # Unknown arg
            echo "Error: Unknown command \`$1\`"
            shutdown 2
            ;;
    esac
}


# Execute main and exit with appropriate error code
main ${@}

# Program success
exit $?