codeshell

#!/usr/bin/bash

curfile="$0"
curdir=$(realpath "$(dirname $curfile)");
default_template="cpp";

detect_distro() {
    if [[ "$OSTYPE" == linux-android* ]]; then
        distro="termux"
    fi

    if [ -z "$distro" ]; then
        distro=$(ls /etc | awk 'match($0, "(.+?)[-_](?:release|version)", groups) {if(groups[1] != "os") {print groups[1]}}')
    fi

    if [ -z "$distro" ]; then
        if [ -f "/etc/os-release" ]; then
            distro="$(source /etc/os-release && echo $ID)"
        elif [ "$OSTYPE" == "darwin" ]; then
            distro="darwin"
        else 
            distro="invalid"
        fi
    fi
}


detect_distro

main="left"
side="right"

echo Distro: $distro
if [[ "$distro" == "termux" ]]; then
  main="top"
  side="bottom"
fi

tmpdir=""
template=""
buildsys="Ninja"
codeshells_dir="$HOME/codeshells"
template_root=$(realpath "$(dirname $0)/../code-templates")

function move_and_restart {
    name="$1"
    if [ -d "$codeshells_dir/$name" ]; then
        echo "The directory ($codeshells_dir/$name) already exists; use another name.";
        exit 1;
    fi
    echo "Creating  $codeshells_dir/$name";
    mkdir -p "$codeshells_dir/$name";
    echo "Movint to $codeshells_dir/$name";
    this_dir=$(realpath .);
    mv -T "$this_dir" "$codeshells_dir/$name";
    tmux kill-pane -a; # kill all the panes
    bash "$curfile" "$name"; # re-run the codeshell
}

function remove_codeshell {
    cmd="$1"
    name="$2"
    if [ "$cmd" = "trash" ]; then
        if command -v trash-put >/dev/null; then
            cmd="trash-put";
        else
            echo "Trash is not supported; please install trash-cli package.";
            echo "  $ sudo pacman -Syu trash-cli";
            exit 1;
        fi
    elif [ "$cmd" = "remove" ]; then
        cmd="rm -rf";
    else
        echo "Unknown command $cmd";
        exit 1;
    fi
    if [ -z "$name" -o "$name" = "." ]; then
        directory=$(realpath .);
        eval $cmd "$directory";
        echo "Removed/Trashed $directory";
        tmux kill-pane -a; # kill all the panes
        return;
    elif [ -d "$codeshells_dir/$name" ]; then
        directory="$codeshells_dir/$name";
        eval $cmd "$directory";
        echo "Removed/Trashed $directory";
        tmux kill-pane -a; # kill all the pane
    else
        echo "The name $name doesn't name a codeshell directory."
        exit 1;
    fi
}

for i in "$@"; do
  case $i in
      -t=*|--template=*)
        template="${i#*=}"
        shift # past argument=value
        ;;

      -n=*|--name=*)
        dir="${i#*=}"
        shift
        ;;

      -h|--help|help)
        echo "Usage: codeshell [template=${default_template}] [name=...]"
        echo "       codeshell help"
        echo "       codeshell save   NAME         # Save the temp codeshell you're in"
        echo "       codeshell remove [NAME]       # Remove the codeshell you're in or the codeshell you named"
        echo "       codeshell trash  [NAME]       # Move to trash the codeshell you're in or the codeshell you named"
        echo
        echo "                 -n=*|--name=*       the name of the project"
        echo "                 -t=*|--template=*   the template to use"
        echo "                 -g=*|-G=*           the build system to use in cmake"
        echo
        echo
        echo "Flow of usage:"
        echo "   Imagine you wanna try something real quick; you type:"
        echo "     $ codeshell c.linux"
        echo
        echo "   Now you do all your testings..."
        echo "   Now you liked the tests and want to save it, you type:"
        echo "     $ codeshell save"
        echo
        echo "   Or maybe the tests weren't good, so you want to remove it:"
        echo "     $ codeshell trash"
        echo
        echo "   Or you if you know the name of your tests already from the get go you type:"
        echo "     $ codeshell c.linux my.pretty.test"
        echo "   Or:"
        echo "     $ codeshell my.pretty.test c.linux"
        echo "   as long as 'c.linux' is a known template in the '$template_root' directory."
        echo
        echo "   If you're using 'trash' instead of 'remove' then you can use trash-cli to manage them:"
        echo "     $ trash-list"
        echo "     $ trash-rm       /tmp/..."
        echo "     $ trash-restore  /tmp/..."
        echo "     $ trash-put      /tmp/..."
        exit;
        ;;

      -g=*|-G=*)
        buildsys="${i#*=}"
        ;;

    save)
        shift;
        move_and_restart $1;
        exit;
        ;;

    ls|list|--list)
        shift;
        ls "$codeshells_dir" --color=auto --hyperlink=auto $@
        exit;
        ;;
        
    remove)
        shift;
        remove_codeshell remove $1;
        exit;
        ;;
        
    trash)
        shift;
        remove_codeshell trash $1;
        exit;
        ;;

      *)
        if [ -d "$template_root/$i" ]; then
            template="$i";
        else
            dir="$i"
        fi
        shift;
        ;;
  esac
