@mcf/lib-ui 0.0.1 → 2.0.124

package/README.md

@@ -8,13 +8,13 @@ Install this package through NPM:
 
 ```bash
 # for NPM
-npm i https://gitlab.com/mycf.sg/lib-ui.git#2.0.114 tachyons
+npm i @mcf/lib-ui tachyons
 ```
 
 Call it from your code with:
 
 ```javascript
-import {...} from '@govtech/mcf-mcfui';
+import {...} from '@mcf/lib-ui';
 ```
 
 Where `...` is the component name.
@@ -28,7 +28,7 @@ import 'tachyons/src/tachyons.css';
 You eventually need to import the default style provided *once* somewhere in your project
 
 ```javascript
-import '@govtechsg/mcf-mcfui/dist/main.css';
+import '@mcf/lib-ui/dist/main.css';
 ```
 This step is optional. You can provide your own style using CSS variables. Using CSS variables make it easy to configure yourself the style of your components at the application level or at a component level.
 
@@ -69,11 +69,9 @@ List of CSS variables overridable (default only if you use the provided style):
 - [RadioButtonGroup](./src/Component/RadioButtonGroup/README.md)
 
 ## Quick Links
-NPM: https://www.npmjs.com/package/@govtechsg/mcf-mcfui
-Base Images: https://hub.docker.com/r/govtechsg/mcf-mcfui-base/
-Dependency Images: https://hub.docker.com/r/govtechsg/mcf-mcfui-dependencies/
-Application Images: https://hub.docker.com/r/govtechsg/mcf-mcfui/
-Demo: https://mcfui.gds-gov.tech
+NPM: https://www.npmjs.com/package/@mcf/lib-ui
+Dependency Images: https://gitlab.com/mycf.sg/lib-ui/container_registry/2214294
+Application Images: https://gitlab.com/mycf.sg/lib-ui/container_registry/2214299
 
 ## Contributing
 
@@ -128,7 +126,6 @@ The Pipeline runs only in the `master` branch.
 
 The following release tags are available for use in your commit message to denote a type of release:
 
-- `[rebuild]`: rebuilds all containers regardless of whether we already have them
 - `[release]`: performs a release by bumping the version in `./package.json` to the same as that of the latest Git tag
 - `[major]`: performs a major version bump (X.y.z -> Y.0.0, Y = X + 1)
 - `[minor]`: performs a major version bump (x.Y.z -> x.Z.0, Z = Y + 1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcf/lib-ui",
-  "version": "0.0.1",
+  "version": "2.0.124",
   "description": "User Interface (UI) components for use in the MCF project.",
   "main": "dist/index.js",
   "types": "dist/@types/Component/index.d.ts",
@@ -25,10 +25,7 @@
     "tsc-check": "tsc --noEmit --skipLibCheck",
     "tslint": "tslint -c tslint.json -p . -t stylish"
   },
