Compare commits
No commits in common. "main" and "4.8.0" have entirely different histories.
@ -1,2 +0,0 @@
|
||||
[tools]
|
||||
nim = "2.2.0"
|
||||
@ -46,7 +46,7 @@ Some other common properties I use are:
|
||||
|
||||
- `resolution`: for short notes about why an issue was moved to `done`,
|
||||
especially if it the action wasn't taken or if it is not completely clear
|
||||
that this issue was completed.
|
||||
that this issue was completed.
|
||||
|
||||
## Configuration Options
|
||||
|
||||
@ -107,7 +107,7 @@ in the configuration file. All options are optional unless stated otherwise.
|
||||
- `defaultContext`: if present all invokations to the CLI will
|
||||
be in this context. This is like adding a `--context <defaultContext>`
|
||||
parameter to every CLI invocation. Any actual `--context` parameter will
|
||||
override this value.
|
||||
override this value.
|
||||
|
||||
- `verbose`: Show issue details when listing issues (same as
|
||||
`--verbose` flag).
|
||||
@ -135,4 +135,7 @@ in the configuration file. All options are optional unless stated otherwise.
|
||||
"Personal"; it does not need an alternate display name.
|
||||
|
||||
* `tasksDir` **required**: a file path to the root directory for the issue
|
||||
repository (same as `--tasks-dir` CLI parameter).
|
||||
repository (same as `--tasks-dir` CLI parameter).
|
||||
|
||||
- CLI parameter: *cannot be specified via CLI*
|
||||
- config file key: `contexts`
|
||||
|
||||
28
pit.nimble
28
pit.nimble
@ -1,31 +1,25 @@
|
||||
# Package
|
||||
|
||||
version = "4.29.1"
|
||||
version = "4.8.0"
|
||||
author = "Jonathan Bernard"
|
||||
description = "Personal issue tracker."
|
||||
license = "MIT"
|
||||
srcDir = "src"
|
||||
installExt = @["nim"]
|
||||
bin = @["pit"]
|
||||
bin = @["pit", "pit_api"]
|
||||
|
||||
# Dependencies
|
||||
|
||||
requires @[
|
||||
"nim >= 1.4.0",
|
||||
"docopt >= 0.7.1",
|
||||
"jester >= 0.6.0",
|
||||
"uuids >= 0.1.10",
|
||||
"zero_functional"
|
||||
]
|
||||
"nim >= 0.19.0",
|
||||
"docopt 0.6.8",
|
||||
"jester 0.4.1",
|
||||
"uuids 0.1.10",
|
||||
|
||||
# Dependencies from git.jdb-software.com/jdb/nim-packages
|
||||
requires @[
|
||||
"cliutils >= 0.9.1",
|
||||
"langutils >= 0.4.0",
|
||||
"timeutils >= 0.5.4",
|
||||
"data_uri > 1.0.0",
|
||||
"update_nim_package_version >= 0.2.0"
|
||||
"https://git.jdb-labs.com/jdb/nim-cli-utils.git >= 0.6.4",
|
||||
"https://git.jdb-labs.com/jdb/nim-lang-utils.git >= 0.4.0",
|
||||
"https://git.jdb-labs.com/jdb/nim-time-utils.git >= 0.4.0",
|
||||
"https://git.jdb-labs.com/jdb/update-nim-package-version"
|
||||
]
|
||||
|
||||
task updateVersion, "Update the version of this package.":
|
||||
exec "update_nim_package_version pit 'src/pit/cliconstants.nim'"
|
||||
exec "update_nim_package_version pit 'src/pitpkg/version.nim'"
|
||||
@ -1 +0,0 @@
|
||||
switch("define", "ssl")
|
||||
534
src/pit.nim
534
src/pit.nim
@ -1,19 +1,160 @@
|
||||
## Personal Issue Tracker CLI interface
|
||||
## ====================================
|
||||
|
||||
import std/[algorithm, logging, options, os, sequtils, tables, times, unicode]
|
||||
import data_uri, docopt, json, timeutils, uuids
|
||||
import cliutils, docopt, json, logging, options, os, sequtils,
|
||||
tables, terminal, times, timeutils, unicode, uuids
|
||||
|
||||
from nre import re
|
||||
import strutils except alignLeft, capitalize, strip, toUpper, toLower
|
||||
import pit/[cliconstants, formatting, libpit, sync_pbm_vsb]
|
||||
import strutils except capitalize, strip, toUpper, toLower
|
||||
import pitpkg/private/libpit
|
||||
export libpit
|
||||
|
||||
export formatting, libpit
|
||||
include "pitpkg/version.nim"
|
||||
|
||||
type
|
||||
CliContext = ref object
|
||||
cfg*: PitConfig
|
||||
contexts*: TableRef[string, string]
|
||||
defaultContext*: Option[string]
|
||||
tasksDir*: string
|
||||
issues*: TableRef[IssueState, seq[Issue]]
|
||||
termWidth*: int
|
||||
triggerPtk*, verbose*: bool
|
||||
|
||||
let EDITOR =
|
||||
if existsEnv("EDITOR"): getEnv("EDITOR")
|
||||
else: "vi"
|
||||
|
||||
|
||||
proc initContext(args: Table[string, Value]): CliContext =
|
||||
let pitCfg = loadConfig(args)
|
||||
|
||||
let cliJson =
|
||||
if pitCfg.cfg.json.hasKey("cli"): pitCfg.cfg.json["cli"]
|
||||
else: newJObject()
|
||||
|
||||
let cliCfg = CombinedConfig(docopt: args, json: cliJson)
|
||||
|
||||
result = CliContext(
|
||||
cfg: pitCfg,
|
||||
contexts: pitCfg.contexts,
|
||||
defaultContext:
|
||||
if not cliJson.hasKey("defaultContext"): none(string)
|
||||
else: some(cliJson["defaultContext"].getStr()),
|
||||
verbose: parseBool(cliCfg.getVal("verbose", "false")) and not args["--quiet"],
|
||||
issues: newTable[IssueState, seq[Issue]](),
|
||||
tasksDir: pitCfg.tasksDir,
|
||||
termWidth: parseInt(cliCfg.getVal("termWidth", "80")),
|
||||
triggerPtk: cliJson.getOrDefault("triggerPtk").getBool(false))
|
||||
|
||||
proc getIssueContextDisplayName(ctx: CliContext, context: string): string =
|
||||
if not ctx.contexts.hasKey(context):
|
||||
if context.isNilOrWhitespace: return "<default>"
|
||||
else: return context.capitalize()
|
||||
return ctx.contexts[context]
|
||||
|
||||
proc formatIssue(ctx: CliContext, issue: Issue): string =
|
||||
result = ($issue.id).withColor(fgBlack, true) & "\n"&
|
||||
issue.summary.withColor(fgWhite) & "\n"
|
||||
|
||||
if issue.tags.len > 0:
|
||||
result &= "tags: ".withColor(fgMagenta) &
|
||||
issue.tags.join(",").withColor(fgGreen, true) & "\n"
|
||||
|
||||
if issue.properties.len > 0:
|
||||
result &= termColor(fgMagenta)
|
||||
for k, v in issue.properties: result &= k & ": " & v & "\n"
|
||||
|
||||
|
||||
result &= "--------".withColor(fgBlack, true) & "\n"
|
||||
if not issue.details.isNilOrWhitespace:
|
||||
result &= issue.details.strip.withColor(fgCyan) & "\n"
|
||||
|
||||
proc formatSectionIssue(ctx: CliContext, issue: Issue, width: int, indent = "",
|
||||
verbose = false): string =
|
||||
|
||||
result = ""
|
||||
|
||||
var showDetails = not issue.details.isNilOrWhitespace and verbose
|
||||
|
||||
var prefixLen = 0
|
||||
var summaryIndentLen = indent.len + 7
|
||||
|
||||
if issue.hasProp("delegated-to"): prefixLen += issue["delegated-to"].len + 2 # space for the ':' and ' '
|
||||
|
||||
# Wrap and write the summary.
|
||||
var wrappedSummary = ("+".repeat(prefixLen) & issue.summary).wordWrap(width - summaryIndentLen).indent(summaryIndentLen)
|
||||
|
||||
wrappedSummary = wrappedSummary[(prefixLen + summaryIndentLen)..^1]
|
||||
|
||||
result = (indent & ($issue.id)[0..<6]).withColor(fgBlack, true) & " "
|
||||
|
||||
if issue.hasProp("delegated-to"):
|
||||
result &= (issue["delegated-to"] & ": ").withColor(fgGreen)
|
||||
|
||||
result &= wrappedSummary.withColor(fgWhite)
|
||||
|
||||
if issue.tags.len > 0:
|
||||
let tagsStr = "(" & issue.tags.join(", ") & ")"
|
||||
if (result.splitLines[^1].len + tagsStr.len + 1) > (width - 2):
|
||||
result &= "\n" & indent
|
||||
result &= " " & tagsStr.withColor(fgGreen)
|
||||
|
||||
|
||||
if issue.hasProp("pending"):
|
||||
let startIdx = "Pending: ".len
|
||||
var pendingText = issue["pending"].wordWrap(width - startIdx - summaryIndentLen)
|
||||
.indent(startIdx)
|
||||
pendingText = ("Pending: " & pendingText[startIdx..^1]).indent(summaryIndentLen)
|
||||
result &= "\n" & pendingText.withColor(fgCyan)
|
||||
|
||||
if showDetails:
|
||||
result &= "\n" & issue.details.strip.indent(indent.len + 2).withColor(fgCyan)
|
||||
|
||||
result &= termReset
|
||||
|
||||
proc formatSectionIssueList(ctx: CliContext, issues: seq[Issue], width: int,
|
||||
indent: string, verbose: bool): string =
|
||||
|
||||
result = ""
|
||||
for i in issues:
|
||||
var issueText = ctx.formatSectionIssue(i, width, indent, verbose)
|
||||
result &= issueText & "\n"
|
||||
|
||||
proc formatSection(ctx: CliContext, issues: seq[Issue], state: IssueState,
|
||||
indent = "", verbose = false): string =
|
||||
let innerWidth = ctx.termWidth - (indent.len * 2)
|
||||
|
||||
result = termColor(fgBlue) &
|
||||
(indent & ".".repeat(innerWidth)) & "\n" &
|
||||
state.displayName.center(ctx.termWidth) & "\n\n" &
|
||||
termReset
|
||||
|
||||
let issuesByContext = issues.groupBy("context")
|
||||
|
||||
if issues.len > 5 and issuesByContext.len > 1:
|
||||
for context, ctxIssues in issuesByContext:
|
||||
|
||||
result &= termColor(fgYellow) &
|
||||
indent & ctx.getIssueContextDisplayName(context) & ":" &
|
||||
termReset & "\n\n"
|
||||
|
||||
result &= ctx.formatSectionIssueList(ctxIssues, innerWidth - 2, indent & " ", verbose)
|
||||
result &= "\n"
|
||||
|
||||
else: result &= ctx.formatSectionIssueList(issues, innerWidth, indent, verbose)
|
||||
|
||||
proc loadIssues(ctx: CliContext, state: IssueState) =
|
||||
ctx.issues[state] = loadIssues(ctx.tasksDir / $state)
|
||||
|
||||
proc loadAllIssues(ctx: CliContext) =
|
||||
ctx.issues = newTable[IssueState, seq[Issue]]()
|
||||
for state in IssueState: ctx.loadIssues(state)
|
||||
|
||||
proc filterIssues(ctx: CliContext, filter: IssueFilter) =
|
||||
for state, issueList in ctx.issues:
|
||||
ctx.issues[state] = issueList.filter(filter)
|
||||
|
||||
proc parsePropertiesOption(propsOpt: string): TableRef[string, string] =
|
||||
result = newTable[string, string]()
|
||||
for propText in propsOpt.split(";"):
|
||||
@ -21,21 +162,21 @@ proc parsePropertiesOption(propsOpt: string): TableRef[string, string] =
|
||||
if pair.len == 1: result[pair[0]] = "true"
|
||||
else: result[pair[0]] = pair[1]
|
||||
|
||||
proc parseExclPropertiesOption(propsOpt: string): TableRef[string, seq[string]] =
|
||||
result = newTable[string, seq[string]]()
|
||||
for propText in propsOpt.split(";"):
|
||||
let pair = propText.split(":", 1)
|
||||
let val =
|
||||
if pair.len == 1: "true"
|
||||
else: pair[1]
|
||||
if result.hasKey(pair[0]): result[pair[0]].add(val)
|
||||
else: result[pair[0]] = @[val]
|
||||
proc sameDay(a, b: DateTime): bool =
|
||||
result = a.year == b.year and a.yearday == b.yearday
|
||||
|
||||
proc writeHeader(ctx: CliContext, header: string) =
|
||||
stdout.setForegroundColor(fgRed, true)
|
||||
stdout.writeLine('_'.repeat(ctx.termWidth))
|
||||
stdout.writeLine(header.center(ctx.termWidth))
|
||||
stdout.writeLine('~'.repeat(ctx.termWidth))
|
||||
stdout.resetAttributes
|
||||
|
||||
proc reorder(ctx: CliContext, state: IssueState) =
|
||||
|
||||
# load the issues to make sure the order file contains all issues in the state.
|
||||
ctx.loadIssues(state)
|
||||
discard os.execShellCmd(EDITOR & " '" & (ctx.cfg.tasksDir / $state / "order.txt") & "' </dev/tty >/dev/tty")
|
||||
discard os.execShellCmd(EDITOR & " '" & (ctx.tasksDir / $state / "order.txt") & "' </dev/tty >/dev/tty")
|
||||
|
||||
proc edit(issue: Issue) =
|
||||
|
||||
@ -48,44 +189,124 @@ proc edit(issue: Issue) =
|
||||
# Try to parse the newly-edited issue to make sure it was successful.
|
||||
let editedIssue = loadIssue(issue.filepath)
|
||||
editedIssue.store()
|
||||
except CatchableError:
|
||||
fatal "updated issue is invalid (ignoring edits): \n\t" &
|
||||
except:
|
||||
fatal "pit: updated issue is invalid (ignoring edits): \n\t" &
|
||||
getCurrentExceptionMsg()
|
||||
issue.store()
|
||||
|
||||
when isMainModule:
|
||||
try:
|
||||
proc list(ctx: CliContext, filter: Option[IssueFilter], state: Option[IssueState], showToday, showFuture, verbose: bool) =
|
||||
|
||||
let consoleLogger = newConsoleLogger(
|
||||
levelThreshold=lvlInfo,
|
||||
fmtStr="pit - $levelname: ")
|
||||
logging.addHandler(consoleLogger)
|
||||
if state.isSome:
|
||||
ctx.loadIssues(state.get)
|
||||
if filter.isSome: ctx.filterIssues(filter.get)
|
||||
stdout.write ctx.formatSection(ctx.issues[state.get], state.get, "", verbose)
|
||||
return
|
||||
|
||||
ctx.loadAllIssues()
|
||||
if filter.isSome: ctx.filterIssues(filter.get)
|
||||
|
||||
let today = showToday and [Current, TodoToday].anyIt(
|
||||
ctx.issues.hasKey(it) and ctx.issues[it].len > 0)
|
||||
|
||||
let future = showFuture and [Pending, Todo].anyIt(
|
||||
ctx.issues.hasKey(it) and ctx.issues[it].len > 0)
|
||||
|
||||
let indent = if today and future: " " else: ""
|
||||
|
||||
# Today's items
|
||||
if today:
|
||||
if future: ctx.writeHeader("Today")
|
||||
|
||||
for s in [Current, TodoToday]:
|
||||
if ctx.issues.hasKey(s) and ctx.issues[s].len > 0:
|
||||
stdout.write ctx.formatSection(ctx.issues[s], s, indent, verbose)
|
||||
|
||||
if ctx.issues.hasKey(Done):
|
||||
let doneIssues = ctx.issues[Done].filterIt(
|
||||
it.hasProp("completed") and
|
||||
sameDay(getTime().local, it.getDateTime("completed")))
|
||||
if doneIssues.len > 0:
|
||||
stdout.write ctx.formatSection(doneIssues, Done, indent, verbose)
|
||||
|
||||
# Future items
|
||||
if future:
|
||||
if today: ctx.writeHeader("Future")
|
||||
|
||||
for s in [Pending, Todo]:
|
||||
if ctx.issues.hasKey(s) and ctx.issues[s].len > 0:
|
||||
stdout.write ctx.formatSection(ctx.issues[s], s, indent, verbose)
|
||||
|
||||
when isMainModule:
|
||||
|
||||
try:
|
||||
let doc = """
|
||||
Usage:
|
||||
pit ( new | add) <summary> [<state>] [options]
|
||||
pit list [<listable>] [options]
|
||||
pit ( start | done | pending | todo-today | todo | suspend ) <id>... [options]
|
||||
pit edit <ref>...
|
||||
pit tag <id>... [options]
|
||||
pit untag <id>... [options]
|
||||
pit reorder <state>
|
||||
pit delegate <id> <delegated-to>
|
||||
pit ( delete | rm ) <id>...
|
||||
|
||||
Options:
|
||||
|
||||
-h, --help Print this usage information.
|
||||
|
||||
-p, --properties <props> Specify properties. Formatted as "key:val;key:val"
|
||||
When used with the list command this option applies
|
||||
a filter to the issues listed, only allowing those
|
||||
which have all of the given properties.
|
||||
|
||||
-c, --context <ctxName> Shorthand for '-p context:<ctxName>'
|
||||
|
||||
-g, --tags <tags> Specify tags for an issue.
|
||||
|
||||
-T, --today Limit to today's issues.
|
||||
|
||||
-F, --future Limit to future issues.
|
||||
|
||||
-m, --match <pattern> Limit to issues whose summaries match the given
|
||||
pattern (PCRE regex supported).
|
||||
|
||||
-M, --match-all <pat> Limit to the issues whose summaries or details
|
||||
match the given pattern (PCRE regex supported).
|
||||
|
||||
-v, --verbose Show issue details when listing issues.
|
||||
|
||||
-q, --quiet Suppress verbose output.
|
||||
|
||||
-y, --yes Automatically answer "yes" to any prompts.
|
||||
|
||||
-C, --config <cfgFile> Location of the config file (defaults to $HOME/.pitrc)
|
||||
|
||||
-E, --echo-args Echo arguments (for debug purposes).
|
||||
|
||||
-d, --tasks-dir Path to the tasks directory (defaults to the value
|
||||
configured in the .pitrc file)
|
||||
|
||||
--term-width <width> Manually set the terminal width to use.
|
||||
|
||||
--ptk Enable PTK integration for this command.
|
||||
"""
|
||||
|
||||
logging.addHandler(newConsoleLogger())
|
||||
|
||||
# Parse arguments
|
||||
let args = docopt(USAGE, version = PIT_VERSION)
|
||||
|
||||
if args["--debug"]:
|
||||
consoleLogger.levelThreshold = lvlDebug
|
||||
|
||||
if args["--silent"]:
|
||||
consoleLogger.levelThreshold = lvlNone
|
||||
let args = docopt(doc, version = PIT_VERSION)
|
||||
|
||||
if args["--echo-args"]: stderr.writeLine($args)
|
||||
|
||||
if args["help"]:
|
||||
stderr.writeLine(USAGE & "\p")
|
||||
stderr.writeLine(ONLINE_HELP)
|
||||
if args["--help"]:
|
||||
stderr.writeLine(doc)
|
||||
quit()
|
||||
|
||||
let ctx = initContext(args)
|
||||
|
||||
trace "context initiated"
|
||||
|
||||
var updatedIssues = newSeq[Issue]()
|
||||
var propertiesOption = none(TableRef[string,string])
|
||||
var exclPropsOption = none(TableRef[string,seq[string]])
|
||||
var tagsOption = none(seq[string])
|
||||
var exclTagsOption = none(seq[string])
|
||||
|
||||
if args["--properties"] or args["--context"]:
|
||||
|
||||
@ -97,25 +318,8 @@ when isMainModule:
|
||||
|
||||
propertiesOption = some(props)
|
||||
|
||||
if args["--excl-properties"] or args["--excl-context"]:
|
||||
|
||||
var exclProps =
|
||||
if args["--excl-properties"]:
|
||||
parseExclPropertiesOption($args["--excl-properties"])
|
||||
else: newTable[string,seq[string]]()
|
||||
|
||||
if args["--excl-context"]:
|
||||
if not exclProps.hasKey("context"): exclProps["context"] = @[]
|
||||
let exclContexts = split($args["--excl-context"], ",")
|
||||
exclProps["context"] = exclProps["context"].concat(exclContexts)
|
||||
|
||||
exclPropsOption = some(exclProps)
|
||||
|
||||
if args["--tags"]: tagsOption = some(($args["--tags"]).split(",").mapIt(it.strip))
|
||||
|
||||
if args["--excl-tags"]: exclTagsOption =
|
||||
some(($args["--excl-tags"]).split(",").mapIt(it.strip))
|
||||
|
||||
## Actual command runners
|
||||
if args["new"] or args["add"]:
|
||||
let state =
|
||||
@ -133,12 +337,12 @@ when isMainModule:
|
||||
summary: $args["<summary>"],
|
||||
properties: issueProps,
|
||||
tags:
|
||||
if tagsOption.isSome: tagsOption.get
|
||||
if args["--tags"]: ($args["--tags"]).split(",").mapIt(it.strip)
|
||||
else: newSeq[string]())
|
||||
|
||||
ctx.cfg.tasksDir.store(issue, state)
|
||||
updatedIssues.add(issue)
|
||||
stdout.writeLine formatIssue(issue)
|
||||
ctx.tasksDir.store(issue, state)
|
||||
|
||||
stdout.writeLine ctx.formatIssue(issue)
|
||||
|
||||
elif args["reorder"]:
|
||||
ctx.reorder(parseEnum[IssueState]($args["<state>"]))
|
||||
@ -146,58 +350,40 @@ when isMainModule:
|
||||
elif args["edit"]:
|
||||
for editRef in @(args["<ref>"]):
|
||||
|
||||
let propsOption =
|
||||
if args["--properties"]:
|
||||
some(parsePropertiesOption($args["--properties"]))
|
||||
else: none(TableRef[string, string])
|
||||
|
||||
var stateOption = none(IssueState)
|
||||
|
||||
try: stateOption = some(parseEnum[IssueState](editRef))
|
||||
except CatchableError: discard
|
||||
except: discard
|
||||
|
||||
if stateOption.isSome:
|
||||
let state = stateOption.get
|
||||
ctx.loadIssues(state)
|
||||
for issue in ctx.issues[state]:
|
||||
if propsOption.isSome:
|
||||
for k,v in propsOption.get:
|
||||
issue[k] = v
|
||||
edit(issue)
|
||||
updatedIssues.add(issue)
|
||||
for issue in ctx.issues[state]: edit(issue)
|
||||
|
||||
else:
|
||||
let issue = ctx.cfg.tasksDir.loadIssueById(editRef)
|
||||
if propertiesOption.isSome:
|
||||
for k,v in propertiesOption.get:
|
||||
issue[k] = v
|
||||
edit(issue)
|
||||
updatedIssues.add(issue)
|
||||
else: edit(ctx.tasksDir.loadIssueById(editRef))
|
||||
|
||||
elif args["tag"]:
|
||||
if tagsOption.isNone: raise newException(Exception, "no tags given")
|
||||
if not args["--tags"]: raise newException(Exception, "no tags given")
|
||||
|
||||
let newTags = tagsOption.get
|
||||
let newTags = ($args["--tags"]).split(",").mapIt(it.strip)
|
||||
|
||||
for id in @(args["<id>"]):
|
||||
var issue = ctx.cfg.tasksDir.loadIssueById(id)
|
||||
var issue = ctx.tasksDir.loadIssueById(id)
|
||||
issue.tags = deduplicate(issue.tags & newTags)
|
||||
issue.store()
|
||||
updatedIssues.add(issue)
|
||||
|
||||
elif args["untag"]:
|
||||
let tagsToRemove: seq[string] =
|
||||
if tagsOption.isSome: tagsOption.get
|
||||
if args["--tags"]: ($args["--tags"]).split(",").mapIt(it.strip)
|
||||
else: @[]
|
||||
|
||||
for id in @(args["<id>"]):
|
||||
var issue = ctx.cfg.tasksDir.loadIssueById(id)
|
||||
var issue = ctx.tasksDir.loadIssueById(id)
|
||||
if tagsToRemove.len > 0:
|
||||
issue.tags = issue.tags.filter(
|
||||
proc (tag: string): bool = not tagsToRemove.anyIt(it == tag))
|
||||
else: issue.tags = @[]
|
||||
issue.store()
|
||||
updatedIssues.add(issue)
|
||||
|
||||
elif args["start"] or args["todo-today"] or args["done"] or
|
||||
args["pending"] or args["todo"] or args["suspend"]:
|
||||
@ -211,60 +397,41 @@ when isMainModule:
|
||||
elif args["suspend"]: targetState = Dormant
|
||||
|
||||
for id in @(args["<id>"]):
|
||||
var issue = ctx.cfg.tasksDir.loadIssueById(id)
|
||||
var issue = ctx.tasksDir.loadIssueById(id)
|
||||
if propertiesOption.isSome:
|
||||
for k,v in propertiesOption.get:
|
||||
issue[k] = v
|
||||
if targetState == Done:
|
||||
issue["completed"] = getTime().local.formatIso8601
|
||||
if issue.hasProp("recurrence") and issue.getRecurrence.isSome:
|
||||
let nextIssue = ctx.cfg.tasksDir.nextRecurrence(issue.getRecurrence.get, issue)
|
||||
ctx.cfg.tasksDir.store(nextIssue, TodoToday)
|
||||
info "created the next recurrence:"
|
||||
updatedIssues.add(nextIssue)
|
||||
stdout.writeLine formatIssue(nextIssue)
|
||||
|
||||
|
||||
issue.changeState(ctx.cfg.tasksDir, targetState)
|
||||
updatedIssues.add(issue)
|
||||
if targetState == Done: issue["completed"] = getTime().local.formatIso8601
|
||||
issue.changeState(ctx.tasksDir, targetState)
|
||||
|
||||
if ctx.triggerPtk or args["--ptk"]:
|
||||
if targetState == Current:
|
||||
let issue = ctx.cfg.tasksDir.loadIssueById($(args["<id>"][0]))
|
||||
let issue = ctx.tasksDir.loadIssueById($(args["<id>"][0]))
|
||||
var cmd = "ptk start"
|
||||
if issue.tags.len > 0 or issue.hasProp("context"):
|
||||
if issue.tags.len > 0 or issue.properties.hasKey("context"):
|
||||
let tags = concat(
|
||||
issue.tags,
|
||||
if issue.hasProp("context"): @[issue.properties["context"]]
|
||||
if issue.properties.hasKey("context"): @[issue.properties["context"]]
|
||||
else: @[]
|
||||
)
|
||||
cmd &= " -g \"" & tags.join(",") & "\""
|
||||
cmd &= " -n \"pit-id: " & $issue.id & "\""
|
||||
cmd &= " \"[" & ($issue.id)[0..<6] & "] " & issue.summary & "\""
|
||||
cmd &= " \"" & issue.summary & "\""
|
||||
discard execShellCmd(cmd)
|
||||
elif targetState == Done or targetState == Pending:
|
||||
discard execShellCmd("ptk stop")
|
||||
|
||||
elif args["hide-until"]:
|
||||
|
||||
let issue = ctx.cfg.tasksDir.loadIssueById($(args["<id>"]))
|
||||
issue.setDateTime("hide-until", parseDate($args["<date>"]))
|
||||
|
||||
issue.store()
|
||||
updatedIssues.add(issue)
|
||||
|
||||
elif args["delegate"]:
|
||||
|
||||
let issue = ctx.cfg.tasksDir.loadIssueById($(args["<id>"]))
|
||||
let issue = ctx.tasksDir.loadIssueById($(args["<id>"]))
|
||||
issue["delegated-to"] = $args["<delegated-to>"]
|
||||
|
||||
issue.store()
|
||||
updatedIssues.add(issue)
|
||||
|
||||
elif args["delete"] or args["rm"]:
|
||||
for id in @(args["<id>"]):
|
||||
|
||||
let issue = ctx.cfg.tasksDir.loadIssueById(id)
|
||||
let issue = ctx.tasksDir.loadIssueById(id)
|
||||
|
||||
if not args["--yes"]:
|
||||
stderr.write("Delete '" & issue.summary & "' (y/n)? ")
|
||||
@ -272,7 +439,6 @@ when isMainModule:
|
||||
continue
|
||||
|
||||
issue.delete
|
||||
updatedIssues.add(issue)
|
||||
|
||||
elif args["list"]:
|
||||
|
||||
@ -284,11 +450,6 @@ when isMainModule:
|
||||
filter.properties = propertiesOption.get
|
||||
filterOption = some(filter)
|
||||
|
||||
# Add property exclusions (if given)
|
||||
if exclPropsOption.isSome:
|
||||
filter.exclProperties = exclPropsOption.get
|
||||
filterOption = some(filter)
|
||||
|
||||
# If they supplied text matches, add that to the filter.
|
||||
if args["--match"]:
|
||||
filter.summaryMatch = some(re("(?i)" & $args["--match"]))
|
||||
@ -304,35 +465,21 @@ when isMainModule:
|
||||
filter.properties["context"] = ctx.defaultContext.get
|
||||
filterOption = some(filter)
|
||||
|
||||
if tagsOption.isSome:
|
||||
filter.hasTags = tagsOption.get
|
||||
filterOption = some(filter)
|
||||
|
||||
if exclTagsOption.isSome:
|
||||
filter.exclTags = exclTagsOption.get
|
||||
filterOption = some(filter)
|
||||
|
||||
# Finally, if the "context" is "all", don't filter on context
|
||||
if filter.properties.hasKey("context") and
|
||||
filter.properties["context"] == "all":
|
||||
|
||||
filter.properties.del("context")
|
||||
filter.exclProperties.del("context")
|
||||
|
||||
var listContexts = false
|
||||
var listTags = false
|
||||
var statesOption = none(seq[IssueState])
|
||||
var issueIdsOption = none(seq[string])
|
||||
var stateOption = none(IssueState)
|
||||
var issueIdOption = none(string)
|
||||
|
||||
if args["contexts"]: listContexts = true
|
||||
elif args["tags"]: listTags = true
|
||||
elif args["<stateOrId>"]:
|
||||
try:
|
||||
statesOption =
|
||||
some(args["<stateOrId>"].
|
||||
mapIt(parseEnum[IssueState]($it)))
|
||||
except CatchableError:
|
||||
issueIdsOption = some(args["<stateOrId>"].mapIt($it))
|
||||
if args["<listable>"]:
|
||||
if $args["<listable>"] == "contexts": listContexts = true
|
||||
else:
|
||||
try: stateOption = some(parseEnum[IssueState]($args["<listable>"]))
|
||||
except: issueIdOption = some($args["<listable>"])
|
||||
|
||||
# List the known contexts
|
||||
if listContexts:
|
||||
@ -343,110 +490,21 @@ when isMainModule:
|
||||
if issue.hasProp("context") and not uniqContexts.contains(issue["context"]):
|
||||
uniqContexts.add(issue["context"])
|
||||
|
||||
let maxLen = foldl(uniqContexts,
|
||||
if a.len > b.len: a
|
||||
else: b
|
||||
).len
|
||||
|
||||
for c in uniqContexts.sorted:
|
||||
stdout.writeLine(c.alignLeft(maxLen+2) & ctx.getIssueContextDisplayName(c))
|
||||
|
||||
elif listTags:
|
||||
var uniqTags = newseq[string]()
|
||||
if statesOption.isSome:
|
||||
for state in statesOption.get: ctx.loadIssues(state)
|
||||
else: ctx.loadAllIssues()
|
||||
|
||||
if filterOption.isSome: ctx.filterIssues(filterOption.get)
|
||||
|
||||
for state, issueList in ctx.issues:
|
||||
for issue in issueList:
|
||||
for tag in issue.tags:
|
||||
if not uniqTags.contains(tag): uniqTags.add(tag)
|
||||
|
||||
stdout.writeLine(uniqTags.sorted.join("\n"))
|
||||
for c in uniqContexts: stdout.writeLine(c)
|
||||
|
||||
# List a specific issue
|
||||
elif issueIdsOption.isSome:
|
||||
for issueId in issueIdsOption.get:
|
||||
let issue = ctx.cfg.tasksDir.loadIssueById(issueId)
|
||||
stdout.writeLine formatIssue(issue)
|
||||
elif issueIdOption.isSome:
|
||||
let issue = ctx.tasksDir.loadIssueById(issueIdOption.get)
|
||||
stdout.writeLine ctx.formatIssue(issue)
|
||||
|
||||
# List all issues
|
||||
else:
|
||||
trace "listing all issues"
|
||||
let showBoth = args["--today"] == args["--future"]
|
||||
ctx.list(
|
||||
filter = filterOption,
|
||||
states = statesOption,
|
||||
showToday = showBoth or args["--today"],
|
||||
showFuture = showBoth or args["--future"],
|
||||
showHidden = args["--show-hidden"],
|
||||
verbose = ctx.verbose)
|
||||
ctx.list(filterOption, stateOption, showBoth or args["--today"],
|
||||
showBoth or args["--future"],
|
||||
ctx.verbose)
|
||||
|
||||
elif args["add-binary-property"]:
|
||||
let issue = ctx.cfg.tasksDir.loadIssueById($(args["<id>"]))
|
||||
|
||||
let propIn =
|
||||
if $(args["<propSource>"]) == "-": stdin
|
||||
else: open($(args["<propSource>"]))
|
||||
|
||||
try: issue[$(args["<propName>"])] = encodeAsDataUri(readAll(propIn))
|
||||
finally: close(propIn)
|
||||
|
||||
issue.store()
|
||||
updatedIssues.add(issue)
|
||||
|
||||
elif args["get-binary-property"]:
|
||||
let issue = ctx.cfg.tasksDir.loadIssueById($(args["<id>"]))
|
||||
|
||||
if not issue.hasProp($(args["<propName>"])):
|
||||
raise newException(Exception,
|
||||
"issue " & ($issue.id)[0..<6] & " has no property name '" &
|
||||
$(args["<propName>"]) & "'")
|
||||
|
||||
let propOut =
|
||||
if $(args["<propDest>"]) == "-": stdout
|
||||
else: open($(args["<propDest>"]), fmWrite)
|
||||
|
||||
try: write(propOut, decodeDataUri(issue[$(args["<propName>"])]))
|
||||
finally: close(propOut)
|
||||
|
||||
elif args["show-dupes"]:
|
||||
ctx.loadAllIssues()
|
||||
|
||||
var idsToPaths = newTable[string, var seq[string]]()
|
||||
for (state, issues) in pairs(ctx.issues):
|
||||
for issue in issues:
|
||||
let issueId = $issue.id
|
||||
|
||||
if idsToPaths.hasKey(issueId): idsToPaths[issueId].add(issue.filepath)
|
||||
else: idsToPaths[issueId] = @[issue.filepath]
|
||||
|
||||
for (issueId, issuePaths) in pairs(idsToPaths):
|
||||
if issuePaths.len < 2: continue
|
||||
stdout.writeLine(issueId & ":\p " & issuePaths.join("\p ") & "\p\p")
|
||||
|
||||
elif args["sync"]:
|
||||
if ctx.cfg.syncTargets.len == 0:
|
||||
info "No sync targets configured"
|
||||
|
||||
for syncTarget in ctx.cfg.syncTargets:
|
||||
let syncCtx = initSyncContext(ctx.cfg, syncTarget)
|
||||
|
||||
sync(syncCtx, args["--dry-run"])
|
||||
|
||||
# after doing stuff, sync if auto-sync is requested
|
||||
if ctx.cfg.autoSync:
|
||||
for syncTarget in ctx.cfg.syncTargets:
|
||||
let syncCtx = initSyncContext(ctx.cfg, syncTarget)
|
||||
if anyIt(
|
||||
updatedIssues,
|
||||
it.hasProp("context") and it["context"] == syncCtx.issueContext):
|
||||
sync(syncCtx, false)
|
||||
|
||||
except CatchableError:
|
||||
fatal getCurrentExceptionMsg()
|
||||
debug getCurrentException().getStackTrace()
|
||||
except:
|
||||
fatal "pit: " & getCurrentExceptionMsg()
|
||||
#raise getCurrentException()
|
||||
quit(QuitFailure)
|
||||
|
||||
@ -1,194 +0,0 @@
|
||||
const PIT_VERSION* = "4.29.1"
|
||||
|
||||
const USAGE* = """Usage:
|
||||
pit ( new | add) <summary> [<state>] [options]
|
||||
pit list contexts [options]
|
||||
pit list tags [options]
|
||||
pit list [<stateOrId>...] [options]
|
||||
pit ( start | done | pending | todo-today | todo | suspend ) <id>... [options]
|
||||
pit edit <ref>... [options]
|
||||
pit tag <id>... [options]
|
||||
pit untag <id>... [options]
|
||||
pit reorder <state> [options]
|
||||
pit delegate <id> <delegated-to> [options]
|
||||
pit hide-until <id> <date> [options]
|
||||
pit ( delete | rm ) <id>... [options]
|
||||
pit add-binary-property <id> <propName> <propSource> [options]
|
||||
pit get-binary-property <id> <propName> <propDest> [options]
|
||||
pit show-dupes
|
||||
pit sync [<syncTarget>...] [options]
|
||||
pit help [options]
|
||||
|
||||
Options:
|
||||
|
||||
-h, --help Print this usage and help information.
|
||||
|
||||
-p, --properties <props> Specify properties. Formatted as "key:val;key:val"
|
||||
When used with the list command this option applies
|
||||
a filter to the issues listed, only allowing those
|
||||
which have all of the given properties.
|
||||
|
||||
-P, --excl-properties <props>
|
||||
When used with the list command, exclude issues
|
||||
that contain properties with the given value. This
|
||||
parameter is formatted the same as the --properties
|
||||
parameter: "key:val;key:val"
|
||||
|
||||
-c, --context <ctx> Shorthand for '-p context:<ctx>'
|
||||
|
||||
-C, --excl-context <ctx> Don't show issues from the given context(s).
|
||||
Multiple contexts can be excluded using a ',' to
|
||||
separate names. For example: -C ctx1,ctx2
|
||||
Shorthand for '-P context:<ctx>'
|
||||
|
||||
-g, --tags <tags> Specify tags for an issue. Tags are specified as a
|
||||
comma-delimited list. For example: -g tag1,tag2
|
||||
|
||||
-G, --excl-tags <tags> When used with the list command, exclude issues
|
||||
that contain any of the provided tags. Tags are
|
||||
specified as a comma-delimited list.
|
||||
For example: -G tag1,tag2
|
||||
|
||||
-T, --today Limit to today's issues.
|
||||
|
||||
-F, --future Limit to future issues.
|
||||
|
||||
-H, --show-hidden Show all matching issues, ignoring any 'hide-until'
|
||||
properties set.
|
||||
|
||||
-m, --match <pattern> Limit to issues whose summaries match the given
|
||||
pattern (PCRE regex supported).
|
||||
|
||||
-M, --match-all <pat> Limit to the issues whose summaries or details
|
||||
match the given pattern (PCRE regex supported).
|
||||
|
||||
-v, --verbose Show issue details when listing issues.
|
||||
|
||||
-q, --quiet Suppress verbose output.
|
||||
|
||||
-y, --yes Automatically answer "yes" to any prompts.
|
||||
|
||||
--config <cfgFile> Location of the config file (defaults to $HOME/.pitrc)
|
||||
|
||||
-E, --echo-args Echo arguments (for debug purposes).
|
||||
|
||||
-d, --tasks-dir Path to the tasks directory (defaults to the value
|
||||
configured in the .pitrc file)
|
||||
|
||||
--ptk Enable PTK integration for this command.
|
||||
|
||||
--debug Enable debug-level log output.
|
||||
|
||||
--dry-run Currently only supported by the `sync` command:
|
||||
only print the changes that would be made, but do
|
||||
not actually make them.
|
||||
|
||||
-s, --silent Suppress all logging and status output.
|
||||
"""
|
||||
|
||||
const ONLINE_HELP* = """Issue States:
|
||||
|
||||
PIT organizes issues around their state, which is one of:
|
||||
|
||||
current - issues actively being worked
|
||||
todo-today - issues planned for today
|
||||
pending - issues that are blocked by some third-party
|
||||
done - issues that have been completely resolved
|
||||
todo - issues that need to be done in the future
|
||||
dormant - issues that are low-priority, to be tracked, but hidden
|
||||
by default
|
||||
|
||||
Issue Properties:
|
||||
|
||||
PIT supports adding arbitrary properties to any issue to track any metadata
|
||||
about the issue the user may wish. There are several properties that have
|
||||
special behavior attached to them. They are:
|
||||
|
||||
created
|
||||
|
||||
If present, expected to be an ISO 8601-formatted date that represents the
|
||||
time when the issue was created. E.g.:
|
||||
|
||||
created: 2023-07-13T13:28:41-05:00
|
||||
|
||||
completed
|
||||
|
||||
If present, expected to be an ISO 8601-formatted date that represents the
|
||||
time when the issue moved to the "done" state. PIT will add this
|
||||
property automatically when you use the "done" command, and can filter on
|
||||
this value.
|
||||
|
||||
completed: 2023-04-27T11:52:28-05:00
|
||||
|
||||
context
|
||||
|
||||
Allows issues to be organized into contexts. The -c option is short-hand
|
||||
for '-p context:<context-name>' and the 'list contexts' command will show
|
||||
all values of 'context' set in existing issues.
|
||||
|
||||
context: family
|
||||
|
||||
delegated-to
|
||||
|
||||
When an issue now belongs to someone else, but needs to be monitored for
|
||||
completion, this allows you to keep the issue in its current state but
|
||||
note how it has been delegated. When present PIT will prepend this value
|
||||
to the issue summary with an accent color.
|
||||
|
||||
delegated-to: Bob Ross
|
||||
|
||||
hide-until
|
||||
|
||||
When present, expected to be an ISO 8601-formatted date and used to
|
||||
supress the display of the issue until on or after the given date.
|
||||
|
||||
hide-until: 2024-01-01T13:45:00-05:00
|
||||
|
||||
pending
|
||||
|
||||
When an issue is blocked by a third party, this property can be used to
|
||||
capture details about the dependency When present PIT will display this
|
||||
value after the issue summary.
|
||||
|
||||
pending: Results of WCAG analysis.
|
||||
|
||||
recurrence
|
||||
|
||||
When an issue is moved to the "done" state, if the issue has a valid
|
||||
"recurrence" property, PIT will create a new issue and set the
|
||||
"hide-until" property for that new issue depending on the recurrence
|
||||
definition.
|
||||
|
||||
A valid recurrence value has a time value and optionally has an source
|
||||
issue ID. For example:
|
||||
|
||||
recurrence: every 5 days, 10a544
|
||||
|
||||
The first word, "every", is expected to be either "every" or "after".
|
||||
|
||||
The second portion is expected to be a time period. Supported time units
|
||||
are "hour", "day", "week", "month", an "year", along with the plural
|
||||
forms (e.g. "5 days", "8 hours", etc.).
|
||||
|
||||
The final portion is the source issue ID. This is optional. When a source
|
||||
issue ID is given, the new issue is created as a clone of the given
|
||||
issue. When not given, the issue being closed is used for cloning.
|
||||
|
||||
The "every" and "after" keywords allow the user to choose whether the new
|
||||
issue is created based on the creation time ("every") or the completion
|
||||
time ("after") of the issue being closed based.
|
||||
|
||||
Examples:
|
||||
|
||||
every day
|
||||
every 2 days
|
||||
after 2 days
|
||||
every week
|
||||
after 12 hours
|
||||
every 2 weeks, 10a544
|
||||
|
||||
tags
|
||||
|
||||
If present, expected to be a comma-delimited list of text tags. The -g
|
||||
option is a short-hand for '-p tags:<tags-value>'.
|
||||
"""
|
||||
@ -1,251 +0,0 @@
|
||||
import std/[options, sequtils, wordwrap, tables, terminal, times, unicode, wordwrap]
|
||||
import cliutils, uuids
|
||||
import std/strutils except alignLeft, capitalize, strip, toLower, toUpper
|
||||
import ./libpit
|
||||
|
||||
proc adjustedTerminalWidth(): int = min(terminalWidth(), 80)
|
||||
|
||||
proc getIssueContextDisplayName*(ctx: CliContext, context: string): string =
|
||||
if not ctx.contexts.hasKey(context):
|
||||
if context.isEmptyOrWhitespace: return "<default>"
|
||||
else: return context.capitalize()
|
||||
return ctx.contexts[context]
|
||||
|
||||
|
||||
proc formatIssue*(issue: Issue): string =
|
||||
result = ($issue.id).withColor(fgBlack, true) & "\n"&
|
||||
issue.summary.withColor(fgWhite) & "\n"
|
||||
|
||||
if issue.tags.len > 0:
|
||||
result &= "tags: ".withColor(fgMagenta) &
|
||||
issue.tags.join(",").withColor(fgGreen, true) & "\n"
|
||||
|
||||
if issue.properties.len > 0:
|
||||
result &= termColor(fgMagenta)
|
||||
for k, v in issue.properties: result &= k & ": " & v & "\n"
|
||||
|
||||
|
||||
result &= "--------".withColor(fgBlack, true) & "\n"
|
||||
if not issue.details.isEmptyOrWhitespace:
|
||||
result &= issue.details.strip.withColor(fgCyan) & "\n"
|
||||
|
||||
result &= termReset
|
||||
|
||||
|
||||
proc formatPlainIssueSummary*(issue: Issue): string =
|
||||
|
||||
result = "$#: $# $#" % [
|
||||
$issue.state,
|
||||
($issue.id)[0..<6],
|
||||
issue.summary ]
|
||||
|
||||
if issue.hasProp("delegated-to") or issue.hasProp("pending"):
|
||||
var parts = newSeq[string]()
|
||||
|
||||
if issue.hasProp("delegated-to"):
|
||||
parts.add("delegated to " & issue["delegated-to"])
|
||||
|
||||
if issue.hasProp("pending"):
|
||||
parts.add("pendin: " & issue["pending"])
|
||||
|
||||
result &= "($#)" % [ parts.join("; ") ]
|
||||
|
||||
|
||||
proc formatSectionIssue*(
|
||||
issue: Issue,
|
||||
width: int = 80,
|
||||
indent = "",
|
||||
verbose = false): string =
|
||||
|
||||
result = (indent & ($issue.id)[0..<6]).withColor(fgBlack, true) & " "
|
||||
|
||||
let showDetails = not issue.details.isEmptyOrWhitespace and verbose
|
||||
|
||||
let summaryIndentLen = indent.len + 7
|
||||
let summaryWidth = width - summaryIndentLen
|
||||
|
||||
let summaryLines = issue.summary
|
||||
.wrapWords(summaryWidth)
|
||||
.splitLines
|
||||
|
||||
result &= summaryLines[0].withColor(fgWhite)
|
||||
|
||||
for line in summaryLines[1..^1]:
|
||||
result &= "\p" & line.indent(summaryIndentLen)
|
||||
|
||||
var lastLineLen = summaryLines[^1].len
|
||||
|
||||
if issue.hasProp("delegated-to"):
|
||||
if lastLineLen + issue["delegated-to"].len + 1 < summaryWidth:
|
||||
result &= " " & issue["delegated-to"].withColor(fgMagenta)
|
||||
lastLineLen += issue["delegated-to"].len + 1
|
||||
else:
|
||||
result &= "\p" & issue["delegated-to"]
|
||||
.withColor(fgMagenta)
|
||||
.indent(summaryIndentLen)
|
||||
lastLineLen = issue["delegated-to"].len
|
||||
|
||||
if issue.tags.len > 0:
|
||||
let tagsStrLines = ("(" & issue.tags.join(", ") & ")")
|
||||
.wrapWords(summaryWidth)
|
||||
.splitLines
|
||||
|
||||
if tagsStrLines.len == 1 and
|
||||
(lastLineLen + tagsStrLines[0].len + 1) < summaryWidth:
|
||||
result &= " " & tagsStrLines[0].withColor(fgGreen)
|
||||
lastLineLen += tagsStrLines[0].len + 1
|
||||
else:
|
||||
result &= "\p" & tagsStrLines
|
||||
.mapIt(it.indent(summaryIndentLen))
|
||||
.join("\p")
|
||||
.withColor(fgGreen)
|
||||
lastLineLen = tagsStrLines[^1].len
|
||||
|
||||
if issue.hasProp("pending"):
|
||||
result &= "\p" & ("Pending: " & issue["pending"])
|
||||
.wrapwords(summaryWidth)
|
||||
.withColor(fgCyan)
|
||||
.indent(summaryIndentLen)
|
||||
|
||||
if showDetails:
|
||||
result &= "\p" & issue.details
|
||||
.strip
|
||||
.withColor(fgBlack, bright = true)
|
||||
.indent(summaryIndentLen)
|
||||
|
||||
result &= termReset
|
||||
|
||||
|
||||
proc formatSectionIssueList*(
|
||||
issues: seq[Issue],
|
||||
width: int = 80,
|
||||
indent: string = "",
|
||||
verbose: bool = false): string =
|
||||
|
||||
result = ""
|
||||
for i in issues:
|
||||
var issueText = formatSectionIssue(i, width, indent, verbose)
|
||||
result &= issueText & "\n"
|
||||
|
||||
|
||||
proc formatSection(ctx: CliContext, issues: seq[Issue], state: IssueState,
|
||||
indent = "", verbose = false): string =
|
||||
let innerWidth = adjustedTerminalWidth() - (indent.len * 2)
|
||||
|
||||
result = termColor(fgBlue) &
|
||||
(indent & ".".repeat(innerWidth)) & "\n" &
|
||||
state.displayName.center(adjustedTerminalWidth()) & "\n\n" &
|
||||
termReset
|
||||
|
||||
let issuesByContext = issues.groupBy("context")
|
||||
|
||||
if issues.len > 5 and issuesByContext.len > 1:
|
||||
for context, ctxIssues in issuesByContext:
|
||||
|
||||
result &= termColor(fgYellow) &
|
||||
indent & ctx.getIssueContextDisplayName(context) & ":" &
|
||||
termReset & "\n\n"
|
||||
|
||||
result &= formatSectionIssueList(ctxIssues, innerWidth - 2, indent & " ", verbose)
|
||||
result &= "\n"
|
||||
|
||||
else: result &= formatSectionIssueList(issues, innerWidth, indent, verbose)
|
||||
|
||||
|
||||
proc writeHeader*(ctx: CliContext, header: string) =
|
||||
stdout.setForegroundColor(fgRed, true)
|
||||
stdout.writeLine('_'.repeat(adjustedTerminalWidth()))
|
||||
stdout.writeLine(header.center(adjustedTerminalWidth()))
|
||||
stdout.writeLine('~'.repeat(adjustedTerminalWidth()))
|
||||
stdout.resetAttributes
|
||||
|
||||
|
||||
proc list*(
|
||||
ctx: CliContext,
|
||||
filter: Option[IssueFilter],
|
||||
states: Option[seq[IssueState]],
|
||||
showToday = false,
|
||||
showFuture = false,
|
||||
showHidden = false,
|
||||
verbose: bool) =
|
||||
|
||||
if states.isSome:
|
||||
trace "listing issues for " & $states.get
|
||||
for state in states.get:
|
||||
ctx.loadIssues(state)
|
||||
if filter.isSome: ctx.filterIssues(filter.get)
|
||||
|
||||
# Show Done for just today if requested
|
||||
if state == Done and showToday:
|
||||
ctx.issues[Done] = ctx.issues[Done].filterIt(
|
||||
it.hasProp("completed") and
|
||||
sameDay(getTime().local, it.getDateTime("completed")))
|
||||
|
||||
if isatty(stdout):
|
||||
stdout.write ctx.formatSection(ctx.issues[state], state, "", verbose)
|
||||
|
||||
else:
|
||||
stdout.writeLine ctx.issues[state]
|
||||
.mapIt(formatPlainIssueSummary(it))
|
||||
.join("\n")
|
||||
|
||||
|
||||
trace "listing complete"
|
||||
return
|
||||
|
||||
ctx.loadOpenIssues()
|
||||
if filter.isSome:
|
||||
ctx.filterIssues(filter.get)
|
||||
trace "filtered issues"
|
||||
|
||||
let today = showToday and [Current, TodoToday, Pending].anyIt(
|
||||
ctx.issues.hasKey(it) and ctx.issues[it].len > 0)
|
||||
|
||||
let future = showFuture and [Pending, Todo].anyIt(
|
||||
ctx.issues.hasKey(it) and ctx.issues[it].len > 0)
|
||||
|
||||
let indent = if today and future: " " else: ""
|
||||
|
||||
# Today's items
|
||||
if today:
|
||||
if future: ctx.writeHeader("Today")
|
||||
|
||||
for s in [Current, TodoToday, Pending]:
|
||||
if ctx.issues.hasKey(s) and ctx.issues[s].len > 0:
|
||||
let visibleIssues = ctx.issues[s].filterIt(
|
||||
showHidden or
|
||||
not (it.hasProp("hide-until") and
|
||||
it.getDateTime("hide-until") > getTime().local))
|
||||
|
||||
if isatty(stdout):
|
||||
stdout.write ctx.formatSection(visibleIssues, s, indent, verbose)
|
||||
|
||||
else:
|
||||
stdout.writeLine visibleIssues
|
||||
.mapIt(formatPlainIssueSummary(it))
|
||||
.join("\n")
|
||||
|
||||
# Future items
|
||||
if future:
|
||||
if today: ctx.writeHeader("Future")
|
||||
|
||||
let futureCategories =
|
||||
if showToday: @[Todo]
|
||||
else: @[Pending, Todo]
|
||||
|
||||
for s in futureCategories:
|
||||
if ctx.issues.hasKey(s) and ctx.issues[s].len > 0:
|
||||
let visibleIssues = ctx.issues[s].filterIt(
|
||||
showHidden or
|
||||
not (it.hasProp("hide-until") and
|
||||
it.getDateTime("hide-until") > getTime().local))
|
||||
|
||||
if isatty(stdout):
|
||||
stdout.write ctx.formatSection(visibleIssues, s, indent, verbose)
|
||||
|
||||
else:
|
||||
stdout.writeLine visibleIssues
|
||||
.mapIt(formatPlainIssueSummary(it))
|
||||
.join("\n")
|
||||
|
||||
trace "listing complete"
|
||||
@ -1,179 +0,0 @@
|
||||
import std/[httpclient, json, jsonutils, logging, options, sets, strutils,
|
||||
terminal, times, tables]
|
||||
import timeutils, uuids, zero_functional
|
||||
import ./formatting, ./libpit
|
||||
|
||||
type
|
||||
PbmVsbSyncContext* = object
|
||||
apiBaseUrl*: string
|
||||
apiToken*: string
|
||||
issueContext*: string
|
||||
pit: PitConfig
|
||||
http: HttpClient
|
||||
|
||||
ServerTask* = object
|
||||
id*: string
|
||||
summary*: string
|
||||
details*: string
|
||||
state*: string
|
||||
lastUpdatedAt*: DateTime
|
||||
archivedAt*: Option[DateTime]
|
||||
tags*: seq[string]
|
||||
parent*: Option[string]
|
||||
priority*: Option[string]
|
||||
project*: Option[string]
|
||||
milestone*: Option[string]
|
||||
hideUntil*: Option[DateTime]
|
||||
|
||||
|
||||
proc `%`*(dt: DateTime): JsonNode = %(dt.formatIso8601)
|
||||
func toJsonHook(dt: DateTime): JsonNode = %(dt.formatIso8601)
|
||||
proc fromJsonHook(dt: var DateTime, n: JsonNode): void =
|
||||
dt = n.getStr.parseIso8601
|
||||
|
||||
|
||||
#func `%`*(p: Project): JsonNode = toJson(p)
|
||||
func `%`*(t: ServerTask): JsonNode = toJson(t)
|
||||
|
||||
|
||||
proc toServerTask(i: Issue): ServerTask =
|
||||
return ServerTask(
|
||||
id: $i.id,
|
||||
summary: i.summary,
|
||||
details: i.details,
|
||||
state: $i.state,
|
||||
tags: i.tags,
|
||||
lastUpdatedAt:
|
||||
if i.hasProp("last-updated"): parseIso8601(i["last-updated"])
|
||||
else: now(),
|
||||
parent:
|
||||
if i.hasProp("parent"): some(i["parent"])
|
||||
else: none[string](),
|
||||
priority:
|
||||
if i.hasProp("priority"): some(i["priority"])
|
||||
else: none[string](),
|
||||
project:
|
||||
if i.hasProp("project"): some(i["project"])
|
||||
else: none[string](),
|
||||
milestone:
|
||||
if i.hasProp("milestone"): some(i["milestone"])
|
||||
else: none[string](),
|
||||
hideUntil:
|
||||
if i.hasProp("hide-until"): some(parseIso8601(i["hide-until"]))
|
||||
else: none[DateTime]())
|
||||
|
||||
|
||||
func getOrFail(n: JsonNode, k: string): JsonNode =
|
||||
if not n.hasKey(k):
|
||||
raise newException(ValueError, "missing key '" & k & "'")
|
||||
return n[k]
|
||||
|
||||
|
||||
proc initSyncContext*(pit: PitConfig, syncConfig: JsonNode): PbmVsbSyncContext =
|
||||
result.pit = pit
|
||||
result.apiBaseUrl = syncConfig.getOrFail("apiBaseUrl").getStr
|
||||
result.apiToken = syncConfig.getOrFail("apiToken").getStr
|
||||
result.issueContext = syncConfig.getOrFail("context").getStr
|
||||
result.http = newHttpClient()
|
||||
result.http.headers = newHttpHeaders({ "Authorization": "Bearer " & result.apiToken })
|
||||
|
||||
|
||||
proc fetchServerTasks*(ctx: PbmVsbSyncContext): seq[ServerTask] =
|
||||
result = newSeq[ServerTask]()
|
||||
let url = ctx.apiBaseUrl & "/tasks"
|
||||
|
||||
debug "Fetching tasks from server:\n\t" & url
|
||||
let resp = ctx.http.get(url)
|
||||
if resp.status != "200":
|
||||
debug("Received " & resp.status & ": " & resp.body)
|
||||
raise newException(Exception, "Failed to fetch tasks from server")
|
||||
fromJson(result, parseJson(resp.body)["data"])
|
||||
|
||||
|
||||
proc updateTask*(ctx: PbmVsbSyncContext, task: ServerTask): void =
|
||||
let url = ctx.apiBaseUrl & "/task" & task.id
|
||||
let body = %task
|
||||
let resp = ctx.http.post(url, $body)
|
||||
if resp.status != "200":
|
||||
debug("Received " & resp.status & ": " & resp.body)
|
||||
raise newException(Exception, "Failed to update task " & task.id & "on server")
|
||||
|
||||
|
||||
proc updateTasks*(ctx: PbmVsbSyncContext, tasks: seq[ServerTask]): void =
|
||||
let url = ctx.apiBaseUrl & "/tasks"
|
||||
let body = %tasks
|
||||
let resp = ctx.http.put(url, $body)
|
||||
if resp.status != "200":
|
||||
debug("Received " & resp.status & ": " & resp.body)
|
||||
raise newException(Exception, "Failed to update tasks on server")
|
||||
|
||||
|
||||
proc deleteTask*(ctx: PbmVsbSyncContext, taskId: string): void =
|
||||
let url = ctx.apiBaseUrl & "/tasks/" & taskId
|
||||
let resp = ctx.http.delete(url)
|
||||
if resp.status != "200":
|
||||
debug("Received " & resp.status & ": " & resp.body)
|
||||
raise newException(Exception, "Failed to delete task " & taskId & " on server")
|
||||
|
||||
|
||||
proc sync*(
|
||||
ctx: PbmVsbSyncContext,
|
||||
dryRun = true,
|
||||
batchSize = 100): void =
|
||||
|
||||
# We're going to do a uni-directional sync, pushing local issues to the
|
||||
# server. However, we only want to update issues that have changed since
|
||||
# the last sync based on the *last-updated* property.
|
||||
|
||||
# Note that all the logic assumes the server only has one context of tasks.
|
||||
# If this ever changes, this logic will need to change.
|
||||
let filter = propsFilter(newTable({ "context": ctx.issueContext }))
|
||||
let allIssues = ctx.pit.tasksDir.loadAllIssues()
|
||||
|
||||
var issues = newSeq[Issue]()
|
||||
for state in allIssues.keys:
|
||||
issues.add(allIssues[state].filter(filter))
|
||||
|
||||
let serverTasks = fetchServerTasks(ctx)
|
||||
debug "Loaded $# server tasks" % [$serverTasks.len]
|
||||
var issuesToPush = newSeq[ServerTask]()
|
||||
|
||||
var unmatchedServerTaskIds = toHashSet(serverTasks --> map(it.id))
|
||||
|
||||
# Process all local issues
|
||||
info "Updating the following tasks for context " & ctx.issueContext
|
||||
for lentIssue in issues:
|
||||
let i = lentIssue
|
||||
let foundTask = serverTasks --> find(it.id == $i.id)
|
||||
|
||||
if foundTask.isSome:
|
||||
# There is a server task for this issue
|
||||
unmatchedServerTaskIds.excl(foundTask.get.id)
|
||||
|
||||
if i.hasProp("last-updated"):
|
||||
var localUpdate = parseIso8601(i["last-updated"])
|
||||
localUpdate.nanosecond = 0
|
||||
if foundTask.get.lastUpdatedAt >= localUpdate:
|
||||
# but we don't have any update
|
||||
continue
|
||||
|
||||
# We fell through the conditional block above, so either there isn't a
|
||||
# server task, or we *do* have an update,
|
||||
issuesToPush.add(toServerTask(i))
|
||||
info " " & formatSectionIssue(i, width = terminalWidth() - 8)
|
||||
|
||||
# Now archive the issues on the server that we didn't see locally.
|
||||
info "Archiving the following tasks for context " & ctx.issueContext
|
||||
for task in serverTasks:
|
||||
var toArchive = task
|
||||
if unmatchedServerTaskIds.contains(task.id) and
|
||||
toArchive.archivedAt.isNone:
|
||||
toArchive.archivedAt = some(now())
|
||||
issuesToPush.add(toArchive)
|
||||
|
||||
if not dryRun:
|
||||
var offset = 0
|
||||
while (offset < issuesToPush.len):
|
||||
let batchSize = min(issuesToPush.len - offset, batchSize)
|
||||
updateTasks(ctx, issuesToPush[offset ..< offset + batchSize])
|
||||
offset += batchSize
|
||||
@ -1,17 +1,12 @@
|
||||
## Personal Issue Tracker API Interface
|
||||
## ====================================
|
||||
#
|
||||
# **NOTE** This is currently not being built as it no longer works under Nim
|
||||
# 2.x due to the inability to call system calls (invoke pit via cli) in a
|
||||
# gc-safe manner. It should be rewritten to use the functionality exposed by
|
||||
# libpit directly rather than calling the pit cli executable. Unfortunately
|
||||
# this would require a non-trivial rewrite.
|
||||
|
||||
import asyncdispatch, cliutils, docopt, jester, json, logging, options, sequtils, strutils
|
||||
import nre except toSeq
|
||||
|
||||
import pit/libpit
|
||||
import pit/cliconstants
|
||||
import pitpkg/private/libpit
|
||||
|
||||
include "pitpkg/version.nim"
|
||||
|
||||
type
|
||||
PitApiCfg* = object
|
||||
@ -25,7 +20,7 @@ proc raiseEx(reason: string): void = raise newException(Exception, reason)
|
||||
|
||||
template halt(code: HttpCode,
|
||||
headers: RawHeaders,
|
||||
content: string): void =
|
||||
content: string): typed =
|
||||
## Immediately replies with the specified request. This means any further
|
||||
## code will not be executed after calling this template in the current
|
||||
## route.
|
||||
@ -45,10 +40,10 @@ template checkAuth(cfg: PitApiCfg) =
|
||||
var authed {.inject.} = false
|
||||
|
||||
try:
|
||||
if not headers(request).hasKey("Authorization"):
|
||||
if not request.headers.hasKey("Authorization"):
|
||||
raiseEx "No auth token."
|
||||
|
||||
let headerVal = headers(request)["Authorization"]
|
||||
let headerVal = request.headers["Authorization"]
|
||||
if not headerVal.startsWith("Bearer "):
|
||||
raiseEx "Invalid Authentication type (only 'Bearer' is supported)."
|
||||
|
||||
|
||||
@ -1,9 +1,7 @@
|
||||
import std/[json, logging, options, os, strformat, strutils, tables, times]
|
||||
import cliutils, docopt, langutils, uuids, zero_functional
|
||||
import cliutils, docopt, json, logging, langutils, options, os, ospaths,
|
||||
sequtils, strutils, tables, times, timeutils, uuids
|
||||
|
||||
import nre except toSeq
|
||||
import timeutils except `>`
|
||||
from sequtils import deduplicate, toSeq
|
||||
from nre import find, match, re, Regex
|
||||
|
||||
type
|
||||
Issue* = ref object
|
||||
@ -12,7 +10,6 @@ type
|
||||
summary*, details*: string
|
||||
properties*: TableRef[string, string]
|
||||
tags*: seq[string]
|
||||
state*: IssueState
|
||||
|
||||
IssueState* = enum
|
||||
Current = "current",
|
||||
@ -25,49 +22,16 @@ type
|
||||
IssueFilter* = ref object
|
||||
completedRange*: Option[tuple[b, e: DateTime]]
|
||||
fullMatch*, summaryMatch*: Option[Regex]
|
||||
hasTags*: seq[string]
|
||||
exclTags*: seq[string]
|
||||
properties*: TableRef[string, string]
|
||||
exclProperties*: TableRef[string, seq[string]]
|
||||
|
||||
PitConfig* = ref object
|
||||
tasksDir*: string
|
||||
contexts*: TableRef[string, string]
|
||||
autoSync*: bool
|
||||
syncTargets*: seq[JsonNode]
|
||||
cfg*: CombinedConfig
|
||||
|
||||
CliContext* = ref object
|
||||
cfg*: PitConfig
|
||||
contexts*: TableRef[string, string]
|
||||
defaultContext*: Option[string]
|
||||
issues*: TableRef[IssueState, seq[Issue]]
|
||||
triggerPtk*, verbose*: bool
|
||||
|
||||
Recurrence* = object
|
||||
cloneId*: Option[string]
|
||||
interval*: TimeInterval
|
||||
isFromCompletion*: bool
|
||||
|
||||
|
||||
const DONE_FOLDER_FORMAT* = "yyyy-MM"
|
||||
const ISO8601_MS = "yyyy-MM-dd'T'HH:mm:ss'.'fffzzz"
|
||||
|
||||
let ISSUE_FILE_PATTERN = re"[A-Fa-f0-9]{8}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{12}\.txt"
|
||||
let RECURRENCE_PATTERN = re"(every|after) ((\d+) )?((hour|day|week|month|year)s?)(, ([0-9a-fA-F]+))?"
|
||||
|
||||
let traceStartTime = cpuTime()
|
||||
var lastTraceTime = traceStartTime
|
||||
|
||||
proc trace*(msg: string, diffFromLast = false) =
|
||||
let curTraceTime = cpuTime()
|
||||
|
||||
if diffFromLast:
|
||||
debug &"{(curTraceTime - lastTraceTime) * 1000:6.2f}ms {msg}"
|
||||
else:
|
||||
debug &"{cpuTime() - traceStartTime:08.4f} {msg}"
|
||||
|
||||
lastTraceTime = curTraceTime
|
||||
|
||||
proc displayName*(s: IssueState): string =
|
||||
case s
|
||||
@ -78,11 +42,6 @@ proc displayName*(s: IssueState): string =
|
||||
of Todo: result = "Todo"
|
||||
of TodoToday: result = "Todo"
|
||||
|
||||
|
||||
proc sameDay*(a, b: DateTime): bool =
|
||||
result = a.year == b.year and a.yearday == b.yearday
|
||||
|
||||
|
||||
## Allow issue properties to be accessed as if the issue was a table
|
||||
proc `[]`*(issue: Issue, key: string): string =
|
||||
return issue.properties[key]
|
||||
@ -90,8 +49,6 @@ proc `[]`*(issue: Issue, key: string): string =
|
||||
proc `[]=`*(issue: Issue, key: string, value: string) =
|
||||
issue.properties[key] = value
|
||||
|
||||
|
||||
## Issue property accessors
|
||||
proc hasProp*(issue: Issue, key: string): bool =
|
||||
return issue.properties.hasKey(key)
|
||||
|
||||
@ -105,41 +62,12 @@ proc getDateTime*(issue: Issue, key: string, default: DateTime): DateTime =
|
||||
proc setDateTime*(issue: Issue, key: string, dt: DateTime) =
|
||||
issue.properties[key] = dt.formatIso8601
|
||||
|
||||
proc getRecurrence*(issue: Issue): Option[Recurrence] =
|
||||
if not issue.hasProp("recurrence"): return none[Recurrence]()
|
||||
|
||||
let m = issue["recurrence"].match(RECURRENCE_PATTERN)
|
||||
|
||||
if not m.isSome:
|
||||
warn "not a valid recurrence value: '" & issue["recurrence"] & "'"
|
||||
return none[Recurrence]()
|
||||
|
||||
let c = nre.toSeq(m.get.captures)
|
||||
let timeVal = if c[2].isSome: c[2].get.parseInt
|
||||
else: 1
|
||||
return some(Recurrence(
|
||||
isFromCompletion: c[0].get == "after",
|
||||
interval:
|
||||
case c[4].get:
|
||||
of "hour": hours(timeVal)
|
||||
of "day": days(timeVal)
|
||||
of "week": weeks(timeVal)
|
||||
of "month": months(timeVal)
|
||||
of "year": years(timeVal)
|
||||
else: weeks(1),
|
||||
cloneId: c[6]))
|
||||
|
||||
|
||||
## Issue filtering
|
||||
proc initFilter*(): IssueFilter =
|
||||
result = IssueFilter(
|
||||
completedRange: none(tuple[b, e: DateTime]),
|
||||
fullMatch: none(Regex),
|
||||
summaryMatch: none(Regex),
|
||||
hasTags: @[],
|
||||
exclTags: @[],
|
||||
properties: newTable[string, string](),
|
||||
exclProperties: newTable[string,seq[string]]())
|
||||
properties: newTable[string, string]())
|
||||
|
||||
proc propsFilter*(props: TableRef[string, string]): IssueFilter =
|
||||
if isNil(props):
|
||||
@ -161,10 +89,6 @@ proc fullMatchFilter*(pattern: string): IssueFilter =
|
||||
result = initFilter()
|
||||
result.fullMatch = some(re("(?i)" & pattern))
|
||||
|
||||
proc hasTagsFilter*(tags: seq[string]): IssueFilter =
|
||||
result = initFilter()
|
||||
result.hasTags = tags
|
||||
|
||||
proc groupBy*(issues: seq[Issue], propertyKey: string): TableRef[string, seq[Issue]] =
|
||||
result = newTable[string, seq[Issue]]()
|
||||
for i in issues:
|
||||
@ -173,24 +97,6 @@ proc groupBy*(issues: seq[Issue], propertyKey: string): TableRef[string, seq[Iss
|
||||
result[key].add(i)
|
||||
|
||||
|
||||
## Parse and format dates
|
||||
const DATE_FORMATS = [
|
||||
"MM/dd",
|
||||
"MM-dd",
|
||||
"yyyy-MM-dd",
|
||||
"yyyy/MM/dd",
|
||||
"yyyy-MM-dd'T'hh:mm:ss"
|
||||
]
|
||||
proc parseDate*(d: string): DateTime =
|
||||
var errMsg = ""
|
||||
for df in DATE_FORMATS:
|
||||
try: return d.parse(df)
|
||||
except CatchableError:
|
||||
errMsg &= "\n\tTried " & df & " with " & d
|
||||
continue
|
||||
raise newException(ValueError, "Unable to parse input as a date: " & d & errMsg)
|
||||
|
||||
|
||||
## Parse and format issues
|
||||
proc fromStorageFormat*(id: string, issueTxt: string): Issue =
|
||||
type ParseState = enum ReadingSummary, ReadingProps, ReadingDetails
|
||||
@ -214,7 +120,7 @@ proc fromStorageFormat*(id: string, issueTxt: string): Issue =
|
||||
|
||||
of ReadingProps:
|
||||
# Ignore empty lines
|
||||
if line.isEmptyOrWhitespace: continue
|
||||
if line.isNilOrWhitespace: continue
|
||||
|
||||
# Look for the sentinal to start parsing as detail lines
|
||||
if line == "--------":
|
||||
@ -222,13 +128,12 @@ proc fromStorageFormat*(id: string, issueTxt: string): Issue =
|
||||
continue
|
||||
|
||||
|
||||
let parts = line.split({':'}, 1) --> map(it.strip())
|
||||
let parts = line.split({':'}, 1).mapIt(it.strip())
|
||||
if parts.len != 2:
|
||||
raise newException(ValueError, "unable to parse property line: " & line)
|
||||
|
||||
# Take care of special properties: `tags`
|
||||
if parts[0] == "tags":
|
||||
result.tags = parts[1].split({','}) --> map(it.strip())
|
||||
if parts[0] == "tags": result.tags = parts[1].split({','}).mapIt(it.strip())
|
||||
else: result[parts[0]] = parts[1]
|
||||
|
||||
of ReadingDetails:
|
||||
@ -238,35 +143,24 @@ proc fromStorageFormat*(id: string, issueTxt: string): Issue =
|
||||
|
||||
proc toStorageFormat*(issue: Issue, withComments = false): string =
|
||||
var lines: seq[string] = @[]
|
||||
|
||||
if withComments: lines.add("# Summary (one line):")
|
||||
lines.add(issue.summary)
|
||||
|
||||
if withComments: lines.add("# Properties (\"key:value\" per line):")
|
||||
issue.properties["last-updated"] = now().format(ISO8601_MS)
|
||||
for key, val in issue.properties:
|
||||
if not val.isEmptyOrWhitespace: lines.add(key & ": " & val)
|
||||
|
||||
if not val.isNilOrWhitespace: lines.add(key & ": " & val)
|
||||
if issue.tags.len > 0: lines.add("tags: " & issue.tags.join(","))
|
||||
|
||||
if not isEmptyOrWhitespace(issue.details) or withComments:
|
||||
if not isNilOrWhitespace(issue.details) or withComments:
|
||||
if withComments: lines.add("# Details go below the \"--------\"")
|
||||
lines.add("--------")
|
||||
lines.add(issue.details)
|
||||
|
||||
result = lines.join("\n")
|
||||
|
||||
|
||||
## Load and store from filesystem
|
||||
proc loadIssue*(filePath: string): Issue =
|
||||
result = fromStorageFormat(splitFile(filePath).name, readFile(filePath))
|
||||
result.filepath = filePath
|
||||
|
||||
let parentDirName = filePath.splitFile().dir.splitFile().name
|
||||
let issueState = IssueState.items.toSeq --> find($it == parentDirName)
|
||||
if issueState.isSome: result.state = issueState.get
|
||||
else: result.state = IssueState.Done
|
||||
|
||||
proc loadIssueById*(tasksDir, id: string): Issue =
|
||||
for path in walkDirRec(tasksDir):
|
||||
if path.splitFile.name.startsWith(id):
|
||||
@ -274,7 +168,6 @@ proc loadIssueById*(tasksDir, id: string): Issue =
|
||||
raise newException(KeyError, "cannot find issue for id: " & id)
|
||||
|
||||
proc store*(issue: Issue, withComments = false) =
|
||||
discard existsOrCreateDir(issue.filePath.parentDir)
|
||||
writeFile(issue.filepath, toStorageFormat(issue, withComments))
|
||||
|
||||
proc store*(tasksDir: string, issue: Issue, state: IssueState, withComments = false) =
|
||||
@ -302,14 +195,12 @@ proc storeOrder*(issues: seq[Issue], path: string) =
|
||||
proc loadIssues*(path: string): seq[Issue] =
|
||||
let orderFile = path / "order.txt"
|
||||
|
||||
trace "loading issues under " & path
|
||||
|
||||
let orderedIds =
|
||||
if fileExists(orderFile):
|
||||
(orderFile.lines.toSeq -->
|
||||
map(it.split(' ')[0]).
|
||||
filter(not it.startsWith("> ") and not it.isEmptyOrWhitespace)).
|
||||
deduplicate()
|
||||
toSeq(orderFile.lines)
|
||||
.mapIt(it.split(' ')[0])
|
||||
.deduplicate
|
||||
.filterIt(not it.startsWith("> ") and not it.isNilOrWhitespace)
|
||||
else: newSeq[string]()
|
||||
|
||||
type TaggedIssue = tuple[issue: Issue, ordered: bool]
|
||||
@ -319,7 +210,6 @@ proc loadIssues*(path: string): seq[Issue] =
|
||||
if extractFilename(path).match(ISSUE_FILE_PATTERN).isSome():
|
||||
unorderedIssues.add((loadIssue(path), false))
|
||||
|
||||
trace "loaded " & $unorderedIssues.len & " issues", true
|
||||
result = @[]
|
||||
|
||||
# Add all ordered issues in order
|
||||
@ -334,182 +224,84 @@ proc loadIssues*(path: string): seq[Issue] =
|
||||
if taggedIssue.ordered: continue
|
||||
result.add(taggedIssue.issue)
|
||||
|
||||
trace "ordered the loaded issues", true
|
||||
|
||||
# Finally, save current order
|
||||
result.storeOrder(path)
|
||||
|
||||
proc loadIssues*(tasksDir: string, state: IssueState): seq[Issue] =
|
||||
loadIssues(tasksDir / $state)
|
||||
|
||||
proc loadAllIssues*(tasksDir: string): TableRef[IssueState, seq[Issue]] =
|
||||
result = newTable[IssueState, seq[Issue]]()
|
||||
for state in IssueState: result[state] = tasksDir.loadIssues(state)
|
||||
|
||||
proc changeState*(issue: Issue, tasksDir: string, newState: IssueState) =
|
||||
var dbgInfo = "[$#] changing state: $# → $#" %
|
||||
[ ($issue.id)[0..<6], $issue.state, $newState ]
|
||||
|
||||
let oldFilepath = issue.filepath
|
||||
if newState == Done: issue.setDateTime("completed", getTime().local)
|
||||
tasksDir.store(issue, newState)
|
||||
if oldFilePath != issue.filepath: removeFile(oldFilepath)
|
||||
dbgInfo &= "\n\told path: $#\n\tnew path: $#" % [oldFilePath, issue.filepath]
|
||||
issue.state = newState
|
||||
debug dbgInfo
|
||||
|
||||
proc delete*(issue: Issue) = removeFile(issue.filepath)
|
||||
|
||||
proc nextRecurrence*(tasksDir: string, rec: Recurrence, defaultIssue: Issue): Issue =
|
||||
let baseIssue = if rec.cloneId.isSome: tasksDir.loadIssueById(rec.cloneId.get)
|
||||
else: defaultIssue
|
||||
|
||||
let newProps = newTable[string,string]()
|
||||
for k, v in baseIssue.properties:
|
||||
if k != "completed": newProps[k] = v
|
||||
newProps["prev-recurrence"] = $baseIssue.id
|
||||
|
||||
result = Issue(
|
||||
id: genUUID(),
|
||||
state: baseIssue.state,
|
||||
summary: baseIssue.summary,
|
||||
properties: newProps,
|
||||
tags: baseIssue.tags)
|
||||
|
||||
let now = getTime().local
|
||||
|
||||
let startDate =
|
||||
if rec.isFromCompletion:
|
||||
if baseIssue.hasProp("completed"): baseIssue.getDateTime("completed")
|
||||
else: now
|
||||
else:
|
||||
if baseIssue.hasProp("created"): baseIssue.getDateTime("created")
|
||||
else: now
|
||||
|
||||
# walk the calendar until the next recurrence that is after the current time.
|
||||
var nextTime = startDate + rec.interval
|
||||
while now > nextTime: nextTime += rec.interval
|
||||
|
||||
result.setDateTime("hide-until", nextTime)
|
||||
|
||||
|
||||
## Utilities for working with issue collections.
|
||||
proc filter*(issues: seq[Issue], filter: IssueFilter): seq[Issue] =
|
||||
var f: seq[Issue] = issues
|
||||
result = issues
|
||||
|
||||
for k,v in filter.properties:
|
||||
f = f --> filter(it.hasProp(k) and it[k] == v)
|
||||
|
||||
for k,v in filter.exclProperties:
|
||||
f = f --> filter(not (it.hasProp(k) and v.contains(it[k])))
|
||||
result = result.filterIt(it.hasProp(k) and it[k] == v)
|
||||
|
||||
if filter.completedRange.isSome:
|
||||
let range = filter.completedRange.get
|
||||
f = f --> filter(
|
||||
result = result.filterIt(
|
||||
not it.hasProp("completed") or
|
||||
it.getDateTime("completed").between(range.b, range.e))
|
||||
|
||||
if filter.summaryMatch.isSome:
|
||||
let p = filter.summaryMatch.get
|
||||
f = f --> filter(it.summary.find(p).isSome)
|
||||
result = result.filterIt(it.summary.find(p).isSome)
|
||||
|
||||
if filter.fullMatch.isSome:
|
||||
let p = filter.fullMatch.get
|
||||
f = f -->
|
||||
filter(it.summary.find(p).isSome or it.details.find(p).isSome)
|
||||
|
||||
for tagLent in filter.hasTags:
|
||||
let tag = tagLent
|
||||
f = f --> filter(it.tags.find(tag) >= 0)
|
||||
|
||||
for exclTagLent in filter.exclTags:
|
||||
let exclTag = exclTagLent
|
||||
f = f --> filter(it.tags.find(exclTag) < 0)
|
||||
|
||||
return f # not using result because zero_functional doesn't play nice with it
|
||||
|
||||
proc find*(
|
||||
issues: TableRef[IssueState, seq[Issue]],
|
||||
filter: IssueFilter
|
||||
): seq[Issue] =
|
||||
|
||||
result = @[]
|
||||
for stateIssues in issues.values: result &= stateIssues.filter(filter)
|
||||
|
||||
result = result.filterIt( it.summary.find(p).isSome or it.details.find(p).isSome)
|
||||
|
||||
### Configuration utilities
|
||||
proc loadConfig*(args: Table[string, Value] = initTable[string, Value]()): PitConfig =
|
||||
var pitrcFilename: string
|
||||
let pitrcLocations = @[
|
||||
if args["--config"]: $args["--config"] else: "",
|
||||
".pitrc", $getEnv("PITRC"), $getEnv("HOME") & "/.pitrc"]
|
||||
|
||||
try:
|
||||
pitrcFilename = findConfigFile(".pitrc",
|
||||
if args["--config"]: @[$args["--config"]] else: @[])
|
||||
except ValueError:
|
||||
warn "could not find .pitrc file: " & pitrcFilename
|
||||
if isEmptyOrWhitespace(pitrcFilename):
|
||||
var pitrcFilename: string =
|
||||
foldl(pitrcLocations, if len(a) > 0: a elif existsFile(b): b else: "")
|
||||
|
||||
if not existsFile(pitrcFilename):
|
||||
warn "pit: could not find .pitrc file: " & pitrcFilename
|
||||
if isNilOrWhitespace(pitrcFilename):
|
||||
pitrcFilename = $getEnv("HOME") & "/.pitrc"
|
||||
var cfgFile: File
|
||||
try:
|
||||
cfgFile = open(pitrcFilename, fmWrite)
|
||||
cfgFile.write("{\"tasksDir\": \"/path/to/tasks\"}")
|
||||
except CatchableError: warn "could not write default .pitrc to " & pitrcFilename
|
||||
except: warn "pit: could not write default .pitrc to " & pitrcFilename
|
||||
finally: close(cfgFile)
|
||||
|
||||
debug "loading config from '$#'" % [pitrcFilename]
|
||||
let cfg = initCombinedConfig(pitrcFilename, args)
|
||||
var cfgJson: JsonNode
|
||||
try: cfgJson = parseFile(pitrcFilename)
|
||||
except: raise newException(IOError,
|
||||
"unable to read config file: " & pitrcFilename &
|
||||
"\x0D\x0A" & getCurrentExceptionMsg())
|
||||
|
||||
let cfg = CombinedConfig(docopt: args, json: cfgJson)
|
||||
|
||||
result = PitConfig(
|
||||
cfg: cfg,
|
||||
autoSync: parseBool(cfg.getVal("auto-sync", "false")),
|
||||
contexts: newTable[string,string](),
|
||||
tasksDir: cfg.getVal("tasks-dir", ""),
|
||||
syncTargets: cfg.getJson("sync-targets", newJArray()).getElems)
|
||||
tasksDir: cfg.getVal("tasks-dir", ""))
|
||||
|
||||
for k, v in cfg.getJson("contexts", newJObject()):
|
||||
result.contexts[k] = v.getStr()
|
||||
if cfgJson.hasKey("contexts"):
|
||||
for k, v in cfgJson["contexts"]:
|
||||
result.contexts[k] = v.getStr()
|
||||
|
||||
if isEmptyOrWhitespace(result.tasksDir):
|
||||
if isNilOrWhitespace(result.tasksDir):
|
||||
raise newException(Exception, "no tasks directory configured")
|
||||
|
||||
if not dirExists(result.tasksDir):
|
||||
if not existsDir(result.tasksDir):
|
||||
raise newException(Exception, "cannot find tasks dir: " & result.tasksDir)
|
||||
|
||||
# Create our tasks directory structure if needed
|
||||
for s in IssueState:
|
||||
if not dirExists(result.tasksDir / $s):
|
||||
if not existsDir(result.tasksDir / $s):
|
||||
(result.tasksDir / $s).createDir
|
||||
|
||||
|
||||
## CliContext functionality
|
||||
proc initContext*(args: Table[string, Value]): CliContext =
|
||||
let pitCfg = loadConfig(args)
|
||||
|
||||
let cliJson =
|
||||
if pitCfg.cfg.json.hasKey("cli"): pitCfg.cfg.json["cli"]
|
||||
else: newJObject()
|
||||
|
||||
let cliCfg = CombinedConfig(docopt: args, json: cliJson)
|
||||
|
||||
result = CliContext(
|
||||
cfg: pitCfg,
|
||||
contexts: pitCfg.contexts,
|
||||
defaultContext:
|
||||
if not cliJson.hasKey("defaultContext"): none(string)
|
||||
else: some(cliJson["defaultContext"].getStr()),
|
||||
verbose: parseBool(cliCfg.getVal("verbose", "false")) and not args["--quiet"],
|
||||
issues: newTable[IssueState, seq[Issue]](),
|
||||
triggerPtk: cliJson.getOrDefault("triggerPtk").getBool(false))
|
||||
|
||||
proc loadIssues*(ctx: CliContext, state: IssueState) =
|
||||
ctx.issues[state] = loadIssues(ctx.cfg.tasksDir, state)
|
||||
|
||||
proc loadOpenIssues*(ctx: CliContext) =
|
||||
ctx.issues = newTable[IssueState, seq[Issue]]()
|
||||
for state in [Current, TodoToday, Todo, Pending, Todo]: ctx.loadIssues(state)
|
||||
|
||||
proc loadAllIssues*(ctx: CliContext) =
|
||||
ctx.issues = ctx.cfg.tasksDir.loadAllIssues()
|
||||
|
||||
proc filterIssues*(ctx: CliContext, filter: IssueFilter) =
|
||||
for state, issueList in ctx.issues:
|
||||
ctx.issues[state] = issueList.filter(filter)
|
||||
1
src/pitpkg/version.nim
Normal file
1
src/pitpkg/version.nim
Normal file
@ -0,0 +1 @@
|
||||
const PIT_VERSION* = "4.8.0"
|
||||
Loading…
x
Reference in New Issue
Block a user