act on selection

[noncopyable]

first, thanks for this awesome mode.

i am probably missing some functionality, probably exists in #-thing-#
wouldn't it be great if meow had a binding that calls, "meow--act-on-selection" (like avy act)
that switches to default modeless emacs (insert), keeping selected region. then we are free to call any ###-region command. after that command executed, automagically switches back to normal mode.

maybe, also adding a act-on-selection-modemap where we could do things like:
act-modemap-leader s => surround
act-modemap-leader i => string-inflection
...

[DogLooksGood]

Hey, the surrounding stuff can actually be built into a package, or built with a paren handling package. I think it's better to use an existing one instead of adding features in Meow.

[noncopyable]

hello, that is precisely what i want. instead of replicating every other package (evil-### way), we could create a temporary environment/state (in which meow-selected-regions remain) where any package (or ##-region command) can do its thing, and we then switch back to the original meow state that the call was issued.

[DogLooksGood]

Well, for a keymap on selection, there's a package available: selected.el. It gives you a keymap when region is active. Of course it works, but very few concepts built for region only. Most features in Emacs works in a Do-What-You-Mean way, so they work with/without a region. (e.g. builtin upcase-dwim, package smartparens). In order to use them whenever possible, we don't bind them to a selection specific keymap.

If you really need a keymap for selection, you probably want to take a look at meow-define-state.

[hkjels]

I use puni, bool-flip and string-inflection with a few custom functions. Works well in my opinion.

(use-package bool-flip
  :defer t
  :commands (bool-flip-do-flip))

(use-package string-inflection
  :defer t
  :commands (string-inflection-all-cycle))

(defun string-transform-dwim ()
  "Toggle a boolean or cycle through transformations at point.
If the thing at point is a boolean, it will be toggled.
If not, cycle through possible string transformations."
  (interactive)
  (condition-case nil
      (bool-flip-do-flip)
    (user-error (string-inflection-all-cycle))))

  (defun puni-wrap (char)
    "Wrap region with the given CHAR."
    (cond ((or (eq char ?\)) (eq char ?\()) (puni-wrap-round))
	  ((or (eq char ?\]) (eq char ?\[)) (puni-wrap-square))
	  ((or (eq char ?\}) (eq char ?\{)) (puni-wrap-curly))
	  (t (save-excursion
               (goto-char (region-end))
               (insert char)
               (goto-char (region-beginning))
               (insert char)))))

  (defun meow-wrap-with-pair ()
    "Prompt user to enter a character to wrap the active region, then use `puni-wrap`."
    (interactive)
    (if (use-region-p)
	(let ((char (read-char "Enter the character to wrap with: ")))
          (puni-wrap char))
      (message "No active region")))

;; These are the bindings I chose
;;   '("T" . string-transform-dwim)
;;   '("S" . meow-wrap-with-pair)