path: root/templater

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

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

# Set shared files location
if [ -e "`dirname $(readlink -f $0)`/share/$BASENAME" ]; then
  # Development or local installation layout
  SHARE="`dirname $(readlink -f $0)`/share/$BASENAME"
else
  # System installation layout
  SHARE="`dirname $(readlink -f $0)`/../share/$BASENAME"
fi

# Initialize project
function __templater_init {
  if [ ! -d "$PROJECT" ]; then
    __templater_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_//'
  ls $SHARE
}

# Message
function __templater_echo {
  #echo ""
  echo "-> $*"
}

# Checkout to develop branch if available
function __templater_checkout_develop {
  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 $SHARE/$implementation/$file .
  elif ! grep -q -f $SHARE/$implementation/$file $file; then
    cat $SHARE/$implementation/$file >> $file
  fi
}

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

  if echo $param | grep -q 'passwd'; then
    read -s -rep "$* (defaults to $default): " input
  else
    read -rep "$* (defaults to $default): " input
  fi

  if [ -z "$input" ]; then
    export $param="$default"
  else
    export $param="$input"
  fi
}

# Basic implementation
function templater_basic {
  if [ ! -e "README.md" ]; then
    echo "$PROJECT"                           > README.md
    basename $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

    touch ChangeLog
  else
    __templater_echo "Basic files already set"
  fi
}

# Git implementation
function templater_git {
  if [ ! -d ".git" ]; then
    __templater_echo "Setting up git..."
    touch .gitignore

    __templater_user_input GIT_USER  User             "-> Choose a git user name"
    __templater_user_input GIT_EMAIL user@example.org "-> Choose a git email address"

    git init
    git config user.name  $GIT_USER
    git config user.email $GIT_EMAIL
    git add .
    git commit -m "Initial import"
  else
    __templater_echo "Git already set"
  fi
}

# Git hooks implementation
function templater_githooks {
  # TODO: check if githooks are already set
  if [ -d ".git" ]; then
    if which git-hooks &> /dev/null; then
      __templater_echo "Setting up git-hooks..."
      git hooks --install
    fi
  else
    __templater_echo "Git hooks already set"
  fi
}

# Setup git-flow implementation
function templater_gitflow {
  if ! grep -q '^\[gitflow' .git/config; then
    if ! git branch --list develop | grep -q develop; then
      __templater_echo "Setting up git-flow..."

      git branch develop

      if [ -e "/usr/lib/git-core/git-flow" ]; then
        echo ""
        __templater_echo "Setting up git-flow..."
        git flow init -d
      fi
    fi
  else
    __templater_echo "Git flow already set"
  fi
}

# Vagrant implementation
function templater_vagrant {
  if [ ! -e "Vagrantfile" ]; then
    __templater_echo "Setting up vagrant..."
    #__templater_checkout_develop
    vagrant init
    echo '.vagrant' >> .gitignore
    #git commit -a -m "Adds vagrant support"
  else
    __templater_echo "Vagrant already set"
  fi
}

# KVMX implementation
function templater_kvmx {
  if [ ! -e "kvmxfile" ]; then
    __templater_echo "Setting up kvmx..."
    kvmx init
    #git commit -a -m "Adds kvmx support"
  else
    __templater_echo "KVMX already set"
  fi
}

# Puppet implementation
function templater_puppet {
  if [ ! -d "puppet" ]; then
    __templater_echo "Setting up puppet..."

    if [ ! -d '.git' ]; then
      __templater_echo "Error: puppet needs a working git setup, skipping"
      return
    fi

    if [ "`git status -s | wc -l`" != 0 ]; then
      __templater_echo "Please commit changes before running setting up puppet"
      return
    fi

    # Use the best approach
    #git clone $BOOSTRAP puppet
    #git submodule add $BOOSTRAP puppet
    git remote add puppet $BOOTSTRAP
    git subtree add --prefix puppet $BOOTSTRAP master --squash
  else
    __templater_echo "Puppet already set"
  fi
}

# Ikiwiki implementation
function templater_ikiwiki {
  if [ ! -e "ikiwiki.yaml" ]; then
    __templater_echo "Setting up ikiwiki..."

    #__templater_checkout_develop
    __templater_copy_or_append ikiwiki .gitignore

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

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

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

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

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

    #if [ -d ".git" ]; then
    #  git add .
    #  git commit -a -m "Static site generation support using ikiwiki"
    #fi
  else
    __templater_echo "Ikiwiki already set"
  fi
}

# Sphinx implementation
function templater_sphinx {
  if [ ! -e "conf.py" ]; then
    __templater_echo "Setting up sphinx..."

    #__templater_checkout_develop
    __templater_copy_or_append sphinx .gitignore

    cp $SHARE/sphinx/conf.py .

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

    if [ ! -d "_static" ]; then
      cp -r $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
  else
    __templater_echo "Sphinx already set"
  fi
}

# Pelican implementation
function templater_pelican {
  if [ ! -e "pelicanconf.py" ]; then
    __templater_echo "Setting up pelican..."

    #__templater_checkout_develop
    __templater_copy_or_append pelican .gitignore

    cp $SHARE/sphinx/pelicanconf.py .

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

    if [ ! -d "content" ]; then
      cp -r $SHARE/pelican/content .
    fi
  else
    __templater_echo "Pelican already set"
  fi
}

