392 lines
8.2 KiB
Go
392 lines
8.2 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"local/pt-todo-server/pttodo"
|
|
"log"
|
|
"os"
|
|
"os/exec"
|
|
"path"
|
|
"strings"
|
|
"syscall"
|
|
|
|
"gopkg.in/yaml.v2"
|
|
)
|
|
|
|
const (
|
|
DUMP_ALL = "all"
|
|
DUMP_TODO = "todo"
|
|
DUMP_SCHEDULED = "scheduled"
|
|
DUMP_DONE = "done"
|
|
)
|
|
|
|
func main() {
|
|
if err := _main(); err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
func _main() error {
|
|
defaultFilepath, ok := os.LookupEnv("PTTODO_FILE")
|
|
if !ok {
|
|
defaultFilepath = "-"
|
|
}
|
|
filepath := flag.String("f", defaultFilepath, "($PTTODO_FILE) path to yaml file or dir (starting with root then alphabetical for dir)")
|
|
filepathToMergeIn := flag.String("g", "", "path to yaml file to merge into -f (modifies f)")
|
|
root := flag.String("root", DUMP_TODO, "path to pretty print ("+fmt.Sprint([]string{DUMP_ALL, DUMP_TODO, DUMP_SCHEDULED, DUMP_DONE})+")")
|
|
tags := flag.String("tags", "", "csv of all tags to find, -tag to invert")
|
|
search := flag.String("search", "", "fts case insensitive")
|
|
e := flag.Bool("e", false, "edit file")
|
|
dry := flag.Bool("dry", false, "dry run")
|
|
flag.Parse()
|
|
if *filepathToMergeIn != "" {
|
|
if err := merge(*dry, *filepath, *filepathToMergeIn); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
filepaths := []string{*filepath}
|
|
if stat, err := os.Stat(*filepath); err != nil && !os.IsNotExist(err) {
|
|
return err
|
|
} else if err == nil && stat.IsDir() {
|
|
filepaths, err = listDir(*filepath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if *e {
|
|
if err := edit(*dry, filepaths); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
var tagslist []string
|
|
if *tags != "" {
|
|
tagslist = strings.Split(*tags, ",")
|
|
}
|
|
return dump(*dry, os.Stdout, filepaths, tagslist, *search, *root)
|
|
}
|
|
|
|
func verifyRoot(root pttodo.Root) error {
|
|
f, err := ioutil.TempFile(os.TempDir(), "tmp")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
f.Close()
|
|
tempFile := f.Name()
|
|
b, err := yaml.Marshal(root)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := ioutil.WriteFile(tempFile, b, os.ModePerm); err != nil {
|
|
return err
|
|
}
|
|
defer os.Remove(tempFile)
|
|
return verifyFile(tempFile)
|
|
}
|
|
|
|
func verifyFile(path string) error {
|
|
if err := dump(true, io.Discard, []string{path}, nil, "", DUMP_ALL); err != nil {
|
|
return fmt.Errorf("failed verifying file %s: %w", path, err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func edit(dry bool, filepaths []string) error {
|
|
tempDir, err := ioutil.TempDir(os.TempDir(), "edit-pttodo")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
cpOne := func(filepath string) error {
|
|
f, err := os.Create(path.Join(tempDir, path.Base(filepath)))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if _, err := os.Stat(filepath); err == nil {
|
|
g, err := os.Open(filepath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if _, err := io.Copy(f, g); err != nil {
|
|
return err
|
|
}
|
|
g.Close()
|
|
}
|
|
f.Close()
|
|
return nil
|
|
}
|
|
cp := func() error {
|
|
for _, filepath := range filepaths {
|
|
if err := cpOne(filepath); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
vi := func() error {
|
|
bin := "vim"
|
|
editorbin, err := exec.LookPath(bin)
|
|
if err != nil {
|
|
editorbin, err = exec.LookPath("vi")
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
args := []string{editorbin, "-p"}
|
|
tempfiles, err := listDir(tempDir)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
args = append(args, tempfiles...)
|
|
cpid, err := syscall.ForkExec(
|
|
editorbin,
|
|
args,
|
|
&syscall.ProcAttr{
|
|
Dir: tempDir,
|
|
Env: os.Environ(),
|
|
Files: []uintptr{os.Stdin.Fd(), os.Stdout.Fd(), os.Stderr.Fd()},
|
|
Sys: nil,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
proc, err := os.FindProcess(cpid)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state, err := proc.Wait()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if exitCode := state.ExitCode(); exitCode != 0 {
|
|
return fmt.Errorf("bad exit code on vim: %d, state: %+v", exitCode, state)
|
|
}
|
|
return nil
|
|
}
|
|
verifyOne := func(tempFile string) error {
|
|
for {
|
|
err := verifyFile(tempFile)
|
|
if err == nil {
|
|
break
|
|
}
|
|
log.Printf("%v, press <Enter> to resume editing", err)
|
|
b := make([]byte, 1)
|
|
if _, err := os.Stdin.Read(b); err != nil {
|
|
break
|
|
}
|
|
if err := vi(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return verifyFile(tempFile)
|
|
}
|
|
verify := func() error {
|
|
for _, filepath := range filepaths {
|
|
tempFile := path.Join(tempDir, path.Base(filepath))
|
|
if err := verifyOne(tempFile); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
saveOne := func(filepath string) error {
|
|
tempFile := path.Join(tempDir, path.Base(filepath))
|
|
if dry {
|
|
log.Printf("would've saved %s as %s", tempFile, filepath)
|
|
return nil
|
|
}
|
|
return os.Rename(tempFile, filepath)
|
|
}
|
|
save := func() error {
|
|
for _, filepath := range filepaths {
|
|
if err := saveOne(filepath); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
for _, foo := range []func() error{cp, vi, verify, save} {
|
|
if err := foo(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if !dry {
|
|
os.RemoveAll(tempDir)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func merge(dry bool, filepath string, mergeTargetFilePath string) error {
|
|
baseReader, err := filePathReader(filepath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
baseB, err := ioutil.ReadAll(baseReader)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
mergingReader, err := filePathReader(mergeTargetFilePath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
mergingB, err := ioutil.ReadAll(mergingReader)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var base, merging pttodo.Root
|
|
if err := yaml.Unmarshal(baseB, &base); err != nil {
|
|
return err
|
|
}
|
|
if err := yaml.Unmarshal(mergingB, &merging); err != nil {
|
|
return err
|
|
}
|
|
|
|
base.MergeIn(merging)
|
|
|
|
if err := verifyRoot(base); err != nil {
|
|
return err
|
|
}
|
|
tmppath, err := marshalRootToTempFile(base)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if dry {
|
|
log.Printf("would've moved %s to %s when adding %s", tmppath, filepath, mergeTargetFilePath)
|
|
return nil
|
|
}
|
|
return os.Rename(tmppath, filepath)
|
|
}
|
|
|
|
func marshalRootToTempFile(root pttodo.Root) (string, error) {
|
|
f, err := ioutil.TempFile(os.TempDir(), "tmp")
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
f.Close()
|
|
os.Remove(f.Name())
|
|
b, err := yaml.Marshal(root)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
filepath := f.Name() + ".yaml"
|
|
err = ioutil.WriteFile(filepath, b, os.ModePerm)
|
|
return filepath, err
|
|
}
|
|
|
|
func dump(dry bool, writer io.Writer, filepaths []string, tags []string, search, rootDisplay string) error {
|
|
var root pttodo.Root
|
|
|
|
for _, filepath := range filepaths {
|
|
reader, err := filePathReader(filepath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
b, err := ioutil.ReadAll(reader)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var root2 pttodo.Root
|
|
if err := yaml.Unmarshal(b, &root2); err != nil {
|
|
return err
|
|
}
|
|
root2.MoveScheduledToTodo()
|
|
root.MergeIn(root2)
|
|
|
|
if !dry {
|
|
b3, err := yaml.Marshal(root2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := os.WriteFile(filepath, b3, os.ModePerm); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
root.MoveScheduledToTodo()
|
|
|
|
var v interface{} = root
|
|
switch rootDisplay {
|
|
case DUMP_ALL:
|
|
case DUMP_TODO:
|
|
v = root.Todo
|
|
case DUMP_SCHEDULED:
|
|
v = root.Scheduled
|
|
case DUMP_DONE:
|
|
v = root.Done
|
|
}
|
|
if todos, ok := v.([]pttodo.Todo); ok {
|
|
if len(tags) > 0 {
|
|
result := make([]pttodo.Todo, 0, len(todos))
|
|
for _, todo := range todos {
|
|
skip := false
|
|
for _, tag := range tags {
|
|
positiveTag := strings.TrimLeft(tag, "-")
|
|
hasTag := strings.Contains(todo.Tags, positiveTag)
|
|
wantToHaveTag := !strings.HasPrefix(tag, "-")
|
|
skip = skip || !(hasTag == wantToHaveTag)
|
|
}
|
|
if !skip {
|
|
result = append(result, todo)
|
|
}
|
|
}
|
|
todos = result
|
|
}
|
|
if len(search) > 0 {
|
|
result := make([]pttodo.Todo, 0, len(todos))
|
|
for _, todo := range todos {
|
|
if strings.Contains(strings.ToLower(fmt.Sprint(todo)), strings.ToLower(search)) {
|
|
result = append(result, todo)
|
|
}
|
|
}
|
|
todos = result
|
|
}
|
|
v = todos
|
|
}
|
|
|
|
b2, err := yaml.Marshal(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
fmt.Fprintf(writer, "%s\n", b2)
|
|
return nil
|
|
}
|
|
|
|
func filePathReader(path string) (io.Reader, error) {
|
|
var reader io.Reader
|
|
if path == "-" {
|
|
reader = os.Stdin
|
|
} else {
|
|
b, err := ioutil.ReadFile(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
reader = bytes.NewReader(b)
|
|
}
|
|
return reader, nil
|
|
}
|
|
|
|
func listDir(dname string) ([]string, error) {
|
|
entries, err := os.ReadDir(dname)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
paths := make([]string, 0, len(entries))
|
|
for i := range entries {
|
|
if entries[i].IsDir() {
|
|
continue
|
|
}
|
|
paths = append(paths, path.Join(dname, entries[i].Name()))
|
|
}
|
|
return paths, nil
|
|
}
|