Rename osc.el to ansi-osc.el (bug#58200)

* lisp/osc.el: Move from here...
* lisp/ansi-osc.el: ...to here.
* test/lisp/osc-tests.el: Move from here...
* test/lisp/ansi-osc-tests.el: ...to here.

etc/NEWS

@@ -2577,12 +2577,12 @@ Enabling this minor mode turns on hiding header material, like
 'elide-head' does; disabling it shows the header.  The commands
 'elide-head' and 'elide-head-show' are now obsolete.
 
-*** New package osc.el.
+*** New package ansi-osc.el.
 Support for OSC ("Operating System Command") escape sequences has been
 extracted from comint.el in order to provide interpretation of OSC
 sequences in compilation buffers.
 
-Adding the new function 'osc-compilation-filter' to
+Adding the new function 'ansi-osc-compilation-filter' to
 'compilation-filter-hook' enables interpretation of OSC escape
 sequences in compilation buffers.  By default, all sequences are
 filtered out.

lisp/ansi-osc.el

@@ -1,4 +1,4 @@
-;;; osc.el --- Support for OSC escape sequences      -*- lexical-binding: t; -*-
+;;; ansi-osc.el --- Support for OSC escape sequences      -*- lexical-binding: t; -*-
 
 ;; Copyright (C) 2022  Free Software Foundation, Inc.
 
@@ -26,37 +26,37 @@
 ;; Handlers for OSC 2, 7 and 8 (for window title, current directory
 ;; and hyperlinks respectively) are provided.
 
-;; The function `osc-compilation-filter' can be added to
+;; The function `ansi-osc-compilation-filter' can be added to
 ;; `compilation-filter-hook' to collect OSC sequences in compilation
-;; buffers.  The variable `osc-for-compilation-buffer' tells what to
-;; do with collected sequences.
+;; buffers.  The variable `ansi-osc-for-compilation-buffer' tells what
+;; to do with collected sequences.
 
 ;;; Code:
 
-(defconst osc-control-seq-regexp
+(defconst ansi-osc-control-seq-regexp
   ;; See ECMA 48, section 8.3.89 "OSC - OPERATING SYSTEM COMMAND".
   "\e\\][\x08-\x0D]*[\x20-\x7E]*\\(\a\\|\e\\\\\\)"
   "Regexp matching an OSC control sequence.")
 
-(defun osc-filter-region (begin end)
+(defun ansi-osc-filter-region (begin end)
   "Filter out all OSC control sequences from region between BEGIN and END."
   (save-excursion
     (goto-char begin)
     ;; Delete escape sequences.
-    (while (re-search-forward osc-control-seq-regexp end t)
+    (while (re-search-forward ansi-osc-control-seq-regexp end t)
       (delete-region (match-beginning 0) (match-end 0)))))
 
-(defvar-local osc-handlers '(("2" . osc-window-title-handler)
-                             ("7" . osc-directory-tracker)
-                             ("8" . osc-hyperlink-handler))
+(defvar-local ansi-osc-handlers '(("2" . ansi-osc-window-title-handler)
+                                  ("7" . ansi-osc-directory-tracker)
+                                  ("8" . ansi-osc-hyperlink-handler))
   "Alist of handlers for OSC escape sequences.
-See `osc-apply-on-region' for details.")
+See `ansi-osc-apply-on-region' for details.")
 
-(defvar-local osc--marker nil)
-;; The function `osc-apply-on-region' can set `osc--marker' to the start
-;; position of an escape sequence without termination.
+(defvar-local ansi-osc--marker nil)
+;; The function `ansi-osc-apply-on-region' can set `ansi-osc--marker'
+;; to the start position of an escape sequence without termination.
 
-(defun osc-apply-on-region (begin end)
+(defun ansi-osc-apply-on-region (begin end)
   "Interpret OSC escape sequences in region between BEGIN and END.
 This function searches for escape sequences of the forms
 
@@ -64,12 +64,13 @@ This function searches for escape sequences of the forms
     ESC ] command ; text ESC \\
 
 Every occurrence of such escape sequences is removed from the
-buffer.  Then, if `command' is a key in the alist that is the value
-of the local variable `osc-handlers', that key's value, which should
-be a function, is called with `command' and `text' as arguments, with
-point where the escape sequence was located."
+buffer.  Then, if `command' is a key in the alist that is the
+value of the local variable `ansi-osc-handlers', that key's
+value, which should be a function, is called with `command' and
+`text' as arguments, with point where the escape sequence was
+located."
   (save-excursion
-    (goto-char (or osc--marker begin))
+    (goto-char (or ansi-osc--marker begin))
     (when (eq (char-before) ?\e) (backward-char))
     (while (re-search-forward "\e]" end t)
       (let ((pos0 (match-beginning 0))
@@ -79,35 +80,35 @@ point where the escape sequence was located."
         (if (re-search-forward "\a\\|\e\\\\" end t)
             (let ((text (buffer-substring-no-properties
                          pos1 (match-beginning 0))))
-              (setq osc--marker nil)
+              (setq ansi-osc--marker nil)
               (delete-region pos0 (point))
-              (when-let ((fun (cdr (assoc-string code osc-handlers))))
+              (when-let ((fun (cdr (assoc-string code ansi-osc-handlers))))
                 (funcall fun code text)))
           (put-text-property pos0 end 'invisible t)
-          (setq osc--marker (copy-marker pos0)))))))
+          (setq ansi-osc--marker (copy-marker pos0)))))))
 
 ;; Window title handling (OSC 2)
 
