Come per ottenere effetti codice di Emacs pieghevole?

StackOverflow https://stackoverflow.com/questions/1085170

  •  23-08-2019
  •  | 
  •  

Domanda

Che cosa è il modo migliore per ottenere qualcosa di simile raggruppamento del codice, o il tipo di bicicletta che org-mode utilizza. Quale sarebbe la migliore soluzione in elisp per creare questo tipo di comportamento?

EDIT: Mi dispiace di non essere stato chiaro. Voglio programmare qualcosa in elisp che fa le cose molto simili a raggruppamento del codice, o in realtà la maggior parte come org-mode con la gerarchia che può essere espansa. Mi chiedo il modo migliore per raggiungere questo effetto. Credo di aver sentito le sovrapposizioni di Emacs sono una buona soluzione, ma non so.

Per quanto piegatura uso appena comando incorporato set-selettivo-display

EDIT NUMERO 2:

Grazie per le risposte, ma credo che sto chiedendo la domanda sbagliata quindi vorrei provare a essere più chiaro su quello che sto cercando di fare. Vorrei creare la seguente

Quando si mette il punto su una funzione e chiama questa funzione elisp metterà la definizione di funzione da dovunque sia (sto pensando solo usando find-tag per questo) e aprirlo nel buffer corrente. L'idea è che se si deve passare a un buffer diverso di leggere la definizione di una funzione mi sento come il suo un cambio di contesto a un altro file. Così desidero a comportarsi come codice piegare solo tira in codice esterno dal buffer. Questo presenta alcuni problemi in quanto non può acutally incollare il codice nel buffer o se qualcuno lo salva salverà il tirato in codice. Quindi mi chiedo se c'è un modo di creare uno spazio all'interno di un buffer che non sia anche parte del buffer. Credo che abbia un senso.

È stato utile?

Soluzione

pieghevole è generalmente inutile con emacs, in quanto dispone di strumenti che implementano esplicitamente le azioni che si fanno manualmente quando si piega il codice.

La maggior parte delle persone hanno un buon successo con semplici ricerche incrementali. Vedere "pippo" di cui parla da qualche parte? Tipo C-s foo, trovare la definizione, premere invio, la lesse, quindi premere C-x C-x per tornare a dove eravate. Semplice e molto utile.

La maggior parte di supporto modalità imenu . M-x imenu vi permetterà di passare a una definizione di funzione (etc.) in base al nome. È inoltre possibile associare ad un clic del mouse per ottenere un menu di funzioni (o aggiungerlo alla barra dei menu, vedere la pagina Info per maggiori dettagli). Esso fornisce i dati per il quale funzione-mode, che vi permetterà di vedere quale funzione siete attualmente all'interno della modeline. (Perché le funzioni così a lungo, però?)

C'è anche speedbar , che visualizza le informazioni imenu (e altre cose) graficamente.