done

if [ ! -z "$dir" ]; then
  tmpdir="$codeshells_dir/$dir"
  mkdir -p "$tmpdir"
fi

# if there's no tempalte and no name
if [ -z "${template}" ] && [ ! -z "${tmpdir}" ]; then
  if [ -s "${tmpdir}/.template" ]; then
    template=$(cat "${tmpdir}/.template")
  fi
fi

if [ -z "$template" ]; then
  template="${default_template}"
fi

if [ -z "$tmpdir" ]; then
  tmpdir=$(mktemp -d --suffix=-codeshell)
fi;

tmpdir=$(realpath ${tmpdir});

template_dir="${template_root}/${template}"

if [ ! -d $template_dir ]; then
  echo "The specified template ($template) does not exists. Possible code-templates are:"
    dir="$(dirname $0)/../code-templates";
    echo "Directory: $dir"
    ls "$dir"
  exit;
fi;

if [ -z "$TMUX" ]; then
  window="code-$((1 + RANDOM % 10000000))"
  tmux new -s ${window} -d -c "${tmpdir}"
else
  window=$(tmux display-message -p "#S")
fi

if [[ "$main" == "left" ]]; then
  tmux split-window -t ${window} -h
else
  tmux split-window -t ${window}
fi
tmux select-pane -t ${window}.${side}
tmux resize-pane -t ${window}.${side} -R 18
tmux send-keys -t ${window}.${main} "cd ${tmpdir}" C-m
tmux send-keys -t ${window}.${side} "cd ${tmpdir}" C-m


# copy files if the directory does not exists
if [ `ls -A ${tmpdir} | wc -m` == "0" ]; then
  cp -nTr "$template_dir" "${tmpdir}"
fi;

# write config files:
echo "${template}" > "${tmpdir}/.template";

if [ -f "${tmpdir}/.editor" ]; then
    EDITOR=$(cat "${tmpdir}/.editor");
elif [ -z "$EDITOR" ]; then
    EDITOR="nvim";
fi;

function open_editor() {
  local file="$1";
  local manifest_file="$2";
  local nonblocking=""
  local kill_window=0;
  case "$EDITOR" in
    qtcreator)
        nonblocking="setsid"
        file=$manifest_file;
        ;;
    aqua|clion1|clion|dataspell|phpstorm|pycharm|studio|webstorm)
        file="${tmpdir}";
        kill_window=1;
        ;;
    code)
        file="${tmpdir}";
        ;;
  esac
  if [ "$file" != "nothing" ]; then
    tmux send-keys -t ${window}.${main} "${nonblocking} ${EDITOR} ${file}" C-m
  fi
  if [ $kill_window == 1 ]; then
    tmux send-keys -t ${window}.${main} "tmux kill-window" C-m;
  fi
}

echo "Editor: ${EDITOR}"
echo "Template: ${template}"
echo "Template directory: ${template_dir}"
echo "Code directory: ${tmpdir}"