-(defvar-local osc-window-title nil)
-(defun osc-window-title-handler (_ text)
-  "Set value of `osc-window-title' from an OSC 2 escape sequence.
-The variable `osc-window-title' can then be referenced in
+(defvar-local ansi-osc-window-title nil)
+(defun ansi-osc-window-title-handler (_ text)
+  "Set value of `ansi-osc-window-title' from an OSC 2 escape sequence.
+The variable `ansi-osc-window-title' can then be referenced in
 `frame-title-format' to dynamically set the frame title.
 
 This function is intended to be included as an element of the
-list that is the value of `osc-handlers'."
-  (setq osc-window-title text))
+list that is the value of `ansi-osc-handlers'."
+  (setq ansi-osc-window-title text))
 
 ;; Current directory tracking (OSC 7)
 
 (declare-function url-host "url/url-parse.el")
 (declare-function url-type "url/url-parse.el")
 (declare-function url-filename "url/url-parse.el")
-(defun osc-directory-tracker (_ text)
+(defun ansi-osc-directory-tracker (_ text)
   "Update `default-directory' from OSC 7 escape sequences.
 
 This function is intended to be included as an element of the
-the list that is the value of `osc-handlers'.  You should arrange
+the list that is the value of `ansi-osc-handlers'.  You should arrange
 for your shell to print the appropriate escape sequence at each prompt,
 such as with the following command:
 
@@ -124,7 +125,7 @@ and `shell-dirtrack-mode'."
 
 ;; Hyperlink handling (OSC 8)
 
-(defvar osc-hyperlink-map
+(defvar ansi-osc-hyperlink-map
   (let ((map (make-sparse-keymap)))
     (define-key map "\C-c\r" 'browse-url-button-open)
     (define-key map [mouse-2] 'browse-url-button-open)
@@ -132,29 +133,29 @@ and `shell-dirtrack-mode'."
     map)
   "Keymap used by OSC 8 hyperlink buttons.")
 