-  "repository": {
-    "type": "git",
-    "url": "ssh://git@gitlab.gds-gov.tech:30022/wsg/mcfui.git"
-  },
+  "repository": "gitlab:mycf.sg/lib-ui",
   "author": "MCF",
   "license": "ISC",
   "dependencies": {
@@ -46,7 +43,8 @@
     "@babel/preset-react": "7.14.5",
     "@babel/preset-typescript": "7.15.0",
     "@storybook/react": "5.1.3",
-    "@types/enzyme": "3.10.10",
+    "@types/cheerio": "0.22.31",
+    "@types/enzyme": "3.10.11",
     "@types/enzyme-adapter-react-16": "1.0.6",
     "@types/jest": "23.3.1",
     "@types/lodash": "4.14.177",

package/scripts/versioning/.travis.yml

@@ -0,0 +1,8 @@
+sudo: required
+language: bash
+services:
+  - docker
+before_install:
+  - docker build ./tests
+script:
+  - ./test

package/scripts/versioning/.version

@@ -0,0 +1 @@
+1.0.0

package/scripts/versioning/get-branch

@@ -0,0 +1,28 @@
+#!/bin/bash
+help () { printf "
+**********
+get-branch
+**********
+retrieves the currently checked-out branch
+
+options:
+\t-q --quiet          : suppresses debug prints
+\t-h --help           : prints this text
+
+usage:
+\t./get-branch [...options]
+
+examples:
+\t./get-branch -q
+";
+}
+
+if [[ $* == *-h* ]] || [[ $* == *--help* ]]; then help; exit 1; fi;
+if [[ $* == *-q* ]] || [[ $* == *--quiet* ]]; then exec 6>&1; exec > /dev/null; fi;
+
+CURRENT_BRANCH=$(git branch | grep '*' | cut -c 3- | tr -d '\n');
+
+if [[ $* == *-q* ]] || [[ $* == *--quiet* ]]; then exec 1>&6 6>&-; fi;
+
+printf "${CURRENT_BRANCH}\n";
+exit 0;

package/scripts/versioning/get-latest

@@ -0,0 +1,53 @@
+#!/bin/bash
+help () { printf "
+*************
+get-latest.sh
+*************
+retrieves the latest git tag that resembles a semver versioning (x.y.z) where x is
+the major version, y is the minor version and z is the patch version. exits with code
+1 if no version is found, exists with code 0 if version is found.
+
+options:
+\t-m --merged         : get only tags that apply to the current branch
+\t-q --quiet          : suppresses debug prints
+\t-h --help           : prints this text
+
+usage:
+\t./get-latest.sh <dash_suffix> [...options]
+\t\t<dash_suffix> : String
+
+examples:
+\t./get-latest.sh dev
+\t\tgets the latest version suffixed with '-dev'
+\t\tif there exists git tags 1.0.0-dev and 1.0.1-dev, this will return 1.0.1-dev
+";
+}
+
+if [[ $* == *-h* ]] || [[ $* == *--help* ]]; then help; exit 1; fi;
+if [[ $* == *-q* ]] || [[ $* == *--quiet* ]]; then exec 6>&1; exec > /dev/null; fi;
+
+VERSION_SELECTOR="^[0-9]+\.[0-9]+\.[0-9]+"
+printf "\nVERSION_SELECTOR: ${VERSION_SELECTOR}\n";
+[[ "$1" != "" ]] && [[ "$1" != "-q" ]] && VERSION_SELECTOR="${VERSION_SELECTOR}\-${1}";
+if [[ $* == *-m* ]] || [[ $* == *--merged* ]]; then
+  VERSION=$(git tag -l --merged | egrep "${VERSION_SELECTOR}$" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | tail -n 1);
+else
+  VERSION=$(git tag -l | egrep "${VERSION_SELECTOR}$" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | tail -n 1);
+fi;
+if [[ $VERSION = "" ]]; then
+  printf "
+ERROR: could not find a git tag that resembles a semver version (x.y.z).
+\t> To add a 1.0.3 tag, run 'git tag 1.0.3'
+\t> Exiting with status code 1.
+
+";
+  exit 1;
+else
+  printf "VERSION: ";
+fi;
+
+
+if [[ $* == *-q* ]] || [[ $* == *--quiet* ]]; then exec 1>&6 6>&-; fi;
+
+printf "$VERSION\n";
+exit 0;

package/scripts/versioning/get-next

@@ -0,0 +1,90 @@
+#!/bin/bash
+help () { printf "
+***********
+get-next.sh
+***********
+gets the next semver versioning of the current folder based on the version
+in the git tag list. version should be in format x.y.z where x is the major
+version, y is the minor version and z is the patch version.
+
+options:
+\t-m --merged         : retrieve only from tags that have been merged
+\t-q --quiet          : suppresses debug prints
+\t-h --help           : prints this text
+
+usage:
+\t./get-next.sh <version_type> [...options]
+\t<version_type>:
+\t\tmajor: {major|maj|m1}
+\t\tminor: {minor|min|m2}
+\t\tpatch: {patch|ptc|p} (DEFAULT)
+
+examples:
+\t./get-next.sh maj : bumps the major version (1.0.0 > 2.0.0)
+\t./get-next.sh min : bumps the minor version (1.0.0 > 1.1.0)
+\t./get-next.sh patch : bumps the patch version (1.0.0 > 1.0.1)
+\t./get-next.sh -q : bumps the patch version (1.0.0 > 1.0.1) w/o output
+
+";
+}
+
+get_current_version () {
+  if [[ $* == *-m* ]] || [[ $* == *--merged* ]]; then MERGE=' -m'; else MERGE=''; fi;
+  GET_LATEST_COMMAND="$(dirname $0)/get-latest -q${MERGE}";
+  CURRENT_VERSION=$($GET_LATEST_COMMAND);
+  if [[ $? != 0 ]]; then
+    printf "
+ERROR: could not find a git tag that resembles a semver version (x.y.z).
+\t> To add a 1.0.3 tag, run 'git tag 1.0.3'
+\t> Exiting with status code 1.
+
+";
+    exit 1;
+  fi;
+  LATEST_MAJOR_VERSION=$(printf "$CURRENT_VERSION" | cut -d. -f1);
+  LATEST_MINOR_VERSION=$(printf "$CURRENT_VERSION" | cut -d. -f2);
+  LATEST_PATCH_VERSION=$(printf "$CURRENT_VERSION" | cut -d. -f3);
+}
+
+get_next_version () {
+  VERSION_TYPE_TO_UPDATE=$1;
+  NEXT_MAJOR_VERSION=$LATEST_MAJOR_VERSION;
+  NEXT_MINOR_VERSION=$LATEST_MINOR_VERSION;
+  NEXT_PATCH_VERSION=$LATEST_PATCH_VERSION;
+  case "$VERSION_TYPE_TO_UPDATE" in
+  "major"|"maj"|"m1")
+    ((NEXT_MAJOR_VERSION++));
+    NEXT_VERSION="${NEXT_MAJOR_VERSION}.0.0";
+    ;;
+  "minor"|"min"|"m2")
+    ((NEXT_MINOR_VERSION++));
+    NEXT_VERSION="${NEXT_MAJOR_VERSION}.${NEXT_MINOR_VERSION}.0";
+    ;;
+  "patch"|"ptc"|"p"|*)
+    ((NEXT_PATCH_VERSION++));
+    NEXT_VERSION="${NEXT_MAJOR_VERSION}.${NEXT_MINOR_VERSION}.${NEXT_PATCH_VERSION}";
+    ;;
+  esac
+}
+
+if [[ $* == *-h* ]] || [[ $* == *--help* ]]; then help; exit 1; fi;
+if [[ $* == *-q* ]] || [[ $* == *--quiet* ]]; then exec 6>&1; exec > /dev/null; fi;
+
+get_current_version;
+printf "CURRENT_VERSION: ${CURRENT_VERSION}\n";
+printf "MAJOR:           ${LATEST_MAJOR_VERSION}\n";
+printf "MINOR:           ${LATEST_MINOR_VERSION}\n";
+printf "PATCH:           ${LATEST_PATCH_VERSION}\n";
+
+get_next_version $1;
+printf "NEXT_VERSION:    ${NEXT_VERSION}\n";
+printf "MAJOR:           ${NEXT_MAJOR_VERSION}\n";
+printf "MINOR:           ${NEXT_MINOR_VERSION}\n";
+printf "PATCH:           ${NEXT_PATCH_VERSION}\n";
+
+printf "VERSION UPGRADE: ${CURRENT_VERSION} > ";
+
+if [[ $* == *-q* ]] || [[ $* == *--quiet* ]]; then exec 1>&6 6>&-; fi;
+
+printf "${NEXT_VERSION}\n";
+exit 0;

