pre-commit

#!/bin/bash

#
#  Global Variable
#

login="forget_c"
ignore_files=""
path_subject="subject.pdf"
step=("ANALYSIS" "DEVELOP" "REVIEW" "FAT" "DONE")

config_file=".git/.config"

date=$(date +"%m-%d-%y")
versions="v1.0"
license="GNU General Public License v3.0"
project=""
info="Epita 2019 - ING 1"
clangformat=".clang-format"

#
#  End Global Variable
#
if [ ! -t 0 ]; then
  [ -z "$(grep "TTY" < ~/.bashrc)" ] &&
  echo 'TTY=$(tty)' >> ~/.bashrc &&
  echo 'export TTY' >> ~/.bashrc &&
  echo "relaunch your terminal please" &&
  exit 1
else
  TTY=$(tty)
fi
#
# correct the coding style
# $1 file to correct
# $? info on correction
#
function coding
{
  local ret=0
  local file=$1
  check_coding $file
  diff $file $file.cod &> /dev/null
  if [ $? -eq 1 ]; then
    vim -d "+nnoremap <enter> :xa<cr>" $file $file.cod < $TTY
  else
    ret=1
  fi

  check_coding $file
  diff $file $file.cod &> /dev/null
  if [ $? -eq 1 ]; then
    ret=2
    read -p "Auto correct :(Y/n)" correct < $TTY
    [[ ! $correct = "n" ]] && cp $file.cod $file && ret=3
  fi
  rm $1.cod
  git add $1
  return "$ret"
}

#
# stock correct coding style of file in file.cod
# $1 file to correct
#
function check_coding
{
  local file="$1"
  if [ -z $clangformat ]; then
    cp $file $file.cod
    clang-format -assume-filename=$clangformat -i $file.cod
  else
    sed "s/ *$//g" $file |
    sed "s/\t/  /g"   |
    sed -r "s/^(.{80})(..*)$/\1\n\2/g"|
    sed -r "s/ sizeof\(/ sizeof \(/g"|
    sed -r "s/,([a-zA-Z])/, \1/g" > $file.cod
  fi
}