-(define-button-type 'osc-hyperlink
-  'keymap osc-hyperlink-map
+(define-button-type 'ansi-osc-hyperlink
+  'keymap ansi-osc-hyperlink-map
   'help-echo (lambda (_ buffer pos)
                (when-let ((url (get-text-property pos 'browse-url-data buffer)))
                  (format "mouse-2, C-c RET: Open %s" url))))
 
-(defvar-local osc-hyperlink--state nil)
+(defvar-local ansi-osc-hyperlink--state nil)
 
-(defun osc-hyperlink-handler (_ text)
+(defun ansi-osc-hyperlink-handler (_ text)
   "Create a hyperlink from an OSC 8 escape sequence.
 This function is intended to be included as an elemnt of the list
-that is the value of `osc-handlers'."
-  (when osc-hyperlink--state
-    (let ((start (car osc-hyperlink--state))
-          (url (cdr osc-hyperlink--state)))
+that is the value of `ansi-osc-handlers'."
+  (when ansi-osc-hyperlink--state
+    (let ((start (car ansi-osc-hyperlink--state))
+          (url (cdr ansi-osc-hyperlink--state)))
       (make-text-button start (point)
-                        'type 'osc-hyperlink
+                        'type 'ansi-osc-hyperlink
                         'browse-url-data url)))
-  (setq osc-hyperlink--state
+  (setq ansi-osc-hyperlink--state
         (and (string-match ";\\(.+\\)" text)
              (cons (point-marker) (match-string-no-properties 1 text)))))
 
-(defcustom osc-for-compilation-buffer 'filter
+(defcustom ansi-osc-for-compilation-buffer 'filter
   "What to do with OSC escape sequences in compilation output.
 
 If nil, do nothing.
@@ -162,9 +163,9 @@ If nil, do nothing.
 If the symbol `filter', then filter out all OSC control sequences.
 
 If any other non-nil value, then collect OSC control sequences
-and call the appropriate handlers as described in `osc-handlers'.
+and call the appropriate handlers as described in `ansi-osc-handlers'.
 
-In order for this to have any effect, `osc-compilation-filter'
+In order for this to have any effect, `ansi-osc-compilation-filter'
 must be in `compilation-filter-hook'."
   :type '(choice (const :tag "Do nothing" nil)
                  (const :tag "Filter out OSC" filter)
@@ -175,17 +176,17 @@ must be in `compilation-filter-hook'."
 (defvar compilation-filter-start)
 
 ;;;###autoload
-(defun osc-compilation-filter ()
+(defun ansi-osc-compilation-filter ()
   "Maybe collect OSC control sequences.
-This function depends on the variable `osc-for-compilation-buffer',
+This function depends on the variable `ansi-osc-for-compilation-buffer',
 and is meant to be used in `compilation-filter-hook'."
   (let ((inhibit-read-only t))
-    (pcase osc-for-compilation-buffer
+    (pcase ansi-osc-for-compilation-buffer
       ('nil nil)
       ('filter
-       (osc-filter-region compilation-filter-start (point)))
+       (ansi-osc-filter-region compilation-filter-start (point)))
       (_
-       (osc-apply-on-region compilation-filter-start (point))))))
+       (ansi-osc-apply-on-region compilation-filter-start (point))))))
 
-(provide 'osc)
-;;; osc.el ends here
+(provide 'ansi-osc)
+;;; ansi-osc.el ends here

lisp/comint.el

@@ -103,7 +103,7 @@
 
 (require 'ring)
 (require 'ansi-color)
-(require 'osc)
+(require 'ansi-osc)
 (require 'regexp-opt)                   ;For regexp-opt-charset.
 (eval-when-compile (require 'subr-x))
 
@@ -3918,11 +3918,11 @@ REGEXP-GROUP is the regular expression group in REGEXP to use."
 ;; sequences.
 
 ;; Aliases defined for reverse compatibility
-(defvaralias 'comint-osc-handlers 'osc-handlers)
-(defalias 'comint-osc-directory-tracker 'osc-directory-tracker)
-(defalias 'comint-osc-hyperlink-handler 'osc-hyperlink-handler)
-(defalias 'comint-osc-hyperlink 'osc-hyperlink)
-(defvaralias 'comint-osc-hyperlink-map 'osc-hyperlink-map)
+(defvaralias 'comint-osc-handlers 'ansi-osc-handlers)
+(defalias 'comint-osc-directory-tracker 'ansi-osc-directory-tracker)
+(defalias 'comint-osc-hyperlink-handler 'ansi-osc-hyperlink-handler)
+(defalias 'comint-osc-hyperlink 'ansi-osc-hyperlink)
+(defvaralias 'comint-osc-hyperlink-map 'ansi-osc-hyperlink-map)
 
 (defun comint-osc-process-output (_)
   "Interpret OSC escape sequences in comint output.
@@ -3941,7 +3941,7 @@ arguments, with point where the escape sequence was located."
   (let ((start (1- comint-last-output-start))
         ;; Start one char before last output to catch a possibly stray ESC
         (bound (process-mark (get-buffer-process (current-buffer)))))
-    (osc-apply-on-region start bound)))
+    (ansi-osc-apply-on-region start bound)))
 
 
 ;;; Input fontification and indentation through an indirect buffer

test/lisp/ansi-osc-tests.el

@@ -26,10 +26,10 @@
 
 ;;; Code:
 
-(require 'osc)
+(require 'ansi-osc)
 (require 'ert)
 
-(defvar osc-tests--strings
+(defvar ansi-osc-tests--strings
   `(
     ("Hello World" "Hello World")
 
@@ -48,10 +48,10 @@
 ;; Don't output those strings to stdout since they may have
 ;; side-effects on the environment
 
-(ert-deftest osc-tests-apply-region-no-handlers ()
-  (let ((osc-handlers nil))
-    (pcase-dolist (`(,input ,text) osc-tests--strings)
+(ert-deftest ansi-osc-tests-apply-region-no-handlers ()
+  (let ((ansi-osc-handlers nil))
+    (pcase-dolist (`(,input ,text) ansi-osc-tests--strings)
       (with-temp-buffer
         (insert input)
-        (osc-apply-on-region (point-min) (point-max))
+        (ansi-osc-apply-on-region (point-min) (point-max))
         (should (equal (buffer-string) text))))))