bash_setup_kde4_programming

#!/bin/bash
###############################################################
# KDE 4 DEVELOPMENT
#
# If you just want to setup your environment for kde4
# development, download this file and save it somewhere
# now put the following line (with the path pointing to
# your just downloaded file) into your ~/.bashrc:
#
# . ~/path/to/this/file
#
# Example (the leading # has to be ommitted of course!)
# . ~/.bash_setup_kde4_programming
###############################################################

# you might have to change the actual filename in the path below
# in my git repo the file is called kde4_setup_build_environment.sh
# NOTE: it's important this lies in ~/.kde/env so it gets
# called at KDE startup. This makes compiled applications
# available via KRunner etc.
. ~/.bin/kde4_setup_build_environment.sh

# Use makeobj instead of make, to automatically switch to the build dir.
# If you don't have makeobj, install the package named kdesdk-scripts or
# kdesdk, or check out kdesdk/scripts from svn.
# use -rR for speed
alias make='makeobj -rR'

# Uncomment the following lines if DBus does not work. DBus is not
# working if, when you run `dbus-uuidgen --ensure && qdbus`, you get an error.
#
# alias dbusstart="eval `PATH=$DBUSDIR/bin \
#  $DBUSDIR/bin/dbus-launch --auto-syntax`"

# A function to easily build the project in the current directory
#
# builds in the dir depending on what you set OBJ_REPLACEMENT to
# installs to "install" folder in the project folder
#
# cd ~/projects/...
# cmakeproject
function cmakeproject {
  local srcdir builddir installdir
  srcdir=$(pwd)
  installdir="$srcdir/install"
  builddir=$(echo $srcdir | sed -e "$OBJ_REPLACEMENT")

  mkdir -p "$builddir"
  cd "$builddir"

  cmake "$srcdir" -DCMAKE_INSTALL_PREFIX="$installdir" \
    -DCMAKE_BUILD_TYPE=debugfull \
    -DKDE4_BUILD_TESTS=ON

  nice make install
  cd "$srcdir"
}

# A function to easily build the current directory of KDE.
#
# This builds only the sources in the current ~/{src,build}/KDE subdirectory.
# Usage: cs KDE/kdebase && cmakekde
#   will build/rebuild the sources in ~/src/KDE/kdebase
function cmakekde {
        local srcFolder current switched fail
        switched=0
        if test -n "$1"; then
                # srcFolder is defined via command line argument
                srcFolder="$1"
        else
                # get srcFolder for current dir
                srcFolder=`pwd | sed -e s,$KDE_BUILD,$KDE_SRC,`
        fi
        # we are in the src folder, change to build directory
        # Alternatively, we could just use makeobj in the commands below...
        current=`pwd`
        if [ "$srcFolder" = "$current" ]; then
                cb
                switched=1
        fi
        fail=0
        # to enable tests, add -DKDE4_BUILD_TESTS=ON to the next line.
        # you can also change "debugfull" to "debug" to save disk space.
        cmake "$srcFolder" -DCMAKE_INSTALL_PREFIX=$KDEDIR \
                -DCMAKE_BUILD_TYPE=debugfull \
                -DKDE4_AUTH_POLICY_FILES_INSTALL_DIR=$KDEDIR/share/polkit-1/actions \
                -DKDE4_BUILD_TESTS=ON || fail=1

        # uncomment the following two lines to make builds wait after
        # configuration step, so that the user can check configure output
        echo "Press <ENTER> to continue..."
        read userinput

        if [[ $fail == 1 ]]; then
          return 1
        fi

        nice make && \
        make install
        kbuildsycoca4
        if test $switched -eq 1; then
          cs
        fi
}
export -f cmakekde
# for the lazy ones, add/comment other directories
function cmakekdeall {
    local directories
    directories=(
      kate
      kdevplatform
      kdevelop
      php
    )
    for i in `seq 1 ${#directories[@]}`; do
        echo "############## ${directories[$i-1]} ##############";
        if [[ "$1" == "" ]]; then
            cs ${directories[$i-1]} && update_cs && cb && make install;
        else
            cs ${directories[$i-1]} && update_cs && cmakekde;
        fi
    done
}

