gitignore-common

#! /bin/bash
# The MIT License
# 
# Copyright 2013 Eric VILLARD <dev@eviweb.fr>.
# 
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# 
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
# 
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.

export GITIGNORE_SRC=$GITIGNORE_DIR/vendor/github/gitignore

declare -a GITIGNORE_DIRS=( )

# shell output
warn() { echo "$@" >&2; }
die() { warn "$@"; exit 1; }

escape() {
    echo "$1" | sed 's/\([\.\$\*]\)/\\\1/g'
}

# set logic
has() {
    local item=$1; shift
    echo " $@ " | grep -q " $(escape $item) "
}

# basic string matching
startswith() { [ "$1" != "${1#$2}" ]; }
endswith() { [ "$1" != "${1%$2}" ]; }

# convenience functions for checking shFlags flags
flag() { local FLAG; eval FLAG='$FLAGS_'$1; [ $FLAG -eq $FLAGS_TRUE ]; }
noflag() { local FLAG; eval FLAG='$FLAGS_'$1; [ $FLAG -ne $FLAGS_TRUE ]; }

# print array elements using column format
printcolumn() {
    declare -a values=($@)
    for value in "${values[@]}"; do 
        printf "%-8s\n" "${value}"
    done | column
}

# list *.gitignore files
listgitignores() {
    local pattern="\.gitignore"
    ls $1 | grep $pattern | sed "s/$pattern//g"
}

# split pattern list
splitpatterns() {
    local patterns=$1
    echo ${patterns//,/ }
}

# get gitignore patterns from files
getpatternsfromfile() {
    local file=$(searchpattern "$pattern")
    if [[ -e $file ]]; then
        echo -e "##### begin $pattern #####\n$(cat $file)\n##### end $pattern #####"
    fi
}

# remove gitignore patterns from files
removepatternsfromfile() {
    local file=$(searchpattern "$pattern")
    if [[ -e $file ]]; then
        sed -i "/##### begin $pattern #####/,/##### end $pattern #####/d" $2
    fi
}

# refresh gitignore patterns in files
refreshpatternsinfile() {
    local replacement="$(getpatternsfromfile $pattern | tr '\n' '\r')"
    if [[ -n "$replacement" ]]; then
        local subject="##### begin $pattern #####.*##### end $pattern #####\r"
        local content="$(cat $2)"
        echo "$content" | tr '\n' '\r' | sed "s|$subject|$replacement|g" | tr '\r' '\n' > $2       
    fi
}

# merge pattern file
mergepatterns() {
    declare -a patterns=( $(splitpatterns "$1") )
    local merged=""
    for pattern in "${patterns[@]}"
    do
        merged=${merged}"\n"$(getpatternsfromfile "$pattern")
    done
    echo -e "$merged" | sed '/^$/d'
}

# checks whether a pattern is in a file
ispatterninfile() {
    cat "$2" | grep  "begin $1" 1> /dev/null
}

# normalize file content
normalizecontent() {
    echo -e "$@" | sed "s/ /\n/g"
}

# define gitignore file as global
setglobal() {
    git config --global core.excludesfile $(readlink -f "$1")
}

# remove gitignore from global
unsetglobal() {
    git config --global --unset core.excludesfile
}

# retrieve the global gitignore file
getglobal() {
    git config --global --get core.excludesfile
}

# retrieve subactions
getsubactions() {
    normalizecontent $(declare -F | grep cmd_ | sed "s/^[^_]*cmd_//g")   
}

# check if a string is a subaction
issubaction() {
    local action=$(getsubactions | grep "$1")
    if [[ "$action" == "$1" ]]; then
        return 0
    fi
    return 1
}

# update list of registered paths
updaterepopathlist() {
    local file=$GITIGNORE_CONFIG_DIR/repositories
    local list="$(find $GITIGNORE_SRC -type d -name "[!.]*")"
    if [[ -e $file ]]
    then
        list=$list' '$(cat $file | awk '/^[^#]/{print $NF}' | tr '\n' ' ')
    fi
    eval "GITIGNORE_DIRS=( $list )"
}

# search pattern in a file
searchpattern() {
    updaterepopathlist
    local i=0
    local l=${#GITIGNORE_DIRS[@]}
    while [ $i -lt $l ] && [[ ! -e ${GITIGNORE_DIRS[i]}/$pattern.gitignore ]]
    do
        (( i++ ))
    done
    if [[ -e ${GITIGNORE_DIRS[i]}/$pattern.gitignore ]]
    then
        echo ${GITIGNORE_DIRS[i]}/$pattern.gitignore
    fi
}

# get git repositories
getgitrepos() {
    local file=$GITIGNORE_CONFIG_DIR/repositories
    local list=""
    if [[ -e $file ]]
    then
        echo $(cat $file | grep ' git ' | awk '/^[^#]/{print $NF}' | tr '\n' ' ')
    fi
}