One key shortcut to jump two-ways between matching opening/closing tags in nxml mode?

Question

Context

Editing an arbitrary XML file in nxml-mode.

Need

Let's say I have a structure like this:

<a>
  <b>...</b>
</a>

Let's say the cursor is at the <a>. I'm looking for one shortcut that brings the cursor directly from <a> to </a>, and back if called again.

Search before you ask

This question requests one-way jump and gets an answer: C-M-n to jump forward, C-u -1 C-M-n to jump backwards -- Emacs, nxhtml how to highlight or jump to the closing html tag? - Stack Overflow.

But this is inconvenient because to jump back one has to:

1. position the cursor exactly at end of closing tag, and
2. use a long and convoluted key shortcut C-u -1 C-M-n.

There's room for more convenience: one shortcut to do both directions.

How to do that?

If this does not already exists, I'd like to it. I'm a seasoned developer in a number of languages and environments but not proficient enough in emacs-lisp to make my own solution. Still, it might be easy enough to do for an emacs-lisp wizard.

Technically, one function with this behavior would do the trick:

• when cursor is on an opening tag, jump forwards (call (nxml-forward-element 1))
• when cursor is on a closing tag, jump backwards (call (nxml-forward-element -1))
• bonus points if, when cursor is anywhere between < and > (not only just before < as nxml-forward-element requires), the function still works
• bonus points if, when cursor is anywhere inside text or whatever, then jump backwards to opening tag.

Answer 1

If you use evil-mode, you can install https://github.com/redguardtoo/evil-matchit and press %

If you prefer original Emacs,

(autoload 'sgml-skip-tag-backward "sgml-mode" nil t)
(autoload 'sgml-skip-tag-forward "sgml-mode" nil t)
(defun html-get-tag ()
  (let ((b (line-beginning-position))
        (e (line-end-position))
        (looping t)
        (html-tag-char (string-to-char "<"))
        (char (following-char))
        (p (point))
        (found_tag -1))

    (save-excursion
      ;; search backward
      (unless (= char html-tag-char)
        (while (and looping (<= b (point)) (not (= char 60)))
          (setq char (following-char))
          (setq p (point))
          (if (= p (point-min))
              ;; need get out of loop anyway
              (setq looping nil)
            (backward-char))))

      ;; search forward
      (if (not (= char html-tag-char))
          (save-excursion
            (while (and (>= e (point)) (not (= char 60)))
              (setq char (following-char))
              (setq p (point))
              (forward-char))))

      ;; is end tag?
      (when (and (= char html-tag-char) (< p e))
        (goto-char p)
        (forward-char)
        (if (= (following-char) 47)
            (progn
              ;; </
              (skip-chars-forward "^>")
              (forward-char)
              (setq p (point))
              (setq found_tag 1))
          (progn
            ;; < , looks fine
            (backward-char)
            (setq found_tag 0)))))
    found_tag))

(defun html-jump(&optional num)
  "Jump forward from html open tag"
  (interactive "P")
  (unless num (setq num 1))
  ;; web-mode-forward-sexp is assigned to forward-sexp-function
  ;; it's buggy in web-mode v11, here is the workaround
  (let ((backup-forward-sexp-function forward-sexp-function))
    (if (= (html-get-tag) 0)
        (sgml-skip-tag-forward num)
      (sgml-skip-tag-backward num))))

Usage: M-x html-jump, it works in any html related major mode (php-mode, xml-mode, web-mode, nxml-mode ....)

Answer 2

Try the following:

(defun nxml-jump-to-closing-tag ()
  (interactive)
  (forward-char 2)
  (if (search-backward "<" nil t)
      (nxml-forward-element)
    (message "No more elements")
    )
  )

(defun nxml-jump-to-openning-tag ()
  (interactive)
  (backward-char 2)
  (if (search-forward ">" nil t)
      (nxml-backward-element)
    (message "No more elements")
    )
  )

(define-key nxml-mode-map (kbd "<C-M-right>") 'nxml-jump-to-closing-tag)
(define-key nxml-mode-map (kbd "<C-M-left>")  'nxml-jump-to-openning-tag)

Press C-M-←. Press C-M-→ to get back.