# Hugo implementation
function templater_hugo {
  if [ ! -e "config.toml" ]; then
    __templater_echo "Setting up Hugo..."

    if which hugo &> /dev/null; then
      hugo new site .
    else
      __templater_echo "Hugo not available, please install it, skipping"
    fi
  else
    __templater_echo "Hugo already set"
  fi
}

# Jekyll implementation
function templater_jekyll {
  if [ ! -e "_config.yml" ]; then
    __templater_echo "Setting up Jekyll..."

    if which jekyll &> /dev/null; then
      jekyll new .
    else
      __templater_echo "Jekyll not available, please install it, skipping"
    fi
  else
    __templater_echo "Jekyll already set"
  fi
}

# Drupal7 implementation
function templater_drupal7 {
  if [ ! -e 'settings.dev.php' ]; then
    __templater_echo "Setting up Drupal 7..."

    #if [ ! -e "Makefile" ]; then
    #  cp $SHARE/drupal7/Makefile .
    ##elif ! grep -q ^drupal: Makefile; then
    ##  grep -v '^#' $SHARE/drupal7/Makefile >> Makefile
    #else
    #  cp $SHARE/drupal7/Makefile Makefile.drupal7
    #fi

    if [ ! -e "drupal.make.yml" ]; then
      cp $SHARE/drupal7/drupal.make.yml .
    fi

    mkdir -p files themes modules libraries
    mkdir -p vendor
  else
    __templater_echo "Drupal already set"
  fi
}

# Drupal8 implementation
function templater_drupal8 {
  if [ ! -e 'settings.php' ]; then
    __templater_echo "Setting up Drupal 8..."

    if [ ! -e ".gitignore" ] || ! grep -q "^settings.php" .gitignore; then
      echo settings.php      >> .gitignore
      echo settings.prod.php >> .gitignore
      echo services.yml      >> .gitignore
    fi

    if [ ! -e "settings.dev.php" ]; then
      cp $SHARE/drupal8/default.settings.php settings.dev.php
      #cp $SHARE/drupal8/default.settings.php .
    fi

    ln -sf settings.dev.php settings.php

    if [ ! -e "services.yml" ]; then
      cp $SHARE/drupal8/default.services.yml services.dev.yml
      #cp $SHARE/drupal8/default.services.yml .
    fi

    ln -sf services.dev.yml services.yml

    if [ ! -e "Makefile" ]; then
      cp $SHARE/drupal8/Makefile .
    #elif ! grep -q ^drupal: Makefile; then
    #  grep -v '^#' $SHARE/drupal8/Makefile >> Makefile
    else
      cp $SHARE/drupal8/Makefile Makefile.drupal8
    fi

    if [ ! -e "drupal.make.yml" ]; then
      cp $SHARE/drupal8/drupal.make.yml .
    fi

    mkdir -p files config themes modules libraries
    mkdir -p vendor
  else
    __templater_echo "Drupal already set"
  fi
}

# GPLv3 License
function templater_gpl {
  if [ ! -e "LICENSE" ]; then
    __templater_echo "Setting up GPLv3 License..."
    cp $SHARE/gpl/LICENSE .
  else
    __templater_echo "LICENSE already set"
  fi
}

# AGPLv3 License
function templater_agpl {
  if [ ! -e "LICENSE" ]; then
    __templater_echo "Setting up Affero GPLv3 License..."
    cp $SHARE/agpl/LICENSE .
  else
    __templater_echo "LICENSE already set"
  fi
}

# MIT License
function templater_mit {
  if [ ! -e "LICENSE" ]; then
    __templater_echo "Setting up MIT License..."
    cp $SHARE/mit/LICENSE .
  else
    __templater_echo "LICENSE already set"
  fi
}

# Apache License
function templater_apache {
  if [ ! -e "LICENSE" ]; then
    __templater_echo "Setting up Apache License..."
    cp $SHARE/apache/LICENSE .
  else
    __templater_echo "LICENSE already set"
  fi
}

# BSD License
function templater_bsd {
  if [ ! -e "LICENSE" ]; then
    __templater_echo "Setting up BSD 3-clause (New BSD) License..."
    cp $SHARE/bsd/LICENSE .
  else
    __templater_echo "LICENSE already set"
  fi
}

# Mozilla License
function templater_mpl {
  if [ ! -e "LICENSE" ]; then
    __templater_echo "Setting up Mozilla Public License..."
    cp $SHARE/mpl/LICENSE .
  else
    __templater_echo "LICENSE already set"
  fi
}

# Do What the Fuck You Want to Public License - WTFPL
function templater_wtfpl {
  if [ ! -e "LICENSE" ]; then
    __templater_echo "Setting up Do What the Fuck You Want Public License..."
    cp $SHARE/wtfpl/LICENSE .
  else
    __templater_echo "LICENSE already set"
  fi
}

# Contributor Covenant: A Code of Conduct for Open Source Projects
function templater_conduct {
  if [ ! -e "CODE_OF_CONDUCT.md" ]; then
    __templater_echo "Setting up Code of Conduct..."
    cp $SHARE/conduct/CODE_OF_CONDUCT.md .
  else
    __templater_echo "Code of Conduct already set"
  fi
}

# 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

# Go to project folder
cd $PROJECT &> /dev/null

# Setup modules
if [ -z "$MODULES" ]; then
  for project in `__templater_implementations`; do
    __templater_ask $project
  done
else
  for module in $MODULES; do
    if `__templater_implementations | grep -q "^$module"`; then
      templater_$module
    else
      __templater_echo "No such module $module, skipping"
    fi
  done
fi

# Teardown
cd $CWD
__templater_echo "Done processing the project :)"