# update the source code which is either in git or in svn
# TODO: return not-0 when nothing got updated, i.e parse output
function update_cs {
    local output
    if [[ -d ".git" || -d "../.git" ]]; then
        output=$(git svn rebase)
    elif [[ -d ".svn" || -d "../.svn" ]]; then
        output=$(svn up)
    fi
    return 0
}

# A function to easily change to the build directory.
# Usage: cb KDE/kdebase
#   will change to $KDE_BUILD/KDE/kdebase
# Usage: cb
#   will simply go to the build folder if you are currently in a src folder
#   Example:
#     $ pwd
#     /home/user/src/KDE/kdebase
#     $ cb && pwd
#     /home/user/build/KDE/kdebase
function cb {
        local dest

        # Make sure build directory exists.
        mkdir -p "$KDE_BUILD"

        # command line argument
        if test -n "$1"; then
                cd "$KDE_BUILD/$1"
                return
        fi
        # substitute src dir with build dir
        dest=`pwd | sed -e $OBJ_REPLACEMENT`
        if test ! -d "$dest"; then
                # build directory does not exist, create
                mkdir -p "$dest"
        fi
        cd "$dest"
}
export -f cb
# Change to the source directory.  Same as cb, except this
# switches to $KDE_SRC instead of $KDE_BUILD.
# Usage: cs KDE/kdebase
#   will change to $KDE_SRC/KDE/kdebase
# Usage: cs
#   will simply go to the source folder if you are currently in a build folder
#   Example:
#     $ pwd
#     /home/user/build/KDE/kdebase
#     $ cs && pwd
#     /home/user/src/KDE/kdebase
function cs {
        local dest current

        # Make sure source directory exists.
        mkdir -p "$KDE_SRC"

        # command line argument
        if test -n "$1"; then
                cd "$KDE_SRC/$1"
        else
                # substitute build dir with src dir
                dest=`pwd | sed -e s,$KDE_BUILD,$KDE_SRC,`
                current=`pwd`
                if [ "$dest" = "$current" ]; then
                        cd "$KDE_SRC"
                else
                        cd "$dest"
                fi
        fi
}
export -f cs
# Add autocompletion to cs function
function _cs_scandir
{
        local base ext

        base=$1
        ext=$2
        if [ -d $base ]; then
                for d in `ls $base`; do
                        if [ -d $base/$d ]; then
                                dirs="$dirs $ext$d/"
                        fi
                done
        fi
}

function _cs()
{
        local cur dirs
        _cs_scandir "$KDE_SRC"
        _cs_scandir "$KDE_SRC/KDE" "KDE/"
        COMPREPLY=()
        cur="${COMP_WORDS[COMP_CWORD]}"
        COMPREPLY=( $(compgen -W "${dirs}" -- ${cur}) )
}

# Remove comment on next line to enable cs autocompletion
complete -F _cs cs

