pbuilder

#!/bin/bash

cwd=$(pwd)
RELEASE_VERSION=()
TOOLS_LIST=()

DEFAULT_CONFIG_FILE="config.conf"

STAGING_DIR="staging"
RELEASES_DIR="releases"
RELEASES_BOARD_DIR="boards"
ARCHIVE_EXT=".tar.gz"

TEMPLATE_DIR="template"
TEMPLATE_PLATFORM_FILE="platform"
TEMPLATE_PACKAGE_FILE="package"
TEMPLATE_EXTENSION=".json"


# -------------------------------------------------------------------------------------------
#	Template stuff
# -------------------------------------------------------------------------------------------

function default_boards_template()
{
	local _board_template=`cat<<EOF
					
					{
						"name" : "${!_board}"
					}
EOF`
echo "${_board_template}"
}

function default_platform_template()
{
	local _plat_template=`cat<<EOF
			{
				"name" : "${BOARD_NAME}",
				"architecture" : "${BOARD_ARCH}",
				"version" : "${_version}",
				"category" : "${BOARD_CATEGORY}",
				"url" : "${_url}",
				"archiveFileName" : "${archiveFileName##*/}",
				"checksum" : "SHA-256:${_sha}",
				"size" : "${_size}",
				"help" : {
					"online" : "${BOARD_HELP_URL}"
				},
				"boards" : [
					${_boards}
				],
				"toolsDependencies" : [
					${_tools_deps}
				]
			}
EOF`
echo "${_plat_template}"
}

function default_package_template()
{
	local _pkg_template=`cat<<EOF
{
	"packages" : [
		{
			"name" : "${BOARD_PACKAGE_NAME}",
			"maintainer" : "${BOARD_PACKAGE_MAINTAINER}",
			"websiteURL" : "${BOARD_PACKAGE_WEB_URL}",
			"email" : "${BOARD_PACKAGE_MAINTAINER_EMAIL}",
			"help" : {
				"online" : "${BOARD_PACKAGE_HELP_URL}"
			},
			"platforms" : [
				${_platforms}
			],
			"tools" : [
			    {
             "name": "micronucleus",
             "version": "2.0a4",
             "systems": [
               {
                 "host": "x86_64-apple-darwin",
                 "archiveFileName": "micronucleus-2.0a4-osx.tar.gz",
                 "url": "https://teenyriot.github.io/TeenyRiot/tools/micronucleus-2.0a4-osx.tar.gz",
                 "checksum": "SHA-256:B5EB0C7B251CD88F4816186BB931855834141E71A28D90FB9E46788E483AA421",
                 "size": "51203"
               },
               {
                 "host": "i686-mingw32",
                 "archiveFileName": "micronucleus-2.0a4-win.zip",
                 "url": "https://teenyriot.github.io/TeenyRiot/tools/micronucleus-2.0a4-win.zip",
                 "checksum": "SHA-256:7738d2a2a46a13771ac567ca3797a4867bcb802e7ca12e41941448645b035c6c",
                 "size": "1712001"
               },
               {
                 "host": "i686-linux-gnu",
                 "archiveFileName": "micronucleus-2.0a4-linux32.tar.gz",
                 "url": "https://teenyriot.github.io/TeenyRiot/tools/micronucleus-2.0a4-linux32.tar.gz",
                 "checksum": "SHA-256:0D4286388EED28D1ECB29AFE81253F24F54D4F0A5C1B2C17507EABD504C595F8",
                 "size": "21909"
               },
               {
                 "host": "x86_64-linux-gnu",
                 "archiveFileName": "micronucleus-2.0a4-linux64.tar.gz",
                 "url": "https://teenyriot.github.io/TeenyRiot/tools/micronucleus-2.0a4-linux64.tar.gz",
                 "checksum": "SHA-256:1f545c0bb60e85a604901c2d7044772ac91776594c209c571dfedad4a70195b8",
                 "size": "22874"
               }

             ]
           }
				    ]
				  }
			]
		}
	]
}
EOF`
echo "${_pkg_template}"
}

# -------------------------------------------------------------------------------------------
#	Template stuff
# -------------------------------------------------------------------------------------------

