How can I make occur display only first line of match?

Question

The context for this is that I was trying to write a function to help me write LaTeX, specifically I'd like to list all the future references, i.e. when you use a \ref{<something>} before \label{<something>}. I managed to write a regex that searches for this pattern, and my attempt is:

(defun get-forward-refs ()
  "List in an occur buffer all the future references of the current file."
  (interactive)
  (occur
   (rx (regex "\\ref{") (group (+ not-newline)) "}"
       (+ anything)
       (regex "\\label{") (backref 1) "}")
   ))

It works, but occur annoyingly displays ALL the match, which in this case could span several lines, so that I cannot quickly navigate the list (which was the purpose of this). The docstring of occur explicitly says "If a match spreads across multiple lines, all those lines are shown.". My question is: can I tweak this behavior, so that occur shows only the first line of the match? Thanks.

Answer 1

(add-hook 'occur-mode-hook
          (lambda ()
            (setq-local outline-regexp "^[[:blank:]]*[[:digit:]]+:"
                        outline-level (lambda ()
                                        1))
            (outline-minor-mode)

            ;; I believe you know how n/p works.
            (keymap-local-set "p"
                              (lambda (n)
                                (interactive "p")
                                (dotimes (_ n)
                                  (execute-kbd-macro (kbd "C-a"))
                                  (previous-error-no-select))))
            (keymap-local-set "n"
                              (lambda (n)
                                (interactive "p")
                                (dotimes (_ n)
                                  (execute-kbd-macro (kbd "C-e"))
                                  (next-error-no-select))))

            ;; To be honest, I don't know why 
            ;; `make-thread` is necessary here.
            (make-thread (lambda ()
                           (thread-yield)
                           (outline-hide-sublevels 1)))))

Answer 2

Without really looking into your problem, maybe this helps.

This is your regexp in Lisp, after removing the rx noise ;-):

"\\(?:\\ref{\\)\\(.+\\)}[^z-a]+\\(?:\\label{\\)\\1}"

[^z-a] matches newline chars. I guess that corresponds to your use of anything. If you don't want to match stuff over multiple lines, then you likely don't really want to match newline chars.