[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[nongnu] elpa/subed 1654a08 207/389: Properly indent tests
|
From: |
ELPA Syncer |
|
Subject: |
[nongnu] elpa/subed 1654a08 207/389: Properly indent tests |
|
Date: |
Fri, 3 Dec 2021 11:00:27 -0500 (EST) |
branch: elpa/subed
commit 1654a0855286cf5f8cdd87aee4a79bbf8a8c2db2
Author: Random User <rndusr@posteo.de>
Commit: Random User <rndusr@posteo.de>
Properly indent tests
---
tests/test-subed-mpv.el | 260 ++---
tests/test-subed-srt.el | 2632 +++++++++++++++++++++++------------------------
tests/test-subed.el | 1302 +++++++++++------------
3 files changed, 2097 insertions(+), 2097 deletions(-)
diff --git a/tests/test-subed-mpv.el b/tests/test-subed-mpv.el
index 59168b4..d92fd4b 100644
--- a/tests/test-subed-mpv.el
+++ b/tests/test-subed-mpv.el
@@ -3,140 +3,140 @@
(require 'subed)
(describe "Starting mpv"
- (it "passes arguments to make-process."
- (spy-on 'make-process)
- (spy-on 'subed-mpv--socket :and-return-value
"/mock/path/to/socket")
- (subed-mpv--server-start "foo" "--bar")
- (expect 'make-process :to-have-been-called-with
- :command (list subed-mpv-executable
- "--input-ipc-server=/mock/path/to/socket"
- "--idle" "foo" "--bar")
- :name "subed-mpv-server" :buffer nil :noquery t))
- (it "sets subed-mpv--server-proc on success."
- (spy-on 'make-process :and-return-value "mock process")
- (subed-mpv--server-start)
- (expect subed-mpv--server-proc :to-equal "mock process"))
- (it "signals error on failure."
- (spy-on 'make-process :and-throw-error 'error)
- (expect (subed-mpv--server-start) :to-throw 'error))
- )
+ (it "passes arguments to make-process."
+ (spy-on 'make-process)
+ (spy-on 'subed-mpv--socket :and-return-value "/mock/path/to/socket")
+ (subed-mpv--server-start "foo" "--bar")
+ (expect 'make-process :to-have-been-called-with
+ :command (list subed-mpv-executable
+ "--input-ipc-server=/mock/path/to/socket"
+ "--idle" "foo" "--bar")
+ :name "subed-mpv-server" :buffer nil :noquery t))
+ (it "sets subed-mpv--server-proc on success."
+ (spy-on 'make-process :and-return-value "mock process")
+ (subed-mpv--server-start)
+ (expect subed-mpv--server-proc :to-equal "mock process"))
+ (it "signals error on failure."
+ (spy-on 'make-process :and-throw-error 'error)
+ (expect (subed-mpv--server-start) :to-throw 'error))
+ )
(describe "Stopping mpv"
- (before-each
- (setq subed-mpv--server-proc "mock running mpv process")
- (spy-on 'process-live-p :and-return-value t)
- (spy-on 'delete-process))
- (it "kills the mpv process."
- (subed-mpv--server-stop)
- (expect 'delete-process :to-have-been-called-with "mock running
mpv process"))
- (it "resets subed-mpv--server-proc."
- (expect subed-mpv--server-proc :not :to-be nil)
- (subed-mpv--server-stop)
- (expect subed-mpv--server-proc :to-be nil))
- )
+ (before-each
+ (setq subed-mpv--server-proc "mock running mpv process")
+ (spy-on 'process-live-p :and-return-value t)
+ (spy-on 'delete-process))
+ (it "kills the mpv process."
+ (subed-mpv--server-stop)
+ (expect 'delete-process :to-have-been-called-with "mock running mpv
process"))
+ (it "resets subed-mpv--server-proc."
+ (expect subed-mpv--server-proc :not :to-be nil)
+ (subed-mpv--server-stop)
+ (expect subed-mpv--server-proc :to-be nil))
+ )
(describe "Connecting"
- (before-each
- (spy-on 'delete-process))
- (it "resets global status variables."
- (spy-on 'subed-mpv--client-connected-p :and-return-value t)
- (spy-on 'make-network-process :and-return-value "mock client
process")
- (spy-on 'process-send-string)
- (spy-on 'subed-mpv--client-send)
- (setq subed-mpv--client-proc "foo"
- subed-mpv-is-playing "baz"
- subed-mpv--client-command-queue '(foo bar baz))
- (subed-mpv--client-connect '(0 0 0))
- (expect subed-mpv--client-proc :to-equal "mock client process")
- (expect subed-mpv-is-playing :to-be nil)
- (expect subed-mpv--client-command-queue :to-be nil))
- (it "correctly calls make-network-process."
- (spy-on 'make-network-process)
- (spy-on 'process-send-string)
- (spy-on 'subed-mpv--socket :and-return-value
"/mock/path/to/socket")
- (subed-mpv--client-connect '(0 0 0))
- (expect 'make-network-process :to-have-been-called-with
- :name "subed-mpv-client"
- :family 'local
- :service (subed-mpv--socket)
- :coding '(utf-8 . utf-8)
- :buffer (subed-mpv--client-buffer)
- :filter #'subed-mpv--client-filter
- :noquery t
- :nowait t))
- (describe "tests the connection"
- (it "and sets subed-mpv--client-proc if the test succeeds."
- (spy-on 'make-network-process :and-return-value "mock
client process")
- (spy-on 'process-send-string)
- (subed-mpv--client-connect '(0 0 0))
- (expect 'process-send-string :to-have-been-called-with
- "mock client process" (concat
subed-mpv--client-test-request "\n"))
- (expect subed-mpv--client-proc :to-equal "mock client
process"))
- (it "and resets subed-mpv--client-proc if the test fails."
- (spy-on 'make-network-process :and-return-value "mock
client process")
- (spy-on 'process-send-string :and-throw-error 'error)
- (setq subed-mpv--client-proc "foo")
- (subed-mpv--client-connect '(0 0 0))
- (expect subed-mpv--client-proc :to-be nil))
- (it "and tries again if the test fails."
- (spy-on 'make-network-process :and-return-value "mock
client process")
- (spy-on 'process-send-string :and-throw-error 'error)
- (subed-mpv--client-connect '(0 0 0))
- ;; FIXME: This seems to be a bug:
- ;;
https://github.com/jorgenschaefer/emacs-buttercup/issues/139
- ;; (expect 'process-send-string
:to-have-been-called-times 3)
- (expect subed-mpv--client-proc :to-be nil))
- )
- (it "sends queued commands and empties the queue."
- (spy-on 'make-network-process :and-return-value "mock client
process")
- (spy-on 'process-send-string)
- (spy-on 'subed-mpv--client-send)
- (setq subed-mpv--client-command-queue '(foo bar baz))
- (subed-mpv--client-connect '(0 0 0))
- (expect 'subed-mpv--client-send :to-have-been-called-with 'foo)
- (expect 'subed-mpv--client-send :to-have-been-called-with 'bar)
- (expect 'subed-mpv--client-send :to-have-been-called-with 'baz)
- (expect subed-mpv--client-command-queue :to-be nil))
- )
+ (before-each
+ (spy-on 'delete-process))
+ (it "resets global status variables."
+ (spy-on 'subed-mpv--client-connected-p :and-return-value t)
+ (spy-on 'make-network-process :and-return-value "mock client process")
+ (spy-on 'process-send-string)
+ (spy-on 'subed-mpv--client-send)
+ (setq subed-mpv--client-proc "foo"
+ subed-mpv-is-playing "baz"
+ subed-mpv--client-command-queue '(foo bar baz))
+ (subed-mpv--client-connect '(0 0 0))
+ (expect subed-mpv--client-proc :to-equal "mock client process")
+ (expect subed-mpv-is-playing :to-be nil)
+ (expect subed-mpv--client-command-queue :to-be nil))
+ (it "correctly calls make-network-process."
+ (spy-on 'make-network-process)
+ (spy-on 'process-send-string)
+ (spy-on 'subed-mpv--socket :and-return-value "/mock/path/to/socket")
+ (subed-mpv--client-connect '(0 0 0))
+ (expect 'make-network-process :to-have-been-called-with
+ :name "subed-mpv-client"
+ :family 'local
+ :service (subed-mpv--socket)
+ :coding '(utf-8 . utf-8)
+ :buffer (subed-mpv--client-buffer)
+ :filter #'subed-mpv--client-filter
+ :noquery t
+ :nowait t))
+ (describe "tests the connection"
+ (it "and sets subed-mpv--client-proc if the test succeeds."
+ (spy-on 'make-network-process :and-return-value "mock client process")
+ (spy-on 'process-send-string)
+ (subed-mpv--client-connect '(0 0 0))
+ (expect 'process-send-string :to-have-been-called-with
+ "mock client process" (concat subed-mpv--client-test-request
"\n"))
+ (expect subed-mpv--client-proc :to-equal "mock client process"))
+ (it "and resets subed-mpv--client-proc if the test fails."
+ (spy-on 'make-network-process :and-return-value "mock client process")
+ (spy-on 'process-send-string :and-throw-error 'error)
+ (setq subed-mpv--client-proc "foo")
+ (subed-mpv--client-connect '(0 0 0))
+ (expect subed-mpv--client-proc :to-be nil))
+ (it "and tries again if the test fails."
+ (spy-on 'make-network-process :and-return-value "mock client process")
+ (spy-on 'process-send-string :and-throw-error 'error)
+ (subed-mpv--client-connect '(0 0 0))
+ ;; FIXME: This seems to be a bug:
+ ;; https://github.com/jorgenschaefer/emacs-buttercup/issues/139
+ ;; (expect 'process-send-string :to-have-been-called-times 3)
+ (expect subed-mpv--client-proc :to-be nil))
+ )
+ (it "sends queued commands and empties the queue."
+ (spy-on 'make-network-process :and-return-value "mock client process")
+ (spy-on 'process-send-string)
+ (spy-on 'subed-mpv--client-send)
+ (setq subed-mpv--client-command-queue '(foo bar baz))
+ (subed-mpv--client-connect '(0 0 0))
+ (expect 'subed-mpv--client-send :to-have-been-called-with 'foo)
+ (expect 'subed-mpv--client-send :to-have-been-called-with 'bar)
+ (expect 'subed-mpv--client-send :to-have-been-called-with 'baz)
+ (expect subed-mpv--client-command-queue :to-be nil))
+ )
(describe "Sending command"
- (before-each
- (spy-on 'delete-process)
- (setq subed-mpv--client-command-queue nil))
- (describe "when mpv process is not running"
- (before-each
- (spy-on 'subed-mpv--server-started-p :and-return-value
nil))
- (it "is not queued if not connected."
- (spy-on 'subed-mpv--client-connected-p
:and-return-value nil)
- (subed-mpv--client-send '(do this thing))
- (expect subed-mpv--client-command-queue :to-be nil))
- )
- (describe "when mpv process is running"
- (before-each
- (spy-on 'subed-mpv--server-started-p :and-return-value t))
- (it "is queued if not connected."
- (spy-on 'subed-mpv--client-connected-p
:and-return-value nil)
- (subed-mpv--client-send '(do this thing))
- (expect subed-mpv--client-command-queue :to-equal
'((do this thing)))
- (subed-mpv--client-send '(do something else))
- (expect subed-mpv--client-command-queue :to-equal
'((do this thing)
-
(do something else))))
- (it "sends command if connected."
- (spy-on 'subed-mpv--client-connected-p
:and-return-value t)
- (spy-on 'process-send-string)
- (setq subed-mpv--client-proc "mock client process")
- (subed-mpv--client-send '(do this thing))
- (expect 'process-send-string :to-have-been-called-with
- "mock client process"
- (concat (json-encode (list :command '(do this
thing))) "\n"))
- (expect subed-mpv--client-command-queue :to-equal nil))
- (it "disconnects if sending fails even though we're
connected."
- (spy-on 'subed-mpv--client-connected-p
:and-return-value t)
- (spy-on 'subed-mpv--client-disconnect)
- (spy-on 'process-send-string :and-throw-error 'error)
- (expect (subed-mpv--client-send '(do this thing))
:to-throw 'error)
- (expect 'subed-mpv--client-disconnect
:to-have-been-called-times 1)
- (expect subed-mpv--client-command-queue :to-equal nil))
- )
- )
+ (before-each
+ (spy-on 'delete-process)
+ (setq subed-mpv--client-command-queue nil))
+ (describe "when mpv process is not running"
+ (before-each
+ (spy-on 'subed-mpv--server-started-p :and-return-value nil))
+ (it "is not queued if not connected."
+ (spy-on 'subed-mpv--client-connected-p :and-return-value nil)
+ (subed-mpv--client-send '(do this thing))
+ (expect subed-mpv--client-command-queue :to-be nil))
+ )
+ (describe "when mpv process is running"
+ (before-each
+ (spy-on 'subed-mpv--server-started-p :and-return-value t))
+ (it "is queued if not connected."
+ (spy-on 'subed-mpv--client-connected-p :and-return-value nil)
+ (subed-mpv--client-send '(do this thing))
+ (expect subed-mpv--client-command-queue :to-equal '((do this thing)))
+ (subed-mpv--client-send '(do something else))
+ (expect subed-mpv--client-command-queue :to-equal '((do this thing)
+ (do something
else))))
+ (it "sends command if connected."
+ (spy-on 'subed-mpv--client-connected-p :and-return-value t)
+ (spy-on 'process-send-string)
+ (setq subed-mpv--client-proc "mock client process")
+ (subed-mpv--client-send '(do this thing))
+ (expect 'process-send-string :to-have-been-called-with
+ "mock client process"
+ (concat (json-encode (list :command '(do this thing))) "\n"))
+ (expect subed-mpv--client-command-queue :to-equal nil))
+ (it "disconnects if sending fails even though we're connected."
+ (spy-on 'subed-mpv--client-connected-p :and-return-value t)
+ (spy-on 'subed-mpv--client-disconnect)
+ (spy-on 'process-send-string :and-throw-error 'error)
+ (expect (subed-mpv--client-send '(do this thing)) :to-throw 'error)
+ (expect 'subed-mpv--client-disconnect :to-have-been-called-times 1)
+ (expect subed-mpv--client-command-queue :to-equal nil))
+ )
+ )
diff --git a/tests/test-subed-srt.el b/tests/test-subed-srt.el
index 39ebc76..168cd85 100644
--- a/tests/test-subed-srt.el
+++ b/tests/test-subed-srt.el
@@ -17,1335 +17,1335 @@ Baz.
")
(describe "Getting"
- (describe "the subtitle ID"
- (it "returns the subtitle ID if it can be found."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 2)
- (expect (subed-srt--subtitle-id) :to-equal 2)))
- (it "returns nil if no subtitle ID can be found."
- (with-temp-buffer
- (expect (subed-srt--subtitle-id) :to-equal nil)))
- )
- (describe "the subtitle ID at playback time"
- (it "returns subtitle ID if time is equal to start time."
- (with-temp-buffer
- (insert mock-srt-data)
- (cl-loop for target-id from 1 to 3 do
- (let ((msecs
(subed-srt--subtitle-msecs-start target-id)))
- (cl-loop for outset-id from 1 to 3 do
- (progn
-
(subed-srt--jump-to-subtitle-id outset-id)
- (expect
(subed-srt--subtitle-id-at-msecs msecs) :to-equal target-id)))))))
- (it "returns subtitle ID if time is equal to stop time."
- (with-temp-buffer
- (insert mock-srt-data)
- (cl-loop for target-id from 1 to 3 do
- (let ((msecs
(subed-srt--subtitle-msecs-stop target-id)))
- (cl-loop for outset-id from 1 to 3 do
- (progn
-
(subed-srt--jump-to-subtitle-id outset-id)
- (expect
(subed-srt--subtitle-id-at-msecs msecs) :to-equal target-id)))))))
- (it "returns subtitle ID if time is between start and stop
time."
- (with-temp-buffer
- (insert mock-srt-data)
- (cl-loop for target-id from 1 to 3 do
- (let ((msecs (+ 1
(subed-srt--subtitle-msecs-start target-id))))
- (cl-loop for outset-id from 1 to 3 do
- (progn
-
(subed-srt--jump-to-subtitle-id outset-id)
- (expect
(subed-srt--subtitle-id-at-msecs msecs) :to-equal target-id)))))))
- (it "returns first subtitle ID if time is before the first
subtitle's start time."
- (with-temp-buffer
- (insert mock-srt-data)
- (let ((msecs (- (save-excursion
- (goto-char (point-min))
- (subed-srt--subtitle-msecs-start))
1)))
- (cl-loop for outset-id from 1 to 3 do
- (progn
- (subed-srt--jump-to-subtitle-id
outset-id)
- (expect
(subed-srt--subtitle-id-at-msecs msecs) :to-equal 1))))))
- (it "returns last subtitle ID if time is after the last
subtitle's start time."
- (with-temp-buffer
- (insert mock-srt-data)
- (let ((msecs (+ (save-excursion
- (goto-char (point-max))
- (subed-srt--subtitle-msecs-stop))
1)))
- (cl-loop for outset-id from 1 to 3 do
- (progn
- (subed-srt--jump-to-subtitle-id
outset-id)
- (expect
(subed-srt--subtitle-id-at-msecs msecs) :to-equal 3))))))
- (it "returns previous subtitle ID when time is between
subtitles."
- (with-temp-buffer
- (insert mock-srt-data)
- (cl-loop for target-id from 1 to 2 do
- (let ((msecs (+
(subed-srt--subtitle-msecs-stop target-id) 1)))
- (cl-loop for outset-id from 1 to 3 do
- (progn
-
(subed-srt--jump-to-subtitle-id outset-id)
- (expect
(subed-srt--subtitle-id-at-msecs msecs) :to-equal target-id))))
- (let ((msecs (-
(subed-srt--subtitle-msecs-start (+ target-id 1)) 1)))
- (cl-loop for outset-id from 1 to 3 do
- (progn
-
(subed-srt--jump-to-subtitle-id outset-id)
- (expect
(subed-srt--subtitle-id-at-msecs msecs) :to-equal target-id)))))))
- (it "doesn't fail when start time is invalid."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-id 2)
- (let ((msecs (- (subed-srt--subtitle-msecs-start)
1)))
- (subed-srt--jump-to-subtitle-time-start)
- (forward-char 8) (delete-char 1)
- (expect (subed-srt--subtitle-id-at-msecs msecs)
:to-equal 2))))
- )
- (describe "the subtitle start/stop time"
- (it "returns the time in milliseconds."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 2)
- (expect (subed-srt--subtitle-msecs-start) :to-equal
(+ (* 2 60000) (* 2 1000) 234))
- (expect (subed-srt--subtitle-msecs-stop) :to-equal
(+ (* 2 60000) (* 10 1000) 345))))
- (it "returns nil if time can't be found."
- (with-temp-buffer
- (expect (subed-srt--subtitle-msecs-start) :to-be nil)
- (expect (subed-srt--subtitle-msecs-stop) :to-be
nil)))
- )
- (describe "the subtitle text"
- (describe "when text is empty"
- (it "and at the beginning with a trailing
newline."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 1)
- (kill-line)
- (expect (subed-srt--subtitle-text)
:to-equal "")))
- (it "and at the beginning without a trailing
newline."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 1)
- (kill-whole-line)
- (expect (subed-srt--subtitle-text)
:to-equal "")))
- (it "and in the middle."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 2)
- (kill-line)
- (expect (subed-srt--subtitle-text)
:to-equal "")))
- (it "and at the end with a trailing newline."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 3)
- (kill-line)
- (expect (subed-srt--subtitle-text)
:to-equal "")))
- (it "and at the end without a trailing newline."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 3)
- (kill-whole-line)
- (expect (subed-srt--subtitle-text)
:to-equal "")))
- )
- (describe "when text is not empty"
- (it "and has no linebreaks."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 2)
- (expect (subed-srt--subtitle-text)
:to-equal "Bar.")))
- (it "and has linebreaks."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 2)
- (insert "Bar.\n")
- (expect (subed-srt--subtitle-text)
:to-equal "Bar.\nBar.")))
- )
- )
- (describe "the point within the subtitle"
- (it "returns the relative point if we can find an ID."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-id 2)
- (expect (subed-srt--subtitle-relative-point)
:to-equal 0)
- (forward-line)
- (expect (subed-srt--subtitle-relative-point)
:to-equal 2)
- (forward-line)
- (expect (subed-srt--subtitle-relative-point)
:to-equal 32)
- (forward-char)
- (expect (subed-srt--subtitle-relative-point)
:to-equal 33)
- (forward-line)
- (expect (subed-srt--subtitle-relative-point)
:to-equal 37)
- (forward-line)
- (expect (subed-srt--subtitle-relative-point)
:to-equal 0)))
- (it "returns nil if we can't find an ID."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-id 1)
- (insert "foo")
- (expect (subed-srt--subtitle-relative-point)
:to-equal nil)))
- )
- )
-
-(describe "Jumping"
- (describe "to current subtitle ID"
- (it "returns ID's point when point is already on the ID."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-min))
- (expect (thing-at-point 'word) :to-equal "1")
- (expect (subed-srt--jump-to-subtitle-id) :to-equal 1)
- (expect (thing-at-point 'word) :to-equal "1")))
- (it "returns ID's point when point is on the duration."
- (with-temp-buffer
- (insert mock-srt-data)
- (search-backward ",234")
- (expect (thing-at-point 'word) :to-equal "02")
- (expect (subed-srt--jump-to-subtitle-id) :to-equal
39)
- (expect (thing-at-point 'word) :to-equal "2")))
- (it "returns ID's point when point is on the text."
- (with-temp-buffer
- (insert mock-srt-data)
- (search-backward "Baz.")
- (expect (thing-at-point 'word) :to-equal "Baz")
- (expect (subed-srt--jump-to-subtitle-id) :to-equal
77)
- (expect (thing-at-point 'word) :to-equal "3")))
- (it "returns ID's point when point is between subtitles."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-min))
- (search-forward "Bar.\n")
- (expect (thing-at-point 'line) :to-equal "\n")
- (expect (subed-srt--jump-to-subtitle-id) :to-equal
39)
- (expect (thing-at-point 'word) :to-equal "2")))
- (it "returns nil if buffer is empty."
- (with-temp-buffer
- (expect (buffer-string) :to-equal "")
- (expect (subed-srt--jump-to-subtitle-id) :to-equal
nil)))
- (it "returns ID's point when buffer starts with blank
lines."
- (with-temp-buffer
- (insert (concat " \n \t \n" mock-srt-data))
- (search-backward "Foo.")
- (expect (thing-at-point 'line) :to-equal "Foo.\n")
- (expect (subed-srt--jump-to-subtitle-id) :to-equal 7)
- (expect (thing-at-point 'word) :to-equal "1")))
- (it "returns ID's point when subtitles are separated with
blank lines."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-min))
- (search-forward "Foo.\n")
- (insert " \n \t \n")
- (expect (subed-srt--jump-to-subtitle-id) :to-equal 1)
- (expect (thing-at-point 'word) :to-equal "1")))
- )
- (describe "to specific subtitle ID"
- (it "returns ID's point if wanted ID exists."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-max))
- (expect (subed-srt--jump-to-subtitle-id 2) :to-equal
39)
- (expect (thing-at-point 'word) :to-equal "2")
- (expect (subed-srt--jump-to-subtitle-id 1) :to-equal
1)
- (expect (thing-at-point 'word) :to-equal "1")
- (expect (subed-srt--jump-to-subtitle-id 3) :to-equal
77)
- (expect (thing-at-point 'word) :to-equal "3")))
- (it "returns nil and does not move if wanted ID does not
exists."
- (with-temp-buffer
- (insert mock-srt-data)
+ (describe "the subtitle ID"
+ (it "returns the subtitle ID if it can be found."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 2)
+ (expect (subed-srt--subtitle-id) :to-equal 2)))
+ (it "returns nil if no subtitle ID can be found."
+ (with-temp-buffer
+ (expect (subed-srt--subtitle-id) :to-equal nil)))
+ )
+ (describe "the subtitle ID at playback time"
+ (it "returns subtitle ID if time is equal to start time."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (cl-loop for target-id from 1 to 3 do
+ (let ((msecs (subed-srt--subtitle-msecs-start target-id)))
+ (cl-loop for outset-id from 1 to 3 do
+ (progn
+ (subed-srt--jump-to-subtitle-id outset-id)
+ (expect (subed-srt--subtitle-id-at-msecs msecs)
:to-equal target-id)))))))
+ (it "returns subtitle ID if time is equal to stop time."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (cl-loop for target-id from 1 to 3 do
+ (let ((msecs (subed-srt--subtitle-msecs-stop target-id)))
+ (cl-loop for outset-id from 1 to 3 do
+ (progn
+ (subed-srt--jump-to-subtitle-id outset-id)
+ (expect (subed-srt--subtitle-id-at-msecs msecs)
:to-equal target-id)))))))
+ (it "returns subtitle ID if time is between start and stop time."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (cl-loop for target-id from 1 to 3 do
+ (let ((msecs (+ 1 (subed-srt--subtitle-msecs-start
target-id))))
+ (cl-loop for outset-id from 1 to 3 do
+ (progn
+ (subed-srt--jump-to-subtitle-id outset-id)
+ (expect (subed-srt--subtitle-id-at-msecs msecs)
:to-equal target-id)))))))
+ (it "returns first subtitle ID if time is before the first subtitle's
start time."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (let ((msecs (- (save-excursion
(goto-char (point-min))
- (search-forward "Foo")
- (let ((stored-point (point)))
- (expect (subed-srt--jump-to-subtitle-id 4)
:to-equal nil)
- (expect stored-point :to-equal (point)))))
- )
- (describe "to subtitle ID at specific time"
- (it "returns ID's point if point changed."
- (with-temp-buffer
- (insert mock-srt-data)
+ (subed-srt--subtitle-msecs-start)) 1)))
+ (cl-loop for outset-id from 1 to 3 do
+ (progn
+ (subed-srt--jump-to-subtitle-id outset-id)
+ (expect (subed-srt--subtitle-id-at-msecs msecs) :to-equal
1))))))
+ (it "returns last subtitle ID if time is after the last subtitle's start
time."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (let ((msecs (+ (save-excursion
(goto-char (point-max))
- (spy-on 'subed-srt--subtitle-id-at-msecs
:and-return-value (point-min))
- (expect (subed-srt--jump-to-subtitle-id-at-msecs
123450) :to-equal (point-min))
- (expect (point) :to-equal (point-min))
- (expect 'subed-srt--subtitle-id-at-msecs
:to-have-been-called-with 123450)
- (expect 'subed-srt--subtitle-id-at-msecs
:to-have-been-called-times 1)))
- (it "returns nil if point didn't change."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char 75)
- (spy-on 'subed-srt--subtitle-id-at-msecs
:and-return-value 75)
- (expect (subed-srt--jump-to-subtitle-id-at-msecs
123450) :to-equal nil)
- (expect (point) :to-equal 75)
- (expect 'subed-srt--subtitle-id-at-msecs
:to-have-been-called-with 123450)
- (expect 'subed-srt--subtitle-id-at-msecs
:to-have-been-called-times 1)))
- )
- (describe "to subtitle start time"
- (it "returns start time's point if movement was
successful."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-min))
- (expect (subed-srt--jump-to-subtitle-time-start)
:to-equal 3)
- (expect (looking-at subed-srt--regexp-timestamp)
:to-be t)
- (expect (match-string 0) :to-equal "00:01:01,000")
- (re-search-forward "\n\n")
- (expect (subed-srt--jump-to-subtitle-time-start)
:to-equal 41)
- (expect (looking-at subed-srt--regexp-timestamp)
:to-be t)
- (expect (match-string 0) :to-equal "00:02:02,234")
- (re-search-forward "\n\n")
- (expect (subed-srt--jump-to-subtitle-time-start)
:to-equal 79)
- (expect (looking-at subed-srt--regexp-timestamp)
:to-be t)
- (expect (match-string 0) :to-equal "00:03:03,45")))
- (it "returns nil if movement failed."
- (with-temp-buffer
- (expect (subed-srt--jump-to-subtitle-time-start)
:to-equal nil)))
- )
- (describe "to subtitle stop time"
- (it "returns stop time's point if movement was successful."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-min))
- (expect (subed-srt--jump-to-subtitle-time-stop)
:to-equal 20)
- (expect (looking-at subed-srt--regexp-timestamp)
:to-be t)
- (expect (match-string 0) :to-equal "00:01:05,123")
- (re-search-forward "\n\n")
- (expect (subed-srt--jump-to-subtitle-time-stop)
:to-equal 58)
- (expect (looking-at subed-srt--regexp-timestamp)
:to-be t)
- (expect (match-string 0) :to-equal "00:02:10,345")
- (re-search-forward "\n\n")
- (expect (subed-srt--jump-to-subtitle-time-stop)
:to-equal 95)
- (expect (looking-at subed-srt--regexp-timestamp)
:to-be t)
- (expect (match-string 0) :to-equal "00:03:15,5")))
- (it "returns nil if movement failed."
- (with-temp-buffer
- (expect (subed-srt--jump-to-subtitle-time-stop)
:to-equal nil)))
- )
- (describe "to subtitle text"
- (it "returns subtitle text's point if movement was
successful."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-min))
- (expect (subed-srt--jump-to-subtitle-text) :to-equal
33)
- (expect (point) :to-equal (save-excursion (goto-char
(point-max)) (search-backward "Foo.")))
- (re-search-forward "\n\n")
- (expect (subed-srt--jump-to-subtitle-text) :to-equal
71)
- (expect (point) :to-equal (save-excursion (goto-char
(point-max)) (search-backward "Bar.")))
- (re-search-forward "\n\n")
- (expect (subed-srt--jump-to-subtitle-text) :to-equal
106)
- (expect (point) :to-equal (save-excursion (goto-char
(point-max)) (search-backward "Baz.")))))
- (it "returns nil if movement failed."
- (with-temp-buffer
- (expect (subed-srt--jump-to-subtitle-time-stop)
:to-equal nil)))
- )
- (describe "to end of subtitle text"
- (it "returns point if subtitle end can be found."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-min))
- (expect (subed-srt--jump-to-subtitle-end) :to-be 37)
- (expect (looking-back "^Foo.$") :to-be t)
- (forward-char 2)
- (expect (subed-srt--jump-to-subtitle-end) :to-be 75)
- (expect (looking-back "^Bar.$") :to-be t)
- (forward-char 2)
- (expect (subed-srt--jump-to-subtitle-end) :to-be 110)
- (expect (looking-back "^Baz.$") :to-be t)
- (goto-char (point-max))
- (backward-char 2)
- (expect (subed-srt--jump-to-subtitle-end) :to-be 110)
- (expect (looking-back "^Baz.$") :to-be t)))
- (it "returns nil if subtitle end cannot be found."
- (with-temp-buffer
- (expect (subed-srt--jump-to-subtitle-end) :to-be
nil)))
- (it "returns nil if point did not move."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 1)
- (kill-line)
- (expect (subed-srt--jump-to-subtitle-end) :to-be
nil)))
- (it "works if text is empty with trailing newline."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 1)
- (kill-line)
- (backward-char)
- (expect (subed-srt--jump-to-subtitle-end) :to-be 33)
- (expect (looking-at "^$") :to-be t)
- (subed-srt--jump-to-subtitle-text 2)
- (kill-line)
- (backward-char)
- (expect (subed-srt--jump-to-subtitle-end) :to-be 67)
- (expect (looking-at "^$") :to-be t)
- (subed-srt--jump-to-subtitle-text 3)
- (kill-line)
- (backward-char)
- (expect (subed-srt--jump-to-subtitle-end) :to-be 98)
- (expect (looking-at "^$") :to-be t)))
- (it "works if text is empty without trailing newline."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 1)
- (kill-whole-line)
- (expect (subed-srt--jump-to-subtitle-end) :to-be nil)
- (expect (looking-at "^$") :to-be t)
- (goto-char (point-min))
- (expect (subed-srt--jump-to-subtitle-end) :to-be 33)
- (expect (looking-at "^$") :to-be t)
- (subed-srt--jump-to-subtitle-text 2)
- (kill-whole-line)
- (expect (subed-srt--jump-to-subtitle-end) :to-be nil)
- (expect (looking-at "^$") :to-be t)
- (backward-char)
- (expect (subed-srt--jump-to-subtitle-end) :to-be 66)
- (expect (looking-at "^$") :to-be t)
- (subed-srt--jump-to-subtitle-text 3)
- (kill-whole-line)
- (expect (subed-srt--jump-to-subtitle-end) :to-be nil)
- (expect (looking-at "^$") :to-be t)
- (backward-char)
- (expect (subed-srt--jump-to-subtitle-end) :to-be 96)
- (expect (looking-at "^$") :to-be t)))
- )
- (describe "to next subtitle ID"
- (it "returns point when there is a next subtitle."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-id 1)
- (expect (thing-at-point 'word) :to-equal "1")
- (expect (subed-srt--forward-subtitle-id) :to-be 39)
- (expect (thing-at-point 'word) :to-equal "2")
- (subed-srt--jump-to-subtitle-time-start 2)
- (expect (thing-at-point 'word) :to-equal "00")
- (expect (subed-srt--forward-subtitle-id) :to-be 77)
- (expect (thing-at-point 'word) :to-equal "3")))
- (it "returns nil and doesn't move when there is no next
subtitle."
- (with-temp-buffer
- (expect (thing-at-point 'word) :to-equal nil)
- (expect (subed-srt--forward-subtitle-id) :to-be nil))
- (with-temp-buffer
- (insert (concat mock-srt-data))
- (subed-srt--jump-to-subtitle-text 1)
- (expect (thing-at-point 'word) :to-equal "Foo")
- (expect (subed-srt--forward-subtitle-id) :to-be 39)
- (expect (thing-at-point 'word) :to-equal "2")
- (subed-srt--jump-to-subtitle-time-stop 2)
- (expect (thing-at-point 'word) :to-equal "00")
- (expect (subed-srt--forward-subtitle-id) :to-be 77)
- (expect (thing-at-point 'word) :to-equal "3"))
- (with-temp-buffer
- (insert (concat mock-srt-data))
- (subed-srt--jump-to-subtitle-text 3)
- (expect (thing-at-point 'word) :to-equal "Baz")
- (expect (subed-srt--forward-subtitle-id) :to-be nil)
- (expect (thing-at-point 'word) :to-equal "Baz"))
- (with-temp-buffer
- (insert (concat mock-srt-data "\n\n"))
- (subed-srt--jump-to-subtitle-time-stop 3)
- (expect (thing-at-point 'word) :to-equal "00")
- (expect (subed-srt--forward-subtitle-id) :to-be nil)
- (expect (thing-at-point 'word) :to-equal "00")))
- )
- (describe "to previous subtitle ID"
- (it "returns point when there is a previous subtitle."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 2)
- (expect (thing-at-point 'word) :to-equal "Bar")
- (expect (subed-srt--backward-subtitle-id) :to-be 1)
- (expect (thing-at-point 'word) :to-equal "1")
- (subed-srt--jump-to-subtitle-time-stop 3)
- (expect (thing-at-point 'word) :to-equal "00")
- (expect (subed-srt--backward-subtitle-id) :to-be 39)
- (expect (thing-at-point 'word) :to-equal "2")))
- (it "returns nil and doesn't move when there is no
previous subtitle."
- (with-temp-buffer
- (expect (subed-srt--backward-subtitle-id) :to-be
nil))
- (with-temp-buffer
- (insert (concat mock-srt-data))
- (subed-srt--jump-to-subtitle-id 1)
- (expect (thing-at-point 'word) :to-equal "1")
- (expect (subed-srt--backward-subtitle-id) :to-be nil)
- (expect (thing-at-point 'word) :to-equal "1"))
- (with-temp-buffer
- (insert (concat mock-srt-data))
- (subed-srt--jump-to-subtitle-text 1)
- (expect (thing-at-point 'word) :to-equal "Foo")
- (expect (subed-srt--backward-subtitle-id) :to-be nil)
- (expect (thing-at-point 'word) :to-equal "Foo"))
- (with-temp-buffer
- (insert (concat "\n\n\n" mock-srt-data))
- (subed-srt--jump-to-subtitle-time-stop 1)
- (expect (thing-at-point 'word) :to-equal "00")
- (expect (subed-srt--backward-subtitle-id) :to-be nil)
- (expect (thing-at-point 'word) :to-equal "00")))
- )
- (describe "to next subtitle text"
- (it "returns point when there is a next subtitle."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-id 1)
- (expect (thing-at-point 'word) :to-equal "1")
- (expect (subed-srt--forward-subtitle-text) :to-be 71)
- (expect (thing-at-point 'word) :to-equal "Bar")))
- (it "returns nil and doesn't move when there is no next
subtitle."
- (with-temp-buffer
- (goto-char (point-max))
- (insert (concat mock-srt-data "\n\n"))
- (subed-srt--jump-to-subtitle-id 3)
- (expect (thing-at-point 'word) :to-equal "3")
- (expect (subed-srt--forward-subtitle-text) :to-be
nil)
- (expect (thing-at-point 'word) :to-equal "3")))
- )
- (describe "to previous subtitle text"
- (it "returns point when there is a previous subtitle."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-id 3)
- (expect (thing-at-point 'word) :to-equal "3")
- (expect (subed-srt--backward-subtitle-text) :to-be
71)
- (expect (thing-at-point 'word) :to-equal "Bar")))
- (it "returns nil and doesn't move when there is no
previous subtitle."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-min))
- (expect (thing-at-point 'word) :to-equal "1")
- (expect (subed-srt--backward-subtitle-text) :to-be
nil)
- (expect (thing-at-point 'word) :to-equal "1")))
- )
- (describe "to next subtitle end"
- (it "returns point when there is a next subtitle."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 2)
- (expect (thing-at-point 'word) :to-equal "Bar")
- (expect (subed-srt--forward-subtitle-end) :to-be 110)
- (expect (thing-at-point 'word) :to-equal nil)))
- (it "returns nil and doesn't move when there is no next
subtitle."
- (with-temp-buffer
- (insert (concat mock-srt-data "\n\n"))
- (subed-srt--jump-to-subtitle-text 3)
- (end-of-line)
- (expect (thing-at-point 'word) :to-equal nil)
- (expect (subed-srt--forward-subtitle-end) :to-be nil)
- (expect (thing-at-point 'word) :to-equal nil)))
- )
- (describe "to previous subtitle end"
- (it "returns point when there is a previous subtitle."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-id 3)
- (expect (thing-at-point 'word) :to-equal "3")
- (expect (subed-srt--backward-subtitle-text) :to-be
71)
- (expect (thing-at-point 'word) :to-equal "Bar")))
- (it "returns nil and doesn't move when there is no
previous subtitle."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-min))
- (expect (thing-at-point 'word) :to-equal "1")
- (expect (subed-srt--backward-subtitle-text) :to-be
nil)
- (expect (thing-at-point 'word) :to-equal "1")))
- )
- (describe "to next subtitle start time"
- (it "returns point when there is a next subtitle."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 1)
- (expect (thing-at-point 'word) :to-equal "Foo")
- (expect (subed-srt--forward-subtitle-time-start)
:to-be 41)
- (expect (thing-at-point 'word) :to-equal "00")))
- (it "returns nil and doesn't move when there is no next
subtitle."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-id 3)
- (expect (thing-at-point 'word) :to-equal "3")
- (expect (subed-srt--forward-subtitle-time-start)
:to-be nil)
- (expect (thing-at-point 'word) :to-equal "3")))
- )
- (describe "to previous subtitle start time"
- (it "returns point when there is a previous subtitle."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-id 2)
- (expect (thing-at-point 'word) :to-equal "2")
- (expect (subed-srt--backward-subtitle-time-start)
:to-be 3)
- (expect (thing-at-point 'word) :to-equal "00")))
- (it "returns nil and doesn't move when there is no
previous subtitle."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-id 1)
- (expect (thing-at-point 'word) :to-equal "1")
- (expect (subed-srt--backward-subtitle-time-start)
:to-be nil)
- (expect (thing-at-point 'word) :to-equal "1")))
- )
- (describe "to next subtitle stop time"
- (it "returns point when there is a next subtitle."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 1)
- (expect (thing-at-point 'word) :to-equal "Foo")
- (expect (subed-srt--forward-subtitle-time-stop)
:to-be 58)
- (expect (thing-at-point 'word) :to-equal "00")))
- (it "returns nil and doesn't move when there is no next
subtitle."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-id 3)
- (expect (thing-at-point 'word) :to-equal "3")
- (expect (subed-srt--forward-subtitle-time-stop)
:to-be nil)
- (expect (thing-at-point 'word) :to-equal "3")))
- )
- (describe "to previous subtitle stop time"
- (it "returns point when there is a previous subtitle."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-id 3)
- (expect (thing-at-point 'word) :to-equal "3")
- (expect (subed-srt--backward-subtitle-time-stop)
:to-be 58)
- (expect (thing-at-point 'word) :to-equal "00")))
- (it "returns nil and doesn't move when there is no
previous subtitle."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-id 1)
- (expect (thing-at-point 'word) :to-equal "1")
- (expect (subed-srt--backward-subtitle-time-stop)
:to-be nil)
- (expect (thing-at-point 'word) :to-equal "1")))
- )
- )
+ (subed-srt--subtitle-msecs-stop)) 1)))
+ (cl-loop for outset-id from 1 to 3 do
+ (progn
+ (subed-srt--jump-to-subtitle-id outset-id)
+ (expect (subed-srt--subtitle-id-at-msecs msecs) :to-equal
3))))))
+ (it "returns previous subtitle ID when time is between subtitles."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (cl-loop for target-id from 1 to 2 do
+ (let ((msecs (+ (subed-srt--subtitle-msecs-stop target-id)
1)))
+ (cl-loop for outset-id from 1 to 3 do
+ (progn
+ (subed-srt--jump-to-subtitle-id outset-id)
+ (expect (subed-srt--subtitle-id-at-msecs msecs)
:to-equal target-id))))
+ (let ((msecs (- (subed-srt--subtitle-msecs-start (+ target-id
1)) 1)))
+ (cl-loop for outset-id from 1 to 3 do
+ (progn
+ (subed-srt--jump-to-subtitle-id outset-id)
+ (expect (subed-srt--subtitle-id-at-msecs msecs)
:to-equal target-id)))))))
+ (it "doesn't fail when start time is invalid."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-id 2)
+ (let ((msecs (- (subed-srt--subtitle-msecs-start) 1)))
+ (subed-srt--jump-to-subtitle-time-start)
+ (forward-char 8) (delete-char 1)
+ (expect (subed-srt--subtitle-id-at-msecs msecs) :to-equal 2))))
+ )
+ (describe "the subtitle start/stop time"
+ (it "returns the time in milliseconds."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 2)
+ (expect (subed-srt--subtitle-msecs-start) :to-equal (+ (* 2 60000) (*
2 1000) 234))
+ (expect (subed-srt--subtitle-msecs-stop) :to-equal (+ (* 2 60000) (*
10 1000) 345))))
+ (it "returns nil if time can't be found."
+ (with-temp-buffer
+ (expect (subed-srt--subtitle-msecs-start) :to-be nil)
+ (expect (subed-srt--subtitle-msecs-stop) :to-be nil)))
+ )
+ (describe "the subtitle text"
+ (describe "when text is empty"
+ (it "and at the beginning with a trailing newline."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 1)
+ (kill-line)
+ (expect (subed-srt--subtitle-text) :to-equal "")))
+ (it "and at the beginning without a trailing newline."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 1)
+ (kill-whole-line)
+ (expect (subed-srt--subtitle-text) :to-equal "")))
+ (it "and in the middle."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 2)
+ (kill-line)
+ (expect (subed-srt--subtitle-text) :to-equal "")))
+ (it "and at the end with a trailing newline."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 3)
+ (kill-line)
+ (expect (subed-srt--subtitle-text) :to-equal "")))
+ (it "and at the end without a trailing newline."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 3)
+ (kill-whole-line)
+ (expect (subed-srt--subtitle-text) :to-equal "")))
+ )
+ (describe "when text is not empty"
+ (it "and has no linebreaks."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 2)
+ (expect (subed-srt--subtitle-text) :to-equal "Bar.")))
+ (it "and has linebreaks."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 2)
+ (insert "Bar.\n")
+ (expect (subed-srt--subtitle-text) :to-equal "Bar.\nBar.")))
+ )
+ )
+ (describe "the point within the subtitle"
+ (it "returns the relative point if we can find an ID."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-id 2)
+ (expect (subed-srt--subtitle-relative-point) :to-equal 0)
+ (forward-line)
+ (expect (subed-srt--subtitle-relative-point) :to-equal 2)
+ (forward-line)
+ (expect (subed-srt--subtitle-relative-point) :to-equal 32)
+ (forward-char)
+ (expect (subed-srt--subtitle-relative-point) :to-equal 33)
+ (forward-line)
+ (expect (subed-srt--subtitle-relative-point) :to-equal 37)
+ (forward-line)
+ (expect (subed-srt--subtitle-relative-point) :to-equal 0)))
+ (it "returns nil if we can't find an ID."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-id 1)
+ (insert "foo")
+ (expect (subed-srt--subtitle-relative-point) :to-equal nil)))
+ )
+ )
+
+(describe "Jumping"
+ (describe "to current subtitle ID"
+ (it "returns ID's point when point is already on the ID."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-min))
+ (expect (thing-at-point 'word) :to-equal "1")
+ (expect (subed-srt--jump-to-subtitle-id) :to-equal 1)
+ (expect (thing-at-point 'word) :to-equal "1")))
+ (it "returns ID's point when point is on the duration."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (search-backward ",234")
+ (expect (thing-at-point 'word) :to-equal "02")
+ (expect (subed-srt--jump-to-subtitle-id) :to-equal 39)
+ (expect (thing-at-point 'word) :to-equal "2")))
+ (it "returns ID's point when point is on the text."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (search-backward "Baz.")
+ (expect (thing-at-point 'word) :to-equal "Baz")
+ (expect (subed-srt--jump-to-subtitle-id) :to-equal 77)
+ (expect (thing-at-point 'word) :to-equal "3")))
+ (it "returns ID's point when point is between subtitles."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-min))
+ (search-forward "Bar.\n")
+ (expect (thing-at-point 'line) :to-equal "\n")
+ (expect (subed-srt--jump-to-subtitle-id) :to-equal 39)
+ (expect (thing-at-point 'word) :to-equal "2")))
+ (it "returns nil if buffer is empty."
+ (with-temp-buffer
+ (expect (buffer-string) :to-equal "")
+ (expect (subed-srt--jump-to-subtitle-id) :to-equal nil)))
+ (it "returns ID's point when buffer starts with blank lines."
+ (with-temp-buffer
+ (insert (concat " \n \t \n" mock-srt-data))
+ (search-backward "Foo.")
+ (expect (thing-at-point 'line) :to-equal "Foo.\n")
+ (expect (subed-srt--jump-to-subtitle-id) :to-equal 7)
+ (expect (thing-at-point 'word) :to-equal "1")))
+ (it "returns ID's point when subtitles are separated with blank lines."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-min))
+ (search-forward "Foo.\n")
+ (insert " \n \t \n")
+ (expect (subed-srt--jump-to-subtitle-id) :to-equal 1)
+ (expect (thing-at-point 'word) :to-equal "1")))
+ )
+ (describe "to specific subtitle ID"
+ (it "returns ID's point if wanted ID exists."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-max))
+ (expect (subed-srt--jump-to-subtitle-id 2) :to-equal 39)
+ (expect (thing-at-point 'word) :to-equal "2")
+ (expect (subed-srt--jump-to-subtitle-id 1) :to-equal 1)
+ (expect (thing-at-point 'word) :to-equal "1")
+ (expect (subed-srt--jump-to-subtitle-id 3) :to-equal 77)
+ (expect (thing-at-point 'word) :to-equal "3")))
+ (it "returns nil and does not move if wanted ID does not exists."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-min))
+ (search-forward "Foo")
+ (let ((stored-point (point)))
+ (expect (subed-srt--jump-to-subtitle-id 4) :to-equal nil)
+ (expect stored-point :to-equal (point)))))
+ )
+ (describe "to subtitle ID at specific time"
+ (it "returns ID's point if point changed."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-max))
+ (spy-on 'subed-srt--subtitle-id-at-msecs :and-return-value (point-min))
+ (expect (subed-srt--jump-to-subtitle-id-at-msecs 123450) :to-equal
(point-min))
+ (expect (point) :to-equal (point-min))
+ (expect 'subed-srt--subtitle-id-at-msecs :to-have-been-called-with
123450)
+ (expect 'subed-srt--subtitle-id-at-msecs :to-have-been-called-times
1)))
+ (it "returns nil if point didn't change."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char 75)
+ (spy-on 'subed-srt--subtitle-id-at-msecs :and-return-value 75)
+ (expect (subed-srt--jump-to-subtitle-id-at-msecs 123450) :to-equal nil)
+ (expect (point) :to-equal 75)
+ (expect 'subed-srt--subtitle-id-at-msecs :to-have-been-called-with
123450)
+ (expect 'subed-srt--subtitle-id-at-msecs :to-have-been-called-times
1)))
+ )
+ (describe "to subtitle start time"
+ (it "returns start time's point if movement was successful."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-min))
+ (expect (subed-srt--jump-to-subtitle-time-start) :to-equal 3)
+ (expect (looking-at subed-srt--regexp-timestamp) :to-be t)
+ (expect (match-string 0) :to-equal "00:01:01,000")
+ (re-search-forward "\n\n")
+ (expect (subed-srt--jump-to-subtitle-time-start) :to-equal 41)
+ (expect (looking-at subed-srt--regexp-timestamp) :to-be t)
+ (expect (match-string 0) :to-equal "00:02:02,234")
+ (re-search-forward "\n\n")
+ (expect (subed-srt--jump-to-subtitle-time-start) :to-equal 79)
+ (expect (looking-at subed-srt--regexp-timestamp) :to-be t)
+ (expect (match-string 0) :to-equal "00:03:03,45")))
+ (it "returns nil if movement failed."
+ (with-temp-buffer
+ (expect (subed-srt--jump-to-subtitle-time-start) :to-equal nil)))
+ )
+ (describe "to subtitle stop time"
+ (it "returns stop time's point if movement was successful."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-min))
+ (expect (subed-srt--jump-to-subtitle-time-stop) :to-equal 20)
+ (expect (looking-at subed-srt--regexp-timestamp) :to-be t)
+ (expect (match-string 0) :to-equal "00:01:05,123")
+ (re-search-forward "\n\n")
+ (expect (subed-srt--jump-to-subtitle-time-stop) :to-equal 58)
+ (expect (looking-at subed-srt--regexp-timestamp) :to-be t)
+ (expect (match-string 0) :to-equal "00:02:10,345")
+ (re-search-forward "\n\n")
+ (expect (subed-srt--jump-to-subtitle-time-stop) :to-equal 95)
+ (expect (looking-at subed-srt--regexp-timestamp) :to-be t)
+ (expect (match-string 0) :to-equal "00:03:15,5")))
+ (it "returns nil if movement failed."
+ (with-temp-buffer
+ (expect (subed-srt--jump-to-subtitle-time-stop) :to-equal nil)))
+ )
+ (describe "to subtitle text"
+ (it "returns subtitle text's point if movement was successful."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-min))
+ (expect (subed-srt--jump-to-subtitle-text) :to-equal 33)
+ (expect (point) :to-equal (save-excursion (goto-char (point-max))
(search-backward "Foo.")))
+ (re-search-forward "\n\n")
+ (expect (subed-srt--jump-to-subtitle-text) :to-equal 71)
+ (expect (point) :to-equal (save-excursion (goto-char (point-max))
(search-backward "Bar.")))
+ (re-search-forward "\n\n")
+ (expect (subed-srt--jump-to-subtitle-text) :to-equal 106)
+ (expect (point) :to-equal (save-excursion (goto-char (point-max))
(search-backward "Baz.")))))
+ (it "returns nil if movement failed."
+ (with-temp-buffer
+ (expect (subed-srt--jump-to-subtitle-time-stop) :to-equal nil)))
+ )
+ (describe "to end of subtitle text"
+ (it "returns point if subtitle end can be found."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-min))
+ (expect (subed-srt--jump-to-subtitle-end) :to-be 37)
+ (expect (looking-back "^Foo.$") :to-be t)
+ (forward-char 2)
+ (expect (subed-srt--jump-to-subtitle-end) :to-be 75)
+ (expect (looking-back "^Bar.$") :to-be t)
+ (forward-char 2)
+ (expect (subed-srt--jump-to-subtitle-end) :to-be 110)
+ (expect (looking-back "^Baz.$") :to-be t)
+ (goto-char (point-max))
+ (backward-char 2)
+ (expect (subed-srt--jump-to-subtitle-end) :to-be 110)
+ (expect (looking-back "^Baz.$") :to-be t)))
+ (it "returns nil if subtitle end cannot be found."
+ (with-temp-buffer
+ (expect (subed-srt--jump-to-subtitle-end) :to-be nil)))
+ (it "returns nil if point did not move."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 1)
+ (kill-line)
+ (expect (subed-srt--jump-to-subtitle-end) :to-be nil)))
+ (it "works if text is empty with trailing newline."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 1)
+ (kill-line)
+ (backward-char)
+ (expect (subed-srt--jump-to-subtitle-end) :to-be 33)
+ (expect (looking-at "^$") :to-be t)
+ (subed-srt--jump-to-subtitle-text 2)
+ (kill-line)
+ (backward-char)
+ (expect (subed-srt--jump-to-subtitle-end) :to-be 67)
+ (expect (looking-at "^$") :to-be t)
+ (subed-srt--jump-to-subtitle-text 3)
+ (kill-line)
+ (backward-char)
+ (expect (subed-srt--jump-to-subtitle-end) :to-be 98)
+ (expect (looking-at "^$") :to-be t)))
+ (it "works if text is empty without trailing newline."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 1)
+ (kill-whole-line)
+ (expect (subed-srt--jump-to-subtitle-end) :to-be nil)
+ (expect (looking-at "^$") :to-be t)
+ (goto-char (point-min))
+ (expect (subed-srt--jump-to-subtitle-end) :to-be 33)
+ (expect (looking-at "^$") :to-be t)
+ (subed-srt--jump-to-subtitle-text 2)
+ (kill-whole-line)
+ (expect (subed-srt--jump-to-subtitle-end) :to-be nil)
+ (expect (looking-at "^$") :to-be t)
+ (backward-char)
+ (expect (subed-srt--jump-to-subtitle-end) :to-be 66)
+ (expect (looking-at "^$") :to-be t)
+ (subed-srt--jump-to-subtitle-text 3)
+ (kill-whole-line)
+ (expect (subed-srt--jump-to-subtitle-end) :to-be nil)
+ (expect (looking-at "^$") :to-be t)
+ (backward-char)
+ (expect (subed-srt--jump-to-subtitle-end) :to-be 96)
+ (expect (looking-at "^$") :to-be t)))
+ )
+ (describe "to next subtitle ID"
+ (it "returns point when there is a next subtitle."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-id 1)
+ (expect (thing-at-point 'word) :to-equal "1")
+ (expect (subed-srt--forward-subtitle-id) :to-be 39)
+ (expect (thing-at-point 'word) :to-equal "2")
+ (subed-srt--jump-to-subtitle-time-start 2)
+ (expect (thing-at-point 'word) :to-equal "00")
+ (expect (subed-srt--forward-subtitle-id) :to-be 77)
+ (expect (thing-at-point 'word) :to-equal "3")))
+ (it "returns nil and doesn't move when there is no next subtitle."
+ (with-temp-buffer
+ (expect (thing-at-point 'word) :to-equal nil)
+ (expect (subed-srt--forward-subtitle-id) :to-be nil))
+ (with-temp-buffer
+ (insert (concat mock-srt-data))
+ (subed-srt--jump-to-subtitle-text 1)
+ (expect (thing-at-point 'word) :to-equal "Foo")
+ (expect (subed-srt--forward-subtitle-id) :to-be 39)
+ (expect (thing-at-point 'word) :to-equal "2")
+ (subed-srt--jump-to-subtitle-time-stop 2)
+ (expect (thing-at-point 'word) :to-equal "00")
+ (expect (subed-srt--forward-subtitle-id) :to-be 77)
+ (expect (thing-at-point 'word) :to-equal "3"))
+ (with-temp-buffer
+ (insert (concat mock-srt-data))
+ (subed-srt--jump-to-subtitle-text 3)
+ (expect (thing-at-point 'word) :to-equal "Baz")
+ (expect (subed-srt--forward-subtitle-id) :to-be nil)
+ (expect (thing-at-point 'word) :to-equal "Baz"))
+ (with-temp-buffer
+ (insert (concat mock-srt-data "\n\n"))
+ (subed-srt--jump-to-subtitle-time-stop 3)
+ (expect (thing-at-point 'word) :to-equal "00")
+ (expect (subed-srt--forward-subtitle-id) :to-be nil)
+ (expect (thing-at-point 'word) :to-equal "00")))
+ )
+ (describe "to previous subtitle ID"
+ (it "returns point when there is a previous subtitle."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 2)
+ (expect (thing-at-point 'word) :to-equal "Bar")
+ (expect (subed-srt--backward-subtitle-id) :to-be 1)
+ (expect (thing-at-point 'word) :to-equal "1")
+ (subed-srt--jump-to-subtitle-time-stop 3)
+ (expect (thing-at-point 'word) :to-equal "00")
+ (expect (subed-srt--backward-subtitle-id) :to-be 39)
+ (expect (thing-at-point 'word) :to-equal "2")))
+ (it "returns nil and doesn't move when there is no previous subtitle."
+ (with-temp-buffer
+ (expect (subed-srt--backward-subtitle-id) :to-be nil))
+ (with-temp-buffer
+ (insert (concat mock-srt-data))
+ (subed-srt--jump-to-subtitle-id 1)
+ (expect (thing-at-point 'word) :to-equal "1")
+ (expect (subed-srt--backward-subtitle-id) :to-be nil)
+ (expect (thing-at-point 'word) :to-equal "1"))
+ (with-temp-buffer
+ (insert (concat mock-srt-data))
+ (subed-srt--jump-to-subtitle-text 1)
+ (expect (thing-at-point 'word) :to-equal "Foo")
+ (expect (subed-srt--backward-subtitle-id) :to-be nil)
+ (expect (thing-at-point 'word) :to-equal "Foo"))
+ (with-temp-buffer
+ (insert (concat "\n\n\n" mock-srt-data))
+ (subed-srt--jump-to-subtitle-time-stop 1)
+ (expect (thing-at-point 'word) :to-equal "00")
+ (expect (subed-srt--backward-subtitle-id) :to-be nil)
+ (expect (thing-at-point 'word) :to-equal "00")))
+ )
+ (describe "to next subtitle text"
+ (it "returns point when there is a next subtitle."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-id 1)
+ (expect (thing-at-point 'word) :to-equal "1")
+ (expect (subed-srt--forward-subtitle-text) :to-be 71)
+ (expect (thing-at-point 'word) :to-equal "Bar")))
+ (it "returns nil and doesn't move when there is no next subtitle."
+ (with-temp-buffer
+ (goto-char (point-max))
+ (insert (concat mock-srt-data "\n\n"))
+ (subed-srt--jump-to-subtitle-id 3)
+ (expect (thing-at-point 'word) :to-equal "3")
+ (expect (subed-srt--forward-subtitle-text) :to-be nil)
+ (expect (thing-at-point 'word) :to-equal "3")))
+ )
+ (describe "to previous subtitle text"
+ (it "returns point when there is a previous subtitle."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-id 3)
+ (expect (thing-at-point 'word) :to-equal "3")
+ (expect (subed-srt--backward-subtitle-text) :to-be 71)
+ (expect (thing-at-point 'word) :to-equal "Bar")))
+ (it "returns nil and doesn't move when there is no previous subtitle."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-min))
+ (expect (thing-at-point 'word) :to-equal "1")
+ (expect (subed-srt--backward-subtitle-text) :to-be nil)
+ (expect (thing-at-point 'word) :to-equal "1")))
+ )
+ (describe "to next subtitle end"
+ (it "returns point when there is a next subtitle."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 2)
+ (expect (thing-at-point 'word) :to-equal "Bar")
+ (expect (subed-srt--forward-subtitle-end) :to-be 110)
+ (expect (thing-at-point 'word) :to-equal nil)))
+ (it "returns nil and doesn't move when there is no next subtitle."
+ (with-temp-buffer
+ (insert (concat mock-srt-data "\n\n"))
+ (subed-srt--jump-to-subtitle-text 3)
+ (end-of-line)
+ (expect (thing-at-point 'word) :to-equal nil)
+ (expect (subed-srt--forward-subtitle-end) :to-be nil)
+ (expect (thing-at-point 'word) :to-equal nil)))
+ )
+ (describe "to previous subtitle end"
+ (it "returns point when there is a previous subtitle."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-id 3)
+ (expect (thing-at-point 'word) :to-equal "3")
+ (expect (subed-srt--backward-subtitle-text) :to-be 71)
+ (expect (thing-at-point 'word) :to-equal "Bar")))
+ (it "returns nil and doesn't move when there is no previous subtitle."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-min))
+ (expect (thing-at-point 'word) :to-equal "1")
+ (expect (subed-srt--backward-subtitle-text) :to-be nil)
+ (expect (thing-at-point 'word) :to-equal "1")))
+ )
+ (describe "to next subtitle start time"
+ (it "returns point when there is a next subtitle."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 1)
+ (expect (thing-at-point 'word) :to-equal "Foo")
+ (expect (subed-srt--forward-subtitle-time-start) :to-be 41)
+ (expect (thing-at-point 'word) :to-equal "00")))
+ (it "returns nil and doesn't move when there is no next subtitle."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-id 3)
+ (expect (thing-at-point 'word) :to-equal "3")
+ (expect (subed-srt--forward-subtitle-time-start) :to-be nil)
+ (expect (thing-at-point 'word) :to-equal "3")))
+ )
+ (describe "to previous subtitle start time"
+ (it "returns point when there is a previous subtitle."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-id 2)
+ (expect (thing-at-point 'word) :to-equal "2")
+ (expect (subed-srt--backward-subtitle-time-start) :to-be 3)
+ (expect (thing-at-point 'word) :to-equal "00")))
+ (it "returns nil and doesn't move when there is no previous subtitle."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-id 1)
+ (expect (thing-at-point 'word) :to-equal "1")
+ (expect (subed-srt--backward-subtitle-time-start) :to-be nil)
+ (expect (thing-at-point 'word) :to-equal "1")))
+ )
+ (describe "to next subtitle stop time"
+ (it "returns point when there is a next subtitle."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 1)
+ (expect (thing-at-point 'word) :to-equal "Foo")
+ (expect (subed-srt--forward-subtitle-time-stop) :to-be 58)
+ (expect (thing-at-point 'word) :to-equal "00")))
+ (it "returns nil and doesn't move when there is no next subtitle."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-id 3)
+ (expect (thing-at-point 'word) :to-equal "3")
+ (expect (subed-srt--forward-subtitle-time-stop) :to-be nil)
+ (expect (thing-at-point 'word) :to-equal "3")))
+ )
+ (describe "to previous subtitle stop time"
+ (it "returns point when there is a previous subtitle."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-id 3)
+ (expect (thing-at-point 'word) :to-equal "3")
+ (expect (subed-srt--backward-subtitle-time-stop) :to-be 58)
+ (expect (thing-at-point 'word) :to-equal "00")))
+ (it "returns nil and doesn't move when there is no previous subtitle."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-id 1)
+ (expect (thing-at-point 'word) :to-equal "1")
+ (expect (subed-srt--backward-subtitle-time-stop) :to-be nil)
+ (expect (thing-at-point 'word) :to-equal "1")))
+ )
+ )
(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)
- (add-hook 'subed-subtitle-time-adjusted-hook 'foo)
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-id 1)
- (subed-srt--adjust-subtitle-start 100)
- (expect 'foo :to-have-been-called-with 61100)
- (expect 'foo :to-have-been-called-times 1)
- (subed-srt--adjust-subtitle-stop 123)
- (expect 'foo :to-have-been-called-with 61100)
- (expect 'foo :to-have-been-called-times 2)
- (subed-srt--jump-to-subtitle-id 2)
- (subed-srt--adjust-subtitle-start 6)
- (expect 'foo :to-have-been-called-with 122240)
- (expect 'foo :to-have-been-called-times 3)
- (subed-srt--adjust-subtitle-stop 123)
- (expect 'foo :to-have-been-called-with 122240)
- (expect 'foo :to-have-been-called-times 4))
- (remove-hook 'subed-subtitle-time-adjusted-hook 'foo)))
- (it "adjusts the start/stop time."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-id 1)
- (expect (subed-srt--adjust-subtitle-start 100) :to-equal 100)
- (expect (save-excursion
(subed-srt--jump-to-subtitle-time-start)
- (thing-at-point 'line)) :to-equal
"00:01:01,100 --> 00:01:05,123\n")
- (expect (subed-srt--adjust-subtitle-start -200) :to-equal -200)
- (expect (save-excursion
(subed-srt--jump-to-subtitle-time-start)
- (thing-at-point 'line)) :to-equal
"00:01:00,900 --> 00:01:05,123\n")
- (expect (subed-srt--adjust-subtitle-stop 200) :to-equal 200)
- (expect (save-excursion
(subed-srt--jump-to-subtitle-time-start)
- (thing-at-point 'line)) :to-equal
"00:01:00,900 --> 00:01:05,323\n")
- (expect (subed-srt--adjust-subtitle-stop -100) :to-equal -100)
- (expect (save-excursion
(subed-srt--jump-to-subtitle-time-start)
- (thing-at-point 'line)) :to-equal
"00:01:00,900 --> 00:01:05,223\n")))
- (it "adjusts the start/stop time if milliseconds lack digits."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-id 3)
- (expect (subed-srt--adjust-subtitle-start 200) :to-equal 200)
- (expect (subed-srt--adjust-subtitle-start -100) :to-equal -100)
- (expect (save-excursion
(subed-srt--jump-to-subtitle-time-start)
- (thing-at-point 'line)) :to-equal
"00:03:03,550 --> 00:03:15,5\n")
- (expect (subed-srt--adjust-subtitle-stop 100) :to-equal 100)
- (expect (subed-srt--adjust-subtitle-stop -200) :to-equal -200)
- (expect (save-excursion (subed-srt--jump-to-subtitle-time-stop)
- (thing-at-point 'line)) :to-equal
"00:03:03,550 --> 00:03:15,400\n")))
- (describe "enforces limits"
- (describe "when decreasing start time"
- (it "of the first subtitle."
- (with-temp-buffer
- (insert (concat "1\n"
- "00:00:01,000 -->
00:00:02,000\n"
- "Foo.\n"))
- (expect (subed-srt--adjust-subtitle-start
-999) :to-be -999)
- (expect (subed-srt--subtitle-msecs-start)
:to-be 1)
- (expect (subed-srt--adjust-subtitle-start
-1) :to-be -1)
- (expect (subed-srt--subtitle-msecs-start)
:to-be 0)
- (expect (subed-srt--adjust-subtitle-start
-1) :to-be nil)
- (expect (subed-srt--subtitle-msecs-start)
:to-be 0)))
- (it "of a non-first subtitle."
- (with-temp-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-srt--jump-to-subtitle-id 2)
- (expect (subed-srt--adjust-subtitle-start
-899) :to-be -899)
- (expect (subed-srt--subtitle-msecs-start)
:to-be 2101)
- (expect (subed-srt--adjust-subtitle-start
-1) :to-be -1)
- (expect (subed-srt--subtitle-msecs-start)
:to-be 2100)
- (expect (subed-srt--adjust-subtitle-start
-1) :to-be nil)
- (expect (subed-srt--subtitle-msecs-start)
:to-be 2100)))
- )
- (it "when increasing start time."
- (with-temp-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"))
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-id 2)
- (expect (subed-srt--adjust-subtitle-start 999)
:to-be 999)
- (expect (subed-srt--subtitle-msecs-start) :to-be
3999)
- (expect (subed-srt--adjust-subtitle-start 1) :to-be
1)
- (expect (subed-srt--subtitle-msecs-start) :to-be
4000)
- (expect (subed-srt--adjust-subtitle-start 1) :to-be
nil)
- (expect (subed-srt--subtitle-msecs-start) :to-be
4000)))
- (it "when decreasing stop time."
- (with-temp-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-srt--jump-to-subtitle-id 2)
- (expect (subed-srt--adjust-subtitle-stop -999)
:to-be -999)
- (expect (subed-srt--subtitle-msecs-stop) :to-be 3001)
- (expect (subed-srt--adjust-subtitle-stop -1) :to-be
-1)
- (expect (subed-srt--subtitle-msecs-stop) :to-be 3000)
- (expect (subed-srt--adjust-subtitle-stop -1) :to-be
nil)
- (expect (subed-srt--subtitle-msecs-stop) :to-be
3000)))
- (describe "when increasing stop time"
- (it "of the last subtitle."
- (with-temp-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-srt--jump-to-subtitle-id 3)
- (expect (subed-srt--adjust-subtitle-stop
1000000):to-be 1000000)
- (expect (subed-srt--subtitle-msecs-stop)
:to-be 1004000)))
- (it "of a non-last subtitle."
- (with-temp-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-srt--jump-to-subtitle-id 1)
- (expect (subed-srt--adjust-subtitle-stop
899) :to-be 899)
- (expect (subed-srt--subtitle-msecs-stop)
:to-be 2899)
- (expect (subed-srt--adjust-subtitle-stop
1) :to-be 1)
- (expect (subed-srt--subtitle-msecs-stop)
:to-be 2900)
- (expect (subed-srt--adjust-subtitle-stop
1) :to-be nil)
- (expect (subed-srt--subtitle-msecs-stop)
:to-be 2900)))
- )
- (it "without undershooting the target time."
- (with-temp-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-srt--adjust-subtitle-stop 1) :to-be
nil)
- (expect (subed-subtitle-msecs-stop) :to-equal 2000)))
- (it "without overshooting the target time."
- (with-temp-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-srt--adjust-subtitle-start -1) :to-be
nil)
- (expect (subed-subtitle-msecs-start) :to-equal
2000)))
- )
- (describe "ignores negative duration if the first argument is truthy"
- (it "when adjusting start time."
- (with-temp-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"))
- (expect (subed-srt--adjust-subtitle-start 2000 t)
:to-be 2000)
- (expect (subed-srt--subtitle-msecs-start) :to-be
3000)
- (expect (subed-srt--subtitle-msecs-stop) :to-be 2000)
- (expect (subed-srt--adjust-subtitle-start -500 t)
:to-be -500)
- (expect (subed-srt--subtitle-msecs-start) :to-be
2500)
- (expect (subed-srt--subtitle-msecs-stop) :to-be
2000)))
- (it "when adjusting stop time."
- (with-temp-buffer
- (insert (concat "1\n"
- "00:00:01,000 --> 00:00:02,000\n"
- "Foo.\n\n"))
- (expect (subed-srt--adjust-subtitle-stop -1500 t)
:to-be -1500)
- (expect (subed-srt--subtitle-msecs-stop) :to-be 500)
- (expect (subed-srt--subtitle-msecs-start) :to-be
1000)
- (expect (subed-srt--adjust-subtitle-stop 200 t)
:to-be 200)
- (expect (subed-srt--subtitle-msecs-stop) :to-be 700)
- (expect (subed-srt--subtitle-msecs-start) :to-be
1000)))
- )
- (describe "ignores subtitle spacing if the second argument is truthy"
- (it "when adjusting start time."
- (with-temp-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-srt--jump-to-subtitle-id 2)
- (expect (subed-srt--adjust-subtitle-start -150 nil
t) :to-be -150)
- (expect (subed-srt--subtitle-msecs-start 2) :to-be
2050)
- (expect (subed-srt--subtitle-msecs-stop 1) :to-be
2000)
- (expect (subed-srt--adjust-subtitle-start -51 nil t)
:to-be -51)
- (expect (subed-srt--subtitle-msecs-start 2) :to-be
1999)
- (expect (subed-srt--subtitle-msecs-stop 1) :to-be
2000)))
- (it "when adjusting stop time."
- (with-temp-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-srt--jump-to-subtitle-id 1)
- (expect (subed-srt--adjust-subtitle-stop 150 nil t)
:to-be 150)
- (expect (subed-srt--subtitle-msecs-stop 1) :to-be
2150)
- (expect (subed-srt--subtitle-msecs-start 2) :to-be
2200)
- (expect (subed-srt--adjust-subtitle-stop 51 nil t)
:to-be 51)
- (expect (subed-srt--subtitle-msecs-stop 1) :to-be
2201)
- (expect (subed-srt--subtitle-msecs-start 2) :to-be
2200)))
- )
- (it "does nothing if no timestamp can be found."
- (with-temp-buffer
- (insert "foo")
- (goto-char (point-min))
- (expect (subed-srt--adjust-subtitle-start 123) :to-be nil)
- (expect (buffer-string) :to-equal "foo")
- (expect (subed-srt--adjust-subtitle-start -123) :to-be nil)
- (expect (buffer-string) :to-equal "foo")))
- )
+ :var (subed-subtitle-time-adjusted-hook)
+ (it "runs the appropriate hook."
+ (let ((foo (setf (symbol-function 'foo) (lambda (msecs) ()))))
+ (spy-on 'foo)
+ (add-hook 'subed-subtitle-time-adjusted-hook 'foo)
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-id 1)
+ (subed-srt--adjust-subtitle-start 100)
+ (expect 'foo :to-have-been-called-with 61100)
+ (expect 'foo :to-have-been-called-times 1)
+ (subed-srt--adjust-subtitle-stop 123)
+ (expect 'foo :to-have-been-called-with 61100)
+ (expect 'foo :to-have-been-called-times 2)
+ (subed-srt--jump-to-subtitle-id 2)
+ (subed-srt--adjust-subtitle-start 6)
+ (expect 'foo :to-have-been-called-with 122240)
+ (expect 'foo :to-have-been-called-times 3)
+ (subed-srt--adjust-subtitle-stop 123)
+ (expect 'foo :to-have-been-called-with 122240)
+ (expect 'foo :to-have-been-called-times 4))
+ (remove-hook 'subed-subtitle-time-adjusted-hook 'foo)))
+ (it "adjusts the start/stop time."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-id 1)
+ (expect (subed-srt--adjust-subtitle-start 100) :to-equal 100)
+ (expect (save-excursion (subed-srt--jump-to-subtitle-time-start)
+ (thing-at-point 'line)) :to-equal "00:01:01,100
--> 00:01:05,123\n")
+ (expect (subed-srt--adjust-subtitle-start -200) :to-equal -200)
+ (expect (save-excursion (subed-srt--jump-to-subtitle-time-start)
+ (thing-at-point 'line)) :to-equal "00:01:00,900
--> 00:01:05,123\n")
+ (expect (subed-srt--adjust-subtitle-stop 200) :to-equal 200)
+ (expect (save-excursion (subed-srt--jump-to-subtitle-time-start)
+ (thing-at-point 'line)) :to-equal "00:01:00,900
--> 00:01:05,323\n")
+ (expect (subed-srt--adjust-subtitle-stop -100) :to-equal -100)
+ (expect (save-excursion (subed-srt--jump-to-subtitle-time-start)
+ (thing-at-point 'line)) :to-equal "00:01:00,900
--> 00:01:05,223\n")))
+ (it "adjusts the start/stop time if milliseconds lack digits."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-id 3)
+ (expect (subed-srt--adjust-subtitle-start 200) :to-equal 200)
+ (expect (subed-srt--adjust-subtitle-start -100) :to-equal -100)
+ (expect (save-excursion (subed-srt--jump-to-subtitle-time-start)
+ (thing-at-point 'line)) :to-equal "00:03:03,550
--> 00:03:15,5\n")
+ (expect (subed-srt--adjust-subtitle-stop 100) :to-equal 100)
+ (expect (subed-srt--adjust-subtitle-stop -200) :to-equal -200)
+ (expect (save-excursion (subed-srt--jump-to-subtitle-time-stop)
+ (thing-at-point 'line)) :to-equal "00:03:03,550
--> 00:03:15,400\n")))
+ (describe "enforces limits"
+ (describe "when decreasing start time"
+ (it "of the first subtitle."
+ (with-temp-buffer
+ (insert (concat "1\n"
+ "00:00:01,000 --> 00:00:02,000\n"
+ "Foo.\n"))
+ (expect (subed-srt--adjust-subtitle-start -999) :to-be -999)
+ (expect (subed-srt--subtitle-msecs-start) :to-be 1)
+ (expect (subed-srt--adjust-subtitle-start -1) :to-be -1)
+ (expect (subed-srt--subtitle-msecs-start) :to-be 0)
+ (expect (subed-srt--adjust-subtitle-start -1) :to-be nil)
+ (expect (subed-srt--subtitle-msecs-start) :to-be 0)))
+ (it "of a non-first subtitle."
+ (with-temp-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-srt--jump-to-subtitle-id 2)
+ (expect (subed-srt--adjust-subtitle-start -899) :to-be -899)
+ (expect (subed-srt--subtitle-msecs-start) :to-be 2101)
+ (expect (subed-srt--adjust-subtitle-start -1) :to-be -1)
+ (expect (subed-srt--subtitle-msecs-start) :to-be 2100)
+ (expect (subed-srt--adjust-subtitle-start -1) :to-be nil)
+ (expect (subed-srt--subtitle-msecs-start) :to-be 2100)))
+ )
+ (it "when increasing start time."
+ (with-temp-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"))
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-id 2)
+ (expect (subed-srt--adjust-subtitle-start 999) :to-be 999)
+ (expect (subed-srt--subtitle-msecs-start) :to-be 3999)
+ (expect (subed-srt--adjust-subtitle-start 1) :to-be 1)
+ (expect (subed-srt--subtitle-msecs-start) :to-be 4000)
+ (expect (subed-srt--adjust-subtitle-start 1) :to-be nil)
+ (expect (subed-srt--subtitle-msecs-start) :to-be 4000)))
+ (it "when decreasing stop time."
+ (with-temp-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-srt--jump-to-subtitle-id 2)
+ (expect (subed-srt--adjust-subtitle-stop -999) :to-be -999)
+ (expect (subed-srt--subtitle-msecs-stop) :to-be 3001)
+ (expect (subed-srt--adjust-subtitle-stop -1) :to-be -1)
+ (expect (subed-srt--subtitle-msecs-stop) :to-be 3000)
+ (expect (subed-srt--adjust-subtitle-stop -1) :to-be nil)
+ (expect (subed-srt--subtitle-msecs-stop) :to-be 3000)))
+ (describe "when increasing stop time"
+ (it "of the last subtitle."
+ (with-temp-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-srt--jump-to-subtitle-id 3)
+ (expect (subed-srt--adjust-subtitle-stop 1000000):to-be 1000000)
+ (expect (subed-srt--subtitle-msecs-stop) :to-be 1004000)))
+ (it "of a non-last subtitle."
+ (with-temp-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-srt--jump-to-subtitle-id 1)
+ (expect (subed-srt--adjust-subtitle-stop 899) :to-be 899)
+ (expect (subed-srt--subtitle-msecs-stop) :to-be 2899)
+ (expect (subed-srt--adjust-subtitle-stop 1) :to-be 1)
+ (expect (subed-srt--subtitle-msecs-stop) :to-be 2900)
+ (expect (subed-srt--adjust-subtitle-stop 1) :to-be nil)
+ (expect (subed-srt--subtitle-msecs-stop) :to-be 2900)))
+ )
+ (it "without undershooting the target time."
+ (with-temp-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-srt--adjust-subtitle-stop 1) :to-be nil)
+ (expect (subed-subtitle-msecs-stop) :to-equal 2000)))
+ (it "without overshooting the target time."
+ (with-temp-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-srt--adjust-subtitle-start -1) :to-be nil)
+ (expect (subed-subtitle-msecs-start) :to-equal 2000)))
+ )
+ (describe "ignores negative duration if the first argument is truthy"
+ (it "when adjusting start time."
+ (with-temp-buffer
+ (insert (concat "1\n"
+ "00:00:01,000 --> 00:00:02,000\n"
+ "Foo.\n\n"))
+ (expect (subed-srt--adjust-subtitle-start 2000 t) :to-be 2000)
+ (expect (subed-srt--subtitle-msecs-start) :to-be 3000)
+ (expect (subed-srt--subtitle-msecs-stop) :to-be 2000)
+ (expect (subed-srt--adjust-subtitle-start -500 t) :to-be -500)
+ (expect (subed-srt--subtitle-msecs-start) :to-be 2500)
+ (expect (subed-srt--subtitle-msecs-stop) :to-be 2000)))
+ (it "when adjusting stop time."
+ (with-temp-buffer
+ (insert (concat "1\n"
+ "00:00:01,000 --> 00:00:02,000\n"
+ "Foo.\n\n"))
+ (expect (subed-srt--adjust-subtitle-stop -1500 t) :to-be -1500)
+ (expect (subed-srt--subtitle-msecs-stop) :to-be 500)
+ (expect (subed-srt--subtitle-msecs-start) :to-be 1000)
+ (expect (subed-srt--adjust-subtitle-stop 200 t) :to-be 200)
+ (expect (subed-srt--subtitle-msecs-stop) :to-be 700)
+ (expect (subed-srt--subtitle-msecs-start) :to-be 1000)))
+ )
+ (describe "ignores subtitle spacing if the second argument is truthy"
+ (it "when adjusting start time."
+ (with-temp-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-srt--jump-to-subtitle-id 2)
+ (expect (subed-srt--adjust-subtitle-start -150 nil t) :to-be -150)
+ (expect (subed-srt--subtitle-msecs-start 2) :to-be 2050)
+ (expect (subed-srt--subtitle-msecs-stop 1) :to-be 2000)
+ (expect (subed-srt--adjust-subtitle-start -51 nil t) :to-be -51)
+ (expect (subed-srt--subtitle-msecs-start 2) :to-be 1999)
+ (expect (subed-srt--subtitle-msecs-stop 1) :to-be 2000)))
+ (it "when adjusting stop time."
+ (with-temp-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-srt--jump-to-subtitle-id 1)
+ (expect (subed-srt--adjust-subtitle-stop 150 nil t) :to-be 150)
+ (expect (subed-srt--subtitle-msecs-stop 1) :to-be 2150)
+ (expect (subed-srt--subtitle-msecs-start 2) :to-be 2200)
+ (expect (subed-srt--adjust-subtitle-stop 51 nil t) :to-be 51)
+ (expect (subed-srt--subtitle-msecs-stop 1) :to-be 2201)
+ (expect (subed-srt--subtitle-msecs-start 2) :to-be 2200)))
+ )
+ (it "does nothing if no timestamp can be found."
+ (with-temp-buffer
+ (insert "foo")
+ (goto-char (point-min))
+ (expect (subed-srt--adjust-subtitle-start 123) :to-be nil)
+ (expect (buffer-string) :to-equal "foo")
+ (expect (subed-srt--adjust-subtitle-start -123) :to-be nil)
+ (expect (buffer-string) :to-equal "foo")))
+ )
(describe "Killing a subtitle"
- (it "removes it when it is the first one."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 1)
- (subed-srt--subtitle-kill)
- (expect (buffer-string) :to-equal (concat "2\n"
- "00:02:02,234 -->
00:02:10,345\n"
- "Bar.\n"
- "\n"
- "3\n"
- "00:03:03,45 -->
00:03:15,5\n"
- "Baz.\n"))))
- (it "removes it when it is in the middle."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 2)
- (subed-srt--subtitle-kill)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:01:01,000 -->
00:01:05,123\n"
- "Foo.\n"
- "\n"
- "3\n"
- "00:03:03,45 -->
00:03:15,5\n"
- "Baz.\n"))))
- (it "removes it when it is the last one."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 3)
- (subed-srt--subtitle-kill)
- (expect (buffer-string) :to-equal (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"))))
- (it "removes the previous subtitle when point is right above an ID."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-id 3)
- (backward-char)
- (expect (looking-at "^\n3\n") :to-be t)
- (subed-srt--subtitle-kill)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:01:01,000 -->
00:01:05,123\n"
- "Foo.\n"
- "\n"
- "3\n"
- "00:03:03,45 -->
00:03:15,5\n"
- "Baz.\n"))))
- )
+ (it "removes it when it is the first one."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 1)
+ (subed-srt--subtitle-kill)
+ (expect (buffer-string) :to-equal (concat "2\n"
+ "00:02:02,234 -->
00:02:10,345\n"
+ "Bar.\n"
+ "\n"
+ "3\n"
+ "00:03:03,45 --> 00:03:15,5\n"
+ "Baz.\n"))))
+ (it "removes it when it is in the middle."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 2)
+ (subed-srt--subtitle-kill)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:01:01,000 -->
00:01:05,123\n"
+ "Foo.\n"
+ "\n"
+ "3\n"
+ "00:03:03,45 --> 00:03:15,5\n"
+ "Baz.\n"))))
+ (it "removes it when it is the last one."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 3)
+ (subed-srt--subtitle-kill)
+ (expect (buffer-string) :to-equal (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"))))
+ (it "removes the previous subtitle when point is right above an ID."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-id 3)
+ (backward-char)
+ (expect (looking-at "^\n3\n") :to-be t)
+ (subed-srt--subtitle-kill)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:01:01,000 -->
00:01:05,123\n"
+ "Foo.\n"
+ "\n"
+ "3\n"
+ "00:03:03,45 --> 00:03:15,5\n"
+ "Baz.\n"))))
+ )
(describe "Inserting"
- (before-each
- (spy-on 'subed-srt--regenerate-ids-soon))
- (describe "in an empty buffer,"
- (describe "appending"
- (it "a single subtile."
- (cl-loop for arg in (list nil 1) do
- (with-temp-buffer
- (subed-srt--subtitle-insert arg)
- (expect (buffer-string) :to-equal
(concat "0\n"
-
"00:00:00,100 --> 00:00:00,900\n\n"))
- (expect (point) :to-equal 33))))
- (it "multiple subtiles."
- (cl-loop for arg in (list 2) do
- (with-temp-buffer
- (subed-srt--subtitle-insert arg)
- (expect (buffer-string) :to-equal
(concat "0\n"
-
"00:00:00,100 --> 00:00:00,950\n\n\n"
-
"0\n"
-
"00:00:01,050 --> 00:00:01,900\n\n"))
- (expect (point) :to-equal 33)))))
- (describe "prepending"
- (it "a single subtile."
- (cl-loop for arg in (list '- -1 (list 4)) do
- (with-temp-buffer
- (subed-srt--subtitle-insert arg)
- (expect (buffer-string) :to-equal
(concat "0\n"
-
"00:00:00,100 --> 00:00:00,900\n\n"))
- (expect (point) :to-equal 33))))
- (it "multiple subtiles."
- (cl-loop for arg in (list -2 (list -16)) do
- (with-temp-buffer
- (subed-srt--subtitle-insert arg)
- (expect (buffer-string) :to-equal
(concat "0\n"
-
"00:00:00,100 --> 00:00:00,950\n\n\n"
-
"0\n"
-
"00:00:01,050 --> 00:00:01,900\n\n"))
- (expect (point) :to-equal 33)))))
- )
- (describe "in a non-empty buffer"
- (describe "before the current subtitle"
- (it "a single subtitle."
- (cl-loop for arg in (list '- -1 (list 4)) do
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text
2)
- (subed-srt--subtitle-insert arg)
- (expect (buffer-string) :to-equal
(concat "1\n"
-
"00:01:01,000 --> 00:01:05,123\n"
-
"Foo.\n\n"
-
"0\n"
-
"00:01:05,223 --> 00:02:02,134\n"
-
"\n\n"
-
"2\n"
-
"00:02:02,234 --> 00:02:10,345\n"
-
"Bar.\n\n"
-
"3\n"
-
"00:03:03,45 --> 00:03:15,5\n"
-
"Baz.\n"))
- (expect (point) :to-equal 71))))
- (it "multiple subtitles."
- (cl-loop for arg in (list -2 (list 16)) do
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text
2)
- (subed-srt--subtitle-insert arg)
- (expect (buffer-string) :to-equal
(concat "1\n"
-
"00:01:01,000 --> 00:01:05,123\n"
-
"Foo.\n\n"
-
"0\n"
-
"00:01:05,223 --> 00:01:33,628\n"
-
"\n\n"
-
"0\n"
-
"00:01:33,728 --> 00:02:02,133\n"
-
"\n\n"
-
"2\n"
-
"00:02:02,234 --> 00:02:10,345\n"
-
"Bar.\n\n"
-
"3\n"
-
"00:03:03,45 --> 00:03:15,5\n"
-
"Baz.\n"))
- (expect (point) :to-equal 71))))
- )
- (describe "after the current subtitle"
- (it "a single subtitle."
- (cl-loop for arg in (list nil 1) do
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text
1)
- (subed-srt--subtitle-insert arg)
- (expect (buffer-string) :to-equal
(concat "1\n"
-
"00:01:01,000 --> 00:01:05,123\n"
-
"Foo.\n\n"
-
"0\n"
-
"00:01:05,223 --> 00:02:02,134\n"
-
"\n\n"
-
"2\n"
-
"00:02:02,234 --> 00:02:10,345\n"
-
"Bar.\n\n"
-
"3\n"
-
"00:03:03,45 --> 00:03:15,5\n"
-
"Baz.\n"))
- (expect (point) :to-equal 71))))
- (it "multiple subtitles."
- (cl-loop for arg in (list 2) do
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text
1)
- (subed-srt--subtitle-insert arg)
- (expect (buffer-string) :to-equal
(concat "1\n"
-
"00:01:01,000 --> 00:01:05,123\n"
-
"Foo.\n\n"
-
"0\n"
-
"00:01:05,223 --> 00:01:33,628\n"
-
"\n\n"
-
"0\n"
-
"00:01:33,728 --> 00:02:02,133\n"
-
"\n\n"
-
"2\n"
-
"00:02:02,234 --> 00:02:10,345\n"
-
"Bar.\n\n"
-
"3\n"
-
"00:03:03,45 --> 00:03:15,5\n"
-
"Baz.\n"))
- (expect (point) :to-equal 71))))
- )
- (describe "before the first subtitle"
- (it "a single subtitle."
- (cl-loop for arg in (list '- -1 (list 4)) do
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text
1)
- (subed-srt--subtitle-insert arg)
- (expect (buffer-string) :to-equal
(concat "0\n"
-
"00:00:00,100 --> 00:01:00,900\n"
-
"\n\n"
-
"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\n"
-
"3\n"
-
"00:03:03,45 --> 00:03:15,5\n"
-
"Baz.\n"))
- (expect (point) :to-equal 33))))
- (it "multiple subtitles."
- (cl-loop for arg in (list -2 (list 16)) do
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text
1)
- (subed-srt--subtitle-insert arg)
- (expect (buffer-string) :to-equal
(concat "0\n"
-
"00:00:00,100 --> 00:00:30,450\n"
-
"\n\n"
-
"0\n"
-
"00:00:30,550 --> 00:01:00,900\n"
-
"\n\n"
-
"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\n"
-
"3\n"
-
"00:03:03,45 --> 00:03:15,5\n"
-
"Baz.\n"))
- (expect (point) :to-equal 33))))
- )
- (describe "after the last subtitle"
- (it "a single subtitle."
- (cl-loop for arg in (list nil 1) do
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text
3)
- (subed-srt--subtitle-insert arg)
- (expect (buffer-string) :to-equal
(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\n"
-
"3\n"
-
"00:03:03,45 --> 00:03:15,5\n"
-
"Baz.\n\n"
-
"0\n"
-
"00:03:15,600 --> 00:03:16,400\n"
-
"\n"))
- (expect (point) :to-equal 144))))
- (it "multiple subtitles."
- (cl-loop for arg in (list 2) do
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text
3)
- (subed-srt--subtitle-insert arg)
- (expect (buffer-string) :to-equal
(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\n"
-
"3\n"
-
"00:03:03,45 --> 00:03:15,5\n"
-
"Baz.\n\n"
-
"0\n"
-
"00:03:15,600 --> 00:03:16,450\n"
-
"\n\n"
-
"0\n"
-
"00:03:16,550 --> 00:03:17,400\n"
-
"\n"))
- (expect (point) :to-equal 144))))
- )
- )
- (it "schedules ID regeneration."
- (with-temp-buffer
- (subed-srt--subtitle-insert)
- (expect #'subed-srt--regenerate-ids-soon
:to-have-been-called-times 1)
- (expect #'subed-srt--regenerate-ids :not
:to-have-been-called)))
- )
+ (before-each
+ (spy-on 'subed-srt--regenerate-ids-soon))
+ (describe "in an empty buffer,"
+ (describe "appending"
+ (it "a single subtile."
+ (cl-loop for arg in (list nil 1) do
+ (with-temp-buffer
+ (subed-srt--subtitle-insert arg)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:00,100 -->
00:00:00,900\n\n"))
+ (expect (point) :to-equal 33))))
+ (it "multiple subtiles."
+ (cl-loop for arg in (list 2) do
+ (with-temp-buffer
+ (subed-srt--subtitle-insert arg)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:00,100 -->
00:00:00,950\n\n\n"
+ "0\n"
+ "00:00:01,050 -->
00:00:01,900\n\n"))
+ (expect (point) :to-equal 33)))))
+ (describe "prepending"
+ (it "a single subtile."
+ (cl-loop for arg in (list '- -1 (list 4)) do
+ (with-temp-buffer
+ (subed-srt--subtitle-insert arg)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:00,100 -->
00:00:00,900\n\n"))
+ (expect (point) :to-equal 33))))
+ (it "multiple subtiles."
+ (cl-loop for arg in (list -2 (list -16)) do
+ (with-temp-buffer
+ (subed-srt--subtitle-insert arg)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:00,100 -->
00:00:00,950\n\n\n"
+ "0\n"
+ "00:00:01,050 -->
00:00:01,900\n\n"))
+ (expect (point) :to-equal 33)))))
+ )
+ (describe "in a non-empty buffer"
+ (describe "before the current subtitle"
+ (it "a single subtitle."
+ (cl-loop for arg in (list '- -1 (list 4)) do
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 2)
+ (subed-srt--subtitle-insert arg)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:01:01,000 -->
00:01:05,123\n"
+ "Foo.\n\n"
+ "0\n"
+ "00:01:05,223 -->
00:02:02,134\n"
+ "\n\n"
+ "2\n"
+ "00:02:02,234 -->
00:02:10,345\n"
+ "Bar.\n\n"
+ "3\n"
+ "00:03:03,45 -->
00:03:15,5\n"
+ "Baz.\n"))
+ (expect (point) :to-equal 71))))
+ (it "multiple subtitles."
+ (cl-loop for arg in (list -2 (list 16)) do
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 2)
+ (subed-srt--subtitle-insert arg)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:01:01,000 -->
00:01:05,123\n"
+ "Foo.\n\n"
+ "0\n"
+ "00:01:05,223 -->
00:01:33,628\n"
+ "\n\n"
+ "0\n"
+ "00:01:33,728 -->
00:02:02,133\n"
+ "\n\n"
+ "2\n"
+ "00:02:02,234 -->
00:02:10,345\n"
+ "Bar.\n\n"
+ "3\n"
+ "00:03:03,45 -->
00:03:15,5\n"
+ "Baz.\n"))
+ (expect (point) :to-equal 71))))
+ )
+ (describe "after the current subtitle"
+ (it "a single subtitle."
+ (cl-loop for arg in (list nil 1) do
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 1)
+ (subed-srt--subtitle-insert arg)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:01:01,000 -->
00:01:05,123\n"
+ "Foo.\n\n"
+ "0\n"
+ "00:01:05,223 -->
00:02:02,134\n"
+ "\n\n"
+ "2\n"
+ "00:02:02,234 -->
00:02:10,345\n"
+ "Bar.\n\n"
+ "3\n"
+ "00:03:03,45 -->
00:03:15,5\n"
+ "Baz.\n"))
+ (expect (point) :to-equal 71))))
+ (it "multiple subtitles."
+ (cl-loop for arg in (list 2) do
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 1)
+ (subed-srt--subtitle-insert arg)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:01:01,000 -->
00:01:05,123\n"
+ "Foo.\n\n"
+ "0\n"
+ "00:01:05,223 -->
00:01:33,628\n"
+ "\n\n"
+ "0\n"
+ "00:01:33,728 -->
00:02:02,133\n"
+ "\n\n"
+ "2\n"
+ "00:02:02,234 -->
00:02:10,345\n"
+ "Bar.\n\n"
+ "3\n"
+ "00:03:03,45 -->
00:03:15,5\n"
+ "Baz.\n"))
+ (expect (point) :to-equal 71))))
+ )
+ (describe "before the first subtitle"
+ (it "a single subtitle."
+ (cl-loop for arg in (list '- -1 (list 4)) do
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 1)
+ (subed-srt--subtitle-insert arg)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:00,100 -->
00:01:00,900\n"
+ "\n\n"
+ "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\n"
+ "3\n"
+ "00:03:03,45 -->
00:03:15,5\n"
+ "Baz.\n"))
+ (expect (point) :to-equal 33))))
+ (it "multiple subtitles."
+ (cl-loop for arg in (list -2 (list 16)) do
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 1)
+ (subed-srt--subtitle-insert arg)
+ (expect (buffer-string) :to-equal (concat "0\n"
+ "00:00:00,100 -->
00:00:30,450\n"
+ "\n\n"
+ "0\n"
+ "00:00:30,550 -->
00:01:00,900\n"
+ "\n\n"
+ "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\n"
+ "3\n"
+ "00:03:03,45 -->
00:03:15,5\n"
+ "Baz.\n"))
+ (expect (point) :to-equal 33))))
+ )
+ (describe "after the last subtitle"
+ (it "a single subtitle."
+ (cl-loop for arg in (list nil 1) do
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 3)
+ (subed-srt--subtitle-insert arg)
+ (expect (buffer-string) :to-equal (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\n"
+ "3\n"
+ "00:03:03,45 -->
00:03:15,5\n"
+ "Baz.\n\n"
+ "0\n"
+ "00:03:15,600 -->
00:03:16,400\n"
+ "\n"))
+ (expect (point) :to-equal 144))))
+ (it "multiple subtitles."
+ (cl-loop for arg in (list 2) do
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 3)
+ (subed-srt--subtitle-insert arg)
+ (expect (buffer-string) :to-equal (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\n"
+ "3\n"
+ "00:03:03,45 -->
00:03:15,5\n"
+ "Baz.\n\n"
+ "0\n"
+ "00:03:15,600 -->
00:03:16,450\n"
+ "\n\n"
+ "0\n"
+ "00:03:16,550 -->
00:03:17,400\n"
+ "\n"))
+ (expect (point) :to-equal 144))))
+ )
+ )
+ (it "schedules ID regeneration."
+ (with-temp-buffer
+ (subed-srt--subtitle-insert)
+ (expect #'subed-srt--regenerate-ids-soon :to-have-been-called-times 1)
+ (expect #'subed-srt--regenerate-ids :not :to-have-been-called)))
+ )
(describe "Validating"
- (it "works in empty buffer."
- (with-temp-buffer
- (expect (subed-srt--validate) :to-be nil)))
- (it "reports invalid IDs."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-id 1)
- (insert "x")
- (expect (subed-srt--validate) :to-throw
- 'error '("Found invalid subtitle ID: \"x1\""))
- (expect (point) :to-equal 1)))
- (it "reports invalid start time."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-time-start 1)
- (forward-char 5)
- (delete-char 1)
- (expect (subed-srt--validate) :to-throw
- 'error '("Found invalid start time: \"00:0101,000 -->
00:01:05,123\""))
- (expect (point) :to-equal 3)))
- (it "reports invalid stop time."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-time-stop 1)
- (forward-char 10)
- (insert "3")
- (expect (subed-srt--validate) :to-throw
- 'error '("Found invalid stop time: \"00:01:01,000 -->
00:01:05,1323\""))
- (expect (point) :to-equal 20)))
- (it "reports invalid time separator."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-time-stop 1)
- (delete-char -1)
- (expect (subed-srt--validate) :to-throw
- 'error '("Found invalid separator between start and
stop time: \"00:01:01,000 -->00:01:05,123\""))
- (expect (point) :to-equal 15)))
- (it "does not report error when last subtitle text is empty."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 3)
- (kill-whole-line)
- (forward-char -2)
- (subed-srt--validate)
- (expect (point) :to-equal 104)))
- (it "preserves point if there is no error."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 2)
- (forward-char 2)
- (subed-srt--validate)
- (expect (point) :to-equal 73)))
- )
+ (it "works in empty buffer."
+ (with-temp-buffer
+ (expect (subed-srt--validate) :to-be nil)))
+ (it "reports invalid IDs."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-id 1)
+ (insert "x")
+ (expect (subed-srt--validate) :to-throw
+ 'error '("Found invalid subtitle ID: \"x1\""))
+ (expect (point) :to-equal 1)))
+ (it "reports invalid start time."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-time-start 1)
+ (forward-char 5)
+ (delete-char 1)
+ (expect (subed-srt--validate) :to-throw
+ 'error '("Found invalid start time: \"00:0101,000 -->
00:01:05,123\""))
+ (expect (point) :to-equal 3)))
+ (it "reports invalid stop time."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-time-stop 1)
+ (forward-char 10)
+ (insert "3")
+ (expect (subed-srt--validate) :to-throw
+ 'error '("Found invalid stop time: \"00:01:01,000 -->
00:01:05,1323\""))
+ (expect (point) :to-equal 20)))
+ (it "reports invalid time separator."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-time-stop 1)
+ (delete-char -1)
+ (expect (subed-srt--validate) :to-throw
+ 'error '("Found invalid separator between start and stop time:
\"00:01:01,000 -->00:01:05,123\""))
+ (expect (point) :to-equal 15)))
+ (it "does not report error when last subtitle text is empty."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 3)
+ (kill-whole-line)
+ (forward-char -2)
+ (subed-srt--validate)
+ (expect (point) :to-equal 104)))
+ (it "preserves point if there is no error."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 2)
+ (forward-char 2)
+ (subed-srt--validate)
+ (expect (point) :to-equal 73)))
+ )
(describe "Sanitizing"
- (it "removes trailing tabs and spaces from all lines."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-min))
- (while (re-search-forward "\n" nil t)
- (replace-match " \n"))
- (expect (buffer-string) :not :to-equal mock-srt-data)
- (subed-srt--sanitize)
- (expect (buffer-string) :to-equal mock-srt-data))
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-min))
- (while (re-search-forward "\n" nil t)
- (replace-match "\t\n"))
- (expect (buffer-string) :not :to-equal mock-srt-data)
- (subed-srt--sanitize)
- (expect (buffer-string) :to-equal mock-srt-data)))
- (it "removes leading tabs and spaces from all lines."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-min))
- (while (re-search-forward "\n" nil t)
- (replace-match "\n "))
- (expect (buffer-string) :not :to-equal mock-srt-data)
- (subed-srt--sanitize)
- (expect (buffer-string) :to-equal mock-srt-data))
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-min))
- (while (re-search-forward "\n" nil t)
- (replace-match "\n\t"))
- (expect (buffer-string) :not :to-equal mock-srt-data)
- (subed-srt--sanitize)
- (expect (buffer-string) :to-equal mock-srt-data)))
- (it "removes excessive empty lines between subtitles."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-min))
- (while (re-search-forward "\n\n" nil t)
- (replace-match "\n \n \t \t\t \n\n \t\n"))
- (expect (buffer-string) :not :to-equal mock-srt-data)
- (subed-srt--sanitize)
- (expect (buffer-string) :to-equal mock-srt-data)))
- (it "ensures double newline between subtitles if text of previous
subtitle is empty."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 1)
- (kill-whole-line)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:01:01,000 -->
00:01:05,123\n"
- "\n"
- "2\n"
- "00:02:02,234 -->
00:02:10,345\n"
- "Bar.\n\n"
- "3\n"
- "00:03:03,45 -->
00:03:15,5\n"
- "Baz.\n"))
- (subed-srt--sanitize)
- (expect (buffer-string) :to-equal (concat "1\n"
- "00:01:01,000 -->
00:01:05,123\n"
- "\n\n"
- "2\n"
- "00:02:02,234 -->
00:02:10,345\n"
- "Bar.\n\n"
- "3\n"
- "00:03:03,45 -->
00:03:15,5\n"
- "Baz.\n"))))
- (it "removes empty lines from beginning of buffer."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-min))
- (insert " \n\t\n")
- (expect (buffer-string) :not :to-equal mock-srt-data)
- (subed-srt--sanitize)
- (expect (buffer-string) :to-equal mock-srt-data)))
- (it "removes empty lines from end of buffer."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-max))
- (insert " \n\t\n\n")
- (expect (buffer-string) :not :to-equal mock-srt-data)
- (subed-srt--sanitize)
- (expect (buffer-string) :to-equal mock-srt-data)))
- (it "ensures a single newline after the last subtitle."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-max))
- (while (eq (char-before (point-max)) ?\n)
- (delete-backward-char 1))
- (expect (buffer-string) :not :to-equal mock-srt-data)
- (subed-srt--sanitize)
- (expect (buffer-string) :to-equal mock-srt-data)))
- (it "ensures single newline after last subtitle if text is empty."
- (with-temp-buffer
- (insert mock-srt-data)
- (subed-srt--jump-to-subtitle-text 3)
- (kill-whole-line)
- (expect (buffer-string) :to-equal (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\n"
- "3\n"
- "00:03:03,45 -->
00:03:15,5\n"
- ""))
- (subed-srt--sanitize)
- (expect (buffer-string) :to-equal (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\n"
- "3\n"
- "00:03:03,45 -->
00:03:15,5\n"
- "\n"))))
- (it "ensures single space before and after time separators."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-min))
- (re-search-forward " --> ")
- (replace-match " --> ")
- (re-search-forward " --> ")
- (replace-match " --> ")
- (re-search-forward " --> ")
- (replace-match "-->")
- (expect (buffer-string) :not :to-equal mock-srt-data)
- (subed-srt--sanitize)
- (expect (buffer-string) :to-equal mock-srt-data)))
- )
+ (it "removes trailing tabs and spaces from all lines."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-min))
+ (while (re-search-forward "\n" nil t)
+ (replace-match " \n"))
+ (expect (buffer-string) :not :to-equal mock-srt-data)
+ (subed-srt--sanitize)
+ (expect (buffer-string) :to-equal mock-srt-data))
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-min))
+ (while (re-search-forward "\n" nil t)
+ (replace-match "\t\n"))
+ (expect (buffer-string) :not :to-equal mock-srt-data)
+ (subed-srt--sanitize)
+ (expect (buffer-string) :to-equal mock-srt-data)))
+ (it "removes leading tabs and spaces from all lines."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-min))
+ (while (re-search-forward "\n" nil t)
+ (replace-match "\n "))
+ (expect (buffer-string) :not :to-equal mock-srt-data)
+ (subed-srt--sanitize)
+ (expect (buffer-string) :to-equal mock-srt-data))
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-min))
+ (while (re-search-forward "\n" nil t)
+ (replace-match "\n\t"))
+ (expect (buffer-string) :not :to-equal mock-srt-data)
+ (subed-srt--sanitize)
+ (expect (buffer-string) :to-equal mock-srt-data)))
+ (it "removes excessive empty lines between subtitles."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-min))
+ (while (re-search-forward "\n\n" nil t)
+ (replace-match "\n \n \t \t\t \n\n \t\n"))
+ (expect (buffer-string) :not :to-equal mock-srt-data)
+ (subed-srt--sanitize)
+ (expect (buffer-string) :to-equal mock-srt-data)))
+ (it "ensures double newline between subtitles if text of previous subtitle
is empty."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 1)
+ (kill-whole-line)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:01:01,000 -->
00:01:05,123\n"
+ "\n"
+ "2\n"
+ "00:02:02,234 -->
00:02:10,345\n"
+ "Bar.\n\n"
+ "3\n"
+ "00:03:03,45 --> 00:03:15,5\n"
+ "Baz.\n"))
+ (subed-srt--sanitize)
+ (expect (buffer-string) :to-equal (concat "1\n"
+ "00:01:01,000 -->
00:01:05,123\n"
+ "\n\n"
+ "2\n"
+ "00:02:02,234 -->
00:02:10,345\n"
+ "Bar.\n\n"
+ "3\n"
+ "00:03:03,45 --> 00:03:15,5\n"
+ "Baz.\n"))))
+ (it "removes empty lines from beginning of buffer."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-min))
+ (insert " \n\t\n")
+ (expect (buffer-string) :not :to-equal mock-srt-data)
+ (subed-srt--sanitize)
+ (expect (buffer-string) :to-equal mock-srt-data)))
+ (it "removes empty lines from end of buffer."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-max))
+ (insert " \n\t\n\n")
+ (expect (buffer-string) :not :to-equal mock-srt-data)
+ (subed-srt--sanitize)
+ (expect (buffer-string) :to-equal mock-srt-data)))
+ (it "ensures a single newline after the last subtitle."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-max))
+ (while (eq (char-before (point-max)) ?\n)
+ (delete-backward-char 1))
+ (expect (buffer-string) :not :to-equal mock-srt-data)
+ (subed-srt--sanitize)
+ (expect (buffer-string) :to-equal mock-srt-data)))
+ (it "ensures single newline after last subtitle if text is empty."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (subed-srt--jump-to-subtitle-text 3)
+ (kill-whole-line)
+ (expect (buffer-string) :to-equal (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\n"
+ "3\n"
+ "00:03:03,45 --> 00:03:15,5\n"
+ ""))
+ (subed-srt--sanitize)
+ (expect (buffer-string) :to-equal (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\n"
+ "3\n"
+ "00:03:03,45 --> 00:03:15,5\n"
+ "\n"))))
+ (it "ensures single space before and after time separators."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-min))
+ (re-search-forward " --> ")
+ (replace-match " --> ")
+ (re-search-forward " --> ")
+ (replace-match " --> ")
+ (re-search-forward " --> ")
+ (replace-match "-->")
+ (expect (buffer-string) :not :to-equal mock-srt-data)
+ (subed-srt--sanitize)
+ (expect (buffer-string) :to-equal mock-srt-data)))
+ )
(describe "Renumbering"
- (it "ensures consecutive subtitle IDs."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-min))
- (while (looking-at "^[0-9]$")
- (replace-match "123"))
- (expect (buffer-string) :not :to-equal mock-srt-data)
- (subed-srt--regenerate-ids)
- (expect (buffer-string) :to-equal mock-srt-data))))
+ (it "ensures consecutive subtitle IDs."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-min))
+ (while (looking-at "^[0-9]$")
+ (replace-match "123"))
+ (expect (buffer-string) :not :to-equal mock-srt-data)
+ (subed-srt--regenerate-ids)
+ (expect (buffer-string) :to-equal mock-srt-data))))
(describe "Sorting"
- (it "orders subtitles by start time."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-min))
- (re-search-forward "01:01")
- (replace-match "12:01")
- (goto-char (point-min))
- (re-search-forward "02:02")
- (replace-match "10:02")
- (goto-char (point-min))
- (re-search-forward "03:03")
- (replace-match "11:03")
- (subed-srt--sort)
- (expect (buffer-string) :to-equal
- (concat
- "1\n"
- "00:10:02,234 --> 00:02:10,345\n"
- "Bar.\n"
- "\n"
- "2\n"
- "00:11:03,45 --> 00:03:15,5\n"
- "Baz.\n"
- "\n"
- "3\n"
- "00:12:01,000 --> 00:01:05,123\n"
- "Foo.\n"))))
- (describe "preserves point in the current subtitle"
- (it "when subtitle text is non-empty."
- (with-temp-buffer
- (insert mock-srt-data)
- (goto-char (point-min))
- (re-search-forward "01:01")
- (replace-match "12:01")
- (search-forward "\n")
- (expect (current-word) :to-equal "Foo")
- (subed-srt--sort)
- (expect (current-word) :to-equal "Foo")))
- (it "when subtitle text is empty."
- (with-temp-buffer
- (insert "1\n00:12:01,000 --> 00:01:05,123\n")
- (goto-char (point-max))
- (subed-srt--sort)
- (expect (point) :to-equal 33)))
- )
- )
+ (it "orders subtitles by start time."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-min))
+ (re-search-forward "01:01")
+ (replace-match "12:01")
+ (goto-char (point-min))
+ (re-search-forward "02:02")
+ (replace-match "10:02")
+ (goto-char (point-min))
+ (re-search-forward "03:03")
+ (replace-match "11:03")
+ (subed-srt--sort)
+ (expect (buffer-string) :to-equal
+ (concat
+ "1\n"
+ "00:10:02,234 --> 00:02:10,345\n"
+ "Bar.\n"
+ "\n"
+ "2\n"
+ "00:11:03,45 --> 00:03:15,5\n"
+ "Baz.\n"
+ "\n"
+ "3\n"
+ "00:12:01,000 --> 00:01:05,123\n"
+ "Foo.\n"))))
+ (describe "preserves point in the current subtitle"
+ (it "when subtitle text is non-empty."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (goto-char (point-min))
+ (re-search-forward "01:01")
+ (replace-match "12:01")
+ (search-forward "\n")
+ (expect (current-word) :to-equal "Foo")
+ (subed-srt--sort)
+ (expect (current-word) :to-equal "Foo")))
+ (it "when subtitle text is empty."
+ (with-temp-buffer
+ (insert "1\n00:12:01,000 --> 00:01:05,123\n")
+ (goto-char (point-max))
+ (subed-srt--sort)
+ (expect (point) :to-equal 33)))
+ )
+ )
diff --git a/tests/test-subed.el b/tests/test-subed.el
index bfdd711..40f6b51 100644
--- a/tests/test-subed.el
+++ b/tests/test-subed.el
@@ -4,660 +4,660 @@
(require 'subed-srt)
(describe "Iterating over subtitles"
- (it "without providing beginning and end."
- (with-temp-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-srt--subtitle-text 1) :to-equal "Hello.")
- (expect (subed-srt--subtitle-text 2) :to-equal "Bar.")
- (expect (subed-srt--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-srt--subtitle-text 1) :to-equal "Hello.")
- (expect (subed-srt--subtitle-text 2) :to-equal "HEllo.")
- (expect (subed-srt--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-srt--subtitle-text 1) :to-equal "Hello.")
- (expect (subed-srt--subtitle-text 2) :to-equal "HEllo.")
- (expect (subed-srt--subtitle-text 3) :to-equal "HELlo.")
- (expect (point) :to-equal 99)))
- (describe "providing only the beginning"
- (it "forwards."
- (with-temp-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-srt--subtitle-text 1) :to-equal
"Foo.")
- (expect (subed-srt--subtitle-text 2) :to-equal "A")
- (expect (subed-srt--subtitle-text 3) :to-equal "B")
- (expect (point) :to-equal 3)))
- (it "backwards."
- (with-temp-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-srt--subtitle-text 1) :to-equal
"Foo.")
- (expect (subed-srt--subtitle-text 2) :to-equal "B")
- (expect (subed-srt--subtitle-text 3) :to-equal "A")
- (expect (point) :to-equal 92)))
- )
- (describe "providing beginning and end,"
- (describe "excluding subtitles above"
- (it "forwards."
- (with-temp-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-srt--subtitle-text 1)
:to-equal "Foo.")
- (expect (subed-srt--subtitle-text 2)
:to-equal "A")
- (expect (subed-srt--subtitle-text 3)
:to-equal "B")
- (expect (point) :to-equal 20)))
- (it "backwards."
- (with-temp-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-srt--subtitle-text 1)
:to-equal "Foo.")
- (expect (subed-srt--subtitle-text 2)
:to-equal "B")
- (expect (subed-srt--subtitle-text 3)
:to-equal "A")
- (expect (point) :to-equal 76)))
- )
- (describe "excluding subtitles below"
- (it "forwards."
- (with-temp-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-srt--subtitle-text 1)
:to-equal "A")
- (expect (subed-srt--subtitle-text 2)
:to-equal "B")
- (expect (subed-srt--subtitle-text 3)
:to-equal "Baz.")
- (expect (point) :to-equal 100)))
- (it "backwards."
- (with-temp-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-srt--subtitle-text 1)
:to-equal "B")
- (expect (subed-srt--subtitle-text 2)
:to-equal "A")
- (expect (subed-srt--subtitle-text 3)
:to-equal "Baz.")
- (expect (point) :to-equal 55)))
- )
- )
- )
+ (it "without providing beginning and end."
+ (with-temp-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-srt--subtitle-text 1) :to-equal "Hello.")
+ (expect (subed-srt--subtitle-text 2) :to-equal "Bar.")
+ (expect (subed-srt--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-srt--subtitle-text 1) :to-equal "Hello.")
+ (expect (subed-srt--subtitle-text 2) :to-equal "HEllo.")
+ (expect (subed-srt--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-srt--subtitle-text 1) :to-equal "Hello.")
+ (expect (subed-srt--subtitle-text 2) :to-equal "HEllo.")
+ (expect (subed-srt--subtitle-text 3) :to-equal "HELlo.")
+ (expect (point) :to-equal 99)))
+ (describe "providing only the beginning"
+ (it "forwards."
+ (with-temp-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-srt--subtitle-text 1) :to-equal "Foo.")
+ (expect (subed-srt--subtitle-text 2) :to-equal "A")
+ (expect (subed-srt--subtitle-text 3) :to-equal "B")
+ (expect (point) :to-equal 3)))
+ (it "backwards."
+ (with-temp-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-srt--subtitle-text 1) :to-equal "Foo.")
+ (expect (subed-srt--subtitle-text 2) :to-equal "B")
+ (expect (subed-srt--subtitle-text 3) :to-equal "A")
+ (expect (point) :to-equal 92)))
+ )
+ (describe "providing beginning and end,"
+ (describe "excluding subtitles above"
+ (it "forwards."
+ (with-temp-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-srt--subtitle-text 1) :to-equal "Foo.")
+ (expect (subed-srt--subtitle-text 2) :to-equal "A")
+ (expect (subed-srt--subtitle-text 3) :to-equal "B")
+ (expect (point) :to-equal 20)))
+ (it "backwards."
+ (with-temp-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-srt--subtitle-text 1) :to-equal "Foo.")
+ (expect (subed-srt--subtitle-text 2) :to-equal "B")
+ (expect (subed-srt--subtitle-text 3) :to-equal "A")
+ (expect (point) :to-equal 76)))
+ )
+ (describe "excluding subtitles below"
+ (it "forwards."
+ (with-temp-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-srt--subtitle-text 1) :to-equal "A")
+ (expect (subed-srt--subtitle-text 2) :to-equal "B")
+ (expect (subed-srt--subtitle-text 3) :to-equal "Baz.")
+ (expect (point) :to-equal 100)))
+ (it "backwards."
+ (with-temp-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-srt--subtitle-text 1) :to-equal "B")
+ (expect (subed-srt--subtitle-text 2) :to-equal "A")
+ (expect (subed-srt--subtitle-text 3) :to-equal "Baz.")
+ (expect (point) :to-equal 55)))
+ )
+ )
+ )
(describe "Moving"
- (it "adjusts start and stop time by the same amount."
- (with-temp-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"
- "3\n"
- "00:00:02,000 --> 00:00:03,000\n"
- "Bar.\n"))
- (let ((orig-point (subed-jump-to-subtitle-id 2)))
- (subed-move-subtitle-forward 100)
- (expect (subed-subtitle-msecs-start) :to-equal 2100)
- (expect (subed-subtitle-msecs-stop) :to-equal 3100)
- (subed-move-subtitle-backward 200)
- (expect (subed-subtitle-msecs-start) :to-equal 1900)
- (expect (subed-subtitle-msecs-stop) :to-equal 2900)
- (expect (point) :to-equal orig-point))))
- (it "adjusts start and stop time by the same amount when bumping
into next subtitle."
- (with-temp-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-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-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-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-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-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))))
- (describe "adjusts subtitles in the active region,"
- (it "excluding the first subtitle."
- (with-temp-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"))
- (spy-on 'use-region-p :and-return-value 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-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"))
- (spy-on 'use-region-p :and-return-value 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-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"))
- (spy-on 'use-region-p :and-return-value 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-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"))
- (spy-on 'use-region-p :and-return-value 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-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"))
- (spy-on 'use-region-p :and-return-value 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-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"))
- (spy-on 'use-region-p :and-return-value 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-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"))
- (spy-on 'use-region-p :and-return-value 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-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"))
- (spy-on 'use-region-p :and-return-value 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-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"))
- (spy-on 'use-region-p :and-return-value 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-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"))
- (spy-on 'use-region-p :and-return-value 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-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"))
- (spy-on 'use-region-p :and-return-value 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-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"))
- (spy-on 'use-region-p :and-return-value 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-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-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-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-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-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)))
- (it "seeks player to first subtitle in active region."
- (with-temp-buffer
- (insert mock-srt-data)
- (let ((beg 15)
- (end (point-max)))
- (spy-on 'use-region-p :and-return-value 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))))
- )
+ (it "adjusts start and stop time by the same amount."
+ (with-temp-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"
+ "3\n"
+ "00:00:02,000 --> 00:00:03,000\n"
+ "Bar.\n"))
+ (let ((orig-point (subed-jump-to-subtitle-id 2)))
+ (subed-move-subtitle-forward 100)
+ (expect (subed-subtitle-msecs-start) :to-equal 2100)
+ (expect (subed-subtitle-msecs-stop) :to-equal 3100)
+ (subed-move-subtitle-backward 200)
+ (expect (subed-subtitle-msecs-start) :to-equal 1900)
+ (expect (subed-subtitle-msecs-stop) :to-equal 2900)
+ (expect (point) :to-equal orig-point))))
+ (it "adjusts start and stop time by the same amount when bumping into next
subtitle."
+ (with-temp-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-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-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-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-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-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))))
+ (describe "adjusts subtitles in the active region,"
+ (it "excluding the first subtitle."
+ (with-temp-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"))
+ (spy-on 'use-region-p :and-return-value 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-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"))
+ (spy-on 'use-region-p :and-return-value 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-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"))
+ (spy-on 'use-region-p :and-return-value 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-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"))
+ (spy-on 'use-region-p :and-return-value 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-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"))
+ (spy-on 'use-region-p :and-return-value 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-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"))
+ (spy-on 'use-region-p :and-return-value 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-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"))
+ (spy-on 'use-region-p :and-return-value 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-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"))
+ (spy-on 'use-region-p :and-return-value 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-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"))
+ (spy-on 'use-region-p :and-return-value 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-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"))
+ (spy-on 'use-region-p :and-return-value 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-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"))
+ (spy-on 'use-region-p :and-return-value 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-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"))
+ (spy-on 'use-region-p :and-return-value 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-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-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-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-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-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)))
+ (it "seeks player to first subtitle in active region."
+ (with-temp-buffer
+ (insert mock-srt-data)
+ (let ((beg 15)
+ (end (point-max)))
+ (spy-on 'use-region-p :and-return-value 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 "Syncing player to point"
- :var (subed-mpv-playback-position)
- (before-each
- (setq subed-mpv-playback-position 0)
- (spy-on 'subed-subtitle-msecs-start :and-return-value 5000)
- (spy-on 'subed-subtitle-msecs-stop :and-return-value 6500)
- (spy-on 'subed-mpv-jump))
- (it "does not seek player if point is on current subtitle."
- (setq subed-mpv-playback-position 5000)
- (subed--sync-player-to-point)
- (expect 'subed-mpv-jump :not :to-have-been-called)
- (setq subed-mpv-playback-position 6500)
- (subed--sync-player-to-point)
- (expect 'subed-mpv-jump :not :to-have-been-called))
- (it "seeks player if point is on future subtitle."
- (setq subed-mpv-playback-position 6501)
- (subed--sync-player-to-point)
- (expect 'subed-mpv-jump :to-have-been-called-with 5000))
- (it "seeks player if point is on past subtitle."
- (setq subed-mpv-playback-position 4999)
- (subed--sync-player-to-point)
- (expect 'subed-mpv-jump :to-have-been-called-with 5000))
- )
+ :var (subed-mpv-playback-position)
+ (before-each
+ (setq subed-mpv-playback-position 0)
+ (spy-on 'subed-subtitle-msecs-start :and-return-value 5000)
+ (spy-on 'subed-subtitle-msecs-stop :and-return-value 6500)
+ (spy-on 'subed-mpv-jump))
+ (it "does not seek player if point is on current subtitle."
+ (setq subed-mpv-playback-position 5000)
+ (subed--sync-player-to-point)
+ (expect 'subed-mpv-jump :not :to-have-been-called)
+ (setq subed-mpv-playback-position 6500)
+ (subed--sync-player-to-point)
+ (expect 'subed-mpv-jump :not :to-have-been-called))
+ (it "seeks player if point is on future subtitle."
+ (setq subed-mpv-playback-position 6501)
+ (subed--sync-player-to-point)
+ (expect 'subed-mpv-jump :to-have-been-called-with 5000))
+ (it "seeks player if point is on past subtitle."
+ (setq subed-mpv-playback-position 4999)
+ (subed--sync-player-to-point)
+ (expect 'subed-mpv-jump :to-have-been-called-with 5000))
+ )
(describe "Temporarily disabling point-to-player syncing"
- (before-each
- (spy-on 'subed-disable-sync-point-to-player))
- (describe "when point-to-player syncing is disabled"
- (before-each
- (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)
- (expect 'subed-disable-sync-point-to-player :not
:to-have-been-called))
- (it "does not schedule re-enabling of point-to-player
syncing."
- (subed-disable-sync-point-to-player-temporarily)
- (expect 'run-at-time :not :to-have-been-called)
- (expect subed--point-sync-delay-after-motion-timer
:to-be nil))
- )
- (describe "when point-to-player syncing is enabled"
- :var (subed--point-sync-delay-after-motion-timer)
- (before-each
- (spy-on 'subed-sync-point-to-player-p :and-return-value t)
- (spy-on 'run-at-time :and-return-value "mock timer")
- (spy-on 'cancel-timer)
- (setq subed--point-sync-delay-after-motion-timer nil))
- (it "disables point-to-player syncing."
- (subed-disable-sync-point-to-player-temporarily)
- (expect 'subed-disable-sync-point-to-player
:to-have-been-called))
- (it "schedules re-enabling of point-to-player syncing."
- (subed-disable-sync-point-to-player-temporarily)
- (expect 'run-at-time :to-have-been-called-with
- subed-point-sync-delay-after-motion nil
- '(lambda ()
- (setq
subed--point-sync-delay-after-motion-timer nil)
- (subed-enable-sync-point-to-player
:quiet))))
- (it "cancels previously scheduled re-enabling of
point-to-player syncing."
- (subed-disable-sync-point-to-player-temporarily)
- (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))
- )
- )
+ (before-each
+ (spy-on 'subed-disable-sync-point-to-player))
+ (describe "when point-to-player syncing is disabled"
+ (before-each
+ (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)
+ (expect 'subed-disable-sync-point-to-player :not :to-have-been-called))
+ (it "does not schedule re-enabling of point-to-player syncing."
+ (subed-disable-sync-point-to-player-temporarily)
+ (expect 'run-at-time :not :to-have-been-called)
+ (expect subed--point-sync-delay-after-motion-timer :to-be nil))
+ )
+ (describe "when point-to-player syncing is enabled"
+ :var (subed--point-sync-delay-after-motion-timer)
+ (before-each
+ (spy-on 'subed-sync-point-to-player-p :and-return-value t)
+ (spy-on 'run-at-time :and-return-value "mock timer")
+ (spy-on 'cancel-timer)
+ (setq subed--point-sync-delay-after-motion-timer nil))
+ (it "disables point-to-player syncing."
+ (subed-disable-sync-point-to-player-temporarily)
+ (expect 'subed-disable-sync-point-to-player :to-have-been-called))
+ (it "schedules re-enabling of point-to-player syncing."
+ (subed-disable-sync-point-to-player-temporarily)
+ (expect 'run-at-time :to-have-been-called-with
+ subed-point-sync-delay-after-motion nil
+ '(lambda ()
+ (setq subed--point-sync-delay-after-motion-timer nil)
+ (subed-enable-sync-point-to-player :quiet))))
+ (it "cancels previously scheduled re-enabling of point-to-player syncing."
+ (subed-disable-sync-point-to-player-temporarily)
+ (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))
+ )
+ )
- [nongnu] elpa/subed a6300b2 164/389: Don't regenerate IDs immediately after inserting subtitle(s), (continued)
- [nongnu] elpa/subed a6300b2 164/389: Don't regenerate IDs immediately after inserting subtitle(s), ELPA Syncer, 2021/12/03
- [nongnu] elpa/subed 800b7aa 166/389: Move timer variables from subed-config.el to where they are used, ELPA Syncer, 2021/12/03
- [nongnu] elpa/subed 3792b4b 178/389: subed-move-subtitle: Adjust docstring, ELPA Syncer, 2021/12/03
- [nongnu] elpa/subed 0e6ba37 180/389: Add option to ignore subtitle spacing when adjusting start/stop time, ELPA Syncer, 2021/12/03
- [nongnu] elpa/subed a7fa089 202/389: Remove unused variable err when parsing JSON response, ELPA Syncer, 2021/12/03
- [nongnu] elpa/subed 41fa03d 195/389: Use temporary-file-directory for mpv socket, ELPA Syncer, 2021/12/03
- [nongnu] elpa/subed c326079 185/389: subed-guess-video-file: Handle language name in subtitle file name, ELPA Syncer, 2021/12/03
- [nongnu] elpa/subed 300341a 186/389: subed-guess-video-file: Elaborate docstring, ELPA Syncer, 2021/12/03
- [nongnu] elpa/subed ab651e8 217/389: Rename subed-srt--max-subtitle-id to subed-srt--subtitle-id-max, ELPA Syncer, 2021/12/03
- [nongnu] elpa/subed 909cffd 216/389: Use generic function subed-subtitle-text in test-subed.el, ELPA Syncer, 2021/12/03
- [nongnu] elpa/subed 1654a08 207/389: Properly indent tests,
ELPA Syncer <=
- [nongnu] elpa/subed 3bab6b7 196/389: Use subed-mpv-socket-dir for subed-mpv--socket, ELPA Syncer, 2021/12/03
- [nongnu] elpa/subed 08e9762 188/389: Add option to ignore negative duration when adjusting start/stop time, ELPA Syncer, 2021/12/03
- [nongnu] elpa/subed 06aa155 187/389: Remove debugging messages from tests, ELPA Syncer, 2021/12/03
- [nongnu] elpa/subed 8bebab8 199/389: Report error when mpv socket file already exists, ELPA Syncer, 2021/12/03
- [nongnu] elpa/subed fbadab7 198/389: Add function subed--buffer-file-name, ELPA Syncer, 2021/12/03
- [nongnu] elpa/subed cd972bd 191/389: (not ...) instead of (eq ... nil), ELPA Syncer, 2021/12/03
- [nongnu] elpa/subed 1821ccd 190/389: (not ...) instead of (eq ... nil), ELPA Syncer, 2021/12/03
- [nongnu] elpa/subed 37545d9 201/389: Call subed-mpv-kill when Emacs exits, ELPA Syncer, 2021/12/03
- [nongnu] elpa/subed fafff02 221/389: subed-srt--jump-to-subtitle-id: Remove useless progn, ELPA Syncer, 2021/12/03
- [nongnu] elpa/subed dbc8394 222/389: Prevent extra goto-char when jumping to specific subtitle ID, ELPA Syncer, 2021/12/03