#define the template.
function generate_platform_template() #version, url, checksum, size
{

	local _version=${1}
	local _url=${2}
	local archiveFileName="${2}"; 
	local _sha=${3}
	# local _size=${4}
	local _tools_deps=${4}
	local _template=${5}

	local _boards=`generate_boards_template BOARD_LIST`


	if [ "${_template}" != "" ] && [ "${_template}" != "default" ]
	then
		eval "cat <<EOF
		$(<./${TEMPLATE_DIR}/${_template}${TEMPLATE_EXTENSION})
		EOF
		" 2> /dev/null
	else
		default_platform_template
	fi


}

function generate_package_template() #platforms
{
	local _platforms=${1}
	local _template=${2}

	if [ "${_template}" != "" ] && [ "${_template}" != "default" ]
	then
		eval "cat <<EOF
		$(<./${TEMPLATE_DIR}/${_template}${TEMPLATE_EXTENSION})
		EOF
		" 2> /dev/null
	else
		default_package_template
	fi

}


function generate_boards_template()
{
	local _tmp_string=""
	local i=0

	local array="${1}[@]"
	local EXPR="echo \${#$1[@]}" 
	local _cnt=`eval $EXPR`

	for (( i=0; i<${_cnt}; i++ ));
	do
		local _board="$1[$i]"
		_tmp_string+=`default_boards_template`
		if [ $((i+1)) -ne ${_cnt} ]
		then
			_tmp_string+=","
		fi

	done
	echo "${_tmp_string}"

}


function generate_tools_deps_template()
{
	local array="${1}[@]"
	local _tmp_string=""

	local EXPR="echo \${#$1[@]}" 
	local _cnt=`eval $EXPR`

	for (( i=0; i<${_cnt}; i++ ));
	do
		local element="$1[$i]"
		IFS=', ' read -a array <<< "${!element}"
		_tmp_string+=`cat<<EOF
					
					{
						"packager" : "${array[1]}",
						"name" : "${array[2]}",
						"version" : "${array[3]}"
					}
EOF`
		if [ $((i+1)) -ne ${_cnt} ]
		then
			_tmp_string+=","
		fi

	done
	echo "${_tmp_string}"
}

