boofnet
1590 lines
62 KiB
Go
1590 lines
62 KiB
Go
// =============================================================================
|
|
// Auth: Alex Celani
|
|
// File: tdm.go
|
|
// Revn: 03-29-2022 3.0
|
|
//
|
|
// Func: display and manage progress of a litany of items to be done,
|
|
// with an organization scheme similar to Trello. It's CLI
|
|
// Trello
|
|
//
|
|
// TODO: add debug statements
|
|
//
|
|
// fix issue where fileIn() breaks on empty board
|
|
// add second object to hold command information
|
|
// make subsubtasks for greater depth
|
|
// M or rooms to contain boards
|
|
// handle command line args
|
|
// auto-update task fill based on subtask fills and (settable)
|
|
// weighting
|
|
// M remember last args
|
|
// move most (read: all) helper functions to external files
|
|
// M add priority to tasks
|
|
// attach text files???
|
|
// fix data storage issue
|
|
// contemplate adding XOR of data in file, altho who cares
|
|
// contemplate adding battery of tests
|
|
// contemplate moving functions to external file
|
|
// side-by-side printing
|
|
// colored printing?
|
|
// keep track of finished items
|
|
// periodic tasks? something to do with the time package
|
|
// convert file delimiters to (customizable?) variables
|
|
// do some more legit testing
|
|
// =============================================================================
|
|
// JUMP TAGS
|
|
// for the lucky few who use vim, press * on a tag to jump to that function
|
|
// CATCH INPUT JOIN FILEIN FILEOUT HELP DELETE FIND СДЕЛАЙ MARK PARSE SHOW MAIN
|
|
// =============================================================================
|
|
// CHANGE LOG
|
|
// -----------------------------------------------------------------------------
|
|
// 10-04-2021: init
|
|
// wrote bones of string parsing into data structure
|
|
// 10-05-2021: commented
|
|
// 10-06-2021: entirely rewrote text format and text processor
|
|
// 10-09-2021: added reading from file
|
|
// wrote bones to while loop
|
|
// created empty functions for commands
|
|
// wrote, but did not test, getting user input
|
|
// 10-10-2021: fixed user input
|
|
// wrote help()
|
|
// wrote second draft of show(), fix immediately
|
|
// 02-21-2022: gutted main loop
|
|
// standardized method to pass commands to subfunctions
|
|
// commented main()
|
|
// 02-22-2022: made help() change log and comment block
|
|
// commented help()
|
|
// added XXX tags to "if flag {" statements
|
|
// added searchable structure to ease defining searches
|
|
// with multiple different types of function calls
|
|
// began restructuring show() to focus on sanitizing
|
|
// inputs before show() gets called
|
|
// 02-23-2022: changed searchable to query
|
|
// 02-24-2022: reduced scope of sanitize() to work with a more rigid
|
|
// set of inputs, just to get a stable release
|
|
// finished sanitize()
|
|
// tested sanitize()
|
|
// commented sanitize()
|
|
// wrote the /all/ portion of show()
|
|
// 02-25-2022: wrote rest of show()
|
|
// rewrote /show/ portion of help()
|
|
// connected sanitize() to show(), added show() to main()
|
|
// 02-27-2022: commented /all/ portion of show()
|
|
// 03-01-2022: planning for find() and delete()
|
|
// wrote and tested find(), checks out
|
|
// changed delete() to del() to avoid overloading builtin
|
|
// wrote and tested first draft of del()
|
|
// 03-02-2022: commented /board/, /task/, and /subtask/ portions of
|
|
// show()
|
|
// wrote mark()
|
|
// made show() accept commands of len greater than 3
|
|
// commented first draft of mark()
|
|
// 03-03-2022: commented first draft of find()
|
|
// commented del()
|
|
// 03-04-2022: improved error condition in mark()
|
|
// 03-06-2022: wrote first draft of parse() to replace sanitize()
|
|
// 03-07-2022: wrote first draft of сделай()
|
|
// 03-08-2022: tested следай()
|
|
// wrote and tested fileOut()
|
|
// watched Taylor Tomlinson's Look At You
|
|
// updated fileIn() to work with files that don't exist
|
|
// updated work functions to take queries instead of
|
|
// []strings
|
|
// 03-09-2022: updated function comment blocks
|
|
// 03-10-2022: commented fileOut()
|
|
// began commenting parse()
|
|
// began updating help()
|
|
//*03-11-2022: updated help()
|
|
// commented /move/ and /mark/ of parse()
|
|
// super fixed subtask propogation bug in fileIn()
|
|
// 03-12-2022: rewrote /delete/, /show/, and /mark/
|
|
// 03-13-2022: added missing call to lower() in input()
|
|
// rewrote /make/
|
|
// began testing /delete/
|
|
// 03-14-2022: finished testing /delete/
|
|
// tested /show/, /mark/, and /make/
|
|
// 03-15-2022: integrated parse.go as parse()
|
|
// added jump tags :)
|
|
// commented parse()
|
|
// 03-20-2022: first draft rewrite of find()
|
|
//*03-27-2022: fixed bug where tasks can't be made under boards with
|
|
// name of length 1
|
|
//*03-29-2022: added, tested, and commented function for catching
|
|
// keyboard interrupts
|
|
//
|
|
// =============================================================================
|
|
|
|
|
|
package main
|
|
|
|
import (
|
|
"fmt" // used for Println
|
|
"strings" // used for Split, ToLower, Join
|
|
"strconv" // used for Atoi
|
|
"os" // used for Exit, Stdin
|
|
"os/signal" // used for Notify
|
|
"syscall" // used for SIGTERM
|
|
"io/ioutil" // used for ReadFile, WriteFile
|
|
"bufio" // used for NewScanner
|
|
)
|
|
|
|
|
|
// aliases for common functions
|
|
var p = fmt.Print
|
|
var print = fmt.Println
|
|
var printf = fmt.Printf
|
|
var split = strings.Split
|
|
var lower = strings.ToLower
|
|
var atoi = strconv.Atoi
|
|
var itoa = strconv.Itoa
|
|
var exit = os.Exit
|
|
var read = ioutil.ReadFile
|
|
var write = ioutil.WriteFile
|
|
|
|
|
|
// CATCH finally something fun
|
|
// asynchronous function that catches keyboard interrupts and exits
|
|
// gracefully
|
|
func catch() {
|
|
// blocking channel of type signal
|
|
c := make( chan os.Signal )
|
|
|
|
// I didn't read what this does, but it was in an example and it
|
|
// worked, so
|
|
// from what I can ascertain, when SIGTERM is detected, it binds
|
|
// Interrupt to channel c
|
|
signal.Notify( c, os.Interrupt, syscall.SIGTERM )
|
|
|
|
// asynchronous goroutine
|
|
go func() {
|
|
<-c // immediately halts in blocking read for signal
|
|
|
|
if changed { // if there was a change to the map...
|
|
fileOut() // rewrite data file
|
|
}
|
|
|
|
print( "\r" ) // this helps with the missing newline
|
|
|
|
exit( 0 ) // and exit gracefully
|
|
}()
|
|
}
|
|
|
|
|
|
// INPUT
|
|
// wrapper function to print input prompt, take user input
|
|
func input( ps1 string ) string {
|
|
p( ps1 ) // print prompt
|
|
// create scanner on stdin
|
|
scanner := bufio.NewScanner( os.Stdin )
|
|
scanner.Scan() // read input
|
|
return lower( scanner.Text() ) // return text
|
|
}
|
|
|
|
|
|
// JOIN
|
|
// quick function to join an array of strings, with delimiting spaces
|
|
func join( subcommands []string ) string {
|
|
|
|
var ret string // declare returnable string
|
|
|
|
// iterate over contained strings inside array
|
|
for _, word := range subcommands {
|
|
// add word and delimiting space to returnable
|
|
ret = ret + word + " "
|
|
}
|
|
|
|
// return everything but last character, a trailing space
|
|
return ret[:len( ret ) - 1]
|
|
|
|
}
|
|
|
|
|
|
// FILEOUT
|
|
// wrapper function to contain all the file writing
|
|
func fileOut() {
|
|
|
|
// initialize data to be written as empty string
|
|
var data string = ""
|
|
// keep track of how many boards have been written, so the
|
|
// delimiter isn't written after the last board
|
|
var boardCount int = 0
|
|
|
|
// iterate over all boards
|
|
for bname, bcontents := range boards {
|
|
|
|
// increment number of boards written
|
|
// actually caused a medium bug, because it's incremented
|
|
// before the check against len(), so if != len() - 1 placed
|
|
// delimiters in the wrong places
|
|
boardCount++
|
|
|
|
data = data + bname // add board name to writestring
|
|
data = data + "|" // XXX task delimiter
|
|
|
|
// iterate over tasks
|
|
for tind, tcontents := range bcontents {
|
|
data = data + tcontents.name // add task name
|
|
data = data + "," // XXX task delimiter
|
|
|
|
// convert fill back to ascii
|
|
// no error, because I guess all ints can be converted to
|
|
// ascii, but not all ascii can be an int?
|
|
// TODO think about keeping fill as ascii
|
|
// maybe check the conversion to see if it worked (i.e.
|
|
// user entered a number), but the ints are never
|
|
// _actually_ used
|
|
fill := itoa( tcontents.fill )
|
|
|
|
data = data + fill // add task fill
|
|
// does the task contain subtasks?
|
|
if len( tcontents.subt ) != 0 {
|
|
// XXX task's subtask delimiter
|
|
data = data + ":"
|
|
// iterate over a task's subtasks
|
|
for sind, scontents := range tcontents.subt {
|
|
// add subtask name
|
|
|
|
// XXX
|
|
if flag { // if debug set, print incoming
|
|
// subtask and data before...
|
|
print( "subt.name: ", scontents.name )
|
|
print( "pre data: ", data )
|
|
}
|
|
|
|
|
|
data = data + scontents.name
|
|
|
|
// XXX
|
|
if flag { // and after
|
|
print( "post data: ", data )
|
|
}
|
|
|
|
data = data + ">" // XXX subtask fill delim
|
|
|
|
// convert fill back to ascii
|
|
// TODO as above
|
|
fill = itoa( scontents.fill )
|
|
|
|
data = data + fill // add subtask fill
|
|
|
|
// check if NOT last subtask
|
|
if sind != len( tcontents.subt ) - 1 {
|
|
data = data + "." // XXX subtask delimiter
|
|
}
|
|
}
|
|
}
|
|
// check if NOT last task
|
|
if tind != len( bcontents ) - 1 {
|
|
data = data + ";" // XXX task delimiter
|
|
}
|
|
}
|
|
// check if NOT last board
|
|
// slightly different than before, explained above
|
|
if boardCount != len( boards ) {
|
|
data = data + "$" // XXX board delimiter
|
|
}
|
|
}
|
|
|
|
// cast writestring to byte array, write to file named "data"
|
|
// if a file doesn't exist, make with 0x644 permissions
|
|
// take error as err, if fails
|
|
err := write( "data", []byte( data ), 0644 )
|
|
|
|
if flag { // if debug set, print data written
|
|
print( data )
|
|
}
|
|
|
|
if err != nil { // if write() failed, tell user
|
|
print( "Error in fileOut(): file not properly written" )
|
|
print( err )
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// FILEIN
|
|
// warpper function to contain all the file reading
|
|
func fileIn() {
|
|
|
|
// test string to use in lieu of a file
|
|
// file :=
|
|
// "b1|tA,:sI>30.sII>30;tB,25;tC,40$b2|tA,5;tB,"
|
|
// b1|tA,:sI>30.sII>30;tB,25;tC,40 ~ first board
|
|
// $ ~ board delimiter
|
|
// b2|tA,5;tB, ~ second board
|
|
// b1 b2 ~ board names
|
|
// |tA,:sI>30.sII>30;tB,25;tC,40 |tA,5;tB, ~ board contents
|
|
// | | ~ task marker
|
|
// ta tB tC tA tB ~ task names
|
|
// ; ; ; ~ task delimiter
|
|
// ,:sI>30.sII>30 ,25 ,40 ,5 , ~ task contents
|
|
// , ,25 ,40 ,5 , ~ task fill
|
|
// , , , , , ~ task fill delim
|
|
// :sI>30.sII>30 ~ task subtasks
|
|
// : ~ subtask marker
|
|
// sI sII ~ subtask names
|
|
// . ~ subtask delim
|
|
// >30 >30 ~ subtask fill
|
|
// > > ~ subtask fill delim
|
|
|
|
file, err := read( "data" ) // open file, failure set err
|
|
|
|
// declare board, because if statement gets mad if I don't
|
|
var board []string
|
|
|
|
// XXX
|
|
if flag { // if debug set, print raw file
|
|
print( "file: ", string( file ) )
|
|
}
|
|
|
|
// no file -> stop trying to build object, let boards be empty
|
|
if err != nil {
|
|
// notify user and leave
|
|
print( "No file found" )
|
|
return
|
|
} else { // if there is a file...
|
|
// $ -> separates different boards
|
|
board = split( string( file ), "$" )
|
|
}
|
|
|
|
// iterate over all boards
|
|
for a := 0; a < len( board ); a++ {
|
|
// split board by name and tasks
|
|
bContents := split( board[a], "|" )
|
|
bName := bContents[0] // assign name of board to var
|
|
bTasks := bContents[1] // assign tasks of board to var
|
|
|
|
// XXX
|
|
if flag { // if debug set, print board name
|
|
print( "board name -> ", bName )
|
|
}
|
|
|
|
// separate tasks from each other
|
|
tTasks := split( bTasks, ";" )
|
|
var tk task // make empty task
|
|
|
|
// iterate over all tasks
|
|
for b := 0; b < len( tTasks ); b++ {
|
|
|
|
// XXX
|
|
if flag { // if debug set, print raw tasks
|
|
print( "tTasks -> ", tTasks[b] )
|
|
}
|
|
|
|
// split subtasks out of tasks
|
|
subs := split( tTasks[b], ":" )
|
|
// len is not one, there are subtasks
|
|
// i.e. no reason to process subtasks
|
|
if len( subs ) != 1 {
|
|
// split list of subtasks
|
|
sTasks := split( subs[1], "." )
|
|
// iterate over subtasks
|
|
for c := 0; c < len( sTasks ); c++ {
|
|
// split subtasks name from fill
|
|
sContents := split( sTasks[c], ">" )
|
|
// convert fill from string to int, discard err
|
|
fil, _ := atoi( sContents[1] )
|
|
// create subtask object with this extracted info
|
|
stk := subtask { name: sContents[0], fill: fil }
|
|
// add subtask object to array of such
|
|
subtasks = append( subtasks, stk )
|
|
}
|
|
// add full subtask array to task object
|
|
tk.subt = subtasks
|
|
}
|
|
// separate task from fill
|
|
tContents := split( tTasks[b], "," )
|
|
// if there is no fill, interpret this as 0 fill
|
|
if len( tContents[1] ) == 0 {
|
|
// inferred fill is a string, so it can be processed
|
|
// like all the other fills
|
|
tContents[1] = "0"
|
|
}
|
|
tk.name = tContents[0] // set name of task
|
|
fil, _ := atoi( tContents[1] ) // convert fill to int
|
|
tk.fill = fil // set fill of task
|
|
tasks = append( tasks, tk ) // add task to task array
|
|
|
|
// XXX
|
|
if flag { // if debug set, print array of tasks
|
|
print( "[]task -> ", tasks )
|
|
}
|
|
|
|
// these lines are so stupid
|
|
tk.subt = nil
|
|
subtasks = nil
|
|
// if tk.subt is not set to nil, then the same array would
|
|
// go to every other task subtask array that follows
|
|
}
|
|
|
|
// make a key/value pair out of the board name and task array
|
|
// add it to hashmap
|
|
boards[bName] = tasks
|
|
tasks = nil // nil out task array, same reason with subt
|
|
}
|
|
|
|
// XXX
|
|
if flag { // if debug set, print entire structure
|
|
print( "\n\nboards -> ", boards, "\n\n" )
|
|
}
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// HELP( commands []string )
|
|
//
|
|
// Revn: 03-10-2022
|
|
// Args: commands - array of strings
|
|
// list of commands, should begin with "help" here
|
|
// any subcommands would specify with which
|
|
// commands that help is needed
|
|
// Func: Prints help messages to the user. If the user requests help about
|
|
// a specific topic, function will print only that topic, otherwise
|
|
// print everything
|
|
// TODO: FIXME rewrite
|
|
// add /about/ subcommand
|
|
//
|
|
// add fail response? change structure to a switch/case
|
|
// check that commands[0] is actualy "help"
|
|
// make more targeted help prompts for when help has args
|
|
// -----------------------------------------------------------------------------
|
|
// CHANGE LOG
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
// ??-??-????: wrote bones to
|
|
// 02-22-2022: made change log
|
|
// commented
|
|
// 02-25-2022: rewrote /show/ to reflect new scope
|
|
// 03-10-2022: rewrote /delete/ to reflect new scope
|
|
// removed /move/ and /choose/ portions, because those
|
|
// commands were removed
|
|
//
|
|
// -----------------------------------------------------------------------------
|
|
func help( commands []string ) {
|
|
|
|
|
|
var helpFlag bool = true // init flag to view all
|
|
var c string // init var for command[1]
|
|
|
|
if len( commands ) > 1 { // check for plural commands
|
|
|
|
c = commands[1] // capture first command
|
|
// recall that commands[0] is the word "help"
|
|
|
|
// set flag to see every entry on user request
|
|
helpFlag = c == "all" || c == ""
|
|
}
|
|
|
|
// XXX
|
|
if flag { // if debug set, print commands[0] and helpFlag
|
|
print( "\n\nc ->", c )
|
|
print( "helpFlag ->", helpFlag )
|
|
print( "\n" )
|
|
|
|
}
|
|
|
|
print() // print extra line to avoid cluttered look
|
|
|
|
// help text really should speak for itself
|
|
// important things to note: helpFlag is set true by default
|
|
// helpFlag is set false if user asks for specific entry
|
|
// c is set to the specific entry
|
|
// if the specific entry is not present, nothing is printed
|
|
// this really should be changed to a switch/case tbh
|
|
if helpFlag || c == "delete" {
|
|
print( " delete [board] <b>" )
|
|
print( " \\-- delete board <b>" )
|
|
print( " \\ [board|task|subtask] <b|t|s>" )
|
|
print( " \\-- delete board <b>, task <t>, or subtask <s>, provided argument exists " )
|
|
}
|
|
if helpFlag || c == "make" {
|
|
print( " make [board] <b>" )
|
|
print( " \\-- create new board, <b>" )
|
|
print( " \\ [board] <b> task <t>" )
|
|
print( " \\-- create new task <t> under board <b>" )
|
|
print( " \\ task <t> subtask <s>" )
|
|
print( " \\-- create new subtask <s> under task <t>" )
|
|
}
|
|
if helpFlag || c == "mark" {
|
|
print( " mark task <t> <fill>" )
|
|
print( " \\ \\-- fill -> 0 - 100" )
|
|
print( " \\-- set progress of <t> to <fill>" )
|
|
print( " mark subtask <s> <fill>" )
|
|
print( " \\ \\-- fill -> 0 - 100" )
|
|
print( " \\-- set progress of <s> to <fill>" )
|
|
}
|
|
if helpFlag || c == "show" {
|
|
print( " show [all]" )
|
|
print( " \\-- display everything" )
|
|
print( " show [board] <b>" )
|
|
print( " \\-- display contents of board <b>" )
|
|
print( " show task <t>" )
|
|
print( " \\-- display contents of task <t>" )
|
|
print( " show subtask <s>" )
|
|
print( " \\-- display contents of subtask <s>" )
|
|
}
|
|
if helpFlag || c == "exit" || c == "quit" {
|
|
print( " exit" )
|
|
print( " quit" )
|
|
print( " \\-- exit program" )
|
|
}
|
|
|
|
print() // print extra line to avoid cluttered look
|
|
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// DELETE( search query )
|
|
//
|
|
// Revn: 03-15-2022
|
|
// Args: search - query
|
|
// object that summarizes what needs deleting
|
|
// Func: delete entries
|
|
// Meth: call find() to get position of wanted entry, replace with
|
|
// last item in list, replace list with [:len()-1] slice
|
|
// TODO:
|
|
// -----------------------------------------------------------------------------
|
|
// CHANGE LOG
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
// 03-01-2022: major planning for deleting functionality
|
|
// plans for moving search functionality to new find()
|
|
// function
|
|
// wrote bones, not working
|
|
// 03-03-2022: commented
|
|
// 03-08-2022: changed arguments from commands []string to search query
|
|
// 03-15-2022: added quick check for search.comm = fail
|
|
//
|
|
// -----------------------------------------------------------------------------
|
|
func del( search query ) {
|
|
|
|
// determine what needs searching
|
|
|
|
// check to see if query returned empty
|
|
// not entirely sure if that's possible, but check for it
|
|
if search == ( query{} ) {
|
|
return
|
|
}
|
|
|
|
// if fail is set, quit
|
|
if search.command == "fail" {
|
|
return
|
|
}
|
|
|
|
// determine "coordinates" of object that needs finding
|
|
// x -> ( string ) name of board, shouldn't ever be blank
|
|
// y -> ( int ) index of task array for a given board
|
|
// z -> ( int ) index of subtask array for a given task
|
|
x, y, z := find( search )
|
|
|
|
if x != "" { // should be a given
|
|
changed = true
|
|
if y == -1 { // not task, should be board
|
|
// maps have easy delete function
|
|
// delete, from map 'boards', key 'x'
|
|
delete( boards, x )
|
|
} else { // yes task
|
|
if z == -1 { // not subtask, should be task
|
|
// XXX it really needs to be mentioned that everything
|
|
// here has to be referenced absolutely, because if you
|
|
// make some other variable about it, like
|
|
// b := boards[x][y]
|
|
// when you go to reassign the array, it won't get rid of
|
|
// the last task, of which there are now two
|
|
|
|
// boards -> map[string][]task
|
|
// boards[x] -> []task
|
|
// boards[x][y] -> task
|
|
|
|
// int len( boards[x] ) - 1
|
|
// task boards[x][len( boards[x] ) - 1]
|
|
// take task at the end of the array, place it over
|
|
// unwanted task
|
|
boards[x][y] = boards[x][len( boards[x] ) - 1]
|
|
// take slice of everything but the last task (
|
|
// because there's two of them in the array ), assign
|
|
// it to array to replace array with two copies
|
|
boards[x] = boards[x][:len( boards[x] ) - 1]
|
|
} else { // yes subtask
|
|
// oh boy
|
|
// boards -> map[string][]task
|
|
// boards[x] -> []task
|
|
// boards[x][y] -> task
|
|
// boards[x][y].subt -> []subtask
|
|
// boards[x][y].subt[z] -> subtask
|
|
|
|
// int len( boards[x][y].subt ) - 1
|
|
// subtask boards[x][y].subt[len( boards[x][y].subt ) - 1]
|
|
// take subtask at the end of the array, place it over
|
|
// unwanted subtask
|
|
boards[x][y].subt[z] = boards[x][y].subt[len(
|
|
boards[x][y].subt ) - 1]
|
|
// take slice of everything but the last subtask (
|
|
// because there's two of them in the array ), assign
|
|
// it to array to replace array with two copies
|
|
boards[x][y].subt = boards[x][y].subt[:len( boards[x][y].subt ) - 1]
|
|
}
|
|
}
|
|
} else { // should be unreachable
|
|
print( "Error in delete(): object does not exist or not specified" )
|
|
}
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// FIND( search query ) ( string, int, int )
|
|
//
|
|
// Revn: 03-27-2022
|
|
// Args: search - query
|
|
// object that outlines what needs finding
|
|
// Retn: x, y, z - string, int, int
|
|
// "coordinates" that outline where sought-after
|
|
// objects are
|
|
// Func: iterate over all everything until exact positions of
|
|
// sought-after object is found
|
|
// TODO: error messages
|
|
// make returnables into struct ( "coords"? )
|
|
// -----------------------------------------------------------------------------
|
|
// CHANGE LOG
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
// 03-01-2022: essentially stole from show()
|
|
// 03-03-2022: commented
|
|
// 03-20-2022: rewrote for updated query definition
|
|
// 03-27-2022: commented
|
|
//
|
|
// -----------------------------------------------------------------------------
|
|
func find( search query ) ( string, int, int ) {
|
|
|
|
var rboard string // init string as empty
|
|
var rtask int = -1 // init ints as -1, the forbidden index
|
|
var rsubt int = -1
|
|
|
|
|
|
// look at subcommand A specifically
|
|
switch search.subA {
|
|
case "board":
|
|
// prs is true if search.board is in boards
|
|
_, prs := boards[search.board]
|
|
if prs { // if prs _is_ true, keep track of that board
|
|
rboard = search.board
|
|
}
|
|
case "task":
|
|
// iterate over boards in boards
|
|
// board -> names of boards ( key in map )
|
|
// contents -> []task ( value in map )
|
|
for board, contents := range boards {
|
|
// iterate through task array
|
|
// ind -> index
|
|
// task -> actual task object
|
|
for ind, task := range contents {
|
|
// if name of found task is requested task name
|
|
if task.name == search.task {
|
|
// keep track of board and index
|
|
rboard = board
|
|
rtask = ind
|
|
}
|
|
}
|
|
}
|
|
case "subtask":
|
|
// iterate over boards in boards
|
|
// board -> names of boards ( key in map )
|
|
// contents -> []task ( value in map )
|
|
for board, contents := range boards {
|
|
// iterate through task array
|
|
// tind -> task index
|
|
// task -> actual task object
|
|
for tind, task := range contents {
|
|
// iterate through subtask array
|
|
// sind -> subtask index
|
|
// subtask -> actual subtask object
|
|
for sind, subtask := range task.subt {
|
|
// if name of found subtask is requested
|
|
// subtask name
|
|
if subtask.name == search.subtask {
|
|
// keep track of board, task index, and
|
|
// subtask index
|
|
rboard = board
|
|
rtask = tind
|
|
rsubt = sind
|
|
}
|
|
}
|
|
}
|
|
}
|
|
default:
|
|
// if the subcommand A is not a known object, error out
|
|
// I'm like 90% sure that this is unreachable, but
|
|
// whatever
|
|
print( "Error in find()" )
|
|
print( "Object /", search.subA, "/ not recognized" )
|
|
}
|
|
|
|
// return returnable 3-tuple
|
|
return rboard, rtask, rsubt
|
|
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// СДЕЛАЙ( search query )
|
|
//
|
|
// Revn: 03-27-2022
|
|
// Args: search - query
|
|
// object that summarizes what needs making
|
|
// Func: create new boards, tasks, and subtasks
|
|
// Meth: find parent object, create new child object, attach
|
|
// TODO: add debug
|
|
// -----------------------------------------------------------------------------
|
|
// CHANGE LOG
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
// 03-07-2022: wrote first draft
|
|
// 03-10-2022: commented
|
|
// 03-16-2022: rewrote to work with updated query{} definition
|
|
// 03-27-2022: added check for command == "fail"
|
|
//
|
|
// -----------------------------------------------------------------------------
|
|
func сделай( search query ) {
|
|
|
|
if flag { // if debug set, print contents of argument
|
|
print( search )
|
|
}
|
|
|
|
// if fail is set, quit
|
|
if search.command == "fail" {
|
|
return
|
|
}
|
|
|
|
// init variable to mark if parent object exists
|
|
var exists bool = false
|
|
// declare variable to determine what caused error
|
|
var err string
|
|
|
|
if search.subtask == "" { // if subtask not specified
|
|
if search.task == "" { // if task not specified
|
|
if search.board == "" { // if board also not specified
|
|
// failure, make called without argument
|
|
// print error, call help about it
|
|
print( "Error in make()" )
|
|
print( "No object specified" )
|
|
makeFailure := []string{ "help", "make" }
|
|
help( makeFailure )
|
|
return
|
|
} else { // yes board
|
|
exists = true // signal that parent did exist
|
|
// declare empty task array
|
|
var t []task
|
|
// map board name to empty task array
|
|
boards[search.board] = t
|
|
changed = true // signal that file needs rewriting
|
|
}
|
|
} else { // yes task
|
|
if search.board == "" { // if no parent board
|
|
err = "board"
|
|
// failure, called to make a task belonging to no
|
|
// board
|
|
// print error, call help about it
|
|
print( "Error in make()" )
|
|
print( "Cannot make task without specifying board" )
|
|
makeFailure := []string{ "help", "make" }
|
|
help( makeFailure )
|
|
return
|
|
} else { // board is specified
|
|
exists = true // signal parent did exist
|
|
// create task with user-given name
|
|
tk := task{ name: search.task }
|
|
// grab []task that given board maps to
|
|
// i literally don't want to type search.board out two
|
|
// more times, v clunky and causes line overrun
|
|
preTask := boards[search.board]
|
|
if len( preTask ) == 0 { // if empty
|
|
// declare empty task array
|
|
var t []task
|
|
t = append( t, tk ) // place inside array
|
|
// map task array to new board
|
|
boards[search.board] = t
|
|
} else { // array not empty
|
|
// simply append to pre-existing task array
|
|
boards[search.board] = append( preTask, tk )
|
|
}
|
|
changed = true // signal file needs rewriting
|
|
}
|
|
}
|
|
} else { // subtask specified
|
|
if search.task == "" { // no task tho
|
|
err = "task"
|
|
// failure, called to make subtask with a parent task
|
|
// print error, call help about it
|
|
print( "Error in make()" )
|
|
print( "Cannot make subtask with specifying task" )
|
|
makeFailure := []string{ "help", "make" }
|
|
help( makeFailure )
|
|
return
|
|
} else { // yes task
|
|
// iterate over boards to look for requested task
|
|
for bname, bcontents := range boards {
|
|
// iterate over tasks in boards
|
|
for ind, t := range bcontents {
|
|
// if task name is given parent task name
|
|
if t.name == search.task {
|
|
exists = true // signal parent exists
|
|
// create subtask with user-given name
|
|
stk := subtask{ name: search.subtask }
|
|
// if task's subtask array is empty
|
|
if len( t.subt ) == 0 {
|
|
// declare empty subtask array
|
|
var s []subtask
|
|
// place created subtask inside array
|
|
s = append( s, stk )
|
|
// map subtask array to task
|
|
boards[bname][ind].subt = s
|
|
} else { // array not empty
|
|
// simply append to pre-existing subtask
|
|
// array
|
|
boards[bname][ind].subt = append( t.subt, stk )
|
|
}
|
|
// signal file needs rewriting
|
|
changed = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if !exists { // nothing was changed, because parent object
|
|
// doesn't exist
|
|
// print error, call help about it
|
|
print( "Error in make()" )
|
|
p( "Parent ", err )
|
|
if err == "board" {
|
|
p( " /", search.board, "/ " )
|
|
} else if err == "task" {
|
|
p( " /", search.task, "/ " )
|
|
} else {
|
|
p( " object " )
|
|
}
|
|
print( "does not exist" )
|
|
makeFailure := []string{ "help", "make" }
|
|
help( makeFailure )
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// MARK( search query )
|
|
//
|
|
// Revn: 03-17-2022
|
|
// Args: search - query
|
|
// object that summarizes what needs showing
|
|
// Func: allow user to complete tasks
|
|
// Meth: call to find() to get "coords", set object at those coords
|
|
// to fill
|
|
// TODO:
|
|
// -----------------------------------------------------------------------------
|
|
// CHANGE LOG
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
// 03-02-2022: planned and wrote first draft, needs much error
|
|
// checking
|
|
// commented first draft
|
|
// 03-04-2022: made error condition show more information
|
|
// 03-09-2022: fixed error condition bug where program didn't know
|
|
// what kind of object user and printed hanging slash
|
|
// 03-11-2022: added reference to variable 'change', so fileOut()
|
|
// will run
|
|
// 03-17-2022: added references to updated definition of a query
|
|
//
|
|
// -----------------------------------------------------------------------------
|
|
func mark( search query ) {
|
|
|
|
// check to see if query returned empty
|
|
// not entirely sure if that's possible, but check for it
|
|
if search == ( query{} ) {
|
|
return
|
|
}
|
|
|
|
// if parse() failed, simply return
|
|
// probably print failure too?
|
|
if search.command == "fail" {
|
|
return
|
|
}
|
|
|
|
// determine "coordinates" of object that needs finding
|
|
// x -> ( string ) name of board, shouldn't ever be blank
|
|
// y -> ( int ) index of task array for a given board
|
|
// z -> ( int ) index of subtask array for a given task
|
|
x, y, z := find( search )
|
|
|
|
// index of last item len( commands ) - 1
|
|
// last item in array commands[len( commands ) - 1]
|
|
// convert string to int
|
|
// atoi( commands[len( commands ) - 1] )
|
|
// markFill -> converted value
|
|
// err -> contains value of atoi() error
|
|
// would happen if passed value isn't ascii
|
|
markFill, err := atoi( search.subB )
|
|
|
|
// on error, print failure, call help about it, return
|
|
if err != nil {
|
|
print( "Fill value /" + search.subB + "/ is not a number" )
|
|
markFailure := []string{ "help", "mark" }
|
|
help( markFailure )
|
|
return
|
|
}
|
|
|
|
// round fill down to 100 max, specifically allow negative fill
|
|
if markFill > 100 {
|
|
markFill = 100
|
|
}
|
|
|
|
if x != "" { // should be true, board is given
|
|
if y == -1 { // not task, should be board
|
|
// shouldn't be possible, boards don't have a fill
|
|
print( "Error in mark(): task does not exist or not specified" )
|
|
} else { // yes task
|
|
if z == -1 { // not subtask, should be task
|
|
// boards -> map[string][]task
|
|
// boards[x] -> []task
|
|
// boards[x][y] -> task
|
|
// boards[x][y].fill -> task.fill, fill field in task
|
|
boards[x][y].fill = markFill
|
|
changed = true // signal that file needs rewriting
|
|
} else { // yes subtask
|
|
// boards -> map[string][]task
|
|
// boards[x] -> []task
|
|
// boards[x][y] -> task
|
|
// boards[x][y].subt -> []subtask
|
|
// boards[x][y].subt[z] -> subtask
|
|
// boards[x][y].subt[z].fill -> subtask.fill
|
|
boards[x][y].subt[z].fill = markFill
|
|
changed = true // signal that file needs rewriting
|
|
}
|
|
}
|
|
} else { // reachable if the user gives input that DNE
|
|
// notify user requested object did not exist
|
|
p( "Error in mark(): " )
|
|
p( search.subA + " /" )
|
|
switch search.subA {
|
|
case "board":
|
|
p( search.board )
|
|
case "task":
|
|
p( search.task )
|
|
case "subtask":
|
|
p( search.subtask )
|
|
default:
|
|
p( "object" )
|
|
}
|
|
print( "/ does not exist" )
|
|
}
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// PARSE( commands []string )
|
|
//
|
|
// Revn: 03-27-2022
|
|
// Args: commands - []string
|
|
// list of commands of what board, task, or subtask
|
|
// to make
|
|
// Retn: search - query
|
|
// object that contains pertinent information
|
|
// Func: parse user input, determine what command to call and about
|
|
// what object is being called about
|
|
// Meth: lots and lots of switch statements
|
|
// switch over first command
|
|
// switch over length of subcommand
|
|
// switch over contents of subcommand
|
|
// TODO: contemplate help case
|
|
// move to external file?
|
|
// -----------------------------------------------------------------------------
|
|
// CHANGE LOG
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
// 03-06-2022: planned
|
|
// wrote everything but help case
|
|
// tested pass cases
|
|
// 03-10-2022: commented /delete/ portion
|
|
// commented /show/ portion
|
|
// 03-12-2022: rewrote /delete/, /show/, and /mark/
|
|
// 03-13-2022: rewrote /make/
|
|
// began testing /delete/
|
|
// 03-14-2022: finished testing /delete/
|
|
// tested /show/, /mark/, and /make/
|
|
// 03-15-2022: commented
|
|
// fixed small bugs related to valid keyword positions
|
|
// 03-17-2022: added small reference to /save/ in the bugout case
|
|
// 03-27-2022: fixed bug in /make/ where tasks under boards with
|
|
// names of length 1 failed ( literally changed "> 1"
|
|
// to "> 0" )
|
|
//
|
|
// -----------------------------------------------------------------------------
|
|
func parse( commands []string ) query {
|
|
|
|
// declare return object
|
|
var search query
|
|
|
|
// separate command from subcommands, take note of amount of
|
|
// subcommands
|
|
comm := commands[0]
|
|
subcommands := commands[1:]
|
|
subcomlen := len( subcommands )
|
|
|
|
// set pre-emptively, clear if it's bad
|
|
// unused as of right now
|
|
search.command = comm
|
|
|
|
// big switch statement over command
|
|
switch comm {
|
|
// these don't really need processing, break out immediately
|
|
case "save", "set", "quit", "exit":
|
|
return search
|
|
case "delete":
|
|
// there are only so many types of commands that work here
|
|
// -> delete <board>
|
|
// -> delete board <board>
|
|
// -> delete task <task>
|
|
// -> delete subtask <subtask>
|
|
// i.e. subcommand can have either length 1 or 2
|
|
|
|
// if user enters JUST delete, set fail and return
|
|
if subcomlen == 0 {
|
|
search.command = "fail"
|
|
return search
|
|
}
|
|
|
|
switch subcommands[0] {
|
|
case "task":
|
|
// delete task xyz
|
|
// set subcommand ( focus ) of search
|
|
search.subA = subcommands[0]
|
|
// join array into string and set as task
|
|
search.task = join( subcommands[1:] )
|
|
case "subtask":
|
|
// delete subtask xyz
|
|
// set subcommand ( focus ) of search
|
|
search.subA = subcommands[0]
|
|
// join array into string and set as subtask
|
|
search.subtask = join( subcommands[1:] )
|
|
default:
|
|
// delete board xyz
|
|
// delete xyz
|
|
// set subcommand ( focus ) of search
|
|
search.subA = "board"
|
|
// if keyword board is given, join without keyword
|
|
if subcommands[0] == "board" && subcomlen > 1 {
|
|
search.board = join( subcommands[1:] )
|
|
} else { // otherwise, join everything
|
|
search.board = join( subcommands[:] )
|
|
}
|
|
}
|
|
case "help":
|
|
// help( subcommands )
|
|
case "make":
|
|
// -> make <board>
|
|
// -> make board <b>
|
|
// -> make <board> task <t>
|
|
// -> make board <b> task <t>
|
|
// -> make task <t> subtask <s>
|
|
// if subcommand length is 1 or 2, make a board
|
|
// if subcommand length is 3 or 4, make a task/subtask
|
|
|
|
// if user enters JUST make, set fail and return
|
|
if subcomlen == 0 {
|
|
search.command = "fail"
|
|
return search
|
|
}
|
|
|
|
var x int = -1 // keep track of position of subcom
|
|
|
|
if subcommands[0] == "task" {
|
|
// make task xyz subtask ijk
|
|
// iterate over subcommands ( not counting task )
|
|
// looking for the subtask keyword
|
|
for ind, _ := range subcommands[1:] {
|
|
// set x equal to index when subtask is found
|
|
if subcommands[ind] == "subtask" {
|
|
x = ind
|
|
}
|
|
}
|
|
// the absolute minimum index for subtask keyword is 2
|
|
// if its found before 2, thats a problem
|
|
// set fail and return
|
|
if x < 2 {
|
|
search.command = "fail"
|
|
return search
|
|
} else { // valid keyword position
|
|
// set secondary focus to subtask
|
|
search.subB = "subtask"
|
|
// set main focus to parent task
|
|
search.subA = "task"
|
|
// join everything between keywords, set to task
|
|
search.task = join( subcommands[1:x] )
|
|
// join everything after subtask, set to subtask
|
|
search.subtask = join( subcommands[x+1:] )
|
|
}
|
|
} else {
|
|
// make xyz
|
|
// make board xyz
|
|
// make xyz task ijk
|
|
// make board xyz task ijk
|
|
|
|
// declare string to hold subsubcommand
|
|
var subsubcom []string
|
|
|
|
// determine what subsubcommand should include
|
|
if subcommands[0] == "board" {
|
|
subsubcom = subcommands[1:]
|
|
} else {
|
|
subsubcom = subcommands[:]
|
|
}
|
|
// iterate over subsubcommand looking for task keyword
|
|
for ind, _ := range subsubcom {
|
|
// set x equal to index when task is found
|
|
if subsubcom[ind] == "task" {
|
|
x = ind
|
|
}
|
|
}
|
|
|
|
// if task was never found, making a board
|
|
if x == -1 {
|
|
// set focus to board
|
|
search.subA = "board"
|
|
// join everything and set to board
|
|
search.board = join( subsubcom )
|
|
// task was found in a valid position
|
|
} else if x > 0 {
|
|
// set secondary focus to task
|
|
search.subB = "task"
|
|
// set main focus to parent board
|
|
search.subA = "board"
|
|
// join everything between keywords, set to board
|
|
search.board = join( subsubcom[:x] )
|
|
// join everything after task, set to task
|
|
search.task = join( subsubcom[x+1:] )
|
|
// task was not in valid position
|
|
} else {
|
|
// set fail and return
|
|
return search
|
|
}
|
|
}
|
|
case "mark":
|
|
// NYI -> mark <board>
|
|
// NYI -> mark board <b>
|
|
// -> mark task <t> fill
|
|
// -> mark subtask <s> fill
|
|
|
|
// if user enters JUST mark, set fail and return
|
|
if subcomlen == 0 {
|
|
search.command = "fail"
|
|
return search
|
|
}
|
|
|
|
switch subcommands[0] {
|
|
case "task":
|
|
// mark task xyz #
|
|
if subcomlen < 3 {
|
|
// absolute minimum length possible is 3
|
|
// task, name, and fill
|
|
search.command = "fail"
|
|
return search
|
|
}
|
|
// set focus to task
|
|
// set fill to absolute last word in list
|
|
search.subA = subcommands[0]
|
|
search.subB = subcommands[subcomlen - 1]
|
|
// join all the other words, set to task
|
|
search.task = join( subcommands[1:subcomlen - 1] )
|
|
case "subtask":
|
|
// mark subtask xyz #
|
|
if subcomlen < 3 {
|
|
// absolute minimum length possible is 3
|
|
// subtask, name, and fill
|
|
search.command = "fail"
|
|
return search
|
|
}
|
|
// set focus to subtask
|
|
// set fill to absolute last word in list
|
|
search.subA = subcommands[0]
|
|
search.subB = subcommands[subcomlen - 1]
|
|
// join all the other words, set to subtask
|
|
search.subtask = join( subcommands[1:subcomlen - 1] )
|
|
default:
|
|
// delete board xyz
|
|
// delete xyz
|
|
// set focus to board
|
|
// set fill to 100
|
|
search.subA = "board"
|
|
search.subB = "100"
|
|
|
|
// if keyword board is given, join without keyword
|
|
if subcommands[0] == "board" && subcomlen > 1 {
|
|
search.board = join( subcommands[1:] )
|
|
} else { // otherwise, join everything
|
|
search.board = join( subcommands[:] )
|
|
}
|
|
}
|
|
case "show":
|
|
// similar call signature to delete()
|
|
// -> show
|
|
// -> show all
|
|
// -> show <board>
|
|
// -> show board <b>
|
|
// -> show task <t>
|
|
// -> show subtask <s>
|
|
// subcom lengths of 1, 2, and 3 are all possible
|
|
if subcomlen == 0 {
|
|
// show
|
|
// set subcommand to all
|
|
search.subA = "all"
|
|
} else {
|
|
switch subcommands[0] {
|
|
case "task":
|
|
// show task xyz
|
|
// set focus to task
|
|
// join all the other words, set to task
|
|
search.subA = subcommands[0]
|
|
search.task = join( subcommands[1:] )
|
|
case "subtask":
|
|
// show subtask xyz
|
|
// set focus to subtask
|
|
// join all the other words, set to subtask
|
|
search.subA = subcommands[0]
|
|
search.subtask = join( subcommands[1:] )
|
|
case "all":
|
|
// show all
|
|
// show <board name beginning with all>
|
|
if subcomlen == 1 {
|
|
// if there's only one subcommand, it's
|
|
// show all...
|
|
// set subcommand to all
|
|
search.subA = subcommands[0]
|
|
} else { // otherwise, it must be a board
|
|
// set focus to board
|
|
// join all the other words, set to board
|
|
search.subA = "board"
|
|
search.board = join( subcommands[:] )
|
|
}
|
|
default:
|
|
// show board xyz
|
|
// show xyz
|
|
// set focus to board
|
|
search.subA = "board"
|
|
// if keyword board is given, join without keyword
|
|
if subcommands[0] == "board" && subcomlen > 1 {
|
|
search.board = join( subcommands[1:] )
|
|
} else { // otherwise, join everything
|
|
search.board = join( subcommands[:] )
|
|
}
|
|
}
|
|
}
|
|
default: // command not recognized
|
|
// print error, call help about it
|
|
//print( "Command /", comm, "/ not recognized" )
|
|
print( "Command /", comm, "/ not recognized" )
|
|
commFailure := []string{ "help" }
|
|
help( commFailure )
|
|
}
|
|
|
|
return search
|
|
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// SHOW( search query )
|
|
//
|
|
// Revn: 03-27-2022
|
|
// Args: search - query
|
|
// object that summarizes what needs showing
|
|
// Func: display stored information to the user
|
|
// Meth: iterate through everything, look for matching info, print
|
|
// TODO: stylize print in some way
|
|
// add debug flag
|
|
// -----------------------------------------------------------------------------
|
|
// CHANGE LOG
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
// 02-24-2022: wrote bones
|
|
// wrote /all/ portion
|
|
// 02-25-2022: implemented /board/, /task/, and /subtask/ portions
|
|
// added calls to help() on error
|
|
// changed input argument from type query to type
|
|
// []string, so it can call sanitize()
|
|
// 02-27-2022: commented /all/ portion
|
|
// 03-02-2022: commented /board/, /task/, and /subtask/ portions
|
|
// 03-16-2022: updated to switch/case system to work with the new
|
|
// version of parse()
|
|
// 03-27-2022: removed 1.x version
|
|
//
|
|
// -----------------------------------------------------------------------------
|
|
func show( search query ) {
|
|
|
|
// check to see if query returned empty
|
|
// not entirely sure if that's possible, but check for it
|
|
if search == ( query{} ) {
|
|
return
|
|
}
|
|
|
|
// ease of use variables from search struct
|
|
subcom := search.subA
|
|
sbd := search.board
|
|
stk := search.task
|
|
sstk := search.subtask
|
|
|
|
switch search.subA {
|
|
case "all":
|
|
// iterate over boards' contents
|
|
for boardName, boardContents := range boards {
|
|
// show all -> print board name
|
|
print( boardName )
|
|
// iterate over board's tasks
|
|
for _, showTask := range boardContents {
|
|
// print indent with no trailing newline
|
|
// indent has len 4
|
|
p( " " )
|
|
// print task name, right justified (with respect
|
|
// to the indent)
|
|
printf( "%-16s", showTask.name )
|
|
// print task fill, left justified
|
|
// indent len 4 + 16 = 20
|
|
printf( "%16d\n", showTask.fill )
|
|
// iterate over the task's subtasks
|
|
for _, showSubtask := range showTask.subt {
|
|
// double indent
|
|
// double indent has len 8
|
|
p( " " )
|
|
// print subtask name, right justified (with
|
|
// respect to indent again)
|
|
printf( "%-16s", showSubtask.name )
|
|
// print subtask fill, left justified
|
|
// indent len 8 + 12 = 20
|
|
printf( "%12d\n", showSubtask.fill )
|
|
}
|
|
}
|
|
}
|
|
case "board":
|
|
// grab user requested board from boards
|
|
// prs is set true if board exists
|
|
contents, prs := boards[sbd]
|
|
if prs { // if user specified board exists
|
|
print( sbd ) // print board name
|
|
// iterate over tasks in board
|
|
for _, showTask := range contents {
|
|
// print indent with no trailing newline
|
|
// indent has len 4
|
|
p( " " )
|
|
// print task name, right justified (with respect
|
|
// to the indent)
|
|
printf( "%-16s", showTask.name )
|
|
// print task fill, left justified
|
|
// indent len 4 + 16 = 20
|
|
printf( "%16d\n", showTask.fill )
|
|
for _, showSubtask := range showTask.subt {
|
|
// double indent
|
|
// double indent has len 8
|
|
p( " " )
|
|
// print subtask name, right justified (with
|
|
// respect to indent again)
|
|
printf( "%-12s", showSubtask.name )
|
|
// print subtask fill, left justified
|
|
// indent len 8 + 12 = 20
|
|
printf( "%16d\n", showSubtask.fill )
|
|
}
|
|
}
|
|
} else { // if board DNE
|
|
// print error, call help about it
|
|
print( "Board /" + sbd + "/ does not exist" )
|
|
showFailure := []string{ "help", "show" }
|
|
help( showFailure )
|
|
return
|
|
}
|
|
case "task":
|
|
// can check if a board is present with _, prs :=
|
|
// but this is a flag to be set if a task exists
|
|
var exists bool
|
|
|
|
// iterate over all boards looking for named task
|
|
for showBoard, contents := range boards {
|
|
// iterate through all tasks in boards
|
|
for _, showTask := range contents {
|
|
// look for matching task name
|
|
if showTask.name == stk {
|
|
exists = true // set exists true
|
|
// print containing board name
|
|
print( showBoard )
|
|
// print task name with same justification
|
|
printf( "%-16s", showTask.name )
|
|
// print task fill with right justification
|
|
printf( "%20d\n", showTask.fill )
|
|
// iterate over contained subtasks
|
|
for _, showSubtask := range showTask.subt {
|
|
// print indent
|
|
p( " " )
|
|
// print subtask name left justified
|
|
printf( "%-16s", showSubtask.name )
|
|
// print subtask fill right justified
|
|
printf( "%16d\n", showSubtask.fill )
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if !exists { // if task not found
|
|
// print error
|
|
// call help about it
|
|
print( "Task /" + stk + "/ does not exist" )
|
|
showFailure := []string{ "help", "show" }
|
|
help( showFailure )
|
|
return
|
|
}
|
|
case "subtask":
|
|
// can check if a board is present with _, prs :=
|
|
// but this is a flag to be set if a task exists
|
|
var exists bool
|
|
|
|
// iterate over all boards looking for named task
|
|
for showBoard, contents := range boards {
|
|
// iterate through all tasks in boards
|
|
for _, showTask := range contents {
|
|
// iterate over contained subtasks
|
|
for _, showSubtask := range showTask.subt {
|
|
// look for matching subtask name
|
|
if showSubtask.name == sstk {
|
|
exists = true // set exists true
|
|
// print containing board name
|
|
print( showBoard )
|
|
// print containing task name
|
|
print( showTask.name )
|
|
// print subtask name left justified
|
|
printf( "%-16s", showSubtask.name )
|
|
// print subtask fill right justified
|
|
printf( "%20d\n", showSubtask.fill )
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if !exists { // if subtask not found
|
|
// print error
|
|
// call help about it
|
|
print( "Subtask /" + sstk + "/ does not exist" )
|
|
showFailure := []string{ "help", "show" }
|
|
help( showFailure )
|
|
return
|
|
}
|
|
default: // unrecognized subcommand
|
|
// print error, call help about it
|
|
print( "Error in show()" )
|
|
print( "Subcommand /" + subcom + "/ does not exist" )
|
|
showFailure := []string{ "help", "show" }
|
|
help( showFailure )
|
|
return
|
|
}
|
|
}
|
|
|
|
var flag bool = false // debug flag
|
|
var changed bool = false
|
|
|
|
|
|
// struct used for defining search parameters
|
|
type query struct {
|
|
command string // command passed, or fail
|
|
board string // requested board
|
|
task string // requested task
|
|
subtask string // requested subtaks
|
|
subA string // subcom A, usually object being acted upon
|
|
subB string // sometimes, two are needed
|
|
}
|
|
|
|
|
|
/*
|
|
type subsubtask struct {
|
|
name string // subsubtasks are named
|
|
fill int // subsubtasks contain progress
|
|
//note string // subsubtasks can contain files
|
|
}
|
|
*/
|
|
|
|
// struct used for defining what constitutes a 'subtask'
|
|
type subtask struct {
|
|
name string // subtasks are named
|
|
fill int // subtasks contain progress
|
|
//ssbt []subsubtask // subtasks can contain subsubtasks
|
|
//note string // subtasks can contain files
|
|
}
|
|
|
|
|
|
// struct used for defining what constitutes a 'task'
|
|
type task struct {
|
|
name string // tasks are named
|
|
fill int // tasks contain progress
|
|
subt []subtask // tasks can contain subtasks
|
|
//note string // tasks can contain files
|
|
}
|
|
|
|
|
|
// boards is a hashmap map[ ]
|
|
// that relates strings string
|
|
// to an array of tasks []task
|
|
var boards = make( map[string][]task )
|
|
var tasks []task // array of tasks referenced above
|
|
var subtasks []subtask // array of subtasks belonging to tasks
|
|
|
|
// MAIN
|
|
func main() {
|
|
|
|
catch() // call function to catch keyboard interrupts
|
|
|
|
fileIn() // open data file, process into structure
|
|
|
|
for { // infinite loop, where everything happens
|
|
|
|
userIn := input( "-> " ) // take user input
|
|
ui := split( userIn, " " ) // split over spaces
|
|
command := ui[0] // first entry is command
|
|
// convention: send entire array to subfunction, do not strip
|
|
// any subcommands off
|
|
|
|
// switch case over command
|
|
// recognize user input, call appropriate command
|
|
|
|
var search query = parse( ui )
|
|
|
|
|
|
switch command {
|
|
case "delete":
|
|
del( search )
|
|
case "help":
|
|
help( ui )
|
|
case "make":
|
|
// make translated into Russian, because make is a
|
|
// GoLang keyword, and Norwegian word was less cool
|
|
// pronounced like 'zdye-lie'
|
|
сделай( search )
|
|
case "mark":
|
|
mark( search )
|
|
case "save":
|
|
fileOut()
|
|
changed = false
|
|
print( "Updates saved" )
|
|
case "show":
|
|
show( search )
|
|
case "exit", "quit":
|
|
|
|
if flag { // if debug set, print if file was changed
|
|
print( changed )
|
|
}
|
|
|
|
// if file was changed, rewrite to file
|
|
if changed {
|
|
fileOut()
|
|
}
|
|
|
|
exit( 0 ) // exeunt
|
|
case "set":
|
|
// XXX
|
|
// turn debug flag on and off
|
|
// conveniently only recognizes first and last word of
|
|
// command; "set true" will work, as will "set flag
|
|
// false" and "set sprite coke pepsi"
|
|
flag = ui[len( ui ) - 1] == "true"
|
|
default: // if the input is unrecognized
|
|
continue // try again
|
|
}
|
|
}
|
|
}
|
|
|