Prevent org source block face from bleeding out in fold

Question

The problem is that when there is one line in between folded headings with source blocks the text properties of the #end-src line bleeds out. You can see the lines bleeding on the right in the image.

Update Progress So Far

step 1

To do this I have taken two steps.

The first is to unfontify the end of the last line of a subtree when hiding it if that line is the end of a source block. That's the line responsible for the bleeding. This will ensure that the font face doesn't bleed out when a block is hidden with outline-hide-subtree.

(defun dwim-unfontify-last-line-of-subtree (&rest _)
  "Unfontify last line of subtree if it's a source block."
  (save-excursion
    (org-end-of-subtree)
    (beginning-of-line)
    (when (looking-at-p (rx "#+end_src"))
      (font-lock-unfontify-region
       (line-end-position) (1+ (line-end-position))))))

(advice-add #'outline-hide-subtree :after #'dwim-unfontify-last-line-of-subtree)

step 2

The second step is the hard one. I determined that outline-show-heading is the fundamental function for showing headings. This function checks if the heading being shown has

(defun dwim-fontify-last-line-of-block (&rest _)
  "Do what I mean: fontify last line of source block.
When the heading has a source block as the last item (in the subtree) do one of the
  following:
If the source block is now visible, fontify the end its last line.
If it's invisible, unfontify its last line."
  (let (font-lock-fn invisible-p heading-name)
    (save-excursion
      ;; Debugging
      ;; (save-match-data
      ;;   (beginning-of-line)
      ;;   (looking-at
      ;;    (rx bol (+ "*") "\s" (submatch (+ (not (any "\n"))))))
      ;;   (setq heading-name (match-string-np 1)))
      (org-end-of-subtree)
      (beginning-of-line)
      (when (looking-at-p (rx "#+end_src"))
        (setq invisible-p (outline-invisible-p (line-end-position)))
        (setq font-lock-fn
              (if invisible-p
                  #'font-lock-unfontify-region
                #'font-lock-fontify-region))
        ;; Debugging
        ;; (message "-%s-’s end_src is %svisible"
        ;;          heading-name
        ;;          (if invisible-p "in" ""))
        (funcall font-lock-fn
                 (line-end-position)
                 (1+ (line-end-position)))))))

(advice-add #'outline-show-heading :after #'dwim-fontify-last-line-of-block)

problem

This is extremely close to working. If you use outline-toggle-children to display the children of a subtree and every child is a subtree (in other words each is displayed as a folded headline), the last source block of every headline should be invisible. That's because all the headings are folded. But (outline-invisible-p (line-end-position)) says the last child of that subtree remains visible.

The picture below shows what I mean. You can see the last child of the Top level headings is bleeding out. And the last child of the level Completion heading is bleeding. This is what happens when I displayed them with outline-toggle-fold.

]

Answer 1

First attempt. Doesn't work, disregard. See below:

I just ran into the same issue and, inspired by @Aquaactress's attempt, added a simple advice to org-flag-region:

(defun org-flag-region-hide-last (from to flag spec)
  "Unfontify last char of hidden region when folding, fontify it
when showing.

This avoids the bleeding of `org-block-end-line' when block or
parent heading is folded."
  (unless (= (point-max) to)
      (save-excursion
        (if flag
            (font-lock-unfontify-region to (1+ to))
          (font-lock-fontify-region to (1+ to))))))

(advice-add 'org-flag-region :after #'org-flag-region-hide-last)

It seems to work well!

(Edit: no it doesn't. It doesn't work well with org-separator-lines and it would leave the last char unfontified in some situations.)

Second attempt. Seems to work:

The above code is still useful (after some adaptations) to deal with hiding the block itself. But, when cycling the outline, we need to hook into org-cycle-hook:

(defun org-fix-bleed-end-line-block (from to flag spec)
  "Toggle fontification of last char of block end lines when cycling.

This avoids the bleeding of `org-block-end-line' when block is
folded."
  (when (and (eq spec 'org-hide-block)
             (/= (point-max) to))
    (save-excursion
      (if flag
          (font-lock-unfontify-region to (1+ to))
        (font-lock-flush to (1+ to))))))

(advice-add 'org-flag-region :after #'org-fix-bleed-end-line-block)

(defun org-fix-bleed-end-line-cycle (state)
  "Toggle fontification of last char of block lines when cycling.

This avoids the bleeding of `org-block-end-line' when outline is
folded."
  (save-excursion
    (when org-fontify-whole-block-delimiter-line
      (let ((case-fold-search t)
            beg end)
        (cond ((memq state '(overview contents all))
               (setq beg (point-min)
                     end (point-max)))
              ((memq state '(children folded subtree))
               (setq beg (point)
                 end (org-end-of-subtree t t))))
        (when beg           ; should always be true, but haven't tested enough
          (goto-char beg)
          (while (search-forward "#+end" end t)
            (end-of-line)
            (unless (= (point) (point-max))
              (if (org-invisible-p (1- (point)))
                  (font-lock-unfontify-region (point) (1+ (point)))
                (font-lock-flush (point) (1+ (point)))))))))))

(add-hook 'org-cycle-hook #'org-fix-bleed-end-line-cycle)

If this doesn't work, try to remove the check for org-fontify-whole-block-delimiter-line. That is org-mode's own mechanism for dealing with whole line fontification; maybe some themes define their own methods for achieving whole line fontification, I don't know.

Last (?) issue

There is still ONE issue I couldn't resolve... When org-startup-folded is t or contents, the lines still bleed when the file first opens up. You can manually cycle the visibility and they'll behave again, but I could not figure out how to do that automatically at startup.

I tried creating a hook:

(defun org-fix-bleed-startup ()
  (when (memq org-startup-folded '(t content))
    (org-fix-bleed-end-line-cycle 'all)))

(add-hook 'org-mode-hook #'org-fix-bleed-startup)
;; also tried:
(remove-hook 'after-change-major-mode-hook #'org-fix-bleed-startup)

But for some reason it doesn't work. I guess some other functions run after org is loaded which also change the visibility of some parts of the buffer? I don't know.

Please test this and let me know if it works!

Answer 2

May not be the answer you were looking for, but the simplest way might be to change the org-block-end-line variable face to that of the default background, thus ensuring that there's nothing to leak in the first place. Also, end_src line generally seems useless in that all the code-block arguments belong in the begin_line, or better yet an entirely separate #+header:.