function generate_tools_template()
{
	local _tmp_string=""
	local _sub_tmp_string=""
	
	local _cnt=${#TOOLS_LIST[@]}

	for (( i=0; i<${_cnt}; i++ ));
	do

 		IFS=', ' read -a array <<< "${TOOLS_LIST[i]}"
 		echo ${array[0]}

		ARRAYNAME=${array[0]}
		array="${ARRAYNAME}[@]"			
		
		local EXPR="echo \${#$ARRAYNAME[@]}" 
		local _cnt_=`eval $EXPR`

			for (( j=0; j<${_cnt_}; j++ ));
			do
				echo $j

				if [ $((j+1)) -ne ${_cnt_} ]
				then
					echo ","
				fi

			done

		if [ $((i+1)) -ne ${_cnt} ]
		then
			echo "-,"
		fi

	done
	echo "${_tmp_string}"
}

# -------------------------------------------------------------------------------------------
#	git
# -------------------------------------------------------------------------------------------


function git_pull_repo()
{
	local _REPO_DIR="${1}"

	if check_folder_git ${_REPO_DIR}
	then
		echo "git repo:${_REPO_DIR}"
		cd ${_REPO_DIR};
		git pull --all
		return 0
	else
		echo "directory is not a repo"
		return 1
	fi

	cd ${cwd}
}

function git_update_repo()
{
	if [ -d "${STAGING_DIR}/${REPO_SOURCE_LOCAL_DIR}" ] #if directory exists
	then
		cd "${cwd}/${STAGING_DIR}/${REPO_SOURCE_LOCAL_DIR}"

		git fetch --all
		git pull --all

#		for b in `git branch -r | grep -v -- '->'`; 
#		do 
#			echo "${b}"
#			#git branch --track ${b##origin/} $b; 
#		done

	fi
	
	cd "${cwd}"
}

function update_release_repo() #repo url, dir, specific commit
{
	local _REPO_REMOTE_URL=${1}
	local _REPO_LOCAL_DIR=${2}
	local _COMMIT_HASH=${3}
	
	if [ -d "${_REPO_LOCAL_DIR}" ] #if directory exists
	then
		cd "${cwd}/${_REPO_LOCAL_DIR}"
		git reset --hard ${_COMMIT_HASH}
		git submodule update --init --recursive
		git submodule foreach --recursive git clean -d -f -f
	else
		git clone "${_REPO_REMOTE_URL}" "${_REPO_LOCAL_DIR}"
		cd "${_REPO_LOCAL_DIR}"
		git checkout ${_COMMIT_HASH}
		git submodule update --init --recursive
		git submodule foreach --recursive git clean -d -f -f
	fi
	
	cd "${cwd}"
}



function git_init_release_pages()
{
	if [ -d "${RELEASES_DIR}/${RELEASE_REPO_DIR}" ] #if directory exists
	then
	echo "git init: directory ${RELEASES_DIR}/${RELEASE_REPO_DIR} already exist!"

	else

	cd ${RELEASES_DIR}
	
	git clone --depth 1 ${RELEASE_REPO_URL} ${RELEASE_REPO_DIR}
	cd ${RELEASE_REPO_DIR}
	git checkout --orphan ${RELEASE_REPO_BRANCH}

	cd ${cwd}

	fi
}

function git_pull_release_pages()
{
	if check_folder_git "${RELEASES_DIR}/${RELEASE_REPO_DIR}"
	then
		cd ${RELEASES_DIR}/${RELEASE_REPO_DIR}
		git pull origin gh-pages
	else
		git_init_release_pages
	fi

	cd ${cwd}
}

function git_push_release_pages()
{

	if check_folder_git "${RELEASES_DIR}/${RELEASE_REPO_DIR}"
	then
		if [ -d "${RELEASES_DIR}/${RELEASE_REPO_DIR}" ] #if directory exists
		then
		
		cd ${RELEASES_DIR}/${RELEASE_REPO_DIR}

		git add .
		git commit -m "update release"
		git push origin ${RELEASE_REPO_BRANCH}

		cd ${cwd}

		else

		echo "git publish: directory ${RELEASES_DIR}/${RELEASE_REPO_DIR} is not exist!"
		
		fi
	else
		git_init_release_pages
	fi


}

# -------------------------------------------------------------------------------------------
#	archiving
# -------------------------------------------------------------------------------------------

function archive_release_repo() #repo dir, filename
{
	mkdir -p ${cwd}/${RELEASES_DIR}/${RELEASE_REPO_DIR}/${RELEASES_BOARD_DIR}

	local _REPO_DIR=${1}
	local _ARCHIVE_FILE=${2}
	local _SOURCE_FILE=${3}

	cd ${cwd}/${_REPO_DIR}

	tar --exclude=".git" --exclude=".DS_Store" --exclude=".gitignore" --exclude=".gitmodules" -c  ${_SOURCE_FILE} | gzip -n > ${cwd}/${RELEASES_DIR}/${RELEASE_REPO_DIR}/${RELEASES_BOARD_DIR}/${_ARCHIVE_FILE}${ARCHIVE_EXT} 
	git log -1 > ${cwd}/${RELEASES_DIR}/${RELEASE_REPO_DIR}/${RELEASES_BOARD_DIR}/${_ARCHIVE_FILE}.sha.txt
	shasum -a 256 ${cwd}/${RELEASES_DIR}/${RELEASE_REPO_DIR}/${RELEASES_BOARD_DIR}/${_ARCHIVE_FILE}${ARCHIVE_EXT}  | cut -d ' ' -f 1 >> ${cwd}/${RELEASES_DIR}/${RELEASE_REPO_DIR}/${RELEASES_BOARD_DIR}/${_ARCHIVE_FILE}.sha.txt
	cd "${cwd}"
}

function get_duplicate_archive()
{
	local _hash=${1}
	local _my_version=${2}
	local j=0

	local tLen=${#RELEASE_VERSION[@]}
	for ((j=0; j<${tLen}; j++ ));
	do
  		IFS=', ' read -a array <<< "${RELEASE_VERSION[$j]}"
		local _RELEASE_VERSION=${array[0]}
		local _COMMIT_HASH=${array[1]}

		if [ "${_hash}" == "${_COMMIT_HASH}" ] && [ "${_my_version}" != "${_RELEASE_VERSION}" ] 
		then
			if check_release_archive_exists ${RELEASE_PREFIX}${_RELEASE_VERSION}
			then
				echo "${_RELEASE_VERSION}"
			fi
		fi

	done

	echo ""
}


# -------------------------------------------------------------------------------------------
#	check function
# -------------------------------------------------------------------------------------------


function check_commit_exist()
{
	local _hash=${1}
	local _my_version=${2}
	local j=0

	local tLen=${#RELEASE_VERSION[@]}
	for ((j=0; j<${tLen}; j++ ));
	do
  		IFS=', ' read -a array <<< "${RELEASE_VERSION[$j]}"
		local _RELEASE_VERSION=${array[0]}
		local _COMMIT_HASH=${array[1]}

		if [ "${_hash}" == "${_COMMIT_HASH}" ] && [ "${_my_version}" != "${_RELEASE_VERSION}" ] 
		then
			if check_release_archive_exists ${RELEASE_PREFIX}${_RELEASE_VERSION}
			then
				return 0
			fi
		fi

	done

	return 1
}

function check_release_archive_exists()
{
	local _FILE_NAME=${1}
	
	if [ -e "${cwd}/${RELEASES_DIR}/${RELEASE_REPO_DIR}/${RELEASES_BOARD_DIR}/${_FILE_NAME}${ARCHIVE_EXT}" ]
	then
		return 0 #true
	else
		return 1 #false
	fi
}


function check_file_exists()
{
	local _FILE_NAME=${1}
	
	if [ -f "${_FILE_NAME}" ]
	then
		return 0 #true
	else
		return 1 #false
	fi	
}


function check_folder_git()
{
	local _FOLDER_NAME=${1}
	
	if  check_dir_exists "${_FOLDER_NAME}/.git"
	then
		return 0 #true
	else
		return 1 #false
	fi	
}

function check_dir_exists()
{
	local _FILE_NAME=${1}
	
	if [ -d "${_FILE_NAME}" ]
	then
		return 0 #true
	else
		return 1 #false
	fi	
}

function check_config_exists()
{
	local _FILE_NAME=${1}
	
	if [ -e "${_FILE_NAME}" ]
	then
		echo "using config ${_FILE_NAME}"
		CONFIG_FILE="${_FILE_NAME}"
		source ${_FILE_NAME}
	else
		if [ -e "${DEFAULT_CONFIG_FILE}" ]
		then
			echo "using default ./${DEFAULT_CONFIG_FILE}"
			CONFIG_FILE="./${DEFAULT_CONFIG_FILE}"
			source "${CONFIG_FILE}"
		else
			echo "config not found, abort"
			exit 1
		fi
	fi
}



# -------------------------------------------------------------------------------------------
#	tools and deps management
# -------------------------------------------------------------------------------------------


function LIST_ALL_TOOLS()
{
	ARRAYNAME="TOOLS_LIST"
	array="${ARRAYNAME}[@]"
	echo "List all tools"	
	for element in "${!array}"; do
		IFS=', ' read -a array <<< "${element}"
		echo "	* ${array[0]} - ${array[1]} - ${array[2]} - ${array[3]}"
		ARRAYNAME=${array[0]}
		array="${ARRAYNAME}[@]"			
				for item in "${!array}"; do
					IFS=', ' read -a array <<< "${item}"
					echo "	 + ${array[0]} - ${array[1]}"
				done			
	done
}

function LIST_DEPENDENCIES()
{
	ARRAYNAME="${1}"
	array="${ARRAYNAME}[@]"
	
	echo "Package: $1"
	
	for element in "${!array}"; do
		IFS=', ' read -a array <<< "${element}"
		echo "	* ${array[0]} - ${array[1]} - ${array[2]} - ${array[3]}"		
	done
}


function LIST_ALL_DEPENDENCIES()
{
	ARRAYNAME="${1}"
	array="${ARRAYNAME}[@]"
	
	echo "Package: $1"
	
	for element in "${!array}"; do
		IFS=', ' read -a array <<< "${element}"
		echo "	* ${array[0]} - ${array[1]} - ${array[2]} - ${array[3]}"
		ARRAYNAME=${array[0]}
		array="${ARRAYNAME}[@]"			
				for item in "${!array}"; do
					IFS=', ' read -a array <<< "${item}"
					echo "	 + ${array[0]} - ${array[1]}"
				done			
	done
}

function ADD_DEPENDENCIES()
{
	local _package_container=${1}	
	local _packager=${2}	
	local _package_name=${3}
	local _version=${4}
	local _package_name_clean=$(echo "${_package_name}" | sed 's#\.#\_#g' | sed 's#\-#\_#g')	
	local _version_clean=$(echo "${_version}" | sed 's#\.#\_#g' | sed 's#\-#\_#g')	
	local _new_var="${_package_name_clean}_${_version_clean}"
	eval "${_package_container}+=(${_new_var},${_packager},${_package_name},${_version})"
}

function ADD_TOOLS()
{
	local _package_name=${1}
	local _version=${2}	
	local _system=${3}
	local _file=${4}		
	local _version_clean=$(echo "${_version}" | sed 's#\.#\_#g' | sed 's#\-#\_#g')
	local _new_var="${_package_name}_${_version_clean}"
	
	local _check="${_new_var}"
		
	if [ "${!_check}" == "" ]
	then
		TOOLS_LIST+=(${_new_var},${_packager},${_package_name},${_version})
	fi
	
	eval "${_new_var}+=(${_system},${_file})"
}

function ADD_BOARD_LIST()
{
	BOARD_LIST+=("${1}")
}

# -------------------------------------------------------------------------------------------
#	release 
# -------------------------------------------------------------------------------------------


function add_new_release()
{
	echo -e "ADD_RELEASE\t\t${1}\t${2}\t${3}\n" >> ${CONFIG_FILE}
}


function ADD_RELEASE()
{
	RELEASE_VERSION+=("${1}","${2}","${3}","${4}")
}


function list_release()
{
	local tLen=${#RELEASE_VERSION[@]}
	echo "------------------------------------------------------------------"			
	echo "Releases:"

	for (( i=0; i<${tLen}; i++ ));
	do
	IFS=', ' read -a array <<< "${RELEASE_VERSION[$i]}"
	local _RELEASE_VERSION=${array[0]}
	local _COMMIT_HASH=${array[1]}

	echo "- release version: ${_RELEASE_VERSION} commit: ${_COMMIT_HASH}"

	done

	echo "------------------------------------------------------------------"


}


# -------------------------------------------------------------------------------------------
#	build function
# -------------------------------------------------------------------------------------------

function build_push_config()
{
	git add config.conf
	git commit -m "update config"	
	git push origin master
}

function build_pull_config()
{
	git pull --all
	git_pull_release_pages
}

# -------------------------------------------------------------------------------------------
#	package builder
# -------------------------------------------------------------------------------------------



function make_packages()
{
	git_update_repo

	# get length of an array
	local tLen=${#RELEASE_VERSION[@]}
	 
	# use for loop read all
	for (( i=0; i<${tLen}; i++ ));
	do
  		IFS=', ' read -a array <<< "${RELEASE_VERSION[$i]}"
		local _RELEASE_VERSION=${array[0]}
		local _COMMIT_HASH=${array[1]}
		local _PLATFORM_DEPS=${array[2]}
		local _PLATFORM_TEMPLATE=${array[3]}	

		if [ "${_PLATFORM_DEPS}" != "" ]
		then
			local tools_deps=`generate_tools_deps_template ${_PLATFORM_DEPS}`
		fi

		#check for duplicate commit that already have archive
		if check_commit_exist ${_COMMIT_HASH} ${_RELEASE_VERSION}
		 then 
		 	#echo "if found duplicate"
		 	#check our own release if exist
			if check_release_archive_exists ${RELEASE_PREFIX}${_RELEASE_VERSION}
			then
				#echo "skip archiving, write to package json only"
				echo "${_RELEASE_VERSION} already exist, skip"
			else #if we dont have package
				
				local _duplicate_archive=`get_duplicate_archive ${_COMMIT_HASH} ${_RELEASE_VERSION}`

				echo "${_RELEASE_VERSION} use archive from ${_duplicate_archive}"

				local sha_result=`shasum -a 256 ${cwd}/${RELEASES_DIR}/${RELEASE_REPO_DIR}/${RELEASES_BOARD_DIR}/${RELEASE_PREFIX}${_duplicate_archive}${ARCHIVE_EXT} | cut -d ' ' -f 1`
				platform_list+=`generate_platform_template ${_RELEASE_VERSION} ${RELEASE_FILE_URL}/${RELEASES_BOARD_DIR}/${RELEASE_PREFIX}${_duplicate_archive}${ARCHIVE_EXT} ${sha_result} "${tools_deps}" ${_PLATFORM_TEMPLATE}`

			fi	

		 else #if no duplicate commit
		 	#echo "no dup commit"
			 if check_release_archive_exists ${RELEASE_PREFIX}${_RELEASE_VERSION}
			 then
			 	echo "${_RELEASE_VERSION} exists, skip"
			 else
			 	update_release_repo "${REPO_SOURCE_URL}" "${STAGING_DIR}/${REPO_SOURCE_LOCAL_DIR}" "${_COMMIT_HASH}"
			 	archive_release_repo "${STAGING_DIR}/${REPO_SOURCE_LOCAL_DIR}" "${RELEASE_PREFIX}${_RELEASE_VERSION}" "${BOARD_ARCH}"
			 fi	

			local sha_result=`shasum -a 256 ${cwd}/${RELEASES_DIR}/${RELEASE_REPO_DIR}/${RELEASES_BOARD_DIR}/${RELEASE_PREFIX}${_RELEASE_VERSION}${ARCHIVE_EXT} | cut -d ' ' -f 1`
			platform_list+=`generate_platform_template ${_RELEASE_VERSION} ${RELEASE_FILE_URL}/${RELEASES_BOARD_DIR}/${RELEASE_PREFIX}${_RELEASE_VERSION}${ARCHIVE_EXT} ${sha_result} "${tools_deps}" ${_PLATFORM_TEMPLATE}`

		fi
		

		
		if [ $((i+1)) -ne $tLen ]
		then
			platform_list+=","
		fi
	done

	local json_package_output=`generate_package_template "${platform_list}"`
	echo "${json_package_output}" > "${RELEASES_DIR}/${RELEASE_REPO_DIR}/${RELEASE_INDEX_JSON_FILENAME}"
}




# -------------------------------------------------------------------------------------------
#	help
# -------------------------------------------------------------------------------------------


function config_info()
{
cat<<EOF

------------------------------------------------------------------			
Package:

- BOARD_PACKAGE_NAME=${BOARD_PACKAGE_NAME}
- BOARD_PACKAGE_MAINTAINER=${BOARD_PACKAGE_MAINTAINER}
- BOARD_PACKAGE_WEB_URL=${BOARD_PACKAGE_WEB_URL}
- BOARD_PACKAGE_HELP_URL=${BOARD_PACKAGE_HELP_URL}
- BOARD_PACKAGE_MAINTAINER_EMAIL=${BOARD_PACKAGE_MAINTAINER_EMAIL}

- BOARD_NAME=${BOARD_NAME}
- BOARD_ARCH=${BOARD_ARCH}
- BOARD_CATEGORY=${BOARD_CATEGORY}
- BOARD_HELP_URL=${BOARD_HELP_URL}

Package url:
Copy paste into arduino package url list

- ${RELEASE_FILE_URL}/${RELEASE_INDEX_JSON_FILENAME}

------------------------------------------------------------------		

EOF
}

function usage()
{
echo "usage"
}


# -------------------------------------------------------------------------------------------
#	todo
# -------------------------------------------------------------------------------------------

function git_reset_staging()
{
		if [ -d "${_REPO_LOCAL_DIR}" ] #if directory exists
		then
			cd ${RELEASES_DIR}/${RELEASE_REPO_DIR}
			git reset --hard
			git clean -dfx
		else
			echo "directory not exist"
		fi
}

# -------------------------------------------------------------------------------------------
#	argument
# -------------------------------------------------------------------------------------------


while [ "$1" != "" ]; do
    case $1 in
        -l | --list | list)   
			check_config_exists ${2} 
			list_release
			exit
        ;;
        -c | --config )
			check_config_exists ${2}
			make_packages
			exit
		;;
        -e | --edit | edit )
			check_config_exists "./${DEFAULT_CONFIG_FILE}"

			echo "fetching latest config to avoid conflict"
			build_pull_config

			vi "./${DEFAULT_CONFIG_FILE}" +
			exit
		;;		
        -a | --add | add)
			check_config_exists "./${DEFAULT_CONFIG_FILE}"

			echo "fetching latest config to avoid conflict"
			build_pull_config

			config_info
			list_release

			echo ""			
			echo "Add new release"
			echo "Enter Version: "; read _version;
			echo "Enter Commit#: "; read _commit;
			add_new_release ${_version} ${_commit}
			echo "new release added, please use build command to make a new package"
			exit		
        ;;
        -h | --help )
			usage
	        exit
        ;;
        -b | --build | build )
			check_config_exists ${2}
			make_packages
			exit
        ;;   
        publish )
			check_config_exists ${2}
			git_push_release_pages
	        exit
        ;; 
        pull )
			build_pull_config
	        exit
        ;;   
        push )
			build_push_config
	        exit
        ;;                          
        initpage )
			check_config_exists ${2}
			git_init_release_pages
	        exit
        ;;  
        info )
			check_config_exists ${2} 
			config_info
			list_release
	        exit
        ;;            
        reset )
			check_config_exists ${2} 
			echo "hard reset local release repo"
			git_reset_staging
	        exit
        ;;            
        clean )
			check_config_exists ${2} 
			echo "cleaning release folder and package json"
			echo "delete ${RELEASES_DIR}/${RELEASE_REPO_DIR}/${RELEASES_BOARD_DIR}/${RELEASE_PREFIX}*"		
			rm -fr ${RELEASES_DIR}/${RELEASE_REPO_DIR}/${RELEASES_BOARD_DIR}/${RELEASE_PREFIX}*
			echo "delete ${RELEASES_DIR}/${RELEASE_REPO_DIR}/${RELEASE_INDEX_JSON_FILENAME}"		
			rm -fr ${RELEASES_DIR}/${RELEASE_REPO_DIR}/${RELEASE_INDEX_JSON_FILENAME}
	        exit
   #      ;;               
   #      * )
			# usage
	  #       exit 1
    esac
    shift