package/scripts/versioning/init

@@ -0,0 +1,40 @@
+#!/bin/bash
+help() { printf "
+*******
+init.sh
+*******
+checks for a semver versioning tag in current git repo. if absent, initializes
+it at 0.0.0. if present, doesn't do anything.
+
+options:
+\t-q --quiet          : suppresses debug prints
+\t-h --help           : prints this text
+
+usage/example:
+\t./init.sh -q : runs this script in quiet mode
+
+";
+}
+
+if [[ $* == *-h* ]] || [[ $* == *--help* ]]; then help; exit 1; fi;
+if [[ $* == *-q* ]] || [[ $* == *--quiet* ]]; then exec 6>&1; exec > /dev/null; fi;
+
+INITIAL_VERSION="0.0.0";
+GET_LATEST_COMMAND="$(dirname $0)/get-latest -q";
+CURRENT_VERSION=$($GET_LATEST_COMMAND);
+if [[ $? = 1 ]]; then
+  git tag ${INITIAL_VERSION};
+  printf "
+!: semver versioning not found from list of git tags...
+\t> initialized repository versioning with 0.0.0.
+
+";
+else
+  printf "
+latest semver version ${CURRENT_VERSION} found in git tags...
+skipping initialization.
+
+";
+fi;
+
+exit 0;

package/scripts/versioning/iterate

@@ -0,0 +1,76 @@
+#!/bin/bash
+help() { printf "
+*******
+iterate
+*******
+this script gets the latest merged version available in the current branch, ups
+the version number depending on the argument passed in. exits with 0 on successful
+updating, exist with 1 if tag could not be applied for any reason.
+
+versioning has to be in semver for this to work. eg. x.y.z where x is the major
+version, y is the minor version and z is the patch version.
+
+options:
+\t-m --merged         : retrieve only from tags that have been merged
+\t-i --init           : initializes tagging if no version tags could be found
+\t-q --quiet          : suppresses debug prints
+\t-h --help           : prints this text
+
+usage:
+\t./iterate [<version_target>]
+\t\t<version_target>:
+\t\t\t{ major|maj|1 } : ups the major version
+\t\t\t{ minor|min|2 } : ups the minor version
+\t\t\t{ patch|p|3 }   : ups the patch version
+
+";
+}
+
+if [[ $* == *-h* ]] || [[ $* == *--help* ]]; then help; exit 1; fi;
+if [[ $* == *-q* ]] || [[ $* == *--quiet* ]]; then exec 6>&1; exec > /dev/null; fi;
+if [[ $* == *-i* ]] || [[ $* == *--init* ]]; then INIT=1; else INIT=0; fi;
+if [[ $* == *-m* ]] || [[ $* == *--merged* ]]; then MERGE=' -m'; else MERGE=''; fi;
+
+GET_LATEST_COMMAND="$(dirname $0)/get-latest -q${MERGE}";
+CURRENT_VERSION=$($GET_LATEST_COMMAND);
+if [[ $? != 0 ]] && [[ $CURRENT_VERSION = "" ]]; then
+if [[ $INIT = 0 ]]; then
+  printf "
+ERROR: Versioning could not be found.
+\tTo initialize it at 0.0.0, pass in parameter -i or --init
+\tExiting with status code 1.
+";
+exit 1;
+else
+INIT_COMMAND="$(dirname $0)/init -q";
+INIT_RETURN=$($INIT_COMMAND)
+if [[ $? != 0 ]]; then
+  printf "
+ERROR: Unknown error happened while initializing version.
+\tYou could add the tag yourself with 'git tag 0.0.0'
+\tExiting with status code 1.
+";
+exit 1;
+fi;
+fi;
+fi;
+
+case $1 in
+  "major"|"maj"|"1")
+    GET_NEXT_COMMAND="$(dirname $0)/get-next major -q";
+  ;;
+  "minor"|"min"|"2")
+    GET_NEXT_COMMAND="$(dirname $0)/get-next minor -q";
+  ;;
+  "patch"|"p"|"3"|*)
+    GET_NEXT_COMMAND="$(dirname $0)/get-next patch -q";
+  ;;
+esac;
+
+NEXT_VERSION=$($GET_NEXT_COMMAND);
+
+CURRENT_BRANCH_COMMAND="$(dirname $0)/get-branch -q";
+CURRENT_BRANCH=$($CURRENT_BRANCH_COMMAND);
+git tag $NEXT_VERSION $CURRENT_BRANCH;
+
+exit 0;

package/scripts/versioning/readme.md

