Re: wrap-search 3.3.5

[Emanuel Berg]

Stefan Monnier wrote:

> You might want to mention `isearch-wrap-pause` and explain
> the advantage of your package over what we get with (setq
> isearch-wrap-pause 'no).

It is not incremental so it never shows you "please help" when
you search for "please her" ... there is no flash update of
what you see until you are done. If you search for something
that exists, when you are done searching for it and not
before, that and nothing else is what is displayed. So it is
very civilized and not rushed, you don't get stressed
or distracted.

> If (like me) you prefer the "[...]" format, you might like
> to use `minibuffer-electric-default-mode` and (setq
> minibuffer-eldef-shorten-default t).

It looks good to me even after that, however I have that
configured another way

  (setq minibuffer-default-prompt-format " [%s]")

> As for the paperwork, you'd want to fill the form below and
> send it as instructed so the FSF can send you the relevant
> paperwork to sign.

OK, I think I did everything you said (not the byte compiler
patch LOL), here it is:

;;; wrap-search.el --- wrapped, non-incremental search -*- lexical-binding: t 
-*-
;;
;; Author: Emanuel Berg <incal@dataswamp.org>
;; Created: 2021-05-23
;; Keywords: matching
;; License: GPL3+
;; URL: https://dataswamp.org/~incal/emacs-init/wrap-search.el
;; Version: 4.3.7
;;
;;; Commentary:
;;
;; The `wrap-search' package offers non-incremental search.
;; It shows hitss - hits and only hits.
;;
;; `wrap-search' searches forward by default, but it wraps
;; and continues up and until the search start position if
;; necessary. This is so one doesn't have to wonder if the
;; target is north or south in the buffer.
;;
;; The philosophy is that `wrap-search' mostly shouldn't be
;; used for searching - that is possible as well, of course,
;; using the same command - rather, it is used to quickly
;; navigate a buffer.
;;
;; To use the package without keyboard shortcuts isn't
;; recommended. Instead, do for example
;;
;;   (global-set-key "\C-s" #'wrap-search)
;;   (global-set-key "\C-r" #'wrap-search-again)
;;
;;; Code:

(let ((prev-str "unspecified search string")
      (prev-case)
      (prev-rev)
      (prev-beg)
      (prev-end) )
  (defun wrap-search-again ()
    (interactive)
    (wrap-search prev-str prev-case prev-rev prev-beg prev-end) )
  (declare-function wrap-search-again nil)

  (defun show-prev-str ()
    (let*((short (truncate-string-to-width prev-str 10))
          (str   (format "%s%s" short
                                  (when (not (string= short prev-str))
                                    "...") )))
      str) )
  (declare-function show-prev-str nil)

  (defun wrap-search (str &optional case rev beg end)
    "Search for STR.

With CASE the search is case-sensitive.
With REV the search direction is reversed, i.e. north in the buffer from point.
BEG and END, or a region, delimits the search area. (default: whole buffer)

Interactively,
\\[universal-argument] sets CASE;
\\[universal-argument] \\[universal-argument] sets REV; and
\\[universal-argument] \\[universal-argument] \\[universal-argument] sets CASE 
and REV.

Do \\[wrap-search-again] to repeat, with `wrap-search-again'."
    (interactive
     `(,(read-string (format-prompt "search" (show-prev-str)))
       ,(member current-prefix-arg '( (4) (64)))
       ,(member current-prefix-arg '((16) (64)))
       ,@(if (use-region-p)
             (list (region-beginning) (region-end))
           (list (point-min) (point-max)) )))
    (if (string= "" str)
        (wrap-search-again)
      (setq prev-str  str)
      (setq prev-case case)
      (setq prev-rev  rev)
      (setq prev-beg  beg)
      (setq prev-end  end)
      (pcase-let*((case-fold-search (not case))
                  (pos (point))
                  (`(,search-f ,search-beg ,search-end)
                   (if rev
                       (list #'search-backward end beg)
                     (list #'search-forward beg end) )))
        (if (funcall search-f str search-end t)
            (message "hit: %s" (point))
          (goto-char search-beg)
          (if (funcall search-f str (+ pos (if rev 0 (length str))) t)
              (if (= pos (point))
                  (message "this is the one occurrence")
                (message "hit: %s (wrap)" (point)) )
            (goto-char pos)
            (message "no hit") ))) ))
  (declare-function wrap-search nil) )

(provide 'wrap-search)
;;; wrap-search.el ends here

-- 
underground experts united
https://dataswamp.org/~incal