path: root/templater

#!/bin/bash
#
# Setup a new code project.
#

# Parameters
PROGRAM="$0"
DIRNAME="`dirname $0`"
BASENAME="`basename $0`"
PROJECT="$1"
shift
MODULES="$*"
BOOTSTRAP="https://git.fluxo.info/puppet-bootstrap.git"
TEMPLATES="https://git.fluxo.info/templates.git"

# Initialize project
function __templater_init {
  if [ ! -d "$PROJECT" ]; then
    echo "Initializing $PROJECT..."
    mkdir -p $PROJECT
  fi
}

# Read a parameter from user
function __templater_ask {
  local input
  local function="$1"
  local default="n"
  shift 2

  read -rep "Setup $function? (defaults to $default): " input

  if [ "$input" == "y" ]; then
    templater_$function
  fi
}

# Return list of implementations
function __templater_implementations {
  # Do not sort this list: the order in which functions are present in the code is important
  grep "^function templater_" $PROGRAM | cut -d ' ' -f 2 | sed -e 's/templater_//'
}

# Checkout to develop branch if available
function __templater_checkout_develop {
  (
    cd $PROJECT &> /dev/null

    if git branch --list develop | grep -q develop; then
      git checkout develop
    fi
  )
}

# Copy or append source file into destination
function __templater_copy_or_append {
  local implementation="$1"
  local file="$2"

  if [ -z "$file" ]; then
    return
  fi

  if [ ! -e "$file" ]; then
    cp $DIRNAME/share/$implementation/$file .
  elif ! grep -q -f $DIRNAME/share/$implmenentation/$file $file; then
    cat $DIRNAME/share/$implementation/$file >> $file
  fi
}

# Git implementation
function templater_git {
  if [ ! -d "$PROJECT/.git" ]; then
  (
    cd $PROJECT &> /dev/null
    touch .gitignore

    echo "$PROJECT"                                     > README.md
    echo "=========`echo $PROJECT | sed -e 's|.|=|g'`" >> README.md
    echo ""                                            >> README.md
    echo "This is the $PROJECT repository."            >> README.md

    echo "TODO"                > TODO.md
    echo "===="               >> TODO.md
    echo ""                   >> TODO.md
    echo "* Nothing here? :P" >> TODO.md

    git init
    git add .
    #git commit -m "Initial import"
  )
  fi
}

# Git hooks implementation
function templater_githooks {
  if [ ! -d "$PROJECT/.git" ]; then
  (
    if which git-hooks &> /dev/null; then
      echo ""
      echo "Installing hooks..."
      git hooks --install
    fi
  )
  fi
}

# Setup git-flow implementation
function templater_gitflow {
  if ! grep -q '^\[gitflow' $PROJECT/.git/config; then
  (
    cd $PROJECT &> /dev/null

    if ! git branch --list develop | grep -q develop; then
      git branch develop

      if [ -e "/usr/lib/git-core/git-flow" ]; then
        echo ""
        echo "Setting up git-flow..."
        git flow init -d
      fi
    fi
  )
  fi
}

# Vagrant implementation
function templater_vagrant {
  if [ ! -e "$PROJECT/Vagrantfile" ]; then
  (
    echo ""
    echo "Setting up vagrant..."
    cd $PROJECT &> /dev/null
    #__templater_checkout_develop
    vagrant init
    echo '.vagrant' >> .gitignore
    git commit -a -m "Adds vagrant support"
  )
  fi
}

# KVMX implementation
function templater_kvmx {
  if [ ! -e "$PROJECT/kvmxfile" ]; then
  (
    echo ""
    echo "Setting up vagrant..."
    cd $PROJECT &> /dev/null
    kvmx init
    git commit -a -m "Adds kvmx support"
  )
  fi
}

# Puppet implementation
function templater_puppet {
  if [ ! -d "$PROJECT/puppet" ]; then
  (
    echo ""
    echo "Setting up puppet..."
    cd $PROJECT &> /dev/null

    # Use the best approach
    #git clone $BOOSTRAP $PROJECT/puppet
    #git submodule add $BOOSTRAP puppet
    git remote add puppet $BOOTSTRAP
    git subtree add --prefix puppet $BOOTSTRAP master --squash
  )
  fi
}

