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.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
  )
}

# 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 implementation..."
    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 implementation..."
    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 implementation..."
    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 [ ! -d "$HOME/file/templates" ]; then
      echo "Please clone $TEMPLATES into $HOME/file/templates"
    else
      echo ""
      echo "Setting up ikiwiki implementation..."
      cd $PROJECT &> /dev/null
      #__templater_checkout_develop

      if [ ! -e ".gitignore" ]; then
        cp $HOME/file/templates/ikiwiki/.gitignore .
      elif ! grep -q -f $HOME/file/templates/ikiwiki/.gitignore .gitignore; then
        cat $HOME/file/templates/ikiwiki/.gitignore >> .gitignore
      fi

      if [ ! -e "index.mdwn" ]; then
        cp $HOME/file/templates/ikiwiki/index.mdwn .
      fi

      if [ ! -e "ikiwiki.setup" ]; then
        cp $HOME/file/templates/ikiwiki/ikiwiki.setup .
      fi

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

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

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

      git add .
      git commit -a -m "Static site generation support using ikiwiki"
    fi
  )
}

# Sphinx implementation
function templater_sphinx {
  echo "TODO: sphinx"
  true
}

# Pelican implementation
function templater_pelican {
  echo "TODO: pelican"
  true
}

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

# Jekyll implementation
function templater_jekyll {
  echo "TODO: jekyll"
  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 :)"