188 lines
9.0 KiB
Plaintext
188 lines
9.0 KiB
Plaintext
(load "Lib.kiss")
|
|
|
|
(method :Void _collectAndValidateArg [:CommandArg arg :Dynamic->Void continuation]
|
|
(case arg.type
|
|
(SelectedEntry
|
|
(if (= 1 selectedEntries.length)
|
|
(continuation (first selectedEntries))
|
|
(ui.reportError "The requested command expects 1 entry to be selected. You have selected: $selectedEntries.length")))
|
|
((SelectedEntries min max)
|
|
(unless min (set min 0))
|
|
// TODO might want to optimize this O(n) count operation by pre-calculating it
|
|
(unless max (set max (count archive.entries)))
|
|
(if !(<= min selectedEntries.length max)
|
|
(ui.reportError "The requested command expects between $min and $max entries to be selected. You have selected: $selectedEntries.length")
|
|
(continuation selectedEntries)))
|
|
((Text maxLength)
|
|
(unless maxLength (set maxLength Math.POSITIVE_INFINITY))
|
|
(ui.enterText
|
|
"${arg.name} (up to ${maxLength} characters):"
|
|
(lambda :Void [text]
|
|
(if !(<= text.length maxLength)
|
|
(ui.reportError "The requested command expected a string up to $maxLength characters long. You entered: $text.length characters")
|
|
(continuation text)))
|
|
maxLength))
|
|
((VarText maxLength)
|
|
(unless maxLength (set maxLength Math.POSITIVE_INFINITY))
|
|
(let [collectedText
|
|
[]
|
|
&mut :Void->Void enterTextAgain
|
|
null
|
|
_enterTextAgain
|
|
->:Void
|
|
(ui.enterText
|
|
"${arg.name} (up to ${maxLength} characters):"
|
|
(lambda :Void [text]
|
|
(if !text
|
|
(continuation collectedText)
|
|
(if !(<= text.length maxLength)
|
|
(ui.reportError "The requested command expected a list of strings up to $maxLength characters long. You entered: $text.length characters")
|
|
{(collectedText.push text)
|
|
(enterTextAgain)})))
|
|
maxLength)]
|
|
(set enterTextAgain _enterTextAgain)
|
|
(enterTextAgain)))
|
|
((Number min max inStepsOf)
|
|
(unless min (set min Math.NEGATIVE_INFINITY))
|
|
(unless max (set max Math.POSITIVE_INFINITY))
|
|
(let [&mut prompt "${arg.name} (${min}-${max}"]
|
|
(when inStepsOf
|
|
(+= prompt " in steps of ${inStepsOf}"))
|
|
(+= prompt "):")
|
|
|
|
(ui.enterNumber
|
|
prompt
|
|
(lambda :Void [number]
|
|
(let [minMaxError
|
|
"The requested command expected a number between $min and $max"
|
|
stepError
|
|
"$minMaxError in steps of $inStepsOf"
|
|
youEntered
|
|
". You entered: $number"]
|
|
(if (or
|
|
!(<= min number max)
|
|
(and inStepsOf !(= 0 (% (- number min) inStepsOf))))
|
|
(if inStepsOf
|
|
(ui.reportError "${stepError}$youEntered")
|
|
(ui.reportError "${minMaxError}$youEntered"))
|
|
(continuation number))))
|
|
min
|
|
max
|
|
inStepsOf)))
|
|
(OneEntry
|
|
(ui.chooseEntry
|
|
"${arg.name}:"
|
|
archive
|
|
continuation))
|
|
((Entries min max)
|
|
(unless min (set min 1))
|
|
// TODO might want to optimize this O(n) count operation by pre-calculating it
|
|
(unless max (set max (count archive.entries)))
|
|
(ui.chooseEntries
|
|
"${arg.name}:"
|
|
archive
|
|
(lambda :Void [:Array<Entry> entries]
|
|
(if (or
|
|
(> min entries.length)
|
|
(< max entries.length))
|
|
|
|
(ui.reportError "The requested command expects between $min and $max entries. You chose: $entries.length")
|
|
(continuation entries)))
|
|
min
|
|
max))))
|
|
|
|
(method :Void->Void _composeArgCollector [:Array<Dynamic> collectedArgs :CommandArg arg :Void->Void lastCollector]
|
|
(lambda :Void []
|
|
(_collectAndValidateArg arg ->:Void [:Dynamic argValue] {(collectedArgs.push argValue) (lastCollector)})))
|
|
|
|
(method :Void runCommand [:Command command]
|
|
(let [collectedArgs
|
|
[]
|
|
&mut lastCollector
|
|
(lambda []
|
|
(set lastChangeSet (the ChangeSet (Reflect.callMethod null command.handler collectedArgs)))
|
|
(ui.handleChanges archive lastChangeSet))]
|
|
// To facilitate asynchronous arg input via UI, we need to construct an insanely complicated nested callback to give the UI
|
|
(doFor arg (reversed command.args)
|
|
(set lastCollector (_composeArgCollector collectedArgs arg lastCollector)))
|
|
(lastCollector)))
|
|
|
|
(defMacro defCommand [name args &body body]
|
|
(let [argPairs
|
|
(groups (expList args) 2)
|
|
methodArgs
|
|
(for [name type] argPairs
|
|
// TODO write an exprCase macro that simplifies this terrible mess,
|
|
// and maybe adds back precise pattern matching instead of relying
|
|
// on partial string matching
|
|
(exprCase type
|
|
((exprOr SelectedEntry OneEntry) `:nat.Entry ,name)
|
|
((exprOr (SelectedEntries _ _) (Entries _ _)) `:Array<nat.Entry> ,name)
|
|
((Text _) `:String ,name)
|
|
((VarText _) `:Array<String> ,name)
|
|
((Number _ _ _) `:Float ,name)))
|
|
commandArgs
|
|
(for [name type] argPairs
|
|
`(object name ,(symbolName name) type ,type))]
|
|
`{
|
|
(method ,name [,@methodArgs] ,@body)
|
|
(dictSet commands ,(symbolName name) (object args [,@commandArgs] handler (the Function ,name)))}))
|
|
|
|
(defNew [&prop :Archive archive
|
|
&prop :ArchiveUI ui]
|
|
[&mut :Array<Entry> selectedEntries []
|
|
&mut :ChangeSet lastChangeSet []
|
|
:Map<String,Command> commands (new Map)]
|
|
|
|
(defCommand selectEntry [e OneEntry]
|
|
(set selectedEntries [e]) [])
|
|
|
|
(defCommand selectEntries [entries (Entries null null)]
|
|
(set selectedEntries entries) [])
|
|
|
|
(defCommand selectAllEntries []
|
|
(set selectedEntries (for =>id e archive.entries e)) [])
|
|
|
|
(defCommand selectLastChangeSet []
|
|
(set selectedEntries lastChangeSet) [])
|
|
|
|
(defCommand printSelectedEntries [entries (SelectedEntries null null)]
|
|
(doFor e entries (ui.displayMessage (archive.fullString e))) [])
|
|
|
|
(defCommand printComponent [entries (SelectedEntries null null)
|
|
componentType (Text null)]
|
|
(doFor e entries (ui.displayMessage (archive.componentData e componentType))) [])
|
|
|
|
(defCommand createEntry [name (Text null)]
|
|
[(archive.createEntry ->e
|
|
(addComponent archive e Name name))])
|
|
|
|
(defCommand createEntries [names (VarText null)]
|
|
(flatten (for name names
|
|
(createEntry name))))
|
|
|
|
(defCommand addTags [entries (SelectedEntries 1 null)
|
|
tagsToAdd (VarText null)]
|
|
(doFor e entries
|
|
(withWritableEntry archive e
|
|
(if (hasComponent e Tags)
|
|
(withWritableComponents archive e [tags Tags]
|
|
(doFor tag tagsToAdd (dictSet tags tag 1)))
|
|
(addComponent archive e Tags (for tag tagsToAdd =>tag 1)))))
|
|
entries) // TODO this includes entries that already had the tag in the changeset
|
|
|
|
(defCommand removeTags [entries (SelectedEntries 1 null)
|
|
tagsToRemove (VarText null)]
|
|
(doFor e entries
|
|
(withWritableEntry archive e
|
|
(when (hasComponent e Tags)
|
|
(withWritableComponents archive e [tags Tags]
|
|
(doFor tag tagsToRemove (tags.remove tag))))))
|
|
entries) // TODO this includes entries that didn't have the tag in the changeset
|
|
|
|
(defCommand selectByTags [tagsBoolExp (Text null)]
|
|
(selectEntries (filter archive.entries ->e (tagsMatch archive e tagsBoolExp))))
|
|
|
|
(defCommand selectByComponents [componentsBoolExp (Text null)]
|
|
(selectEntries (filter archive.entries ->e (componentsMatch e componentsBoolExp)))))
|