Se si vuole avere una panoramica del file, provare Mx occur "Data un'espressione regolare, si creerà un nuovo buffer con ogni partita nel buffer corrente. È possibile cercare" ( defun" per ottenere una panoramica delle funzioni del file corrente implementa. Cliccando sul risultato si sposterà a quella posizione nel file.

Quindi, comunque, pensare a ciò che si vuole veramente raggiungere, e Emacs probabilmente implementa questo. Non combattere con strumenti imperfetti che ti fanno piegare e spiegare le cose costantemente.

Altri suggerimenti

Modalità nascondi-spettacolo (hs-minor-mode) con predefinito scorciatoia C-c @ C-M-h per attivare il pieghevole (hs-hide-all)

Un altro modo per la pelle del gatto:

  

Si dà il caso, non è necessario alcun pacchetto o configurazione aggiuntiva per   quello. Basta andare a qualsiasi file sorgente, tipo

M-1 C-x $ e la magia accade!

Come al solito, si tratta di magia bianca:. C-x $ porterà il vostro codice di schiena

  

Possiamo usare sistema di aiuto di Emacs’ per scoprire cosa sta succedendo: C-h k C-x $   noi che la combinazione di tasti di cui sopra sta chiamando dice    set-selettivo-display , una funzione che accetta un argomento numerico   (Il prefisso M-1 passa 1 come valore di tale argomento) e,   ovviamente, imposta il selettivo display variabile per il valore di   tale argomento.

emacs minori magia blog

Solo per completezza:. M-3 C-x $ sarebbe mostrare il codice più profondo nidificato e così via

FWIW ho fatto un piccolo aiutante oggi sulla base di smth. trovati qui modo che il codice alterna F5 pieghevole in base alla posizione attuale del cursore: 

(global-set-key (kbd "<f5>") '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 il modo minore contorno a piegare il mio codice python. Invece di dover posizionare {{{e}}} come nella modalità pieghevole, utilizza 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 si tratta con emacs. Ho poi Aggiungi 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 \C-c@ prefix, too hard to type. Note this overides some bindings.
  (setq outline-minor-mode-prefix "\C-t")
  ; turn on outline mode
  (outline-minor-mode t)
  ; initially hide all but the headers
  ;(hide-body)
  ; make paren matches visible
  (show-paren-mode 1)
)

È anche possibile ottenere il codice di piegatura utilizzando CEDET con seguente codice nel file di init: 

(global-semantic-folding-mode t)

Dopo la valutazione di questo codice, il piccolo triangolo apparirà nella zona fringle, quindi sarà in grado di piegare e dispiegare codice di utilizzarlo. Questo metodo è più preciso, in quanto utilizza informazioni sintattiche, estratta codice sorgente

hs-minor-mode funziona a meraviglia.

Funziona ancora più bello se abbinato con fold-DWIM (faccio quello che voglio dire). Poi c'è piegare-DWIM-org, che fornisce org-mode come associazioni di tasti per il codice pieghevole! Entrambi possono essere installati tramite la marmellata (e penso ELPA).

A quanto pare non esiste una soluzione perfetta, ma penso che il migliore è 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 pieghevole testo come in Vim. Essa ha le seguenti caratteristiche:

     
      
  • piegatura di regioni attive;
    •   
  • un buon feedback visivo: è ovvio che parte del testo è piegato;
    •   
  • la persistenza di default: quando si chiude il file tuoi pieghe non scompaiono;
    •   
  • persistenza scala bene, si può lavorare su centinaia di file con un sacco di pieghe, senza effetti negativi;
    •   
  • non si rompe indentazione o qualcosa;
    •   
  • pieghe può essere attivata da stato ripiegato spiegato ed indietro molto facilmente;
    •   
  • veloce la navigazione tra le pieghe esistenti;
    •   
  • è possibile utilizzare il mouse per svolgersi pieghe (buoni per i principianti e non solo per loro);
    •   
  • per gli appassionati di pacchetto Avy: è possibile utilizzare avy di piegare il testo con un numero minimo di colpi chiave
    • !   

Utilizzando l'ottimo use-package ho installare e attivare utilizzando questo frammento nel mio config: 

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

Emacs ha hs-minore-mode che fascilitates code di piegatura fra le espressioni bilanciate http://www.emacswiki.org/emacs/HideShow

Credo che il confronto del "progetto" di ripiegamento non è abbastanza buono, perché pieghevole è di cambiare l'aspetto, mantenendo intatto il contenuto del buffer (il testo). Il progetto comporterebbe mostrando il testo in più, mantenendo il contenuto del buffer intatto, AFAIU. Così. non è implementabile come composizione di testo inserimento e piegatura (quindi, il contenuto del buffer sarebbe cambiato).

Ma forse, è davvero possibile con lo stesso meccanismo di ripiegamento è fatto con - "sovrapposizioni" ... Si consideri il e proprietà di sovrapposizione ; forse, si potrebbe mettere le definizioni di funzioni in queste stringhe appartenenti ad una sovrapposizione di lunghezza zero in corrispondenza del punto. Guardate delineare-bandiera-regione per vedere come sovrapposizioni vengono utilizzati nella modalità contorno.

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

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

Con ispirazione da di einSelbst risposta : 

(advice-add 'set-selective-display
            :filter-args (lambda (args)
                           (if (or (car args) selective-display)
                               args
                             (list (1+ (current-column)))))
            '((name . set-selective-display-from-cursor-column)))

Voila, C-x $ divenne improvvisamente utile anche senza alcuna C-u né M-4 affari.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top