csfg

#!/bin/bash
# Helper script for commands related to the CS Field Guide repository.
#
# Notes:
#  - Changes to template only require user to refresh browser.
#  - Changes to static files require the 'static' command to be run.
#  - Changes to Python code are detected by gunicorn and should take effect
#    on the server after a few seconds.
#
# Future plans:
#  - Start systems when a command is given (for example: 'static') when the
#    development system has not yet been started.
#  - When 'start' is run open website in default browser without creating
#    new terminal prompt.

set -e

RED='\033[0;31m'
GREEN='\033[0;32m'
NC='\033[0m' # No Color

cmd_helps=()
dev_cmd_helps=()

defhelp() {
  if [ "$1" = '-dev' ]; then
    local command="${2?}"
    local text="${3?}"
    local help_str
    help_str="$(printf '   %-18s %s' "$command" "$text")"
    dev_cmd_helps+=("$help_str")
  else
    local command="${1?}"
    local text="${2?}"
    local help_str
    help_str="$(printf '   %-18s %s' "$command" "$text")"
    cmd_helps+=("$help_str")
  fi
}

# Print out help information
cmd_help() {
  echo "Script for performing tasks related to the CS Field Guide repository."
  echo
  echo "Usage: ./csfg [COMMAND]"
  echo "Replace [COMMAND] with a word from the list below."
  echo
  echo "COMMAND list:"
  for str in "${cmd_helps[@]}"; do
    echo -e "$str"
  done
  echo
  echo "DEV_COMMAND list:"
  for str in "${dev_cmd_helps[@]}"; do
    echo -e "$str"
  done
}

defhelp help 'View all help.'
defhelp 'dev [DEV_COMMAND]' 'Run a developer command.'

# Start development environment
cmd_start() {
  echo "Creating systems..."
  docker-compose up -d
  echo ""
  # Alert user that system is ready
  echo -e "\n${GREEN}System is up!${NC}"
  echo "Run the command ./csfg update to load content."
}

defhelp start 'Start development environment.'

# Stop development environment
cmd_end() {
  echo "Stopping systems... (takes roughly 10 to 20 seconds)"
  docker-compose down
  echo
  echo "Deleting system volumes..."
  volumes=($(docker volume ls -qf dangling=true ))
  for volume in "${volumes[@]}"; do
      docker volume rm "${volume}"
  done
}
defhelp end 'Stop development environment.'

cmd_restart() {
  cmd_end
  cmd_start
}
defhelp restart 'Stop and then restart development environment.'

# Run Django migrate and updatedata commands
cmd_update() {
  dev_static

  echo ""
  dev_migrate

  echo ""
  dev_updatedata
  dev_rebuild_index

  echo ""
  dev_collect_static
  echo ""
  echo -e "\n${GREEN}Content is loaded!${NC}"
  echo "Open your preferred web browser to the URL 'localhost:81'"
}
defhelp update 'Run Django migrate and updatedata commands and build static files.'

# Build Docker images
dev_build() {
  echo "Building Docker images..."
  docker-compose build
}
defhelp -dev build 'Build or rebuild Docker images.'

# Collecting static files
dev_collect_static() {
  echo
  echo "Collecting static files..."
  docker-compose exec django /docker_venv/bin/python3 ./manage.py collectstatic --no-input --clear
}
defhelp -dev collect_static "Collecting static files."

# Run Django compilemessages command
dev_compilemessages() {
  echo "Compiling message files..."
  docker-compose exec django /docker_venv/bin/python3 ./manage.py compilemessages
}
defhelp -dev compilemessages 'Run Django compilemessages command.'

# Generates the documentation (with warnings as errors)
dev_docs() {
  echo "Removing any existing documentation..."
  docker-compose exec django rm -rf /cs-field-guide/docs/build/
  docker-compose exec django mkdir /cs-field-guide/docs/build/
  echo
  echo "Creating documentation..."
  docker-compose exec django /docker_venv/bin/sphinx-build -W /cs-field-guide/docs/source/ /cs-field-guide/docs/build/
}
defhelp -dev docs 'Generate documentation.'

# Run Django makemessages command
dev_makemessages() {
  echo "Creating message files..."
  docker-compose exec django /docker_venv/bin/python3 ./manage.py makemessages -l en
}
defhelp -dev makemessages 'Run Django makemessages command.'

# Run Django makemigrations command
dev_makemigrations() {
  echo "Creating database migrations..."
  docker-compose exec django /docker_venv/bin/python3 ./manage.py makemigrations --no-input
}
defhelp -dev makemigrations 'Run Django makemigrations command.'

# Run Django migrate command
dev_migrate() {
  echo "Applying database migrations..."
  docker-compose exec django /docker_venv/bin/python3 ./manage.py migrate
}
defhelp -dev migrate 'Run Django migrate command.'

# Reboot Django Docker container
dev_reboot_django() {
  echo "Rebooting Django Docker container..."
  docker-compose restart django
}
defhelp -dev reboot_django 'Reboot Django Docker container.'

# Run shell
dev_shell() {
  docker-compose exec django bash
}
defhelp -dev shell "Open shell to Django folder."

# Build static files
dev_static() {
  echo "Building static files..."
  docker-compose exec nginx gulp build
}
defhelp -dev static 'Build static files.'

# Build production static files
dev_static_prod() {
  echo "Building production static files..."
  docker-compose exec nginx gulp build --production
}
defhelp -dev static_prod 'Build production static files.'

# Run Django command rebuild_index
dev_rebuild_index() {
  echo "Rebuilding search index..."
  docker-compose exec django /docker_venv/bin/python3 ./manage.py rebuild_index --noinput
}
defhelp -dev rebuild_index "Run Django rebuild_index command."

