[bash-notes.git] / notes.sh

#! /bin/bash

# set -ex

PID=$$
VERSION="0.1"

set_defaults() {
# Binaries to use
EDITOR=${EDITOR:-/usr/bin/vim}
TERMINAL=${TERMINAL:-/usr/bin/alacritty}
# add options for your terminal. Remember to add the last option to execute
# your editor program, otherwise the script will fail.
# see example in the addnote function
TERM_OPTS="--class notes --title notes -e "
JQ=${JQ:-/usr/bin/jq}

# base directory for program files
BASEDIR=${BASEDIR:-~/.local/share/bash-notes}
# notes database in json format
DB=${BASEDIR}/db.json
# directory containing the actual notes
NOTESDIR=${BASEDIR}/notes

} # end set_defaults, do not change this line.

set_defaults

# Do not edit below this point
RCFILE=${RCFILE:-~/.config/bash-notes.rc}
TMPDB=/tmp/db.json
BASENAME=$( basename $0 )
NOW=$(date +%s)

if [ ! -x $JQ ]; then
	echo "jq not found in your PATH"
	echo "install jq to continue"
	exit 1
fi

# IMPORT USER DEFINED OPTIONS IF ANY
if [[ -f $RCFILE ]]; then
	source $RCFILE
fi

# We prevent the program from running more than one instance:
PIDFILE=/var/tmp/$(basename $0 .sh).pid

# Make sure the PID file is removed when we kill the process
trap 'rm -f $PIDFILE; exit 1' TERM INT

if [[ -r $PIDFILE ]]; then
	# PIDFILE exists, so I guess there's already an instance running
	# let's kill it and run again
	kill -s 15 $(cat $PIDFILE) > /dev/null 2>&1
	# should already be deleted by trap, but just to be sure
	rm $PIDFILE
fi

# create PIDFILE
echo $PID > $PIDFILE

# check if input is a number, returns false or the number itself
function check_noteID() {
	IN=$1
	case $IN in
		''|*[!0-9]*)
			return 1
			;;
		*)
			echo $IN
			;;
	esac
}

function helptext() {
    echo "Usage:"
    echo "  $0 [PARAMS] ..."
    echo ""
	cat << __NOWCONF__ 
${BASENAME} configuration is:

base directory:		${BASEDIR}/
notes archive:		${NOTESDIR}/
notes database:		${DB}
rc file:		$RCFILE

text editor:		${EDITOR}
terminal:		${TERMINAL}
jq executable:		${JQ}
__NOWCONF__

	echo ""
    echo "${BASENAME} parameters are:"
    echo "  -h | --help			: This help text"
    echo "  -p | --plain			: Output is in plain text"
    echo "				  (without this option the output is formatted)"
    echo "				  (this option must precede all others)"
    echo "  -l | --list			: List existing notes"
    echo "  -a | --add [\"<title>\"]	: Add new note"
    echo "  -m | --modify [<note>] 	: Modify note"
    echo "  -d | --delete [<note> | all]	: Delete single note or all notes at once"
    echo "  -v | --version		: Print version"
    echo "  --userconf			: Export User config file"
    echo ""
}

function addnote() {
	# remove eventually existing temp DB file
	if [[ -f $TMPDB ]]; then
		rm $TMPDB
	fi

	NOTETITLE="$1"
	echo "adding new note - \"$NOTETITLE\""
	LASTID=$($JQ '.notes[-1].id // 0 | tonumber' $DB)
	# [ "" == $LASTID ] && LASTID=0
	NOTEID=$(( $LASTID + 1 ))
	touch ${NOTESDIR}/${NOW}
	$JQ --arg i "$NOTEID" --arg t "$NOTETITLE" --arg f "$NOW" '.notes += [{"id": $i, "title": $t, "file": $f}]' "$DB" > $TMPDB
	mv $TMPDB $DB
	# example for alacritty:
	# alacritty --class notes --title notes -e /usr/bin/vim ...
	$(${TERMINAL} ${TERM_OPTS} ${EDITOR} ${NOTESDIR}/${NOW})
}

