Come ottenere effetti di piegatura del codice in Emacs?

Qual è il modo migliore per ottenere qualcosa come la piegatura del codice o il tipo di ciclo che utilizza la modalità org. Quale sarebbe la migliore soluzione in elisp per creare questo tipo di comportamento?

EDIT: Mi dispiace non essere stato chiaro. Voglio programmare qualcosa in elisp che faccia cose molto simili al code folding, o che in realtà assomigli molto alla modalità org con la gerarchia che può essere espansa. Mi sto chiedendo il modo migliore per ottenere questo effetto. Penso di aver sentito che le sovrapposizioni di emacs sono una buona soluzione, ma non lo so.

Per quanto riguarda la piegatura, utilizzo solo il set-selective-display integrato

MODIFICA NUMERO 2:

Grazie per le risposte, ma penso di porre la domanda sbagliata, quindi permettetemi di essere più chiaro su ciò che sto cercando di fare. Mi piacerebbe creare il seguente

Quando metti il ​​tuo punto su una funzione e chiami questa funzione elisp, metterà la definizione della funzione da dovunque sia (sto pensando di usare solo find-tag per questo) e la spiegherò nel buffer corrente. L’idea è se devi passare a un buffer diverso per leggere la definizione della funzione che mi sembra come se fosse un interruttore di contesto in un altro file. Quindi mi piacerebbe che si comportasse come il codice che si piega solo nel codice esterno dal buffer. Questo presenta alcuni problemi in quanto non può incollare acusticamente il codice nel buffer o se qualcuno lo salva salverà il codice inserito. Quindi mi chiedo se c’è un modo per creare un’area all’interno di un buffer che non fa parte del buffer. Penso che abbia senso.

La piegatura non è generalmente necessaria con emacs, in quanto dispone di strumenti che implementano esplicitamente le azioni che le persone eseguono manualmente quando piegano il codice.

La maggior parte delle persone ha un buon successo con semplici ricerche incrementali. Vedi “foo” menzionato da qualche parte? Digita Cs foo , trova la definizione, premi invio, leggilo, quindi premi Cx Cx per tornare al punto in cui ti trovavi. Semplice e molto utile.

La maggior parte delle modalità supporta imenu . Mx imenu ti permetterà di passare a una definizione di funzione (ecc.) Per nome. Puoi anche associarlo a un clic del mouse per ottenere un menu di funzioni (o aggiungerlo alla barra dei menu, vedere la pagina Informazioni per maggiori dettagli). Fornisce i dati per la quale-funzione-mode, che ti permetterà di vedere quale funzione sei attualmente all’interno della modeline. (Perché le tue funzioni sono così lunghe, però?)

C’è anche la barra di velocità , che mostra le informazioni dell’imenu (e altre cose) graficamente.