@@ -0,0 +1,280 @@
+# Version Tagging Scripts
+
+[![Build Status](https://travis-ci.org/zephinzer/version-tagging-scripts.svg?branch=master)](https://travis-ci.org/zephinzer/version-tagging-scripts)
+
+This package provides scripts that helps with managing semver versioning systems using
+git tagging.
+
+Semver versioning is:
+```
+ X . Y . Z
+ |   |   |-> patch version (bug fixes)
+ |   |-> minor version (backward-compatible changes/additions)
+ |-> major version (backward-compatibility breaking changes)
+```
+
+Read more on semver at: [http://semver.org/](http://semver.org/)
+
+
+
+# Recommended Installation
+
+
+
+Use this as a `git` submodule. Install it by running the following in the root of your
+project:
+
+```
+git submodule add https://github.com/zephinzer/version-tagging-scripts <./path/to/put/it/in>
+```
+
+
+
+# Usage
+
+
+
+By default, all scripts will print the debug output. They also come with a `-q` or
+`--quiet` flag that can silence the debug output which you should use once you've tested
+them out.
+
+Details of all scripts can also be found via the `-h` or `--help` script.
+
+> **IMPORTANT** Call the scripts using `./script` instead of `bash ./script`, this allows
+the script to find itself relative to where you're calling it from and things will **fail**
+should you not do so. The necessary hashbangs have been added and they are labelled with
+`#!/bin/sh`. 
+
+
+## `./iterate`
+
+
+The `./iterate` script should be enough for most continuous integration pipelines.
+
+Run it anywhere in your pipeline that you need to up the version number.
+
+To up the `patch` version, use:
+
+```bash
+./path/you/put/it/iterate -q -i
+```
+
+To up the `minor` version, use:
+
+```bash
+./path/you/put/it/iterate minor -q -i
+```
+
+To up the `major` version, use:
+
+```bash
+./path/you/put/it/iterate major -q -i
+```
+
+## `./get-branch`
+
+
+This script outputs the current branch you are on.
+
+
+## `./get-latest`
+
+
+This script outputs the latest version you are on.
+
+
+## `./get-next`
+
+
+This script outputs the next version you should be migrating to.
+
+
+## `./init`
+
+
+This script checks for the presence of a `git` tag that resembles `x.y.z` where
+`x` is the major version, `y` is the minor version, and `z` is the patch version.
+Should it fail to find such a git tag, it will initialize by adding a global
+`0.0.0` tag to your repository.
+
+
+
+# CI Software Integration Help
+
+
+
+## GitLab
+
+
+Install it in your dev machine with:
+
+```bash
+git submodule add https://github.com/zephinzer/version-tagging-scripts <./path/you/wanna/add/submodule/to>
+```
+
+A new file `.gitmodules` should appear. Verify that it looks like
+
+```
+[submodule './path/you/added/submodule/to']
+  path = ./path/you/added/submodule/to
+  url = https://github.com/zephinzer/version-tagging-scripts
+```
+
+We use this script with GitLab by installing this repository as a `git` submodule.
+In a `build` phase in your `scripts` property, add the following:
+
+```yaml
+...
+  stage: build
+...
+  artifacts:
+    path:
+      - ./path/you/added/submodule/to
+...
+  scripts:
+    - git submodule deinit -f .
+    - git submodule init
+    - git submodule update --init
+    - git submodule sync
+    - ...
+...
+```
+
+Note that using the `ssh://` version for this repo when adding the submodule **WILL NOT WORK**
+and will corrupt whichever runner it runs on.
+
+Incase you corrupt a runner, you'll need to access the directory containing your 
+project builds and manually run `deinit` and change the `.gitmodules` file to direct it
+to the HTTPS version of this repository. Main symptom of a corrupt runner will be during
+the fetch/clone phase of a job, you'll see some lines that look like:
+
+```
+Fetching changes...
+fatal: [../]+.git/modules/[./path/you/added/submodule/to] is not a git repository
+```
+
+Or something to that effect. No tests have been run, `before_script` has not run either.
+
+
+
+# Play With It
+
+
+
+The `./utils` directory contains some tools to get you started on how this works.
+
+
+## Setup Branches
+
+
+Run the following to set up a traditional CI pipeline consisting of
+`dev`, `ci`, `qa`, `uat`, `staging` and `production` branches/environments:
+
+```bash
+#> ./utils/branch_setup
+```
+
+You should find yourself on the `_dev` branch. They will be prefixed with an underscore
+incase you forget that they are just test example environments.
+
+
+## Setup Pipeline
+
+
+Run the following to add commits to the relevant branches:
+
+```bash
+#> ./utils/pipeline_setup
+```
+
+This will add commits to the environments that simulate an actual pipeline with
+`_production` having only 1 commit and `_dev` having all 6 commits (1 for each
+environment/branch).
+
+
+## Play With It
+
+
+Run `./iterate -q -i` on the `_dev` branch (which you should be on). This will initialize
+the versioning in _dev. Check out the versions available with:
+
+```bash
+#> git tag -l --merged
+```
+
+There should be `0.0.0` and `0.0.1`. Great.
+
+Now checkout the `_ci` branch and check the branch for tags with:
+
+```bash
+#> git tag -l --merged
+```
+
+There should be no tags. Now do a rebase from the `_dev` branch into your `_ci` branch:
+
+```bash
+#> git rebase _dev
+```
+
+Run the tag checking command again:
+
+```bash
+#> git tag -l --merged
+```
+
+You should now see `0.0.0` and `0.0.1` because the tags associated with the `HEAD`
+commit in the `_dev` branch should have been played to `_ci` and `_ci` now has the
+commits from `_dev`. Verify this yourself with `git log -n 1`. Both should match.
+
+
+## Enough Games
+
+
+Run the following to revert all test/example branches:
+
+```bash
+#> ./utils/branch_teardown
+```
+
+
+
+# Inspiration
+
+
+
+We needed a standardised way to add versioning to our packages. The primary way we use it internally is in a GitLab environment.
+
+
+
+# Testing
+
+
+
+We use Docker to test the code so that we can check if certain expected features are available.
+
+Run the tests using:
+
+```
+#> ./test
+```
+
+
+
+# Supported Versions
+
+
+
+## Git
+
+- Git 1.8.5
+
+
+# Contributing
+
+
+
+Feel it's lacking something? Feel free to submit a Pull Request. Got it to work with
+another CI software? Feel free to add to this readme's CI Software Integration Help
+section.
+
+Cheers!

package/scripts/versioning/test

@@ -0,0 +1,127 @@
+#!/bin/bash
+printf_top () {
+  printf "\e[4m                                                                            \e[0m\n";
+}
+
+printf_bottom () {
+  printf "⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻\n";
+}
+
+printf_fail () {
+  printf "\033[0;31mFAILED\033[0m\n";
+}
+
+printf_success () {
+  printf "\033[0;32mSUCCESSFUL\033[0m\n";
+}
+
+# on ./test [-s/--start] flag
+if [[ $* == *-s* ]] || [[ $* == *--start* ]]; then
+
+  # runs in CONTAINER
+
+  printf_top;
+  printf "PATH: $PATH\n";
+  printf "GIT: $(git --version)\n";
+  printf "USER: $(whoami)\n";
+  printf "TIMESTAMP: $(date +"%a, %d %h %Y %I:%M %p")\n"
+  printf_bottom;
+
+  TEST_RESULTS_DIRECTORY="$(dirname $0)/tests/results";
+  printf "Creating test results directory... ";
+  mkdir -p $TEST_RESULTS_DIRECTORY;
+  if [[ $? != 0 ]]; then printf_fail; else printf_success; fi;
+  printf "\t> PWD:      $(pwd)\n";
+  printf "\t> REL_PATH: $TEST_RESULTS_DIRECTORY\n";
+  rm -rf $TEST_RESULTS_DIRECTORY/*.test
+  ls tests/scripts | xargs -n 1 -I@ sh -c "$(dirname $0)/test --run @";
+
+# on ./test [-r/--run] flag
+elif [[ $* == *-r* ]] || [[ $* == *--run* ]]; then
+
+  # runs in CONTAINER
+
+  chmod +x $(dirname $0)/tests/scripts/$2;
+  printf_top;
+  printf "TEST MODULE  : $2\n";
+  printf "CURRENT DIR  : $(pwd)\n"
+  printf "CURRENT PATH : ${PATH}\n"
+  printf_bottom;
+  sh $(dirname $0)/tests/scripts/$2;
+  printf "$?" > $(dirname $0)/tests/results/$2;
+
+# on ./test [-e/--evaluate] flag
+elif [[ $* == *-e* ]] || [[ $* == *--evaluate* ]]; then
+
+  # runs on HOST
+
+  TEST_CASE=$2;
+  printf "Evaluating $TEST_CASE... ";
+
+  STATUS_CODE=$(cat $TEST_CASE);
+  if [[ $STATUS_CODE = 0 ]]; then printf "\033[0;32m"; else printf "\033[0;31m"; fi;
+  printf "Exited with status code $STATUS_CODE\033[0m.\n";
+
+  exit $(cat $TEST_CASE);
+
+# on ./test
+else
+
+  # runs on HOST
+
+  printf_top;
+
+  # get current version of scripts, exit if .version cannot be found
+  SCRIPTS_VERSION=$(cat $(dirname $0)/.version);
+  [[ $? != 0 ]] && CORRECT_DIRECTORY=0 || CORRECT_DIRECTORY=1;
+  if [[ $CORRECT_DIRECTORY = 0 ]]; then
+    printf "Error reading version specification. Are you in the right directory?\n";
+    printf "You are in $(pwd).\n";
+    printf_bottom;
+    exit 1;
+  fi;
+  printf "VERSION: $SCRIPTS_VERSION\n";
+
+  # check if Docker is available, exit if not
+  DOCKER_VERSION=$(docker --version);
+  [[ $? != 0 ]] && DOCKER_EXISTS=0 || DOCKER_EXISTS=1;
+  if [[ $DOCKER_EXISTS = 0 ]]; then
+    printf "We use Docker to ensure compliance with our software environments but we";
+    printf "coudln't find a Docker daemon to work with. Go to https://www.docker.com";
+    printf "to download it.\n\n";
+    printf "Quicklinks:\n";
+    printf "\tMAC: https://store.docker.com/editions/community/docker-ce-desktop-mac\n";
+    printf "\tWIN: https://store.docker.com/editions/community/docker-ce-desktop-windows\n"
+    printf_bottom;
+    exit 1;
+  fi;
+  printf "DOCKER VERSION: $DOCKER_VERSION\n";
+
+  # get some diagnostic info on which version we're on
+  COMMIT_SHA=$(git log -n 1 --pretty="%H");
+  [[ $(git status | grep 'Untracked') = "" ]] && UNTRACKED_EXISTS=0 || UNTRACKED_EXISTS=1;
+  [[ $(git status | grep 'modified:') = "" ]] && MODIFIED_EXISTS=0 || MODIFIED_EXISTS=1;
+  if [[ $UNTRACKED_EXISTS = 1 ]] | [[ $MODIFIED_EXISTS = 1 ]]; then
+    COMMIT_SHA="$COMMIT_SHA * modified";
+  fi;
+  printf "COMMIT SHA: $COMMIT_SHA\n";
+  CURRENT_BRANCH=$(git branch | grep "*" | cut -d' ' -f2);  
+  printf "ON BRANCH: $CURRENT_BRANCH\n";
+  printf_bottom;
+
+  # run tests
+  docker-compose -f ./tests/docker-compose.yml up --build;
+
+  # print results
+  printf_top;
+  ls tests/results | xargs -n 1 -I@ sh -c "$(dirname $0)/test --evaluate tests/results/@";
+  COLLATED_TESTS_RESULT=$?;
+  if [[ $COLLATED_TESTS_RESULT = 0 ]]; then printf "\033[0;32m"; else printf "\033[0;31m"; fi;
+  printf "\nExiting with status code $COLLATED_TESTS_RESULT.\033[0m\n";
+
+  printf_bottom;
+
+  # exit with test results code
+  exit $COLLATED_TESTS_RESULT;
+
+fi;

package/scripts/versioning/tests/Dockerfile

@@ -0,0 +1,4 @@
+FROM centos:centos7
+RUN yum -y update
+RUN yum -y install git
+RUN git --version

package/scripts/versioning/tests/docker-compose.yml

@@ -0,0 +1,8 @@
+version: '3'
+services:
+  test_it:
+    build: .
+    working_dir: /testpkg
+    command: ./test --start
+    volumes:
+      - ../:/testpkg

package/scripts/versioning/tests/scripts/get-branch.test

@@ -0,0 +1,50 @@
+#!/bin/sh
+ERRORS=0;
+
+printf_fail () {
+  ((ERRORS++));
+  printf "\033[0;31mFAILED\033[0m\n";
+}
+
+printf_success () {
+  printf "\033[0;32mSUCCESSFUL\033[0m\n";
+}
+
+./utils/branch_setup > /dev/null;
+
+git checkout _production > /dev/null;
+PRODUCTION_BRANCH=$(./get-branch);
+printf "_production : ";
+[[ $PRODUCTION_BRANCH = "_production" ]] && printf_success || printf_fail;
+
+git checkout _staging > /dev/null;
+STAGING_BRANCH=$(./get-branch);
+printf "_staging : ";
+[[ $STAGING_BRANCH = "_staging" ]] && printf_success || printf_fail;
+
+git checkout _uat > /dev/null;
+UAT_BRANCH=$(./get-branch);
+printf "_uat : ";
+[[ $UAT_BRANCH = "_uat" ]] && printf_success || printf_fail;
+
+git checkout _qa > /dev/null;
+QA_BRANCH=$(./get-branch);
+printf "_qa : ";
+[[ $QA_BRANCH = "_qa" ]] && printf_success || printf_fail;
+
+git checkout _ci > /dev/null;
+CI_BRANCH=$(./get-branch);
+printf "_ci : ";
+[[ $CI_BRANCH = "_ci" ]] && printf_success || printf_fail;
+
+git checkout _dev > /dev/null;
+DEV_BRANCH=$(./get-branch);
+printf "_dev : ";
+[[ $DEV_BRANCH = "_dev" ]] && printf_success || printf_fail;
+
+./utils/branch_teardown > /dev/null;
+
+[[ $ERRORS > 0 ]] && FAILURE=1 || FAILURE=0;
+
+printf "\nExiting with status code $FAILURE.\n\n";
+exit $FAILURE;

package/scripts/versioning/tests/scripts/get-latest.test

@@ -0,0 +1,53 @@
+#!/bin/sh
+# error count, anything more than 1 and we should exit with 1
+ERRORS=0;
+# each test case should alwys be larger than the next so we can automate checking
+# note that tags will actually be created, so use numbers that users prolly won't use
+TEST_CASES="
+1000.0.0
+1001.0.0
+1010.0.0
+1100.0.0
+9000.0.0
+10000.0.0
+10000.1.0
+10000.9.0
+10000.10.0
+10000.10.1
+10000.10.10
+10000.10.99
+10000.99.99
+10000.99.100
+10000.100.99
+"
+
+test_if_largest () {
+  printf "\t$1 : ";
+  git tag $1;
+  TEST_CASE=$(./get-latest -q);
+  if [[ $TEST_CASE != $1 ]] | [[ $? != 0 ]]; then
+    printf "\033[0;31mFAILED\033[0m\n";
+    exit 1;
+  fi;
+  printf "\033[0;32mSUCCESSFUL\033[0m\n";
+}
+
+teardown () {
+  printf "\t$1... ";
+  git tag -d $1 > /dev/null;
+  if [[ $? != 0 ]]; then
+    printf "\033[0;31mERROR\033[0m\n";
+    exit 1;
+  fi;
+  printf "\033[0;32mOK\033[0m\n";
+}
+
+printf "Processing...\n";
+echo $TEST_CASES | xargs -n 1 | xargs -I@ sh -c "$(declare -f test_if_largest); test_if_largest @;";
+[[ $? != 0 ]] && FAILURE=1 || FAILURE=0;
+printf "...DONE.\nRemoving...\n";
+echo $TEST_CASES | xargs -n 1 | xargs -I@ sh -c "$(declare -f teardown); teardown @;";
+printf "...DONE.\n";
+printf "\nExiting with status code $FAILURE.\n\n";
+
+exit $FAILURE;

package/scripts/versioning/tests/scripts/get-next.test

@@ -0,0 +1,50 @@
+#!/bin/sh
+ERRORS=0;
+TAG='1234567.1234567.1234567';
+EXPECTED_NEXT_PATCH='1234567.1234567.1234568';
+EXPECTED_NEXT_MINOR='1234567.1234568.0';
+EXPECTED_NEXT_MAJOR='1234568.0.0';
+
+printf_fail () {
+  EXPECTED=$1;
+  ACTUAL=$2;
+  ((ERRORS++));
+  printf "\033[0;31mFAILED (expected '${EXPECTED}' but got '${ACTUAL}')\033[0m\n";
+}
+
+printf_success () {
+  printf "\033[0;32mSUCCESSFUL\033[0m\n";
+}
+
+git tag $TAG;
+[[ $? != 0 ]] && ((ERRORS++));
+printf "Added tag '$TAG'\n";
+
+printf "Using 'patch'..."
+if [[ $(./get-next patch -q) != $EXPECTED_NEXT_PATCH ]]; then printf_fail $EXPECTED_NEXT_PATCH $(./get-next patch -q); else printf_success; fi;
+printf "Using 'ptc'..."
+if [[ $(./get-next ptc -q) != $EXPECTED_NEXT_PATCH ]]; then printf_fail $EXPECTED_NEXT_PATCH $(./get-next ptc -q); else printf_success; fi;
+printf "Using 'p'..."
+if [[ $(./get-next p -q) != $EXPECTED_NEXT_PATCH ]]; then printf_fail $EXPECTED_NEXT_PATCH $(./get-next p -q); else printf_success; fi;
+
+printf "Using 'minor'..."
+if [[ $(./get-next minor -q) != $EXPECTED_NEXT_MINOR ]]; then printf_fail $EXPECTED_NEXT_MINOR $(./get-next minor -q); else printf_success; fi;
+printf "Using 'min'..."
+if [[ $(./get-next min -q) != $EXPECTED_NEXT_MINOR ]]; then printf_fail $EXPECTED_NEXT_MINOR $(./get-next min -q); else printf_success; fi;
+printf "Using 'm2'..."
+if [[ $(./get-next m2 -q) != $EXPECTED_NEXT_MINOR ]]; then printf_fail $EXPECTED_NEXT_MINOR $(./get-next m2 -q); else printf_success; fi;
+
+printf "Using 'major'... "
+if [[ $(./get-next major -q) != $EXPECTED_NEXT_MAJOR ]]; then printf_fail $EXPECTED_NEXT_MAJOR $(./get-next major -q); else printf_success; fi;
+printf "Using 'maj'... "
+if [[ $(./get-next maj -q) != $EXPECTED_NEXT_MAJOR ]]; then printf_fail $EXPECTED_NEXT_MAJOR $(./get-next maj -q); else printf_success; fi;
+printf "Using 'm1'... "
+if [[ $(./get-next m1 -q) != $EXPECTED_NEXT_MAJOR ]]; then printf_fail $EXPECTED_NEXT_MAJOR $(./get-next m1 -q); else printf_success; fi;
+
+git tag -d $TAG;
+[[ $? != 0 ]] && ((ERRORS++));
+
+[[ $ERRORS > 0 ]] && FAILURE=1 || FAILURE=0;
+
+printf "\nExiting with status code $FAILURE.\n\n";
+exit $FAILURE;

package/scripts/versioning/tests/scripts/init.test

@@ -0,0 +1,25 @@
+#!/bin/sh
+ERRORS=0;
+INIT_VALUE="0.0.0";
+
+printf_fail () {
+  ((ERRORS++));
+  printf "\033[0;31mFAILED\033[0m\n";
+}
+
+printf_success () {
+  printf "\033[0;32mSUCCESSFUL\033[0m\n";
+}
+
+git tag -l | xargs -n 1 -I@ sh -c "git tag -d @";
+printf "Performing './init -q'... ";
+./init -q;
+if [[ $? != 0 ]]; then printf_fail; else printf_success; fi;
+printf "Checking for tag 0.0.0... ";
+if [[ $(git tag -l | grep $INIT_VALUE) != $INIT_VALUE ]]; then printf_fail; else printf_success; fi;
+git tag -d $INIT_VALUE;
+
+[[ $ERRORS > 0 ]] && FAILURE=1 || FAILURE=0;
+
+printf "\nExiting with status code $FAILURE.\n\n";
+exit $FAILURE;

package/scripts/versioning/tests/scripts/iterate.test

@@ -0,0 +1,65 @@
+#!/bin/sh
+ERRORS=0;
+INITIAL_VERSION="123456.123456.123456";
+NEXT_PATCH_VERSION="123456.123456.123457";
+NEXT_MINOR_VERSION="123456.123457.0";
+NEXT_MAJOR_VERSION="123457.0.0";
+
+iterate_with () {
+  git tag $INITIAL_VERSION;
+  ./iterate $1 -q;
+}
+
+teardown () {
+  git tag -d $INITIAL_VERSION >/dev/null;
+  git tag -d $1 >/dev/null;
+}
+
+run_test_and_cleanup_on () {
+  [[ $(git tag -l | grep $1) = "" ]] && printf_fail || printf_success;
+  teardown $1;
+}
+
+printf_fail () {
+  ((ERRORS++));
+  printf "\033[0;31mFAILED\033[0m\n";
+}
+
+printf_success () {
+  printf "\033[0;32mSUCCESSFUL\033[0m\n";
+}
+
+printf "Using 'patch': ";
+iterate_with patch;
+run_test_and_cleanup_on $NEXT_PATCH_VERSION;
+printf "Using 'p': ";
+iterate_with p;
+run_test_and_cleanup_on $NEXT_PATCH_VERSION;
+printf "Using '3': ";
+iterate_with 3;
+run_test_and_cleanup_on $NEXT_PATCH_VERSION;
+
+printf "Using 'minor': ";
+iterate_with minor;
+run_test_and_cleanup_on $NEXT_MINOR_VERSION;
+printf "Using 'min': ";
+iterate_with min;
+run_test_and_cleanup_on $NEXT_MINOR_VERSION;
+printf "Using '2': ";
+iterate_with 2;
+run_test_and_cleanup_on $NEXT_MINOR_VERSION;
+
+printf "Using 'major': ";
+iterate_with major;
+run_test_and_cleanup_on $NEXT_MAJOR_VERSION;
+printf "Using 'maj': ";
+iterate_with maj;
+run_test_and_cleanup_on $NEXT_MAJOR_VERSION;
+printf "Using '1': ";
+iterate_with 1;
+run_test_and_cleanup_on $NEXT_MAJOR_VERSION;
+
+[[ $ERRORS > 0 ]] && FAILURE=1 || FAILURE=0;
+
+printf "\nExiting with status code $FAILURE.\n\n";
+exit $FAILURE;

package/scripts/versioning/utils/branch_setup

@@ -0,0 +1,7 @@
+#!/bin/sh
+git checkout -b _production
+git checkout -b _staging
+git checkout -b _uat
+git checkout -b _qa
+git checkout -b _ci
+git checkout -b _dev

package/scripts/versioning/utils/branch_teardown

@@ -0,0 +1,8 @@
+#!/bin/sh
+git checkout master
+git branch -D _dev
+git branch -D _ci
+git branch -D _qa
+git branch -D _uat
+git branch -D _staging
+git branch -D _production

package/scripts/versioning/utils/pipeline_setup

@@ -0,0 +1,79 @@
+#!/bin/sh
+[[ $(git branch | egrep '_dev$') != "" ]] && DEV_EXISTS=1 || DEV_EXISTS=0;
+[[ $(git branch | egrep '_ci$') != "" ]] && CI_EXISTS=1 || CI_EXISTS=0;
+[[ $(git branch | egrep '_qa$') != "" ]] && QA_EXISTS=1 || QA_EXISTS=0;
+[[ $(git branch | egrep '_uat$') != "" ]] && UAT_EXISTS=1 || UAT_EXISTS=0;
+[[ $(git branch | egrep '_staging$') != "" ]] && STAGING_EXISTS=1 || STAGING_EXISTS=0;
+[[ $(git branch | egrep '_production$') != "" ]] && PRODUCTION_EXISTS=1 || PRODUCTION_EXISTS=0;
+echo "$DEV_EXISTS $CI_EXISTS $QA_EXISTS $UAT_EXISTS $STAGING_EXISTS $PRODUCTION_EXISTS";
+if [[ $DEV_EXISTS = 0 ]] |
+  [[ $CI_EXISTS = 0 ]] |
+  [[ $QA_EXISTS = 0 ]] |
+  [[ $UAT_EXISTS = 0 ]] |
+  [[ $STAGING_EXISTS = 0 ]] |
+  [[ $PRODUCTION_EXISTS = 0 ]]; then
+  printf 'The necessary environments (_dev, _ci, _qa, _uat, _staging, _production) could not be found. Run "branch_setup" before continuing"\n';
+  exit 1;
+fi;
+
+mkdir -p _data
+
+git checkout _dev;
+echo 'prod' > ./_data/prod.flag;
+git add -f ./_data/prod.flag;
+git commit -m 'prod';
+git checkout _ci;
+git rebase _dev;
+git checkout _qa;
+git rebase _ci;
+git checkout _uat;
+git rebase _qa;
+git checkout _staging;
+git rebase _uat;
+git checkout _production;
+git rebase _staging;
+
+git checkout _dev;
+echo 'staging' > ./_data/staging.flag;
+git add -f ./_data/staging.flag;
+git commit -m 'staging';
+git checkout _ci;
+git rebase _dev;
+git checkout _qa;
+git rebase _ci;
+git checkout _uat;
+git rebase _qa;
+git checkout _staging;
+git rebase _uat;
+
+git checkout _dev;
+echo 'uat' > ./_data/uat.flag;
+git add -f ./_data/uat.flag;
+git commit -m 'uat';
+git checkout _ci;
+git rebase _dev;
+git checkout _qa;
+git rebase _ci;
+git checkout _uat;
+git rebase _qa;
+
+git checkout _dev;
+echo 'qa' > ./_data/qa.flag;
+git add -f ./_data/qa.flag;
+git commit -m 'qa';
+git checkout _ci;
+git rebase _dev;
+git checkout _qa;
+git rebase _ci;
+
+git checkout _dev;
+echo 'ci' > ./_data/ci.flag;
+git add -f ./_data/ci.flag;
+git commit -m 'ci';
+git checkout _ci;
+git rebase _dev;
+
+git checkout _dev;
+echo 'dev' > ./_data/dev.flag;
+git add -f ./_data/dev.flag;
+git commit -m 'dev';