function listnotes() {
	# [ $PLAIN == true ] && echo "output is plain text" || echo "output is colored"
	if [[ $(ls -A $NOTESDIR) ]]; then
		if [ $PLAIN == false ]; then
			echo "listing all notes"
			echo ""
		fi
		[ $PLAIN == false ] && echo "[ID]	[TITLE]		[CREATED]"
		for i in ${NOTESDIR}/*; do
			local fname=$(basename $i)
			DATE=$(date -d @${fname} +"%d/%m/%Y %R %z%Z")
			TITLE=$($JQ -r --arg z $(basename $i) '.notes[] | select(.file == $z) | .title' $DB)
			ID=$($JQ -r --arg z $(basename $i) '.notes[] | select(.file == $z) | .id' $DB)
			[ $PLAIN == false ] && echo "[${ID}]	${TITLE}	${DATE}" || echo "${ID} - ${TITLE} - ${DATE}"
		done
	else
		echo "no notes yet. You can add your first one with: ${BASENAME} -a \"your note title\""
	fi
}

function editnote() {
	NOTE=$1
	local OK=$(check_noteID $NOTE)
	if [ ! $OK ]; then
		echo "invalid note \"$NOTE\""
		exit 1
	fi

	TITLE=$($JQ --arg i $OK '.notes[] | select(.id == $i) | .title' $DB)
	FILE=$($JQ -r --arg i $OK '.notes[] | select(.id == $i) | .file' $DB)
	if [ "$TITLE" ]; then
		echo "editing note $TITLE"
		$(${TERMINAL} ${TERM_OPTS} ${EDITOR} ${NOTESDIR}/${FILE})
	else
		 echo "note not found"
		 exit 1
	fi
}

function rmnote() {
	# remove eventually existing temp DB file
	if [[ -f $TMPDB ]]; then
		rm $TMPDB
	fi

	NOTE=$1
	if [ "all" == $NOTE ]; then
		echo "You're going to delete all notes."
		read -r -p "Do you wish to continue? (y/N) " ANSWER
		case $ANSWER in
			y|Y )
				$JQ 'del(.notes[])' $DB > $TMPDB
				mv $TMPDB $DB
				rm $NOTESDIR/*
				echo "Deleted all notes"
				;;
			* )
				echo "Aborting, no notes were deleted."
				exit 1
				;;
		esac
	else
		local OK=$(check_noteID $NOTE)
		if [ ! $OK ]; then
			echo "invalid note \"$NOTE\""
			exit 1
		fi

		TITLE=$($JQ --arg i $OK '.notes[] | select(.id == $i) | .title' $DB)
		FILE=$($JQ -r --arg i $OK '.notes[] | select(.id == $i) | .file' $DB)
		if [ "$TITLE" ]; then
		$JQ -r --arg i $OK 'del(.notes[] | select(.id == $i))' $DB > $TMPDB
		mv $TMPDB $DB
		rm $NOTESDIR/$FILE
		echo "Deleted note $TITLE"
		else
			 echo "note not found"
			 exit 1
		fi
	fi
}

function export_config() {
	if [ -r ${RCFILE} ]; then
		echo "Backing up current '${RCFILE}'...."
		mv -f ${RCFILE} ${RCFILE}.$(date +%Y%m%d_%H%M)
	fi
	echo "Writing '${RCFILE}'...."
	sed  -n '/^set_defaults() {/,/^} # end set_defaults, do not change this line./p' $0 \
	| grep -v set_defaults \
	| sed -e 's/^\([^=]*\)=\${\1:-\([^}]*\)}/\1=\2/' \
	> ${RCFILE}
	if [ -r ${RCFILE} ]; then
		echo "Taking no further action."
		exit 0
	else
		echo "Could not write '${RCFILE}'...!"
		exit 1
	fi
}

# we should expand on this function to add a sample note and explain a little bit
# how the program works.
function firstrun() {
	[ -f $RCFILE ] && RC=$RCFILE || RC="none"

	clear
	echo "${BASENAME} configuration:

base directory:		${BASEDIR}/
notes archive:		${NOTESDIR}/
notes database:		${DB}
rc file:		$RC
text editor:		${EDITOR}
terminal:		${TERMINAL}
jq executable:		${JQ}
"

	read -r -p "Do you wish to continue? (y/N) " ANSWER
	case $ANSWER in
		y|Y )
			mkdir -p $NOTESDIR
			cat << __EOL__ > ${DB}
{
	"params": {
		"version": "${VERSION}",
		"dbversion": "${NOW}"
	},
	"notes": []
}
__EOL__
			echo; echo "All done, you can now write your first note."
			;;
		* )
			echo "No changes made. Exiting"
			exit
			;;
	esac
}

# check for notes dir existance and create it in case it doesn't exists
if [[ ! -d $NOTESDIR ]]; then
	# we don't have a directory. FIRST RUN?
	firstrun
fi

# NOTE: This requires GNU getopt.  On Mac OS X and FreeBSD, you have to install this
# separately; see below.
GOPT=`getopt -o hvpla:m:d: --long help,version,list,plain,userconf,add:,modify:,delete:,editor:,storage: \
             -n 'bash-notes' -- "$@"`

if [ $? != 0 ] ; then echo "Terminating..." >&2 ; exit 1 ; fi

# Note the quotes around `$GOPT': they are essential!
eval set -- "$GOPT"

PLAIN=false

while true; do
	case "$1" in
	  	-h | --help )
			helptext
	        exit
	        ;;
		-v | --version )
			echo $BASENAME v${VERSION}
			exit
			;;
	    -p | --plain )
			PLAIN=true
			shift
	        ;;
	    -l | --list )
			listnotes
			exit
	        ;;
	    -a | --add )
			TITLE="$2"
			shift 2
			addnote "$TITLE"
	        ;;
		-m | --modify )
			NOTE="$2"
			shift 2
			editnote "$NOTE"
			;;
		-d | --delete )
			NOTE="$2"
			shift 2
			rmnote "$NOTE"
			;;
		--userconf )
			export_config
			echo "config exported to \"$RCFILE\""
			exit
			;;
		-- )
			shift
			break
			;;
		* )
			break
			;;
	esac
done
Commit	Line	Data
	1	#! /bin/bash
	2
	3	# set -ex
	4
	5	PID=$$
	6	VERSION="0.1"
	7
	8	set_defaults() {
	9	# Binaries to use
	10	EDITOR=${EDITOR:-/usr/bin/vim}
	11	TERMINAL=${TERMINAL:-/usr/bin/alacritty}
	12	# add options for your terminal. Remember to add the last option to execute
	13	# your editor program, otherwise the script will fail.
	14	# see example in the addnote function
	15	TERM_OPTS="--class notes --title notes -e "
	16	JQ=${JQ:-/usr/bin/jq}
	17
	18	# base directory for program files
	19	BASEDIR=${BASEDIR:-~/.local/share/bash-notes}
	20	# notes database in json format
	21	DB=${BASEDIR}/db.json
	22	# directory containing the actual notes
	23	NOTESDIR=${BASEDIR}/notes
	24
	25	} # end set_defaults, do not change this line.
	26
	27	set_defaults
	28
	29	# Do not edit below this point
	30	RCFILE=${RCFILE:-~/.config/bash-notes.rc}
	31	TMPDB=/tmp/db.json
	32	BASENAME=$( basename $0 )
	33	NOW=$(date +%s)
	34
	35	if [ ! -x $JQ ]; then
	36	echo "jq not found in your PATH"
	37	echo "install jq to continue"
	38	exit 1
	39	fi
	40
	41	# IMPORT USER DEFINED OPTIONS IF ANY
	42	if [[ -f $RCFILE ]]; then
	43	source $RCFILE
	44	fi
	45
	46	# We prevent the program from running more than one instance:
	47	PIDFILE=/var/tmp/$(basename $0 .sh).pid
	48
	49	# Make sure the PID file is removed when we kill the process
	50	trap 'rm -f $PIDFILE; exit 1' TERM INT
	51
	52	if [[ -r $PIDFILE ]]; then
	53	# PIDFILE exists, so I guess there's already an instance running
	54	# let's kill it and run again
	55	kill -s 15 $(cat $PIDFILE) > /dev/null 2>&1
	56	# should already be deleted by trap, but just to be sure
	57	rm $PIDFILE
	58	fi
	59
	60	# create PIDFILE
	61	echo $PID > $PIDFILE
	62
	63	# check if input is a number, returns false or the number itself
	64	function check_noteID() {
	65	IN=$1
	66	case $IN in
	67	''\|[!0-9])
	68	return 1
	69	;;
	70	*)
	71	echo $IN
	72	;;
	73	esac
	74	}
	75
	76	function helptext() {
	77	echo "Usage:"
	78	echo " $0 [PARAMS] ..."
	79	echo ""
	80	cat << __NOWCONF__
	81	${BASENAME} configuration is:
	82
	83	base directory: ${BASEDIR}/
	84	notes archive: ${NOTESDIR}/
	85	notes database: ${DB}
	86	rc file: $RCFILE
	87
	88	text editor: ${EDITOR}
	89	terminal: ${TERMINAL}
	90	jq executable: ${JQ}
	91	__NOWCONF__
	92
	93	echo ""
	94	echo "${BASENAME} parameters are:"
	95	echo " -h \| --help : This help text"
	96	echo " -p \| --plain : Output is in plain text"
	97	echo " (without this option the output is formatted)"
	98	echo " (this option must precede all others)"
	99	echo " -l \| --list : List existing notes"
	100	echo " -a \| --add [\"<title>\"] : Add new note"
	101	echo " -m \| --modify [<note>] : Modify note"
	102	echo " -d \| --delete [<note> \| all] : Delete single note or all notes at once"
	103	echo " -v \| --version : Print version"
	104	echo " --userconf : Export User config file"
	105	echo ""
	106	}
	107
	108	function addnote() {
	109	# remove eventually existing temp DB file
	110	if [[ -f $TMPDB ]]; then
	111	rm $TMPDB
	112	fi
	113
	114	NOTETITLE="$1"
	115	echo "adding new note - \"$NOTETITLE\""
	116	LASTID=$($JQ '.notes[-1].id // 0 \| tonumber' $DB)
	117	# [ "" == $LASTID ] && LASTID=0
	118	NOTEID=$(( $LASTID + 1 ))
	119	touch ${NOTESDIR}/${NOW}
	120	$JQ --arg i "$NOTEID" --arg t "$NOTETITLE" --arg f "$NOW" '.notes += [{"id": $i, "title": $t, "file": $f}]' "$DB" > $TMPDB
	121	mv $TMPDB $DB
	122	# example for alacritty:
	123	# alacritty --class notes --title notes -e /usr/bin/vim ...
	124	$(${TERMINAL} ${TERM_OPTS} ${EDITOR} ${NOTESDIR}/${NOW})
	125	}
	126
	127	function listnotes() {
	128	# [ $PLAIN == true ] && echo "output is plain text" \|\| echo "output is colored"
	129	if [[ $(ls -A $NOTESDIR) ]]; then
	130	if [ $PLAIN == false ]; then
	131	echo "listing all notes"
	132	echo ""
	133	fi
	134	[ $PLAIN == false ] && echo "[ID] [TITLE] [CREATED]"
	135	for i in ${NOTESDIR}/*; do
	136	local fname=$(basename $i)
	137	DATE=$(date -d @${fname} +"%d/%m/%Y %R %z%Z")
	138	TITLE=$($JQ -r --arg z $(basename $i) '.notes[] \| select(.file == $z) \| .title' $DB)
	139	ID=$($JQ -r --arg z $(basename $i) '.notes[] \| select(.file == $z) \| .id' $DB)
	140	[ $PLAIN == false ] && echo "[${ID}] ${TITLE} ${DATE}" \|\| echo "${ID} - ${TITLE} - ${DATE}"
	141	done
	142	else
	143	echo "no notes yet. You can add your first one with: ${BASENAME} -a \"your note title\""
	144	fi
	145	}
	146
	147	function editnote() {
	148	NOTE=$1
	149	local OK=$(check_noteID $NOTE)
	150	if [ ! $OK ]; then
	151	echo "invalid note \"$NOTE\""
	152	exit 1
	153	fi
	154
	155	TITLE=$($JQ --arg i $OK '.notes[] \| select(.id == $i) \| .title' $DB)
	156	FILE=$($JQ -r --arg i $OK '.notes[] \| select(.id == $i) \| .file' $DB)
	157	if [ "$TITLE" ]; then
	158	echo "editing note $TITLE"
	159	$(${TERMINAL} ${TERM_OPTS} ${EDITOR} ${NOTESDIR}/${FILE})
	160	else
	161	echo "note not found"
	162	exit 1
	163	fi
	164	}
	165
	166	function rmnote() {
	167	# remove eventually existing temp DB file
	168	if [[ -f $TMPDB ]]; then
	169	rm $TMPDB
	170	fi
	171
	172	NOTE=$1
	173	if [ "all" == $NOTE ]; then
	174	echo "You're going to delete all notes."
	175	read -r -p "Do you wish to continue? (y/N) " ANSWER
	176	case $ANSWER in
	177	y\|Y )
	178	$JQ 'del(.notes[])' $DB > $TMPDB
	179	mv $TMPDB $DB
	180	rm $NOTESDIR/*
	181	echo "Deleted all notes"
	182	;;
	183	* )
	184	echo "Aborting, no notes were deleted."
	185	exit 1
	186	;;
	187	esac
	188	else
	189	local OK=$(check_noteID $NOTE)
	190	if [ ! $OK ]; then
	191	echo "invalid note \"$NOTE\""
	192	exit 1
	193	fi
	194
	195	TITLE=$($JQ --arg i $OK '.notes[] \| select(.id == $i) \| .title' $DB)
	196	FILE=$($JQ -r --arg i $OK '.notes[] \| select(.id == $i) \| .file' $DB)
	197	if [ "$TITLE" ]; then
	198	$JQ -r --arg i $OK 'del(.notes[] \| select(.id == $i))' $DB > $TMPDB
	199	mv $TMPDB $DB
	200	rm $NOTESDIR/$FILE
	201	echo "Deleted note $TITLE"
	202	else
	203	echo "note not found"
	204	exit 1
	205	fi
	206	fi
	207	}
	208
	209	function export_config() {
	210	if [ -r ${RCFILE} ]; then
	211	echo "Backing up current '${RCFILE}'...."
	212	mv -f ${RCFILE} ${RCFILE}.$(date +%Y%m%d_%H%M)
	213	fi
	214	echo "Writing '${RCFILE}'...."
	215	sed -n '/^set_defaults() {/,/^} # end set_defaults, do not change this line./p' $0 \
	216	\| grep -v set_defaults \
	217	\| sed -e 's/^\([^=]\)=\${\1:-\([^}]\)}/\1=\2/' \
	218	> ${RCFILE}
	219	if [ -r ${RCFILE} ]; then
	220	echo "Taking no further action."
	221	exit 0
	222	else
	223	echo "Could not write '${RCFILE}'...!"
	224	exit 1
	225	fi
	226	}
	227
	228	# we should expand on this function to add a sample note and explain a little bit
	229	# how the program works.
	230	function firstrun() {
	231	[ -f $RCFILE ] && RC=$RCFILE \|\| RC="none"
	232
	233	clear
	234	echo "${BASENAME} configuration:
	235
	236	base directory: ${BASEDIR}/
	237	notes archive: ${NOTESDIR}/
	238	notes database: ${DB}
	239	rc file: $RC
	240	text editor: ${EDITOR}
	241	terminal: ${TERMINAL}
	242	jq executable: ${JQ}
	243	"
	244
	245	read -r -p "Do you wish to continue? (y/N) " ANSWER
	246	case $ANSWER in
	247	y\|Y )
	248	mkdir -p $NOTESDIR
	249	cat << __EOL__ > ${DB}
	250	{
	251	"params": {
	252	"version": "${VERSION}",
	253	"dbversion": "${NOW}"
	254	},
	255	"notes": []
	256	}
	257	__EOL__
	258	echo; echo "All done, you can now write your first note."
	259	;;
	260	* )
	261	echo "No changes made. Exiting"
	262	exit
	263	;;
	264	esac
	265	}
	266
	267	# check for notes dir existance and create it in case it doesn't exists
	268	if [[ ! -d $NOTESDIR ]]; then
	269	# we don't have a directory. FIRST RUN?
	270	firstrun
	271	fi
	272
	273	# NOTE: This requires GNU getopt. On Mac OS X and FreeBSD, you have to install this
	274	# separately; see below.
	275	GOPT=`getopt -o hvpla:m:d: --long help,version,list,plain,userconf,add:,modify:,delete:,editor:,storage: \
	276	-n 'bash-notes' -- "$@"`
	277
	278	if [ $? != 0 ] ; then echo "Terminating..." >&2 ; exit 1 ; fi
	279
	280	# Note the quotes around `$GOPT': they are essential!
	281	eval set -- "$GOPT"
	282
	283	PLAIN=false
	284
	285	while true; do
	286	case "$1" in
	287	-h \| --help )
	288	helptext
	289	exit
	290	;;
	291	-v \| --version )
	292	echo $BASENAME v${VERSION}
	293	exit
	294	;;
	295	-p \| --plain )
	296	PLAIN=true
	297	shift
	298	;;
	299	-l \| --list )
	300	listnotes
	301	exit
	302	;;
	303	-a \| --add )
	304	TITLE="$2"
	305	shift 2
	306	addnote "$TITLE"
	307	;;
	308	-m \| --modify )
	309	NOTE="$2"
	310	shift 2
	311	editnote "$NOTE"
	312	;;
	313	-d \| --delete )
	314	NOTE="$2"
	315	shift 2
	316	rmnote "$NOTE"
	317	;;
	318	--userconf )
	319	export_config
	320	echo "config exported to \"$RCFILE\""
	321	exit
	322	;;
	323	-- )
	324	shift
	325	break
	326	;;
	327	* )
	328	break
	329	;;
	330	esac
	331	done
	332