Se vuoi ottenere una panoramica del tuo file, prova Mx . “Data una regex, creerà un nuovo buffer con ogni corrispondenza nel buffer corrente. Puoi cercare” (defun “per ottenere una panoramica delle funzioni strumenti di file correnti. Cliccando sul risultato ti sposterai in quella posizione nel file.

Ad ogni modo, pensa a ciò che vuoi veramente ottenere, ed Emacs probabilmente lo implementa. Non combattere con strumenti imperfetti che ti fanno piegare e dispiegare le cose costantemente.

modalità hide-show (modalità hs-minor-mode ) con la Cc @ CMh di tasti predefinita Cc @ CMh per triggersre la piegatura ( hs-hide-all )

Un altro modo per scuoiare il gatto:

Come succede, non hai bisogno di alcun pacchetto o configurazione extra per questo. Basta andare su qualsiasi file sorgente, digitare

M-1 Cx $ e la magia accade!

Come al solito, è magia bianca: Cx $ riporterà il tuo codice.

Possiamo usare il sistema di aiuto di Emacs per scoprire cosa sta succedendo: Ch k Cx $ ci dice che la suddetta combinazione di tasti chiama set-selective-display , una funzione che accetta un argomento numerico (il prefisso M-1 passa 1 come valore di tale argomento) e, non sorprende, imposta la variabile selective-display sul valore di tale argomento.

dal blog di magie emacs minori

Solo per completezza: M-3 Cx $ mostrerebbe un codice annidato più profondo e così via.

FWIW Ho fatto un piccolo aiuto oggi basato su smth. trovato qui in modo che F5 alterna la piegatura del codice in base alla posizione corrente del cursore:

 (global-set-key (kbd "") 'set-selective-display-dlw) (defun set-selective-display-dlw (&optional level) "Fold text indented same of more than the cursor. If level is set, set the indent level to LEVEL. If 'selective-display' is already set to LEVEL, clicking F5 again will unset 'selective-display' by setting it to 0." (interactive "P") (if (eq selective-display (1+ (current-column))) (set-selective-display 0) (set-selective-display (or level (1+ (current-column)))))) 

Io uso la modalità di contorno minore per piegare il mio codice Python. Invece di dover inserire {{{e}}} come in modalità pieghevole, usa dove è definito il blocco.

http://www.gnu.org/software/emacs/manual/html_node/emacs/Outline-Mode.html http://www.emacswiki.org/emacs/OutlineMinorMode

Sono abbastanza sicuro che venga fornito con emacs. Quindi aggiungo questo al mio .emacs

 ;;======= Code folding ======= (add-hook 'python-mode-hook 'my-python-outline-hook) ; this gets called by outline to deteremine the level. Just use the length of the whitespace (defun py-outline-level () (let (buffer-invisibility-spec) (save-excursion (skip-chars-forward " ") (current-column)))) ; this get called after python mode is enabled (defun my-python-outline-hook () ; outline uses this regexp to find headers. I match lines with no indent and indented "class" ; and "def" lines. (setq outline-regexp "[^ \t]\\|[ \t]*\\(def\\|class\\) ") ; enable our level computation (setq outline-level 'py-outline-level) ; do not use their \[email protected] prefix, too hard to type. Note this overides some bindings. (setq outline-minor-mode-prefix "\Ct") ; turn on outline mode (outline-minor-mode t) ; initially hide all but the headers ;(hide-body) ; make paren matches visible (show-paren-mode 1) ) 

Puoi anche ottenere la piegatura del codice usando CEDET con il seguente codice nel file init:

 (global-semantic-folding-mode t) 

Dopo la valutazione di questo codice, il piccolo triangolo apparirà nell’area fringle, quindi potrai piegarlo e aprirlo usando il codice. Questo metodo è più preciso in quanto utilizza le informazioni sintattiche, estratte dal codice sorgente

hs-minor-mode funziona magnificamente.

Funziona ancora più bene se abbinato a fold-dwim (fai quello che voglio dire). Poi c’è fold-dwim-org, che fornisce org-mode come combinazioni di tasti per la piegatura del codice! Entrambi possono essere installati tramite marmellata (e credo che elpa).

Apparentemente non esiste una soluzione perfetta, ma penso che la migliore sia questa:

http://www.emacswiki.org/emacs/FoldingMode

vimish-fold è anche una soluzione piacevole e facile.

https://github.com/mrkkrp/vimish-fold .

Dalla homepage:

Questo è un pacchetto per eseguire la piegatura del testo come in Vim. Ha le seguenti caratteristiche:

  • piegatura di regioni attive;
  • buon riscontro visivo: è ovvio quale parte del testo è piegata;
  • persistenza di default: quando chiudi il file le tue pieghe non scompaiono;
  • la persistenza si adatta bene, puoi lavorare su centinaia di file con molte pieghe senza effetti collaterali;
  • non rompe indentazione o qualcosa;
  • le pieghe possono essere passate dallo stato piegato a quello aperto e indietro molto facilmente;
  • navigazione veloce tra le pieghe esistenti;
  • puoi usare il mouse per dispiegare le pieghe (buono per i principianti e non solo per loro);
  • per i fan del pacchetto avy: puoi usare avy per piegare il testo con un numero minimo di tratti chiave!

Utilizzando l’eccellente use-package lo installo e lo attivo utilizzando questo frammento nella mia configurazione:

 (use-package vimish-fold :ensure t :config (vimish-fold-global-mode t)) 

emacs viene fornito con hs-minor-mode che affascina il ripiegamento del codice tra le espressioni bilanciate http://www.emacswiki.org/emacs/HideShow

Credo che il tuo confronto tra il tuo “progetto” e la piegatura non sia abbastanza buono, perché piegare significa cambiare l’aspetto mantenendo intatto il contenuto del buffer (il testo). Il tuo progetto comporterebbe la visualizzazione di testo extra mantenendo intatto il contenuto del buffer, AFAIU. Così. non è implementabile come una composizione di inserimento e piegatura del testo (quindi, il contenuto del buffer potrebbe essere modificato).

Ma forse, è effettivamente ansible con lo stesso meccanismo con cui la piegatura viene eseguita con – “sovrapposizioni” … Considerate le proprietà di sovrapposizione “prima della stringa” e “dopo la stringa”; forse, potresti mettere le tue definizioni di funzione in queste stringhe che appartengono a una sovrapposizione di lunghezza zero al punto. Guarda la funzione outline-flag-region per vedere come vengono usati gli overlay nella modalità outline.

Se si utilizza hs-minor-mode , potrebbe essere una buona idea anche impostare una scorciatoia più comoda, ad esempio:

 (eval-after-load 'hideshow '(progn (global-set-key (kbd "C-+") 'hs-toggle-hiding)))