#!/bin/bash

version="0.1.0"

script=${0##*/}

usage="\

Module Git (v$version)

Global Commands:

$script [options] <command>

-------------------------------

init initialize .modgit folder

list list all modules that are currently installed

update-all update all modules that are currently installed

-h this help

-v display the modgit script's version

Module Commands:

$script [options] <command> <module> [<src>] [<git options>]

----------------------------------------------------------------

clone <module> <src> clone a git repository

update <module> update module

remove <module> remove module

[<git options>] specify additional parameters to git clone

-i include filter: -i app/ -i README [...]

-e exclude filter: -e file.txt -e lib/tests [...]

"

dry_run=0

includes=''

excludes=''

add_include()

{

if [ -z $includes ]; then

includes="$1"

else

includes="$includes\n$1"

fi

}

add_exclude()

{

if [ -z $excludes ]; then

excludes="$1"

else

excludes="$excludes\n$1"

fi

}

# Handle options

while getopts ":nvhi:e:" opt; do

case $opt in

h)

echo -e "$usage"

exit 0

;;

v)

echo "Module Git version: $version"

exit 0

;;

n)

dry_run=1

shift $((OPTIND-1)); OPTIND=1

;;

i)

add_include "$OPTARG"

shift $((OPTIND-1)); OPTIND=1

;;

e)

add_exclude "$OPTARG"

shift $((OPTIND-1)); OPTIND=1

;;

\?)

echo "Invalid option: -$OPTARG" >&2

exit 1

;;

:)

echo "Option -$OPTARG requires an argument." >&2

exit 1

;;

esac

done

# Echo in bold

echo_b()

{

if [ "$1" = "-e" ]; then

echo -e "$(tput bold)$2$(tput sgr0)"

else

echo "$(tput bold)$1$(tput sgr0)"

fi

}

# Initializes .modgit folder in root dir then quit

if [ "$1" = "init" ]; then

mkdir .modgit || { echo_b "Could not create .modgit directory" && exit 1; }

echo_b "Initialized Module Git at $(pwd)"

exit 0

fi

# Checks if module dir exists or quit

require_module_dir()

{

if ! [ -d "$modgit_dir/$1" ]; then

echo_b "ERROR: $1 does not exist.";

exit 1

fi

return 0

}

delete_files()