# Ikiwiki implementation
function templater_ikiwiki {
  if [ ! -e "$PROJECT/ikiwiki.yaml" ]; then
  (
    echo ""
    echo "Setting up ikiwiki..."
    cd $PROJECT &> /dev/null

    #__templater_checkout_develop
    __templater_copy_or_append ikiwiki .gitignore

    #if [ ! -e "index.md" ]; then
    #  cp $DIRNAME/share/ikiwiki/index.md .
    #fi
    cp $DIRNAME/share/ikiwiki/index.md .

    if [ ! -e "ikiwiki.yaml" ]; then
      cp $DIRNAME/share/ikiwiki/ikiwiki.yaml.
    fi

    if [ ! -e "Makefile" ]; then
      cp $DIRNAME/share/ikiwiki/Makefile .
    elif ! grep -q ^wiki: Makefile; then
      grep -v '^#' $DIRNAME/share/ikiwiki/Makefile >> Makefile
    fi

    if [ ! -d "templates" ]; then
      cp -r $DIRNAME/share/ikiwiki/templates .
    fi

    if [ ! -d "bootstrap" ]; then
      cp -r $DIRNAME/share/ikiwiki/bootstrap .
    fi

    if [ -d ".git" ]; then
      git add .
      #git commit -a -m "Static site generation support using ikiwiki"
    fi
  )
  fi
}

# Sphinx implementation
function templater_sphinx {
  if [ ! -e "$PROJECT/conf.py" ]; then
  (
    echo ""
    echo "Setting up sphinx..."
    cd $PROJECT &> /dev/null

    #__templater_checkout_develop
    __templater_copy_or_append sphinx .gitignore

    cp $DIRNAME/share/sphinx/conf.py .

    if [ ! -e "Makefile" ]; then
      cp $DIRNAME/share/sphinx/Makefile .
    elif ! grep -q sphinx Makefile; then
      grep -v '^#' $DIRNAME/share/sphinx/Makefile >> Makefile
    fi

    if [ ! -d "_static" ]; then
      cp -r $DIRNAME/share/sphinx/_static .
    fi

    if [ ! -d "_themes" ]; then
      mkdir _themes
      git submodule add https://github.com/snide/sphinx_rtd_theme _themes/sphinx_rtd_theme
    fi
  )
  fi
}

# Pelican implementation
function templater_pelican {
  if [ ! -e "$PROJECT/pelicanconf.py" ]; then
  (
    echo ""
    echo "Setting up pelican..."
    cd $PROJECT &> /dev/null

    #__templater_checkout_develop
    __templater_copy_or_append pelican .gitignore

    cp $DIRNAME/share/sphinx/pelicanconf.py .

    if [ ! -e "Makefile" ]; then
      cp $DIRNAME/share/pelican/Makefile .
    elif ! grep -q pelican Makefile; then
      grep -v '^#' $DIRNAME/share/pelican/Makefile >> Makefile
    fi

    if [ ! -d "content" ]; then
      cp -r $DIRNAME/share/pelican/content .
    fi
  )
  fi
}

# Hugo implementation
function templater_hugo {
  echo "TODO: hugo"
  true
}

# Jekyll implementation
function templater_jekyll {
  echo "TODO: jekyll"
  true
}

# Drupal7 implementation
function templater_drupal7 {
  echo "TODO: drupal7"
  true
}

# Drupal8 implementation
function templater_drupal8 {
  echo "TODO: drupal8"
  true
}

# Syntax check
if [ -z "$PROJECT" ]; then
  echo "$BASENAME: create a new project folder and/or setup helper utilities"
  echo ""
  echo "usage: $BASENAME <path> [<module1> ... <moduleN>]"
  echo ""
  echo "examples":
  echo ""
  echo -e "\t templater myproject git ikiwiki # adds git and ikiwiki config into myproject"
  echo -e "\t templater . pelican             # add pelican config into the current folder"
  echo ""
  echo "available modules:"
  echo ""
  __templater_implementations | xargs -L 6 | column -t -c 6 | sed -e 's/^/\t/'
  echo ""
  exit 1
fi

# Initialize
__templater_init

# Setup modules
if [ -z "$MODULES" ]; then
  for project in `__templater_implementations`; do
    __templater_ask $project
  done
else
  for module in $MODULES; do
    templater_$module
  done
fi

# Teardown
echo "Done processing the project :)"