#
# launch Coding Style
#
function launch_correction
{
  for i in $(find .                                        \
    \(                                                     \
    $(print_ignore_files)                                  \
    \) -prune                                              \
    -o                                                     \
    \(                                                     \
    -type f                                                \
    \(                                                     \
    -name "*.[ch]" -o -name "*.[ch][ch]" -o -name "*.hxx" \
    \)                                                     \
    \) -print                                              \
    )
do
  inf=""
  coding $i
  case $? in
    0)
      inf="CORRECTED";;
    1)
      inf="NO ERROR";;
    2)
      inf="NOT CORRECTED";;
    3)
      inf="AUTO CORRECTED";;
  esac
  printf "$i"
  print_nchar ' ' $((80 - (${#i} + ${#inf})))
  printf "\e[32m[$inf]\e[39m\n"
done
}


#
# print Authors
# $@ list of AUTHORS
#
function make_authors
{
  #
  # print Authors
  # $@ list of AUTHORS
  #
  function print_authors { for i in $@; do echo "* "$i; done }

  if [ -s AUTHORS ];then
    if ! diff AUTHORS <(print_authors $@) > /dev/null;then
      printf "\e[31m Wrong Authors \e[39m\n"
      read -p "Do you want to correct ?(Y/n)" correct < $TTY
      [[ ! $correct = "n" ]] && print_authors $@ > AUTHORS || exit 1
    fi
  else
    printf "\e[31m no Authors \e[39m\n"
    print_authors $@ > AUTHORS
  fi
  git add AUTHORS
}

function print_nchar
{
  local char=$1
  local n=$2
  printf "%-$n""s" | tr ' ' "$char"
}
#
# Make Readme
#
function make_readme
{
  update_var_readme
  local IFS="\t\n"
  # principal header
  echo $(print_nchar '=' 80)         >  README
  echo $(print_nchar ' ' 37)"README" >> README
  echo $(print_nchar '=' 80)         >> README
  printf "\n\n\n"                    >> README
  # category
  for i in "GENERAL INFO" GOAL USAGE CHANGELOG;
  do
    printf $(print_nchar '=' $((39 - $((${#i} / 2)))))           >> README
    printf " $i "                                                >> README
    printf $(print_nchar '=' $((39 - $(((${#i} + 1) / 2)))))"\n" >> README
    printf "\n\n"                                                >> README
    case $i in
      "GENERAL INFO")
        echo "  Project: $project"                               >> README
        echo "  Contributors: $login"                            >> README
        echo "  License: $license"                               >> README
        echo "  Version: $versions"                              >> README
        echo "  Date: $date"                                     >> README
        printf "\n\n  $info\n"                                   >> README
        ;;
      USAGE)
        if [ -f CMakeLists.txt ];then
          echo "To get the Makefile : 'mkdir build && cd build && cmake ..'" >> README
        elif [ -f autogen.sh ];then
          echo "To get the Makefile : './autogen.sh && ./configure'" >> README
        fi
        if [ -f Makefile -o -f CMakeLists.txt -o -f autogen.sh ];then
          echo "To compile the project to get the binary file: 'make or make all'" >> README
          echo "To clean the project: 'make clean'"     >> README
          echo "To launch the test suite: 'make check'" >> README
        fi
        ;;
      *)
        echo "  ##FIXME##"                                       >> README
        ;;
    esac
    printf "\n\n"                                                >> README
  done
}

#
# Make Todo
# $1 subject to parse
#
function make_todo
{
  [[ ! -f $1 ]] && return 1
  printf "TODO:\n" > TODO

  #get summary
  local test=$(pdftotext $1 /dev/stdout |
  grep -E "^[0-9](.*)( \.)+" |
  sed -r 's/^([0-9]\.?)+([a-zA-Z ’:?0-9]+)(.*)*/\2/' |
  tr '\n' '@')

  local IFS="@"

  #padding
  local cnt=0
  for i in $test;
  do
    [[ $cnt -lt ${#i} ]] && cnt=${#i}
  done

  #write TODO
  for i in $test;
  do
    local c=$((cnt - ${#i}))
    [[ ! ${#i} -lt 2 ]] &&
      printf $i"%-$c""s""\t[${step[0]}]\t[$login]\n" >> TODO ;
  done
}

#
# Create architecture
# $1 subject to parse
#
function make_archi
{
  [[ ! -f $1 ]] && return 1
  local test=$(pdftotext $1 /dev/stdout |
  grep "^\./[[:alpha:]]" |
  sed "s/*//" |
  sed "s/^\.\///" );
  for i in $test
  do
    if [[ "$i" =~ \/$ ]]; then
      mkdir $i
    else
      touch $i
    fi
  done
}

function print_ignore_files
{
  printf " -path ./.git"
  for i in $ignore_files;
  do
    while read in; do
      printf " -o -path ./$in"
    done < $i
  done
}

#
# Update TODO
#
function update_todo
{
  read -r -a logins <<< "$login"
  local todomap="+map <enter> bde"

  # map for steps
  local s_size=$((${#step[@]} - 1))
  todomap+=":if @\" =~ '^${step[$s_size]}$' <cr> execute \"normal! i${step[0]}\"<cr>"
  for (( i=0; i < s_size ; i++ ))
  do
    todomap+=":elseif @\" =~ '^${step[$i]}$' <cr> execute \"normal! i${step[$(($i + 1))]}\"<cr>"
  done

  # map for login
  local l_size=$((${#logins[@]} -1))
  todomap+=":elseif @\" =~ '^${logins[$l_size]}$' <cr> execute \"normal! i${logins[0]}\"<cr>"
  for (( i=0; i < l_size ; i++ ))
  do
    todomap+=":elseif @\" =~ '^${logins[$i]}$' <cr> execute \"normal! i${logins[$(($i + 1))]}\"<cr>"
  done
  todomap+=":else <cr> execute \"normal! hp\"<cr>"
  todomap+="endif<cr><cr>"

  #launch todo editor
  vim \
    "+map 1 bdeiANALYSIS<esc>" \
    "+map 2 bdeiDEVELOP<esc>"  \
    "+map 3 bdeiREVIEW<esc>"\
    "+map 4 bdeiFAT<esc>"\
    "+map 5 bdeiDONE<esc>"\
    "$todomap"\
    TODO < $TTY
  [ -f TODO ] && git add TODO
}

function generate_config
{
  [[ ! -f $1 ]] && return 1
  echo "PROJECT="$(pdftotext $1 /dev/stdout | head -n 1 | sed "s/ — Subject//I") >> "$config_file"
  printf "DATE=" >> "$config_file"
  pdftotext $1 /dev/stdout | grep -E "^[A-Z][a-z]+, [A-Z][a-z]+ [0-9]+, [0-9]+" | tr '\n' ':' >> "$config_file"
  echo >> "$config_file"
}

function update_var_readme
{
  local IFS="="
  while read var value
  do
    case $var in
      "VERSION")
        versions=$value
        ;;
      "DATE")
        date=$value
        ;;
      "PROJECT")
        project=$value
        ;;
      "LICENSE")
        license=$value
        ;;
      "INFO")
        info=$value
    esac
  done < $config_file
}

if [ ! -t 0 -o $# -eq 0 ];
then
  if [ -s $path_subject ];
  then
    [ ! -f AUTHORS -o ! -f TODO ] && make_archi $path_subject
    if [ ! -s TODO ];then
      make_todo $path_subject
    fi
    generate_config $path_subject
  fi
  make_authors $login
  if [ ! -s README ];then
    make_readme
  fi
  launch_correction
  if git diff-index --quiet HEAD -- TODO; then
    update_todo
  fi
  exit 0
elif [ $1 == "-ut" ];
then
  update_todo
elif [ $1 == "-c" ];
then
  launch_correction
elif [ $1 == "-a" ];
then
  make_authors $login
elif [ $1 == "-r" ];
then
  make_readme
elif [ $1 == "-t" ];
then
  make_todo $2
elif [ $1 == "-init" ];
then
  make_archi $2
elif [ $1 == "-conf" ];
then
  generate_config $2
else
  echo "Usage: $0 [-ut] [-c] [-a] [-r] [-t file] [-init file] [-conf file]"
fi