task processing

[bjohas]

gtasks process --list ABC [--match "string"] [--pipeto "script.sh"] [--interactive yes|no, default: yes] [--action markdone|none, default: none]

If option --match is set, scan all task titles/descriptions in ABC for a specific string (such as '#email'). Otherwise use all tasks. Ask whether to perform action or not? If the users answers y, the item is piped to 'script.sh' (as json) and the task is marked as done.

For example:

gtasks process --list ABC --interactive no

outputs all tasks from the list ABC.

For example:

gtasks process --list ABC --match "string" --interactive no

outputs all tasks from the list ABC that match "string"

For example:

gtasks process --list ABC --match "#email" -pipeto "sendmail_script.sh" --interactive yes --action markdone

goes through the list ABC and present this information:

List: ABC
Task 1
Title: Buy milk. #email
Description: ....
Other metadata: ...

Then dialogue:

Perform action "sendmail_script.sh" (y)?
Advance to next item (n)?
There are subtasks - examine (e)?

The user inputs:

User> y

The content is piped to the script. This includes

• y for yes,
• n for no, and the option
• e to examine subtasks if present. If 'e' is selected, subtasks are presented.

If a user says 'y' to the main task with subtasks, then the full task+subtasks is passed to the script, and the whole task+subtasks is archived. If the user examines 'e' subtasks, then only the subtasks is passed to the script, and only the subtask is archived.

Other options:

• --action markdone means that when the task is processed with 'y', the task is marked as done
• --action none means that the task is left alone.
• --interactive yes means that tasks are presented one by one
• --interactive no means that all matching tasks are presented

[Resinderate]

Have started to flesh out the process interface and added the options to the UI. Still stubbed for now though so will move onto the implementation next. Help for process looks like this now:

(gtasks) ~/dev/upwork/gtasks (develop) $ ./gtasks process --help
usage: gtasks process [-h] --list LIST [--match MATCH] [--pipeto PIPETO]
                      [--interactive {yes,no}] [--action {markdone,none}]

optional arguments:
  -h, --help            show this help message and exit
  --list LIST           The list to look for tasks in.
  --match MATCH         The search term to look for in task titles as a
                        filter.
  --pipeto PIPETO       The script to pipe the content of the task to. Must be
                        available to run directly from this scipt. i.e on your
                        PATH. E.g `myscript.sh`
  --interactive {yes,no}
                        If no, just lists the matching tasks. If yes, will
                        prompt about piping to scipt and descending to
                        subtasks or not. Default: yes
  --action {markdone,none}
                        Whether to mark the tasks as done or not after
                        processing them in interactive mode. Default: none

I just wanted to confirm my understanding on the flow for:

If a user says 'y' to the main task with subtasks, then the full task+subtasks is passed to the script, and the whole task+subtasks is archived.

So each of the tasks will have potentially have some content/notes (not the title). In the case where we have 1 parent task, with 2 child tasks and we press (y) to process the parent task. Then we combine all of the content (perhaps simply with a newline or something), and send that bunch of content to the script, and then mark all the tasks as done (if --action markdone). Is this correct? An alternate is to pipe them to the script one by one.

I think just because I'm not aware of what is going to be mentioned inside these tasks, or what the scripts they will be piped to I'm having a tough time imagining what the scenario would be. The script would need to be smart enough to deal with the bigger blob of input for example.

[bjohas]

Yes, pass the whole task + subtasks to the script. How about just passing it as JSON? Then the script can decide what to do?

[bjohas]

The idea with interactive=no was that (if a script is specified) all tasks are passed to the script. If action=markdowns, then all tasks are marked as done only if script and action are both not set, the result is just a list.

Let me give a somewhat cryptic workflow...

gtasks list ABC interactive no

Ok that's all that's on that list.
that's all done, let's mark it as done

gtasks list ABC interactive no action markdone

Or, if we need to send it all elsewhere:

gtasks list ABC action markdone interactive no script xyz.sh

Alternative workflow; where was the GitHub task again?

gtasks match GitHub interactive no

Ok, there it is - but there are several... Let me select and process

gtasks match GitHub interactive yes script XY.sh

Sorry for the shorthand with the options, hope it makes sense!

[Resinderate]

Yep, think that makes sense, so we can automatically pipe a bunch of tasks to something, or automatically mark a bunch as done.

Have updated the description of the help on the --interactive option to reflect the new understanding. Looks like this now:

(gtasks) ~/dev/upwork/gtasks (develop) $ ./gtasks process -h
usage: gtasks process [-h] --list TARGET_LIST [--match MATCH]
                      [--pipeto PIPETO] [--interactive {yes,no}]
                      [--action {markdone,none}]

optional arguments:
  -h, --help            show this help message and exit
  --list TARGET_LIST    The list to look for tasks in.
  --match MATCH         The search term to look for in task titles as a
                        filter.
  --pipeto PIPETO       The script to pipe the content of the task to. Must be
                        available to run directly from this scipt. i.e on your
                        PATH. E.g `myscript.sh`
  --interactive {yes,no}
                        If yes, will ask for confirmation before performing
                        actions. If no, will proceed with actions without
                        asking.
  --action {markdone,none}
                        Whether to mark the tasks as done or not after
                        processing them in interactive mode. Default: none

Have got some more work done on the process, and now have the listing and matching/filtering operations working. The listing looks like this right now:

(gtasks) ~/dev/upwork/gtasks (develop) $ ./gtasks process --list "My Tasks" --match task
Processing!
List:  My Tasks
Match: task
--
Task 0
Title:  Example Task
Description:  a note
Last Updated:  2019-11-16T18:46:48.000Z
Sub Tasks:
    --
    Title:  Sub Task
    Description:  asd
    Last Updated:  2019-11-19T23:00:05.000Z
    --
    Title:  Sub Task 2
    Description:  None
    Last Updated:  2019-11-19T22:45:54.000Z

Done processing!

The output is quite quick to update if we like. To start with I've made both the list it's looking for and the matching case in-sensitive to try and be a bit more graceful, we can swap that to being case sensitive if you think that would work better.

If you want to pass names or matches with a space in them, we have to enclose them in quotes, like --list "my tasks".

When filtering against the --match word, we first check the parents, and only if the parent matches do we look in the child tasks of the parent. We could swap this over to also looking in those ignored ones, but it's a little tricky and we would need to decide what that would looks like. Such as a <Non Matching Parent> line in the output or something. Can let me know if we what to chase that one.

Up next I'll work on the --action, --interactive and then the --pipeto, which would be good to try and test out with some scenarios to make sure we're covering the end to end flow completely 👍

[Resinderate]

Have implemented the --action now. In --interactive=no mode, it will take the action to all matching tasks, even if no --pipeto is provided. In --interactive=yes mode, if there is a --pipeto, if you do the --pipeto action it will also do the markdone action. If there is no --pipeto script given, you are instead just asked Perform action 'markdone' (y)?. Probably worth playing around with to test if it feels right.

The --pipeto option is also implemented. It passes the contents of the tasks serialized to a json string to the script. If we're in --interactive=no mode we get a list of tasks like "[{...}, {...}]", piped to the script all at once. If we're in --interactive=yes mode, and we answer (y) just the current task is piped to the script. I've used the built in cat command to simply repeat back what we have given it for testing.

I've created two videos, one in interactive mode and one not to try and illustrate the usage a bit better so far 🙂

https://youtu.be/tKq4yQVeVEw
https://youtu.be/mkXI1FdQnQw