[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[nongnu] elpa/subed 82e137352d 3/5: Handle subed-enforce-time-boundaries
|
From: |
ELPA Syncer |
|
Subject: |
[nongnu] elpa/subed 82e137352d 3/5: Handle subed-enforce-time-boundaries values of error, adjust, and clip |
|
Date: |
Tue, 7 Mar 2023 19:01:15 -0500 (EST) |
branch: elpa/subed
commit 82e137352d723370a2604f15135b02201d922228
Author: Sacha Chua <sacha@sachachua.com>
Commit: Sacha Chua <sacha@sachachua.com>
Handle subed-enforce-time-boundaries values of error, adjust, and clip
* subed/subed-common.el (set-subtitle-time-start): Handle
subed-enforce-time-boundaries values of error, adjust, and clip.
(set-subtitle-time-stop): Handle subed-enforce-time-boundaries values
of error, adjust, and clip.
(subed-adjust-subtitle-time-start): Return time adjusted.
(subed-adjust-subtitle-time-stop): Return time adjusted.
(subed--scale-subtitles-in-region): Check for nonchronological
subtitles before moving.
(subed-disable-sync-point-to-player-temporarily): Check timer.
(subed-trim-overlap-stop): Use subed-set-subtitle-time-stop and return
the new stop time.
(subed-trim-overlap-next-start): Use subed-set-subtitle-time-start and
return the new start time.
* subed/subed-config.el (subed-enforce-time-boundaries): Document
'clip and add it as an option.
* tests/test-subed-common.el (with-temp-srt-buffer): Don't set the
buffer file name. Tweak the test cases to deal with
subed-enforce-time-boundaries, and tweak some of the wording changes
as well. Not sure, this feels like it needs more testing.
---
subed/subed-common.el | 217 +-
subed/subed-config.el | 6 +-
tests/test-subed-common.el | 5480 +++++++++++++++++++++++---------------------
3 files changed, 2976 insertions(+), 2727 deletions(-)
diff --git a/subed/subed-common.el b/subed/subed-common.el
index fbf995097a..77483ebeb2 100644
--- a/subed/subed-common.el
+++ b/subed/subed-common.el
@@ -355,30 +355,40 @@ If SUB-ID is not given, set the text of the current
subtitle."
If SUB-ID is not given, set the start of the current subtitle.
-Unless either IGNORE-NEGATIVE-DURATION is non-nil or
-`subed-enforce-time-boundaries' is nil, throw an error if
-the start time will be after the stop time. Zero-length
-subtitles are allowed.
-
-Unless either IGNORE-OVERLAP is non-nil or `subed-enforce-time-boundaries'
-is nil, ensure that there are no gaps between subtitles
-smaller than `subed-subtitle-spacing' milliseconds by adjusting
-MSECS if necessary.
+If `subed-enforce-time-boundaries' is set to 'adjust, adjust the
+current subtitle's stop time to avoid negative durations (unless
+IGNORE-NEGATIVE-DURATION is non-nil) and adjust the previous
+subtitle's stop time to maintain `subed-subtitle-spacing' (unless
+IGNORE-OVERLAP is non-nil) if needed. If
+`subed-enforce-time-boundaries' is set to 'error, throw an error
+in those cases. If `subed-enforce-time-boundaries' is nil, make
+the changes without checking.
Return the new subtitle start time in milliseconds."
(save-excursion
(when (or (not sub-id)
(and sub-id (subed-jump-to-subtitle-id sub-id)))
+ (when (< msecs 0)
+ (if (eq subed-enforce-time-boundaries
'error)
+ (error "Start time %d is
negative." msecs)
+ (setq msecs 0)))
(when (and
(not ignore-negative-duration)
subed-enforce-time-boundaries
(> msecs
(subed-subtitle-msecs-stop)))
- (if (eq subed-enforce-time-boundaries 'error)
- (error "Start time %s will be
after stop time %s"
-
(subed-msecs-to-timestamp msecs)
-
(subed-msecs-to-timestamp (subed-subtitle-msecs-stop)))
- (let ((subed-enforce-time-boundaries
nil))
- (subed-set-subtitle-time-stop
msecs))))
+ (pcase subed-enforce-time-boundaries
+ ('error
+ (error "Start time %s will be after
stop time %s"
+
(subed-msecs-to-timestamp msecs)
+
(subed-msecs-to-timestamp (subed-subtitle-msecs-stop))))
+ ('clip
+ (setq msecs
(subed-subtitle-msecs-stop))
+ (message "Clipping to %s"
(subed-msecs-to-timestamp msecs)))
+ ('adjust
+ (let ((subed-enforce-time-boundaries
nil))
+ (subed-set-subtitle-time-stop
msecs)
+ (message "Adjusted stop time
to %s to avoid negative duration"
+
(subed-msecs-to-timestamp (subed-subtitle-msecs-stop)))))))
(when (and subed-enforce-time-boundaries
(not
ignore-overlap))
(subed-save-excursion
@@ -386,16 +396,26 @@ Return the new subtitle start time in milliseconds."
subed-subtitle-spacing
(> (subed-subtitle-msecs-stop)
(- msecs subed-subtitle-spacing)))
- (if (eq subed-enforce-time-boundaries
'error)
- (error "Start time %s
will be too close to previous stop time of %s"
-
(subed-msecs-to-timestamp msecs)
-
(subed-msecs-to-timestamp (subed-subtitle-msecs-stop)))
- (let
((subed-enforce-time-boundaries nil))
-
(subed-set-subtitle-time-stop (- msecs subed-subtitle-spacing)))))))
+ (pcase subed-enforce-time-boundaries
+ ('error
+ (error "Start time %s
will be too close to previous stop time of %s"
+
(subed-msecs-to-timestamp msecs)
+
(subed-msecs-to-timestamp (subed-subtitle-msecs-stop))))
+ ('clip
+ (setq msecs (+
(subed-subtitle-msecs-stop) subed-subtitle-spacing))
+ (message "Clipping to
%s to maintain spacing from previous stop time of %s"
+
msecs
+
(subed-subtitle-msecs-stop)))
+ ('adjust
+ (let
((subed-enforce-time-boundaries nil))
+
(subed-set-subtitle-time-stop (- msecs subed-subtitle-spacing))
+ (message
"Adjusted previous stop time to %s to maintain spacing"
+
(subed-msecs-to-timestamp (subed-subtitle-msecs-stop)))))))))
(when (and (subed-jump-to-subtitle-time-start sub-id)
(looking-at subed--regexp-timestamp))
(replace-match
- (save-match-data (subed-msecs-to-timestamp msecs)))))))
+ (save-match-data (subed-msecs-to-timestamp msecs)))
+ (subed-subtitle-msecs-start)))))
(subed-define-generic-function set-subtitle-time-stop (msecs &optional sub-id
ignore-negative-duration
@@ -404,30 +424,38 @@ Return the new subtitle start time in milliseconds."
If SUB-ID is not given, set the stop of the current subtitle.
-Unless either IGNORE-NEGATIVE-DURATION is non-nil or
-`subed-enforce-time-boundaries' is nil, throw an error if
-the start time will be after the stop time. Zero-length
-subtitles are allowed.
-
-Unless either IGNORE-OVERLAP is non-nil or `subed-enforce-time-boundaries'
-is nil, ensure that there are no gaps between subtitles
-smaller than `subed-subtitle-spacing' milliseconds by adjusting
-MSECS if necessary.
+If `subed-enforce-time-boundaries' is set to 'adjust, adjust the
+current subtitle's start time to avoid negative durations (unless
+IGNORE-NEGATIVE-DURATION is non-nil) and adjust the next
+subtitle's start time to maintain
+`subed-subtitle-spacing' (unless IGNORE-OVERLAP is non-nil) if
+needed. If `subed-enforce-time-boundaries' is set to 'error,
+throw an error in those cases. If
+`subed-enforce-time-boundaries' is nil, make the changes without
+checking.
Return the new subtitle stop time in milliseconds."
(save-excursion
(when (or (not sub-id)
(and sub-id (subed-jump-to-subtitle-id sub-id)))
- (when (subed-jump-to-subtitle-time-stop sub-id)
- (when (and subed-enforce-time-boundaries
- (not
ignore-negative-duration)
- (<
msecs (subed-subtitle-msecs-start)))
- (if (eq subed-enforce-time-boundaries
'error)
- (error "Stop time %s
will be before start time %s"
-
(subed-msecs-to-timestamp msecs)
-
(subed-msecs-to-timestamp (subed-subtitle-msecs-start)))
- (let
((subed-enforce-time-boundaries nil))
-
(subed-set-subtitle-time-start msecs)))))
+ (let ((current-start (subed-subtitle-msecs-start)))
+ (when (subed-jump-to-subtitle-time-stop sub-id)
+ (when (and subed-enforce-time-boundaries
+
(not ignore-negative-duration)
+
(< msecs current-start))
+ (pcase
subed-enforce-time-boundaries
+ ('error
+ (error "Stop time %s
will be before start time %s"
+
(subed-msecs-to-timestamp msecs)
+
(subed-msecs-to-timestamp current-start)))
+ ('clip
+ (message "Clipping
time to %s" (subed-msecs-to-timestamp current-start))
+ (setq msecs
(subed-subtitle-msecs-start)))
+ ('adjust
+ (let
((subed-enforce-time-boundaries nil))
+
(subed-set-subtitle-time-start msecs)
+ (message
"Adjusted start time to %s to avoid negative duration"
+
(subed-msecs-to-timestamp current-start))))))))
(when (and subed-enforce-time-boundaries
(not
ignore-overlap))
(subed-save-excursion
@@ -435,17 +463,26 @@ Return the new subtitle stop time in milliseconds."
subed-subtitle-spacing
(< (subed-subtitle-msecs-start)
(+ msecs subed-subtitle-spacing)))
- (if (eq subed-enforce-time-boundaries
'error)
- (error "Stop time %s
will be too close to next start time of %s"
-
(subed-msecs-to-timestamp msecs)
-
(subed-msecs-to-timestamp (subed-subtitle-msecs-start)))
- (let
((subed-enforce-time-boundaries nil))
-
(subed-set-subtitle-time-start (+ msecs subed-subtitle-spacing)))))))
+ (pcase subed-enforce-time-boundaries
+ ('error
+ (error "Stop time %s
will be too close to next start time of %s"
+
(subed-msecs-to-timestamp msecs)
+
(subed-msecs-to-timestamp (subed-subtitle-msecs-start))))
+ ('clip
+ (setq msecs (-
(subed-subtitle-msecs-start) subed-subtitle-spacing))
+ (message "Clipping to
%s to preserve spacing"
+
(subed-msecs-to-timestamp msecs)))
+ ('adjust
+ (let
((subed-enforce-time-boundaries nil))
+
(subed-set-subtitle-time-start (+ msecs subed-subtitle-spacing))
+ (message
"Adjusted next start time to %s to maintain spacing"
+
(subed-msecs-to-timestamp (subed-subtitle-msecs-start)))))))))
(when (and
(subed-jump-to-subtitle-time-stop)
(looking-at
subed--regexp-timestamp))
(replace-match
- (save-match-data (subed-msecs-to-timestamp
msecs)))))))
+ (save-match-data (subed-msecs-to-timestamp
msecs)))
+ (subed-subtitle-msecs-stop)))))
(subed-define-generic-function make-subtitle (&optional id start stop text
comment)
"Generate new subtitle string.
@@ -675,9 +712,10 @@ nil if nothing changed."
(when msecs-new
;; MSECS-NEW must be bigger than the current start time if we are adding
;; or smaller if we are subtracting.
- (subed-set-subtitle-time-start msecs-new nil
-
ignore-negative-duration
-
ignore-overlap)
+ (setq msecs-new
+ (subed-set-subtitle-time-start
msecs-new nil
+
ignore-negative-duration
+
ignore-overlap))
(subed--run-subtitle-time-adjusted-hook)
(- msecs-new msecs-start))))
@@ -703,10 +741,11 @@ nil if nothing changed."
(msecs-new (when msecs-stop (+ msecs-stop msecs))))
;; MSECS-NEW must be bigger than the current stop time if we are adding or
;; smaller if we are subtracting.
- (when (and (>= msecs-new 0) ;; Ignore
negative times
- (or (and (> msecs 0) (> msecs-new msecs-stop)) ;; Adding
- (and (< msecs 0) (< msecs-new msecs-stop)))) ;; Subtracting
- (subed-set-subtitle-time-stop msecs-new nil ignore-negative-duration
ignore-overlap)
+ (when (and (>= msecs-new 0) ;; Ignore negative times
+ (or (and (> msecs 0) (> msecs-new msecs-stop)) ;; Adding
+ (and (< msecs 0) (< msecs-new msecs-stop)))) ;;
Subtracting
+ (setq msecs-new
+ (subed-set-subtitle-time-stop
msecs-new nil ignore-negative-duration ignore-overlap))
(subed--run-subtitle-time-adjusted-hook)
(- msecs-new msecs-stop))))
@@ -859,7 +898,24 @@ subtitles by the same offset, use `subed-move-subtitles'
instead."
;; check for range with 0 time interval
(unless (/= beg-start-msecs old-end-start-msecs)
(user-error "Can't scale subtitle range with 0 time interval"))
-
+ ;; check for overlap
+ (when (and (> msecs 0) (eq subed-enforce-time-boundaries
'error))
+ (subed-save-excursion
+ (goto-char end-point)
+ (let ((old-stop (subed-subtitle-msecs-stop)))
+ (when (and (subed-forward-subtitle-time-start)
+
(> (+ old-stop msecs subed-subtitle-spacing)
+
(subed-subtitle-msecs-start)))
+ (user-error "Can't scale when
extension would overlap subsequent subtitles")))))
+ ;; check for non-chronological: last will start before previous
subtitle stops
+ (let ((list
+ (subed-subtitle-list beg end)))
+ ;; make sure each subtitle ends before the next
subtitle starts
+ (while list
+ (when (and (cdr list)
+ (>
(elt (car list) 2) (elt (cadr list) 1)))
+ (user-error "Can't scale when
nonchronological subtitles exist"))
+ (setq list (cdr list))))
(unless (= msecs 0)
(subed-with-subtitle-replay-disabled
(cl-flet ((move-subtitle (subed--get-move-subtitle-func msecs)))
@@ -886,10 +942,7 @@ subtitles by the same offset, use `subed-move-subtitles'
instead."
;; Moving forward - Start on last subtitle to see if we
;; can move forward.
(goto-char end)
- (let ((adjusted-msecs (move-subtitle msecs)))
- (unless (and adjusted-msecs
- (= msecs adjusted-msecs))
- (user-error "Can't scale when extension would overlap
subsequent subtitles")))
+ (move-subtitle msecs)
(funcall scale-subtitles :reverse))
(save-excursion
;; Moving backward - Make sure the last subtitle will not
@@ -932,8 +985,8 @@ subtitles by the same offset, use `subed-move-subtitles'
instead."
(unless (setq msecs (move-subtitle msecs))
(throw 'bumped-into-subtitle t))
(subed-forward-subtitle-id)
- (subed-for-each-subtitle (point) end nil
- (move-subtitle msecs :ignore-negative-duration)))))))))
+
(subed-for-each-subtitle (point) end nil
+ (move-subtitle
msecs :ignore-negative-duration)))))))))
(defun subed-scale-subtitles (msecs &optional beg end)
"Scale subtitles between BEG and END after moving END MSECS.
@@ -1513,7 +1566,8 @@ If QUIET is non-nil, do not display a message in the
minibuffer."
After `subed-point-sync-delay-after-motion' seconds point is re-synced."
(if subed--point-sync-delay-after-motion-timer
- (cancel-timer subed--point-sync-delay-after-motion-timer)
+ (when (timerp
subed--point-sync-delay-after-motion-timer)
+ (cancel-timer
subed--point-sync-delay-after-motion-timer))
(setq subed--point-was-synced (subed-sync-point-to-player-p)))
(when subed--point-was-synced
(subed-disable-sync-point-to-player :quiet))
@@ -1953,21 +2007,25 @@ the start times instead."
Trim the end time of the current subtitle to MSECS or
`subed-subtitle-spacing' less than the start time of the next
-subtitle. Unless either IGNORE-NEGATIVE-DURATION or
+subtitle, if needed. Unless either IGNORE-NEGATIVE-DURATION or
`subed-enforce-time-boundaries' are non-nil, adjust MSECS so that
-the stop time isn't smaller than the start time."
+the stop time isn't smaller than the start time.
+
+Return the new stop time."
(interactive "P")
(let ((next-sub-start-time (save-excursion
(and
(subed-forward-subtitle-time-start)
(subed-subtitle-msecs-start))))
(this-sub-stop-time (subed-subtitle-msecs-stop)))
- (when (and next-sub-start-time this-sub-stop-time)
- (subed-adjust-subtitle-time-stop
- (min 0
- (- (- next-sub-start-time
- (if (numberp msecs) msecs subed-subtitle-spacing))
- this-sub-stop-time))
+ (when (and next-sub-start-time this-sub-stop-time
+ (> this-sub-stop-time
+ (-
next-sub-start-time
+
(if (numberp msecs) msecs subed-subtitle-spacing))))
+ (subed-set-subtitle-time-stop
+ (- next-sub-start-time
+ (if (numberp msecs) msecs subed-subtitle-spacing))
+ nil
ignore-negative-duration
t))))
@@ -1978,7 +2036,9 @@ Trim the start time of the next subtitle to MSECS or
`subed-subtitle-spacing' greater than the end time of the current
subtitle. Unless either IGNORE-NEGATIVE-DURATION or
`subed-enforce-time-boundaries' are non-nil, adjust MSECS so that
-the stop time isn't smaller than the start time."
+the stop time isn't smaller than the start time.
+
+Return the new start time."
(interactive "P")
(save-excursion
(let ((this-sub-stop-time (subed-subtitle-msecs-stop))
@@ -1987,12 +2047,13 @@ the stop time isn't smaller than the start time."
(subed-subtitle-msecs-start))))
(when (and this-sub-stop-time
next-sub-start-time
- (or msecs subed-subtitle-spacing))
- (subed-adjust-subtitle-time-start
- (max 0
- (-
- (+ this-sub-stop-time (or msecs subed-subtitle-spacing))
- next-sub-start-time))
+ (or msecs subed-subtitle-spacing)
+ (<
next-sub-start-time
+
(+ this-sub-stop-time
+
(if (numberp msecs) msecs subed-subtitle-spacing))))
+ (subed-set-subtitle-time-start
+ (+ this-sub-stop-time (or msecs
subed-subtitle-spacing))
+ nil
ignore-negative-duration
t)))))
diff --git a/subed/subed-config.el b/subed/subed-config.el
index 4f82726aa5..7507afd374 100644
--- a/subed/subed-config.el
+++ b/subed/subed-config.el
@@ -164,12 +164,14 @@ If set to zero or smaller, playback is paused."
- 'adjust means adjust the stop or start time of the current subtitle to
keep duration >= 0, and adjust the previous or next subtitle as needed
to maintain `subed-subtitle-spacing'.
-- 'error means report an error.
+- 'clip means limit the change to the maximum it can be within the boundaries.
+- 'error means report an error if there will be overlaps or negative duration.
- nil means perform the change without checking.
-Other values aside from the ones specified above will be treated as 'adjust."
+Other values aside from the ones specified above will be treated as nil."
:type '(choice
(const :tag "Adjust other times as
needed" adjust)
+ (const :tag "Limit changes" clip)
(const :tag "Report an error" error)
(const :tag "Do not check" nil))
:group 'subed)
diff --git a/tests/test-subed-common.el b/tests/test-subed-common.el
index d61d0db2b0..fab57b24cf 100644
--- a/tests/test-subed-common.el
+++ b/tests/test-subed-common.el
@@ -23,730 +23,743 @@ Baz.
(declare (indent defun))
`(with-temp-buffer
;; subed--init uses file extension to detect format
- (setq buffer-file-name "test.srt")
(subed-srt-mode)
(progn ,@body)))
(describe "COMMON"
(describe "Iterating over subtitles"
- (it "without providing beginning and end."
- (with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-time-stop 1)
- (subed-for-each-subtitle nil nil nil
- (expect (looking-at "^[0-9]$") :to-be t)
- (forward-line 2)
- (kill-line)
- (insert "Hello."))
- (expect (subed-subtitle-text 1) :to-equal "Hello.")
- (expect (subed-subtitle-text 2) :to-equal "Bar.")
- (expect (subed-subtitle-text 3) :to-equal "Baz.")
- (expect (point) :to-equal 20)
- (subed-jump-to-subtitle-time-stop 2)
- (subed-for-each-subtitle nil nil nil
- (expect (looking-at "^[0-9]$") :to-be t)
- (forward-line 2)
- (kill-line)
- (insert "HEllo."))
- (expect (subed-subtitle-text 1) :to-equal "Hello.")
- (expect (subed-subtitle-text 2) :to-equal "HEllo.")
- (expect (subed-subtitle-text 3) :to-equal "Baz.")
- (expect (point) :to-equal 60)
- (subed-jump-to-subtitle-time-stop 3)
- (subed-for-each-subtitle nil nil nil
- (expect (looking-at "^[0-9]$") :to-be t)
- (forward-line 2)
- (kill-line)
- (insert "HELlo."))
- (expect (subed-subtitle-text 1) :to-equal "Hello.")
- (expect (subed-subtitle-text 2) :to-equal "HEllo.")
- (expect (subed-subtitle-text 3) :to-equal "HELlo.")
- (expect (point) :to-equal 99)))
- (describe "providing only the beginning"
- (it "forwards."
- (with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-time-start 1)
- (expect (point) :to-equal 3)
- (let ((new-texts (list "A" "B" "C")))
- (subed-for-each-subtitle 71 nil nil
- (expect (looking-at "^[0-9]$") :to-be t)
- (forward-line 2)
- (kill-line)
- (insert (pop new-texts))))
- (expect (subed-subtitle-text 1) :to-equal "Foo.")
- (expect (subed-subtitle-text 2) :to-equal "A")
- (expect (subed-subtitle-text 3) :to-equal "B")
- (expect (point) :to-equal 3)))
- (it "backwards."
- (with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-time-stop 3)
- (expect (point) :to-equal 95)
- (let ((new-texts (list "A" "B" "C")))
- (subed-for-each-subtitle 75 nil :reverse
- (expect (looking-at "^[0-9]$") :to-be t)
- (forward-line 2)
- (kill-line)
- (insert (pop new-texts))))
- (expect (subed-subtitle-text 1) :to-equal "Foo.")
- (expect (subed-subtitle-text 2) :to-equal "B")
- (expect (subed-subtitle-text 3) :to-equal "A")
- (expect (point) :to-equal 92)))
- )
- (describe "providing beginning and end,"
- (describe "excluding subtitles above"
- (it "forwards."
- (with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-time-stop 1)
- (expect (point) :to-equal 20)
- (let ((new-texts (list "A" "B" "C")))
- (subed-for-each-subtitle 71 79 nil
- (expect (looking-at "^[0-9]$") :to-be t)
- (forward-line 2)
- (kill-line)
- (insert (pop new-texts))))
- (expect (subed-subtitle-text 1) :to-equal "Foo.")
- (expect (subed-subtitle-text 2) :to-equal "A")
- (expect (subed-subtitle-text 3) :to-equal "B")
- (expect (point) :to-equal 20)))
- (it "backwards."
- (with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-time-start 3)
- (expect (point) :to-equal 79)
- (let ((new-texts (list "A" "B" "C")))
- (subed-for-each-subtitle 39 77 :reverse
- (expect (looking-at "^[0-9]$") :to-be t)
- (forward-line 2)
- (kill-line)
- (insert (pop new-texts))))
- (expect (subed-subtitle-text 1) :to-equal "Foo.")
- (expect (subed-subtitle-text 2) :to-equal "B")
- (expect (subed-subtitle-text 3) :to-equal "A")
- (expect (point) :to-equal 76)))
- )
- (describe "excluding subtitles below"
- (it "forwards."
- (with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-text 3)
- (expect (point) :to-equal 106)
- (let ((new-texts (list "A" "B" "C")))
- (subed-for-each-subtitle 5 76 nil
- (expect (looking-at "^[0-9]$") :to-be t)
- (forward-line 2)
- (kill-line)
- (insert (pop new-texts))))
- (expect (subed-subtitle-text 1) :to-equal "A")
- (expect (subed-subtitle-text 2) :to-equal "B")
- (expect (subed-subtitle-text 3) :to-equal "Baz.")
- (expect (point) :to-equal 100)))
- (it "backwards."
- (with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-time-stop 2)
- (expect (point) :to-equal 58)
- (let ((new-texts (list "A" "B" "C")))
- (subed-for-each-subtitle 20 76 :reverse
- (expect (looking-at "^[0-9]$") :to-be t)
- (forward-line 2)
- (kill-line)
- (insert (pop new-texts))))
- (expect (subed-subtitle-text 1) :to-equal "B")
- (expect (subed-subtitle-text 2) :to-equal "A")
- (expect (subed-subtitle-text 3) :to-equal "Baz.")
- (expect (point) :to-equal 55)))
- )
- )
- )
+ (describe "without providing beginning and end"
+ (it "goes through each subtitle."
+ (with-temp-srt-buffer
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-time-stop 1)
+ (subed-for-each-subtitle nil nil nil
+ (expect (looking-at "^[0-9]$")
:to-be t)
+ (forward-line 2)
+ (kill-line)
+ (insert "Hello."))
+ (expect (subed-subtitle-text 1)
:to-equal "Hello.")
+ (expect (subed-subtitle-text 2)
:to-equal "Bar.")
+ (expect (subed-subtitle-text 3)
:to-equal "Baz.")
+ (expect (point) :to-equal 20)
+ (subed-jump-to-subtitle-time-stop 2)
+ (subed-for-each-subtitle nil nil nil
+ (expect (looking-at "^[0-9]$")
:to-be t)
+ (forward-line 2)
+ (kill-line)
+ (insert "HEllo."))
+ (expect (subed-subtitle-text 1)
:to-equal "Hello.")
+ (expect (subed-subtitle-text 2)
:to-equal "HEllo.")
+ (expect (subed-subtitle-text 3)
:to-equal "Baz.")
+ (expect (point) :to-equal 60)
+ (subed-jump-to-subtitle-time-stop 3)
+ (subed-for-each-subtitle nil nil nil
+ (expect (looking-at "^[0-9]$")
:to-be t)
+ (forward-line 2)
+ (kill-line)
+ (insert "HELlo."))
+ (expect (subed-subtitle-text 1)
:to-equal "Hello.")
+ (expect (subed-subtitle-text 2)
:to-equal "HEllo.")
+ (expect (subed-subtitle-text 3)
:to-equal "HELlo.")
+ (expect (point) :to-equal 99))))
+ (describe "providing only the beginning"
+ (it "goes forward."
+ (with-temp-srt-buffer
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-time-start 1)
+ (expect (point) :to-equal 3)
+ (let ((new-texts (list "A" "B" "C")))
+ (subed-for-each-subtitle 71 nil
nil
+ (expect (looking-at
"^[0-9]$") :to-be t)
+ (forward-line 2)
+ (kill-line)
+ (insert (pop
new-texts))))
+ (expect (subed-subtitle-text 1)
:to-equal "Foo.")
+ (expect (subed-subtitle-text 2)
:to-equal "A")
+ (expect (subed-subtitle-text 3)
:to-equal "B")
+ (expect (point) :to-equal 3)))
+ (it "goes backward."
+ (with-temp-srt-buffer
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-time-stop 3)
+ (expect (point) :to-equal 95)
+ (let ((new-texts (list "A" "B" "C")))
+ (subed-for-each-subtitle 75 nil
:reverse
+ (expect (looking-at
"^[0-9]$") :to-be t)
+ (forward-line 2)
+ (kill-line)
+ (insert (pop
new-texts))))
+ (expect (subed-subtitle-text 1)
:to-equal "Foo.")
+ (expect (subed-subtitle-text 2)
:to-equal "B")
+ (expect (subed-subtitle-text 3)
:to-equal "A")
+ (expect (point) :to-equal 92)))
+ )
+ (describe "providing beginning and end,"
+ (describe "excluding subtitles above"
+ (it "goes forward."
+ (with-temp-srt-buffer
+ (insert mock-srt-data)
+
(subed-jump-to-subtitle-time-stop 1)
+ (expect (point) :to-equal 20)
+ (let ((new-texts (list "A" "B"
"C")))
+
(subed-for-each-subtitle 71 79 nil
+ (expect
(looking-at "^[0-9]$") :to-be t)
+ (forward-line 2)
+ (kill-line)
+ (insert (pop
new-texts))))
+ (expect (subed-subtitle-text 1)
:to-equal "Foo.")
+ (expect (subed-subtitle-text 2)
:to-equal "A")
+ (expect (subed-subtitle-text 3)
:to-equal "B")
+ (expect (point) :to-equal 20)))
+ (it "goes backward."
+ (with-temp-srt-buffer
+ (insert mock-srt-data)
+
(subed-jump-to-subtitle-time-start 3)
+ (expect (point) :to-equal 79)
+ (let ((new-texts (list "A" "B"
"C")))
+
(subed-for-each-subtitle 39 77 :reverse
+ (expect
(looking-at "^[0-9]$") :to-be t)
+ (forward-line 2)
+ (kill-line)
+ (insert (pop
new-texts))))
+ (expect (subed-subtitle-text 1)
:to-equal "Foo.")
+ (expect (subed-subtitle-text 2)
:to-equal "B")
+ (expect (subed-subtitle-text 3)
:to-equal "A")
+ (expect (point) :to-equal 76))))
+ (describe "excluding subtitles below"
+ (it "goes forward."
+ (with-temp-srt-buffer
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-text 3)
+ (expect (point) :to-equal 106)
+ (let ((new-texts (list "A" "B"
"C")))
+
(subed-for-each-subtitle 5 76 nil
+ (expect
(looking-at "^[0-9]$") :to-be t)
+ (forward-line 2)
+ (kill-line)
+ (insert (pop
new-texts))))
+ (expect (subed-subtitle-text 1)
:to-equal "A")
+ (expect (subed-subtitle-text 2)
:to-equal "B")
+ (expect (subed-subtitle-text 3)
:to-equal "Baz.")
+ (expect (point) :to-equal 100)))
+ (it "goes backward."
+ (with-temp-srt-buffer
+ (insert mock-srt-data)
+
(subed-jump-to-subtitle-time-stop 2)
+ (expect (point) :to-equal 58)
+ (let ((new-texts (list "A" "B"
"C")))
+
(subed-for-each-subtitle 20 76 :reverse
+ (expect
(looking-at "^[0-9]$") :to-be t)
+ (forward-line 2)
+ (kill-line)
+ (insert (pop
new-texts))))
+ (expect (subed-subtitle-text 1)
:to-equal "B")
+ (expect (subed-subtitle-text 2)
:to-equal "A")
+ (expect (subed-subtitle-text 3)
:to-equal "Baz.")
+ (expect (point) :to-equal 55)))
+ )
+ ))
(describe "Setting subtitle start time"
(describe "when this causes an overlap"
(describe "when time boundaries are enforced by errors"
- :var ((subed-subtitle-spacing 100))
+ ;; lexical binding gets confused at some point
+ (before-all
+ (setq subed-enforce-time-boundaries
'error
+
subed-subtitle-spacing 100))
(it "continues when setting the first
subtitle's start time."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 1)
- (let ((subed-enforce-time-boundaries
'error))
- (subed-set-subtitle-time-start
30000))
- (expect (subed-subtitle-msecs-start)
:to-equal 30000)))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 1)
+ (subed-set-subtitle-time-start
30000)
+ (expect
(subed-subtitle-msecs-start) :to-equal 30000)))
(it "ignores the previous subtitle's stop time
if there's enough spacing."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 2)
- (let ((subed-enforce-time-boundaries
'error))
- (subed-set-subtitle-time-start
(subed-timestamp-to-msecs "00:01:10,000")))
- (expect (subed-subtitle-msecs-start)
:to-equal (subed-timestamp-to-msecs "00:01:10,000"))
- (expect (subed-subtitle-msecs-stop 1)
:to-equal (subed-timestamp-to-msecs "00:01:05,123"))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 2)
+ (let
((subed-enforce-time-boundaries 'error)
+
(subed-subtitle-spacing 100))
+
(subed-set-subtitle-time-start (subed-timestamp-to-msecs "00:01:10,000")))
+ (expect
(subed-subtitle-msecs-start) :to-equal (subed-timestamp-to-msecs
"00:01:10,000"))
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal (subed-timestamp-to-msecs
"00:01:05,123"))))
(it "ignores the previous subtitle's stop time
if spacing is unspecified."
(let ((subed-subtitle-spacing nil)
(subed-enforce-time-boundaries 'error))
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 2)
- (subed-set-subtitle-time-start
(subed-timestamp-to-msecs "00:01:05,000"))
- (expect
(subed-subtitle-msecs-start) :to-equal (subed-timestamp-to-msecs
"00:01:05,000"))
- (expect
(subed-subtitle-msecs-stop 1) :to-equal (subed-timestamp-to-msecs
"00:01:05,123")))))
+ (insert mock-srt-data)
+
(subed-jump-to-subtitle-id 2)
+
(subed-set-subtitle-time-start (subed-timestamp-to-msecs "00:01:05,000"))
+ (expect
(subed-subtitle-msecs-start) :to-equal (subed-timestamp-to-msecs
"00:01:05,000"))
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal (subed-timestamp-to-msecs
"00:01:05,123")))))
(it "reports an error if the change violates
spacing."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 2)
- (let ((subed-enforce-time-boundaries
'error)
-
(subed-subtitle-spacing 100))
- (expect
(subed-set-subtitle-time-start (subed-timestamp-to-msecs "00:01:05,000"))
:to-throw 'error)))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 2)
+ (let
((subed-enforce-time-boundaries 'error)
+
(subed-subtitle-spacing 100))
+ (expect
(subed-set-subtitle-time-start (subed-timestamp-to-msecs "00:01:05,000"))
:to-throw 'error)))))
(describe "when time boundaries are enforced by
adjusting"
(it "continues when setting the first
subtitle's start time."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 1)
- (let ((subed-enforce-time-boundaries
'adjust)
-
(subed-subtitle-spacing 100))
- (subed-set-subtitle-time-start
(subed-timestamp-to-msecs "00:01:00,000")))
- (expect (subed-subtitle-msecs-start)
:to-equal (subed-timestamp-to-msecs "00:01:00,000"))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 1)
+ (let
((subed-enforce-time-boundaries 'adjust)
+
(subed-subtitle-spacing 100))
+
(subed-set-subtitle-time-start (subed-timestamp-to-msecs "00:01:00,000")))
+ (expect
(subed-subtitle-msecs-start) :to-equal (subed-timestamp-to-msecs
"00:01:00,000"))))
(it "ignores the previous subtitle's stop time
if there's enough spacing."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 2)
- (let ((subed-enforce-time-boundaries
'adjust)
-
(subed-subtitle-spacing 100))
- (subed-set-subtitle-time-start
(subed-timestamp-to-msecs "00:01:10,000")))
- (expect (subed-subtitle-msecs-start)
:to-equal (subed-timestamp-to-msecs "00:01:10,000"))
- (expect (subed-subtitle-msecs-stop 1)
:to-equal (subed-timestamp-to-msecs "00:01:05,123"))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 2)
+ (let
((subed-enforce-time-boundaries 'adjust)
+
(subed-subtitle-spacing 100))
+
(subed-set-subtitle-time-start (subed-timestamp-to-msecs "00:01:10,000")))
+ (expect
(subed-subtitle-msecs-start) :to-equal (subed-timestamp-to-msecs
"00:01:10,000"))
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal (subed-timestamp-to-msecs
"00:01:05,123"))))
(it "ignores the previous subtitle's stop time
if spacing is unspecified."
(let ((subed-subtitle-spacing nil)
(subed-enforce-time-boundaries 'adjust))
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 2)
- (subed-set-subtitle-time-start
(subed-timestamp-to-msecs "00:01:05,000"))
- (expect
(subed-subtitle-msecs-start) :to-equal (subed-timestamp-to-msecs
"00:01:05,000"))
- (expect
(subed-subtitle-msecs-stop 1) :to-equal (subed-timestamp-to-msecs
"00:01:05,123")))))
+ (insert mock-srt-data)
+
(subed-jump-to-subtitle-id 2)
+
(subed-set-subtitle-time-start (subed-timestamp-to-msecs "00:01:05,000"))
+ (expect
(subed-subtitle-msecs-start) :to-equal (subed-timestamp-to-msecs
"00:01:05,000"))
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal (subed-timestamp-to-msecs
"00:01:05,123")))))
(it "adjusts the previous subtitle's stop time
to maintain spacing."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 2)
- (let ((subed-enforce-time-boundaries
'adjust)
-
(subed-subtitle-spacing 100))
- (subed-set-subtitle-time-start
(subed-timestamp-to-msecs "00:01:05,000")))
- (expect (subed-subtitle-msecs-start)
:to-equal (subed-timestamp-to-msecs "00:01:05,000"))
- (expect (subed-subtitle-msecs-stop 1)
:to-equal (subed-timestamp-to-msecs "00:01:04,900"))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 2)
+ (let
((subed-enforce-time-boundaries 'adjust)
+
(subed-subtitle-spacing 100))
+
(subed-set-subtitle-time-start (subed-timestamp-to-msecs "00:01:05,000")))
+ (expect
(subed-subtitle-msecs-start) :to-equal (subed-timestamp-to-msecs
"00:01:05,000"))
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal (subed-timestamp-to-msecs
"00:01:04,900"))))
(it "adjusts the previous subtitle's stop time,
but not the one before it."
;; TODO: Decide if we want to change
this expectation
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 3)
- (let ((subed-enforce-time-boundaries
'adjust)
-
(subed-subtitle-spacing 100))
- (subed-set-subtitle-time-start
(subed-timestamp-to-msecs "00:01:05,000")))
- (expect (subed-subtitle-msecs-start)
:to-equal (subed-timestamp-to-msecs "00:01:05,000"))
- (expect (subed-subtitle-msecs-stop 2)
:to-equal (subed-timestamp-to-msecs "00:01:04,900"))
- (expect (subed-subtitle-msecs-stop 1)
:to-equal (subed-timestamp-to-msecs "00:01:05,123"))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 3)
+ (let
((subed-enforce-time-boundaries 'adjust)
+
(subed-subtitle-spacing 100))
+
(subed-set-subtitle-time-start (subed-timestamp-to-msecs "00:01:05,000")))
+ (expect
(subed-subtitle-msecs-start) :to-equal (subed-timestamp-to-msecs
"00:01:05,000"))
+ (expect
(subed-subtitle-msecs-stop 2) :to-equal (subed-timestamp-to-msecs
"00:01:04,900"))
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal (subed-timestamp-to-msecs
"00:01:05,123"))))
(it "adjusts the current subtitle's stop time
to at least the start time."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 2)
- (let ((subed-enforce-time-boundaries
'adjust)
-
(subed-subtitle-spacing 100))
- (subed-set-subtitle-time-start
(subed-timestamp-to-msecs "00:02:11,000")))
- (expect (subed-subtitle-msecs-start)
:to-equal (subed-timestamp-to-msecs "00:02:11,000"))
- (expect (subed-subtitle-msecs-stop 1)
:to-equal (subed-timestamp-to-msecs "00:01:05,123"))))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 2)
+ (let
((subed-enforce-time-boundaries 'adjust)
+
(subed-subtitle-spacing 100))
+
(subed-set-subtitle-time-start (subed-timestamp-to-msecs "00:02:11,000")))
+ (expect
(subed-subtitle-msecs-start) :to-equal (subed-timestamp-to-msecs
"00:02:11,000"))
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal (subed-timestamp-to-msecs
"00:01:05,123"))))))
(describe "when it will result in invalid duration"
:var ((temp-time (+ (* 3 60 1000) (* 17 1000))))
(it "throws an error when enforcing time boundaries."
(let ((subed-enforce-time-boundaries 'error))
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 3)
- (expect (subed-set-subtitle-time-start
temp-time)
-
:to-throw 'error))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 3)
+ (expect
(subed-set-subtitle-time-start temp-time)
+
:to-throw 'error))))
(it "changes it when ignoring time boundaries."
(let ((subed-enforce-time-boundaries nil))
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 3)
- (subed-set-subtitle-time-start
temp-time)
- (expect (subed-subtitle-msecs-start)
:to-equal temp-time))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 3)
+ (subed-set-subtitle-time-start
temp-time)
+ (expect
(subed-subtitle-msecs-start) :to-equal temp-time))))
(it "changes it when negative durations are allowed."
(let ((subed-enforce-time-boundaries 'error))
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 3)
- (subed-set-subtitle-time-start
temp-time nil t)
- (expect (subed-subtitle-msecs-start)
:to-equal temp-time))))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 3)
+ (subed-set-subtitle-time-start
temp-time nil t)
+ (expect
(subed-subtitle-msecs-start) :to-equal temp-time))))))
(describe "Setting subtitle stop time"
(describe "when this causes an overlap"
(describe "when time boundaries are enforced by errors"
:var ((subed-subtitle-spacing 100))
(it "continues when setting the last subtitle's
stop time."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 3)
- (let ((subed-enforce-time-boundaries
'error))
- (subed-set-subtitle-time-stop
(subed-timestamp-to-msecs "00:03:30,000")))
- (expect (subed-subtitle-msecs-stop)
:to-equal (subed-timestamp-to-msecs "00:03:30,000"))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 3)
+ (let
((subed-enforce-time-boundaries 'error))
+
(subed-set-subtitle-time-stop (subed-timestamp-to-msecs "00:03:30,000")))
+ (expect
(subed-subtitle-msecs-stop) :to-equal (subed-timestamp-to-msecs
"00:03:30,000"))))
(it "ignores the next subtitle's start time if
there's enough spacing."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 2)
- (let ((subed-enforce-time-boundaries
'error))
- (subed-set-subtitle-time-stop
(subed-timestamp-to-msecs "00:03:01,000")))
- (expect (subed-subtitle-msecs-stop)
:to-equal (subed-timestamp-to-msecs "00:03:01,000"))
- (expect (subed-subtitle-msecs-start 3)
:to-equal (subed-timestamp-to-msecs "00:03:03,45"))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 2)
+ (let
((subed-enforce-time-boundaries 'error))
+
(subed-set-subtitle-time-stop (subed-timestamp-to-msecs "00:03:01,000")))
+ (expect
(subed-subtitle-msecs-stop) :to-equal (subed-timestamp-to-msecs "00:03:01,000"))
+ (expect
(subed-subtitle-msecs-start 3) :to-equal (subed-timestamp-to-msecs
"00:03:03,45"))))
(it "ignores the next subtitle's start time if
spacing is unspecified."
(let ((subed-subtitle-spacing nil)
(subed-enforce-time-boundaries 'error))
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 2)
- (let
((subed-enforce-time-boundaries 'error))
-
(subed-set-subtitle-time-stop (subed-timestamp-to-msecs "00:03:05,000")))
- (expect
(subed-subtitle-msecs-stop) :to-equal (subed-timestamp-to-msecs "00:03:05,000"))
- (expect
(subed-subtitle-msecs-start 3) :to-equal (subed-timestamp-to-msecs
"00:03:03,45")))))
+ (insert mock-srt-data)
+
(subed-jump-to-subtitle-id 2)
+ (let
((subed-enforce-time-boundaries 'error))
+
(subed-set-subtitle-time-stop (subed-timestamp-to-msecs "00:03:05,000")))
+ (expect
(subed-subtitle-msecs-stop) :to-equal (subed-timestamp-to-msecs "00:03:05,000"))
+ (expect
(subed-subtitle-msecs-start 3) :to-equal (subed-timestamp-to-msecs
"00:03:03,45")))))
(it "reports an error if the change violates
spacing."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 2)
- (let ((subed-enforce-time-boundaries
'error)
-
(subed-subtitle-spacing 100))
- (expect
(subed-set-subtitle-time-stop (subed-timestamp-to-msecs "00:03:05,000"))
-
:to-throw 'error)))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 2)
+ (let
((subed-enforce-time-boundaries 'error)
+
(subed-subtitle-spacing 100))
+ (expect
(subed-set-subtitle-time-stop (subed-timestamp-to-msecs "00:03:05,000"))
+
:to-throw 'error)))))
(describe "when time boundaries are enforced by
adjusting"
:var ((subed-subtitle-spacing 100))
(it "continues when setting the last subtitle's
stop time."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 3)
- (let ((subed-enforce-time-boundaries
'adjust))
- (subed-set-subtitle-time-stop
(subed-timestamp-to-msecs "00:03:30,000")))
- (expect (subed-subtitle-msecs-stop)
:to-equal (subed-timestamp-to-msecs "00:03:30,000"))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 3)
+ (let
((subed-enforce-time-boundaries 'adjust))
+
(subed-set-subtitle-time-stop (subed-timestamp-to-msecs "00:03:30,000")))
+ (expect
(subed-subtitle-msecs-stop) :to-equal (subed-timestamp-to-msecs
"00:03:30,000"))))
(it "ignores the next subtitle's start time if
there's enough spacing."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 2)
- (let ((subed-enforce-time-boundaries
'adjust))
- (subed-set-subtitle-time-stop
(subed-timestamp-to-msecs "00:03:01,000")))
- (expect (subed-subtitle-msecs-stop)
:to-equal (subed-timestamp-to-msecs "00:03:01,000"))
- (expect (subed-subtitle-msecs-start 3)
:to-equal (subed-timestamp-to-msecs "00:03:03,45"))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 2)
+ (let
((subed-enforce-time-boundaries 'adjust))
+
(subed-set-subtitle-time-stop (subed-timestamp-to-msecs "00:03:01,000")))
+ (expect
(subed-subtitle-msecs-stop) :to-equal (subed-timestamp-to-msecs "00:03:01,000"))
+ (expect
(subed-subtitle-msecs-start 3) :to-equal (subed-timestamp-to-msecs
"00:03:03,45"))))
(it "ignores the next subtitle's start time if
spacing is unspecified."
(let ((subed-subtitle-spacing nil))
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 2)
- (let
((subed-enforce-time-boundaries 'adjust))
-
(subed-set-subtitle-time-stop (subed-timestamp-to-msecs "00:03:05,000")))
- (expect
(subed-subtitle-msecs-stop) :to-equal (subed-timestamp-to-msecs "00:03:05,000"))
- (expect
(subed-subtitle-msecs-start 3) :to-equal (subed-timestamp-to-msecs
"00:03:03,45")))))
+ (insert mock-srt-data)
+
(subed-jump-to-subtitle-id 2)
+ (let
((subed-enforce-time-boundaries 'adjust))
+
(subed-set-subtitle-time-stop (subed-timestamp-to-msecs "00:03:05,000")))
+ (expect
(subed-subtitle-msecs-stop) :to-equal (subed-timestamp-to-msecs "00:03:05,000"))
+ (expect
(subed-subtitle-msecs-start 3) :to-equal (subed-timestamp-to-msecs
"00:03:03,45")))))
(it "adjusts the next subtitle's start time to
maintain spacing."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 2)
- (let ((subed-enforce-time-boundaries
'adjust)
-
(subed-subtitle-spacing 100))
- (subed-set-subtitle-time-stop
(subed-timestamp-to-msecs "00:03:05,000")))
- (expect (subed-subtitle-msecs-stop)
:to-equal (subed-timestamp-to-msecs "00:03:05,000"))
- (expect (subed-subtitle-msecs-start 3)
:to-equal (subed-timestamp-to-msecs "00:03:05,100"))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 2)
+ (let
((subed-enforce-time-boundaries 'adjust)
+
(subed-subtitle-spacing 100))
+
(subed-set-subtitle-time-stop (subed-timestamp-to-msecs "00:03:05,000")))
+ (expect
(subed-subtitle-msecs-stop) :to-equal (subed-timestamp-to-msecs "00:03:05,000"))
+ (expect
(subed-subtitle-msecs-start 3) :to-equal (subed-timestamp-to-msecs
"00:03:05,100"))))
(it "adjusts the next subtitle's stop time, but
not the one after it."
;; TODO: Decide if we want to change
this expectation
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 1)
- (let ((subed-enforce-time-boundaries
'adjust)
-
(subed-subtitle-spacing 100))
- (subed-set-subtitle-time-stop
(subed-timestamp-to-msecs "00:03:05,000")))
- (expect (subed-subtitle-msecs-stop)
:to-equal (subed-timestamp-to-msecs "00:03:05,000"))
- (expect (subed-subtitle-msecs-start 2)
:to-equal (subed-timestamp-to-msecs "00:03:05,100"))
- (expect (subed-subtitle-msecs-start 3)
:to-equal (subed-timestamp-to-msecs "00:03:03,45"))))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 1)
+ (let
((subed-enforce-time-boundaries 'adjust)
+
(subed-subtitle-spacing 100))
+
(subed-set-subtitle-time-stop (subed-timestamp-to-msecs "00:03:05,000")))
+ (expect
(subed-subtitle-msecs-stop) :to-equal (subed-timestamp-to-msecs "00:03:05,000"))
+ (expect
(subed-subtitle-msecs-start 2) :to-equal (subed-timestamp-to-msecs
"00:03:05,100"))
+ (expect
(subed-subtitle-msecs-start 3) :to-equal (subed-timestamp-to-msecs
"00:03:03,45"))))))
(describe "when it will result in invalid duration"
(it "adjusts the start time as needed."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 3)
- (let ((subed-enforce-time-boundaries 'adjust)
- (temp-time
(subed-timestamp-to-msecs "00:03:01,000")))
- (subed-set-subtitle-time-stop
temp-time)
- (expect (subed-subtitle-msecs-start)
:to-equal temp-time)
- (expect (subed-subtitle-msecs-stop)
:to-equal temp-time))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 3)
+ (let ((subed-enforce-time-boundaries
'adjust)
+ (temp-time
(subed-timestamp-to-msecs "00:03:01,000")))
+ (subed-set-subtitle-time-stop
temp-time)
+ (expect
(subed-subtitle-msecs-start) :to-equal temp-time)
+ (expect
(subed-subtitle-msecs-stop) :to-equal temp-time))))
(it "throws an error when enforcing time boundaries."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 3)
- (let ((subed-enforce-time-boundaries 'error)
- (temp-time
(subed-timestamp-to-msecs "00:03:01,000")))
- (expect (subed-set-subtitle-time-stop
temp-time)
-
:to-throw 'error))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 3)
+ (let ((subed-enforce-time-boundaries
'error)
+ (temp-time
(subed-timestamp-to-msecs "00:03:01,000")))
+ (expect
(subed-set-subtitle-time-stop temp-time)
+
:to-throw 'error))))
(it "changes it when ignoring time boundaries."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 3)
- (let ((subed-enforce-time-boundaries nil)
- (temp-time
(subed-timestamp-to-msecs "00:03:01,000")))
- (subed-set-subtitle-time-stop
temp-time)
- (expect (subed-subtitle-msecs-stop)
:to-equal temp-time))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 3)
+ (let ((subed-enforce-time-boundaries
nil)
+ (temp-time
(subed-timestamp-to-msecs "00:03:01,000")))
+ (subed-set-subtitle-time-stop
temp-time)
+ (expect
(subed-subtitle-msecs-stop) :to-equal temp-time))))
(it "changes it when negative durations are allowed."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 3)
- (let ((subed-enforce-time-boundaries 'error)
- (temp-time
(subed-timestamp-to-msecs "00:03:01,000")))
- (subed-set-subtitle-time-stop
temp-time nil t)
- (expect (subed-subtitle-msecs-stop)
:to-equal temp-time))))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 3)
+ (let ((subed-enforce-time-boundaries
'error)
+ (temp-time
(subed-timestamp-to-msecs "00:03:01,000")))
+ (subed-set-subtitle-time-stop
temp-time nil t)
+ (expect
(subed-subtitle-msecs-stop) :to-equal temp-time))))))
(describe "Adjusting subtitle start/stop time"
:var (subed-subtitle-time-adjusted-hook)
(it "runs the appropriate hook."
(let ((foo (setf (symbol-function 'foo) (lambda (msecs) ()))))
(spy-on 'foo)
(with-temp-srt-buffer
- (add-hook 'subed-subtitle-time-adjusted-hook 'foo)
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 1)
- (expect (subed-adjust-subtitle-time-start 100) :to-equal 100)
- (expect 'foo :to-have-been-called-with 61100)
- (expect 'foo :to-have-been-called-times 1)
- (expect (subed-adjust-subtitle-time-stop 123) :to-equal 123)
- (expect 'foo :to-have-been-called-with 61100)
- (expect 'foo :to-have-been-called-times 2)
- (subed-jump-to-subtitle-id 2)
- (expect (subed-adjust-subtitle-time-start 6) :to-equal 6)
- (expect 'foo :to-have-been-called-with 122240)
- (expect 'foo :to-have-been-called-times 3)
- (expect (subed-adjust-subtitle-time-stop 123) :to-equal 123)
- (expect 'foo :to-have-been-called-with 122240)
- (expect 'foo :to-have-been-called-times 4))))
+ (add-hook
'subed-subtitle-time-adjusted-hook 'foo)
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 1)
+ (expect
(subed-adjust-subtitle-time-start 100) :to-equal 100)
+ (expect 'foo :to-have-been-called-with
61100)
+ (expect 'foo :to-have-been-called-times
1)
+ (expect
(subed-adjust-subtitle-time-stop 123) :to-equal 123)
+ (expect 'foo :to-have-been-called-with
61100)
+ (expect 'foo :to-have-been-called-times
2)
+ (subed-jump-to-subtitle-id 2)
+ (expect
(subed-adjust-subtitle-time-start 6) :to-equal 6)
+ (expect 'foo :to-have-been-called-with
122240)
+ (expect 'foo :to-have-been-called-times
3)
+ (expect
(subed-adjust-subtitle-time-stop 123) :to-equal 123)
+ (expect 'foo :to-have-been-called-with
122240)
+ (expect 'foo :to-have-been-called-times
4))))
(it "adjusts the start/stop time."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 1)
- (expect (subed-adjust-subtitle-time-start 100) :to-equal 100)
- (expect (save-excursion (subed-jump-to-subtitle-time-start)
- (thing-at-point 'line)) :to-equal "00:01:01,100
--> 00:01:05,123\n")
- (expect (subed-adjust-subtitle-time-start -200) :to-equal -200)
- (expect (save-excursion (subed-jump-to-subtitle-time-start)
- (thing-at-point 'line)) :to-equal "00:01:00,900
--> 00:01:05,123\n")
- (expect (subed-adjust-subtitle-time-stop 200) :to-equal 200)
- (expect (save-excursion (subed-jump-to-subtitle-time-start)
- (thing-at-point 'line)) :to-equal "00:01:00,900
--> 00:01:05,323\n")
- (expect (subed-adjust-subtitle-time-stop -100) :to-equal -100)
- (expect (save-excursion (subed-jump-to-subtitle-time-start)
- (thing-at-point 'line)) :to-equal "00:01:00,900
--> 00:01:05,223\n")))
- (describe "enforces boundaries"
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 1)
+ (expect (subed-adjust-subtitle-time-start 100)
:to-equal 100)
+ (expect (save-excursion
(subed-jump-to-subtitle-time-start)
+
(thing-at-point 'line))
:to-equal "00:01:01,100 --> 00:01:05,123\n")
+ (expect (subed-adjust-subtitle-time-start -200)
:to-equal -200)
+ (expect (save-excursion
(subed-jump-to-subtitle-time-start)
+
(thing-at-point 'line))
:to-equal "00:01:00,900 --> 00:01:05,123\n")
+ (expect (subed-adjust-subtitle-time-stop 200)
:to-equal 200)
+ (expect (save-excursion
(subed-jump-to-subtitle-time-start)
+
(thing-at-point 'line))
:to-equal "00:01:00,900 --> 00:01:05,323\n")
+ (expect (subed-adjust-subtitle-time-stop -100)
:to-equal -100)
+ (expect (save-excursion
(subed-jump-to-subtitle-time-start)
+
(thing-at-point 'line))
:to-equal "00:01:00,900 --> 00:01:05,223\n")))
+ (describe "when enforcing boundaries with errors"
(describe "when decreasing start time"
- (it "of the first subtitle."
+ (it "handles the first subtitle."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n"))
- (expect (subed-adjust-subtitle-time-start -999) :to-be -999)
- (expect (subed-subtitle-msecs-start) :to-be 1)
- (expect (subed-adjust-subtitle-time-start -1) :to-be -1)
- (expect (subed-subtitle-msecs-start) :to-be 0)
- (expect (subed-adjust-subtitle-time-start -1) :to-be nil)
- (expect (subed-subtitle-msecs-start) :to-be 0)))
- (it "of a non-first subtitle."
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n"))
+ (let
((subed-enforce-time-boundaries 'error))
+ (expect
subed-enforce-time-boundaries :to-equal 'error)
+ (expect
(subed-adjust-subtitle-time-start -999) :to-be -999)
+ (expect
(subed-subtitle-msecs-start) :to-be 1)
+ (expect
(subed-adjust-subtitle-time-start -1) :to-be -1)
+ (expect
(subed-subtitle-msecs-start) :to-be 0)
+ (expect
(subed-adjust-subtitle-time-start -1) :to-throw 'error))))
+ (it "handles a non-first subtitle."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:03,000 --> 00:00:04,000\n"
- "Bar.\n\n"))
- (subed-jump-to-subtitle-id 2)
- (expect (subed-adjust-subtitle-time-start -899) :to-be -899)
- (expect (subed-subtitle-msecs-start) :to-be 2101)
- (expect (subed-adjust-subtitle-time-start -1) :to-be -1)
- (expect (subed-subtitle-msecs-start) :to-be 2100)
- (expect (subed-adjust-subtitle-time-start -1) :to-be nil)
- (expect (subed-subtitle-msecs-start) :to-be 2100)))
- )
- (it "when increasing start time."
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:03,000 --> 00:00:04,000\n"
+
"Bar.\n\n"))
+ (subed-jump-to-subtitle-id 2)
+ (let
((subed-enforce-time-boundaries 'error)
+
(subed-subtitle-spacing 100))
+ (expect
(subed-adjust-subtitle-time-start -899) :to-be -899)
+ (expect
(subed-subtitle-msecs-start) :to-be 2101)
+ (expect
(subed-adjust-subtitle-time-start -1) :to-be -1)
+ (expect
(subed-subtitle-msecs-start) :to-be 2100)
+ ;; report an error if
it bumps up against a previous subtitle
+ (expect
(subed-adjust-subtitle-time-start -1) :to-throw 'error)
+ (expect
(subed-subtitle-msecs-start) :to-be 2100)))))
+ (it "increases start time."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:03,000 --> 00:00:04,000\n"
- "Bar.\n\n"))
- (subed-jump-to-subtitle-id 2)
- (expect (subed-adjust-subtitle-time-start 999) :to-be 999)
- (expect (subed-subtitle-msecs-start) :to-be 3999)
- (expect (subed-adjust-subtitle-time-start 1) :to-be 1)
- (expect (subed-subtitle-msecs-start) :to-be 4000)
- (expect (subed-adjust-subtitle-time-start 1) :to-be nil)
- (expect (subed-subtitle-msecs-start) :to-be 4000)))
- (it "when decreasing stop time."
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:03,000 --> 00:00:04,000\n"
+
"Bar.\n\n"))
+ (subed-jump-to-subtitle-id 2)
+ (let ((subed-enforce-time-boundaries
'error)
+
(subed-subtitle-spacing 100))
+ (expect
(subed-adjust-subtitle-time-start 999) :to-be 999)
+ (expect
(subed-subtitle-msecs-start) :to-be 3999)
+ (expect
(subed-adjust-subtitle-time-start 1) :to-be 1)
+ (expect
(subed-subtitle-msecs-start) :to-be 4000)
+ (expect
(subed-adjust-subtitle-time-start 1) :to-throw 'error)
+ (expect
(subed-subtitle-msecs-start) :to-be 4000))))
+ (it "decreases stop time."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:03,000 --> 00:00:04,000\n"
- "Bar.\n\n"))
- (subed-jump-to-subtitle-id 2)
- (expect (subed-adjust-subtitle-time-stop -999) :to-be -999)
- (expect (subed-subtitle-msecs-stop) :to-be 3001)
- (expect (subed-adjust-subtitle-time-stop -1) :to-be -1)
- (expect (subed-subtitle-msecs-stop) :to-be 3000)
- (expect (subed-adjust-subtitle-time-stop -1) :to-be nil)
- (expect (subed-subtitle-msecs-stop) :to-be 3000)))
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:03,000 --> 00:00:04,000\n"
+
"Bar.\n\n"))
+ (subed-jump-to-subtitle-id 2)
+ (let ((subed-enforce-time-boundaries
'error)
+
(subed-subtitle-spacing 100))
+ (expect
(subed-adjust-subtitle-time-stop -999) :to-be -999)
+ (expect
(subed-subtitle-msecs-stop) :to-be 3001)
+ (expect
(subed-adjust-subtitle-time-stop -1) :to-be -1)
+ (expect
(subed-subtitle-msecs-stop) :to-be 3000)
+ (expect
(subed-adjust-subtitle-time-stop -1) :to-throw 'error)
+ (expect
(subed-subtitle-msecs-stop) :to-be 3000))))
(describe "when increasing stop time"
- (it "of the last subtitle."
+ (it "increases the last subtitle."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:03,000 --> 00:00:04,000\n"
- "Bar.\n\n"))
- (subed-jump-to-subtitle-id 2)
- (expect (subed-adjust-subtitle-time-stop 1000000):to-be 1000000)
- (expect (subed-subtitle-msecs-stop) :to-be 1004000)))
- (it "of a non-last subtitle."
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:03,000 --> 00:00:04,000\n"
+
"Bar.\n\n"))
+ (subed-jump-to-subtitle-id 2)
+ (expect
(subed-adjust-subtitle-time-stop 1000000):to-be 1000000)
+ (expect
(subed-subtitle-msecs-stop) :to-be 1004000)))
+ (it "increases a non-last subtitle."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:03,000 --> 00:00:04,000\n"
- "Bar.\n\n"))
- (subed-jump-to-subtitle-id 1)
- (expect (subed-adjust-subtitle-time-stop 899) :to-be 899)
- (expect (subed-subtitle-msecs-stop) :to-be 2899)
- (expect (subed-adjust-subtitle-time-stop 1) :to-be 1)
- (expect (subed-subtitle-msecs-stop) :to-be 2900)
- (expect (subed-adjust-subtitle-time-stop 1) :to-be nil)
- (expect (subed-subtitle-msecs-stop) :to-be 2900)))
- )
- (it "without undershooting the target time."
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:03,000 --> 00:00:04,000\n"
+
"Bar.\n\n"))
+ (subed-jump-to-subtitle-id 1)
+ (expect
(subed-adjust-subtitle-time-stop 899) :to-be 899)
+ (expect
(subed-subtitle-msecs-stop) :to-be 2899)
+ (expect
(subed-adjust-subtitle-time-stop 1) :to-be 1)
+ (expect
(subed-subtitle-msecs-stop) :to-be 2900)
+ (let
((subed-enforce-time-boundaries 'error)
+
(subed-subtitle-spacing 100))
+ (expect
(subed-adjust-subtitle-time-stop 1) :to-throw 'error)
+ (expect
(subed-subtitle-msecs-stop) :to-be 2900)))))
+ (it "increases without undershooting the target time."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:02,000 --> 00:00:03,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-id 1)
- (expect (subed-adjust-subtitle-time-stop 1) :to-be nil)
- (expect (subed-subtitle-msecs-stop) :to-equal 2000)))
- (it "without overshooting the target time."
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:02,000 --> 00:00:03,000\n"
+
"Bar.\n"))
+ (subed-jump-to-subtitle-id 1)
+ (let ((subed-enforce-time-boundaries
'error)
+
(subed-subtitle-spacing 100))
+ (expect
(subed-adjust-subtitle-time-stop 1) :to-throw 'error)
+ (expect
(subed-subtitle-msecs-stop) :to-equal 2000))))
+ (it "increases without overshooting the target time."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:02,000 --> 00:00:03,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-id 2)
- (expect (subed-adjust-subtitle-time-start -1) :to-be nil)
- (expect (subed-subtitle-msecs-start) :to-equal 2000)))
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:02,000 --> 00:00:03,000\n"
+
"Bar.\n"))
+ (subed-jump-to-subtitle-id 2)
+ (let ((subed-enforce-time-boundaries
'error)
+
(subed-subtitle-spacing 100))
+ (expect
(subed-adjust-subtitle-time-start -1) :to-throw 'error)
+ (expect
(subed-subtitle-msecs-start) :to-equal 2000))))
)
(describe "ignores negative duration if the second argument is truthy"
(it "when adjusting start time."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"))
- (expect (subed-adjust-subtitle-time-start 2000 t) :to-be 2000)
- (expect (subed-subtitle-msecs-start) :to-be 3000)
- (expect (subed-subtitle-msecs-stop) :to-be 2000)
- (expect (subed-adjust-subtitle-time-start -500 t) :to-be -500)
- (expect (subed-subtitle-msecs-start) :to-be 2500)
- (expect (subed-subtitle-msecs-stop) :to-be 2000)))
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"))
+ (expect
(subed-adjust-subtitle-time-start 2000 t) :to-be 2000)
+ (expect (subed-subtitle-msecs-start)
:to-be 3000)
+ (expect (subed-subtitle-msecs-stop)
:to-be 2000)
+ (expect
(subed-adjust-subtitle-time-start -500 t) :to-be -500)
+ (expect (subed-subtitle-msecs-start)
:to-be 2500)
+ (expect (subed-subtitle-msecs-stop)
:to-be 2000)))
(it "when adjusting stop time."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"))
- (expect (subed-adjust-subtitle-time-stop -1500 t) :to-be -1500)
- (expect (subed-subtitle-msecs-stop) :to-be 500)
- (expect (subed-subtitle-msecs-start) :to-be 1000)
- (expect (subed-adjust-subtitle-time-stop 200 t) :to-be 200)
- (expect (subed-subtitle-msecs-stop) :to-be 700)
- (expect (subed-subtitle-msecs-start) :to-be 1000)))
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"))
+ (expect
(subed-adjust-subtitle-time-stop -1500 t) :to-be -1500)
+ (expect (subed-subtitle-msecs-stop)
:to-be 500)
+ (expect (subed-subtitle-msecs-start)
:to-be 1000)
+ (expect
(subed-adjust-subtitle-time-stop 200 t) :to-be 200)
+ (expect (subed-subtitle-msecs-stop)
:to-be 700)
+ (expect (subed-subtitle-msecs-start)
:to-be 1000)))
)
(describe "ignores subtitle spacing if the second argument is truthy"
(it "when adjusting start time."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:02,200 --> 00:00:03,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-id 2)
- (expect (subed-adjust-subtitle-time-start -150 nil t) :to-be -150)
- (expect (subed-subtitle-msecs-start 2) :to-be 2050)
- (expect (subed-subtitle-msecs-stop 1) :to-be 2000)
- (expect (subed-adjust-subtitle-time-start -51 nil t) :to-be -51)
- (expect (subed-subtitle-msecs-start 2) :to-be 1999)
- (expect (subed-subtitle-msecs-stop 1) :to-be 2000)))
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:02,200 --> 00:00:03,000\n"
+
"Bar.\n"))
+ (subed-jump-to-subtitle-id 2)
+ (expect
(subed-adjust-subtitle-time-start -150 nil t) :to-be -150)
+ (expect (subed-subtitle-msecs-start 2)
:to-be 2050)
+ (expect (subed-subtitle-msecs-stop 1)
:to-be 2000)
+ (expect
(subed-adjust-subtitle-time-start -51 nil t) :to-be -51)
+ (expect (subed-subtitle-msecs-start 2)
:to-be 1999)
+ (expect (subed-subtitle-msecs-stop 1)
:to-be 2000)))
(it "when adjusting stop time."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:02,200 --> 00:00:03,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-id 1)
- (expect (subed-adjust-subtitle-time-stop 150 nil t) :to-be 150)
- (expect (subed-subtitle-msecs-stop 1) :to-be 2150)
- (expect (subed-subtitle-msecs-start 2) :to-be 2200)
- (expect (subed-adjust-subtitle-time-stop 51 nil t) :to-be 51)
- (expect (subed-subtitle-msecs-stop 1) :to-be 2201)
- (expect (subed-subtitle-msecs-start 2) :to-be 2200)))
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:02,200 --> 00:00:03,000\n"
+
"Bar.\n"))
+ (subed-jump-to-subtitle-id 1)
+ (expect
(subed-adjust-subtitle-time-stop 150 nil t) :to-be 150)
+ (expect (subed-subtitle-msecs-stop 1)
:to-be 2150)
+ (expect (subed-subtitle-msecs-start 2)
:to-be 2200)
+ (expect
(subed-adjust-subtitle-time-stop 51 nil t) :to-be 51)
+ (expect (subed-subtitle-msecs-stop 1)
:to-be 2201)
+ (expect (subed-subtitle-msecs-start 2)
:to-be 2200)))
)
(describe "ignores negative duration if subed-enforce-time-boundaries is
falsy"
(it "when adjusting start time."
(with-temp-srt-buffer
- (setq-local subed-enforce-time-boundaries nil)
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"))
- (expect (subed-adjust-subtitle-time-start 2000) :to-be 2000)
- (expect (subed-subtitle-msecs-start) :to-be 3000)
- (expect (subed-subtitle-msecs-stop) :to-be 2000)
- (expect (subed-adjust-subtitle-time-start -500) :to-be -500)
- (expect (subed-subtitle-msecs-start) :to-be 2500)
- (expect (subed-subtitle-msecs-stop) :to-be 2000)))
+ (setq-local
subed-enforce-time-boundaries nil)
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"))
+ (expect
(subed-adjust-subtitle-time-start 2000) :to-be 2000)
+ (expect (subed-subtitle-msecs-start)
:to-be 3000)
+ (expect (subed-subtitle-msecs-stop)
:to-be 2000)
+ (expect
(subed-adjust-subtitle-time-start -500) :to-be -500)
+ (expect (subed-subtitle-msecs-start)
:to-be 2500)
+ (expect (subed-subtitle-msecs-stop)
:to-be 2000)))
(it "when adjusting stop time."
(with-temp-srt-buffer
- (setq-local subed-enforce-time-boundaries nil)
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"))
- (expect (subed-adjust-subtitle-time-stop -1500) :to-be -1500)
- (expect (subed-subtitle-msecs-stop) :to-be 500)
- (expect (subed-subtitle-msecs-start) :to-be 1000)
- (expect (subed-adjust-subtitle-time-stop 200) :to-be 200)
- (expect (subed-subtitle-msecs-stop) :to-be 700)
- (expect (subed-subtitle-msecs-start) :to-be 1000)))
+ (setq-local
subed-enforce-time-boundaries nil)
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"))
+ (expect
(subed-adjust-subtitle-time-stop -1500) :to-be -1500)
+ (expect (subed-subtitle-msecs-stop)
:to-be 500)
+ (expect (subed-subtitle-msecs-start)
:to-be 1000)
+ (expect
(subed-adjust-subtitle-time-stop 200) :to-be 200)
+ (expect (subed-subtitle-msecs-stop)
:to-be 700)
+ (expect (subed-subtitle-msecs-start)
:to-be 1000)))
)
(describe "ignores subtitle spacing if subed-enforce-time-boundaries is
falsy"
(it "when adjusting start time."
(with-temp-srt-buffer
- (setq-local subed-enforce-time-boundaries nil)
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:02,200 --> 00:00:03,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-id 2)
- (expect (subed-adjust-subtitle-time-start -150) :to-be -150)
- (expect (subed-subtitle-msecs-start 2) :to-be 2050)
- (expect (subed-subtitle-msecs-stop 1) :to-be 2000)
- (expect (subed-adjust-subtitle-time-start -51) :to-be -51)
- (expect (subed-subtitle-msecs-start 2) :to-be 1999)
- (expect (subed-subtitle-msecs-stop 1) :to-be 2000)))
+ (setq-local
subed-enforce-time-boundaries nil)
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:02,200 --> 00:00:03,000\n"
+
"Bar.\n"))
+ (subed-jump-to-subtitle-id 2)
+ (expect
(subed-adjust-subtitle-time-start -150) :to-be -150)
+ (expect (subed-subtitle-msecs-start 2)
:to-be 2050)
+ (expect (subed-subtitle-msecs-stop 1)
:to-be 2000)
+ (expect
(subed-adjust-subtitle-time-start -51) :to-be -51)
+ (expect (subed-subtitle-msecs-start 2)
:to-be 1999)
+ (expect (subed-subtitle-msecs-stop 1)
:to-be 2000)))
(it "when adjusting stop time."
(with-temp-srt-buffer
- (setq-local subed-enforce-time-boundaries nil)
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:02,200 --> 00:00:03,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-id 1)
- (expect (subed-adjust-subtitle-time-stop 150) :to-be 150)
- (expect (subed-subtitle-msecs-stop 1) :to-be 2150)
- (expect (subed-subtitle-msecs-start 2) :to-be 2200)
- (expect (subed-adjust-subtitle-time-stop 51) :to-be 51)
- (expect (subed-subtitle-msecs-stop 1) :to-be 2201)
- (expect (subed-subtitle-msecs-start 2) :to-be 2200)))
+ (setq-local
subed-enforce-time-boundaries nil)
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:02,200 --> 00:00:03,000\n"
+
"Bar.\n"))
+ (subed-jump-to-subtitle-id 1)
+ (expect
(subed-adjust-subtitle-time-stop 150) :to-be 150)
+ (expect (subed-subtitle-msecs-stop 1)
:to-be 2150)
+ (expect (subed-subtitle-msecs-start 2)
:to-be 2200)
+ (expect
(subed-adjust-subtitle-time-stop 51) :to-be 51)
+ (expect (subed-subtitle-msecs-stop 1)
:to-be 2201)
+ (expect (subed-subtitle-msecs-start 2)
:to-be 2200)))
)
(describe "prevents negative time even if subed-enforce-time-boundaries is
falsy"
(it "when adjusting start time."
(with-temp-srt-buffer
- (setq-local subed-enforce-time-boundaries nil)
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"))
- (expect (subed-adjust-subtitle-time-start -1000) :to-be -1000)
- (expect (subed-subtitle-msecs-start) :to-be 0)
- (expect (subed-adjust-subtitle-time-start -1) :to-be nil)
- (expect (subed-subtitle-msecs-start) :to-be 0)))
+ (setq-local
subed-enforce-time-boundaries nil)
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"))
+ (expect
(subed-adjust-subtitle-time-start -1000) :to-be -1000)
+ (expect (subed-subtitle-msecs-start)
:to-be 0)
+ (expect
(subed-adjust-subtitle-time-start -1) :to-be 0)
+ (expect (subed-subtitle-msecs-start)
:to-be 0)))
(it "when adjusting stop time."
(with-temp-srt-buffer
- (setq-local subed-enforce-time-boundaries nil)
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"))
- (expect (subed-adjust-subtitle-time-stop -2000) :to-be -2000)
- (expect (subed-subtitle-msecs-stop) :to-be 0)
- (expect (subed-adjust-subtitle-time-stop -1) :to-be nil)
- (expect (subed-subtitle-msecs-stop) :to-be 0)))
+ (setq-local
subed-enforce-time-boundaries nil)
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"))
+ (expect
(subed-adjust-subtitle-time-stop -2000) :to-be -2000)
+ (expect (subed-subtitle-msecs-stop)
:to-be 0)
+ (expect
(subed-adjust-subtitle-time-stop -1) :to-be nil)
+ (expect (subed-subtitle-msecs-stop)
:to-be 0)))
)
(it "does nothing if no timestamp can be found."
(with-temp-srt-buffer
- (insert "foo")
- (goto-char (point-min))
- (expect (subed-adjust-subtitle-time-start 123) :to-be nil)
- (expect (buffer-string) :to-equal "foo")
- (expect (subed-adjust-subtitle-time-start -123) :to-be nil)
- (expect (buffer-string) :to-equal "foo")))
+ (insert "foo")
+ (goto-char (point-min))
+ (expect (subed-adjust-subtitle-time-start 123)
:to-be nil)
+ (expect (buffer-string) :to-equal "foo")
+ (expect (subed-adjust-subtitle-time-start -123)
:to-be nil)
+ (expect (buffer-string) :to-equal "foo")))
)
(describe "Copy start/stop time from player"
:var (subed-mpv-playback-position)
(it "does nothing in an empty buffer."
(with-temp-srt-buffer
- (let ((subed-mpv-playback-position 12345))
- (expect (subed-copy-player-pos-to-start-time) :to-be nil)
- (expect (subed-copy-player-pos-to-stop-time) :to-be nil)
- (expect (buffer-string) :to-equal ""))))
+ (let ((subed-mpv-playback-position 12345))
+ (expect
(subed-copy-player-pos-to-start-time) :to-be nil)
+ (expect
(subed-copy-player-pos-to-stop-time) :to-be nil)
+ (expect (buffer-string) :to-equal ""))))
(it "does nothing if player position is unknown."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n"))
- (let ((subed-mpv-playback-position nil))
- (expect (subed-copy-player-pos-to-start-time) :to-be nil)
- (expect (subed-copy-player-pos-to-stop-time) :to-be nil)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:00:01,000 -->
00:00:02,000\n"
- "Foo.\n")))))
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n"))
+ (let ((subed-mpv-playback-position nil))
+ (expect
(subed-copy-player-pos-to-start-time) :to-be nil)
+ (expect
(subed-copy-player-pos-to-stop-time) :to-be nil)
+ (expect (buffer-string) :to-equal
(concat "1\n"
+
"00:00:01,000 -->
00:00:02,000\n"
+
"Foo.\n")))))
(it "sets start/stop time when possible."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n"))
- (let ((subed-mpv-playback-position (+ 60000 2000 123))
- (subed-enforce-time-boundaries
nil))
- (expect (subed-copy-player-pos-to-start-time) :to-be
subed-mpv-playback-position)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:01:02,123 -->
00:00:02,000\n"
- "Foo.\n")))
- (let ((subed-mpv-playback-position (+ 60000 5000 456))
- (subed-enforce-time-boundaries
nil))
- (expect (subed-copy-player-pos-to-stop-time) :to-be
subed-mpv-playback-position)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:01:02,123 -->
00:01:05,456\n"
- "Foo.\n")))))
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n"))
+ (let ((subed-mpv-playback-position (+ 60000
2000 123))
+
(subed-enforce-time-boundaries nil))
+ (expect
(subed-copy-player-pos-to-start-time) :to-be subed-mpv-playback-position)
+ (expect (buffer-string) :to-equal
(concat "1\n"
+
"00:01:02,123 -->
00:00:02,000\n"
+
"Foo.\n")))
+ (let ((subed-mpv-playback-position (+ 60000
5000 456))
+
(subed-enforce-time-boundaries nil))
+ (expect
(subed-copy-player-pos-to-stop-time) :to-be subed-mpv-playback-position)
+ (expect (buffer-string) :to-equal
(concat "1\n"
+
"00:01:02,123 -->
00:01:05,456\n"
+
"Foo.\n")))))
(it "runs the appropriate hook."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n"))
- (let ((foo (setf (symbol-function 'foo) (lambda (msecs) ())))
- (subed-enforce-time-boundaries
nil))
- (spy-on 'foo)
- (add-hook 'subed-subtitle-time-adjusted-hook 'foo)
- (let ((subed-mpv-playback-position (+ 60000 2000 123)))
- (expect (subed-copy-player-pos-to-start-time) :to-be
subed-mpv-playback-position)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:01:02,123 -->
00:00:02,000\n"
- "Foo.\n"))
- (expect (spy-calls-args-for 'foo 0) :to-equal `(,(+ 60000 2000
123)))
- (expect (spy-calls-count 'foo) :to-equal 1)))
- (let ((subed-mpv-playback-position (+ 60000 5000 456)))
- (expect (subed-copy-player-pos-to-stop-time) :to-be
subed-mpv-playback-position)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:01:02,123 -->
00:01:05,456\n"
- "Foo.\n"))
- (expect (spy-calls-args-for 'foo 0) :to-equal `(,(+ 60000 2000 123)))
- (expect (spy-calls-count 'foo) :to-equal 2)))
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n"))
+ (let ((foo (setf (symbol-function 'foo) (lambda
(msecs) ())))
+
(subed-enforce-time-boundaries nil))
+ (spy-on 'foo)
+ (add-hook
'subed-subtitle-time-adjusted-hook 'foo)
+ (let ((subed-mpv-playback-position (+
60000 2000 123)))
+ (expect
(subed-copy-player-pos-to-start-time) :to-be subed-mpv-playback-position)
+ (expect (buffer-string)
:to-equal (concat "1\n"
+
"00:01:02,123 -->
00:00:02,000\n"
+
"Foo.\n"))
+ (expect (spy-calls-args-for
'foo 0) :to-equal `(,(+ 60000 2000 123)))
+ (expect (spy-calls-count 'foo)
:to-equal 1)))
+ (let ((subed-mpv-playback-position (+ 60000
5000 456)))
+ (expect
(subed-copy-player-pos-to-stop-time) :to-be subed-mpv-playback-position)
+ (expect (buffer-string) :to-equal
(concat "1\n"
+
"00:01:02,123 -->
00:01:05,456\n"
+
"Foo.\n"))
+ (expect (spy-calls-args-for 'foo 0)
:to-equal `(,(+ 60000 2000 123)))
+ (expect (spy-calls-count 'foo)
:to-equal 2)))
(remove-hook 'subed-subtitle-time-adjusted-hook 'foo))
)
@@ -754,457 +767,466 @@ Baz.
(describe "to subtitle text given msecs"
(it "finds the right subtitle"
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-text-at-msecs 122234)
- (expect (looking-at "Bar\\.") :to-equal t)))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-text-at-msecs
122234)
+ (expect (looking-at "Bar\\.") :to-equal
t)))))
(describe "Moving"
(it "adjusts start and stop time by the same amount."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n"))
- (let ((orig-point (subed-jump-to-subtitle-text 1)))
- (subed-move-subtitle-forward 100)
- (expect (subed-subtitle-msecs-start) :to-equal 1100)
- (expect (subed-subtitle-msecs-stop) :to-equal 2100)
- (subed-move-subtitle-backward 200)
- (expect (subed-subtitle-msecs-start) :to-equal 900)
- (expect (subed-subtitle-msecs-stop) :to-equal 1900)
- (expect (point) :to-equal orig-point))))
- (it "adjusts start and stop time by the same amount when bumping into next
subtitle."
- (with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:01,600\n"
- "Foo.\n\n"
- "2\n"
- "00:00:02,000 --> 00:00:03,000\n"
- "Bar.\n"))
- (let ((orig-point (subed-jump-to-subtitle-id 1)))
- (subed-move-subtitle-forward 1000)
- (expect (subed-subtitle-msecs-start) :to-equal 1300)
- (expect (subed-subtitle-msecs-stop) :to-equal 1900)
- (expect (point) :to-equal orig-point))))
- (it "adjusts start and stop time by the same amount when bumping into
previous subtitle."
- (with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:01,600\n"
- "Foo.\n\n"
- "2\n"
- "00:00:02,000 --> 00:00:03,000\n"
- "Bar.\n"))
- (let ((orig-point (subed-jump-to-subtitle-id 2)))
- (subed-move-subtitle-backward 1000)
- (expect (subed-subtitle-msecs-start) :to-equal 1700)
- (expect (subed-subtitle-msecs-stop) :to-equal 2700)
- (expect (point) :to-equal orig-point))))
- (it "does not adjust anything if subtitle cannot be moved forward at all."
- (with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:02,000 --> 00:00:03,000\n"
- "Bar.\n"))
- (let ((orig-point (subed-jump-to-subtitle-id 1)))
- (subed-move-subtitle-forward 1)
- (expect (subed-subtitle-msecs-start 1) :to-equal 1000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2000)
- (expect (subed-subtitle-msecs-start 2) :to-equal 2000)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 3000)
- (expect (point) :to-equal orig-point))))
- (it "does not adjust anything if subtitle cannot be moved backward at all."
- (with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:02,000 --> 00:00:03,000\n"
- "Bar.\n"))
- (let ((orig-point (subed-jump-to-subtitle-id 2)))
- (subed-move-subtitle-backward 1)
- (expect (subed-subtitle-msecs-start 1) :to-equal 1000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2000)
- (expect (subed-subtitle-msecs-start 2) :to-equal 2000)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 3000)
- (expect (point) :to-equal orig-point))))
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n"))
+ (let ((orig-point (subed-jump-to-subtitle-text
1)))
+ (subed-move-subtitle-forward 100)
+ (expect (subed-subtitle-msecs-start)
:to-equal 1100)
+ (expect (subed-subtitle-msecs-stop)
:to-equal 2100)
+ (subed-move-subtitle-backward 200)
+ (expect (subed-subtitle-msecs-start)
:to-equal 900)
+ (expect (subed-subtitle-msecs-stop)
:to-equal 1900)
+ (expect (point) :to-equal orig-point))))
+ (describe "when clipping to time boundaries"
+ (it "adjusts start and stop time by the same amount
when bumping into next subtitle."
+ (with-temp-srt-buffer
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:01,600\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:02,000 --> 00:00:03,000\n"
+
"Bar.\n"))
+ (let ((orig-point
(subed-jump-to-subtitle-id 1))
+
(subed-subtitle-spacing 100)
+
(subed-enforce-time-boundaries 'clip))
+ (subed-move-subtitle-forward
1000)
+ (expect
(subed-subtitle-msecs-start) :to-equal 1300)
+ (expect
(subed-subtitle-msecs-stop) :to-equal 1900)
+ (expect (point) :to-equal
orig-point))))
+ (it "adjusts start and stop time by the same amount
when bumping into previous subtitle."
+ (with-temp-srt-buffer
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:01,600\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:02,000 --> 00:00:03,000\n"
+
"Bar.\n"))
+ (let ((orig-point
(subed-jump-to-subtitle-id 2))
+
(subed-subtitle-spacing 100)
+
(subed-enforce-time-boundaries 'clip))
+ (subed-move-subtitle-backward
1000)
+ (expect
(subed-subtitle-msecs-start) :to-equal 1700)
+ (expect
(subed-subtitle-msecs-stop) :to-equal 2700)
+ (expect (point) :to-equal
orig-point)))))
+ (describe "when time boundaries are enforced with errors"
+ (it "does not adjust anything if subtitle cannot be
moved forward at all."
+ (with-temp-srt-buffer
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:02,000 --> 00:00:03,000\n"
+
"Bar.\n"))
+ (let ((orig-point
(subed-jump-to-subtitle-id 1))
+
(subed-enforce-time-boundaries 'error))
+ (expect
(subed-move-subtitle-forward 1) :to-throw 'error)
+ (expect
(subed-subtitle-msecs-start 1) :to-equal 1000)
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal 2000)
+ (expect
(subed-subtitle-msecs-start 2) :to-equal 2000)
+ (expect
(subed-subtitle-msecs-stop 2) :to-equal 3000)
+ (expect (point) :to-equal
orig-point))))
+ (it "does not adjust anything if subtitle cannot be
moved backward at all."
+ (with-temp-srt-buffer
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:02,000 --> 00:00:03,000\n"
+
"Bar.\n"))
+ (let ((orig-point
(subed-jump-to-subtitle-id 2))
+
(subed-enforce-time-boundaries 'error))
+ (expect
(subed-move-subtitle-backward 1) :to-throw 'error)
+ (expect
(subed-subtitle-msecs-start 1) :to-equal 1000)
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal 2000)
+ (expect
(subed-subtitle-msecs-start 2) :to-equal 2000)
+ (expect
(subed-subtitle-msecs-stop 2) :to-equal 3000)
+ (expect (point) :to-equal
orig-point)))))
(describe "adjusts subtitles in the active region,"
(it "excluding the first subtitle."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:03,000 --> 00:00:04,000\n"
- "Bar.\n\n"
- "3\n"
- "00:00:05,000 --> 00:00:06,000\n"
- "Baz.\n"))
- (setq mark-active t)
- (spy-on 'region-beginning :and-return-value
(subed-jump-to-subtitle-text 2))
- (spy-on 'region-end :and-return-value
(subed-jump-to-subtitle-time-start 3))
- (let ((orig-point (subed-jump-to-subtitle-text 2)))
- (subed-move-subtitle-forward 100)
- (expect (subed-subtitle-msecs-start 1) :to-equal 1000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2000)
- (expect (subed-subtitle-msecs-start 2) :to-equal 3100)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 4100)
- (expect (subed-subtitle-msecs-start 3) :to-equal 5100)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 6100)
- (expect (point) :to-equal orig-point)
- (subed-move-subtitle-backward 200)
- (expect (subed-subtitle-msecs-start 1) :to-equal 1000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2000)
- (expect (subed-subtitle-msecs-start 2) :to-equal 2900)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 3900)
- (expect (subed-subtitle-msecs-start 3) :to-equal 4900)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 5900)
- (expect (point) :to-equal orig-point))))
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:03,000 --> 00:00:04,000\n"
+
"Bar.\n\n"
+
"3\n"
+
"00:00:05,000 --> 00:00:06,000\n"
+
"Baz.\n"))
+ (setq mark-active t)
+ (spy-on 'region-beginning
:and-return-value (subed-jump-to-subtitle-text 2))
+ (spy-on 'region-end :and-return-value
(subed-jump-to-subtitle-time-start 3))
+ (let ((orig-point
(subed-jump-to-subtitle-text 2)))
+ (subed-move-subtitle-forward
100)
+ (expect
(subed-subtitle-msecs-start 1) :to-equal 1000)
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal 2000)
+ (expect
(subed-subtitle-msecs-start 2) :to-equal 3100)
+ (expect
(subed-subtitle-msecs-stop 2) :to-equal 4100)
+ (expect
(subed-subtitle-msecs-start 3) :to-equal 5100)
+ (expect
(subed-subtitle-msecs-stop 3) :to-equal 6100)
+ (expect (point) :to-equal
orig-point)
+ (subed-move-subtitle-backward
200)
+ (expect
(subed-subtitle-msecs-start 1) :to-equal 1000)
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal 2000)
+ (expect
(subed-subtitle-msecs-start 2) :to-equal 2900)
+ (expect
(subed-subtitle-msecs-stop 2) :to-equal 3900)
+ (expect
(subed-subtitle-msecs-start 3) :to-equal 4900)
+ (expect
(subed-subtitle-msecs-stop 3) :to-equal 5900)
+ (expect (point) :to-equal
orig-point))))
(it "excluding the last subtitle."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:03,000 --> 00:00:04,000\n"
- "Bar.\n\n"
- "3\n"
- "00:00:05,000 --> 00:00:06,000\n"
- "Baz.\n"))
- (setq mark-active t)
- (spy-on 'region-beginning :and-return-value
(subed-jump-to-subtitle-text 1))
- (spy-on 'region-end :and-return-value
(subed-jump-to-subtitle-time-stop 2))
- (let ((orig-point (subed-jump-to-subtitle-time-stop 3)))
- (subed-move-subtitle-forward 500)
- (expect (subed-subtitle-msecs-start 1) :to-equal 1500)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2500)
- (expect (subed-subtitle-msecs-start 2) :to-equal 3500)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 4500)
- (expect (subed-subtitle-msecs-start 3) :to-equal 5000)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 6000)
- (expect (point) :to-equal orig-point)
- (subed-move-subtitle-backward 300)
- (expect (subed-subtitle-msecs-start 1) :to-equal 1200)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2200)
- (expect (subed-subtitle-msecs-start 2) :to-equal 3200)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 4200)
- (expect (subed-subtitle-msecs-start 3) :to-equal 5000)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 6000)
- (expect (point) :to-equal orig-point))))
- (describe "not changing spacing between subtitles"
- (it "when moving forward."
- (with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:10,000 --> 00:00:11,000\n"
- "Bar.\n\n"
- "3\n"
- "00:00:12,000 --> 00:00:13,000\n"
- "Baz.\n"))
- (setq mark-active t)
- (spy-on 'region-beginning :and-return-value
(subed-jump-to-subtitle-id 1))
- (spy-on 'region-end :and-return-value (subed-jump-to-subtitle-text
2))
- (let ((orig-point (subed-jump-to-subtitle-time-start 1)))
- (subed-move-subtitle-forward 2000)
- (expect (subed-subtitle-msecs-start 1) :to-equal 1900)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2900)
- (expect (subed-subtitle-msecs-start 2) :to-equal 10900)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 11900)
- (expect (subed-subtitle-msecs-start 3) :to-equal 12000)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 13000)
- (expect (point) :to-equal orig-point))))
- (it "when moving backward."
- (with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:3,000 --> 00:00:4,000\n"
- "Bar.\n\n"
- "3\n"
- "00:00:10,000 --> 00:00:11,000\n"
- "Baz.\n"))
- (setq mark-active t)
- (spy-on 'region-beginning :and-return-value
(subed-jump-to-subtitle-id 2))
- (spy-on 'region-end :and-return-value (subed-jump-to-subtitle-text
3))
- (let ((orig-point (subed-jump-to-subtitle-time-start 2)))
- (subed-move-subtitle-backward 10000)
- (expect (subed-subtitle-msecs-start 1) :to-equal 1000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2000)
- (expect (subed-subtitle-msecs-start 2) :to-equal 2100)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 3100)
- (expect (subed-subtitle-msecs-start 3) :to-equal 9100)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 10100)
- (expect (point) :to-equal orig-point))))
- )
- )
- (describe "unless there is no space left"
- (it "when moving forward."
- (with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:10,000 --> 00:00:11,000\n"
- "Bar.\n\n"
- "3\n"
- "00:00:11,000 --> 00:00:12,000\n"
- "Baz.\n"))
- (setq mark-active t)
- (spy-on 'region-beginning :and-return-value
(subed-jump-to-subtitle-id 1))
- (spy-on 'region-end :and-return-value (subed-jump-to-subtitle-text 2))
- (let ((orig-point (subed-jump-to-subtitle-text 1)))
- (subed-move-subtitle-forward 1)
- (expect (subed-subtitle-msecs-start 1) :to-equal 1000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2000)
- (expect (subed-subtitle-msecs-start 2) :to-equal 10000)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 11000)
- (expect (subed-subtitle-msecs-start 3) :to-equal 11000)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 12000)
- (expect (point) :to-equal orig-point))))
- (it "when moving backward."
- (with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:02,000 --> 00:00:03,000\n"
- "Bar.\n\n"
- "3\n"
- "00:00:11,000 --> 00:00:12,000\n"
- "Baz.\n"))
- (setq mark-active t)
- (spy-on 'region-beginning :and-return-value
(subed-jump-to-subtitle-id 2))
- (spy-on 'region-end :and-return-value (subed-jump-to-subtitle-text 3))
- (let ((orig-point (subed-jump-to-subtitle-id 3)))
- (subed-move-subtitle-backward 1)
- (expect (subed-subtitle-msecs-start 1) :to-equal 1000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2000)
- (expect (subed-subtitle-msecs-start 2) :to-equal 2000)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 3000)
- (expect (subed-subtitle-msecs-start 3) :to-equal 11000)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 12000)
- (expect (point) :to-equal orig-point))))
- )
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:03,000 --> 00:00:04,000\n"
+
"Bar.\n\n"
+
"3\n"
+
"00:00:05,000 --> 00:00:06,000\n"
+
"Baz.\n"))
+ (setq mark-active t)
+ (spy-on 'region-beginning
:and-return-value (subed-jump-to-subtitle-text 1))
+ (spy-on 'region-end :and-return-value
(subed-jump-to-subtitle-time-stop 2))
+ (let ((orig-point
(subed-jump-to-subtitle-time-stop 3)))
+ (subed-move-subtitle-forward
500)
+ (expect
(subed-subtitle-msecs-start 1) :to-equal 1500)
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal 2500)
+ (expect
(subed-subtitle-msecs-start 2) :to-equal 3500)
+ (expect
(subed-subtitle-msecs-stop 2) :to-equal 4500)
+ (expect
(subed-subtitle-msecs-start 3) :to-equal 5000)
+ (expect
(subed-subtitle-msecs-stop 3) :to-equal 6000)
+ (expect (point) :to-equal
orig-point)
+ (subed-move-subtitle-backward
300)
+ (expect
(subed-subtitle-msecs-start 1) :to-equal 1200)
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal 2200)
+ (expect
(subed-subtitle-msecs-start 2) :to-equal 3200)
+ (expect
(subed-subtitle-msecs-stop 2) :to-equal 4200)
+ (expect
(subed-subtitle-msecs-start 3) :to-equal 5000)
+ (expect
(subed-subtitle-msecs-stop 3) :to-equal 6000)
+ (expect (point) :to-equal
orig-point))))
+ (describe "when ignoring time boundaries"
+ (it "does not change spacing between subtitles
when moving subtitles forward."
+ (with-temp-srt-buffer
+ (insert "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:10,000 --> 00:00:11,000\n"
+
"Bar.\n\n"
+
"3\n"
+
"00:00:12,000 --> 00:00:13,000\n"
+
"Baz.\n")
+ (setq mark-active t)
+ (spy-on 'region-beginning
:and-return-value (subed-jump-to-subtitle-id 1))
+ (spy-on 'region-end
:and-return-value (subed-jump-to-subtitle-text 2))
+ (let ((orig-point
(subed-jump-to-subtitle-time-start 1))
+
(subed-enforce-time-boundaries nil))
+
(subed-move-subtitle-forward 2000)
+ (expect
(subed-subtitle-msecs-start 1) :to-equal 3000)
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal 4000)
+ (expect
(subed-subtitle-msecs-start 2) :to-equal 12000)
+ (expect
(subed-subtitle-msecs-stop 2) :to-equal 13000)
+ (expect
(subed-subtitle-msecs-start 3) :to-equal 12000)
+ (expect
(subed-subtitle-msecs-stop 3) :to-equal 13000)
+ (expect (point)
:to-equal orig-point))))
+ (it "does not change spacing between subtitles
when moving subtitles backward."
+ (with-temp-srt-buffer
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:03,000 --> 00:00:04,000\n"
+
"Bar.\n\n"
+
"3\n"
+
"00:00:10,000 --> 00:00:11,000\n"
+
"Baz.\n"))
+ (setq mark-active t)
+ (spy-on 'region-beginning
:and-return-value (subed-jump-to-subtitle-id 2))
+ (spy-on 'region-end
:and-return-value (subed-jump-to-subtitle-text 3))
+ (let ((orig-point
(subed-jump-to-subtitle-time-start 2))
+
(subed-enforce-time-boundaries nil))
+
(subed-move-subtitle-backward 1000)
+ (expect
(subed-subtitle-msecs-start 1) :to-equal 1000)
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal 2000)
+ (expect
(subed-subtitle-msecs-start 2) :to-equal 2000)
+ (expect
(subed-subtitle-msecs-stop 2) :to-equal 3000)
+ (expect
(subed-subtitle-msecs-start 3) :to-equal 9000)
+ (expect
(subed-subtitle-msecs-stop 3) :to-equal 10000)
+ (expect (point)
:to-equal orig-point))))))
+ ;; What does it mean by not having space left?
+ ;; (describe "unless there is no space left"
+ ;; (describe "when moving forward"
+ ;; (it "updates the start time."
+ ;; (with-temp-srt-buffer
+ ;; (insert (concat "1\n"
+ ;;
"00:00:01,000 --> 00:00:02,000\n"
+ ;;
"Foo.\n\n"
+ ;;
"2\n"
+ ;;
"00:00:10,000 --> 00:00:11,000\n"
+ ;;
"Bar.\n\n"
+ ;;
"3\n"
+ ;;
"00:00:11,000 --> 00:00:12,000\n"
+ ;;
"Baz.\n"))
+ ;; (setq mark-active t)
+ ;; (spy-on 'region-beginning
:and-return-value (subed-jump-to-subtitle-id 1))
+ ;; (spy-on 'region-end
:and-return-value (subed-jump-to-subtitle-text 2))
+ ;; (let ((orig-point
(subed-jump-to-subtitle-text 1)))
+ ;;
(subed-move-subtitle-forward 1)
+ ;; (expect
(subed-subtitle-msecs-start 1) :to-equal 1000)
+ ;; (expect
(subed-subtitle-msecs-stop 1) :to-equal 2000)
+ ;; (expect
(subed-subtitle-msecs-start 2) :to-equal 10000)
+ ;; (expect
(subed-subtitle-msecs-stop 2) :to-equal 11000)
+ ;; (expect
(subed-subtitle-msecs-start 3) :to-equal 11000)
+ ;; (expect
(subed-subtitle-msecs-stop 3) :to-equal 12000)
+ ;; (expect (point)
:to-equal orig-point)))))
+ ;; (it "when moving backward."
+ ;; (with-temp-srt-buffer
+ ;; (insert (concat "1\n"
+ ;;
"00:00:01,000 --> 00:00:02,000\n"
+ ;;
"Foo.\n\n"
+ ;;
"2\n"
+ ;;
"00:00:02,000 --> 00:00:03,000\n"
+ ;;
"Bar.\n\n"
+ ;;
"3\n"
+ ;;
"00:00:11,000 --> 00:00:12,000\n"
+ ;;
"Baz.\n"))
+ ;; (setq mark-active t)
+ ;; (spy-on 'region-beginning
:and-return-value (subed-jump-to-subtitle-id 2))
+ ;; (spy-on 'region-end :and-return-value
(subed-jump-to-subtitle-text 3))
+ ;; (let ((orig-point
(subed-jump-to-subtitle-id 3)))
+ ;; (subed-move-subtitle-backward 1)
+ ;; (expect
(subed-subtitle-msecs-start 1) :to-equal 1000)
+ ;; (expect
(subed-subtitle-msecs-stop 1) :to-equal 2000)
+ ;; (expect
(subed-subtitle-msecs-start 2) :to-equal 2000)
+ ;; (expect
(subed-subtitle-msecs-stop 2) :to-equal 3000)
+ ;; (expect
(subed-subtitle-msecs-start 3) :to-equal 11000)
+ ;; (expect
(subed-subtitle-msecs-stop 3) :to-equal 12000)
+ ;; (expect (point) :to-equal
orig-point))))
+ ;; )
(describe "ignoring spacing for non-leading subtitles"
(it "when moving forward."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:00,000 --> 00:00:01,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:01,050 --> 00:00:02,000\n"
- "Bar.\n\n"
- "3\n"
- "00:00:05,000 --> 00:00:6,000\n"
- "Baz.\n"))
- (setq mark-active t)
- (spy-on 'region-beginning :and-return-value
(subed-jump-to-subtitle-id 1))
- (spy-on 'region-end :and-return-value (subed-jump-to-subtitle-text 2))
- (let ((orig-point (subed-jump-to-subtitle-time-start 3)))
- (subed-move-subtitle-forward 1000)
- (expect (subed-subtitle-msecs-start 1) :to-equal 1000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2000)
- (expect (subed-subtitle-msecs-start 2) :to-equal 2050)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 3000)
- (expect (subed-subtitle-msecs-start 3) :to-equal 5000)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 6000)
- (expect (point) :to-equal orig-point))))
+ (insert (concat "1\n"
+
"00:00:00,000 --> 00:00:01,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:01,050 --> 00:00:02,000\n"
+
"Bar.\n\n"
+
"3\n"
+
"00:00:05,000 --> 00:00:6,000\n"
+
"Baz.\n"))
+ (setq mark-active t)
+ (spy-on 'region-beginning
:and-return-value (subed-jump-to-subtitle-id 1))
+ (spy-on 'region-end :and-return-value
(subed-jump-to-subtitle-text 2))
+ (let ((orig-point
(subed-jump-to-subtitle-time-start 3)))
+ (subed-move-subtitle-forward
1000)
+ (expect
(subed-subtitle-msecs-start 1) :to-equal 1000)
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal 2000)
+ (expect
(subed-subtitle-msecs-start 2) :to-equal 2050)
+ (expect
(subed-subtitle-msecs-stop 2) :to-equal 3000)
+ (expect
(subed-subtitle-msecs-start 3) :to-equal 5000)
+ (expect
(subed-subtitle-msecs-stop 3) :to-equal 6000)
+ (expect (point) :to-equal
orig-point))))
(it "when moving backward."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:04,000 --> 00:00:05,000\n"
- "Bar.\n\n"
- "3\n"
- "00:00:05,000 --> 00:00:05,000\n"
- "Baz.\n"))
- (setq mark-active t)
- (spy-on 'region-beginning :and-return-value
(subed-jump-to-subtitle-id 2))
- (spy-on 'region-end :and-return-value (subed-jump-to-subtitle-text 3))
- (let ((orig-point (subed-jump-to-subtitle-time-stop 1)))
- (subed-move-subtitle-backward 1000)
- (expect (subed-subtitle-msecs-start 1) :to-equal 1000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2000)
- (expect (subed-subtitle-msecs-start 2) :to-equal 3000)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 4000)
- (expect (subed-subtitle-msecs-start 3) :to-equal 4000)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 4000)
- (expect (point) :to-equal orig-point))))
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:04,000 --> 00:00:05,000\n"
+
"Bar.\n\n"
+
"3\n"
+
"00:00:05,000 --> 00:00:05,000\n"
+
"Baz.\n"))
+ (setq mark-active t)
+ (spy-on 'region-beginning
:and-return-value (subed-jump-to-subtitle-id 2))
+ (spy-on 'region-end :and-return-value
(subed-jump-to-subtitle-text 3))
+ (let ((orig-point
(subed-jump-to-subtitle-time-stop 1)))
+ (subed-move-subtitle-backward
1000)
+ (expect
(subed-subtitle-msecs-start 1) :to-equal 1000)
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal 2000)
+ (expect
(subed-subtitle-msecs-start 2) :to-equal 3000)
+ (expect
(subed-subtitle-msecs-stop 2) :to-equal 4000)
+ (expect
(subed-subtitle-msecs-start 3) :to-equal 4000)
+ (expect
(subed-subtitle-msecs-stop 3) :to-equal 4000)
+ (expect (point) :to-equal
orig-point))))
)
(describe "ignoring overlapping subtitles"
(it "when moving forward."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:01,500\n"
- "Foo.\n\n"
- "2\n"
- "00:00:01,300 --> 00:00:02,000\n"
- "Bar.\n\n"
- "3\n"
- "00:00:05,000 --> 00:00:6,000\n"
- "Baz.\n"))
- (setq mark-active t)
- (spy-on 'region-beginning :and-return-value
(subed-jump-to-subtitle-id 1))
- (spy-on 'region-end :and-return-value (subed-jump-to-subtitle-text 2))
- (let ((orig-point (subed-jump-to-subtitle-text 2)))
- (subed-move-subtitle-forward 1000)
- (expect (subed-subtitle-msecs-start 1) :to-equal 2000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2500)
- (expect (subed-subtitle-msecs-start 2) :to-equal 2300)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 3000)
- (expect (subed-subtitle-msecs-start 3) :to-equal 5000)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 6000)
- (expect (point) :to-equal orig-point))))
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:01,500\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:01,300 --> 00:00:02,000\n"
+
"Bar.\n\n"
+
"3\n"
+
"00:00:05,000 --> 00:00:6,000\n"
+
"Baz.\n"))
+ (setq mark-active t)
+ (spy-on 'region-beginning
:and-return-value (subed-jump-to-subtitle-id 1))
+ (spy-on 'region-end :and-return-value
(subed-jump-to-subtitle-text 2))
+ (let ((orig-point
(subed-jump-to-subtitle-text 2)))
+ (subed-move-subtitle-forward
1000)
+ (expect
(subed-subtitle-msecs-start 1) :to-equal 2000)
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal 2500)
+ (expect
(subed-subtitle-msecs-start 2) :to-equal 2300)
+ (expect
(subed-subtitle-msecs-stop 2) :to-equal 3000)
+ (expect
(subed-subtitle-msecs-start 3) :to-equal 5000)
+ (expect
(subed-subtitle-msecs-stop 3) :to-equal 6000)
+ (expect (point) :to-equal
orig-point))))
(it "when moving backward."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:04,500 --> 00:00:04,000\n"
- "Bar.\n\n"
- "3\n"
- "00:00:04,500 --> 00:00:04,490\n"
- "Baz.\n"))
- (setq mark-active t)
- (spy-on 'region-beginning :and-return-value
(subed-jump-to-subtitle-id 2))
- (spy-on 'region-end :and-return-value (subed-jump-to-subtitle-text 3))
- (let ((orig-point (subed-jump-to-subtitle-text 1)))
- (subed-move-subtitle-backward 1000)
- (expect (subed-subtitle-msecs-start 1) :to-equal 1000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2000)
- (expect (subed-subtitle-msecs-start 2) :to-equal 3500)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 3000)
- (expect (subed-subtitle-msecs-start 3) :to-equal 3500)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 3490)
- (expect (point) :to-equal orig-point))))
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:04,500 --> 00:00:04,000\n"
+
"Bar.\n\n"
+
"3\n"
+
"00:00:04,500 --> 00:00:04,490\n"
+
"Baz.\n"))
+ (setq mark-active t)
+ (spy-on 'region-beginning
:and-return-value (subed-jump-to-subtitle-id 2))
+ (spy-on 'region-end :and-return-value
(subed-jump-to-subtitle-text 3))
+ (let ((orig-point
(subed-jump-to-subtitle-text 1)))
+ (subed-move-subtitle-backward
1000)
+ (expect
(subed-subtitle-msecs-start 1) :to-equal 1000)
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal 2000)
+ (expect
(subed-subtitle-msecs-start 2) :to-equal 3500)
+ (expect
(subed-subtitle-msecs-stop 2) :to-equal 3000)
+ (expect
(subed-subtitle-msecs-start 3) :to-equal 3500)
+ (expect
(subed-subtitle-msecs-stop 3) :to-equal 3490)
+ (expect (point) :to-equal
orig-point))))
)
(it "ignoring start time being larger than stop time."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,500 --> 00:00:01,400\n"
- "Foo.\n\n"
- "2\n"
- "00:00:02,500 --> 00:00:02,499\n"
- "Bar.\n\n"
- "3\n"
- "00:00:05,000 --> 00:00:06,000\n"
- "Bar.\n"))
- (setq mark-active t)
- (spy-on 'region-beginning :and-return-value
(subed-jump-to-subtitle-text 1))
- (spy-on 'region-end :and-return-value
(subed-jump-to-subtitle-time-start 2))
- (let ((orig-point (subed-jump-to-subtitle-time-stop 1)))
- (subed-move-subtitle-forward 1000)
- (expect (subed-subtitle-msecs-start 1) :to-equal 2500)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2400)
- (expect (subed-subtitle-msecs-start 2) :to-equal 3500)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 3499)
- (expect (subed-subtitle-msecs-start 3) :to-equal 5000)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 6000)
- (expect (point) :to-equal orig-point)
- (subed-move-subtitle-backward 500)
- (expect (subed-subtitle-msecs-start 1) :to-equal 2000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 1900)
- (expect (subed-subtitle-msecs-start 2) :to-equal 3000)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 2999)
- (expect (subed-subtitle-msecs-start 3) :to-equal 5000)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 6000)
- (expect (point) :to-equal orig-point))))
+ (insert (concat "1\n"
+
"00:00:01,500 --> 00:00:01,400\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:02,500 --> 00:00:02,499\n"
+
"Bar.\n\n"
+
"3\n"
+
"00:00:05,000 --> 00:00:06,000\n"
+
"Bar.\n"))
+ (setq mark-active t)
+ (spy-on 'region-beginning :and-return-value
(subed-jump-to-subtitle-text 1))
+ (spy-on 'region-end :and-return-value
(subed-jump-to-subtitle-time-start 2))
+ (let ((orig-point
(subed-jump-to-subtitle-time-stop 1)))
+ (subed-move-subtitle-forward 1000)
+ (expect (subed-subtitle-msecs-start 1)
:to-equal 2500)
+ (expect (subed-subtitle-msecs-stop 1)
:to-equal 2400)
+ (expect (subed-subtitle-msecs-start 2)
:to-equal 3500)
+ (expect (subed-subtitle-msecs-stop 2)
:to-equal 3499)
+ (expect (subed-subtitle-msecs-start 3)
:to-equal 5000)
+ (expect (subed-subtitle-msecs-stop 3)
:to-equal 6000)
+ (expect (point) :to-equal orig-point)
+ (subed-move-subtitle-backward 500)
+ (expect (subed-subtitle-msecs-start 1)
:to-equal 2000)
+ (expect (subed-subtitle-msecs-stop 1)
:to-equal 1900)
+ (expect (subed-subtitle-msecs-start 2)
:to-equal 3000)
+ (expect (subed-subtitle-msecs-stop 2)
:to-equal 2999)
+ (expect (subed-subtitle-msecs-start 3)
:to-equal 5000)
+ (expect (subed-subtitle-msecs-stop 3)
:to-equal 6000)
+ (expect (point) :to-equal orig-point))))
(it "ignoring stop time being smaller than start time."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"
- "2\n"
- "00:00:04,100 --> 00:00:04,099\n"
- "Bar.\n\n"
- "3\n"
- "00:00:05,500 --> 00:00:05,000\n"
- "Bar.\n"))
- (setq mark-active t)
- (spy-on 'region-beginning :and-return-value
(subed-jump-to-subtitle-text 2))
- (spy-on 'region-end :and-return-value
(subed-jump-to-subtitle-time-start 3))
- (let ((orig-point (subed-jump-to-subtitle-text 1)))
- (subed-move-subtitle-forward 1000)
- (expect (subed-subtitle-msecs-start 1) :to-equal 1000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2000)
- (expect (subed-subtitle-msecs-start 2) :to-equal 5100)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 5099)
- (expect (subed-subtitle-msecs-start 3) :to-equal 6500)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 6000)
- (expect (point) :to-equal orig-point)
- (subed-move-subtitle-backward 500)
- (expect (subed-subtitle-msecs-start 1) :to-equal 1000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2000)
- (expect (subed-subtitle-msecs-start 2) :to-equal 4600)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 4599)
- (expect (subed-subtitle-msecs-start 3) :to-equal 6000)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 5500)
- (expect (point) :to-equal orig-point))))
+ (insert (concat "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+
"Foo.\n\n"
+
"2\n"
+
"00:00:04,100 --> 00:00:04,099\n"
+
"Bar.\n\n"
+
"3\n"
+
"00:00:05,500 --> 00:00:05,000\n"
+
"Bar.\n"))
+ (setq mark-active t)
+ (spy-on 'region-beginning :and-return-value
(subed-jump-to-subtitle-text 2))
+ (spy-on 'region-end :and-return-value
(subed-jump-to-subtitle-time-start 3))
+ (let ((orig-point (subed-jump-to-subtitle-text
1)))
+ (subed-move-subtitle-forward 1000)
+ (expect (subed-subtitle-msecs-start 1)
:to-equal 1000)
+ (expect (subed-subtitle-msecs-stop 1)
:to-equal 2000)
+ (expect (subed-subtitle-msecs-start 2)
:to-equal 5100)
+ (expect (subed-subtitle-msecs-stop 2)
:to-equal 5099)
+ (expect (subed-subtitle-msecs-start 3)
:to-equal 6500)
+ (expect (subed-subtitle-msecs-stop 3)
:to-equal 6000)
+ (expect (point) :to-equal orig-point)
+ (subed-move-subtitle-backward 500)
+ (expect (subed-subtitle-msecs-start 1)
:to-equal 1000)
+ (expect (subed-subtitle-msecs-stop 1)
:to-equal 2000)
+ (expect (subed-subtitle-msecs-start 2)
:to-equal 4600)
+ (expect (subed-subtitle-msecs-stop 2)
:to-equal 4599)
+ (expect (subed-subtitle-msecs-start 3)
:to-equal 6000)
+ (expect (subed-subtitle-msecs-stop 3)
:to-equal 5500)
+ (expect (point) :to-equal orig-point))))
(it "disables subtitle replay while moving subtitles."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-enable-replay-adjusted-subtitle :quiet)
- (spy-on 'subed-enable-replay-adjusted-subtitle :and-call-through)
- (spy-on 'subed-disable-replay-adjusted-subtitle :and-call-through)
- (spy-on 'subed-adjust-subtitle-time-start :and-call-fake
- (lambda (msecs &optional a b) (expect
(subed-replay-adjusted-subtitle-p) :to-be nil)))
- (spy-on 'subed-adjust-subtitle-stop :and-call-fake
- (lambda (msecs &optional a b) (expect
(subed-replay-adjusted-subtitle-p) :to-be nil)))
- (subed-move-subtitle-forward 100)
- (expect 'subed-disable-replay-adjusted-subtitle
:to-have-been-called-times 1)
- (expect 'subed-enable-replay-adjusted-subtitle
:to-have-been-called-times 1)
- (subed-move-subtitle-backward 100)
- (expect 'subed-disable-replay-adjusted-subtitle
:to-have-been-called-times 2)
- (expect 'subed-enable-replay-adjusted-subtitle
:to-have-been-called-times 2)))
+ (insert mock-srt-data)
+ (subed-enable-replay-adjusted-subtitle :quiet)
+ (spy-on 'subed-enable-replay-adjusted-subtitle
:and-call-through)
+ (spy-on 'subed-disable-replay-adjusted-subtitle
:and-call-through)
+ (spy-on 'subed-adjust-subtitle-time-start
:and-call-fake
+ (lambda (msecs
&optional a b) (expect (subed-replay-adjusted-subtitle-p) :to-be nil)))
+ (spy-on 'subed-adjust-subtitle-stop
:and-call-fake
+ (lambda (msecs
&optional a b) (expect (subed-replay-adjusted-subtitle-p) :to-be nil)))
+ (subed-move-subtitle-forward 100)
+ (expect 'subed-disable-replay-adjusted-subtitle
:to-have-been-called-times 1)
+ (expect 'subed-enable-replay-adjusted-subtitle
:to-have-been-called-times 1)
+ (subed-move-subtitle-backward 100)
+ (expect 'subed-disable-replay-adjusted-subtitle
:to-have-been-called-times 2)
+ (expect 'subed-enable-replay-adjusted-subtitle
:to-have-been-called-times 2)))
(it "does not enable subtitle replay afterwards if it is disabled."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-disable-replay-adjusted-subtitle :quiet)
- (spy-on 'subed-enable-replay-adjusted-subtitle :and-call-through)
- (spy-on 'subed-disable-replay-adjusted-subtitle :and-call-through)
- (spy-on 'subed-adjust-subtitle-time-start :and-call-fake
- (lambda (msecs &optional a b) (expect
(subed-replay-adjusted-subtitle-p) :to-be nil)))
- (spy-on 'subed-adjust-subtitle-stop :and-call-fake
- (lambda (msecs &optional a b) (expect
(subed-replay-adjusted-subtitle-p) :to-be nil)))
- (subed-move-subtitle-forward 100)
- (expect 'subed-disable-replay-adjusted-subtitle
:to-have-been-called-times 1)
- (expect 'subed-enable-replay-adjusted-subtitle
:to-have-been-called-times 0)
- (subed-move-subtitle-backward 100)
- (expect 'subed-disable-replay-adjusted-subtitle
:to-have-been-called-times 2)
- (expect 'subed-enable-replay-adjusted-subtitle
:to-have-been-called-times 0)))
+ (insert mock-srt-data)
+ (subed-disable-replay-adjusted-subtitle :quiet)
+ (spy-on 'subed-enable-replay-adjusted-subtitle
:and-call-through)
+ (spy-on 'subed-disable-replay-adjusted-subtitle
:and-call-through)
+ (spy-on 'subed-adjust-subtitle-time-start
:and-call-fake
+ (lambda (msecs
&optional a b) (expect (subed-replay-adjusted-subtitle-p) :to-be nil)))
+ (spy-on 'subed-adjust-subtitle-stop
:and-call-fake
+ (lambda (msecs
&optional a b) (expect (subed-replay-adjusted-subtitle-p) :to-be nil)))
+ (subed-move-subtitle-forward 100)
+ (expect 'subed-disable-replay-adjusted-subtitle
:to-have-been-called-times 1)
+ (expect 'subed-enable-replay-adjusted-subtitle
:to-have-been-called-times 0)
+ (subed-move-subtitle-backward 100)
+ (expect 'subed-disable-replay-adjusted-subtitle
:to-have-been-called-times 2)
+ (expect 'subed-enable-replay-adjusted-subtitle
:to-have-been-called-times 0)))
(it "seeks player to current subtitle if region is not active."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (spy-on 'subed-replay-adjusted-subtitle-p :and-return-value t)
- (spy-on 'subed-mpv-jump)
- (subed-move-subtitle-forward 100)
- (expect 'subed-mpv-jump :to-have-been-called-times 1)
- (expect 'subed-mpv-jump :to-have-been-called-with 183550)
- (subed-move-subtitle-backward 200)
- (expect 'subed-mpv-jump :to-have-been-called-times 2)
- (expect 'subed-mpv-jump :to-have-been-called-with 183350)))
+ (insert mock-srt-data)
+ (spy-on 'subed-replay-adjusted-subtitle-p
:and-return-value t)
+ (spy-on 'subed-mpv-jump)
+ (subed-move-subtitle-forward 100)
+ (expect 'subed-mpv-jump
:to-have-been-called-times 1)
+ (expect 'subed-mpv-jump
:to-have-been-called-with 183550)
+ (subed-move-subtitle-backward 200)
+ (expect 'subed-mpv-jump
:to-have-been-called-times 2)
+ (expect 'subed-mpv-jump
:to-have-been-called-with 183350)))
(it "seeks player to first subtitle in active region."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (let ((beg 15)
- (end (point-max)))
- (setq mark-active t)
- (spy-on 'region-beginning :and-return-value beg)
- (spy-on 'region-end :and-return-value end)
- (spy-on 'subed-replay-adjusted-subtitle-p :and-return-value t)
- (spy-on 'subed-mpv-jump)
- (subed-move-subtitle-forward 100)
- (expect 'subed-mpv-jump :to-have-been-called-times 1)
- (expect 'subed-mpv-jump :to-have-been-called-with '61100)
- (subed-move-subtitle-backward 300)
- (expect 'subed-mpv-jump :to-have-been-called-times 2)
- (expect 'subed-mpv-jump :to-have-been-called-with '60800))))
- )
+ (insert mock-srt-data)
+ (let ((beg 15)
+ (end (point-max)))
+ (setq mark-active t)
+ (spy-on 'region-beginning
:and-return-value beg)
+ (spy-on 'region-end :and-return-value
end)
+ (spy-on
'subed-replay-adjusted-subtitle-p :and-return-value t)
+ (spy-on 'subed-mpv-jump)
+ (subed-move-subtitle-forward 100)
+ (expect 'subed-mpv-jump
:to-have-been-called-times 1)
+ (expect 'subed-mpv-jump
:to-have-been-called-with '61100)
+ (subed-move-subtitle-backward 300)
+ (expect 'subed-mpv-jump
:to-have-been-called-times 2)
+ (expect 'subed-mpv-jump
:to-have-been-called-with '60800)))))
(describe "Inserting evenly spaced"
(describe "in an empty buffer,"
@@ -1212,55 +1234,55 @@ Baz.
(it "a single subtile."
(cl-loop for arg in (list nil 1) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (expect (subed-insert-subtitle arg) :to-equal 33)
- (expect (buffer-string) :to-equal (concat "0\n"
- "00:00:00,000
--> 00:00:01,000\n"
- "\n"))
- (expect (point) :to-equal 33)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (expect (subed-insert-subtitle arg) :to-equal 33)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:00,000
--> 00:00:01,000\n"
+ "\n"))
+ (expect (point) :to-equal 33)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtiles."
(cl-loop for arg in (list 2) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (expect (subed-insert-subtitle arg) :to-equal 33)
- (expect (buffer-string) :to-equal (concat "0\n"
- "00:00:00,000
--> 00:00:01,000\n"
- "\n\n"
- "0\n"
- "00:00:01,100
--> 00:00:02,100\n"
- "\n"))
- (expect (point) :to-equal 33)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (expect (subed-insert-subtitle arg) :to-equal 33)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:00,000
--> 00:00:01,000\n"
+ "\n\n"
+ "0\n"
+ "00:00:01,100
--> 00:00:02,100\n"
+ "\n"))
+ (expect (point) :to-equal 33)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
(describe "prepending"
(it "a single subtile."
(cl-loop for arg in (list '- -1 (list 4)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (expect (subed-insert-subtitle arg) :to-equal 33)
- (expect (buffer-string) :to-equal (concat "0\n"
- "00:00:00,000
--> 00:00:01,000\n"
- "\n"))
- (expect (point) :to-equal 33)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (expect (subed-insert-subtitle arg) :to-equal 33)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:00,000
--> 00:00:01,000\n"
+ "\n"))
+ (expect (point) :to-equal 33)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtiles."
(cl-loop for arg in (list -2 (list -16)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (expect (subed-insert-subtitle arg) :to-equal 33)
- (expect (buffer-string) :to-equal (concat "0\n"
- "00:00:00,000
--> 00:00:01,000\n"
- "\n\n"
- "0\n"
- "00:00:01,100
--> 00:00:02,100\n"
- "\n"))
- (expect (point) :to-equal 33)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (expect (subed-insert-subtitle arg) :to-equal 33)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:00,000
--> 00:00:01,000\n"
+ "\n\n"
+ "0\n"
+ "00:00:01,100
--> 00:00:02,100\n"
+ "\n"))
+ (expect (point) :to-equal 33)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
)
(describe "in a non-empty buffer"
@@ -1268,335 +1290,335 @@ Baz.
(it "a single subtitle."
(cl-loop for arg in (list '- -1 (list 4)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "2\n"
- "00:02:00,000 --> 00:02:01,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-text 2)
- (expect (subed-insert-subtitle arg) :to-equal 71)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:00:59,000
--> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
- "00:01:30,000
--> 00:01:31,000\n"
- "\n\n"
- "2\n"
- "00:02:00,000
--> 00:02:01,000\n"
- "Bar.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:02:00,000 --> 00:02:01,000\n"
+ "Bar.\n"))
+ (subed-jump-to-subtitle-text 2)
+ (expect (subed-insert-subtitle arg) :to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:00:59,000
--> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+ "00:01:30,000
--> 00:01:31,000\n"
+ "\n\n"
+ "2\n"
+ "00:02:00,000
--> 00:02:01,000\n"
+ "Bar.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtitles."
(cl-loop for arg in (list -2 (list 16)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "2\n"
- "00:02:00,000 --> 00:02:01,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-text 2)
- (expect (subed-insert-subtitle arg) :to-equal 71)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:00:59,000
--> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
- "00:01:20,000
--> 00:01:21,000\n"
- "\n\n"
- "0\n"
- "00:01:40,000
--> 00:01:41,000\n"
- "\n\n"
- "2\n"
- "00:02:00,000
--> 00:02:01,000\n"
- "Bar.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:02:00,000 --> 00:02:01,000\n"
+ "Bar.\n"))
+ (subed-jump-to-subtitle-text 2)
+ (expect (subed-insert-subtitle arg) :to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:00:59,000
--> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+ "00:01:20,000
--> 00:01:21,000\n"
+ "\n\n"
+ "0\n"
+ "00:01:40,000
--> 00:01:41,000\n"
+ "\n\n"
+ "2\n"
+ "00:02:00,000
--> 00:02:01,000\n"
+ "Bar.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
(describe "appending between subtitles"
(it "a single subtitle."
(cl-loop for arg in (list nil 1) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "2\n"
- "00:02:00,000 --> 00:02:01,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle arg) :to-equal 71)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:00:59,000
--> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
- "00:01:30,000
--> 00:01:31,000\n"
- "\n\n"
- "2\n"
- "00:02:00,000
--> 00:02:01,000\n"
- "Bar.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:02:00,000 --> 00:02:01,000\n"
+ "Bar.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle arg) :to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:00:59,000
--> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+ "00:01:30,000
--> 00:01:31,000\n"
+ "\n\n"
+ "2\n"
+ "00:02:00,000
--> 00:02:01,000\n"
+ "Bar.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtitles."
(cl-loop for arg in (list 2) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "2\n"
- "00:02:00,000 --> 00:02:01,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle arg) :to-equal 71)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:00:59,000
--> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
- "00:01:20,000
--> 00:01:21,000\n"
- "\n\n"
- "0\n"
- "00:01:40,000
--> 00:01:41,000\n"
- "\n\n"
- "2\n"
- "00:02:00,000
--> 00:02:01,000\n"
- "Bar.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:02:00,000 --> 00:02:01,000\n"
+ "Bar.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle arg) :to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:00:59,000
--> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+ "00:01:20,000
--> 00:01:21,000\n"
+ "\n\n"
+ "0\n"
+ "00:01:40,000
--> 00:01:41,000\n"
+ "\n\n"
+ "2\n"
+ "00:02:00,000
--> 00:02:01,000\n"
+ "Bar.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
(describe "prepending to the first subtitle"
(it "a single subtitle."
(cl-loop for arg in (list '- -1 (list 4)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:01:00,000 --> 00:01:01,000\n"
- "Foo.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle arg) :to-equal 33)
- (expect (buffer-string) :to-equal (concat "0\n"
- "00:00:30,000
--> 00:00:31,000\n"
- "\n\n"
- "1\n"
- "00:01:00,000
--> 00:01:01,000\n"
- "Foo.\n"))
- (expect (point) :to-equal 33)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:01:00,000 --> 00:01:01,000\n"
+ "Foo.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle arg) :to-equal 33)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:30,000
--> 00:00:31,000\n"
+ "\n\n"
+ "1\n"
+ "00:01:00,000
--> 00:01:01,000\n"
+ "Foo.\n"))
+ (expect (point) :to-equal 33)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtitles."
(cl-loop for arg in (list -2 (list 16)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:01:00,000 --> 00:01:01,000\n"
- "Foo.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle arg) :to-equal 33)
- (expect (buffer-string) :to-equal (concat "0\n"
- "00:00:20,000
--> 00:00:21,000\n"
- "\n\n"
- "0\n"
- "00:00:40,000
--> 00:00:41,000\n"
- "\n\n"
- "1\n"
- "00:01:00,000
--> 00:01:01,000\n"
- "Foo.\n"))
- (expect (point) :to-equal 33)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:01:00,000 --> 00:01:01,000\n"
+ "Foo.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle arg) :to-equal 33)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:20,000
--> 00:00:21,000\n"
+ "\n\n"
+ "0\n"
+ "00:00:40,000
--> 00:00:41,000\n"
+ "\n\n"
+ "1\n"
+ "00:01:00,000
--> 00:01:01,000\n"
+ "Foo.\n"))
+ (expect (point) :to-equal 33)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
(describe "appending to the last subtitle"
(it "a single subtitle."
(cl-loop for arg in (list nil 1) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle arg) :to-equal 71)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:00:59,000
--> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
- "00:01:00,100
--> 00:01:01,100\n"
- "\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle arg) :to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:00:59,000
--> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+ "00:01:00,100
--> 00:01:01,100\n"
+ "\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtitles."
(cl-loop for arg in (list 2) do
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n"))
- (subed-jump-to-subtitle-text 3)
- (expect (subed-insert-subtitle arg) :to-equal 71)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:00:59,000
--> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
- "00:01:00,100
--> 00:01:01,100\n"
- "\n\n"
- "0\n"
- "00:01:01,200
--> 00:01:02,200\n"
- "\n"))
- (expect (point) :to-equal 71))))
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n"))
+ (subed-jump-to-subtitle-text 3)
+ (expect (subed-insert-subtitle arg) :to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:00:59,000
--> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+ "00:01:00,100
--> 00:01:01,100\n"
+ "\n\n"
+ "0\n"
+ "00:01:01,200
--> 00:01:02,200\n"
+ "\n"))
+ (expect (point) :to-equal 71))))
)
(describe "when there is not enough time for the subtitles"
(describe "to append"
(it "a single subtitle."
(cl-loop for arg in (list nil 1) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "2\n"
- "00:01:00,600 --> 00:01:02,000\n"
- "Foo.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle arg) :to-equal 71)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:00:59,000
--> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
- "00:01:00,100
--> 00:01:00,500\n"
- "\n\n"
- "2\n"
- "00:01:00,600
--> 00:01:02,000\n"
- "Foo.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:01:00,600 --> 00:01:02,000\n"
+ "Foo.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle arg) :to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:00:59,000
--> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+ "00:01:00,100
--> 00:01:00,500\n"
+ "\n\n"
+ "2\n"
+ "00:01:00,600
--> 00:01:02,000\n"
+ "Foo.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtitles."
(cl-loop for arg in (list 2) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "2\n"
- "00:01:00,600 --> 00:01:02,000\n"
- "Foo.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle arg) :to-equal 71)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:00:59,000
--> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
- "00:01:00,100
--> 00:01:00,250\n"
- "\n\n"
- "0\n"
- "00:01:00,350
--> 00:01:00,500\n"
- "\n\n"
- "2\n"
- "00:01:00,600
--> 00:01:02,000\n"
- "Foo.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:01:00,600 --> 00:01:02,000\n"
+ "Foo.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle arg) :to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:00:59,000
--> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+ "00:01:00,100
--> 00:01:00,250\n"
+ "\n\n"
+ "0\n"
+ "00:01:00,350
--> 00:01:00,500\n"
+ "\n\n"
+ "2\n"
+ "00:01:00,600
--> 00:01:02,000\n"
+ "Foo.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
(describe "to prepend"
(describe "between subtitles"
(it "a single subtitle."
(cl-loop for arg in (list '- -1 (list 4)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:57,000 --> 00:00:59,100\n"
- "Foo.\n\n"
- "2\n"
- "00:01:00,000 --> 00:01:02,000\n"
- "Foo.\n"))
- (subed-jump-to-subtitle-text 2)
- (expect (subed-insert-subtitle arg) :to-equal 71)
- (expect (buffer-string) :to-equal (concat "1\n"
-
"00:00:57,000 --> 00:00:59,100\n"
- "Foo.\n\n"
- "0\n"
-
"00:00:59,200 --> 00:00:59,900\n"
- "\n\n"
- "2\n"
-
"00:01:00,000 --> 00:01:02,000\n"
- "Foo.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:57,000 --> 00:00:59,100\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:01:00,000 --> 00:01:02,000\n"
+ "Foo.\n"))
+ (subed-jump-to-subtitle-text 2)
+ (expect (subed-insert-subtitle arg) :to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+
"00:00:57,000 --> 00:00:59,100\n"
+ "Foo.\n\n"
+ "0\n"
+
"00:00:59,200 --> 00:00:59,900\n"
+ "\n\n"
+ "2\n"
+
"00:01:00,000 --> 00:01:02,000\n"
+ "Foo.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtitles."
(cl-loop for arg in (list -2 (list 16)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:57,000 --> 00:00:59,100\n"
- "Foo.\n\n"
- "2\n"
- "00:01:00,000 --> 00:01:02,000\n"
- "Foo.\n"))
- (subed-jump-to-subtitle-text 2)
- (expect (subed-insert-subtitle arg) :to-equal 71)
- (expect (buffer-string) :to-equal (concat "1\n"
-
"00:00:57,000 --> 00:00:59,100\n"
- "Foo.\n\n"
- "0\n"
-
"00:00:59,200 --> 00:00:59,500\n"
- "\n\n"
- "0\n"
-
"00:00:59,600 --> 00:00:59,900\n"
- "\n\n"
- "2\n"
-
"00:01:00,000 --> 00:01:02,000\n"
- "Foo.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:57,000 --> 00:00:59,100\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:01:00,000 --> 00:01:02,000\n"
+ "Foo.\n"))
+ (subed-jump-to-subtitle-text 2)
+ (expect (subed-insert-subtitle arg) :to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+
"00:00:57,000 --> 00:00:59,100\n"
+ "Foo.\n\n"
+ "0\n"
+
"00:00:59,200 --> 00:00:59,500\n"
+ "\n\n"
+ "0\n"
+
"00:00:59,600 --> 00:00:59,900\n"
+ "\n\n"
+ "2\n"
+
"00:01:00,000 --> 00:01:02,000\n"
+ "Foo.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
(describe "before the first subtitle"
(it "a single subtitle."
(cl-loop for arg in (list '- -1 (list 4)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:00,500 --> 00:00:02,000\n"
- "Foo.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle arg) :to-equal 33)
- (expect (buffer-string) :to-equal (concat "0\n"
-
"00:00:00,100 --> 00:00:00,400\n"
- "\n\n"
- "1\n"
-
"00:00:00,500 --> 00:00:02,000\n"
- "Foo.\n"))
- (expect (point) :to-equal 33)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:00,500 --> 00:00:02,000\n"
+ "Foo.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle arg) :to-equal 33)
+ (expect (buffer-string) :to-equal (concat "0\n"
+
"00:00:00,100 --> 00:00:00,400\n"
+ "\n\n"
+ "1\n"
+
"00:00:00,500 --> 00:00:02,000\n"
+ "Foo.\n"))
+ (expect (point) :to-equal 33)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtitles."
(cl-loop for arg in (list -2 (list 16)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:00,600 --> 00:00:01,500\n"
- "Foo.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle arg) :to-equal 33)
- (expect (buffer-string) :to-equal (concat "0\n"
-
"00:00:00,100 --> 00:00:00,250\n"
- "\n\n"
- "0\n"
-
"00:00:00,350 --> 00:00:00,500\n"
- "\n\n"
- "1\n"
-
"00:00:00,600 --> 00:00:01,500\n"
- "Foo.\n"))
- (expect (point) :to-equal 33)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:00,600 --> 00:00:01,500\n"
+ "Foo.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle arg) :to-equal 33)
+ (expect (buffer-string) :to-equal (concat "0\n"
+
"00:00:00,100 --> 00:00:00,250\n"
+ "\n\n"
+ "0\n"
+
"00:00:00,350 --> 00:00:00,500\n"
+ "\n\n"
+ "1\n"
+
"00:00:00,600 --> 00:00:01,500\n"
+ "Foo.\n"))
+ (expect (point) :to-equal 33)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
)
)
@@ -1606,149 +1628,149 @@ Baz.
(it "a single subtitle."
(cl-loop for arg in (list '- -1 (list 4)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:55,000 --> 00:00:59,950\n"
- "Foo.\n\n"
- "2\n"
- "00:01:00,000 --> 00:01:02,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-text 2)
- (expect (subed-insert-subtitle arg) :to-equal 71)
- (expect (buffer-string) :to-equal (concat "1\n"
-
"00:00:55,000 --> 00:00:59,950\n"
- "Foo.\n\n"
- "0\n"
-
"00:00:59,950 --> 00:00:59,950\n"
- "\n\n"
- "2\n"
-
"00:01:00,000 --> 00:01:02,000\n"
- "Bar.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:55,000 --> 00:00:59,950\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:01:00,000 --> 00:01:02,000\n"
+ "Bar.\n"))
+ (subed-jump-to-subtitle-text 2)
+ (expect (subed-insert-subtitle arg) :to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+
"00:00:55,000 --> 00:00:59,950\n"
+ "Foo.\n\n"
+ "0\n"
+
"00:00:59,950 --> 00:00:59,950\n"
+ "\n\n"
+ "2\n"
+
"00:01:00,000 --> 00:01:02,000\n"
+ "Bar.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtitles."
(cl-loop for arg in (list -2 (list 16)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:57,000 --> 00:00:59,999\n"
- "Foo.\n\n"
- "2\n"
- "00:01:00,000 --> 00:01:02,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-text 2)
- (expect (subed-insert-subtitle arg) :to-equal 71)
- (expect (buffer-string) :to-equal (concat "1\n"
-
"00:00:57,000 --> 00:00:59,999\n"
- "Foo.\n\n"
- "0\n"
-
"00:00:59,999 --> 00:00:59,999\n"
- "\n\n"
- "0\n"
-
"00:00:59,999 --> 00:00:59,999\n"
- "\n\n"
- "2\n"
-
"00:01:00,000 --> 00:01:02,000\n"
- "Bar.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:57,000 --> 00:00:59,999\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:01:00,000 --> 00:01:02,000\n"
+ "Bar.\n"))
+ (subed-jump-to-subtitle-text 2)
+ (expect (subed-insert-subtitle arg) :to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+
"00:00:57,000 --> 00:00:59,999\n"
+ "Foo.\n\n"
+ "0\n"
+
"00:00:59,999 --> 00:00:59,999\n"
+ "\n\n"
+ "0\n"
+
"00:00:59,999 --> 00:00:59,999\n"
+ "\n\n"
+ "2\n"
+
"00:01:00,000 --> 00:01:02,000\n"
+ "Bar.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
(describe "when appending"
(it "a single subtitle."
(cl-loop for arg in (list nil 1) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "2\n"
- "00:01:00,010 --> 00:01:02,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle arg) :to-equal 71)
- (expect (buffer-string) :to-equal (concat "1\n"
-
"00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
-
"00:01:00,000 --> 00:01:00,000\n"
- "\n\n"
- "2\n"
-
"00:01:00,010 --> 00:01:02,000\n"
- "Bar.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:01:00,010 --> 00:01:02,000\n"
+ "Bar.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle arg) :to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+
"00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+
"00:01:00,000 --> 00:01:00,000\n"
+ "\n\n"
+ "2\n"
+
"00:01:00,010 --> 00:01:02,000\n"
+ "Bar.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtitles."
(cl-loop for arg in (list 2) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "2\n"
- "00:01:00,100 --> 00:01:02,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle arg) :to-equal 71)
- (expect (buffer-string) :to-equal (concat "1\n"
-
"00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
-
"00:01:00,000 --> 00:01:00,000\n"
- "\n\n"
- "0\n"
-
"00:01:00,000 --> 00:01:00,000\n"
- "\n\n"
- "2\n"
-
"00:01:00,100 --> 00:01:02,000\n"
- "Bar.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:01:00,100 --> 00:01:02,000\n"
+ "Bar.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle arg) :to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+
"00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+
"00:01:00,000 --> 00:01:00,000\n"
+ "\n\n"
+ "0\n"
+
"00:01:00,000 --> 00:01:00,000\n"
+ "\n\n"
+ "2\n"
+
"00:01:00,100 --> 00:01:02,000\n"
+ "Bar.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
)
(describe "before the first subtitle"
(it "a single subtitle."
(cl-loop for arg in (list '- -1 (list 4)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:00,050 --> 00:00:02,000\n"
- "Foo.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle arg) :to-equal 33)
- (expect (buffer-string) :to-equal (concat "0\n"
- "00:00:00,000
--> 00:00:00,000\n"
- "\n\n"
- "1\n"
- "00:00:00,050
--> 00:00:02,000\n"
- "Foo.\n"))
- (expect (point) :to-equal 33)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:00,050 --> 00:00:02,000\n"
+ "Foo.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle arg) :to-equal 33)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:00,000
--> 00:00:00,000\n"
+ "\n\n"
+ "1\n"
+ "00:00:00,050
--> 00:00:02,000\n"
+ "Foo.\n"))
+ (expect (point) :to-equal 33)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtitles."
(cl-loop for arg in (list -2 (list 16)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:00,100 --> 00:00:01,500\n"
- "Foo.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle arg) :to-equal 33)
- (expect (buffer-string) :to-equal (concat "0\n"
- "00:00:00,000
--> 00:00:00,000\n"
- "\n\n"
- "0\n"
- "00:00:00,000
--> 00:00:00,000\n"
- "\n\n"
- "1\n"
- "00:00:00,100
--> 00:00:01,500\n"
- "Foo.\n"))
- (expect (point) :to-equal 33)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:00,100 --> 00:00:01,500\n"
+ "Foo.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle arg) :to-equal 33)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:00,000
--> 00:00:00,000\n"
+ "\n\n"
+ "0\n"
+ "00:00:00,000
--> 00:00:00,000\n"
+ "\n\n"
+ "1\n"
+ "00:00:00,100
--> 00:00:01,500\n"
+ "Foo.\n"))
+ (expect (point) :to-equal 33)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
)
)
@@ -1760,55 +1782,55 @@ Baz.
(it "a single subtile."
(cl-loop for arg in (list nil 1) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal 33)
- (expect (buffer-string) :to-equal (concat "0\n"
- "00:00:00,000
--> 00:00:01,000\n"
- "\n"))
- (expect (point) :to-equal 33)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (expect (subed-insert-subtitle-adjacent arg) :to-equal 33)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:00,000
--> 00:00:01,000\n"
+ "\n"))
+ (expect (point) :to-equal 33)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtiles."
(cl-loop for arg in (list 2) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal 33)
- (expect (buffer-string) :to-equal (concat "0\n"
- "00:00:00,000
--> 00:00:01,000\n"
- "\n\n"
- "0\n"
- "00:00:01,100
--> 00:00:02,100\n"
- "\n"))
- (expect (point) :to-equal 33)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (expect (subed-insert-subtitle-adjacent arg) :to-equal 33)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:00,000
--> 00:00:01,000\n"
+ "\n\n"
+ "0\n"
+ "00:00:01,100
--> 00:00:02,100\n"
+ "\n"))
+ (expect (point) :to-equal 33)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
(describe "prepending"
(it "a single subtile."
(cl-loop for arg in (list '- -1 (list 4)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal 33)
- (expect (buffer-string) :to-equal (concat "0\n"
- "00:00:00,000
--> 00:00:01,000\n"
- "\n"))
- (expect (point) :to-equal 33)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (expect (subed-insert-subtitle-adjacent arg) :to-equal 33)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:00,000
--> 00:00:01,000\n"
+ "\n"))
+ (expect (point) :to-equal 33)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtiles."
(cl-loop for arg in (list -2 (list -16)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal 33)
- (expect (buffer-string) :to-equal (concat "0\n"
- "00:00:00,000
--> 00:00:01,000\n"
- "\n\n"
- "0\n"
- "00:00:01,100
--> 00:00:02,100\n"
- "\n"))
- (expect (point) :to-equal 33)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (expect (subed-insert-subtitle-adjacent arg) :to-equal 33)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:00,000
--> 00:00:01,000\n"
+ "\n\n"
+ "0\n"
+ "00:00:01,100
--> 00:00:02,100\n"
+ "\n"))
+ (expect (point) :to-equal 33)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
)
(describe "in a non-empty buffer"
@@ -1816,338 +1838,338 @@ Baz.
(it "a single subtitle."
(cl-loop for arg in (list '- -1 (list 4)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "2\n"
- "00:02:00,000 --> 00:02:01,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-text 2)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal 71)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:00:59,000
--> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
- "00:01:58,900
--> 00:01:59,900\n"
- "\n\n"
- "2\n"
- "00:02:00,000
--> 00:02:01,000\n"
- "Bar.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:02:00,000 --> 00:02:01,000\n"
+ "Bar.\n"))
+ (subed-jump-to-subtitle-text 2)
+ (expect (subed-insert-subtitle-adjacent arg) :to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:00:59,000
--> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+ "00:01:58,900
--> 00:01:59,900\n"
+ "\n\n"
+ "2\n"
+ "00:02:00,000
--> 00:02:01,000\n"
+ "Bar.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtitles."
(cl-loop for arg in (list -2 (list 16)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "2\n"
- "00:02:00,000 --> 00:02:01,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-text 2)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal 71)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:00:59,000
--> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
- "00:01:57,800
--> 00:01:58,800\n"
- "\n\n"
- "0\n"
- "00:01:58,900
--> 00:01:59,900\n"
- "\n\n"
- "2\n"
- "00:02:00,000
--> 00:02:01,000\n"
- "Bar.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:02:00,000 --> 00:02:01,000\n"
+ "Bar.\n"))
+ (subed-jump-to-subtitle-text 2)
+ (expect (subed-insert-subtitle-adjacent arg) :to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:00:59,000
--> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+ "00:01:57,800
--> 00:01:58,800\n"
+ "\n\n"
+ "0\n"
+ "00:01:58,900
--> 00:01:59,900\n"
+ "\n\n"
+ "2\n"
+ "00:02:00,000
--> 00:02:01,000\n"
+ "Bar.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
(describe "appending between subtitles"
(it "a single subtitle."
(cl-loop for arg in (list nil 1) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "2\n"
- "00:02:00,000 --> 00:02:01,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal 71)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:00:59,000
--> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
- "00:01:00,100
--> 00:01:01,100\n"
- "\n\n"
- "2\n"
- "00:02:00,000
--> 00:02:01,000\n"
- "Bar.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:02:00,000 --> 00:02:01,000\n"
+ "Bar.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle-adjacent arg) :to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:00:59,000
--> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+ "00:01:00,100
--> 00:01:01,100\n"
+ "\n\n"
+ "2\n"
+ "00:02:00,000
--> 00:02:01,000\n"
+ "Bar.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtitles."
(cl-loop for arg in (list 2) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "2\n"
- "00:02:00,000 --> 00:02:01,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal 71)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:00:59,000
--> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
- "00:01:00,100
--> 00:01:01,100\n"
- "\n\n"
- "0\n"
- "00:01:01,200
--> 00:01:02,200\n"
- "\n\n"
- "2\n"
- "00:02:00,000
--> 00:02:01,000\n"
- "Bar.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:02:00,000 --> 00:02:01,000\n"
+ "Bar.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle-adjacent arg) :to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:00:59,000
--> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+ "00:01:00,100
--> 00:01:01,100\n"
+ "\n\n"
+ "0\n"
+ "00:01:01,200
--> 00:01:02,200\n"
+ "\n\n"
+ "2\n"
+ "00:02:00,000
--> 00:02:01,000\n"
+ "Bar.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
(describe "prepending to the first subtitle"
(it "a single subtitle."
(cl-loop for arg in (list '- -1 (list 4)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:01:00,000 --> 00:01:01,000\n"
- "Foo.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal 33)
- (expect (buffer-string) :to-equal (concat "0\n"
- "00:00:58,900
--> 00:00:59,900\n"
- "\n\n"
- "1\n"
- "00:01:00,000
--> 00:01:01,000\n"
- "Foo.\n"))
- (expect (point) :to-equal 33)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:01:00,000 --> 00:01:01,000\n"
+ "Foo.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle-adjacent arg) :to-equal 33)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:58,900
--> 00:00:59,900\n"
+ "\n\n"
+ "1\n"
+ "00:01:00,000
--> 00:01:01,000\n"
+ "Foo.\n"))
+ (expect (point) :to-equal 33)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtitles."
(cl-loop for arg in (list -2 (list 16)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:01:00,000 --> 00:01:01,000\n"
- "Foo.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal 33)
- (expect (buffer-string) :to-equal (concat "0\n"
- "00:00:57,800
--> 00:00:58,800\n"
- "\n\n"
- "0\n"
- "00:00:58,900
--> 00:00:59,900\n"
- "\n\n"
- "1\n"
- "00:01:00,000
--> 00:01:01,000\n"
- "Foo.\n"))
- (expect (point) :to-equal 33)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:01:00,000 --> 00:01:01,000\n"
+ "Foo.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle-adjacent arg) :to-equal 33)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:57,800
--> 00:00:58,800\n"
+ "\n\n"
+ "0\n"
+ "00:00:58,900
--> 00:00:59,900\n"
+ "\n\n"
+ "1\n"
+ "00:01:00,000
--> 00:01:01,000\n"
+ "Foo.\n"))
+ (expect (point) :to-equal 33)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
(describe "appending to the last subtitle"
(it "a single subtitle."
(cl-loop for arg in (list nil 1) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal 71)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:00:59,000
--> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
- "00:01:00,100
--> 00:01:01,100\n"
- "\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle-adjacent arg) :to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:00:59,000
--> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+ "00:01:00,100
--> 00:01:01,100\n"
+ "\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtitles."
(cl-loop for arg in (list 2) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n"))
- (subed-jump-to-subtitle-text 3)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal 71)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:00:59,000
--> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
- "00:01:00,100
--> 00:01:01,100\n"
- "\n\n"
- "0\n"
- "00:01:01,200
--> 00:01:02,200\n"
- "\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n"))
+ (subed-jump-to-subtitle-text 3)
+ (expect (subed-insert-subtitle-adjacent arg) :to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:00:59,000
--> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+ "00:01:00,100
--> 00:01:01,100\n"
+ "\n\n"
+ "0\n"
+ "00:01:01,200
--> 00:01:02,200\n"
+ "\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
(describe "when there is not enough time for the subtitles"
(describe "to append"
(it "a single subtitle."
(cl-loop for arg in (list nil 1) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "2\n"
- "00:01:00,500 --> 00:01:05,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal
71)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:00:59,000
--> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
- "00:01:00,100
--> 00:01:00,400\n"
- "\n\n"
- "2\n"
- "00:01:00,500
--> 00:01:05,000\n"
- "Bar.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:01:00,500 --> 00:01:05,000\n"
+ "Bar.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle-adjacent arg) :to-equal
71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:00:59,000
--> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+ "00:01:00,100
--> 00:01:00,400\n"
+ "\n\n"
+ "2\n"
+ "00:01:00,500
--> 00:01:05,000\n"
+ "Bar.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtitles."
(cl-loop for arg in (list 2) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "2\n"
- "00:01:00,500 --> 00:01:05,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal
71)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:00:59,000
--> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
- "00:01:00,100
--> 00:01:00,200\n"
- "\n\n"
- "0\n"
- "00:01:00,300
--> 00:01:00,400\n"
- "\n\n"
- "2\n"
- "00:01:00,500
--> 00:01:05,000\n"
- "Bar.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:01:00,500 --> 00:01:05,000\n"
+ "Bar.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle-adjacent arg) :to-equal
71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:00:59,000
--> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+ "00:01:00,100
--> 00:01:00,200\n"
+ "\n\n"
+ "0\n"
+ "00:01:00,300
--> 00:01:00,400\n"
+ "\n\n"
+ "2\n"
+ "00:01:00,500
--> 00:01:05,000\n"
+ "Bar.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
(describe "to prepend"
(describe "between subtitles"
(it "a single subtitle."
(cl-loop for arg in (list '- -1 (list 4)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "2\n"
- "00:01:00,700 --> 00:01:05,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-text 2)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal
71)
- (expect (buffer-string) :to-equal (concat "1\n"
-
"00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
-
"00:01:00,100 --> 00:01:00,600\n"
- "\n\n"
- "2\n"
-
"00:01:00,700 --> 00:01:05,000\n"
- "Bar.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:01:00,700 --> 00:01:05,000\n"
+ "Bar.\n"))
+ (subed-jump-to-subtitle-text 2)
+ (expect (subed-insert-subtitle-adjacent arg)
:to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+
"00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+
"00:01:00,100 --> 00:01:00,600\n"
+ "\n\n"
+ "2\n"
+
"00:01:00,700 --> 00:01:05,000\n"
+ "Bar.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtitles."
(cl-loop for arg in (list -2 (list 16)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "2\n"
- "00:01:00,500 --> 00:01:05,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-text 2)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal
71)
- (expect (buffer-string) :to-equal (concat "1\n"
-
"00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
-
"00:01:00,100 --> 00:01:00,200\n"
- "\n\n"
- "0\n"
-
"00:01:00,300 --> 00:01:00,400\n"
- "\n\n"
- "2\n"
-
"00:01:00,500 --> 00:01:05,000\n"
- "Bar.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:01:00,500 --> 00:01:05,000\n"
+ "Bar.\n"))
+ (subed-jump-to-subtitle-text 2)
+ (expect (subed-insert-subtitle-adjacent arg)
:to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+
"00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+
"00:01:00,100 --> 00:01:00,200\n"
+ "\n\n"
+ "0\n"
+
"00:01:00,300 --> 00:01:00,400\n"
+ "\n\n"
+ "2\n"
+
"00:01:00,500 --> 00:01:05,000\n"
+ "Bar.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
(describe "before the first subtitle"
(it "a single subtitle."
(cl-loop for arg in (list '- -1 (list 4)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal
33)
- (expect (buffer-string) :to-equal (concat "0\n"
-
"00:00:00,100 --> 00:00:00,900\n"
- "\n\n"
- "1\n"
-
"00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n"))
- (expect (point) :to-equal 33)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:01,000 --> 00:00:02,000\n"
+ "Foo.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle-adjacent arg)
:to-equal 33)
+ (expect (buffer-string) :to-equal (concat "0\n"
+
"00:00:00,100 --> 00:00:00,900\n"
+ "\n\n"
+ "1\n"
+
"00:00:01,000 --> 00:00:02,000\n"
+ "Foo.\n"))
+ (expect (point) :to-equal 33)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtitles."
(cl-loop for arg in (list -2 (list 16)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:00,800 --> 00:00:03,000\n"
- "Foo.\n"))
- (subed-jump-to-subtitle-text 2)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal
33)
- (expect (buffer-string) :to-equal (concat "0\n"
-
"00:00:00,100 --> 00:00:00,350\n"
- "\n\n"
- "0\n"
-
"00:00:00,450 --> 00:00:00,700\n"
- "\n\n"
- "1\n"
-
"00:00:00,800 --> 00:00:03,000\n"
- "Foo.\n"))
- (expect (point) :to-equal 33)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:00,800 --> 00:00:03,000\n"
+ "Foo.\n"))
+ (subed-jump-to-subtitle-text 2)
+ (expect (subed-insert-subtitle-adjacent arg)
:to-equal 33)
+ (expect (buffer-string) :to-equal (concat "0\n"
+
"00:00:00,100 --> 00:00:00,350\n"
+ "\n\n"
+ "0\n"
+
"00:00:00,450 --> 00:00:00,700\n"
+ "\n\n"
+ "1\n"
+
"00:00:00,800 --> 00:00:03,000\n"
+ "Foo.\n"))
+ (expect (point) :to-equal 33)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
)
)
@@ -2157,149 +2179,149 @@ Baz.
(it "a single subtitle."
(cl-loop for arg in (list '- -1 (list 4)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "2\n"
- "00:01:00,005 --> 00:01:05,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-text 2)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal
71)
- (expect (buffer-string) :to-equal (concat "1\n"
-
"00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
-
"00:01:00,005 --> 00:01:00,005\n"
- "\n\n"
- "2\n"
-
"00:01:00,005 --> 00:01:05,000\n"
- "Bar.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:01:00,005 --> 00:01:05,000\n"
+ "Bar.\n"))
+ (subed-jump-to-subtitle-text 2)
+ (expect (subed-insert-subtitle-adjacent arg)
:to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+
"00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+
"00:01:00,005 --> 00:01:00,005\n"
+ "\n\n"
+ "2\n"
+
"00:01:00,005 --> 00:01:05,000\n"
+ "Bar.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtitles."
(cl-loop for arg in (list -2 (list 16)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "2\n"
- "00:01:00,025 --> 00:01:05,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-text 2)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal
71)
- (expect (buffer-string) :to-equal (concat "1\n"
-
"00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
-
"00:01:00,025 --> 00:01:00,025\n"
- "\n\n"
- "0\n"
-
"00:01:00,025 --> 00:01:00,025\n"
- "\n\n"
- "2\n"
-
"00:01:00,025 --> 00:01:05,000\n"
- "Bar.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:01:00,025 --> 00:01:05,000\n"
+ "Bar.\n"))
+ (subed-jump-to-subtitle-text 2)
+ (expect (subed-insert-subtitle-adjacent arg)
:to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+
"00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+
"00:01:00,025 --> 00:01:00,025\n"
+ "\n\n"
+ "0\n"
+
"00:01:00,025 --> 00:01:00,025\n"
+ "\n\n"
+ "2\n"
+
"00:01:00,025 --> 00:01:05,000\n"
+ "Bar.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
(describe "when appending"
(it "a single subtitle."
(cl-loop for arg in (list nil 1) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "2\n"
- "00:01:00,099 --> 00:01:05,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal
71)
- (expect (buffer-string) :to-equal (concat "1\n"
-
"00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
-
"00:01:00,000 --> 00:01:00,000\n"
- "\n\n"
- "2\n"
-
"00:01:00,099 --> 00:01:05,000\n"
- "Bar.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:01:00,099 --> 00:01:05,000\n"
+ "Bar.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle-adjacent arg)
:to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+
"00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+
"00:01:00,000 --> 00:01:00,000\n"
+ "\n\n"
+ "2\n"
+
"00:01:00,099 --> 00:01:05,000\n"
+ "Bar.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtitles."
(cl-loop for arg in (list 2) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "2\n"
- "00:01:00,075 --> 00:01:05,000\n"
- "Bar.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal
71)
- (expect (buffer-string) :to-equal (concat "1\n"
-
"00:00:59,000 --> 00:01:00,000\n"
- "Foo.\n\n"
- "0\n"
-
"00:01:00,000 --> 00:01:00,000\n"
- "\n\n"
- "0\n"
-
"00:01:00,000 --> 00:01:00,000\n"
- "\n\n"
- "2\n"
-
"00:01:00,075 --> 00:01:05,000\n"
- "Bar.\n"))
- (expect (point) :to-equal 71)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "2\n"
+ "00:01:00,075 --> 00:01:05,000\n"
+ "Bar.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle-adjacent arg)
:to-equal 71)
+ (expect (buffer-string) :to-equal (concat "1\n"
+
"00:00:59,000 --> 00:01:00,000\n"
+ "Foo.\n\n"
+ "0\n"
+
"00:01:00,000 --> 00:01:00,000\n"
+ "\n\n"
+ "0\n"
+
"00:01:00,000 --> 00:01:00,000\n"
+ "\n\n"
+ "2\n"
+
"00:01:00,075 --> 00:01:05,000\n"
+ "Bar.\n"))
+ (expect (point) :to-equal 71)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
)
(describe "before the first subtitle"
(it "a single subtitle."
(cl-loop for arg in (list '- -1 (list 4)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:00,040 --> 00:00:05,000\n"
- "Foo.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal
33)
- (expect (buffer-string) :to-equal (concat "0\n"
- "00:00:00,040
--> 00:00:00,040\n"
- "\n\n"
- "1\n"
- "00:00:00,040
--> 00:00:05,000\n"
- "Foo.\n"))
- (expect (point) :to-equal 33)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:00,040 --> 00:00:05,000\n"
+ "Foo.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle-adjacent arg) :to-equal
33)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:00,040
--> 00:00:00,040\n"
+ "\n\n"
+ "1\n"
+ "00:00:00,040
--> 00:00:05,000\n"
+ "Foo.\n"))
+ (expect (point) :to-equal 33)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
(it "multiple subtitles."
(cl-loop for arg in (list -2 (list 16)) do
(with-temp-srt-buffer
- (spy-on 'subed-regenerate-ids-soon)
- (insert (concat "1\n"
- "00:00:00,024 --> 00:00:05,000\n"
- "Foo.\n"))
- (subed-jump-to-subtitle-text 1)
- (expect (subed-insert-subtitle-adjacent arg) :to-equal
33)
- (expect (buffer-string) :to-equal (concat "0\n"
- "00:00:00,024
--> 00:00:00,024\n"
- "\n\n"
- "0\n"
- "00:00:00,024
--> 00:00:00,024\n"
- "\n\n"
- "1\n"
- "00:00:00,024
--> 00:00:05,000\n"
- "Foo.\n"))
- (expect (point) :to-equal 33)
- (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
- (spy-calls-reset 'subed-regenerate-ids-soon))))
+ (spy-on 'subed-regenerate-ids-soon)
+ (insert (concat "1\n"
+ "00:00:00,024 --> 00:00:05,000\n"
+ "Foo.\n"))
+ (subed-jump-to-subtitle-text 1)
+ (expect (subed-insert-subtitle-adjacent arg) :to-equal
33)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:00,024
--> 00:00:00,024\n"
+ "\n\n"
+ "0\n"
+ "00:00:00,024
--> 00:00:00,024\n"
+ "\n\n"
+ "1\n"
+ "00:00:00,024
--> 00:00:05,000\n"
+ "Foo.\n"))
+ (expect (point) :to-equal 33)
+ (expect 'subed-regenerate-ids-soon
:to-have-been-called-times 1)
+ (spy-calls-reset 'subed-regenerate-ids-soon))))
)
)
)
@@ -2335,10 +2357,12 @@ Baz.
(describe "Temporarily disabling point-to-player syncing"
(before-each
- (spy-on 'subed-disable-sync-point-to-player))
+ (spy-on 'subed-disable-sync-point-to-player)
+ (spy-on 'timerp :and-return-value t))
(describe "when point-to-player syncing is disabled"
(before-each
- (spy-on 'subed-sync-point-to-player-p :and-return-value nil)
+ (setq subed--point-sync-delay-after-motion-timer nil)
+ (spy-on 'subed-sync-point-to-player-p
:and-return-value nil)
(spy-on 'run-at-time))
(it "does not disable point-to-player syncing."
(subed-disable-sync-point-to-player-temporarily)
@@ -2373,25 +2397,22 @@ Baz.
(expect 'cancel-timer :not :to-have-been-called-with "mock timer")
(subed-disable-sync-point-to-player-temporarily)
(expect 'cancel-timer :to-have-been-called-with "mock timer")
- (expect 'cancel-timer :to-have-been-called-times 1)
- (subed-disable-sync-point-to-player-temporarily)
- (expect 'cancel-timer :to-have-been-called-with "mock timer")
- (expect 'cancel-timer :to-have-been-called-times 2))
+ (expect 'cancel-timer :to-have-been-called-times 1))
)
)
(describe "Splitting subtitles"
(it "handles empty subtitles"
(with-temp-srt-buffer
- (insert "1
+ (insert "1
00:01:23,000 --> 00:02:34,567
")
- (forward-line -1)
- (let ((subed-subtitle-spacing 100))
- (subed-split-subtitle 100))
- (expect (buffer-string) :to-equal
- "1
+ (forward-line -1)
+ (let ((subed-subtitle-spacing 100))
+ (subed-split-subtitle 100))
+ (expect (buffer-string) :to-equal
+ "1
00:01:23,000 --> 00:01:23,100
@@ -2410,11 +2431,11 @@ that has two lines.
(subed-subtitle-spacing 100))
(it "properly splits text when called at the beginning of the
subtitle."
(with-temp-srt-buffer
- (insert text)
- (re-search-backward "This is a subtitle")
- (goto-char (match-beginning 0))
- (save-excursion (subed-split-subtitle 100))
- (expect (buffer-string) :to-equal "1
+ (insert text)
+ (re-search-backward "This is a
subtitle")
+ (goto-char (match-beginning 0))
+ (save-excursion
(subed-split-subtitle 100))
+ (expect (buffer-string)
:to-equal "1
00:01:23,000 --> 00:01:23,100
@@ -2425,29 +2446,29 @@ that has two lines.
")))
(it "properly splits text when called in the middle of the subtitle."
(with-temp-srt-buffer
- (insert text)
- (re-search-backward "This is a")
- (goto-char (match-end 0))
- (subed-split-subtitle 100)
- (expect (subed-subtitle-text 1) :to-equal "This is a")
- (subed-regenerate-ids)
- (expect (subed-subtitle-text 2) :to-equal "subtitle\nthat has two
lines.")))
+ (insert text)
+ (re-search-backward "This is a")
+ (goto-char (match-end 0))
+ (subed-split-subtitle 100)
+ (expect (subed-subtitle-text 1)
:to-equal "This is a")
+ (subed-regenerate-ids)
+ (expect (subed-subtitle-text 2)
:to-equal "subtitle\nthat has two lines.")))
(it "properly splits text when called at the end of a line in the
middle of the subtitle"
(with-temp-srt-buffer
- (insert text)
- (re-search-backward "This is a subtitle")
- (goto-char (match-end 0))
- (subed-split-subtitle 100)
- (expect (subed-subtitle-text 1) :to-equal "This is a subtitle")
- (subed-regenerate-ids)
- (expect (subed-subtitle-text 2) :to-equal "that has two lines.")))
+ (insert text)
+ (re-search-backward "This is a
subtitle")
+ (goto-char (match-end 0))
+ (subed-split-subtitle 100)
+ (expect (subed-subtitle-text 1)
:to-equal "This is a subtitle")
+ (subed-regenerate-ids)
+ (expect (subed-subtitle-text 2)
:to-equal "that has two lines.")))
(it "properly splits text when called at the beginning of a line in
the middle of the subtitle."
(with-temp-srt-buffer
- (insert text)
- (re-search-backward "that has two lines")
- (goto-char (match-beginning 0))
- (subed-split-subtitle 100)
- (expect (buffer-string) :to-equal "1
+ (insert text)
+ (re-search-backward "that has
two lines")
+ (goto-char (match-beginning 0))
+ (subed-split-subtitle 100)
+ (expect (buffer-string)
:to-equal "1
00:01:23,000 --> 00:01:23,100
This is a subtitle
@@ -2455,25 +2476,25 @@ This is a subtitle
00:01:23,200 --> 00:02:34,567
that has two lines.
") (expect (subed-subtitle-text 1) :to-equal "This is a subtitle")
- (subed-regenerate-ids)
- (expect (subed-subtitle-text 2) :to-equal "that has two lines.")))
+ (subed-regenerate-ids)
+ (expect (subed-subtitle-text 2)
:to-equal "that has two lines.")))
(it "properly splits text when called at the end of the subtitle."
(with-temp-srt-buffer
- (insert text)
- (subed-jump-to-subtitle-end 1)
- (subed-split-subtitle 100)
- (expect (subed-subtitle-text 1) :to-equal "This is a subtitle\nthat
has two lines.")
- (subed-regenerate-ids)
- (expect (subed-subtitle-text 2) :to-equal "")))
+ (insert text)
+ (subed-jump-to-subtitle-end 1)
+ (subed-split-subtitle 100)
+ (expect (subed-subtitle-text 1)
:to-equal "This is a subtitle\nthat has two lines.")
+ (subed-regenerate-ids)
+ (expect (subed-subtitle-text 2)
:to-equal "")))
(it "properly splits text when called before whitespace at the end of
the subtitle."
(with-temp-srt-buffer
- (insert text)
- (subed-jump-to-subtitle-end 1)
- (save-excursion (insert " "))
- (subed-split-subtitle 100)
- (expect (subed-subtitle-text 1) :to-equal "This is a subtitle\nthat
has two lines.")
- (subed-regenerate-ids)
- (expect (subed-subtitle-text 2) :to-equal ""))))
+ (insert text)
+ (subed-jump-to-subtitle-end 1)
+ (save-excursion (insert " "))
+ (subed-split-subtitle 100)
+ (expect (subed-subtitle-text 1)
:to-equal "This is a subtitle\nthat has two lines.")
+ (subed-regenerate-ids)
+ (expect (subed-subtitle-text 2)
:to-equal ""))))
(describe "with another subtitle after it"
:var ((text "1
00:01:23,000 --> 00:02:34,567
@@ -2483,15 +2504,16 @@ that has two lines.
2
00:05:00,000 --> 00:06:00,000
This is another.
-")
- (subed-subtitle-spacing 100))
+"))
(it "properly splits text when called at the beginning of the
subtitle."
(with-temp-srt-buffer
- (insert text)
- (re-search-backward "This is a subtitle")
- (goto-char (match-beginning 0))
- (save-excursion (subed-split-subtitle 100))
- (expect (buffer-string) :to-equal "1
+ (insert text)
+ (re-search-backward "This is a
subtitle")
+ (goto-char (match-beginning 0))
+ (let ((subed-subtitle-spacing
100))
+ (save-excursion
(subed-split-subtitle 100))
+ (expect
subed-subtitle-spacing :to-equal 100))
+ (expect (buffer-string)
:to-equal "1
00:01:23,000 --> 00:01:23,100
0
@@ -2505,30 +2527,32 @@ This is another.
")))
(it "properly splits text when called in the middle of the subtitle."
(with-temp-srt-buffer
- (insert text)
- (re-search-backward "This is a subtitle")
- (goto-char (match-end 0))
- (backward-word 1)
- (subed-split-subtitle 100)
- (expect (subed-subtitle-text 1) :to-equal "This is a")
- (subed-regenerate-ids)
- (expect (subed-subtitle-text 2) :to-equal "subtitle\nthat has two
lines.")))
+ (insert text)
+ (re-search-backward "This is a
subtitle")
+ (goto-char (match-end 0))
+ (backward-word 1)
+ (subed-split-subtitle 100)
+ (expect (subed-subtitle-text 1)
:to-equal "This is a")
+ (subed-regenerate-ids)
+ (expect (subed-subtitle-text 2)
:to-equal "subtitle\nthat has two lines.")))
(it "properly splits text when called at the end of a line in the
middle of the subtitle"
(with-temp-srt-buffer
- (insert text)
- (re-search-backward "This is a subtitle")
- (goto-char (match-end 0))
- (subed-split-subtitle 100)
- (expect (subed-subtitle-text 1) :to-equal "This is a subtitle")
- (subed-regenerate-ids)
- (expect (subed-subtitle-text 2) :to-equal "that has two lines.")))
+ (insert text)
+ (re-search-backward "This is a
subtitle")
+ (goto-char (match-end 0))
+ (subed-split-subtitle 100)
+ (expect (subed-subtitle-text 1)
:to-equal "This is a subtitle")
+ (subed-regenerate-ids)
+ (expect (subed-subtitle-text 2)
:to-equal "that has two lines.")))
(it "properly splits text when called at the beginning of a line in
the middle of the subtitle."
(with-temp-srt-buffer
- (insert text)
- (re-search-backward "that has two lines")
- (goto-char (match-beginning 0))
- (subed-split-subtitle 100)
- (expect (buffer-string) :to-equal "1
+ (insert text)
+ (re-search-backward "that has
two lines")
+ (goto-char (match-beginning 0))
+ (let
((subed-enforce-time-boundaries 'adjust)
+
(subed-subtitle-spacing 100))
+ (subed-split-subtitle
100))
+ (expect (buffer-string)
:to-equal "1
00:01:23,000 --> 00:01:23,100
This is a subtitle
@@ -2540,812 +2564,839 @@ that has two lines.
00:05:00,000 --> 00:06:00,000
This is another.
") (expect (subed-subtitle-text 1) :to-equal "This is a subtitle")
- (subed-regenerate-ids)
- (expect (subed-subtitle-text 2) :to-equal "that has two lines.")))
+ (subed-regenerate-ids)
+ (expect (subed-subtitle-text 2)
:to-equal "that has two lines.")))
(it "properly splits text when called at the end of the subtitle."
(with-temp-srt-buffer
- (insert text)
- (subed-jump-to-subtitle-end 1)
- (subed-split-subtitle 100)
- (expect (subed-subtitle-text 1) :to-equal "This is a subtitle\nthat
has two lines.")
- (subed-regenerate-ids)
- (expect (subed-subtitle-text 2) :to-equal "")))
+ (insert text)
+ (subed-jump-to-subtitle-end 1)
+ (subed-split-subtitle 100)
+ (expect (subed-subtitle-text 1)
:to-equal "This is a subtitle\nthat has two lines.")
+ (subed-regenerate-ids)
+ (expect (subed-subtitle-text 2)
:to-equal "")))
(it "properly splits text when called before whitespace at the end of
the subtitle."
(with-temp-srt-buffer
- (insert text)
- (subed-jump-to-subtitle-end 1)
- (save-excursion (insert " "))
- (subed-split-subtitle 100)
- (expect (subed-subtitle-text 1) :to-equal "This is a subtitle\nthat
has two lines.")
- (subed-regenerate-ids)
- (expect (subed-subtitle-text 2) :to-equal "")))
+ (insert text)
+ (subed-jump-to-subtitle-end 1)
+ (save-excursion (insert " "))
+ (subed-split-subtitle 100)
+ (expect (subed-subtitle-text 1)
:to-equal "This is a subtitle\nthat has two lines.")
+ (subed-regenerate-ids)
+ (expect (subed-subtitle-text 2)
:to-equal "")))
(it "accepts a timestamp."
(with-temp-srt-buffer
- (insert text)
- (re-search-backward "subtitle")
- (end-of-line)
- (subed-split-subtitle "00:01:43,100")
- (expect (subed-subtitle-msecs-start) :to-equal 103100)
- (subed-backward-subtitle-time-start)
- (expect (subed-subtitle-msecs-stop) :to-equal (- 103100
subed-subtitle-spacing))))))
+ (insert text)
+ (re-search-backward "subtitle")
+ (end-of-line)
+ (subed-split-subtitle
"00:01:43,100")
+ (expect
(subed-subtitle-msecs-start) :to-equal 103100)
+
(subed-backward-subtitle-time-start)
+ (expect
(subed-subtitle-msecs-stop) :to-equal (- 103100 subed-subtitle-spacing))))))
(describe "when playing the media in MPV"
(it "splits at point in the middle of the subtitle."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (re-search-backward "Foo\\.")
- (end-of-line)
- (save-excursion (insert " Some text here."))
- (setq-local subed-mpv-playback-position 61600)
- (setq-local subed-subtitle-spacing 100)
- (subed-split-subtitle)
- (expect (subed-subtitle-msecs-start) :to-equal 61700)
- (expect (subed-subtitle-msecs-stop) :to-equal 65123)
- (expect (subed-subtitle-text) :to-equal "Some text here.")
- (subed-backward-subtitle-time-start)
- (expect (subed-subtitle-msecs-stop) :to-equal 61600)
- (expect (subed-subtitle-text) :to-equal "Foo.")))
+ (insert mock-srt-data)
+ (re-search-backward "Foo\\.")
+ (end-of-line)
+ (save-excursion (insert " Some text
here."))
+ (setq-local subed-mpv-playback-position
61600)
+ (setq-local subed-subtitle-spacing 100)
+ (subed-split-subtitle)
+ (expect (subed-subtitle-msecs-start)
:to-equal 61700)
+ (expect (subed-subtitle-msecs-stop)
:to-equal 65123)
+ (expect (subed-subtitle-text) :to-equal
"Some text here.")
+ (subed-backward-subtitle-time-start)
+ (expect (subed-subtitle-msecs-stop)
:to-equal 61600)
+ (expect (subed-subtitle-text) :to-equal
"Foo.")))
(it "splits at the end even if there are spaces."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (re-search-backward "Foo\\.")
- (subed-jump-to-subtitle-end)
- (insert " ")
- (setq-local subed-mpv-playback-position 61600)
- (setq-local subed-subtitle-spacing 100)
- (subed-split-subtitle)
- (expect (subed-subtitle-text) :to-equal "")
- (expect (subed-subtitle-msecs-start) :to-equal 61700)
- (expect (subed-subtitle-msecs-stop) :to-equal 65123)
- (subed-backward-subtitle-time-start)
- (expect (subed-subtitle-text) :to-equal "Foo.")
- (expect (subed-subtitle-msecs-stop) :to-equal 61600)))
+ (insert mock-srt-data)
+ (re-search-backward "Foo\\.")
+ (subed-jump-to-subtitle-end)
+ (insert " ")
+ (setq-local subed-mpv-playback-position
61600)
+ (setq-local subed-subtitle-spacing 100)
+ (subed-split-subtitle)
+ (expect (subed-subtitle-text) :to-equal
"")
+ (expect (subed-subtitle-msecs-start)
:to-equal 61700)
+ (expect (subed-subtitle-msecs-stop)
:to-equal 65123)
+ (subed-backward-subtitle-time-start)
+ (expect (subed-subtitle-text) :to-equal
"Foo.")
+ (expect (subed-subtitle-msecs-stop)
:to-equal 61600)))
(it "splits at the beginning."
(with-temp-srt-buffer
- (save-excursion (insert mock-srt-data))
- (subed-jump-to-subtitle-text)
- (setq-local subed-mpv-playback-position 61600)
- (setq-local subed-subtitle-spacing 100)
- (subed-split-subtitle)
- (expect (subed-subtitle-text) :to-equal "Foo.")
- (expect (subed-subtitle-msecs-start) :to-equal 61700)
- (expect (subed-subtitle-msecs-stop) :to-equal 65123)
- (subed-backward-subtitle-time-start)
- (expect (subed-subtitle-text) :to-equal "")
- (expect (subed-subtitle-msecs-stop) :to-equal 61600))))
+ (save-excursion (insert mock-srt-data))
+ (subed-jump-to-subtitle-text)
+ (setq-local subed-mpv-playback-position
61600)
+ (setq-local subed-subtitle-spacing 100)
+ (subed-split-subtitle)
+ (expect (subed-subtitle-text) :to-equal
"Foo.")
+ (expect (subed-subtitle-msecs-start)
:to-equal 61700)
+ (expect (subed-subtitle-msecs-stop)
:to-equal 65123)
+ (subed-backward-subtitle-time-start)
+ (expect (subed-subtitle-text) :to-equal
"")
+ (expect (subed-subtitle-msecs-stop)
:to-equal 61600))))
(describe "when a positive offset is specified"
(it "splits from the starting time."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (re-search-backward "Foo\\.")
- (end-of-line)
- (save-excursion (insert " Some text here."))
- (setq-local subed-subtitle-spacing 100)
- (subed-split-subtitle 300)
- (expect (subed-subtitle-msecs-start) :to-equal 61400)
- (expect (subed-subtitle-msecs-stop) :to-equal 65123)
- (expect (subed-subtitle-text) :to-equal "Some text here.")
- (subed-backward-subtitle-time-start)
- (expect (subed-subtitle-msecs-stop) :to-equal 61300)
- (expect (subed-subtitle-text) :to-equal "Foo.")))
+ (insert mock-srt-data)
+ (re-search-backward "Foo\\.")
+ (end-of-line)
+ (save-excursion (insert " Some text
here."))
+ (setq-local subed-subtitle-spacing 100)
+ (subed-split-subtitle 300)
+ (expect (subed-subtitle-msecs-start)
:to-equal 61400)
+ (expect (subed-subtitle-msecs-stop)
:to-equal 65123)
+ (expect (subed-subtitle-text) :to-equal
"Some text here.")
+ (subed-backward-subtitle-time-start)
+ (expect (subed-subtitle-msecs-stop)
:to-equal 61300)
+ (expect (subed-subtitle-text) :to-equal
"Foo.")))
(it "uses the offset instead of the playing position."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (re-search-backward "Foo\\.")
- (setq-local subed-mpv-playback-position 61600)
- (setq-local subed-subtitle-spacing 100)
- (subed-split-subtitle 300)
- (expect (subed-subtitle-msecs-start) :to-equal 61400)
- (expect (subed-subtitle-msecs-stop) :to-equal 65123))))
+ (insert mock-srt-data)
+ (re-search-backward "Foo\\.")
+ (setq-local subed-mpv-playback-position
61600)
+ (setq-local subed-subtitle-spacing 100)
+ (subed-split-subtitle 300)
+ (expect (subed-subtitle-msecs-start)
:to-equal 61400)
+ (expect (subed-subtitle-msecs-stop)
:to-equal 65123))))
(describe "when a negative offset is specified"
(it "splits from the ending time."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (re-search-backward "Foo\\.")
- (end-of-line)
- (save-excursion (insert " Some text here."))
- (setq-local subed-subtitle-spacing 100)
- (subed-split-subtitle -300)
- (expect (subed-subtitle-msecs-start) :to-equal 64923)
- (expect (subed-subtitle-msecs-stop) :to-equal 65123)
- (expect (subed-subtitle-text) :to-equal "Some text here.")
- (subed-backward-subtitle-time-start)
- (expect (subed-subtitle-msecs-stop) :to-equal 64823)
- (expect (subed-subtitle-text) :to-equal "Foo.")))
+ (insert mock-srt-data)
+ (re-search-backward "Foo\\.")
+ (end-of-line)
+ (save-excursion (insert " Some text
here."))
+ (setq-local subed-subtitle-spacing 100)
+ (subed-split-subtitle -300)
+ (expect (subed-subtitle-msecs-start)
:to-equal 64923)
+ (expect (subed-subtitle-msecs-stop)
:to-equal 65123)
+ (expect (subed-subtitle-text) :to-equal
"Some text here.")
+ (subed-backward-subtitle-time-start)
+ (expect (subed-subtitle-msecs-stop)
:to-equal 64823)
+ (expect (subed-subtitle-text) :to-equal
"Foo.")))
(it "uses the offset instead of the playing position."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (re-search-backward "Foo\\.")
- (setq-local subed-subtitle-spacing 100)
- (setq-local subed-mpv-playback-position 61600)
- (subed-split-subtitle -300)
- (expect (subed-subtitle-msecs-start) :to-equal 64923)
- (expect (subed-subtitle-msecs-stop) :to-equal 65123)
- (subed-backward-subtitle-time-start)
- (expect (subed-subtitle-msecs-stop) :to-equal 64823))))
+ (insert mock-srt-data)
+ (re-search-backward "Foo\\.")
+ (setq-local subed-subtitle-spacing 100)
+ (setq-local subed-mpv-playback-position
61600)
+ (subed-split-subtitle -300)
+ (expect (subed-subtitle-msecs-start)
:to-equal 64923)
+ (expect (subed-subtitle-msecs-stop)
:to-equal 65123)
+ (subed-backward-subtitle-time-start)
+ (expect (subed-subtitle-msecs-stop)
:to-equal 64823))))
(describe "when nothing is specified"
(it "splits proportional to the location."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (re-search-backward "Foo\\.")
- (end-of-line)
- (save-excursion (insert " Bar"))
- (setq-local subed-subtitle-spacing 100)
- (subed-split-subtitle)
- (expect (subed-subtitle-msecs-start) :to-equal 63161)
- (expect (subed-subtitle-msecs-stop) :to-equal 65123)
- (expect (subed-subtitle-text) :to-equal "Bar")
- (subed-backward-subtitle-time-start)
- (expect (subed-subtitle-msecs-stop) :to-equal 63061)
- (expect (subed-subtitle-text) :to-equal "Foo.")))))
+ (insert mock-srt-data)
+ (re-search-backward "Foo\\.")
+ (end-of-line)
+ (save-excursion (insert " Bar"))
+ (setq-local subed-subtitle-spacing 100)
+ (subed-split-subtitle)
+ (expect (subed-subtitle-msecs-start)
:to-equal 63161)
+ (expect (subed-subtitle-msecs-stop)
:to-equal 65123)
+ (expect (subed-subtitle-text) :to-equal
"Bar")
+ (subed-backward-subtitle-time-start)
+ (expect (subed-subtitle-msecs-stop)
:to-equal 63061)
+ (expect (subed-subtitle-text) :to-equal
"Foo.")))))
(describe "Scaling subtitles"
(it "without providing beginning and end."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (spy-on 'subed-scale-subtitles :and-call-through)
- (subed-scale-subtitles-forward 1000)
- (expect (subed-subtitle-msecs-start 1) :to-equal 61000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 65123)
- (expect (subed-subtitle-msecs-start 2) :to-equal 122734)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 130845)
- (expect (subed-subtitle-msecs-start 3) :to-equal 184450)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 196500)
- (subed-scale-subtitles-backward 1000)
- (expect (subed-subtitle-msecs-start 1) :to-equal 61000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 65123)
- (expect (subed-subtitle-msecs-start 2) :to-equal 122234)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 130345)
- (expect (subed-subtitle-msecs-start 3) :to-equal 183450)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 195500)
- (expect (spy-calls-all-args 'subed-scale-subtitles) :to-equal
- '((+1000 nil nil)
- (-1000 nil nil)))))
+ (insert mock-srt-data)
+ (spy-on 'subed-scale-subtitles
:and-call-through)
+ (subed-scale-subtitles-forward 1000)
+ (expect (subed-subtitle-msecs-start 1)
:to-equal 61000)
+ (expect (subed-subtitle-msecs-stop 1) :to-equal
65123)
+ (expect (subed-subtitle-msecs-start 2)
:to-equal 122734)
+ (expect (subed-subtitle-msecs-stop 2) :to-equal
130845)
+ (expect (subed-subtitle-msecs-start 3)
:to-equal 184450)
+ (expect (subed-subtitle-msecs-stop 3) :to-equal
196500)
+ (subed-scale-subtitles-backward 1000)
+ (expect (subed-subtitle-msecs-start 1)
:to-equal 61000)
+ (expect (subed-subtitle-msecs-stop 1) :to-equal
65123)
+ (expect (subed-subtitle-msecs-start 2)
:to-equal 122234)
+ (expect (subed-subtitle-msecs-stop 2) :to-equal
130345)
+ (expect (subed-subtitle-msecs-start 3)
:to-equal 183450)
+ (expect (subed-subtitle-msecs-stop 3) :to-equal
195500)
+ (expect (spy-calls-all-args
'subed-scale-subtitles) :to-equal
+ '((+1000 nil
nil)
+ (-1000
nil nil)))))
(it "without providing end."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-scale-subtitles 1000 (point-min) nil)
- (expect (subed-subtitle-msecs-start 1) :to-equal 61000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 65123)
- (expect (subed-subtitle-msecs-start 2) :to-equal 122734)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 130845)
- (expect (subed-subtitle-msecs-start 3) :to-equal 184450)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 196500)
- (subed-scale-subtitles -1000 (point-min) nil)
- (expect (subed-subtitle-msecs-start 1) :to-equal 61000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 65123)
- (expect (subed-subtitle-msecs-start 2) :to-equal 122234)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 130345)
- (expect (subed-subtitle-msecs-start 3) :to-equal 183450)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 195500)))
+ (insert mock-srt-data)
+ (subed-scale-subtitles 1000 (point-min) nil)
+ (expect (subed-subtitle-msecs-start 1)
:to-equal 61000)
+ (expect (subed-subtitle-msecs-stop 1) :to-equal
65123)
+ (expect (subed-subtitle-msecs-start 2)
:to-equal 122734)
+ (expect (subed-subtitle-msecs-stop 2) :to-equal
130845)
+ (expect (subed-subtitle-msecs-start 3)
:to-equal 184450)
+ (expect (subed-subtitle-msecs-stop 3) :to-equal
196500)
+ (subed-scale-subtitles -1000 (point-min) nil)
+ (expect (subed-subtitle-msecs-start 1)
:to-equal 61000)
+ (expect (subed-subtitle-msecs-stop 1) :to-equal
65123)
+ (expect (subed-subtitle-msecs-start 2)
:to-equal 122234)
+ (expect (subed-subtitle-msecs-stop 2) :to-equal
130345)
+ (expect (subed-subtitle-msecs-start 3)
:to-equal 183450)
+ (expect (subed-subtitle-msecs-stop 3) :to-equal
195500)))
(it "without providing beginning."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-scale-subtitles 1000 nil (point-max))
- (expect (subed-subtitle-msecs-start 1) :to-equal 61000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 65123)
- (expect (subed-subtitle-msecs-start 2) :to-equal 122734)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 130845)
- (expect (subed-subtitle-msecs-start 3) :to-equal 184450)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 196500)
- (subed-scale-subtitles -1000 nil (point-max))
- (expect (subed-subtitle-msecs-start 1) :to-equal 61000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 65123)
- (expect (subed-subtitle-msecs-start 2) :to-equal 122234)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 130345)
- (expect (subed-subtitle-msecs-start 3) :to-equal 183450)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 195500)))
+ (insert mock-srt-data)
+ (subed-scale-subtitles 1000 nil (point-max))
+ (expect (subed-subtitle-msecs-start 1)
:to-equal 61000)
+ (expect (subed-subtitle-msecs-stop 1) :to-equal
65123)
+ (expect (subed-subtitle-msecs-start 2)
:to-equal 122734)
+ (expect (subed-subtitle-msecs-stop 2) :to-equal
130845)
+ (expect (subed-subtitle-msecs-start 3)
:to-equal 184450)
+ (expect (subed-subtitle-msecs-stop 3) :to-equal
196500)
+ (subed-scale-subtitles -1000 nil (point-max))
+ (expect (subed-subtitle-msecs-start 1)
:to-equal 61000)
+ (expect (subed-subtitle-msecs-stop 1) :to-equal
65123)
+ (expect (subed-subtitle-msecs-start 2)
:to-equal 122234)
+ (expect (subed-subtitle-msecs-stop 2) :to-equal
130345)
+ (expect (subed-subtitle-msecs-start 3)
:to-equal 183450)
+ (expect (subed-subtitle-msecs-stop 3) :to-equal
195500)))
(it "with active region on entire buffer."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (let ((beg (point-min))
- (end (point-max)))
- (spy-on 'subed-scale-subtitles :and-call-through)
- (spy-on 'region-beginning :and-return-value beg)
- (spy-on 'region-end :and-return-value end)
- (setq mark-active t)
- (subed-scale-subtitles-forward 1000)
- (expect (subed-subtitle-msecs-start 1) :to-equal 61000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 65123)
- (expect (subed-subtitle-msecs-start 2) :to-equal 122734)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 130845)
- (expect (subed-subtitle-msecs-start 3) :to-equal 184450)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 196500)
- (subed-scale-subtitles-backward 1000)
- (expect (subed-subtitle-msecs-start 1) :to-equal 61000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 65123)
- (expect (subed-subtitle-msecs-start 2) :to-equal 122234)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 130345)
- (expect (subed-subtitle-msecs-start 3) :to-equal 183450)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 195500)
- (expect (spy-calls-all-args 'subed-scale-subtitles) :to-equal
- `((+1000 ,beg ,end)
- (-1000 ,beg ,end))))))
+ (insert mock-srt-data)
+ (let ((beg (point-min))
+ (end (point-max)))
+ (spy-on 'subed-scale-subtitles
:and-call-through)
+ (spy-on 'region-beginning
:and-return-value beg)
+ (spy-on 'region-end :and-return-value
end)
+ (setq mark-active t)
+ (subed-scale-subtitles-forward 1000)
+ (expect (subed-subtitle-msecs-start 1)
:to-equal 61000)
+ (expect (subed-subtitle-msecs-stop 1)
:to-equal 65123)
+ (expect (subed-subtitle-msecs-start 2)
:to-equal 122734)
+ (expect (subed-subtitle-msecs-stop 2)
:to-equal 130845)
+ (expect (subed-subtitle-msecs-start 3)
:to-equal 184450)
+ (expect (subed-subtitle-msecs-stop 3)
:to-equal 196500)
+ (subed-scale-subtitles-backward 1000)
+ (expect (subed-subtitle-msecs-start 1)
:to-equal 61000)
+ (expect (subed-subtitle-msecs-stop 1)
:to-equal 65123)
+ (expect (subed-subtitle-msecs-start 2)
:to-equal 122234)
+ (expect (subed-subtitle-msecs-stop 2)
:to-equal 130345)
+ (expect (subed-subtitle-msecs-start 3)
:to-equal 183450)
+ (expect (subed-subtitle-msecs-stop 3)
:to-equal 195500)
+ (expect (spy-calls-all-args
'subed-scale-subtitles) :to-equal
+
`((+1000 ,beg ,end)
+
(-1000 ,beg ,end))))))
(it "with a zero msec extension/contraction."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-scale-subtitles-forward 0)
- (expect (subed-subtitle-msecs-start 1) :to-equal 61000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 65123)
- (expect (subed-subtitle-msecs-start 2) :to-equal 122234)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 130345)
- (expect (subed-subtitle-msecs-start 3) :to-equal 183450)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 195500)
- (subed-scale-subtitles-backward 0)
- (expect (subed-subtitle-msecs-start 1) :to-equal 61000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 65123)
- (expect (subed-subtitle-msecs-start 2) :to-equal 122234)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 130345)
- (expect (subed-subtitle-msecs-start 3) :to-equal 183450)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 195500)))
+ (insert mock-srt-data)
+ (subed-scale-subtitles-forward 0)
+ (expect (subed-subtitle-msecs-start 1)
:to-equal 61000)
+ (expect (subed-subtitle-msecs-stop 1) :to-equal
65123)
+ (expect (subed-subtitle-msecs-start 2)
:to-equal 122234)
+ (expect (subed-subtitle-msecs-stop 2) :to-equal
130345)
+ (expect (subed-subtitle-msecs-start 3)
:to-equal 183450)
+ (expect (subed-subtitle-msecs-stop 3) :to-equal
195500)
+ (subed-scale-subtitles-backward 0)
+ (expect (subed-subtitle-msecs-start 1)
:to-equal 61000)
+ (expect (subed-subtitle-msecs-stop 1) :to-equal
65123)
+ (expect (subed-subtitle-msecs-start 2)
:to-equal 122234)
+ (expect (subed-subtitle-msecs-stop 2) :to-equal
130345)
+ (expect (subed-subtitle-msecs-start 3)
:to-equal 183450)
+ (expect (subed-subtitle-msecs-stop 3) :to-equal
195500)))
(it "with active region on one subtitle."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (let ((beg 77) ; point at ID of third subtitle
- (end (point-max)))
- (spy-on 'region-beginning :and-return-value beg)
- (spy-on 'region-end :and-return-value end)
- (spy-on 'user-error :and-call-through)
- (setq mark-active t)
- (expect (subed-scale-subtitles-forward 1000) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale with fewer than 3 subtitles")))
- (expect (buffer-string) :to-equal mock-srt-data))))
+ (insert mock-srt-data)
+ (let ((beg 77)
; point at ID of third subtitle
+ (end (point-max)))
+ (spy-on 'region-beginning
:and-return-value beg)
+ (spy-on 'region-end :and-return-value
end)
+ (spy-on 'user-error :and-call-through)
+ (setq mark-active t)
+ (expect (subed-scale-subtitles-forward
1000) :to-throw 'error)
+ (expect (spy-calls-all-args
'user-error) :to-equal
+
'(("Can't scale with fewer than 3 subtitles")))
+ (expect (buffer-string) :to-equal
mock-srt-data))))
(it "with active region on two subtitles."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (let ((beg 39) ; point at ID of second subtitle
- (end (point-max)))
- (spy-on 'region-beginning :and-return-value beg)
- (spy-on 'region-end :and-return-value end)
- (spy-on 'user-error :and-call-through)
- (setq mark-active t)
- (expect (subed-scale-subtitles-forward 1000) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale with only 2 subtitles")))
- (expect (buffer-string) :to-equal mock-srt-data))))
+ (insert mock-srt-data)
+ (let ((beg 39)
; point at ID of second subtitle
+ (end (point-max)))
+ (spy-on 'region-beginning
:and-return-value beg)
+ (spy-on 'region-end :and-return-value
end)
+ (spy-on 'user-error :and-call-through)
+ (setq mark-active t)
+ (expect (subed-scale-subtitles-forward
1000) :to-throw 'error)
+ (expect (spy-calls-all-args
'user-error) :to-equal
+
'(("Can't scale with only 2 subtitles")))
+ (expect (buffer-string) :to-equal
mock-srt-data))))
(it "with active region contraction."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:43,233 --> 00:00:45,861\n"
- "a\n"
- "\n"
- "2\n"
- "00:00:51,675 --> 00:00:54,542\n"
- "b\n"
- "\n"
- "3\n"
- "00:01:00,717 --> 00:01:02,378\n"
- "c\n"
- "\n"
- "4\n"
- "00:01:02,452 --> 00:01:05,216\n"
- "d\n"))
- (let ((beg (point-min))
- (end 103)) ; point at TEXT of third subtitle
- (spy-on 'region-beginning :and-return-value beg)
- (spy-on 'region-end :and-return-value end)
- (setq mark-active t)
- (subed-scale-subtitles-backward 1000)
- (expect (subed-subtitle-msecs-start 1) :to-equal 43233)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 45861)
- (expect (subed-subtitle-msecs-start 2) :to-equal 51192)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 54059)
- (expect (subed-subtitle-msecs-start 3) :to-equal 59717)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 61378)
- (expect (subed-subtitle-msecs-start 4) :to-equal 62452)
- (expect (subed-subtitle-msecs-stop 4) :to-equal 65216))))
+ (insert (concat "1\n"
+
"00:00:43,233 --> 00:00:45,861\n"
+
"a\n"
+
"\n"
+
"2\n"
+
"00:00:51,675 --> 00:00:54,542\n"
+
"b\n"
+
"\n"
+
"3\n"
+
"00:01:00,717 --> 00:01:02,378\n"
+
"c\n"
+
"\n"
+
"4\n"
+
"00:01:02,452 --> 00:01:05,216\n"
+
"d\n"))
+ (let ((beg (point-min))
+ (end 103))
; point at TEXT of third subtitle
+ (spy-on 'region-beginning
:and-return-value beg)
+ (spy-on 'region-end :and-return-value
end)
+ (setq mark-active t)
+ (subed-scale-subtitles-backward 1000)
+ (expect (subed-subtitle-msecs-start 1)
:to-equal 43233)
+ (expect (subed-subtitle-msecs-stop 1)
:to-equal 45861)
+ (expect (subed-subtitle-msecs-start 2)
:to-equal 51192)
+ (expect (subed-subtitle-msecs-stop 2)
:to-equal 54059)
+ (expect (subed-subtitle-msecs-start 3)
:to-equal 59717)
+ (expect (subed-subtitle-msecs-stop 3)
:to-equal 61378)
+ (expect (subed-subtitle-msecs-start 4)
:to-equal 62452)
+ (expect (subed-subtitle-msecs-stop 4)
:to-equal 65216))))
(it "with active region extension."
(with-temp-srt-buffer
- (insert (concat "1\n"
- "00:00:43,233 --> 00:00:45,861\n"
- "a\n"
- "\n"
- "2\n"
- "00:00:51,192 --> 00:00:54,059\n"
- "b\n"
- "\n"
- "3\n"
- "00:00:59,717 --> 00:01:01,378\n"
- "c\n"
- "\n"
- "4\n"
- "00:01:02,452 --> 00:01:05,216\n"
- "d\n"))
- (let ((beg (point-min))
- (end 103)) ; point at TEXT of third subtitle
- (spy-on 'region-beginning :and-return-value beg)
- (spy-on 'region-end :and-return-value end)
- (setq mark-active t)
- (setq-local subed-subtitle-spacing 0)
- (subed-scale-subtitles-forward 1000)
- (expect (subed-subtitle-msecs-start 1) :to-equal 43233)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 45861)
- (expect (subed-subtitle-msecs-start 2) :to-equal 51675)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 54542)
- (expect (subed-subtitle-msecs-start 3) :to-equal 60717)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 62378)
- (expect (subed-subtitle-msecs-start 4) :to-equal 62452)
- (expect (subed-subtitle-msecs-stop 4) :to-equal 65216))))
- (it "when active region extension overlaps next subtitle."
- (with-temp-srt-buffer
- (let ((initial-contents
- (concat "1\n"
- "00:00:43,233 --> 00:00:45,861\n"
- "a\n"
- "\n"
- "2\n"
- "00:00:51,675 --> 00:00:54,542\n"
- "b\n"
- "\n"
- "3\n"
- "00:01:00,717 --> 00:01:02,378\n"
- "c\n"
- "\n"
- "4\n"
- "00:01:02,452 --> 00:01:05,216\n"
- "d\n"))
- (beg 1)
- (end 103)) ; point at TEXT of third subtitle
- (spy-on 'region-beginning :and-return-value beg)
- (spy-on 'region-end :and-return-value end)
- (spy-on 'user-error :and-call-through)
- (insert initial-contents)
- (setq mark-active t)
- (expect (subed-scale-subtitles-forward 1000) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale when extension would overlap subsequent
subtitles")))
- (expect (buffer-string) :to-equal initial-contents))))
- (it "when end subtitle start time moved to same time as begin subtitle
start time."
- (with-temp-srt-buffer
- (insert mock-srt-data)
- (let ((beg (point-min))
- (end (point-max))
- (delta (- (subed-subtitle-msecs-start 3)
- (subed-subtitle-msecs-start 1))))
- (spy-on 'region-beginning :and-return-value beg)
- (spy-on 'region-end :and-return-value end)
- (spy-on 'user-error :and-call-through)
- (setq mark-active t)
- (expect (subed-scale-subtitles-backward delta) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale when contraction would eliminate region")))
- (expect (buffer-string) :to-equal mock-srt-data))))
+ (insert (concat "1\n"
+
"00:00:43,233 --> 00:00:45,861\n"
+
"a\n"
+
"\n"
+
"2\n"
+
"00:00:51,192 --> 00:00:54,059\n"
+
"b\n"
+
"\n"
+
"3\n"
+
"00:00:59,717 --> 00:01:01,378\n"
+
"c\n"
+
"\n"
+
"4\n"
+
"00:01:02,452 --> 00:01:05,216\n"
+
"d\n"))
+ (let ((beg (point-min))
+ (end 103))
; point at TEXT of third subtitle
+ (spy-on 'region-beginning
:and-return-value beg)
+ (spy-on 'region-end :and-return-value
end)
+ (setq mark-active t)
+ (setq-local subed-subtitle-spacing 0)
+ (subed-scale-subtitles-forward 1000)
+ (expect (subed-subtitle-msecs-start 1)
:to-equal 43233)
+ (expect (subed-subtitle-msecs-stop 1)
:to-equal 45861)
+ (expect (subed-subtitle-msecs-start 2)
:to-equal 51675)
+ (expect (subed-subtitle-msecs-stop 2)
:to-equal 54542)
+ (expect (subed-subtitle-msecs-start 3)
:to-equal 60717)
+ (expect (subed-subtitle-msecs-stop 3)
:to-equal 62378)
+ (expect (subed-subtitle-msecs-start 4)
:to-equal 62452)
+ (expect (subed-subtitle-msecs-stop 4)
:to-equal 65216))))
+ (describe "when active region extension overlaps next subtitle"
+ (it "reports an error"
+ (with-temp-srt-buffer
+ (let ((initial-contents
+ (concat "1\n"
+
"00:00:43,233 --> 00:00:45,861\n"
+
"a\n"
+
"\n"
+
"2\n"
+
"00:00:51,675 --> 00:00:54,542\n"
+
"b\n"
+
"\n"
+
"3\n"
+
"00:01:00,717 --> 00:01:02,378\n"
+
"c\n"
+
"\n"
+
"4\n"
+
"00:01:02,452 --> 00:01:05,216\n"
+
"d\n"))
+ (beg 1)
+ (end 103))
; point at TEXT of third subtitle
+ (spy-on 'region-beginning
:and-return-value beg)
+ (spy-on 'region-end
:and-return-value end)
+ (spy-on 'user-error
:and-call-through)
+ (insert initial-contents)
+ (setq mark-active t)
+ (let
((subed-enforce-time-boundaries 'error))
+ (expect
(subed-scale-subtitles-forward 1000) :to-throw 'error))
+ (expect (spy-calls-all-args
'user-error) :to-equal
+
'(("Can't scale when extension would overlap subsequent subtitles")))
+ (expect (buffer-string)
:to-equal initial-contents))))
+ (it "when end subtitle start time moved to same time as
begin subtitle start time."
+ (with-temp-srt-buffer
+ (insert mock-srt-data)
+ (let ((beg (point-min))
+ (end
(point-max))
+ (delta (-
(subed-subtitle-msecs-start 3)
+
(subed-subtitle-msecs-start 1))))
+ (spy-on 'region-beginning
:and-return-value beg)
+ (spy-on 'region-end
:and-return-value end)
+ (spy-on 'user-error
:and-call-through)
+ (setq mark-active t)
+ (expect
(subed-scale-subtitles-backward delta) :to-throw 'error)
+ (expect (spy-calls-all-args
'user-error) :to-equal
+
'(("Can't scale when contraction would eliminate region")))
+ (expect (buffer-string)
:to-equal mock-srt-data)))))
(it "when end subtitle start time moved to just before begin subtitle
start time."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (let ((beg (point-min))
- (end (point-max))
- (delta (- (subed-subtitle-msecs-start 3)
- (subed-subtitle-msecs-start 1))))
- (spy-on 'region-beginning :and-return-value beg)
- (spy-on 'region-end :and-return-value end)
- (spy-on 'user-error :and-call-through)
- (setq mark-active t)
- (expect (subed-scale-subtitles-backward (+ delta 1)) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale when contraction would eliminate region")))
- (expect (buffer-string) :to-equal mock-srt-data))))
+ (insert mock-srt-data)
+ (let ((beg (point-min))
+ (end (point-max))
+ (delta (-
(subed-subtitle-msecs-start 3)
+
(subed-subtitle-msecs-start 1))))
+ (spy-on 'region-beginning
:and-return-value beg)
+ (spy-on 'region-end :and-return-value
end)
+ (spy-on 'user-error :and-call-through)
+ (setq mark-active t)
+ (expect (subed-scale-subtitles-backward
(+ delta 1)) :to-throw 'error)
+ (expect (spy-calls-all-args
'user-error) :to-equal
+
'(("Can't scale when contraction would eliminate region")))
+ (expect (buffer-string) :to-equal
mock-srt-data))))
(it "when end subtitle start time moved to just after begin subtitle start
time."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (let ((beg (point-min))
- (end (point-max))
- (delta (- (subed-subtitle-msecs-start 3)
- (subed-subtitle-msecs-start 1))))
- (spy-on 'region-beginning :and-return-value beg)
- (spy-on 'region-end :and-return-value end)
- (setq mark-active t)
- (subed-scale-subtitles-backward (- delta 1))
- (expect (subed-subtitle-msecs-start 1) :to-equal 61000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 65123)
- (expect (subed-subtitle-msecs-start 2) :to-equal 61001)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 69112)
- (expect (subed-subtitle-msecs-start 3) :to-equal 61001)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 73051))))
+ (insert mock-srt-data)
+ (let ((beg (point-min))
+ (end (point-max))
+ (delta (-
(subed-subtitle-msecs-start 3)
+
(subed-subtitle-msecs-start 1))))
+ (spy-on 'region-beginning
:and-return-value beg)
+ (spy-on 'region-end :and-return-value
end)
+ (setq mark-active t)
+ (subed-scale-subtitles-backward (-
delta 1))
+ (expect (subed-subtitle-msecs-start 1)
:to-equal 61000)
+ (expect (subed-subtitle-msecs-stop 1)
:to-equal 65123)
+ (expect (subed-subtitle-msecs-start 2)
:to-equal 61001)
+ (expect (subed-subtitle-msecs-stop 2)
:to-equal 69112)
+ (expect (subed-subtitle-msecs-start 3)
:to-equal 61001)
+ (expect (subed-subtitle-msecs-stop 3)
:to-equal 73051))))
(it "when begin start time same as end start time."
(with-temp-srt-buffer
- (let ((initial-contents
- (concat "1\n"
- "00:01:01,000 --> 00:01:05,123\n"
- "Foo.\n"
- "\n"
- "2\n"
- "00:01:01,000 --> 00:01:05,123\n"
- "Bar.\n"
- "\n"
- "3\n"
- "00:01:01,000 --> 00:01:05,123\n"
- "Baz.\n")))
- (spy-on 'user-error :and-call-through)
- (insert initial-contents)
- (expect (subed-scale-subtitles-forward 1000) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale subtitle range with 0 time interval")))
- (expect (buffer-string) :to-equal initial-contents)
- (spy-calls-reset 'user-error)
- (expect (subed-scale-subtitles-backward 1000) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale subtitle range with 0 time interval")))
- (expect (buffer-string) :to-equal initial-contents))))
+ (let ((initial-contents
+ (concat "1\n"
+ "00:01:01,000 --> 00:01:05,123\n"
+ "Foo.\n"
+ "\n"
+ "2\n"
+ "00:01:01,000 --> 00:01:05,123\n"
+ "Bar.\n"
+ "\n"
+ "3\n"
+ "00:01:01,000 --> 00:01:05,123\n"
+ "Baz.\n")))
+ (spy-on 'user-error :and-call-through)
+ (insert initial-contents)
+ (expect (subed-scale-subtitles-forward
1000) :to-throw 'error)
+ (expect (spy-calls-all-args
'user-error) :to-equal
+
'(("Can't scale subtitle range with 0 time interval")))
+ (expect (buffer-string) :to-equal
initial-contents)
+ (spy-calls-reset 'user-error)
+ (expect (subed-scale-subtitles-backward
1000) :to-throw 'error)
+ (expect (spy-calls-all-args
'user-error) :to-equal
+
'(("Can't scale subtitle range with 0 time interval")))
+ (expect (buffer-string) :to-equal
initial-contents))))
(it "when buffer is empty."
(spy-on 'user-error :and-call-through)
(with-temp-srt-buffer
- (expect (subed-scale-subtitles-forward 1000) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale with fewer than 3 subtitles")))
- (expect (buffer-string) :to-equal "")
- (spy-calls-reset 'user-error)
- (expect (subed-scale-subtitles-backward 1000) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale with fewer than 3 subtitles")))
- (expect (buffer-string) :to-equal "")))
+ (expect (subed-scale-subtitles-forward 1000)
:to-throw 'error)
+ (expect (spy-calls-all-args 'user-error)
:to-equal
+ '(("Can't scale
with fewer than 3 subtitles")))
+ (expect (buffer-string) :to-equal "")
+ (spy-calls-reset 'user-error)
+ (expect (subed-scale-subtitles-backward 1000)
:to-throw 'error)
+ (expect (spy-calls-all-args 'user-error)
:to-equal
+ '(("Can't scale
with fewer than 3 subtitles")))
+ (expect (buffer-string) :to-equal "")))
(it "when buffer contains one subtitle."
(spy-on 'user-error :and-call-through)
(with-temp-srt-buffer
- (let ((initial-contents
- (concat "1\n"
- "00:01:01,000 --> 00:01:05,123\n"
- "Foo.\n")))
- (insert initial-contents)
- (expect (subed-scale-subtitles-forward 1000) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale with fewer than 3 subtitles")))
- (expect (buffer-string) :to-equal initial-contents)
- (spy-calls-reset 'user-error)
- (expect (subed-scale-subtitles-backward 1000) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale with fewer than 3 subtitles")))
- (expect (buffer-string) :to-equal initial-contents))))
+ (let ((initial-contents
+ (concat "1\n"
+ "00:01:01,000 --> 00:01:05,123\n"
+ "Foo.\n")))
+ (insert initial-contents)
+ (expect (subed-scale-subtitles-forward
1000) :to-throw 'error)
+ (expect (spy-calls-all-args
'user-error) :to-equal
+
'(("Can't scale with fewer than 3 subtitles")))
+ (expect (buffer-string) :to-equal
initial-contents)
+ (spy-calls-reset 'user-error)
+ (expect (subed-scale-subtitles-backward
1000) :to-throw 'error)
+ (expect (spy-calls-all-args
'user-error) :to-equal
+
'(("Can't scale with fewer than 3 subtitles")))
+ (expect (buffer-string) :to-equal
initial-contents))))
(it "when buffer contains two subtitles."
(spy-on 'user-error :and-call-through)
(with-temp-srt-buffer
- (let ((initial-contents
- (concat "1\n"
- "00:01:01,000 --> 00:01:05,123\n"
- "Foo.\n"
- "\n"
- "2\n"
- "00:02:02,234 --> 00:02:10,345\n"
- "Bar.\n")))
- (insert initial-contents)
- (expect (subed-scale-subtitles-forward 1000) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale with only 2 subtitles")))
- (expect (buffer-string) :to-equal initial-contents)
- (spy-calls-reset 'user-error)
- (expect (subed-scale-subtitles-backward 1000) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale with only 2 subtitles")))
- (expect (buffer-string) :to-equal initial-contents))))
- (it "with subtitle in region containing start time after end start time."
+ (let ((initial-contents
+ (concat "1\n"
+ "00:01:01,000 --> 00:01:05,123\n"
+ "Foo.\n"
+ "\n"
+ "2\n"
+ "00:02:02,234 --> 00:02:10,345\n"
+ "Bar.\n")))
+ (insert initial-contents)
+ (expect (subed-scale-subtitles-forward
1000) :to-throw 'error)
+ (expect (spy-calls-all-args
'user-error) :to-equal
+
'(("Can't scale with only 2 subtitles")))
+ (expect (buffer-string) :to-equal
initial-contents)
+ (spy-calls-reset 'user-error)
+ (expect (subed-scale-subtitles-backward
1000) :to-throw 'error)
+ (expect (spy-calls-all-args
'user-error) :to-equal
+
'(("Can't scale with only 2 subtitles")))
+ (expect (buffer-string) :to-equal
initial-contents))))
+ (it "reports an error if the subtitle in region has a start time after end
start time."
(spy-on 'user-error :and-call-through)
(with-temp-srt-buffer
- (let ((initial-contents
- (concat "1\n"
- "00:01:01,000 --> 00:01:05,123\n"
- "Foo.\n"
- "\n"
- "2\n"
- "00:03:03,45 --> 00:03:15,5\n"
- "Baz.\n"
- "\n"
- "3\n"
- "00:02:02,234 --> 00:02:10,345\n"
- "Bar.\n")))
- (insert initial-contents)
- (expect (subed-scale-subtitles-forward 1000) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale when nonchronological subtitles exist")))
- (expect (buffer-string) :to-equal initial-contents)
- (spy-calls-reset 'user-error)
- (expect (subed-scale-subtitles-backward 1000) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale when nonchronological subtitles exist")))
- (expect (buffer-string) :to-equal initial-contents))))
+ (let ((initial-contents
+ (concat "1\n"
+ "00:01:01,000 --> 00:01:05,123\n"
+ "Foo.\n"
+ "\n"
+ "2\n"
+ "00:03:03,45 --> 00:03:15,5\n"
+ "Baz.\n"
+ "\n"
+ "3\n"
+ "00:02:02,234 --> 00:02:10,345\n"
+ "Bar.\n"))
+
(subed-enforce-time-boundaries 'error)
+ (subed-subtitle-spacing
100))
+ (insert initial-contents)
+ (expect subed-enforce-time-boundaries
:to-equal 'error)
+ (expect (subed-scale-subtitles-forward
1000) :to-throw 'error)
+ (expect (spy-calls-all-args
'user-error) :to-equal
+
'(("Can't scale when nonchronological subtitles exist")))
+ (expect (buffer-string) :to-equal
initial-contents)
+ (spy-calls-reset 'user-error)
+ (expect (subed-scale-subtitles-backward
1000) :to-throw 'error)
+ (expect (spy-calls-all-args
'user-error) :to-equal
+
'(("Can't scale when nonchronological subtitles exist")))
+ (expect (buffer-string) :to-equal
initial-contents))))
(it "with first subtitle containing no timestamp."
(spy-on 'user-error :and-call-through)
(with-temp-srt-buffer
- (let ((initial-contents
- (concat "1\n"
- "a\n"
- "\n"
- "2\n"
- "00:00:51,675 --> 00:00:54,542\n"
- "b\n"
- "\n"
- "3\n"
- "00:01:00,717 --> 00:01:02,378\n"
- "c\n")))
- (insert initial-contents)
- (expect (subed-scale-subtitles-forward 1000) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale when first subtitle timestamp missing")))
- (expect (buffer-string) :to-equal initial-contents)
- (spy-calls-reset 'user-error)
- (expect (subed-scale-subtitles-backward 1000) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale when first subtitle timestamp missing")))
- (expect (buffer-string) :to-equal initial-contents))))
+ (let ((initial-contents
+ (concat "1\n"
+ "a\n"
+ "\n"
+ "2\n"
+ "00:00:51,675 --> 00:00:54,542\n"
+ "b\n"
+ "\n"
+ "3\n"
+ "00:01:00,717 --> 00:01:02,378\n"
+ "c\n")))
+ (insert initial-contents)
+ (expect (subed-scale-subtitles-forward
1000) :to-throw 'error)
+ (expect (spy-calls-all-args
'user-error) :to-equal
+
'(("Can't scale when first subtitle timestamp missing")))
+ (expect (buffer-string) :to-equal
initial-contents)
+ (spy-calls-reset 'user-error)
+ (expect (subed-scale-subtitles-backward
1000) :to-throw 'error)
+ (expect (spy-calls-all-args
'user-error) :to-equal
+
'(("Can't scale when first subtitle timestamp missing")))
+ (expect (buffer-string) :to-equal
initial-contents))))
(it "with last subtitle containing no timestamp."
(spy-on 'user-error :and-call-through)
(with-temp-srt-buffer
- (let ((initial-contents
- (concat "1\n"
- "00:00:43,233 --> 00:00:45,861\n"
- "a\n"
- "\n"
- "2\n"
- "00:00:51,675 --> 00:00:54,542\n"
- "b\n"
- "\n"
- "3\n"
- "c\n")))
- (insert initial-contents)
- (expect (subed-scale-subtitles-forward 1000) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale when last subtitle timestamp missing")))
- (expect (buffer-string) :to-equal initial-contents)
- (spy-calls-reset 'user-error)
- (expect (subed-scale-subtitles-backward 1000) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale when last subtitle timestamp missing")))
- (expect (buffer-string) :to-equal initial-contents))))
+ (let ((initial-contents
+ (concat "1\n"
+ "00:00:43,233 --> 00:00:45,861\n"
+ "a\n"
+ "\n"
+ "2\n"
+ "00:00:51,675 --> 00:00:54,542\n"
+ "b\n"
+ "\n"
+ "3\n"
+ "c\n")))
+ (insert initial-contents)
+ (expect (subed-scale-subtitles-forward
1000) :to-throw 'error)
+ (expect (spy-calls-all-args
'user-error) :to-equal
+
'(("Can't scale when last subtitle timestamp missing")))
+ (expect (buffer-string) :to-equal
initial-contents)
+ (spy-calls-reset 'user-error)
+ (expect (subed-scale-subtitles-backward
1000) :to-throw 'error)
+ (expect (spy-calls-all-args
'user-error) :to-equal
+
'(("Can't scale when last subtitle timestamp missing")))
+ (expect (buffer-string) :to-equal
initial-contents))))
(it "with subtitle in region containing no timestamp."
(spy-on 'user-error :and-call-through)
(with-temp-srt-buffer
- (let ((initial-contents
- (concat "1\n"
- "00:00:43,233 --> 00:00:45,861\n"
- "a\n"
- "\n"
- "2\n"
- "b\n"
- "\n"
- "3\n"
- "00:01:00,717 --> 00:01:02,378\n"
- "c\n")))
- (insert initial-contents)
- (expect (subed-scale-subtitles-forward 1000) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale when subtitle timestamp missing")))
- (expect (buffer-string) :to-equal initial-contents)
- (spy-calls-reset 'user-error)
- (expect (subed-scale-subtitles-backward 1000) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale when subtitle timestamp missing")))
- (expect (buffer-string) :to-equal initial-contents))))
+ (let ((initial-contents
+ (concat "1\n"
+ "00:00:43,233 --> 00:00:45,861\n"
+ "a\n"
+ "\n"
+ "2\n"
+ "b\n"
+ "\n"
+ "3\n"
+ "00:01:00,717 --> 00:01:02,378\n"
+ "c\n")))
+ (insert initial-contents)
+ (expect (subed-scale-subtitles-forward
1000) :to-throw 'error)
+ (expect (spy-calls-all-args
'user-error) :to-equal
+
'(("Can't scale when subtitle timestamp missing")))
+ (expect (buffer-string) :to-equal
initial-contents)
+ (spy-calls-reset 'user-error)
+ (expect (subed-scale-subtitles-backward
1000) :to-throw 'error)
+ (expect (spy-calls-all-args
'user-error) :to-equal
+
'(("Can't scale when subtitle timestamp missing")))
+ (expect (buffer-string) :to-equal
initial-contents))))
(it "with out-of-order range."
(spy-on 'user-error :and-call-through)
(with-temp-srt-buffer
- (expect (subed-scale-subtitles 1000 5 4) :to-throw 'error)
- (expect (spy-calls-all-args 'user-error) :to-equal
- '(("Can't scale with improper range"))))))
+ (expect (subed-scale-subtitles 1000 5 4)
:to-throw 'error)
+ (expect (spy-calls-all-args 'user-error)
:to-equal
+ '(("Can't scale
with improper range"))))))
(describe "Trimming subtitles"
(describe "when spacing is 0"
(it "detects overlaps"
(with-temp-srt-buffer
- (insert "1\n00:00:01,000 --> 00:00:05,000\nA\n\n"
- "2\n00:00:04,000 --> 00:00:06,000\nA\n\n")
- (let ((subed-subtitle-spacing 0))
- (expect (subed--identify-overlaps)
- :to-equal '(1)))))
+ (insert "1\n00:00:01,000 -->
00:00:05,000\nA\n\n"
+
"2\n00:00:04,000 --> 00:00:06,000\nA\n\n")
+ (let ((subed-subtitle-spacing 0))
+ (expect
(subed--identify-overlaps)
+
:to-equal '(1)))))
(it "ignores non-overlapping subtitles"
(with-temp-srt-buffer
- (insert "1\n00:00:01,000 --> 00:00:02,000\nA\n\n"
- "2\n00:00:03,000 --> 00:00:04,000\nA\n\n"
- "3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
- (let ((subed-subtitle-spacing 0))
- (expect (subed--identify-overlaps)
- :to-equal nil)))))
+ (insert "1\n00:00:01,000 -->
00:00:02,000\nA\n\n"
+
"2\n00:00:03,000 --> 00:00:04,000\nA\n\n"
+
"3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
+ (let ((subed-subtitle-spacing 0))
+ (expect
(subed--identify-overlaps)
+
:to-equal nil)))))
(describe "when spacing is 1"
(it "detects overlaps"
(with-temp-srt-buffer
- (insert "1\n00:00:01,000 --> 00:00:04,000\nA\n\n"
- "2\n00:00:04,000 --> 00:00:06,000\nA\n\n")
- (let ((subed-subtitle-spacing 1))
- (expect (subed--identify-overlaps)
- :to-equal '(1)))))
+ (insert "1\n00:00:01,000 -->
00:00:04,000\nA\n\n"
+
"2\n00:00:04,000 --> 00:00:06,000\nA\n\n")
+ (let ((subed-subtitle-spacing 1))
+ (expect
(subed--identify-overlaps)
+
:to-equal '(1)))))
(it "ignores non-overlapping subtitles"
(with-temp-srt-buffer
- (insert "1\n00:00:01,000 --> 00:00:02,999\nA\n\n"
- "2\n00:00:03,000 --> 00:00:04,000\nA\n\n")
- (let ((subed-subtitle-spacing 1))
- (expect (subed--identify-overlaps)
- :to-equal nil)))))
+ (insert "1\n00:00:01,000 -->
00:00:02,999\nA\n\n"
+
"2\n00:00:03,000 --> 00:00:04,000\nA\n\n")
+ (let ((subed-subtitle-spacing 1))
+ (expect
(subed--identify-overlaps)
+
:to-equal nil)))))
(describe "when spacing is greater"
(it "detects overlaps because of spacing"
(with-temp-srt-buffer
- (insert "1\n00:00:01,000 --> 00:00:02,999\nA\n\n"
- "2\n00:00:03,000 --> 00:00:05,000\nA\n\n"
- "3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
- (let ((subed-subtitle-spacing 100))
- (expect (subed--identify-overlaps)
- :to-equal '(1 2)))))
+ (insert "1\n00:00:01,000 -->
00:00:02,999\nA\n\n"
+
"2\n00:00:03,000 --> 00:00:05,000\nA\n\n"
+
"3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
+ (let ((subed-subtitle-spacing 100))
+ (expect
(subed--identify-overlaps)
+
:to-equal '(1 2)))))
(it "ignores non-overlapping subtitles."
(with-temp-srt-buffer
- (insert "1\n00:00:01,000 --> 00:00:02,000\nA\n\n"
- "2\n00:00:03,000 --> 00:00:03,500\nA\n\n"
- "3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
- (let ((subed-subtitle-spacing 100))
- (expect (subed--identify-overlaps)
- :to-equal nil)))))
+ (insert "1\n00:00:01,000 -->
00:00:02,000\nA\n\n"
+
"2\n00:00:03,000 --> 00:00:03,500\nA\n\n"
+
"3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
+ (let ((subed-subtitle-spacing 100))
+ (expect
(subed--identify-overlaps)
+
:to-equal nil)))))
(describe "overlap end time"
(it "sets it to the next timestamp minus spacing."
(with-temp-srt-buffer
- (insert "1\n00:00:01,000 --> 00:00:02,000\nA\n\n"
- "2\n00:00:03,000 --> 00:00:04,500\nA\n\n"
- "3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
- (let ((subed-subtitle-spacing 100))
- (subed-jump-to-subtitle-id 2)
- (subed-trim-overlap-stop)
- (expect (subed-subtitle-msecs-stop) :to-equal 3900))))
+ (insert "1\n00:00:01,000 -->
00:00:02,000\nA\n\n"
+
"2\n00:00:03,000 --> 00:00:04,500\nA\n\n"
+
"3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
+ (let ((subed-subtitle-spacing 100))
+ (subed-jump-to-subtitle-id 2)
+ (subed-trim-overlap-stop)
+ (expect
(subed-subtitle-msecs-stop) :to-equal 3900))))
(it "sets it to the next timestamp minus the argument."
(with-temp-srt-buffer
- (insert "1\n00:00:01,000 --> 00:00:02,000\nA\n\n"
- "2\n00:00:03,000 --> 00:00:04,500\nA\n\n"
- "3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
- (let ((subed-subtitle-spacing 100))
- (subed-jump-to-subtitle-id 2)
- (subed-trim-overlap-stop 500)
- (expect (subed-subtitle-msecs-stop) :to-equal 3500))))
+ (insert "1\n00:00:01,000 -->
00:00:02,000\nA\n\n"
+
"2\n00:00:03,000 --> 00:00:04,500\nA\n\n"
+
"3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
+ (let ((subed-subtitle-spacing 100))
+ (subed-jump-to-subtitle-id 2)
+ (subed-trim-overlap-stop 500)
+ (expect
(subed-subtitle-msecs-stop) :to-equal 3500))))
(it "ignores non-overlapping subtitles."
(with-temp-srt-buffer
- (insert "1\n00:00:01,000 --> 00:00:02,000\nA\n\n"
- "2\n00:00:03,000 --> 00:00:04,500\nA\n\n"
- "3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
- (let ((subed-subtitle-spacing 100))
- (subed-jump-to-subtitle-id 1)
- (subed-trim-overlap-stop)
- (expect (subed-subtitle-msecs-stop) :to-equal 2000))))
+ (insert "1\n00:00:01,000 -->
00:00:02,000\nA\n\n"
+
"2\n00:00:03,000 --> 00:00:04,500\nA\n\n"
+
"3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
+ (let ((subed-subtitle-spacing 100))
+ (subed-jump-to-subtitle-id 1)
+ (subed-trim-overlap-stop)
+ (expect
(subed-subtitle-msecs-stop) :to-equal 2000))))
(it "handles the last subtitle gracefully."
(with-temp-srt-buffer
- (insert "1\n00:00:01,000 --> 00:00:02,000\nA\n\n"
- "2\n00:00:03,000 --> 00:00:04,500\nA\n\n"
- "3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
- (let ((subed-subtitle-spacing 100))
- (subed-jump-to-subtitle-id 3)
- (subed-trim-overlap-stop 500)
- (expect (subed-subtitle-msecs-stop) :to-equal 6000))))
+ (insert "1\n00:00:01,000 -->
00:00:02,000\nA\n\n"
+
"2\n00:00:03,000 --> 00:00:04,500\nA\n\n"
+
"3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
+ (let ((subed-subtitle-spacing 100))
+ (subed-jump-to-subtitle-id 3)
+ (subed-trim-overlap-stop 500)
+ (expect
(subed-subtitle-msecs-stop) :to-equal 6000))))
(it "handles empty buffers gracefully."
(with-temp-srt-buffer
- (subed-trim-overlap-stop 500)
- (expect (subed-subtitle-msecs-stop) :to-equal nil)))
- (it "adjusts the stop time if the new stop would be before the start
time."
- (with-temp-srt-buffer
- (insert "1\n00:00:01,500 --> 00:00:02,000\nA\n\n"
- "2\n00:00:01,000 --> 00:00:02,000\nA\n\n"
- "3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
- (let ((subed-subtitle-spacing 100))
- (subed-jump-to-subtitle-id 1)
- (expect (subed-trim-overlap-stop) :to-equal -500)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 1500)
- (expect (subed-subtitle-msecs-start 1) :to-equal 1500)))))
+ (subed-trim-overlap-stop 500)
+ (expect (subed-subtitle-msecs-stop)
:to-equal nil)))
+ (describe "when adjusting to time boundaries"
+ (it "adjusts the start time if the new stop
would be before the start time."
+ (with-temp-srt-buffer
+ (insert "1\n00:00:01,500 -->
00:00:02,000\nA\n\n"
+
"2\n00:00:01,000 --> 00:00:02,000\nA\n\n"
+
"3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
+ (let ((subed-subtitle-spacing
100)
+
(subed-enforce-time-boundaries 'adjust))
+
(subed-jump-to-subtitle-id 1)
+ (expect
(subed-trim-overlap-stop) :to-equal 900)
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal 900)
+ (expect
(subed-subtitle-msecs-start 1) :to-equal 900)))))
+ (describe "when clipping to time boundaries"
+ (it "adjusts the start time if the new stop
would be before the start time."
+ (with-temp-srt-buffer
+ (insert "1\n00:00:01,500 -->
00:00:02,000\nA\n\n"
+
"2\n00:00:01,000 --> 00:00:02,000\nA\n\n"
+
"3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
+ (let ((subed-subtitle-spacing
100)
+
(subed-enforce-time-boundaries 'clip))
+
(subed-jump-to-subtitle-id 1)
+ (expect
(subed-trim-overlap-stop) :to-equal 1500)
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal 1500)
+ (expect
(subed-subtitle-msecs-start 1) :to-equal 1500))))))
(describe "overlap start time"
(it "sets next start to the current timestamp plus spacing."
(with-temp-srt-buffer
- (insert "1\n00:00:01,000 --> 00:00:02,000\nA\n\n"
- "2\n00:00:03,000 --> 00:00:04,500\nA\n\n"
- "3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
- (let ((subed-subtitle-spacing 100))
- (subed-jump-to-subtitle-id 2)
- (subed-trim-overlap-next-start)
- (subed-forward-subtitle-time-start)
- (expect (subed-subtitle-msecs-start) :to-equal 4600))))
+ (insert "1\n00:00:01,000 -->
00:00:02,000\nA\n\n"
+
"2\n00:00:03,000 --> 00:00:04,500\nA\n\n"
+
"3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
+ (let ((subed-subtitle-spacing 100))
+ (subed-jump-to-subtitle-id 2)
+ (subed-trim-overlap-next-start)
+
(subed-forward-subtitle-time-start)
+ (expect
(subed-subtitle-msecs-start) :to-equal 4600))))
(it "sets next start to the current timestamp plus the argument."
(with-temp-srt-buffer
- (insert "1\n00:00:01,000 --> 00:00:02,000\nA\n\n"
- "2\n00:00:03,000 --> 00:00:04,500\nA\n\n"
- "3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
- (let ((subed-subtitle-spacing 100))
- (subed-jump-to-subtitle-id 2)
- (subed-trim-overlap-next-start 500)
- (subed-forward-subtitle-time-start)
- (expect (subed-subtitle-msecs-start) :to-equal 5000))))
+ (insert "1\n00:00:01,000 -->
00:00:02,000\nA\n\n"
+
"2\n00:00:03,000 --> 00:00:04,500\nA\n\n"
+
"3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
+ (let ((subed-subtitle-spacing 100))
+ (subed-jump-to-subtitle-id 2)
+ (subed-trim-overlap-next-start
500)
+
(subed-forward-subtitle-time-start)
+ (expect
(subed-subtitle-msecs-start) :to-equal 5000))))
(it "handles the last subtitle gracefully."
(with-temp-srt-buffer
- (insert "1\n00:00:01,000 --> 00:00:02,000\nA\n\n"
- "2\n00:00:03,000 --> 00:00:04,500\nA\n\n"
- "3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
- (let ((subed-subtitle-spacing 100))
- (subed-jump-to-subtitle-id 3)
- (subed-trim-overlap-next-start 500)
- (expect (subed-subtitle-msecs-start) :to-equal 4000))))
+ (insert "1\n00:00:01,000 -->
00:00:02,000\nA\n\n"
+
"2\n00:00:03,000 --> 00:00:04,500\nA\n\n"
+
"3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
+ (let ((subed-subtitle-spacing 100))
+ (subed-jump-to-subtitle-id 3)
+ (subed-trim-overlap-next-start
500)
+ (expect
(subed-subtitle-msecs-start) :to-equal 4000))))
(it "adjusts the timestamp if the new start is past the stop time."
(with-temp-srt-buffer
- (insert "1\n00:00:01,000 --> 00:00:02,000\nA\n\n"
- "2\n00:00:01,500 --> 00:00:02,000\nA\n\n"
- "3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
- (let ((subed-subtitle-spacing 100))
- (subed-jump-to-subtitle-id 1)
- (expect (subed-trim-overlap-next-start 500) :to-equal 500)
- (expect (subed-subtitle-msecs-start 2) :to-equal 2000))))
+ (insert "1\n00:00:01,000 -->
00:00:02,000\nA\n\n"
+
"2\n00:00:01,500 --> 00:00:02,000\nA\n\n"
+
"3\n00:00:04,000 --> 00:00:06,000\nA\n\n")
+ (let ((subed-subtitle-spacing 100)
+
(subed-enforce-time-boundaries 'adjust))
+ (subed-jump-to-subtitle-id 1)
+ (expect
(subed-trim-overlap-next-start 500) :to-equal 2500)
+ (expect
(subed-subtitle-msecs-start 2) :to-equal 2500)
+ (expect
(subed-subtitle-msecs-stop 2) :to-equal 2500))))
(it "handles empty buffers gracefully."
(with-temp-srt-buffer
- (subed-trim-overlap-next-start 500)
- (expect (subed-subtitle-msecs-stop) :to-equal nil))))
+ (subed-trim-overlap-next-start 500)
+ (expect (subed-subtitle-msecs-stop)
:to-equal nil))))
(describe "trimming overlaps"
(it "adjusts stop times by default."
(with-temp-srt-buffer
- (insert "1\n00:00:01,000 --> 00:00:02,000\nA\n\n"
- "2\n00:00:03,000 --> 00:00:04,500\nA\n\n"
- "3\n00:00:04,000 --> 00:00:06,000\nA\n\n"
- "4\n00:00:05,000 --> 00:00:06,000\nA\n\n")
- (let ((subed-subtitle-spacing 100))
- (subed-trim-overlaps))
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2000)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 3900)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 4900)))
+ (insert "1\n00:00:01,000 -->
00:00:02,000\nA\n\n"
+
"2\n00:00:03,000 --> 00:00:04,500\nA\n\n"
+
"3\n00:00:04,000 --> 00:00:06,000\nA\n\n"
+
"4\n00:00:05,000 --> 00:00:06,000\nA\n\n")
+ (let ((subed-subtitle-spacing 100))
+ (subed-trim-overlaps))
+ (expect (subed-subtitle-msecs-stop 1)
:to-equal 2000)
+ (expect (subed-subtitle-msecs-stop 2)
:to-equal 3900)
+ (expect (subed-subtitle-msecs-stop 3)
:to-equal 4900)))
(it "adjusts start times if specified."
(with-temp-srt-buffer
- (insert "1\n00:00:01,000 --> 00:00:02,000\nA\n\n"
- "2\n00:00:03,000 --> 00:00:04,500\nA\n\n"
- "3\n00:00:04,000 --> 00:00:06,000\nA\n\n"
- "4\n00:00:05,000 --> 00:00:06,000\nA\n\n")
- (let ((subed-subtitle-spacing 100)
- (subed-trim-overlap-use-start t))
- (subed-trim-overlaps)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2000)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 4500)
- (expect (subed-subtitle-msecs-start 3) :to-equal 4600)
- (expect (subed-subtitle-msecs-start 4) :to-equal 6000))))
+ (insert "1\n00:00:01,000 -->
00:00:02,000\nA\n\n"
+
"2\n00:00:03,000 --> 00:00:04,500\nA\n\n"
+
"3\n00:00:04,000 --> 00:00:06,000\nA\n\n"
+
"4\n00:00:05,000 --> 00:00:06,000\nA\n\n")
+ (let ((subed-subtitle-spacing 100)
+
(subed-enforce-time-boundaries 'adjust)
+
(subed-trim-overlap-use-start t))
+ (subed-trim-overlaps)
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal 2000)
+ (expect
(subed-subtitle-msecs-stop 2) :to-equal 4500)
+ (expect
(subed-subtitle-msecs-start 3) :to-equal 4600)
+ (expect
(subed-subtitle-msecs-start 4) :to-equal 6100))))
(it "can specify the number of milliseconds."
(with-temp-srt-buffer
- (insert "1\n00:00:01,000 --> 00:00:02,000\nA\n\n"
- "2\n00:00:03,000 --> 00:00:04,500\nA\n\n"
- "3\n00:00:04,000 --> 00:00:06,000\nA\n\n"
- "4\n00:00:05,000 --> 00:00:06,000\nA\n\n")
- (let ((subed-subtitle-spacing 100))
- (subed-trim-overlaps 200))
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2000)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 3800)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 4800)))
+ (insert "1\n00:00:01,000 -->
00:00:02,000\nA\n\n"
+
"2\n00:00:03,000 --> 00:00:04,500\nA\n\n"
+
"3\n00:00:04,000 --> 00:00:06,000\nA\n\n"
+
"4\n00:00:05,000 --> 00:00:06,000\nA\n\n")
+ (let ((subed-subtitle-spacing 100))
+ (subed-trim-overlaps 200))
+ (expect (subed-subtitle-msecs-stop 1)
:to-equal 2000)
+ (expect (subed-subtitle-msecs-stop 2)
:to-equal 3800)
+ (expect (subed-subtitle-msecs-stop 3)
:to-equal 4800)))
(it "handles empty buffers gracefully."
(with-temp-srt-buffer
- (expect (subed-trim-overlaps) :not :to-throw)))
+ (expect (subed-trim-overlaps) :not
:to-throw)))
(it "handles single subtitles gracefully."
(with-temp-srt-buffer
- (insert "1\n00:00:01,000 --> 00:00:02,000\nA\n\n")
- (let ((subed-subtitle-spacing 100))
- (expect (subed-trim-overlaps) :not :to-throw))
- (expect (subed-subtitle-msecs-start 1) :to-equal 1000)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2000))))
+ (insert "1\n00:00:01,000 -->
00:00:02,000\nA\n\n")
+ (let ((subed-subtitle-spacing 100))
+ (expect (subed-trim-overlaps)
:not :to-throw))
+ (expect (subed-subtitle-msecs-start 1)
:to-equal 1000)
+ (expect (subed-subtitle-msecs-stop 1)
:to-equal 2000))))
(describe "when configured to trim on save,"
(it "trims overlaps after sorting."
(with-temp-srt-buffer
- (let ((subed-trim-overlap-on-save t)
- (subed-subtitle-spacing 200))
- (insert "1\n00:00:01,000 --> 00:00:02,000\nA\n\n"
- "2\n00:00:04,000 --> 00:00:06,000\nA\n\n"
- "3\n00:00:03,000 --> 00:00:04,500\nA\n\n"
- "4\n00:00:05,000 --> 00:00:06,000\nA\n\n")
- (subed-prepare-to-save)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2000)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 3800)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 4800)))))
- (describe "when configured to check on save,"
- (it "reports overlaps."
- (with-temp-srt-buffer
- (insert "1\n00:00:01,000 --> 00:00:02,000\nA\n\n"
- "2\n00:00:04,000 --> 00:00:06,000\nA\n\n"
- "3\n00:00:03,000 --> 00:00:04,500\nA\n\n"
- "4\n00:00:05,000 --> 00:00:06,000\nA\n\n")
- (let ((subed-trim-overlap-check-on-save t)
- (subed-trim-overlap-on-save nil)
- (subed-subtitle-spacing 200))
- (spy-on 'subed-trim-overlap-check :and-call-through)
- (spy-on 'subed-trim-overlaps :and-call-through)
- (spy-on 'yes-or-no-p :and-return-value t)
- (subed-prepare-to-save)
- (expect 'subed-trim-overlap-check :to-have-been-called)
- (expect 'yes-or-no-p :to-have-been-called)
- (expect (subed-subtitle-msecs-stop 1) :to-equal 2000)
- (expect (subed-subtitle-msecs-stop 2) :to-equal 3800)
- (expect (subed-subtitle-msecs-stop 3) :to-equal 4800)))))
+ (let ((subed-trim-overlap-on-save t)
+
(subed-subtitle-spacing 200))
+ (insert "1\n00:00:01,000 -->
00:00:02,000\nA\n\n"
+
"2\n00:00:04,000 --> 00:00:06,000\nA\n\n"
+
"3\n00:00:03,000 --> 00:00:04,500\nA\n\n"
+
"4\n00:00:05,000 --> 00:00:06,000\nA\n\n")
+ (subed-prepare-to-save)
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal 2000)
+ (expect
(subed-subtitle-msecs-stop 2) :to-equal 3800)
+ (expect
(subed-subtitle-msecs-stop 3) :to-equal 4800)))))
+ (describe "when configured to check on save,"
+ (it "reports overlaps."
+ (with-temp-srt-buffer
+ ;; Changed the test data to avoid
sorting confusion
+ (insert "1\n00:00:01,000 -->
00:00:02,000\nA1\n\n"
+
"2\n00:00:03,000 --> 00:00:04,500\nA2\n\n"
+
"3\n00:00:04,000 --> 00:00:06,000\nA3\n\n"
+
"4\n00:00:05,000 --> 00:00:06,000\nA4\n\n")
+ (let ((subed-trim-overlap-check-on-save
t)
+
(subed-trim-overlap-on-save nil)
+
(subed-subtitle-spacing 200)
+
(subed-enforce-time-boundaries 'adjust)
+
(buffer-modified-p nil))
+ (spy-on
'subed-trim-overlap-check :and-call-through)
+ (spy-on 'subed-trim-overlaps
:and-call-through)
+ (spy-on 'yes-or-no-p
:and-return-value t)
+ (subed-prepare-to-save)
+ (expect
'subed-trim-overlap-check :to-have-been-called)
+ (expect 'yes-or-no-p
:to-have-been-called)
+ ;; Note changed behaviour:
adjust the start time if needed,
+ ;; and don't change stop if
there's enough space
+ (expect
(subed-subtitle-msecs-stop 1) :to-equal 2000)
+ (expect
(subed-subtitle-msecs-start 2) :to-equal 3000)
+ (expect
(subed-subtitle-msecs-stop 2) :to-equal 3800)
+ (expect
(subed-subtitle-msecs-stop 3) :to-equal 4800)))))
(describe "when configured to check on load,"
(it "reports overlaps."
(with-temp-buffer
- (setq buffer-file-name "test.srt")
(insert "1\n00:00:01,000 --> 00:00:02,000\nA\n\n"
"2\n00:00:04,000 --> 00:00:06,000\nA\n\n"
"3\n00:00:03,000 --> 00:00:04,500\nA\n\n"
@@ -3359,23 +3410,23 @@ This is another.
(describe "Getting a list of subtitles"
(it "returns nil in an empty buffer."
(with-temp-srt-buffer
- (expect (subed-subtitle-list) :to-equal nil)))
+ (expect (subed-subtitle-list) :to-equal nil)))
(it "returns the list."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (expect (subed-subtitle-list) :to-equal
- '((1 61000 65123 "Foo." nil)
- (2 122234 130345 "Bar." nil)
- (3 183450 195500 "Baz." nil)))))
+ (insert mock-srt-data)
+ (expect (subed-subtitle-list) :to-equal
+ '((1 61000
65123 "Foo." nil)
+ (2
122234 130345 "Bar." nil)
+ (3
183450 195500 "Baz." nil)))))
(it "returns a subset when bounds are specified."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-jump-to-subtitle-id 3)
- (backward-char 1)
- (expect (subed-subtitle-list (point-min) (point))
- :to-equal
- '((1 61000 65123 "Foo." nil)
- (2 122234 130345 "Bar." nil))))))
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-id 3)
+ (backward-char 1)
+ (expect (subed-subtitle-list (point-min)
(point))
+ :to-equal
+ '((1 61000
65123 "Foo." nil)
+ (2
122234 130345 "Bar." nil))))))
(describe "Getting the text of a list"
(it "returns a blank string when given nothing."
(expect (subed-subtitle-list-text nil) :to-equal ""))
@@ -3402,14 +3453,14 @@ This is another.
(describe "Copying region text"
(it "works on the whole buffer"
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-copy-region-text)
- (expect (current-kill 0) :to-equal "Foo.\nBar.\nBaz.\n")))
+ (insert mock-srt-data)
+ (subed-copy-region-text)
+ (expect (current-kill 0) :to-equal
"Foo.\nBar.\nBaz.\n")))
(it "works on a specified region."
(with-temp-srt-buffer
- (insert mock-srt-data)
- (subed-copy-region-text (re-search-backward "Foo.") (re-search-forward
"Bar."))
- (expect (current-kill 0) :to-equal "Foo.\nBar.\n"))))
+ (insert mock-srt-data)
+ (subed-copy-region-text (re-search-backward
"Foo.") (re-search-forward "Bar."))
+ (expect (current-kill 0) :to-equal
"Foo.\nBar.\n"))))
(describe "Sorting"
(it "detects sorted lists."
(expect (subed--sorted-p '((1 1000 2000 "Test")
@@ -3630,3 +3681,138 @@ Bar.
Baz.
")))))
))
+
+(describe "Iterating over subtitles"
+ (it "without providing beginning and end."
+ (with-temp-srt-buffer
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-time-stop 1)
+ (subed-for-each-subtitle nil nil nil
+ (expect (looking-at "^[0-9]$") :to-be t)
+ (forward-line 2)
+ (kill-line)
+ (insert "Hello."))
+ (expect (subed-subtitle-text 1) :to-equal "Hello.")
+ (expect (subed-subtitle-text 2) :to-equal "Bar.")
+ (expect (subed-subtitle-text 3) :to-equal "Baz.")
+ (expect (point) :to-equal 20)
+ (subed-jump-to-subtitle-time-stop 2)
+ (subed-for-each-subtitle nil nil nil
+ (expect (looking-at "^[0-9]$") :to-be t)
+ (forward-line 2)
+ (kill-line)
+ (insert "HEllo."))
+ (expect (subed-subtitle-text 1) :to-equal "Hello.")
+ (expect (subed-subtitle-text 2) :to-equal "HEllo.")
+ (expect (subed-subtitle-text 3) :to-equal "Baz.")
+ (expect (point) :to-equal 60)
+ (subed-jump-to-subtitle-time-stop 3)
+ (subed-for-each-subtitle nil nil nil
+ (expect (looking-at "^[0-9]$") :to-be t)
+ (forward-line 2)
+ (kill-line)
+ (insert "HELlo."))
+ (expect (subed-subtitle-text 1) :to-equal "Hello.")
+ (expect (subed-subtitle-text 2) :to-equal "HEllo.")
+ (expect (subed-subtitle-text 3) :to-equal "HELlo.")
+ (expect (point) :to-equal 99)))
+ (describe "providing only the beginning"
+ (it "forwards."
+ (with-temp-srt-buffer
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-time-start 1)
+ (expect (point) :to-equal 3)
+ (let ((new-texts (list "A" "B" "C")))
+ (subed-for-each-subtitle 71 nil nil
+ (expect (looking-at "^[0-9]$") :to-be t)
+ (forward-line 2)
+ (kill-line)
+ (insert (pop new-texts))))
+ (expect (subed-subtitle-text 1) :to-equal "Foo.")
+ (expect (subed-subtitle-text 2) :to-equal "A")
+ (expect (subed-subtitle-text 3) :to-equal "B")
+ (expect (point) :to-equal 3)))
+ (it "backwards."
+ (with-temp-srt-buffer
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-time-stop 3)
+ (expect (point) :to-equal 95)
+ (let ((new-texts (list "A" "B" "C")))
+ (subed-for-each-subtitle 75 nil :reverse
+ (expect (looking-at "^[0-9]$") :to-be t)
+ (forward-line 2)
+ (kill-line)
+ (insert (pop new-texts))))
+ (expect (subed-subtitle-text 1) :to-equal "Foo.")
+ (expect (subed-subtitle-text 2) :to-equal "B")
+ (expect (subed-subtitle-text 3) :to-equal "A")
+ (expect (point) :to-equal 92)))
+ )
+ (describe "providing beginning and end,"
+ (describe "excluding subtitles above"
+ (it "forwards."
+ (with-temp-srt-buffer
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-time-stop 1)
+ (expect (point) :to-equal 20)
+ (let ((new-texts (list "A" "B" "C")))
+ (subed-for-each-subtitle 71 79 nil
+ (expect (looking-at "^[0-9]$") :to-be t)
+ (forward-line 2)
+ (kill-line)
+ (insert (pop new-texts))))
+ (expect (subed-subtitle-text 1) :to-equal "Foo.")
+ (expect (subed-subtitle-text 2) :to-equal "A")
+ (expect (subed-subtitle-text 3) :to-equal "B")
+ (expect (point) :to-equal 20)))
+ (it "backwards."
+ (with-temp-srt-buffer
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-time-start 3)
+ (expect (point) :to-equal 79)
+ (let ((new-texts (list "A" "B" "C")))
+ (subed-for-each-subtitle 39 77 :reverse
+ (expect (looking-at "^[0-9]$") :to-be t)
+ (forward-line 2)
+ (kill-line)
+ (insert (pop new-texts))))
+ (expect (subed-subtitle-text 1) :to-equal "Foo.")
+ (expect (subed-subtitle-text 2) :to-equal "B")
+ (expect (subed-subtitle-text 3) :to-equal "A")
+ (expect (point) :to-equal 76)))
+ )
+ (describe "excluding subtitles below"
+ (it "forwards."
+ (with-temp-srt-buffer
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-text 3)
+ (expect (point) :to-equal 106)
+ (let ((new-texts (list "A" "B" "C")))
+ (subed-for-each-subtitle 5 76 nil
+ (expect (looking-at "^[0-9]$") :to-be t)
+ (forward-line 2)
+ (kill-line)
+ (insert (pop new-texts))))
+ (expect (subed-subtitle-text 1) :to-equal "A")
+ (expect (subed-subtitle-text 2) :to-equal "B")
+ (expect (subed-subtitle-text 3) :to-equal "Baz.")
+ (expect (point) :to-equal 100)))
+ (it "backwards."
+ (with-temp-srt-buffer
+ (insert mock-srt-data)
+ (subed-jump-to-subtitle-time-stop 2)
+ (expect (point) :to-equal 58)
+ (let ((new-texts (list "A" "B" "C")))
+ (subed-for-each-subtitle 20 76 :reverse
+ (expect (looking-at "^[0-9]$") :to-be t)
+ (forward-line 2)
+ (kill-line)
+ (insert (pop new-texts))))
+ (expect (subed-subtitle-text 1) :to-equal "B")
+ (expect (subed-subtitle-text 2) :to-equal "A")
+ (expect (subed-subtitle-text 3) :to-equal "Baz.")
+ (expect (point) :to-equal 55)))
+ )
+ )
+ )
+
- [nongnu] elpa/subed updated (28a75a6f68 -> 43fcde0c3a), ELPA Syncer, 2023/03/07
- [nongnu] elpa/subed 82e137352d 3/5: Handle subed-enforce-time-boundaries values of error, adjust, and clip,
ELPA Syncer <=
- [nongnu] elpa/subed 43fcde0c3a 5/5: v1.1.0 Mention subed-enforce-time-boundaries values, ELPA Syncer, 2023/03/07
- [nongnu] elpa/subed 00f315b318 2/5: Default to new 'adjust value for subed-enforce-time-boundaries, ELPA Syncer, 2023/03/07
- [nongnu] elpa/subed f8ce6d4e6c 1/5: Enforce time boundaries when setting start or stop time, ELPA Syncer, 2023/03/07
- [nongnu] elpa/subed 0810c97a76 4/5: Tweak tests some more for wording, coverage reporting, ELPA Syncer, 2023/03/07