mirror of
https://github.com/LGUG2Z/komorebi.git
synced 2026-11-16 13:51:19 +01:00
feat(annotate): mark the timeline from a script while recording
`komorebi-recorder mark "text"` appends a point note (author script) to the session being recorded, found by --session, KOMOREBI_RECORDER_SESSION or the newest running recording. Notes now show as ticks on the viewer's bug lane.
This commit is contained in:
1 parent
cf15fc978c
commit
f9f4e437e4
10 files changed
+596
-2
No files matched your search
@@ -62,6 +62,9 @@ komorebi-recorder overview ./repro # the whole recording at a glance
|
||||
komorebi-recorder trace ./repro event:7 # one event, from the handler that ran to what changed and who changed it
|
||||
```
|
||||
|
||||
A script that drives the repro can name its steps on the timeline while recording, with
|
||||
`komorebi-recorder mark "step 3: move window right"`; they show up as notes.
|
||||
|
||||
For example, a four second recording of a Mac with komorebi running:
|
||||
|
||||
```text
|
||||
|
||||
@@ -128,6 +128,7 @@ and `event:12.end` when it finished.
|
||||
| `blank --region x,y,w,h` | When a region was blank (one colour, named: `white`, `black`, a hex code) or frozen (identical to the frame before): "the window went white for 200 ms" |
|
||||
| `compare A B` | Two recordings side by side: duration, frames, effective fps, worst frame gap, motion, findings by kind, annotations, and the difference |
|
||||
| `annotate`, `annotations` | Add, change and list bug regions, notes and findings |
|
||||
| `mark TEXT` | While recording: drop a named point note (author `script`) onto the timeline from a script; it then appears in `annotations`, `brief` and the viewer like any note |
|
||||
|
||||
### Who changed it
|
||||
|
||||
|
||||
@@ -127,6 +127,23 @@ This is what makes the recording useful to whoever investigates it, person or ag
|
||||
truth of _what_ went wrong, and everything else in the session is evidence of _why_. See
|
||||
[Investigating a recording](investigating-a-recording.md#marking-the-bug).
|
||||
|
||||
### Marking steps from a script
|
||||
|
||||
A script that performs the repro can drop named markers onto the timeline while the recording is going:
|
||||
|
||||
```
|
||||
komorebi-recorder mark "step 3: move window right"
|
||||
```
|
||||
|
||||
A marker is a note by the author `script`, written at the moment the command runs, so it appears in `annotations`,
|
||||
`brief`, `search`, `overview` and as a tick on the viewer's bug lane. `mark` prints the video time (`marked 00:03.28 (a-3f9c1e02): ...`) once the first frame has been captured and
|
||||
the wall time (`marked 12:00:08.12Z (...)`) before that.
|
||||
|
||||
It marks the session named by `--session DIR`, else by the environment variable `KOMOREBI_RECORDER_SESSION` (which
|
||||
`record --until-exit` sets for the command it runs), else the newest recording in komorebi's data directory that is
|
||||
still running. A recording that has finished is refused: it has no "now" to mark; use `annotate <session> add` with a
|
||||
time instead. `--json` prints the `mark/1` envelope.
|
||||
|
||||
### Without video
|
||||
|
||||
`komorebi-recorder record --no-video` records everything but the screen: komorebi's events and log, the OS trace and
|
||||
|
||||
@@ -149,6 +149,11 @@ pub const ALL: &[Entry] = &[
|
||||
about: "`annotate delete`: the id removed",
|
||||
schema: of::<DeletedData>,
|
||||
},
|
||||
Entry {
|
||||
name: "mark/1",
|
||||
about: "`mark`: the marker dropped on a recording that is still going",
|
||||
schema: of::<crate::cli::mark::MarkData>,
|
||||
},
|
||||
Entry {
|
||||
name: "doctor/1",
|
||||
about: "`doctor`: what this machine can do for a recording",
|
||||
|
||||
@@ -0,0 +1,393 @@
|
||||
//! `mark`: dropping a named marker onto a recording's timeline while it is being recorded.
|
||||
//!
|
||||
//! A script that drives komorebi (or anything else on the machine) can say where it is:
|
||||
//! `komorebi-recorder mark "step 3: move window right"`. The marker is a note, written to the
|
||||
//! session's `annotations.jsonl` at the instant the command runs, so it shows up in `annotations`,
|
||||
//! `brief`, `search`, `overview` and the viewer like any other note, with the author `script`.
|
||||
//!
|
||||
//! The note is a point in time: its start and end are the same nanosecond of the master clock
|
||||
//! ([`crate::clock::mono_now_ns`], which every process on the machine agrees on). It does not go
|
||||
//! through `cli::load`, which refuses a session that is still recording, and it does not take
|
||||
//! the recorder's lock: [`crate::annotations::add`] only appends one line, which is safe beside the
|
||||
//! recorder and beside other marks.
|
||||
//!
|
||||
//! # Which session
|
||||
//!
|
||||
//! In this order ([`resolve_session`]):
|
||||
//!
|
||||
//! 1. `--session DIR`;
|
||||
//! 2. the environment variable [`SESSION_ENV`] (`record --until-exit` sets it for the command it
|
||||
//! runs);
|
||||
//! 3. the newest session under komorebi's `recordings/` directory whose recorder is running.
|
||||
//!
|
||||
//! A session no recorder is working on is refused: a finished recording has no "now" to mark, and
|
||||
//! `annotate <session> add` is how to put a note at a time in it. Covered by `tests/mark.rs`.
|
||||
|
||||
use super::print_json;
|
||||
use crate::analysis::envelope;
|
||||
use crate::analysis::envelope::Envelope;
|
||||
use crate::annotations;
|
||||
use crate::annotations::Kind;
|
||||
use crate::annotations::New;
|
||||
use crate::clock;
|
||||
use crate::lock;
|
||||
use crate::lock::Recorder;
|
||||
use crate::session::Session;
|
||||
use crate::timecode;
|
||||
use crate::timeline;
|
||||
use clap::Args;
|
||||
use color_eyre::eyre;
|
||||
use schemars::JsonSchema;
|
||||
use serde::Serialize;
|
||||
use std::path::Path;
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// The environment variable that names the session to mark: `KOMOREBI_RECORDER_SESSION`, which
|
||||
/// `record --until-exit` sets for its command.
|
||||
pub use super::until_exit::SESSION_ENV;
|
||||
|
||||
/// The author a marker is written under.
|
||||
pub const AUTHOR_SCRIPT: &str = "script";
|
||||
|
||||
/// The `schema` of the output of `mark` with `--json` ([`MarkData`]).
|
||||
pub const SCHEMA_MARK: &str = "mark/1";
|
||||
|
||||
/// The arguments of `mark`.
|
||||
#[derive(Args, Debug)]
|
||||
pub struct MarkArgs {
|
||||
/// What to call this moment, e.g. "step 3: move window right"
|
||||
pub text: String,
|
||||
/// The session being recorded [default: `$KOMOREBI_RECORDER_SESSION`, else the newest recording
|
||||
/// in komorebi's data directory that is still running]
|
||||
#[arg(long, value_name = "DIR")]
|
||||
pub session: Option<PathBuf>,
|
||||
/// The kind of annotation to drop: `note`, or `bug` for a point where the bug is seen
|
||||
#[arg(long, value_enum, default_value = "note")]
|
||||
pub kind: MarkKind,
|
||||
/// Machine-readable JSON output
|
||||
#[arg(long)]
|
||||
pub json: bool,
|
||||
}
|
||||
|
||||
/// The kinds of annotation `mark` writes.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, clap::ValueEnum)]
|
||||
pub enum MarkKind {
|
||||
/// A remark about a moment
|
||||
Note,
|
||||
/// A point where the bug is seen
|
||||
Bug,
|
||||
}
|
||||
|
||||
/// What `mark` answers with `--json`.
|
||||
#[derive(Debug, Serialize, JsonSchema)]
|
||||
pub struct MarkData {
|
||||
/// The id of the annotation written, such as `a-3f9c1e02`.
|
||||
pub id: String,
|
||||
/// The kind of annotation: `note` unless `--kind` said otherwise.
|
||||
pub kind: String,
|
||||
/// The text of the marker.
|
||||
pub text: String,
|
||||
/// The session directory it was written to.
|
||||
pub session: String,
|
||||
/// The moment of the marker on the master clock, in nanoseconds.
|
||||
pub at_mach_ns: u64,
|
||||
/// The moment as a UTC time in RFC 3339 form with microseconds.
|
||||
pub at_wall_utc: Option<String>,
|
||||
/// The moment in seconds of video time. `None` until the recording has captured its first
|
||||
/// frame, where video time starts.
|
||||
pub video_s: Option<f64>,
|
||||
}
|
||||
|
||||
/// Decides which session a mark goes to.
|
||||
///
|
||||
/// `explicit` is `--session`, `env` the value of [`SESSION_ENV`] (empty counts as unset) and
|
||||
/// `recordings` the directory to search for the newest running recording, which is the
|
||||
/// name-ordered last directory in it whose recorder holds its lock (recordings are named for the
|
||||
/// UTC time they began).
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// - a not-found error if a named directory does not exist, or if nothing was named and no recording
|
||||
/// in `recordings` is running; the message gives the three ways to name a session;
|
||||
/// - a usage error if the session named is not being recorded: a finished recording has no "now" to
|
||||
/// mark.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust
|
||||
/// use komorebi_recorder::cli::mark::resolve_session;
|
||||
/// use komorebi_recorder::lock::RecorderLock;
|
||||
///
|
||||
/// let root = std::env::temp_dir().join(format!("komorebi-recorder-doc-resolve-{}", std::process::id()));
|
||||
/// let (old, new) = (root.join("20260101T000000Z"), root.join("20260102T000000Z"));
|
||||
/// std::fs::create_dir_all(&old)?;
|
||||
/// std::fs::create_dir_all(&new)?;
|
||||
/// let _old = RecorderLock::acquire(&old)?;
|
||||
/// let _new = RecorderLock::acquire(&new)?;
|
||||
///
|
||||
/// // nothing named: the newest recording that is running
|
||||
/// assert_eq!(resolve_session(None, None, &root)?, new);
|
||||
/// // the environment beats the search, and --session beats the environment
|
||||
/// assert_eq!(resolve_session(None, Some(old.clone().into()), &root)?, old);
|
||||
/// assert_eq!(resolve_session(Some(&new), Some(old.clone().into()), &root)?, new);
|
||||
/// # std::fs::remove_dir_all(&root)?;
|
||||
/// # Ok::<(), Box<dyn std::error::Error>>(())
|
||||
/// ```
|
||||
pub fn resolve_session(
|
||||
explicit: Option<&Path>,
|
||||
env: Option<std::ffi::OsString>,
|
||||
recordings: &Path,
|
||||
) -> eyre::Result<PathBuf> {
|
||||
let named = explicit
|
||||
.map(Path::to_path_buf)
|
||||
.or_else(|| env.filter(|value| !value.is_empty()).map(PathBuf::from));
|
||||
|
||||
if let Some(dir) = named {
|
||||
if !dir.is_dir() {
|
||||
return Err(envelope::not_found(format!(
|
||||
"{} is not a session directory",
|
||||
dir.display()
|
||||
)));
|
||||
}
|
||||
return match lock::recorder(&dir) {
|
||||
Recorder::Running(_) => Ok(dir),
|
||||
Recorder::NotRunning | Recorder::Unknown => Err(envelope::with_hint(
|
||||
envelope::usage(format!(
|
||||
"{} is not being recorded, and a finished recording has no \"now\" to mark",
|
||||
dir.display()
|
||||
)),
|
||||
format!(
|
||||
"put a note at a time in it with `komorebi-recorder annotate {} add --kind note \
|
||||
--start <t> --text <text>`",
|
||||
dir.display()
|
||||
),
|
||||
)),
|
||||
};
|
||||
}
|
||||
|
||||
let mut candidates: Vec<PathBuf> = std::fs::read_dir(recordings)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.flatten()
|
||||
.map(|entry| entry.path())
|
||||
.filter(|path| path.is_dir())
|
||||
.collect();
|
||||
candidates.sort();
|
||||
candidates
|
||||
.into_iter()
|
||||
.rev()
|
||||
.find(|dir| matches!(lock::recorder(dir), Recorder::Running(_)))
|
||||
.ok_or_else(|| {
|
||||
envelope::not_found(format!(
|
||||
"no recording to mark: name the session with --session <dir>, or with the \
|
||||
environment variable {SESSION_ENV} (`record --until-exit` sets it for its command), \
|
||||
or start a recording; none under {} is running",
|
||||
recordings.display()
|
||||
))
|
||||
})
|
||||
}
|
||||
|
||||
/// Writes the marker and returns what was written.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// Returns a usage error if the text is blank, and whatever [`annotations::add`] fails with.
|
||||
pub fn write_mark(dir: &Path, text: &str, kind: MarkKind) -> eyre::Result<MarkData> {
|
||||
if text.trim().is_empty() {
|
||||
return Err(envelope::usage("a marker needs some text"));
|
||||
}
|
||||
|
||||
let at = clock::mono_now_ns();
|
||||
let at_wall_us = clock::wall_now_us();
|
||||
let kind = match kind {
|
||||
MarkKind::Note => Kind::Note,
|
||||
MarkKind::Bug => Kind::Bug,
|
||||
};
|
||||
let id = annotations::add(
|
||||
dir,
|
||||
New {
|
||||
kind: Some(kind),
|
||||
// a point in time: an annotation with no end would run to the end of the recording
|
||||
start_mach_ns: at,
|
||||
end_mach_ns: Some(at),
|
||||
text: text.to_string(),
|
||||
author: Some(AUTHOR_SCRIPT.to_string()),
|
||||
..New::default()
|
||||
},
|
||||
)?;
|
||||
|
||||
// video time starts at the first frame, which the manifest records once there is one; before
|
||||
// that the wall time is all there is
|
||||
let video_s = Session::open(dir)
|
||||
.and_then(|session| session.manifest())
|
||||
.ok()
|
||||
.filter(|manifest| manifest.video_t0_mach_ns.is_some())
|
||||
.map(|manifest| manifest.video_seconds(at));
|
||||
|
||||
Ok(MarkData {
|
||||
id,
|
||||
kind: kind.to_string(),
|
||||
text: text.to_string(),
|
||||
session: dir.display().to_string(),
|
||||
at_mach_ns: at,
|
||||
at_wall_utc: timeline::format_wall_us(at_wall_us),
|
||||
video_s,
|
||||
})
|
||||
}
|
||||
|
||||
pub(super) fn mark(args: &MarkArgs) -> eyre::Result<()> {
|
||||
let dir = resolve_session(
|
||||
args.session.as_deref(),
|
||||
std::env::var_os(SESSION_ENV),
|
||||
&crate::session::default_recordings_dir(),
|
||||
)?;
|
||||
let marked = write_mark(&dir, &args.text, args.kind)?;
|
||||
|
||||
if args.json {
|
||||
return print_json(&Envelope::ok(SCHEMA_MARK, marked));
|
||||
}
|
||||
|
||||
let when = match (marked.video_s, &marked.at_wall_utc) {
|
||||
(Some(video_s), _) => timecode::format(video_s),
|
||||
// 2026-10-26T12:00:08.123456Z -> 12:00:08.12Z
|
||||
(None, Some(wall)) => format!("{}Z", wall.get(11..22).unwrap_or(wall)),
|
||||
(None, None) => "now".to_string(),
|
||||
};
|
||||
println!("marked {when} ({}): {}", marked.id, marked.text);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::lock::RecorderLock;
|
||||
|
||||
fn scratch(name: &str) -> PathBuf {
|
||||
let dir = std::env::temp_dir().join(format!(
|
||||
"komorebi-recorder-mark-{name}-{}",
|
||||
std::process::id()
|
||||
));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
std::fs::create_dir_all(&dir).expect("create");
|
||||
dir
|
||||
}
|
||||
|
||||
fn running(root: &Path, name: &str) -> (PathBuf, RecorderLock) {
|
||||
let dir = root.join(name);
|
||||
std::fs::create_dir_all(&dir).expect("create");
|
||||
let lock = RecorderLock::acquire(&dir).expect("lock");
|
||||
(dir, lock)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_newest_running_recording_is_the_default() {
|
||||
let root = scratch("newest");
|
||||
let (_old, _a) = running(&root, "20260101T000000Z");
|
||||
let (new, _b) = running(&root, "20260102T000000Z");
|
||||
// newer still, but its recorder is gone
|
||||
let finished = root.join("20260103T000000Z");
|
||||
std::fs::create_dir_all(&finished).expect("create");
|
||||
drop(RecorderLock::acquire(&finished).expect("lock"));
|
||||
|
||||
assert_eq!(resolve_session(None, None, &root).expect("found"), new);
|
||||
let _ = std::fs::remove_dir_all(&root);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_environment_beats_the_search_and_the_flag_beats_the_environment() {
|
||||
let root = scratch("order");
|
||||
let (old, _a) = running(&root, "20260101T000000Z");
|
||||
let (new, _b) = running(&root, "20260102T000000Z");
|
||||
|
||||
assert_eq!(
|
||||
resolve_session(None, Some(old.clone().into()), &root).expect("env"),
|
||||
old
|
||||
);
|
||||
assert_eq!(
|
||||
resolve_session(Some(&new), Some(old.into()), &root).expect("flag"),
|
||||
new
|
||||
);
|
||||
// an empty variable is not set
|
||||
assert_eq!(
|
||||
resolve_session(None, Some(String::new().into()), &root).expect("empty"),
|
||||
new
|
||||
);
|
||||
let _ = std::fs::remove_dir_all(&root);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nothing_running_says_how_to_name_a_session() {
|
||||
let root = scratch("none");
|
||||
let error = resolve_session(None, None, &root).unwrap_err();
|
||||
assert_eq!(
|
||||
envelope::exit_kind(&error),
|
||||
envelope::ExitKind::NotFound,
|
||||
"{error:?}"
|
||||
);
|
||||
let message = format!("{error}");
|
||||
assert!(message.contains("--session") && message.contains(SESSION_ENV));
|
||||
|
||||
// not even a recordings directory
|
||||
let error = resolve_session(None, None, &root.join("missing")).unwrap_err();
|
||||
assert_eq!(envelope::exit_kind(&error), envelope::ExitKind::NotFound);
|
||||
let _ = std::fs::remove_dir_all(&root);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_finished_session_is_refused_with_a_pointer_to_annotate() {
|
||||
let root = scratch("finished");
|
||||
let finished = root.join("done");
|
||||
std::fs::create_dir_all(&finished).expect("create");
|
||||
drop(RecorderLock::acquire(&finished).expect("lock"));
|
||||
|
||||
let error = resolve_session(Some(&finished), None, &root).unwrap_err();
|
||||
assert_eq!(envelope::exit_kind(&error), envelope::ExitKind::Usage);
|
||||
assert!(format!("{error:?}").contains("annotate"), "{error:?}");
|
||||
|
||||
// no lock file at all is no recorder either
|
||||
let bare = root.join("bare");
|
||||
std::fs::create_dir_all(&bare).expect("create");
|
||||
assert!(resolve_session(Some(&bare), None, &root).is_err());
|
||||
let _ = std::fs::remove_dir_all(&root);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_marker_is_one_point_note_by_the_script() {
|
||||
let root = scratch("line");
|
||||
let (dir, _lock) = running(&root, "now");
|
||||
|
||||
let marked = write_mark(&dir, "step 3: move window right", MarkKind::Note).expect("mark");
|
||||
let text = std::fs::read_to_string(dir.join(annotations::ANNOTATIONS_FILE)).expect("read");
|
||||
assert_eq!(text.lines().count(), 1);
|
||||
assert!(text.ends_with('\n'));
|
||||
|
||||
let line: serde_json::Value = serde_json::from_str(text.trim()).expect("json");
|
||||
assert_eq!(line["v"], 1);
|
||||
assert_eq!(line["id"], marked.id.as_str());
|
||||
assert_eq!(line["op"], "add");
|
||||
assert_eq!(line["kind"], "note");
|
||||
assert_eq!(line["author"], "script");
|
||||
assert_eq!(line["title"], "");
|
||||
assert_eq!(line["text"], "step 3: move window right");
|
||||
assert_eq!(line["start_mach_ns"], line["end_mach_ns"]);
|
||||
assert_eq!(line["start_mach_ns"].as_u64(), Some(marked.at_mach_ns));
|
||||
|
||||
let loaded = annotations::load(&dir).expect("load");
|
||||
let note = loaded.get(&marked.id).expect("read back");
|
||||
assert!(!note.open_ended());
|
||||
// no manifest here, so only the wall time is known
|
||||
assert_eq!(marked.video_s, None);
|
||||
assert!(marked.at_wall_utc.is_some());
|
||||
let _ = std::fs::remove_dir_all(&root);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn blank_text_is_refused_and_writes_nothing() {
|
||||
let root = scratch("blank");
|
||||
let (dir, _lock) = running(&root, "now");
|
||||
let error = write_mark(&dir, " ", MarkKind::Note).unwrap_err();
|
||||
assert_eq!(envelope::exit_kind(&error), envelope::ExitKind::Usage);
|
||||
assert!(!dir.join(annotations::ANNOTATIONS_FILE).exists());
|
||||
let _ = std::fs::remove_dir_all(&root);
|
||||
}
|
||||
}
|
||||
@@ -10,8 +10,9 @@ mod annotate;
|
||||
mod doctor;
|
||||
mod findings;
|
||||
mod investigate;
|
||||
pub mod outputs;
|
||||
mod logq;
|
||||
pub mod mark;
|
||||
pub mod outputs;
|
||||
mod query;
|
||||
mod record;
|
||||
pub mod refspec;
|
||||
@@ -147,6 +148,8 @@ pub enum Command {
|
||||
Annotate(AnnotateArgs),
|
||||
/// List a session's bug regions, notes and findings
|
||||
Annotations(AnnotationsArgs),
|
||||
/// Drop a named marker onto the timeline of a recording that is still going
|
||||
Mark(mark::MarkArgs),
|
||||
/// Rebuild a session's timeline from its raw files, recovering it first if the recorder died
|
||||
Reindex(ReindexArgs),
|
||||
/// Check the video-to-clock alignment against a rendered on-screen clock
|
||||
@@ -222,6 +225,7 @@ impl Command {
|
||||
Self::Compare(args) => args.json,
|
||||
Self::Annotate(args) => args.json(),
|
||||
Self::Annotations(args) => args.json,
|
||||
Self::Mark(args) => args.json,
|
||||
Self::Doctor(args) => args.json,
|
||||
Self::Record(args) => args.json,
|
||||
Self::Displays(args) => args.json,
|
||||
@@ -294,6 +298,7 @@ pub fn run(command: Command) -> eyre::Result<()> {
|
||||
Command::Findings(args) => findings::findings(&args),
|
||||
Command::Annotate(args) => annotate::annotate(&args),
|
||||
Command::Annotations(args) => annotate::list(&args),
|
||||
Command::Mark(args) => mark::mark(&args),
|
||||
Command::Reindex(args) => reindex(&args),
|
||||
Command::Selftest(args) => crate::selftest::run(&args),
|
||||
Command::SelftestClock => crate::selftest::run_clock(),
|
||||
|
||||
@@ -32,6 +32,9 @@ not listed), what looked wrong and for how long, the state as the bug began and
|
||||
what differs, what happened to the machine nearby (a display unplugged, a sleep), and the events most
|
||||
worth tracing first with the reason each was chosen.
|
||||
|
||||
Notes by the author `script` are markers a script dropped while recording (`komorebi-recorder mark`),
|
||||
naming the steps of the repro; read them as the timeline of what was being done.
|
||||
|
||||
Check `skew` before trusting any source location: it says whether komorebi's source is the commit
|
||||
that was recorded. If not, check out the recorded commit and rebuild the recorder, or treat source
|
||||
locations as hints.
|
||||
|
||||
@@ -458,6 +458,27 @@ impl Open {
|
||||
}
|
||||
}
|
||||
|
||||
// notes, and the markers a script dropped with `mark`: a tick, in the bugs lane
|
||||
for note in self.loaded.notes() {
|
||||
let x = view.x(note.start_video_s, left, width);
|
||||
if x < left || x > area.right() {
|
||||
continue;
|
||||
}
|
||||
let selected = self.selected_bug.as_deref() == Some(note.id.as_str());
|
||||
let colour = if selected {
|
||||
Color32::WHITE
|
||||
} else {
|
||||
Color32::from_rgb(120, 190, 235)
|
||||
};
|
||||
painter.line_segment(
|
||||
[
|
||||
Pos2::new(x, bugs_strip.top() + 1.0),
|
||||
Pos2::new(x, bugs_strip.bottom() - 1.0),
|
||||
],
|
||||
Stroke::new(2.0_f32, colour),
|
||||
);
|
||||
}
|
||||
|
||||
// the range being picked
|
||||
if let Some((from, to)) = self.selection {
|
||||
let (x0, x1) = (view.x(from, left, width), view.x(to, left, width));
|
||||
@@ -821,7 +842,13 @@ impl Open {
|
||||
.find(|bug| {
|
||||
time >= bug.start_video_s - reach && time <= bug.end_video_s + reach
|
||||
})
|
||||
.map(|bug| (bug.id.clone(), bug.start_video_s));
|
||||
.map(|bug| (bug.id.clone(), bug.start_video_s))
|
||||
.or_else(|| {
|
||||
self.loaded
|
||||
.notes()
|
||||
.find(|note| (note.start_video_s - time).abs() <= reach)
|
||||
.map(|note| (note.id.clone(), note.start_video_s))
|
||||
});
|
||||
match hit {
|
||||
Some((id, start)) => {
|
||||
self.selected_bug = Some(id);
|
||||
@@ -918,6 +945,20 @@ impl Open {
|
||||
timecode::format(bug.end_video_s),
|
||||
bug.text
|
||||
)
|
||||
})
|
||||
.or_else(|| {
|
||||
self.loaded
|
||||
.notes()
|
||||
.find(|note| (note.start_video_s - time).abs() <= reach)
|
||||
.map(|note| {
|
||||
format!(
|
||||
"{} · note by {}
|
||||
{}",
|
||||
timecode::format(note.start_video_s),
|
||||
note.author,
|
||||
note.text
|
||||
)
|
||||
})
|
||||
}),
|
||||
Some(Lane::Screen) => self.changes.as_ref().and_then(|changes| {
|
||||
changes
|
||||
|
||||
@@ -235,6 +235,14 @@ impl Loaded {
|
||||
.filter(|annotation| annotation.kind == annotations::Kind::Bug)
|
||||
}
|
||||
|
||||
/// Returns the notes (the annotations of kind [`Kind::Note`](annotations::Kind::Note)), in
|
||||
/// time order. A marker dropped by `mark` is one, with the same start and end.
|
||||
pub fn notes(&self) -> impl Iterator<Item = &AnnotationView> {
|
||||
self.annotations
|
||||
.iter()
|
||||
.filter(|annotation| annotation.kind == annotations::Kind::Note)
|
||||
}
|
||||
|
||||
/// Returns the event with sequence number `seq`, if there is one.
|
||||
///
|
||||
/// The search is linear in the number of events.
|
||||
|
||||
@@ -0,0 +1,118 @@
|
||||
//! `mark` through the real binary, against a synthetic session whose recorder lock is held by the
|
||||
//! test, the way a recorder holds it.
|
||||
|
||||
use komorebi_recorder::lock::RecorderLock;
|
||||
use komorebi_recorder::testkit::SessionBuilder;
|
||||
use serde_json::Value;
|
||||
use std::process::Command;
|
||||
use std::process::Output;
|
||||
|
||||
fn recorder(args: &[&str]) -> Output {
|
||||
Command::new(env!("CARGO_BIN_EXE_komorebi-recorder"))
|
||||
.args(args)
|
||||
// never pick up the environment of whoever runs the tests
|
||||
.env_remove("KOMOREBI_RECORDER_SESSION")
|
||||
.output()
|
||||
.expect("run komorebi-recorder")
|
||||
}
|
||||
|
||||
fn stdout(output: &Output) -> String {
|
||||
String::from_utf8_lossy(&output.stdout).into_owned()
|
||||
}
|
||||
|
||||
fn json(output: &Output) -> Value {
|
||||
serde_json::from_slice(&output.stdout)
|
||||
.unwrap_or_else(|error| panic!("not JSON ({error}): {}", stdout(output)))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_marker_lands_on_a_session_being_recorded_and_is_listed_like_a_note() {
|
||||
let (session, _) = SessionBuilder::new("mark-running").build();
|
||||
let dir = session.dir.display().to_string();
|
||||
let _lock = RecorderLock::acquire(&session.dir).expect("hold the recorder lock");
|
||||
|
||||
// `annotations` and `brief` refuse nothing here, but `view`-style loading would: marking must
|
||||
// not depend on it
|
||||
let first = recorder(&["mark", "step 1: open it", "--session", &dir]);
|
||||
assert!(
|
||||
first.status.success(),
|
||||
"{}",
|
||||
String::from_utf8_lossy(&first.stderr)
|
||||
);
|
||||
let text = stdout(&first);
|
||||
assert!(text.starts_with("marked "), "{text}");
|
||||
assert!(
|
||||
text.contains("(a-") && text.trim_end().ends_with("step 1: open it"),
|
||||
"{text}"
|
||||
);
|
||||
|
||||
let second = recorder(&["mark", "step 2", "--session", &dir, "--json"]);
|
||||
assert!(second.status.success());
|
||||
let envelope = json(&second);
|
||||
assert_eq!(envelope["schema"], "mark/1");
|
||||
assert_eq!(envelope["ok"], true);
|
||||
assert_eq!(envelope["data"]["kind"], "note");
|
||||
assert_eq!(envelope["data"]["text"], "step 2");
|
||||
assert!(envelope["data"]["at_mach_ns"].as_u64().is_some());
|
||||
|
||||
let listed = recorder(&["annotations", &dir, "--json", "--kind", "note"]);
|
||||
let annotations = json(&listed)["data"]["annotations"].clone();
|
||||
let annotations = annotations.as_array().expect("array");
|
||||
assert_eq!(annotations.len(), 2);
|
||||
for note in annotations {
|
||||
assert_eq!(note["author"], "script");
|
||||
assert_eq!(note["open_ended"], false);
|
||||
assert_eq!(note["start_mach_ns"], note["end_mach_ns"]);
|
||||
}
|
||||
|
||||
let brief = json(&recorder(&["brief", &dir, "--json"]));
|
||||
assert_eq!(
|
||||
brief["data"]["notes"].as_array().map(Vec::len),
|
||||
Some(2),
|
||||
"{brief}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_environment_names_the_session() {
|
||||
let (session, _) = SessionBuilder::new("mark-env").build();
|
||||
let _lock = RecorderLock::acquire(&session.dir).expect("hold the recorder lock");
|
||||
|
||||
let output = Command::new(env!("CARGO_BIN_EXE_komorebi-recorder"))
|
||||
.args(["mark", "from the environment"])
|
||||
.env("KOMOREBI_RECORDER_SESSION", &session.dir)
|
||||
.output()
|
||||
.expect("run");
|
||||
assert!(
|
||||
output.status.success(),
|
||||
"{}",
|
||||
String::from_utf8_lossy(&output.stderr)
|
||||
);
|
||||
let file = std::fs::read_to_string(session.dir.join("annotations.jsonl")).expect("written");
|
||||
assert!(file.contains("from the environment"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_finished_session_is_refused_and_pointed_at_annotate() {
|
||||
let (session, _) = SessionBuilder::new("mark-finished").build();
|
||||
let dir = session.dir.display().to_string();
|
||||
|
||||
let output = recorder(&["mark", "too late", "--session", &dir, "--json"]);
|
||||
assert_eq!(output.status.code(), Some(2));
|
||||
assert!(String::from_utf8_lossy(&output.stderr).contains("annotate"));
|
||||
assert_eq!(json(&output)["ok"], false);
|
||||
assert!(!session.dir.join("annotations.jsonl").exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn no_session_to_mark_is_not_found() {
|
||||
let missing = std::env::temp_dir().join("komorebi-recorder-no-such-session");
|
||||
let output = recorder(&[
|
||||
"mark",
|
||||
"nobody is listening",
|
||||
"--session",
|
||||
&missing.display().to_string(),
|
||||
]);
|
||||
assert_eq!(output.status.code(), Some(3));
|
||||
assert!(String::from_utf8_lossy(&output.stderr).contains("not a session directory"));
|
||||
}
|
||||
Reference in new issue
Block a user