# run build commands
if [ -f "${template_dir}/.start" ]; then
  start_file="${template_dir}/.start";
  main_file=$(cat "${start_file}" | grep "main:" | cut -d" " -f2- | sed 's/^[ \t]*//;s/[ \t]*$//');
  manifest_file=$(cat "${start_file}" | grep "manifest:" | cut -d" " -f2- | sed 's/^[ \t]*//;s/[ \t]*$//');
  if [ -f "${template_dir}/.watch" ]; then
    tmux send-keys -t ${window}.${side} "/bin/bash ${tmpdir}/.watch" C-m
  fi
  open_editor "$main_file" "$manifest_file";
elif [[ "$template" == asm* ]]; then # make
  tmux send-keys -t ${window}.${side} "find . -name '*.asm' | entr -cs 'make -j10 && ./a.out'" C-m
  open_editor "main.asm" "main.asm";
elif [ -f ${template_dir}/main.lua ]; then # make
  tmux send-keys -t ${window}.${side} "find . -name '*.lua' | entr -cs 'lua main.lua'" C-m
  open_editor "main.lua" "main.lua";
elif [ -f ${template_dir}/package.json ]; then # make
  tmux send-keys -t ${window}.${side} "find . -name '*.js' -or -name '*.json' | entr -cs 'make && npm start'" C-m
  open_editor "index.js" "index.js";
elif [ -f ${template_dir}/Makefile ]; then # make
  if [ -f ${template_dir}/main.c ]; then
    tmux send-keys -t ${window}.${side} "find . -name '*.c' -or -name '*.h' -or -name 'Makefile' | entr -cs 'make -j10 && ./a.out'" C-m
  open_editor "main.c" "main.c";
  else
    tmux send-keys -t ${window}.${side} "find . -name '*.cpp' -or -name '*.h' -or -name '*.hpp' -or -name 'Makefile' | entr -cs 'make -j10 && ./a.out'" C-m
  open_editor "main.cpp" "main.cpp";
  fi;
elif [ -f ${template_dir}/CMakeLists.txt ]; then # CMake
  buildsyscmd="ninja";
  if [ "${buildsys}" == "Ninja" ]; then
    buildsyscmd="ninja"
  elif [ "${buildsys}" == "Unix Makefiles" ]; then
    buildsyscmd="make -j10"
  fi

  echo "Build system generator: cmake"
  echo "Build system: ${buildsys}"
  echo "Build system command: ${buildsyscmd}"

  tmux send-keys -t ${window}.${side} "mkdir -p \"${tmpdir}/build\"" C-m
  tmux send-keys -t ${window}.${side} "cd build/" C-m;
  tmux send-keys -t ${window}.${main} "cmake -G \"${buildsys}\" -B${tmpdir}/build -S${tmpdir}" C-m
  tmux send-keys -t ${window}.${side} "find .. -name '*.cpp' -or -name '*.h' -or -name '*.hpp' -or -name 'CMakeLists.txt' | entr -cs '${buildsyscmd} && ./a.out'" C-m
  open_editor "main.cpp" "CMakeLists.txt";
elif [ -f ${template_dir}/main.py ]; then # Python
  chmod +x ${tmpdir}/main.py
  tmux send-keys -t ${window}.${side} "find . -name 'main.py' | entr -cs '${tmpdir}/main.py'" C-m
  open_editor "main.py" "main.py";
elif [ -f ${template_dir}/main.sh ]; then # Bash
  chmod +x ${tmpdir}/main.sh
  tmux send-keys -t ${window}.${side} "find . -name 'main.sh' | entr -cs '${tmpdir}/main.sh'" C-m
  open_editor "main.sh" "main.sh";
elif [ -f ${template_dir}/Cargo.toml ]; then # Rust
  tmux send-keys -t ${window}.${side} "find . -name '*.rs' | entr -cs 'cd ${tmpdir} && cargo build && cargo run'" C-m
  open_editor "src/main.rs" "Cargo.toml";
fi;

# tmux split-pane -t ${window}.${side} -v
# tmux send-keys -t ${window}.bottom-right "cd ${tmpdir}" C-m
# tmux send-keys -t ${window}.bottom-right "find ${tmpdir} -name \"*.s\" | entr -cs \"clear; cat ${tmpdir}/main.s\"" C-m


tmux select-pane -t ${window}.${main}

if [ -z "$TMUX" ]; then
  tmux attach -t ${window}
fi