done


# -------------------------------------------------------------------------------------------
#	if no argument specified
# -------------------------------------------------------------------------------------------

# echo "test"
check_config_exists "./${DEFAULT_CONFIG_FILE}"

# generate_tools_deps_template Digistump_SAM


cat << "asciiart"
                          (   (       )         
  *   )                   )\ ))\ ) ( /(  *   )  
` )  /(  (   (       (   (()/(()/( )\()` )  /(  
 ( )(_))))\ ))\ (    )\ ) /(_)/(_)((_)\ ( )(_)) 
(_(_())/((_/((_))\ )(()/((_))(_))   ((_(_(_())  
|_   _(_))(_)) _(_/( )(_)| _ |_ _| / _ |_   _|  
  | | / -_/ -_| ' \)| || |   /| | | (_) || |    
  |_| \___\___|_||_| \_, |_|_|___| \___/ |_|    
                     |__/                       

              < BUILD _ TOOLS >
*--------------------------------------------------*
|command - description                             |
|--------------------------------------------------|
|initpage - init release github page               |
|add      - add a new release                      |
|edit     - edit config file                       |
|build    - fetch remote repo and package board    |
|--------------------------------------------------|
|publish  - publish release to git pages           |
|--------------------------------------------------|
|info     - get list of release and board url      |
|list     - get list of release                    |
|--------------------------------------------------|
|pull     - sync build tools                       |
|push     - sync build tools                       |
*--------------------------------------------------*

asciiart


# echo $wew
#generate_tools_template
#make_packages

#generate_boards_template BOARD_LIST