{

local module=$1

local module_dir="$modgit_dir/$module"

local deployed_file="$module_dir/deployed.modgit"

while read line; do

if ! [ -z $line ] && [ -f "$root/$line" ]; then

rm "$root/$line" 2>/dev/null

prev_dir=''

dir=$(dirname $line)

while [ "$dir" != "$prev_dir" ]; do

prev_dir=$dir

test_dir="$root/$dir"

if ! [ "$(ls -A $test_dir)" ]; then

rmdir $test_dir

fi

dir=${dir%/*}

done

fi

done < <(cat "$deployed_file" 2>/dev/null)

return 0

}

# Removes a module

delete_module()

{

local module=$1

local module_dir="$modgit_dir/$module"

if delete_files "$module" &&

rm -rf "$module_dir" 2>/dev/null;

then

return 0

else

return 1

fi

}

deploy_file()

{

mkdir -p $(dirname $2) && cp "$1" "$2"

}

# Synchronizes files from module dir to root dir, then store deployed files for easy remove

move_files()

{

local module=$1

local module_dir="$modgit_dir/$module"

local source_dir="$module_dir/source"

local includes_file="$module_dir/includes.modgit"

local excludes_file="$module_dir/excludes.modgit"

local modman_file="$source_dir/modman"

local deployed_file="$module_dir/deployed.modgit"

cd "$source_dir" || return 1

while read file; do

# Copy file by default

copy=1

target="$file"

# Include filters

if [ -s "$includes_file" ]; then

copy=0

while read filter; do

src=$(echo $filter | cut -d: -f1)

if [ -z $src ]; then

continue

fi

if [[ "$file" =~ ^$src ]]; then

copy=1

# Handle optional different target

real=$(echo $filter | cut -d: -f2)

if [ "$src" != "$real" ]; then

tmp_src=$(echo $src | sed 's/^[\/]*//;s/[\/]*$//')

tmp_src="$tmp_src/"

tmp_src="${tmp_src//\//\\/}"

tmp_real=$(echo $real | sed 's/^[\/]*//;s/[\/]*$//')

tmp_real="$tmp_real/"

tmp_real="${tmp_real//\//\\/}"

target=$(echo $file | sed "s/$tmp_src/$tmp_real/g")

fi

break

fi

done < <(cat "$includes_file")

fi

# Exclude filters

if [ -s "$excludes_file" ] && [ $copy -eq 1 ]; then

while read filter; do

if [[ "$file" =~ ^$filter ]]; then

copy=0

break

fi

done < <(cat "$excludes_file")

fi

if [ $copy -eq 1 ]; then

# Handle modman file

if [ -s "$modman_file" ]; then

while read line; do

if [ -z "$line" ] || [[ $line =~ ^# ]] || [[ $line =~ ^@ ]]; then

continue

fi

set -- $line

if [[ "$file" =~ ^$1 ]]; then

# Remove trailing slashes and escape paths for sed

src=$(echo $1 | sed 's/^[\/]*//;s/[\/]*$//')

dest=$(echo $2 | sed 's/^[\/]*//;s/[\/]*$//')

src="${src//\//\\/}"

dest="${dest//\//\\/}"

target=$(echo $file | sed "s/$src/$dest/g")

deploy_file "$file" "$root/$target"

echo "$target" >> "$deployed_file"

fi

done < <(cat "$modman_file")

else

deploy_file "$file" "$root/$target"

echo "$file" >> "$deployed_file"

fi

fi

done < <(find . -type f | grep -v '^\.\/.git.*' | sed 's/^\.\///')

return 0

}

# Creates module dir, clones git repo and optionally stores include/exclude filters

create_module()

{

local repo=$1;

local module=$2

local module_dir="$modgit_dir/$module"; shift 2

local source_dir="$module_dir/source"

local git_options=$@

cd "$modgit_dir"

if ! git clone --recursive $git_options -- $repo "$source_dir"; then

echo_b "Error cloning $repo to $source_dir."

rm -rf "$module_dir" 2>/dev/null

exit 1

fi

if ! [ -z $includes ]; then

echo -e $includes > "$module_dir/includes.modgit"

fi

if ! [ -z $excludes ]; then

echo -e $excludes > "$module_dir/excludes.modgit"

fi

return 0

}

# Updates a module

update_module()

{

local module=$1

local module_dir="$modgit_dir/$module"

local source_dir="$module_dir/source"

local success=0

require_module_dir "$module"

cd "$source_dir"

git pull && git submodule update --init --recursive && success=1

if [ $success -eq 1 ] &&

delete_files "$module" &&

move_files "$module";

then

return 0

else

return 1

fi

}

# Try to find .modgit dir

_pwd=$(pwd -P)

root=$_pwd

if ! [ -d $root/.modgit ]; then

echo_b "-e" "Module Git directory not found.\nRun \"$script init\" in the root of your project."

exit 1

fi

modgit_dir=$root/.modgit # path to .modgit

# list command

if [ "$1" = "list" ]; then

if [ -n "$2" ]; then echo "Too many arguments for list command."; exit 1; fi

while read -d $'\n' module; do

test -d "$modgit_dir/$module" || continue;

require_module_dir "$module" && echo "$module"

done < <(ls -1 "$modgit_dir")

exit 0

# update-all command

elif [ "$1" = "update-all" ]; then

if [ -n "$2" ]; then echo "Too many arguments for update-all command."; exit 1; fi

update_errors=0

updated=''

while read -d $'\n' module; do

test -d "$modgit_dir/$module" || continue;

echo "Updating $module..."

if ! update_module "$module"; then

echo_b "-e" "Error occurred while updating '$module'.\n"

update_errors=$((update_errors+1))

fi

done < <(ls -1 "$modgit_dir")

echo_b "Updated all modules with $update_errors update errors."

exit 0

# remove-all command

elif [ "$1" = "remove-all" ]; then

if [ -n "$2" ]; then echo "Too many arguments for remove-all command."; exit 1; fi

removeall_errors=0

removeall=''

while read -d $'\n' module; do

test -d "$modgit_dir/$module" || continue;

echo "Remove $module..."

if ! delete_module "$module"; then

echo_b "-e" "Error occurred while masive remove '$module'.\n"

removeall_errors=$((removeall_errors+1))

fi

done < <(ls -1 "$modgit_dir")

echo_b "Remove all modules with $removeall_errors remove errors."

exit 0

fi

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

# Handle all other module-specific commands #

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

REGEX_ACTION='(clone|update|remove|tmp)'

# Action is first argument

action=''

if [[ "$1" =~ $REGEX_ACTION ]]; then

action=$1; shift

fi

# If no module discovered or valid module is specified on command line

if [ -z "$module" ] || [ -n "$1" -a -d "$modgit_dir/$1" ]; then

module=$1; shift # module name is first argument

fi

[ -z "$module" ] && { echo_b "Not enough arguments (no module specified)"; exit 1; }

[ -z "$action" ] && { echo_b "Not enough arguments (no action specified)"; exit 1; }

cd "$_pwd" # restore old root

module_dir="$modgit_dir/$module" # working copy directory for module

# Handle module action

case "$action" in

clone)

if [[ "$module" =~ $REGEX_ACTION ]]; then

echo_b "-e" "You cannot $action a module with a name matching $REGEX_ACTION.\nModule specified: $module" && exit 1

fi

if [[ "$module" =~ [^a-z0-9_-]+ ]]; then

echo_b "-e" "You cannot $action a module with a name not matching [^a-z0-9_-]+ pattern.\nModule specified: $module" && exit 1

fi

if [ -d "$module_dir" ]; then

echo_b "A module with this name has already been cloned." && exit 1

fi

repo=$1; shift

create_module $repo $module $@ && success=1

if [ $success -eq 1 ]; then

if require_module_dir "$module" &&

move_files "$module";

then

echo_b "Clone of $module complete."

fi

else

if [ -d "$module_dir" ]; then rm -rf "$module_dir"; fi

echo_b "Error cloning $module, operation cancelled."

fi

;;

update)

if update_module "$module"

then

echo_b "Update of $module complete."

else

echo_b "Error updating $module, operation cancelled."

fi

;;

remove)

if require_module_dir "$module" &&

delete_module "$module";

then

echo_b "Removal of $module complete."

else

echo_b "Error removing $module, operation cancelled."

fi

;;

*)

echo -e "$usage"

echo_b "Invalid action: $action";

exit;

esac