# run a given unit-test or all via ctest
function kdetest
{
  local tests test args old_pwd tmpfile debug;

  debug=

  old_pwd=$(pwd)
  cb

  if [[ "$1" == "--debug" ]]; then
    debug=$1
    shift 1
  fi

  if [[ -d "$1" ]]; then
    cd $1
    shift 1
  fi

  tests=$(getTests $debug)

  if [[ "$tests" == "" ]]; then
    echo "this directory does not contain any unit tests!"
    echo
    cd "$old_pwd"
    return 1
  fi

  tmpfile=/tmp/testoutput_$$

  KDEHOME_backup=$KDEHOME
  KDEHOME=~/.kde-unit-test

  if [[ "$1" != "" ]]; then
    test=$1
    if [[ "$debug" == "--debug" ]]; then
      test=${test/.shell/}
    fi
    shift 1
    args=$@

    if [ ! -f "$test" ] || ! in_array "$test" $tests ; then
      if in_array "$test.shell" $tests; then
        test="$test".shell
      else
        echo "could not find unittest '$test'. available are:"
        echo $tests
        echo
        cd "$old_pwd"
        return 1
      fi
    fi

    if [[ "$debug" != "" ]]; then
      gdb --eval-command="run" --args ./$test -maxwarnings 0 $args 2>&1 | tee -a "$tmpfile"
    else
      ./$test -maxwarnings 0 $args 2>&1 | tee -a "$tmpfile"
    fi
    echo
  else
    # run all tests
    for test in $tests; do
      if [[ "$debug" != "" ]]; then
        gdb --eval-command="run" --args ./$test -maxwarnings 0 2>&1 | tee -a "$tmpfile"
      else
        ./$test -maxwarnings 0 2>&1 | tee -a "$tmpfile"
      fi
    done
  fi

  KDEHOME=$KDEHOME_backup

  if [[ "$(grep -c "^RESULT " "$tmpfile")" != 0 ]]; then
    echo
    echo " --- BENCHMARKS --- "
    grep --color=never -A 1 "^RESULT " "$tmpfile"
    echo
  fi

  echo
  echo " --- ALL PASSED TESTS --- "
  grep --color=never "^PASS " "$tmpfile"
  echo
  echo $(grep -c "^PASS " "$tmpfile")" passed tests in total"

  if [[ "$(grep -c "^XFAIL " "$tmpfile")" != 0 ]]; then
    echo
    echo " --- EXPECTED FAILURES --- "
    perl -ne '(/^^XFAIL/../^   Loc:/) && print' "$tmpfile"
    echo
    echo $(grep -c "^XFAIL" "$tmpfile")" expected failed tests in total"
    echo
  fi

  if [[ "$(grep -c "^XPASS " "$tmpfile")" != 0 ]]; then
    echo
    echo " --- UNEXPECTED PASSES --- "
    perl -ne '(/^^XPASS/../^   Loc:/) && print' "$tmpfile"
    echo
    echo $(grep -c "^XPASS" "$tmpfile")" unexpected passed tests in total"
    echo
  fi

  echo
  echo " --- ALL FAILED TESTS --- "
  perl -ne '(/^^FAIL!/../^   Loc:/) && print' "$tmpfile"
  echo
  echo $(grep -c "^FAIL!" "$tmpfile")" failed tests in total"
  echo
  grep --color=never "^QFATAL : " "$tmpfile"
  grep --color=never -B 5 "^Segmentation fault" "$tmpfile"

  rm "$tmpfile"

  cd "$old_pwd"
}

# completion for kdetest
function _kdetest
{
  local tests;

  COMPREPLY=()
  cur="${COMP_WORDS[COMP_CWORD]}"
  prev="${COMP_WORDS[COMP_CWORD-1]}"

  old_pwd=$(pwd)
  cb

  tests=$(getTests ${COMP_WORDS[1]})

  if [[ "$prev" == "kdetest" || "$prev" == "--debug" ]]; then
    # completion of tests
    COMPREPLY=( $(compgen -W "${tests}" -- ${cur}) )
  elif in_array "$prev" $tests; then
    # completion of available functions
    COMPREPLY=( $(compgen -W "$(./$prev -functions 2>/dev/null | cut -f 1 -d \( )" -- ${cur}) )
  fi

  cd "$old_pwd"
}

# removes .shell from the end of each test file
function getTests {
  local tests;
  tests=""

  tests=$(LANG=en_US.UTF-8 ctest -N -V | grep "Test command:" | egrep -o ' [^ ]+$' | cut -c $(echo " "$(pwd)"/" | wc -c)-)

  if [[ "$1" == "--debug" ]]; then
    # remove trailing .shell
    for t in $tests; do
      echo -n ${t/.shell/}" "
    done
    echo
  else
    echo $tests
  fi
}

complete -F _kdetest kdetest

# see http://ftp.hu.freebsd.org/pub/linux/distributions/frugalware/frugalware-testing/t/functions.sh
function in_array
{
  local i
  needle=$1
  shift 1
  # array() undefined
  [ -z "$1" ] && return 1
  for i in $*
  do
    [ "$i" == "$needle" ] && return 0
  done
  return 1
}
export -f in_array