# Run style checks
dev_style() {
  echo "Running PEP8 style checker..."
  docker-compose exec django /docker_venv/bin/flake8
  pep8_status=$?
  echo
  echo "Running Python docstring checker..."
  docker-compose exec django /docker_venv/bin/pydocstyle --count --explain
  pydocstyle_status=$?
  ! (( pep8_status || pydocstyle_status ))
}
defhelp -dev style 'Run style checks.'

# Run test suite
dev_test_suite() {
  echo "Running test suite..."
  docker-compose exec django /docker_venv/bin/coverage run --rcfile=/cs-field-guide/.coveragerc ./manage.py test --settings=config.settings.testing --pattern "test_*.py" -v 3 --nomigrations
}
defhelp -dev test_suite 'Run test suite with code coverage.'

# Run specific test suite
dev_test_specific() {
  echo "Running specific test suite..."
  docker-compose exec django /docker_venv/bin/python3 ./manage.py test --settings=config.settings.testing "${1}" -v 3 --nomigrations
}
defhelp -dev test_specific 'Run specific test suite. Pass in parameter of Python test module.'

# Display test coverage table
dev_test_coverage() {
  echo "Displaying test suite coverage..."
  docker-compose exec django /docker_venv/bin/coverage xml -i
  docker-compose exec django /docker_venv/bin/coverage report -m --skip-covered
}
defhelp -dev test_coverage 'Display code coverage report.'

# Run test suite backwards for CI testing
dev_test_backwards() {
  echo "Running test suite backwards..."
  docker-compose exec django /docker_venv/bin/python3 ./manage.py test --settings=config.settings.testing --pattern "test_*.py" --reverse -v 0 --nomigrations
}
defhelp -dev test_backwards 'Run test suite backwards.'

# Run Django updatedata command
dev_updatedata() {
  echo "Loading content..."
  docker-compose exec django /docker_venv/bin/python3 ./manage.py updatedata
}
defhelp -dev updatedata 'Run updatedata command.'

# Delete all untagged dangling Docker images
cmd_clean() {
  echo "If the following commands return an argument not found error,"
  echo "this is because there is nothing to delete for clean up."

  echo
  echo "Deleting unused volumes..."

  unused_volumes=($(docker volume ls -qf dangling=true))
  for vol in "${unused_volumes[@]}"; do
      docker volume rm "${vol}"
  done

  echo
  echo "Deleting exited containers..."
  exited_containers=($(docker ps --filter status=dead --filter status=exited -aq))
  for container in "${exited_containers[@]}"; do
      docker rm -v "${container}"
  done
  echo
  echo "Deleting dangling images..."
  dangling_images=($(docker images -f "dangling=true" -q))
  if [[ ${#dangling_images[@]} -gt 0 ]]; then
      docker rmi "${dangling_images[@]}"
  fi
}
defhelp clean 'Delete unused Docker files.'

# Delete all Docker containers and images
cmd_wipe() {
  docker ps -a -q | xargs docker rm
  docker images -q | xargs docker rmi
}
defhelp wipe 'Delete all Docker containers and images.'

# View logs
cmd_logs() {
  docker-compose logs
}
defhelp logs 'View logs.'

ci_test_general() {
  dev_static
  dev_collect_static
  docker-compose exec django /docker_venv/bin/coverage run --rcfile=/cs-field-guide/.coveragerc ./manage.py test --settings=config.settings.testing --pattern "test_*.py" -v 3 --nomigrations --exclude-tag=management
  test_status=$?
  dev_test_coverage
  coverage_status=$?
  bash <(curl -s https://codecov.io/bash)
  ! (( $test_status || $coverage_status ))
}

ci_test_management() {
  dev_static
  dev_collect_static
  docker-compose exec django /docker_venv/bin/coverage run --rcfile=/cs-field-guide/.coveragerc ./manage.py test --settings=config.settings.testing --pattern "test_*.py" -v 3 --nomigrations --tag=management
  test_status=$?
  dev_test_coverage
  coverage_status=$?
  bash <(curl -s https://codecov.io/bash)
  ! (( $test_status || $coverage_status ))
}

ci_style() {
  dev_style
}

ci_test_backwards() {
  dev_static
  dev_collect_static
  dev_test_backwards
}

ci_docs() {
  dev_docs
}

ci_load_content() {
  cmd_update
}

cmd_ci() {
  cmd_start
  local cmd="$1"
  shift
  if [ -z "$cmd" ]; then
    echo -e "${RED}ERROR: ci command requires one parameter!${NC}"
    cmd_help
    exit 1
  fi
  if silent type "ci_$cmd"; then
    "ci_$cmd" "$@"
    exit $?
  else
    echo -e "${RED}ERROR: Unknown command!${NC}"
    echo "Type './csfg help' for available commands."
    return 1
  fi
}

silent() {
  "$@" > /dev/null 2>&1
}

cmd_dev() {
  local cmd="$1"
  shift
  if [ -z "$cmd" ]; then
    echo -e "${RED}ERROR: dev command requires one parameter!${NC}"
    cmd_help
    return 1
  fi
  if silent type "dev_$cmd"; then
    "dev_$cmd" "$@"
    exit $?
  else
    echo -e "${RED}ERROR: Unknown command!${NC}"
    echo "Type './csfg help' for available commands."
    return 1
  fi
}

# If no command given
if [ $# -eq 0 ]; then
  echo -e "${RED}ERROR: This script requires a command!${NC}"
  cmd_help
  exit 1
fi
cmd="$1"
shift
if silent type "cmd_$cmd"; then
  "cmd_$cmd" "$@"
  exit $?
else
  echo -e "${RED}ERROR: Unknown command!${NC}"
  echo "Type './csfg help' for available commands."
  exit 1
fi